canopycms-next 0.0.0 → 0.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopycms-next",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Next.js adapter for CanopyCMS",
   "license": "MIT",
   "repository": {
@@ -17,8 +17,7 @@
     "./client": "./src/client.tsx"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "exports": {
@@ -41,8 +40,8 @@
     "node": ">=18"
   },
   "peerDependencies": {
-    "canopycms": "*",
-    "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
+    "canopycms": "^0.0.1",
+    "next": "^0.0.1",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {

package/src/adapter.test.ts

@@ -1,194 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-// Mock next/server before any imports
-vi.mock('next/server', () => {
-  return {
-    NextResponse: {
-      json: (body: any, init?: any) => ({
-        body,
-        status: init?.status ?? 200,
-        headers: init?.headers,
-      }),
-    },
-  }
-})
-
-// Mock canopycms/http to return a controlled response
-vi.mock('canopycms/http', async () => {
-  return {
-    createCanopyRequestHandler: vi.fn(() => {
-      return async (req: any, segments: string[]) => {
-        // Return different responses based on segments
-        if (segments.length === 1 && segments[0] === 'branches') {
-          return {
-            status: 200,
-            body: { ok: true, status: 200, data: { branches: [] } },
-          }
-        }
-        if (segments.length === 0 || segments.includes('unknown')) {
-          return {
-            status: 404,
-            body: { ok: false, status: 404, error: 'Not found' },
-          }
-        }
-        return {
-          status: 200,
-          body: { ok: true, status: 200 },
-        }
-      }
-    }),
-  }
-})
-
-import { createCanopyCatchAllHandler } from './adapter'
-import { createMockAuthPlugin } from './test-utils'
-
-describe('Next.js adapter', () => {
-  const mockAuthPlugin = createMockAuthPlugin({
-    userId: 'test-user',
-    groups: ['Admins'],
-  })
-
-  describe('createCanopyCatchAllHandler', () => {
-    it('converts NextRequest to CanopyRequest and returns NextResponse', async () => {
-      const handler = createCanopyCatchAllHandler({
-        services: {} as any,
-        authPlugin: mockAuthPlugin,
-      })
-
-      const mockNextRequest = {
-        method: 'GET',
-        url: 'http://localhost:3000/api/canopycms/branches',
-        headers: { get: () => null },
-        json: async () => undefined,
-      } as any
-
-      const response: any = await handler(mockNextRequest, {
-        params: { canopycms: ['branches'] },
-      })
-
-      expect(response.status).toBe(200)
-      expect(response.body).toHaveProperty('ok', true)
-    })
-
-    it('handles Next.js 14 direct params object', async () => {
-      const handler = createCanopyCatchAllHandler({
-        services: {} as any,
-        authPlugin: mockAuthPlugin,
-      })
-
-      const mockNextRequest = {
-        method: 'GET',
-        url: 'http://localhost:3000/api/canopycms/branches',
-        headers: { get: () => null },
-        json: async () => undefined,
-      } as any
-
-      // Next.js 14 style - params is a direct object
-      const response: any = await handler(mockNextRequest, {
-        params: { canopycms: ['branches'] },
-      })
-
-      expect(response.status).toBe(200)
-    })
-
-    it('handles Next.js 15 async params Promise', async () => {
-      const handler = createCanopyCatchAllHandler({
-        services: {} as any,
-        authPlugin: mockAuthPlugin,
-      })
-
-      const mockNextRequest = {
-        method: 'GET',
-        url: 'http://localhost:3000/api/canopycms/branches',
-        headers: { get: () => null },
-        json: async () => undefined,
-      } as any
-
-      // Next.js 15 style - params is a Promise
-      const response: any = await handler(mockNextRequest, {
-        params: Promise.resolve({ canopycms: ['branches'] }),
-      })
-
-      expect(response.status).toBe(200)
-    })
-
-    it('handles missing params gracefully', async () => {
-      const handler = createCanopyCatchAllHandler({
-        services: {} as any,
-        authPlugin: mockAuthPlugin,
-      })
-
-      const mockNextRequest = {
-        method: 'GET',
-        url: 'http://localhost:3000/api/canopycms',
-        headers: { get: () => null },
-        json: async () => undefined,
-      } as any
-
-      // No params at all
-      const response: any = await handler(mockNextRequest, undefined)
-
-      expect(response.status).toBe(404)
-    })
-  })
-})
-
-describe('wrapNextRequest', () => {
-  it('wraps NextRequest correctly', async () => {
-    const { wrapNextRequest } = await import('./adapter')
-
-    const mockReq = {
-      method: 'POST',
-      url: 'http://localhost:3000/api/canopycms/branches',
-      headers: {
-        get: (name: string) =>
-          name.toLowerCase() === 'authorization' ? 'Bearer test-token' : null,
-      },
-      json: async () => ({ name: 'test-branch' }),
-    } as any
-
-    const wrapped = wrapNextRequest(mockReq)
-
-    expect(wrapped.method).toBe('POST')
-    expect(wrapped.url).toBe('http://localhost:3000/api/canopycms/branches')
-    expect(wrapped.header('Authorization')).toBe('Bearer test-token')
-    expect(await wrapped.json()).toEqual({ name: 'test-branch' })
-  })
-
-  it('returns null for missing headers', async () => {
-    const { wrapNextRequest } = await import('./adapter')
-
-    const mockReq = {
-      method: 'GET',
-      url: 'http://localhost:3000/api/test',
-      headers: {
-        get: () => null,
-      },
-      json: async () => undefined,
-    } as any
-
-    const wrapped = wrapNextRequest(mockReq)
-
-    expect(wrapped.header('X-Custom-Header')).toBeNull()
-  })
-
-  it('returns undefined for GET request body', async () => {
-    const { wrapNextRequest } = await import('./adapter')
-
-    const mockReq = {
-      method: 'GET',
-      url: 'http://localhost:3000/api/test',
-      headers: {
-        get: () => null,
-      },
-      json: async () => {
-        throw new Error('No body')
-      },
-    } as any
-
-    const wrapped = wrapNextRequest(mockReq)
-
-    expect(await wrapped.json()).toBeUndefined()
-  })
-})

package/src/adapter.ts

@@ -1,105 +0,0 @@
-import type { NextRequest } from 'next/server'
-import { NextResponse } from 'next/server'
-
-import {
-  createCanopyRequestHandler,
-  type CanopyHandlerOptions,
-  type CanopyRequest,
-  type CanopyResponse,
-} from 'canopycms/http'
-
-/**
- * Options for creating a Canopy Next.js handler.
- * Same as core CanopyHandlerOptions - re-exported for convenience.
- */
-export interface CanopyNextOptions extends CanopyHandlerOptions {}
-
-/**
- * Wrap a Next.js request to implement the CanopyRequest interface.
- */
-export function wrapNextRequest(req: NextRequest): CanopyRequest {
-  return {
-    method: req.method,
-    url: req.url,
-
-    header(name: string): string | null {
-      return req.headers.get(name)
-    },
-
-    async json(): Promise<unknown> {
-      if (req.method === 'GET') return undefined
-      try {
-        return await req.json()
-      } catch {
-        return undefined
-      }
-    },
-  }
-}
-
-/**
- * Convert a CanopyResponse to a NextResponse.
- */
-function toNextResponse(response: CanopyResponse<unknown>): ReturnType<typeof NextResponse.json> {
-  return NextResponse.json(response.body, {
-    status: response.status,
-    headers: response.headers,
-  })
-}
-
-/**
- * Extract path segments from Next.js catch-all route params.
- * Handles both Next.js 14 (direct object) and Next.js 15 (Promise) params.
- */
-async function extractPathSegments(ctx?: {
-  params?: Promise<{ canopycms?: string[] }> | { canopycms?: string[] }
-}): Promise<string[]> {
-  if (!ctx?.params) return []
-  const resolvedParams = ctx.params instanceof Promise ? await ctx.params : ctx.params
-  return (resolvedParams?.canopycms ?? []).filter(Boolean)
-}
-
-/**
- * Catch-all Next.js handler for a single API route (e.g., /api/canopycms/[...canopycms]).
- *
- * This is a thin adapter that:
- * 1. Converts NextRequest to CanopyRequest
- * 2. Extracts path segments from Next.js params
- * 3. Delegates to the core handler
- * 4. Converts CanopyResponse to NextResponse
- *
- * @example
- * ```ts
- * // app/api/canopycms/[...canopycms]/route.ts
- * import { createCanopyCatchAllHandler } from 'canopycms-next'
- * import { createClerkAuthPlugin } from 'canopycms-auth-clerk'
- * import config from '../../../../canopycms.config'
- *
- * const handler = createCanopyCatchAllHandler({
- *   config: config.server,
- *   authPlugin: createClerkAuthPlugin({ useOrganizationsAsGroups: true }),
- * })
- *
- * export const GET = handler
- * export const POST = handler
- * export const PUT = handler
- * export const DELETE = handler
- * ```
- */
-export const createCanopyCatchAllHandler = (options: CanopyNextOptions) => {
-  const coreHandler = createCanopyRequestHandler(options)
-
-  return async (
-    req: NextRequest,
-    ctx?: {
-      params?:
-        | Promise<{ canopycms?: string[]; [key: string]: any }>
-        | { canopycms?: string[]; [key: string]: any }
-    },
-  ) => {
-    const canopyReq = wrapNextRequest(req)
-    const segments = await extractPathSegments(ctx)
-    const response = await coreHandler(canopyReq, segments)
-    return toNextResponse(response)
-  }
-}

package/src/client.tsx

@@ -1,36 +0,0 @@
-'use client'
-
-import { useSearchParams } from 'next/navigation'
-import { CanopyEditorPage } from 'canopycms/client'
-import type { CanopyClientConfig } from 'canopycms/client'
-
-/**
- * Next.js-specific wrapper for CanopyEditorPage that automatically reads
- * URL search params (branch, entry) using Next.js's useSearchParams hook.
- *
- * @example
- * ```tsx
- * // app/edit/page.tsx
- * 'use client'
- * import { NextCanopyEditorPage } from 'canopycms-next/client'
- * import config from '../../canopycms.config'
- *
- * export default function EditPage() {
- *   const clientConfig = config.client()
- *   const EditorPage = NextCanopyEditorPage(clientConfig)
- *   return <EditorPage />
- * }
- * ```
- */
-export const NextCanopyEditorPage = (config: CanopyClientConfig) => {
-  const CorePage = CanopyEditorPage(config)
-
-  return function NextEditorPage() {
-    const urlSearchParams = useSearchParams()
-    const searchParams = {
-      branch: urlSearchParams.get('branch') ?? undefined,
-      entry: urlSearchParams.get('entry') ?? undefined,
-    }
-    return <CorePage searchParams={searchParams} />
-  }
-}

package/src/context-wrapper.ts

@@ -1,87 +0,0 @@
-import { cache } from 'react'
-import { headers } from 'next/headers'
-import { createCanopyContext, type CanopyContext, createCanopyServices } from 'canopycms/server'
-import type { CanopyConfig, AuthPlugin, CanopyUser, FieldConfig } from 'canopycms'
-import { authResultToCanopyUser } from 'canopycms'
-import { loadInternalGroups, loadBranchContext } from 'canopycms/server'
-import type { InternalGroup } from 'canopycms/server'
-import { createCanopyCatchAllHandler } from './adapter'
-
-let warnedNoAdmins = false
-
-export interface NextCanopyOptions {
-  config: CanopyConfig
-  authPlugin: AuthPlugin
-  entrySchemaRegistry: Record<string, readonly FieldConfig[]>
-}
-
-/**
- * Create Next.js-specific wrapper around core context.
- * Adds React cache() for per-request memoization and API handler.
- * This function is async because it needs to load .collection.json meta files.
- */
-export async function createNextCanopyContext(options: NextCanopyOptions) {
-  // Create services ONCE at initialization
-  const services = await createCanopyServices(options.config, {
-    entrySchemaRegistry: options.entrySchemaRegistry,
-  })
-
-  // User extractor: passes Next.js headers to auth plugin, loads internal groups, applies authorization
-  const extractUser = async (): Promise<CanopyUser> => {
-    const headersList = await headers()
-    const authResult = await options.authPlugin.authenticate(headersList)
-
-    // Load internal groups from main branch
-    const baseBranch = services.config.defaultBaseBranch ?? 'main'
-    const operatingMode = services.config.mode ?? 'dev'
-    const mainBranchContext = await loadBranchContext({
-      branchName: baseBranch,
-      mode: operatingMode,
-    })
-    const internalGroups: InternalGroup[] = mainBranchContext
-      ? await loadInternalGroups(
-          mainBranchContext.branchRoot,
-          operatingMode,
-          services.bootstrapAdminIds,
-        ).catch((err: unknown) => {
-          console.warn('CanopyCMS: Failed to load internal groups from main branch:', err)
-          return [] as InternalGroup[]
-        })
-      : []
-
-    if (!warnedNoAdmins && Array.isArray(internalGroups)) {
-      const adminsGroup = internalGroups.find((g) => g.id === 'Admins')
-      if (!adminsGroup || adminsGroup.members.length === 0) {
-        console.warn(
-          'CanopyCMS: No admin users configured. Set CANOPY_BOOTSTRAP_ADMIN_IDS or add members to the Admins group.',
-        )
-      }
-      warnedNoAdmins = true
-    }
-
-    return authResultToCanopyUser(authResult, services.bootstrapAdminIds, internalGroups)
-  }
-
-  // Create core context with pre-created services (framework-agnostic)
-  const coreContext = createCanopyContext({
-    services,
-    extractUser,
-  })
-
-  // Wrap with React cache() for per-request caching
-  const getCanopy = cache((): Promise<CanopyContext> => {
-    return coreContext.getContext()
-  })
-
-  // Create API handler using same services
-  const handler = createCanopyCatchAllHandler({
-    ...options,
-    services,
-  })
-
-  return {
-    getCanopy,
-    handler,
-    services,
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export { createCanopyCatchAllHandler, wrapNextRequest, type CanopyNextOptions } from './adapter'
-
-export { createNextCanopyContext, type NextCanopyOptions } from './context-wrapper'
-
-export { createMockAuthPlugin, createRejectingAuthPlugin } from './test-utils'

package/src/test-utils.ts

@@ -1,42 +0,0 @@
-import type { AuthPlugin } from 'canopycms/auth'
-import type { AuthenticatedUser } from 'canopycms'
-
-const ADMINS = 'Admins'
-
-/**
- * Create a mock AuthPlugin for testing.
- * Returns a valid user by default (as Admin), or can be configured to return specific users.
- */
-export const createMockAuthPlugin = (
-  user: AuthenticatedUser = {
-    type: 'authenticated',
-    userId: 'test-user',
-    groups: [ADMINS],
-  },
-): AuthPlugin => ({
-  authenticate: async () => ({
-    success: true,
-    user: {
-      userId: user.userId,
-      email: user.email,
-      name: user.name,
-      avatarUrl: user.avatarUrl,
-      externalGroups: user.groups,
-    },
-  }),
-  searchUsers: async () => [],
-  getUserMetadata: async () => null,
-  getGroupMetadata: async () => null,
-  listGroups: async () => [],
-})
-
-/**
- * Create a mock AuthPlugin that rejects all authentication.
- */
-export const createRejectingAuthPlugin = (error = 'Unauthorized'): AuthPlugin => ({
-  authenticate: async () => ({ success: false, error }),
-  searchUsers: async () => [],
-  getUserMetadata: async () => null,
-  getGroupMetadata: async () => null,
-  listGroups: async () => [],
-})