canopycms 0.0.0 → 0.0.2

package/src/editor/hooks/useBranchManager.test.tsx

@@ -1,391 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useBranchManager, UseBranchManagerOptions } from './useBranchManager'
-import type { BranchMetadata } from '../../types'
-import type { MockApiClient } from '../../api/__test__/mock-client'
-import {
-  setupMockApiClient,
-  setupMockLocation,
-  setupMockHistory,
-  setupMockConsole,
-  createApiClientWrapper,
-} from './__test__/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(),
-  },
-}))
-
-// Mock modals - auto-confirm by default
-vi.mock('@mantine/modals', () => ({
-  modals: {
-    openConfirmModal: vi.fn((options) => {
-      // Automatically call onConfirm to simulate user clicking "Confirm"
-      if (options.onConfirm) {
-        options.onConfirm()
-      }
-    }),
-  },
-}))
-
-describe('useBranchManager', () => {
-  let mockClient: MockApiClient
-  let wrapper: ReturnType<typeof createApiClientWrapper>
-
-  const mockBranches: BranchMetadata[] = [
-    {
-      name: 'main',
-      status: 'editing',
-      title: 'Main Branch',
-      access: { allowedUsers: [], allowedGroups: [] },
-      createdBy: 'user1',
-      createdAt: '2024-01-01',
-      updatedAt: '2024-01-02',
-    },
-    {
-      name: 'feature',
-      status: 'submitted',
-      title: 'Feature Branch',
-      access: { allowedUsers: ['user1'], allowedGroups: ['group1'] },
-      createdBy: 'user1',
-      createdAt: '2024-01-01',
-      updatedAt: '2024-01-03',
-    },
-  ]
-
-  const mockSetBusy = vi.fn()
-
-  const defaultOptions: UseBranchManagerOptions = {
-    initialBranch: 'main',
-    operatingMode: 'dev' as const,
-    setBusy: mockSetBusy,
-    comments: [],
-  }
-
-  beforeEach(async () => {
-    mockClient = await setupMockApiClient()
-    wrapper = createApiClientWrapper(mockClient)
-
-    setupMockLocation()
-    setupMockHistory()
-  })
-
-  afterEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('initializes with initial branch', () => {
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { branches: [] },
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    expect(result.current.branchName).toBe('main')
-    expect(result.current.branches).toEqual([])
-  })
-
-  it('loads branches on mount', async () => {
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { branches: mockBranches },
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toEqual(mockBranches)
-    })
-
-    expect(mockClient.branches.list).toHaveBeenCalled()
-    expect(mockSetBusy).toHaveBeenCalledWith(true)
-    expect(mockSetBusy).toHaveBeenCalledWith(false)
-  })
-
-  it('handles branch load returning 404 gracefully', async () => {
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toEqual([])
-    })
-  })
-
-  it('handles branch load error', async () => {
-    const { restore } = setupMockConsole(['error'])
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-    })
-
-    renderHook(() => useBranchManager(defaultOptions), { wrapper })
-
-    await waitFor(() => {
-      expect(mockSetBusy).toHaveBeenCalledWith(false)
-    })
-
-    restore()
-  })
-
-  it('computes currentBranch and branchStatus', async () => {
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { branches: mockBranches },
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.currentBranch).toEqual(mockBranches[0])
-      expect(result.current.branchStatus).toBe('editing')
-    })
-  })
-
-  it('submits branch successfully', async () => {
-    mockClient.branches.list
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-
-    mockClient.workflow.submit.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.handleSubmit('feature')
-    })
-
-    expect(mockClient.workflow.submit).toHaveBeenCalledWith({
-      branch: 'feature',
-    })
-    expect(mockSetBusy).toHaveBeenCalledWith(true)
-    expect(mockSetBusy).toHaveBeenCalledWith(false)
-  })
-
-  it('handles submit error', async () => {
-    const { restore } = setupMockConsole(['error'])
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { branches: mockBranches },
-    })
-
-    mockClient.workflow.submit.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-      error: 'Submit failed',
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    await act(async () => {
-      try {
-        await result.current.handleSubmit('feature')
-        // Should not reach here - expect rejection
-        expect.fail('Expected handleSubmit to reject')
-      } catch (err) {
-        // Expected - error should be rejected
-        expect(err).toBeInstanceOf(Error)
-      }
-    })
-
-    expect(mockSetBusy).toHaveBeenCalledWith(false)
-    restore()
-  })
-
-  it('withdraws branch successfully', async () => {
-    mockClient.branches.list
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-
-    mockClient.workflow.withdraw.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.handleWithdraw('feature')
-    })
-
-    expect(mockClient.workflow.withdraw).toHaveBeenCalledWith({
-      branch: 'feature',
-    })
-  })
-
-  it('requests changes successfully', async () => {
-    mockClient.branches.list
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-
-    mockClient.workflow.requestChanges.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.handleRequestChanges('feature')
-    })
-
-    expect(mockClient.workflow.requestChanges).toHaveBeenCalledWith({ branch: 'feature' }, {})
-  })
-
-  it('reloads branch data', async () => {
-    mockClient.branches.list
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        data: { branches: mockBranches },
-      })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    await act(async () => {
-      await result.current.handleReloadBranchData()
-    })
-
-    // Verify loadBranches was called
-    expect(mockClient.branches.list).toHaveBeenCalledTimes(2)
-  })
-
-  it('syncs branch name to URL', async () => {
-    mockClient.branches.list.mockResolvedValue({
-      ok: true,
-      status: 200,
-      data: { branches: mockBranches },
-    })
-
-    renderHook(() => useBranchManager(defaultOptions), { wrapper })
-
-    await waitFor(() => {
-      expect(window.history.replaceState).toHaveBeenCalled()
-    })
-
-    const calls = (window.history.replaceState as any).mock.calls
-    const urlCall = calls.find((call: any) => call[2].includes('branch='))
-    expect(urlCall).toBeTruthy()
-  })
-
-  it('loads branches on mount', async () => {
-    mockClient.branches.list.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      data: { branches: mockBranches },
-    })
-
-    const { result } = renderHook(() => useBranchManager(defaultOptions), {
-      wrapper,
-    })
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2)
-    })
-
-    // Verify loadBranches was called
-    expect(mockClient.branches.list).toHaveBeenCalled()
-  })
-
-  it('handles error during loadBranches in useEffect', async () => {
-    const { error, restore } = setupMockConsole(['error'])
-    mockClient.branches.list.mockRejectedValueOnce(new Error('Network error'))
-
-    renderHook(() => useBranchManager(defaultOptions), { wrapper })
-
-    await waitFor(() => {
-      expect(error).toHaveBeenCalled()
-    })
-
-    restore()
-  })
-})

package/src/editor/hooks/useBranchManager.tsx

@@ -1,326 +0,0 @@
-import { useEffect, useMemo, useState } from 'react'
-import { Text } from '@mantine/core'
-import { modals } from '@mantine/modals'
-import { notifications } from '@mantine/notifications'
-import type { BranchMetadata } from '../../types'
-import type { OperatingMode } from '../../operating-mode'
-import type { CommentThread } from '../../comment-store'
-import { useApiClient } from '../context'
-
-/**
- * Helper function to show confirmation modal for branch submit action.
- */
-const showSubmitConfirmation = (
-  branchName: string,
-  onConfirm: () => Promise<void>,
-  onCancel: () => void,
-) => {
-  modals.openConfirmModal({
-    title: 'Submit Branch for Review',
-    children: (
-      <Text size="sm" style={{ whiteSpace: 'pre-line' }}>
-        {`Are you sure you want to submit "${branchName}" for review?\n\nThis will:\n• Create a pull request for review\n• Change the branch status to "submitted"\n• Notify reviewers of pending changes`}
-      </Text>
-    ),
-    labels: { confirm: 'Submit Branch', cancel: 'Cancel' },
-    confirmProps: { color: 'brand' },
-    onCancel,
-    onConfirm,
-  })
-}
-
-/**
- * Helper function to show confirmation modal for branch withdraw action.
- */
-const showWithdrawConfirmation = (
-  branchName: string,
-  onConfirm: () => Promise<void>,
-  onCancel: () => void,
-) => {
-  modals.openConfirmModal({
-    title: 'Withdraw Branch from Review',
-    children: (
-      <Text size="sm" style={{ whiteSpace: 'pre-line' }}>
-        {`Are you sure you want to withdraw "${branchName}" from review?\n\nThis will:\n• Convert the pull request to a draft\n• Change the branch status back to "editing"\n• Remove from review queue`}
-      </Text>
-    ),
-    labels: { confirm: 'Withdraw Branch', cancel: 'Cancel' },
-    confirmProps: { color: 'orange' },
-    onCancel,
-    onConfirm,
-  })
-}
-
-/**
- * Branch summary for display in BranchManager component.
- */
-export interface BranchSummary {
-  name: string
-  status: string
-  createdBy?: string
-  updatedAt?: string
-  access: {
-    users: string[] | undefined
-    groups: string[] | undefined
-  }
-  pullRequestUrl?: string
-  pullRequestNumber?: number
-  commentCount: number
-}
-
-export interface UseBranchManagerOptions {
-  /**
-   * Initial branch name.
-   */
-  initialBranch: string
-
-  /**
-   * Operating mode (dev, etc.).
-   */
-  operatingMode: OperatingMode
-
-  /**
-   * Callback to set busy state.
-   */
-  setBusy: (busy: boolean) => void
-
-  /**
-   * Current comments (for computing comment counts per branch).
-   */
-  comments: CommentThread[]
-}
-
-export interface UseBranchManagerReturn {
-  branchName: string
-  setBranchName: (name: string) => void
-  branches: BranchMetadata[]
-  branchSummaries: BranchSummary[]
-  currentBranch: BranchMetadata | undefined
-  branchStatus: string
-  handleSubmit: (branchName: string) => Promise<void>
-  handleWithdraw: (branchName: string) => Promise<void>
-  handleRequestChanges: (branchName: string) => Promise<void>
-  handleDelete: (branchName: string) => Promise<void>
-  handleReloadBranchData: () => Promise<void>
-  loadBranches: () => Promise<void>
-}
-
-/**
- * Custom hook for managing git branches.
- *
- * Handles:
- * - Loading branches from API
- * - Branch switching with unsaved changes confirmation
- * - Creating new branches
- * - Branch workflow (submit, withdraw, request changes)
- * - URL synchronization for branch parameter
- *
- * @example
- * ```tsx
- * const {
- *   branchName,
- *   branches,
- *   currentBranch,
- *   handleBranchChange,
- *   handleCreateBranch,
- *   handleSubmit
- * } = useBranchManager({
- *   initialBranch: 'main',
- *   operatingMode: 'collaboration',
- *   selectedPath,
- *   drafts,
- *   loadedValues,
- *   setDrafts,
- *   setLoadedValues,
- *   setSelectedId,
- *   setEntries,
- *   onEntriesRefresh: refreshEntries,
- *   onCommentsLoad: loadComments,
- *   setBusy
- * })
- * ```
- */
-export function useBranchManager(options: UseBranchManagerOptions): UseBranchManagerReturn {
-  const apiClient = useApiClient()
-  const [branchName, setBranchName] = useState<string>(options.initialBranch)
-  const [branches, setBranches] = useState<BranchMetadata[]>([])
-
-  const currentBranch = branches.find((b) => b.name === branchName)
-  const branchStatus = currentBranch?.status ?? 'editing'
-
-  // Compute branch summaries with comment counts
-  const branchSummaries = useMemo(() => {
-    return branches.map((b) => {
-      const branchComments = b.name === branchName ? options.comments : []
-      const unresolvedCount = branchComments.filter((t) => !t.resolved).length
-      return {
-        name: b.name,
-        status: b.status,
-        createdBy: b.createdBy,
-        updatedAt: b.updatedAt,
-        access: {
-          users: b.access.allowedUsers,
-          groups: b.access.allowedGroups,
-        },
-        pullRequestUrl: b.pullRequestUrl,
-        pullRequestNumber: b.pullRequestNumber,
-        commentCount: unresolvedCount,
-      }
-    })
-  }, [branches, branchName, options.comments])
-
-  const loadBranches = async () => {
-    options.setBusy(true)
-    try {
-      const result = await apiClient.branches.list()
-      if (result.status === 404) {
-        // No branch endpoint available; stay branchless until user selects/creates via other means.
-        setBranches([])
-        return
-      }
-      if (!result.ok) throw new Error(`Failed to load branches: ${result.status}`)
-      const list = result.data?.branches ?? []
-      setBranches(list)
-    } catch (err) {
-      console.error(err)
-      notifications.show({ message: 'Failed to load branches', color: 'red' })
-    } finally {
-      options.setBusy(false)
-    }
-  }
-
-  const handleSubmit = async (branchNameToSubmit: string) => {
-    return new Promise<void>((resolve, reject) => {
-      showSubmitConfirmation(
-        branchNameToSubmit,
-        async () => {
-          options.setBusy(true)
-          try {
-            const result = await apiClient.workflow.submit({
-              branch: branchNameToSubmit,
-            })
-            if (!result.ok) {
-              throw new Error(result.error || 'Failed to submit branch')
-            }
-            notifications.show({
-              message: 'Branch submitted for review',
-              color: 'green',
-            })
-            await loadBranches()
-            resolve()
-          } catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to submit branch'
-            notifications.show({ message, color: 'red' })
-            reject(err)
-          } finally {
-            options.setBusy(false)
-          }
-        },
-        () => reject(new Error('User cancelled submit')),
-      )
-    })
-  }
-
-  const handleWithdraw = async (branchNameToWithdraw: string) => {
-    return new Promise<void>((resolve, reject) => {
-      showWithdrawConfirmation(
-        branchNameToWithdraw,
-        async () => {
-          options.setBusy(true)
-          try {
-            const result = await apiClient.workflow.withdraw({
-              branch: branchNameToWithdraw,
-            })
-            if (!result.ok) {
-              throw new Error(result.error || 'Failed to withdraw branch')
-            }
-            notifications.show({ message: 'Branch withdrawn', color: 'blue' })
-            await loadBranches()
-            resolve()
-          } catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to withdraw branch'
-            notifications.show({ message, color: 'red' })
-            reject(err)
-          } finally {
-            options.setBusy(false)
-          }
-        },
-        () => reject(new Error('User cancelled withdraw')),
-      )
-    })
-  }
-
-  const handleRequestChanges = async (branchNameForChanges: string) => {
-    options.setBusy(true)
-    try {
-      const result = await apiClient.workflow.requestChanges({ branch: branchNameForChanges }, {})
-      if (!result.ok) {
-        throw new Error(result.error || 'Failed to request changes')
-      }
-      notifications.show({ message: 'Changes requested', color: 'orange' })
-      await loadBranches()
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to request changes'
-      notifications.show({ message, color: 'red' })
-    } finally {
-      options.setBusy(false)
-    }
-  }
-
-  const handleDelete = async (branchNameToDelete: string) => {
-    options.setBusy(true)
-    try {
-      const result = await apiClient.branches.delete({
-        branch: branchNameToDelete,
-      })
-      if (!result.ok) {
-        throw new Error(result.error || 'Failed to delete branch')
-      }
-      notifications.show({ message: 'Branch deleted', color: 'green' })
-      await loadBranches()
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to delete branch'
-      notifications.show({ message, color: 'red' })
-    } finally {
-      options.setBusy(false)
-    }
-  }
-
-  const handleReloadBranchData = async () => {
-    await loadBranches()
-  }
-
-  // Load branches on mount and when branchName changes
-
-  useEffect(() => {
-    loadBranches().catch(console.error)
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- loadBranches would cause infinite loop
-  }, [branchName])
-
-  // Sync branch to URL parameter
-  useEffect(() => {
-    if (typeof window === 'undefined') return
-    if (!branchName) return
-    const url = new URL(window.location.href)
-    const current = url.searchParams.get('branch')
-    if (current !== branchName) {
-      url.searchParams.set('branch', branchName)
-      window.history.replaceState({}, '', url.toString())
-    }
-  }, [branchName])
-
-  return {
-    branchName,
-    setBranchName,
-    branches,
-    branchSummaries,
-    currentBranch,
-    branchStatus,
-    handleSubmit,
-    handleWithdraw,
-    handleRequestChanges,
-    handleDelete,
-    handleReloadBranchData,
-    loadBranches,
-  }
-}