canopycms 0.0.0

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

@@ -0,0 +1,370 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { renderHook, act } from '@testing-library/react'
+import { useSchemaManager } from './useSchemaManager'
+import type { MockApiClient } from '../../api/__test__/mock-client'
+import { setupMockApiClient, createApiClientWrapper } from './__test__/test-utils'
+import { mockSuccess, mockError } from '../../api/__test__/mock-client'
+import { unsafeAsLogicalPath, unsafeAsContentId } from '../../paths/test-utils'
+import { mockConsole } from '../../test-utils/console-spy'
+
+// 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('useSchemaManager', () => {
+  let mockClient: MockApiClient
+  let wrapper: ReturnType<typeof createApiClientWrapper>
+
+  beforeEach(async () => {
+    mockConsole()
+    vi.clearAllMocks()
+    mockClient = await setupMockApiClient()
+    wrapper = createApiClientWrapper(mockClient)
+  })
+
+  describe('createCollection', () => {
+    it('creates collection successfully', async () => {
+      mockClient.schema.createCollection.mockResolvedValueOnce(
+        mockSuccess({
+          collectionPath: unsafeAsLogicalPath('posts'),
+          contentId: unsafeAsContentId('abc123def456'),
+        }),
+      )
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let createResult: { collectionPath: string; contentId: string } | null = null
+      await act(async () => {
+        createResult = await result.current.createCollection({
+          name: 'posts',
+          label: 'Posts',
+          entries: [{ name: 'post', format: 'json', schema: 'postSchema' }],
+        })
+      })
+
+      expect(createResult).toEqual({
+        collectionPath: unsafeAsLogicalPath('posts'),
+        contentId: 'abc123def456',
+      })
+      expect(mockClient.schema.createCollection).toHaveBeenCalledWith(
+        { branch: 'main' },
+        {
+          name: 'posts',
+          label: 'Posts',
+          entries: [{ name: 'post', format: 'json', schema: 'postSchema' }],
+        },
+      )
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+
+    it('returns null on error', async () => {
+      mockClient.schema.createCollection.mockResolvedValueOnce(
+        mockError(400, 'Collection already exists'),
+      )
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let createResult: { collectionPath: string; contentId: string } | null = null
+      await act(async () => {
+        createResult = await result.current.createCollection({
+          name: 'posts',
+          entries: [{ name: 'post', format: 'json', schema: 'postSchema' }],
+        })
+      })
+
+      expect(createResult).toBeNull()
+    })
+  })
+
+  describe('updateCollection', () => {
+    it('updates collection successfully', async () => {
+      mockClient.schema.updateCollection.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let updateResult = false
+      await act(async () => {
+        updateResult = await result.current.updateCollection(unsafeAsLogicalPath('posts'), {
+          label: 'Blog Posts',
+        })
+      })
+
+      expect(updateResult).toBe(true)
+      expect(mockClient.schema.updateCollection).toHaveBeenCalledWith(
+        { branch: 'main', collectionPath: 'posts' },
+        { label: 'Blog Posts' },
+      )
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+
+    it('returns false on error', async () => {
+      mockClient.schema.updateCollection.mockResolvedValueOnce(
+        mockError(404, 'Collection not found'),
+      )
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let updateResult = true
+      await act(async () => {
+        updateResult = await result.current.updateCollection(unsafeAsLogicalPath('nonexistent'), {
+          label: 'Test',
+        })
+      })
+
+      expect(updateResult).toBe(false)
+    })
+  })
+
+  describe('deleteCollection', () => {
+    it('deletes collection successfully', async () => {
+      mockClient.schema.deleteCollection.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let deleteResult = false
+      await act(async () => {
+        deleteResult = await result.current.deleteCollection(unsafeAsLogicalPath('posts'))
+      })
+
+      expect(deleteResult).toBe(true)
+      expect(mockClient.schema.deleteCollection).toHaveBeenCalledWith({
+        branch: 'main',
+        collectionPath: 'posts',
+      })
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+
+    it('returns false when collection is not empty', async () => {
+      mockClient.schema.deleteCollection.mockResolvedValueOnce(
+        mockError(400, 'Collection must be empty'),
+      )
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let deleteResult = true
+      await act(async () => {
+        deleteResult = await result.current.deleteCollection(unsafeAsLogicalPath('posts'))
+      })
+
+      expect(deleteResult).toBe(false)
+    })
+  })
+
+  describe('addEntryType', () => {
+    it('adds entry type successfully', async () => {
+      mockClient.schema.addEntryType.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let addResult = false
+      await act(async () => {
+        addResult = await result.current.addEntryType(unsafeAsLogicalPath('posts'), {
+          name: 'featured',
+          format: 'mdx',
+          schema: 'postSchema',
+        })
+      })
+
+      expect(addResult).toBe(true)
+      expect(mockClient.schema.addEntryType).toHaveBeenCalledWith(
+        { branch: 'main', collectionPath: 'posts' },
+        { name: 'featured', format: 'mdx', schema: 'postSchema' },
+      )
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+  })
+
+  describe('updateEntryType', () => {
+    it('updates entry type successfully', async () => {
+      mockClient.schema.updateEntryType.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let updateResult = false
+      await act(async () => {
+        updateResult = await result.current.updateEntryType(unsafeAsLogicalPath('posts'), 'post', {
+          label: 'Blog Post',
+          maxItems: 100,
+        })
+      })
+
+      expect(updateResult).toBe(true)
+      expect(mockClient.schema.updateEntryType).toHaveBeenCalledWith(
+        { branch: 'main', collectionPath: 'posts', entryTypeName: 'post' },
+        { label: 'Blog Post', maxItems: 100 },
+      )
+    })
+  })
+
+  describe('removeEntryType', () => {
+    it('removes entry type successfully', async () => {
+      mockClient.schema.removeEntryType.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let removeResult = false
+      await act(async () => {
+        removeResult = await result.current.removeEntryType(
+          unsafeAsLogicalPath('posts'),
+          'featured',
+        )
+      })
+
+      expect(removeResult).toBe(true)
+      expect(mockClient.schema.removeEntryType).toHaveBeenCalledWith({
+        branch: 'main',
+        collectionPath: 'posts',
+        entryTypeName: 'featured',
+      })
+    })
+
+    it('returns false when removing last entry type', async () => {
+      mockClient.schema.removeEntryType.mockResolvedValueOnce(
+        mockError(400, 'Cannot remove last entry type'),
+      )
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let removeResult = true
+      await act(async () => {
+        removeResult = await result.current.removeEntryType(unsafeAsLogicalPath('posts'), 'post')
+      })
+
+      expect(removeResult).toBe(false)
+    })
+  })
+
+  describe('updateOrder', () => {
+    it('updates order successfully', async () => {
+      mockClient.schema.updateOrder.mockResolvedValueOnce(mockSuccess({ success: true }))
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let updateResult = false
+      await act(async () => {
+        updateResult = await result.current.updateOrder(unsafeAsLogicalPath('posts'), [
+          'id3',
+          'id1',
+          'id2',
+        ])
+      })
+
+      expect(updateResult).toBe(true)
+      expect(mockClient.schema.updateOrder).toHaveBeenCalledWith(
+        { branch: 'main', collectionPath: 'posts' },
+        { order: ['id3', 'id1', 'id2'] },
+      )
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+  })
+
+  describe('deleteEntry', () => {
+    it('deletes entry successfully', async () => {
+      mockClient.entries.delete.mockResolvedValueOnce(mockSuccess({ deleted: true }))
+
+      const onSchemaChange = vi.fn()
+      const { result } = renderHook(
+        () => useSchemaManager({ branchName: 'main', onSchemaChange }),
+        { wrapper },
+      )
+
+      let deleteResult = false
+      await act(async () => {
+        deleteResult = await result.current.deleteEntry(unsafeAsLogicalPath('posts/hello-world'))
+      })
+
+      expect(deleteResult).toBe(true)
+      expect(mockClient.entries.delete).toHaveBeenCalledWith({
+        branch: 'main',
+        entryPath: 'posts/hello-world',
+      })
+      expect(onSchemaChange).toHaveBeenCalled()
+    })
+
+    it('returns false when lacking permission', async () => {
+      mockClient.entries.delete.mockResolvedValueOnce(mockError(403, 'Edit permission required'))
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      let deleteResult = true
+      await act(async () => {
+        deleteResult = await result.current.deleteEntry(unsafeAsLogicalPath('posts/protected'))
+      })
+
+      expect(deleteResult).toBe(false)
+    })
+  })
+
+  describe('isLoading state', () => {
+    it('sets isLoading during operations', async () => {
+      let resolvePromise: (value: unknown) => void
+      const promise = new Promise((resolve) => {
+        resolvePromise = resolve
+      })
+      mockClient.schema.createCollection.mockReturnValueOnce(promise as any)
+
+      const { result } = renderHook(() => useSchemaManager({ branchName: 'main' }), { wrapper })
+
+      expect(result.current.isLoading).toBe(false)
+
+      // Start operation
+      let createPromise: Promise<unknown>
+      act(() => {
+        createPromise = result.current.createCollection({
+          name: 'posts',
+          entries: [{ name: 'post', format: 'json', schema: 'postSchema' }],
+        })
+      })
+
+      // Should be loading
+      expect(result.current.isLoading).toBe(true)
+
+      // Complete the operation
+      await act(async () => {
+        resolvePromise!(
+          mockSuccess({
+            collectionPath: unsafeAsLogicalPath('posts'),
+            contentId: unsafeAsContentId('abc123'),
+          }),
+        )
+        await createPromise
+      })
+
+      // Should no longer be loading
+      expect(result.current.isLoading).toBe(false)
+    })
+  })
+})

package/src/editor/hooks/useSchemaManager.ts

@@ -0,0 +1,310 @@
+import { useState, useCallback } from 'react'
+import { notifications } from '@mantine/notifications'
+import { useApiClient } from '../context'
+import type {
+  CreateCollectionInput,
+  UpdateCollectionInput,
+  CreateEntryTypeInput,
+  UpdateEntryTypeInput,
+} from '../../api'
+import type { LogicalPath, ContentId } from '../../paths/types'
+
+export interface UseSchemaManagerOptions {
+  branchName: string
+  onSchemaChange?: () => void
+}
+
+export interface UseSchemaManagerReturn {
+  // Collection operations
+  createCollection: (
+    input: CreateCollectionInput,
+  ) => Promise<{ collectionPath: LogicalPath; contentId: ContentId } | null>
+  updateCollection: (
+    collectionPath: LogicalPath,
+    updates: UpdateCollectionInput,
+  ) => Promise<boolean>
+  deleteCollection: (collectionPath: LogicalPath) => Promise<boolean>
+
+  // Entry type operations
+  addEntryType: (collectionPath: LogicalPath, entryType: CreateEntryTypeInput) => Promise<boolean>
+  updateEntryType: (
+    collectionPath: LogicalPath,
+    entryTypeName: string,
+    updates: UpdateEntryTypeInput,
+  ) => Promise<boolean>
+  removeEntryType: (collectionPath: LogicalPath, entryTypeName: string) => Promise<boolean>
+
+  // Order operations
+  updateOrder: (collectionPath: LogicalPath, order: string[]) => Promise<boolean>
+
+  // Delete entry
+  deleteEntry: (entryPath: LogicalPath) => Promise<boolean>
+
+  // State
+  isLoading: boolean
+}
+
+/**
+ * Hook for managing schema operations (collections, entry types, ordering).
+ *
+ * Provides methods to create, update, and delete collections and entry types.
+ * All operations require admin permissions on the server.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   createCollection,
+ *   deleteCollection,
+ *   addEntryType,
+ *   updateOrder,
+ *   isLoading
+ * } = useSchemaManager({ branchName: 'main', onSchemaChange: refreshEntries })
+ *
+ * // Create a new collection
+ * await createCollection({
+ *   name: 'posts',
+ *   label: 'Blog Posts',
+ *   entries: [{ name: 'post', format: 'mdx', schema: 'postSchema' }]
+ * })
+ * ```
+ */
+export function useSchemaManager(options: UseSchemaManagerOptions): UseSchemaManagerReturn {
+  const apiClient = useApiClient()
+  const [isLoading, setIsLoading] = useState(false)
+
+  const handleError = useCallback((message: string, error: unknown) => {
+    console.error(message, error)
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    notifications.show({
+      title: 'Error',
+      message: `${message}: ${errorMessage}`,
+      color: 'red',
+    })
+  }, [])
+
+  const createCollection = useCallback(
+    async (input: CreateCollectionInput) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.createCollection(
+          { branch: options.branchName },
+          input,
+        )
+        if (!result.ok || !result.data) {
+          throw new Error(result.error || 'Failed to create collection')
+        }
+        notifications.show({
+          message: `Collection "${input.name}" created`,
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return result.data
+      } catch (error) {
+        handleError('Failed to create collection', error)
+        return null
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const updateCollection = useCallback(
+    async (collectionPath: LogicalPath, updates: UpdateCollectionInput) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.updateCollection(
+          { branch: options.branchName, collectionPath },
+          updates,
+        )
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to update collection')
+        }
+        notifications.show({
+          message: 'Collection updated',
+          color: 'green',
+        })
+        await options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to update collection', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const deleteCollection = useCallback(
+    async (collectionPath: LogicalPath) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.deleteCollection({
+          branch: options.branchName,
+          collectionPath,
+        })
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to delete collection')
+        }
+        notifications.show({
+          message: 'Collection deleted',
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to delete collection', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const addEntryType = useCallback(
+    async (collectionPath: LogicalPath, entryType: CreateEntryTypeInput) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.addEntryType(
+          { branch: options.branchName, collectionPath },
+          entryType,
+        )
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to add entry type')
+        }
+        notifications.show({
+          message: `Entry type "${entryType.name}" added`,
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to add entry type', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const updateEntryType = useCallback(
+    async (collectionPath: LogicalPath, entryTypeName: string, updates: UpdateEntryTypeInput) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.updateEntryType(
+          { branch: options.branchName, collectionPath, entryTypeName },
+          updates,
+        )
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to update entry type')
+        }
+        notifications.show({
+          message: 'Entry type updated',
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to update entry type', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const removeEntryType = useCallback(
+    async (collectionPath: LogicalPath, entryTypeName: string) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.removeEntryType({
+          branch: options.branchName,
+          collectionPath,
+          entryTypeName,
+        })
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to remove entry type')
+        }
+        notifications.show({
+          message: `Entry type "${entryTypeName}" removed`,
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to remove entry type', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const updateOrder = useCallback(
+    async (collectionPath: LogicalPath, order: string[]) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.schema.updateOrder(
+          { branch: options.branchName, collectionPath },
+          { order },
+        )
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to update order')
+        }
+        // Silent success for order updates (common operation)
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to update order', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  const deleteEntry = useCallback(
+    async (entryPath: LogicalPath) => {
+      setIsLoading(true)
+      try {
+        const result = await apiClient.entries.delete({
+          branch: options.branchName,
+          entryPath,
+        })
+        if (!result.ok) {
+          throw new Error(result.error || 'Failed to delete entry')
+        }
+        notifications.show({
+          message: 'Entry deleted',
+          color: 'green',
+        })
+        options.onSchemaChange?.()
+        return true
+      } catch (error) {
+        handleError('Failed to delete entry', error)
+        return false
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [apiClient, options.branchName, options.onSchemaChange, handleError],
+  )
+
+  return {
+    createCollection,
+    updateCollection,
+    deleteCollection,
+    addEntryType,
+    updateEntryType,
+    removeEntryType,
+    updateOrder,
+    deleteEntry,
+    isLoading,
+  }
+}