Users and Permissions

/**
 * Notion user account information
 */
interface User {
  /** User identifier */
  id: ID;
  /** User record version */
  version: number;
  /** User email address */
  email: string;
  /** User's first name */
  given_name: string;
  /** User's last name */
  family_name: string;
  /** Profile photo URL */
  profile_photo: string;
  /** Desktop onboarding status */
  onboarding_completed: boolean;
  /** Mobile onboarding status */
  mobile_onboarding_completed: boolean;
}

/**
 * User permission roles
 */
type Role = 
  | 'editor'        // Full edit access
  | 'reader'        // Read-only access
  | 'none'          // No access
  | 'read_and_write'; // Read and write access

import { User, Role } from "notion-types";

// Create a user object
const user: User = {
  id: "user-123",
  version: 1,
  email: "john.doe@example.com",
  given_name: "John",
  family_name: "Doe",
  profile_photo: "https://example.com/avatar.jpg",
  onboarding_completed: true,
  mobile_onboarding_completed: false
};

// Helper functions for user management
function getFullName(user: User): string {
  return `${user.given_name} ${user.family_name}`;
}

function getDisplayName(user: User): string {
  const fullName = getFullName(user);
  return fullName.trim() || user.email;
}

function hasCompletedOnboarding(user: User): boolean {
  return user.onboarding_completed && user.mobile_onboarding_completed;
}

function canEdit(role: Role): boolean {
  return role === 'editor' || role === 'read_and_write';
}

function canRead(role: Role): boolean {
  return role !== 'none';
}

function getRoleDescription(role: Role): string {
  switch (role) {
    case 'editor':
      return 'Full edit access';
    case 'reader':
      return 'Read-only access';
    case 'read_and_write':
      return 'Read and write access';
    case 'none':
      return 'No access';
    default:
      return 'Unknown role';
  }
}

// User permissions checking
interface UserPermission {
  user: User;
  role: Role;
}

function checkPermissions(userPermission: UserPermission, action: 'read' | 'write' | 'edit'): boolean {
  const { role } = userPermission;
  
  switch (action) {
    case 'read':
      return canRead(role);
    case 'write':
      return role === 'editor' || role === 'read_and_write';
    case 'edit':
      return role === 'editor';
    default:
      return false;
  }
}

// Example user management
const users: User[] = [
  {
    id: "user-1",
    version: 1,
    email: "admin@company.com",
    given_name: "Admin",
    family_name: "User",
    profile_photo: "",
    onboarding_completed: true,
    mobile_onboarding_completed: true
  },
  {
    id: "user-2", 
    version: 1,
    email: "viewer@company.com",
    given_name: "View",
    family_name: "Only",
    profile_photo: "",
    onboarding_completed: true,
    mobile_onboarding_completed: false
  }
];

const userPermissions: UserPermission[] = [
  { user: users[0], role: 'editor' },
  { user: users[1], role: 'reader' }
];

// Filter users by permission level
function getUsersWithRole(permissions: UserPermission[], role: Role): User[] {
  return permissions
    .filter(p => p.role === role)
    .map(p => p.user);
}

// Get users who can perform a specific action
function getUsersWithPermission(permissions: UserPermission[], action: 'read' | 'write' | 'edit'): User[] {
  return permissions
    .filter(p => checkPermissions(p, action))
    .map(p => p.user);
}

// User lookup functions
function findUserById(users: User[], id: string): User | undefined {
  return users.find(user => user.id === id);
}

function findUserByEmail(users: User[], email: string): User | undefined {
  return users.find(user => user.email.toLowerCase() === email.toLowerCase());
}

// User display utilities
function formatUserForMention(user: User): string {
  return `@${getDisplayName(user)}`;
}

function getUserInitials(user: User): string {
  const firstInitial = user.given_name.charAt(0).toUpperCase();
  const lastInitial = user.family_name.charAt(0).toUpperCase();
  return `${firstInitial}${lastInitial}`;
}

// Example usage
const adminUsers = getUsersWithRole(userPermissions, 'editor');
const readOnlyUsers = getUsersWithRole(userPermissions, 'reader');

console.log('Admin users:', adminUsers.map(getDisplayName));
console.log('Read-only users:', readOnlyUsers.map(getDisplayName));

const editorsAndWriters = getUsersWithPermission(userPermissions, 'write');
console.log('Users who can write:', editorsAndWriters.map(getDisplayName));

// Check specific user permissions
const specificUser = findUserByEmail(users, 'admin@company.com');
if (specificUser) {
  const permission = userPermissions.find(p => p.user.id === specificUser.id);
  if (permission) {
    console.log(`${getDisplayName(specificUser)} has ${getRoleDescription(permission.role)}`);
    console.log(`Can edit: ${checkPermissions(permission, 'edit')}`);
    console.log(`Can write: ${checkPermissions(permission, 'write')}`);
    console.log(`Can read: ${checkPermissions(permission, 'read')}`);
  }
}