canopycms 0.0.0 → 0.0.2

package/src/editor/hooks/useGroupManager.ts

@@ -1,139 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-import { notifications } from '@mantine/notifications'
-import type { InternalGroup } from '../../authorization'
-import type { UserSearchResult, GroupMetadata } from '../../auth/types'
-import { useApiClient } from '../context'
-
-export interface UseGroupManagerOptions {
-  /**
-   * Whether the group manager is currently open.
-   * Groups are loaded when this becomes true.
-   */
-  isOpen: boolean
-}
-
-export interface UseGroupManagerReturn {
-  groupsData: InternalGroup[]
-  groupsLoading: boolean
-  handleSaveGroups: (groups: InternalGroup[]) => Promise<void>
-  handleSearchUsers: (query: string, limit?: number) => Promise<UserSearchResult[]>
-  handleGetUserMetadata: (userId: string) => Promise<UserSearchResult | null>
-  handleSearchExternalGroups: (query: string) => Promise<GroupMetadata[]>
-  loadGroups: () => Promise<void>
-}
-
-/**
- * Custom hook for managing internal groups (CRUD operations).
- *
- * Handles:
- * - Loading groups from API
- * - Saving groups to API
- * - Searching for users to add to groups
- * - Searching for external groups
- *
- * @example
- * ```tsx
- * const { groupsData, groupsLoading, handleSaveGroups, handleSearchUsers } = useGroupManager({
- *   isOpen: groupManagerOpen
- * })
- *
- * // Groups are automatically loaded when isOpen becomes true
- * // Save groups
- * await handleSaveGroups(updatedGroups)
- *
- * // Search users
- * const users = await handleSearchUsers('john', 10)
- * ```
- */
-export function useGroupManager(options: UseGroupManagerOptions): UseGroupManagerReturn {
-  const apiClient = useApiClient()
-  const [groupsData, setGroupsData] = useState<InternalGroup[]>([])
-  const [groupsLoading, setGroupsLoading] = useState(false)
-
-  const loadGroups = async () => {
-    setGroupsLoading(true)
-    try {
-      const result = await apiClient.groups.getInternal()
-      if (!result.ok) throw new Error('Failed to load groups')
-      setGroupsData(result.data?.groups ?? [])
-    } catch (err) {
-      console.error('Failed to load groups:', err)
-      notifications.show({ message: 'Failed to load groups', color: 'red' })
-    } finally {
-      setGroupsLoading(false)
-    }
-  }
-
-  const handleSaveGroups = useCallback(async (groups: InternalGroup[]) => {
-    try {
-      const result = await apiClient.groups.updateInternal({ groups })
-      if (!result.ok) {
-        throw new Error(result.error || 'Failed to save groups')
-      }
-      notifications.show({
-        title: 'Groups Saved',
-        message: 'Internal groups have been updated',
-        color: 'green',
-      })
-      await loadGroups()
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to save groups'
-      notifications.show({ message, color: 'red' })
-      throw err
-    }
-  }, [])
-
-  const handleSearchUsers = useCallback(async (query: string, limit?: number) => {
-    try {
-      const params: Record<string, string> = { q: query }
-      if (limit) {
-        params.limit = String(limit)
-      }
-      const result = await apiClient.permissions.searchUsers(params)
-      if (!result.ok) return []
-      return result.data?.users ?? []
-    } catch (err) {
-      console.error('User search failed:', err)
-      return []
-    }
-  }, [])
-
-  const handleGetUserMetadata = useCallback(async (userId: string) => {
-    try {
-      const result = await apiClient.permissions.getUserMetadata({ userId })
-      if (!result.ok) return null
-      return result.data?.user ?? null
-    } catch (err) {
-      console.error('Get user metadata failed:', err)
-      return null
-    }
-  }, [])
-
-  const handleSearchExternalGroups = useCallback(async (query: string) => {
-    try {
-      const result = await apiClient.groups.searchExternal({ q: query })
-      if (!result.ok) return []
-      return result.data?.groups ?? []
-    } catch (err) {
-      console.error('External group search failed:', err)
-      return []
-    }
-  }, [])
-
-  // Load groups when group manager opens
-  useEffect(() => {
-    if (options.isOpen) {
-      loadGroups()
-    }
-  }, [options.isOpen])
-
-  return {
-    groupsData,
-    groupsLoading,
-    handleSaveGroups,
-    handleSearchUsers,
-    handleGetUserMetadata,
-    handleSearchExternalGroups,
-    loadGroups,
-  }
-}

package/src/editor/hooks/usePermissionManager.test.ts

@@ -1,211 +0,0 @@
-import { renderHook, waitFor } from '@testing-library/react'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { usePermissionManager } from './usePermissionManager'
-import type { MockApiClient } from '../../api/__test__/mock-client'
-import { setupMockApiClient, setupMockConsole, createApiClientWrapper } from './__test__/test-utils'
-import { unsafeAsPermissionPath } from '../../authorization/test-utils'
-
-// Mock the API client module
-vi.mock('../../api', async () => {
-  const actual = await vi.importActual('../../api')
-  return {
-    ...actual,
-    createApiClient: vi.fn(),
-  }
-})
-
-// Mock notifications
-vi.mock('@mantine/notifications', () => ({
-  notifications: {
-    show: vi.fn(),
-  },
-}))
-
-describe('usePermissionManager', () => {
-  let mockClient: MockApiClient
-  let wrapper: ReturnType<typeof createApiClientWrapper>
-
-  beforeEach(async () => {
-    mockClient = await setupMockApiClient()
-    wrapper = createApiClientWrapper(mockClient)
-  })
-
-  afterEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('initializes with empty permissions', () => {
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    expect(result.current.permissionsData).toEqual([])
-    expect(result.current.permissionsLoading).toBe(false)
-  })
-
-  it('loads permissions when isOpen becomes true', async () => {
-    const mockPermissions = [
-      {
-        path: unsafeAsPermissionPath('/content/pages'),
-        edit: { allowedGroups: ['editors'] },
-      },
-      {
-        path: unsafeAsPermissionPath('/content/posts'),
-        read: { allowedGroups: ['writers'] },
-      },
-    ]
-
-    mockClient.permissions.get.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { permissions: mockPermissions },
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: true }), { wrapper })
-
-    // Should start loading
-    expect(result.current.permissionsLoading).toBe(true)
-
-    await waitFor(() => {
-      expect(result.current.permissionsLoading).toBe(false)
-    })
-
-    expect(result.current.permissionsData).toEqual(mockPermissions)
-    expect(mockClient.permissions.get).toHaveBeenCalled()
-  })
-
-  it('handles load permissions error', async () => {
-    const { restore } = setupMockConsole(['error'])
-    mockClient.permissions.get.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: true }), { wrapper })
-
-    await waitFor(() => {
-      expect(result.current.permissionsLoading).toBe(false)
-    })
-
-    expect(result.current.permissionsData).toEqual([])
-    restore()
-  })
-
-  it('saves permissions successfully', async () => {
-    const mockPermissions = [
-      {
-        path: unsafeAsPermissionPath('/content/pages'),
-        edit: { allowedGroups: ['editors'] },
-      },
-    ]
-
-    // Mock initial load
-    mockClient.permissions.get.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { permissions: [] },
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: true }), { wrapper })
-
-    await waitFor(() => {
-      expect(result.current.permissionsLoading).toBe(false)
-    })
-
-    // Mock save
-    mockClient.permissions.update.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-    })
-
-    // Mock reload after save
-    mockClient.permissions.get.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { permissions: mockPermissions },
-    })
-
-    await result.current.handleSavePermissions(mockPermissions)
-
-    await waitFor(() => {
-      expect(result.current.permissionsData).toEqual(mockPermissions)
-    })
-
-    expect(mockClient.permissions.update).toHaveBeenCalledWith({
-      permissions: mockPermissions,
-    })
-  })
-
-  it('handles save permissions error', async () => {
-    mockClient.permissions.update.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-      error: 'Save failed',
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    await expect(result.current.handleSavePermissions([])).rejects.toThrow('Save failed')
-  })
-
-  it('lists groups successfully', async () => {
-    const mockGroups = [
-      { id: 'group1', name: 'Editors' },
-      { id: 'group2', name: 'Writers' },
-    ]
-
-    mockClient.permissions.listGroups.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { groups: mockGroups },
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    const groups = await result.current.handleListGroups()
-
-    expect(groups).toEqual(mockGroups)
-    expect(mockClient.permissions.listGroups).toHaveBeenCalled()
-  })
-
-  it('handles list groups error', async () => {
-    mockClient.permissions.listGroups.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    const groups = await result.current.handleListGroups()
-
-    expect(groups).toEqual([])
-  })
-
-  it('does not load permissions when isOpen is false', async () => {
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    expect(result.current.permissionsLoading).toBe(false)
-    expect(mockClient.permissions.get).not.toHaveBeenCalled()
-  })
-
-  it('can manually reload permissions', async () => {
-    const mockPermissions = [
-      {
-        path: unsafeAsPermissionPath('/content/pages'),
-        edit: { allowedGroups: ['editors'] },
-      },
-    ]
-
-    mockClient.permissions.get.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { permissions: mockPermissions },
-    })
-
-    const { result } = renderHook(() => usePermissionManager({ isOpen: false }), { wrapper })
-
-    await result.current.loadPermissions()
-
-    await waitFor(() => {
-      expect(result.current.permissionsData).toEqual(mockPermissions)
-    })
-  })
-})

package/src/editor/hooks/usePermissionManager.ts

@@ -1,113 +0,0 @@
-import { useEffect, useState } from 'react'
-import { notifications } from '@mantine/notifications'
-import type { PathPermission } from '../../config'
-import type { GroupMetadata } from '../../auth/types'
-import { useApiClient } from '../context'
-
-export interface UsePermissionManagerOptions {
-  /**
-   * Whether the permission manager is currently open.
-   * Permissions are loaded when this becomes true.
-   */
-  isOpen: boolean
-}
-
-export interface UsePermissionManagerReturn {
-  permissionsData: PathPermission[]
-  permissionsLoading: boolean
-  handleSavePermissions: (permissions: PathPermission[]) => Promise<void>
-  handleListGroups: () => Promise<GroupMetadata[]>
-  loadPermissions: () => Promise<void>
-}
-
-/**
- * Custom hook for managing path permissions (CRUD operations).
- *
- * Handles:
- * - Loading permissions from API
- * - Saving permissions to API
- * - Listing groups for permission assignment
- *
- * @example
- * ```tsx
- * const { permissionsData, permissionsLoading, handleSavePermissions, handleListGroups } = usePermissionManager({
- *   isOpen: permissionManagerOpen
- * })
- *
- * // Permissions are automatically loaded when isOpen becomes true
- * // Save permissions
- * await handleSavePermissions(updatedPermissions)
- *
- * // List groups
- * const groups = await handleListGroups()
- * ```
- */
-export function usePermissionManager(
-  options: UsePermissionManagerOptions,
-): UsePermissionManagerReturn {
-  const apiClient = useApiClient()
-  const [permissionsData, setPermissionsData] = useState<PathPermission[]>([])
-  const [permissionsLoading, setPermissionsLoading] = useState(false)
-
-  const loadPermissions = async () => {
-    setPermissionsLoading(true)
-    try {
-      const result = await apiClient.permissions.get()
-      if (!result.ok) throw new Error('Failed to load permissions')
-      setPermissionsData(result.data?.permissions ?? [])
-    } catch (err) {
-      console.error('Failed to load permissions:', err)
-      notifications.show({
-        message: 'Failed to load permissions',
-        color: 'red',
-      })
-    } finally {
-      setPermissionsLoading(false)
-    }
-  }
-
-  const handleSavePermissions = async (permissions: PathPermission[]) => {
-    try {
-      const result = await apiClient.permissions.update({ permissions })
-      if (!result.ok) {
-        throw new Error(result.error || 'Failed to save permissions')
-      }
-      notifications.show({
-        title: 'Permissions Saved',
-        message: 'Permissions have been updated',
-        color: 'green',
-      })
-      await loadPermissions()
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to save permissions'
-      notifications.show({ message, color: 'red' })
-      throw err
-    }
-  }
-
-  const handleListGroups = async () => {
-    try {
-      const result = await apiClient.permissions.listGroups()
-      if (!result.ok) return []
-      return result.data?.groups ?? []
-    } catch (err) {
-      console.error('Group list failed:', err)
-      return []
-    }
-  }
-
-  // Load permissions when permission manager opens
-  useEffect(() => {
-    if (options.isOpen) {
-      loadPermissions()
-    }
-  }, [options.isOpen])
-
-  return {
-    permissionsData,
-    permissionsLoading,
-    handleSavePermissions,
-    handleListGroups,
-    loadPermissions,
-  }
-}

package/src/editor/hooks/useReferenceResolution.ts

@@ -1,248 +0,0 @@
-/**
- * Hook for live preview reference resolution
- *
- * LIVE PREVIEW REFERENCE RESOLUTION
- *
- * Problem: The preview needs full referenced content (e.g., {name: "Alice", bio: "..."}),
- * but the form only stores IDs (e.g., "5NVkkrB1MJUvnLqEDqDkRN").
- *
- * Solution: Synchronous resolution with background caching
- *
- * 1. SYNCHRONOUS PHASE (useMemo):
- *    - Compute resolvedValue by applying cached data to form value
- *    - If reference ID is in cache, use full object; otherwise keep ID
- *    - Runs during render, so no async gaps or race conditions
- *    - Preview always gets complete, valid data
- *
- * 2. BACKGROUND PHASE (useEffect):
- *    - Find IDs not in cache
- *    - After 300ms debounce, fetch from API
- *    - Update cache with resolved data
- *    - Trigger useMemo re-run via resolutionTrigger
- *    - Preview updates again with full data
- *
- * This two-phase approach eliminates race conditions that occurred with async state,
- * where form data and resolved data could get out of sync during transitions
- * (e.g., "Discard All Drafts" was passing empty objects to preview).
- *
- * Cache structure: Map<string, unknown> with keys like "main:5NVkkrB1MJUvnLqEDqDkRN"
- * - Branch-scoped to prevent stale cross-branch data
- * - Cleared on branch change
- * - Persists across edits for instant re-renders
- */
-
-import { useEffect, useMemo, useRef, useState } from 'react'
-import type { EntrySchema } from '../../config'
-import { resolveChangedReferences } from '../client-reference-resolver'
-
-export type FormValue = Record<string, unknown>
-
-export interface UseReferenceResolutionOptions {
-  value: FormValue
-  fields: EntrySchema
-  branch: string
-  onResolvedValueChange?: (resolved: FormValue) => void
-  onLoadingStateChange?: (loadingState: FormValue) => void
-}
-
-export interface UseReferenceResolutionResult {
-  resolvedValue: FormValue
-  loadingState: FormValue
-}
-
-export function useReferenceResolution({
-  value,
-  fields,
-  branch,
-  onResolvedValueChange,
-  onLoadingStateChange,
-}: UseReferenceResolutionOptions): UseReferenceResolutionResult {
-  const resolvedCache = useRef<Map<string, unknown>>(new Map())
-  const prevValueRef = useRef<FormValue>({}) // Track previous value for change detection
-  const lastNotifiedValueRef = useRef<string>('') // Track last notified value to prevent infinite loops
-  const [resolutionTrigger, setResolutionTrigger] = useState(0) // Trigger to force useMemo re-computation
-
-  // Map field names to their types for fast lookup
-  const referenceFieldNames = useMemo(() => {
-    const names = new Set<string>()
-    for (const field of fields) {
-      if (field.type === 'reference') {
-        names.add(field.name)
-      }
-    }
-    return names
-  }, [fields])
-
-  /**
-   * PHASE 1: SYNCHRONOUS RESOLUTION
-   *
-   * Compute resolved value by applying cached reference data to form value.
-   * This runs synchronously during render (useMemo), so there are no async gaps.
-   *
-   * For each reference field:
-   * - If ID is in cache: substitute full object
-   * - If ID not in cache: keep the ID (loading state)
-   *
-   * Dependencies include resolutionTrigger, which is incremented when cache updates,
-   * forcing this to re-run and pick up newly-resolved data.
-   */
-  const resolvedValue = useMemo(() => {
-    const result = { ...value }
-
-    // Synchronously apply cached resolutions
-    for (const fieldName of referenceFieldNames) {
-      const fieldValue = value[fieldName]
-      if (fieldValue) {
-        if (Array.isArray(fieldValue)) {
-          // List of references
-          result[fieldName] = fieldValue.map((id) => {
-            if (typeof id === 'string') {
-              const cached = resolvedCache.current.get(`${branch}:${id}`)
-              // Return cached object, or null if not yet resolved
-              return cached || null
-            }
-            return id
-          })
-        } else if (typeof fieldValue === 'string') {
-          // Single reference
-          const cached = resolvedCache.current.get(`${branch}:${fieldValue}`)
-          // Return cached object, or null if not yet resolved
-          result[fieldName] = cached || null
-        }
-      }
-    }
-
-    return result
-  }, [value, branch, resolutionTrigger, referenceFieldNames])
-
-  /**
-   * Compute loading state that mirrors the data structure.
-   * For each reference field, track if it's currently loading (not in cache).
-   */
-  const loadingState = useMemo(() => {
-    const result: FormValue = {}
-
-    for (const fieldName of referenceFieldNames) {
-      const fieldValue = value[fieldName]
-      if (fieldValue) {
-        if (Array.isArray(fieldValue)) {
-          // List of references - return array of booleans
-          result[fieldName] = fieldValue.map((id) => {
-            if (typeof id === 'string') {
-              return !resolvedCache.current.has(`${branch}:${id}`)
-            }
-            return false
-          })
-        } else if (typeof fieldValue === 'string') {
-          // Single reference - return boolean
-          result[fieldName] = !resolvedCache.current.has(`${branch}:${fieldValue}`)
-        } else {
-          result[fieldName] = false
-        }
-      } else {
-        result[fieldName] = false
-      }
-    }
-
-    return result
-  }, [value, branch, resolutionTrigger, referenceFieldNames])
-
-  /**
-   * PHASE 2: BACKGROUND ASYNC RESOLUTION
-   *
-   * Find reference IDs that aren't in cache yet and fetch them from the API.
-   */
-  useEffect(() => {
-    // Find all uncached reference IDs
-    const uncachedIds = new Set<string>()
-
-    for (const fieldName of referenceFieldNames) {
-      const fieldValue = value[fieldName]
-      if (fieldValue) {
-        const ids = Array.isArray(fieldValue) ? fieldValue : [fieldValue]
-        for (const id of ids) {
-          if (typeof id === 'string' && !resolvedCache.current.has(`${branch}:${id}`)) {
-            uncachedIds.add(id)
-          }
-        }
-      }
-    }
-
-    if (uncachedIds.size === 0) {
-      prevValueRef.current = value
-      return
-    }
-
-    // Debounce API calls to batch multiple rapid changes
-    const timeout = setTimeout(async () => {
-      try {
-        // Resolve uncached IDs via API
-        const updates = await resolveChangedReferences(
-          prevValueRef.current,
-          value,
-          fields,
-          branch,
-          resolvedCache.current,
-        )
-
-        // Update cache with resolved values
-        for (const [fieldName, resolvedFieldValue] of Object.entries(updates)) {
-          if (Array.isArray(resolvedFieldValue)) {
-            resolvedFieldValue.forEach((obj, idx) => {
-              const fieldValue = value[fieldName]
-              if (Array.isArray(fieldValue)) {
-                const id = fieldValue[idx]
-                if (typeof obj === 'object' && obj !== null && typeof id === 'string') {
-                  resolvedCache.current.set(`${branch}:${id}`, obj)
-                }
-              }
-            })
-          } else if (typeof resolvedFieldValue === 'object' && resolvedFieldValue !== null) {
-            const id = value[fieldName] as string
-            if (typeof id === 'string') {
-              resolvedCache.current.set(`${branch}:${id}`, resolvedFieldValue)
-            }
-          }
-        }
-
-        // Trigger useMemo re-computation
-        setResolutionTrigger((prev) => prev + 1)
-        prevValueRef.current = value
-      } catch (error) {
-        console.error('Reference resolution failed:', error)
-      }
-    }, 300) // 300ms debounce
-
-    return () => clearTimeout(timeout)
-  }, [value, fields, branch, referenceFieldNames])
-
-  // Clear cache when branch changes
-  useEffect(() => {
-    resolvedCache.current.clear()
-    setResolutionTrigger((prev) => prev + 1) // Trigger re-computation with empty cache
-  }, [branch])
-
-  // Notify parent of resolved value changes (with infinite loop prevention)
-  useEffect(() => {
-    const serialized = JSON.stringify(resolvedValue)
-    if (serialized !== lastNotifiedValueRef.current) {
-      lastNotifiedValueRef.current = serialized
-      onResolvedValueChange?.(resolvedValue)
-    }
-  }, [resolvedValue, onResolvedValueChange])
-
-  // Notify parent of loading state changes
-  const lastNotifiedLoadingRef = useRef<string>('')
-  useEffect(() => {
-    const serialized = JSON.stringify(loadingState)
-    if (serialized !== lastNotifiedLoadingRef.current) {
-      lastNotifiedLoadingRef.current = serialized
-      onLoadingStateChange?.(loadingState)
-    }
-  }, [loadingState, onLoadingStateChange])
-
-  return {
-    resolvedValue,
-    loadingState,
-  }
-}