canopycms 0.0.0 → 0.0.2

package/src/api/comments.test.ts

@@ -1,285 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-vi.mock('../comment-store', () => ({
-  CommentStore: vi.fn().mockImplementation(() => ({
-    listThreads: vi.fn().mockResolvedValue([
-      {
-        id: 'thread1',
-        comments: [
-          {
-            id: 'c1',
-            text: 'Test comment',
-            userId: 'u1',
-            threadId: 'thread1',
-            timestamp: '2024-01-01',
-          },
-        ],
-        resolved: false,
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-        canopyPath: 'title',
-        authorId: 'u1',
-        createdAt: '2024-01-01',
-      },
-    ]),
-    addComment: vi.fn().mockResolvedValue({ threadId: 'thread1', commentId: 'c1' }),
-    getThread: vi.fn().mockResolvedValue({
-      id: 'thread1',
-      comments: [],
-      resolved: false,
-      type: 'field',
-      entryPath: unsafeAsLogicalPath('posts/hello'),
-      canopyPath: 'title',
-      authorId: 'u1',
-      createdAt: '2024-01-01',
-    }),
-    resolveThread: vi.fn().mockResolvedValue(true),
-  })),
-}))
-
-import { COMMENT_ROUTES } from './comments'
-import { RESERVED_GROUPS } from '../authorization'
-import { createMockApiContext, createMockBranchContext } from '../test-utils'
-import { unsafeAsBranchName, unsafeAsLogicalPath } from '../paths/test-utils'
-
-// Extract handlers for testing
-const listComments = COMMENT_ROUTES.list.handler
-const addComment = COMMENT_ROUTES.add.handler
-const resolveComment = COMMENT_ROUTES.resolve.handler
-
-const baseContext = createMockBranchContext({ branchName: 'feature/x' })
-
-const makeCtx = (allowed = true) =>
-  createMockApiContext({
-    branchContext: baseContext,
-    allowBranchAccess: allowed,
-  })
-
-describe('comments api - listComments', () => {
-  it('returns 404 if branch not found', async () => {
-    const ctx = makeCtx()
-    ctx.getBranchContext = vi.fn().mockResolvedValue(null)
-    const res = await listComments(
-      ctx,
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('missing') },
-    )
-    expect(res.status).toBe(404)
-  })
-
-  it('returns 403 if access forbidden', async () => {
-    const res = await listComments(
-      makeCtx(false),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-    )
-    expect(res.status).toBe(403)
-  })
-
-  it('lists comments when allowed', async () => {
-    const res = await listComments(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-    )
-    expect(res.ok).toBe(true)
-    expect(res.data?.threads).toHaveLength(1)
-  })
-})
-
-describe('comments api - addComment', () => {
-  it('returns 404 if branch not found', async () => {
-    const ctx = makeCtx()
-    ctx.getBranchContext = vi.fn().mockResolvedValue(null)
-    const res = await addComment(
-      ctx,
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('missing') },
-      {
-        text: 'test',
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-        canopyPath: 'title',
-      },
-    )
-    expect(res.status).toBe(404)
-  })
-
-  it('returns 403 if access forbidden', async () => {
-    const res = await addComment(
-      makeCtx(false),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      {
-        text: 'test',
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-        canopyPath: 'title',
-      },
-    )
-    expect(res.status).toBe(403)
-  })
-
-  it('returns 400 if canopyPath missing for field comment', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      {
-        text: 'test',
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-      } as any,
-    )
-    expect(res.status).toBe(400)
-    expect(res.error).toContain('canopyPath required')
-  })
-
-  it('returns 400 if entryPath missing for field comment', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      { text: 'test', type: 'field', canopyPath: 'title' } as any,
-    )
-    expect(res.status).toBe(400)
-    expect(res.error).toContain('entryPath required')
-  })
-
-  it('returns 400 if entryPath missing for entry comment', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      { text: 'test', type: 'entry' } as any,
-    )
-    expect(res.status).toBe(400)
-    expect(res.error).toContain('entryPath required')
-  })
-
-  it('adds field comment when allowed', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      {
-        text: 'Great work!',
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-        canopyPath: 'title',
-      },
-    )
-    expect(res.ok).toBe(true)
-    expect(res.data?.threadId).toBe('thread1')
-    expect(res.data?.commentId).toBe('c1')
-  })
-
-  it('adds entry comment when allowed', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      {
-        text: 'Entry feedback',
-        type: 'entry',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-      },
-    )
-    expect(res.ok).toBe(true)
-  })
-
-  it('adds branch comment when allowed', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      { text: 'Branch discussion', type: 'branch' },
-    )
-    expect(res.ok).toBe(true)
-  })
-
-  it('accepts optional threadId for replies', async () => {
-    const res = await addComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x') },
-      {
-        text: 'Reply comment',
-        threadId: 'existing-thread',
-        type: 'field',
-        entryPath: unsafeAsLogicalPath('posts/hello'),
-        canopyPath: 'title',
-      },
-    )
-    expect(res.ok).toBe(true)
-  })
-})
-
-describe('comments api - resolveComment', () => {
-  it('returns 404 if branch not found', async () => {
-    const ctx = makeCtx()
-    ctx.getBranchContext = vi.fn().mockResolvedValue(null)
-    const res = await resolveComment(
-      ctx,
-      {
-        user: {
-          type: 'authenticated',
-          userId: 'u1',
-          groups: [RESERVED_GROUPS.ADMINS],
-        },
-      },
-      { branch: unsafeAsBranchName('missing'), threadId: 'thread1' },
-    )
-    expect(res.status).toBe(404)
-  })
-
-  it('returns 403 if user is not author, reviewer, or admin', async () => {
-    const res = await resolveComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u2', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x'), threadId: 'thread1' },
-    )
-    expect(res.status).toBe(403)
-    expect(res.error).toContain('thread author, Reviewers, or Admins')
-  })
-
-  it('allows thread author to resolve', async () => {
-    const res = await resolveComment(
-      makeCtx(),
-      { user: { type: 'authenticated', userId: 'u1', groups: [] } },
-      { branch: unsafeAsBranchName('feature/x'), threadId: 'thread1' },
-    )
-    expect(res.ok).toBe(true)
-    expect(res.data?.resolved).toBe(true)
-  })
-
-  it('allows admin to resolve', async () => {
-    const res = await resolveComment(
-      makeCtx(),
-      {
-        user: {
-          type: 'authenticated',
-          userId: 'u2',
-          groups: [RESERVED_GROUPS.ADMINS],
-        },
-      },
-      { branch: unsafeAsBranchName('feature/x'), threadId: 'thread1' },
-    )
-    expect(res.ok).toBe(true)
-  })
-
-  it('allows reviewer to resolve', async () => {
-    const res = await resolveComment(
-      makeCtx(),
-      {
-        user: {
-          type: 'authenticated',
-          userId: 'u2',
-          groups: [RESERVED_GROUPS.REVIEWERS],
-        },
-      },
-      { branch: unsafeAsBranchName('feature/x'), threadId: 'thread1' },
-    )
-    expect(res.ok).toBe(true)
-  })
-})

package/src/api/comments.ts

@@ -1,210 +0,0 @@
-import { z } from 'zod'
-
-import type { ApiContext, ApiRequest, ApiResponse } from './types'
-import type { BranchContext } from '../types'
-import type { CommentThread, CommentType } from '../comment-store'
-import { CommentStore } from '../comment-store'
-import { isReviewer } from '../authorization'
-import { defineEndpoint } from './route-builder'
-import { branchNameSchema, logicalPathSchema } from './validators'
-
-export interface AddCommentBody {
-  text: string
-  threadId?: string
-  type: CommentType
-  entryPath?: string
-  canopyPath?: string
-}
-
-export interface ListCommentsResponse {
-  threads: CommentThread[]
-}
-
-/** Response type for listing comments */
-export type CommentsResponse = ApiResponse<ListCommentsResponse>
-
-/** Response type for adding a comment */
-export type AddCommentResponse = ApiResponse<{
-  threadId: string
-  commentId: string
-}>
-
-/** Response type for resolving a comment */
-export type ResolveCommentResponse = ApiResponse<{ resolved: boolean }>
-
-// ============================================================================
-// Zod Schemas for Validation
-// ============================================================================
-
-const branchParamSchema = z.object({
-  branch: branchNameSchema,
-})
-
-const threadParamSchema = z.object({
-  branch: branchNameSchema,
-  threadId: z.string().min(1),
-})
-
-const addCommentBodySchema = z.object({
-  text: z.string().min(1),
-  threadId: z.string().optional(),
-  type: z.enum(['field', 'entry', 'branch']),
-  entryPath: logicalPathSchema.optional(),
-  canopyPath: z.string().optional(), // Canopy field path, not a file path
-})
-
-const listCommentsHandler = async (
-  gc: { branchContext: BranchContext },
-  _ctx: ApiContext,
-  _req: ApiRequest,
-  _params: z.infer<typeof branchParamSchema>,
-): Promise<CommentsResponse> => {
-  const { branchContext } = gc
-
-  const commentStore = new CommentStore(branchContext.branchRoot)
-  const threads = await commentStore.listThreads({ includeResolved: true })
-
-  return { ok: true, status: 200, data: { threads } }
-}
-
-const addCommentHandler = async (
-  gc: { branchContext: BranchContext },
-  _ctx: ApiContext,
-  req: ApiRequest,
-  _params: z.infer<typeof branchParamSchema>,
-  body: z.infer<typeof addCommentBodySchema>,
-): Promise<AddCommentResponse> => {
-  const { branchContext } = gc
-
-  // Validate required fields based on type
-  if (body.type === 'field' && !body.canopyPath) {
-    return {
-      ok: false,
-      status: 400,
-      error: 'canopyPath required for field comments',
-    }
-  }
-
-  if ((body.type === 'field' || body.type === 'entry') && !body.entryPath) {
-    return {
-      ok: false,
-      status: 400,
-      error: 'entryPath required for field/entry comments',
-    }
-  }
-
-  const commentStore = new CommentStore(branchContext.branchRoot)
-
-  const result = await commentStore.addComment({
-    userId: req.user.userId,
-    text: body.text,
-    threadId: body.threadId,
-    type: body.type,
-    entryPath: body.entryPath,
-    canopyPath: body.canopyPath,
-  })
-
-  return { ok: true, status: 200, data: result }
-}
-
-const resolveCommentHandler = async (
-  gc: { branchContext: BranchContext },
-  _ctx: ApiContext,
-  req: ApiRequest,
-  params: z.infer<typeof threadParamSchema>,
-): Promise<ResolveCommentResponse> => {
-  const { branchContext } = gc
-
-  const commentStore = new CommentStore(branchContext.branchRoot)
-
-  // Get the thread to check permissions
-  const thread = await commentStore.getThread(params.threadId)
-  if (!thread) {
-    return { ok: false, status: 404, error: 'Thread not found' }
-  }
-
-  // Check permissions: thread author, reviewer, or admin
-  const isAuthor = thread.authorId === req.user.userId
-  const userIsReviewer = isReviewer(req.user.groups)
-
-  if (!isAuthor && !userIsReviewer) {
-    return {
-      ok: false,
-      status: 403,
-      error: 'Only thread author, Reviewers, or Admins can resolve comments',
-    }
-  }
-
-  const resolved = await commentStore.resolveThread(params.threadId, req.user.userId)
-  if (!resolved) {
-    return { ok: false, status: 404, error: 'Thread not found' }
-  }
-
-  return { ok: true, status: 200, data: { resolved: true } }
-}
-
-// ============================================================================
-// Route Definitions with defineEndpoint
-// ============================================================================
-
-/**
- * List all comment threads for a branch
- * GET /:branch/comments
- */
-const listComments = defineEndpoint({
-  namespace: 'comments',
-  name: 'list',
-  method: 'GET',
-  path: '/:branch/comments',
-  params: branchParamSchema,
-  responseType: 'CommentsResponse',
-  response: {} as CommentsResponse,
-  defaultMockData: { threads: [] },
-  guards: ['branchAccess'] as const,
-  handler: listCommentsHandler,
-})
-
-/**
- * Add a comment to a thread or create new thread
- * POST /:branch/comments
- */
-const addComment = defineEndpoint({
-  namespace: 'comments',
-  name: 'add',
-  method: 'POST',
-  path: '/:branch/comments',
-  params: branchParamSchema,
-  body: addCommentBodySchema,
-  bodyType: 'AddCommentBody',
-  responseType: 'AddCommentResponse',
-  response: {} as AddCommentResponse,
-  defaultMockData: { threadId: 'mock-thread-id', commentId: 'mock-comment-id' },
-  guards: ['branchAccess'] as const,
-  handler: addCommentHandler,
-})
-
-/**
- * Resolve a comment thread
- * POST /:branch/comments/:threadId/resolve
- */
-const resolveComment = defineEndpoint({
-  namespace: 'comments',
-  name: 'resolve',
-  method: 'POST',
-  path: '/:branch/comments/:threadId/resolve',
-  params: threadParamSchema,
-  responseType: 'ResolveCommentResponse',
-  response: {} as ResolveCommentResponse,
-  defaultMockData: { resolved: true },
-  guards: ['branchAccess'] as const,
-  handler: resolveCommentHandler,
-})
-
-/**
- * Exported routes for router registration
- */
-export const COMMENT_ROUTES = {
-  list: listComments,
-  add: addComment,
-  resolve: resolveComment,
-} as const