canopycms 0.0.0 → 0.0.2

package/src/editor/theme.tsx

@@ -1,119 +0,0 @@
-'use client'
-
-import React, { useMemo } from 'react'
-
-import {
-  DEFAULT_THEME,
-  MantineProvider,
-  type MantineColorScheme,
-  type MantineColorsTuple,
-  type MantineThemeOverride,
-  createTheme,
-} from '@mantine/core'
-import { Notifications } from '@mantine/notifications'
-import { ModalsProvider } from '@mantine/modals'
-import { generateColors } from '@mantine/colors-generator'
-
-import '@mantine/core/styles.css'
-import '@mantine/notifications/styles.css'
-import '@mdxeditor/editor/style.css'
-
-export type CanopyColorInput = MantineColorsTuple | string
-
-export interface CanopyColorConfig {
-  brand?: CanopyColorInput
-  primary?: CanopyColorInput
-  neutral?: CanopyColorInput
-  accent?: CanopyColorInput
-}
-
-export interface CanopyThemeOptions {
-  colors?: CanopyColorConfig
-  colorScheme?: MantineColorScheme
-  themeOverride?: MantineThemeOverride
-  withNotifications?: boolean
-}
-
-const defaultCanopyColors: Required<CanopyColorConfig> = {
-  brand: '#3b82f6',
-  primary: '#2563eb',
-  neutral: '#1f2937',
-  accent: '#f59e0b',
-}
-
-export const CANOPY_DEFAULT_COLORS = defaultCanopyColors
-
-const toScale = (
-  input: CanopyColorInput | undefined,
-  fallbackKey: keyof typeof DEFAULT_THEME.colors,
-  fallback: CanopyColorInput,
-) => {
-  const fallbackScale =
-    DEFAULT_THEME.colors[fallbackKey] ??
-    (Array.isArray(fallback) && fallback.length === 10
-      ? (fallback as MantineColorsTuple)
-      : generateColors(String(fallback)))
-  if (!input) return fallbackScale
-  if (Array.isArray(input) && input.length === 10) return input as MantineColorsTuple
-
-  if (typeof input === 'string') {
-    const fromTheme = DEFAULT_THEME.colors[input as keyof typeof DEFAULT_THEME.colors]
-    if (fromTheme) return fromTheme
-    try {
-      return generateColors(input)
-    } catch {
-      return fallbackScale
-    }
-  }
-
-  return fallbackScale
-}
-
-export const createCanopyTheme = (
-  options?: Pick<CanopyThemeOptions, 'colors' | 'themeOverride'>,
-) => {
-  const { colors, themeOverride } = options ?? {}
-  const brand = toScale(colors?.brand, 'indigo', defaultCanopyColors.brand)
-  const primary = toScale(colors?.primary ?? colors?.brand, 'blue', defaultCanopyColors.primary)
-  const neutral = toScale(colors?.neutral, 'gray', defaultCanopyColors.neutral)
-  const accent = toScale(colors?.accent, 'teal', defaultCanopyColors.accent)
-
-  return createTheme({
-    primaryColor: 'brand',
-    primaryShade: { light: 6, dark: 5 },
-    defaultRadius: 'md',
-    colors: {
-      ...DEFAULT_THEME.colors,
-      brand,
-      primary,
-      neutral,
-      accent,
-      ...(themeOverride?.colors ?? {}),
-    },
-    fontFamily: 'Inter, -apple-system, BlinkMacSystemFont, Segoe UI, sans-serif',
-    ...themeOverride,
-  })
-}
-
-export interface CanopyCMSProviderProps extends CanopyThemeOptions {
-  children: React.ReactNode
-}
-
-export const CanopyCMSProvider: React.FC<CanopyCMSProviderProps> = ({
-  children,
-  colors,
-  colorScheme = 'light',
-  themeOverride,
-  withNotifications = true,
-}) => {
-  const theme = useMemo(() => createCanopyTheme({ colors, themeOverride }), [colors, themeOverride])
-
-  return (
-    <MantineProvider theme={theme} defaultColorScheme={colorScheme}>
-      <ModalsProvider>
-        {withNotifications ? <Notifications position="bottom-left" /> : null}
-        {children}
-      </ModalsProvider>
-    </MantineProvider>
-  )
-}

package/src/editor/utils/env.ts

@@ -1,39 +0,0 @@
-/**
- * Detect if we're running in a test environment.
- * Playwright and other E2E frameworks often set specific globals.
- */
-export function isTestEnvironment(): boolean {
-  if (typeof window === 'undefined') return false
-
-  // Check for common E2E testing indicators
-  return (
-    // Playwright sets window.playwright
-    'playwright' in window ||
-    // Cypress sets window.Cypress
-    'Cypress' in window ||
-    // Check if running in test mode via env variable (set by test runner)
-    (window as unknown as Record<string, unknown>).__E2E_TEST__ === true ||
-    // Some test frameworks set navigator.webdriver
-    navigator.webdriver === true
-  )
-}
-
-/**
- * Get notification duration based on environment.
- * Tests get longer durations to be more reliable.
- *
- * @param defaultMs - Default duration in milliseconds for production (default: 4000)
- * @returns Duration in milliseconds (15000ms for tests, defaultMs for production)
- *
- * @example
- * ```typescript
- * notifications.show({
- *   message: 'Saved',
- *   color: 'green',
- *   autoClose: getNotificationDuration(4000),  // 4s in production, 15s in tests
- * })
- * ```
- */
-export function getNotificationDuration(defaultMs = 4000): number {
-  return isTestEnvironment() ? 15000 : defaultMs
-}

package/src/entry-schema-registry.test.ts

@@ -1,281 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdir, writeFile, rm } from 'fs/promises'
-import { join } from 'pathe'
-import { createEntrySchemaRegistry, validateEntrySchemaRegistry } from './entry-schema-registry'
-
-describe('createEntrySchemaRegistry', () => {
-  it('accepts valid schema registry', () => {
-    const registry = createEntrySchemaRegistry({
-      postSchema: [{ type: 'string', name: 'title', label: 'Title', required: true }],
-      authorSchema: [{ type: 'string', name: 'name', label: 'Name', required: true }],
-    })
-
-    expect(registry).toBeDefined()
-    expect(Object.keys(registry)).toEqual(['postSchema', 'authorSchema'])
-  })
-
-  it('throws error for non-object registry', () => {
-    expect(() => createEntrySchemaRegistry(null as any)).toThrow(
-      'Entry schema registry must be an object',
-    )
-    expect(() => createEntrySchemaRegistry(undefined as any)).toThrow(
-      'Entry schema registry must be an object',
-    )
-    expect(() => createEntrySchemaRegistry('invalid' as any)).toThrow(
-      'Entry schema registry must be an object',
-    )
-  })
-
-  it('throws error for empty registry', () => {
-    expect(() => createEntrySchemaRegistry({})).toThrow('Entry schema registry cannot be empty')
-  })
-
-  it('throws error for non-array schema', () => {
-    expect(() =>
-      createEntrySchemaRegistry({
-        postSchema: 'not an array' as any,
-      }),
-    ).toThrow('Entry schema registry entry "postSchema" must be an array of FieldConfig')
-  })
-
-  it('throws error for empty schema array', () => {
-    expect(() =>
-      createEntrySchemaRegistry({
-        postSchema: [],
-      }),
-    ).toThrow('Entry schema registry entry "postSchema" cannot be empty')
-  })
-})
-
-describe('validateEntrySchemaRegistry', () => {
-  const testDir = join(process.cwd(), '.test-content-validate')
-
-  beforeEach(async () => {
-    await mkdir(testDir, { recursive: true })
-  })
-
-  afterEach(async () => {
-    await rm(testDir, { recursive: true, force: true })
-  })
-
-  it('validates registry with matching schema references', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    // Create a collection that references postSchema
-    await mkdir(join(testDir, 'posts'), { recursive: true })
-    await writeFile(
-      join(testDir, 'posts', '.collection.json'),
-      JSON.stringify({
-        name: 'posts',
-        entries: [
-          {
-            name: 'post',
-            format: 'mdx',
-            schema: 'postSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).resolves.toBeUndefined()
-  })
-
-  it('throws error for missing schema reference in collection', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    // Create a collection that references non-existent schema
-    await mkdir(join(testDir, 'posts'), { recursive: true })
-    await writeFile(
-      join(testDir, 'posts', '.collection.json'),
-      JSON.stringify({
-        name: 'posts',
-        entries: [
-          {
-            name: 'post',
-            format: 'mdx',
-            schema: 'authorSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).rejects.toThrow(
-      /Entry type "post" in collection "posts".*references entry schema "authorSchema".*does not exist/,
-    )
-    await expect(validateEntrySchemaRegistry(registry, testDir)).rejects.toThrow(
-      /Available: postSchema/,
-    )
-  })
-
-  it('throws error for missing schema reference in root entry type', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    // Create root collection with entry type referencing non-existent schema
-    await writeFile(
-      join(testDir, '.collection.json'),
-      JSON.stringify({
-        entries: [
-          {
-            name: 'home',
-            format: 'json',
-            schema: 'homeSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).rejects.toThrow(
-      /Root entry type "home".*references entry schema "homeSchema".*does not exist/,
-    )
-  })
-
-  it('throws error for missing schema reference in collection entry type', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    // Create collection with entry type referencing non-existent schema
-    await mkdir(join(testDir, 'docs'), { recursive: true })
-    await writeFile(
-      join(testDir, 'docs', '.collection.json'),
-      JSON.stringify({
-        name: 'docs',
-        entries: [
-          {
-            name: 'doc',
-            format: 'json',
-            schema: 'configSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).rejects.toThrow(
-      /Entry type "doc" in collection "docs".*references entry schema "configSchema".*does not exist/,
-    )
-  })
-
-  it('validates nested collections correctly', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-      docSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    // Create nested collections
-    await mkdir(join(testDir, 'docs', 'api'), { recursive: true })
-    await writeFile(
-      join(testDir, 'docs', '.collection.json'),
-      JSON.stringify({
-        name: 'docs',
-        entries: [
-          {
-            name: 'doc',
-            format: 'mdx',
-            schema: 'docSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-    await writeFile(
-      join(testDir, 'docs', 'api', '.collection.json'),
-      JSON.stringify({
-        name: 'api',
-        entries: [
-          {
-            name: 'doc',
-            format: 'mdx',
-            schema: 'docSchema',
-          },
-        ],
-        order: [],
-      }),
-    )
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).resolves.toBeUndefined()
-  })
-
-  it('throws error for non-existent content directory', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    await expect(validateEntrySchemaRegistry(registry, '/nonexistent')).rejects.toThrow(
-      /Content directory not found/,
-    )
-  })
-
-  it('validates with no .collection.json files (empty content dir)', async () => {
-    const registry = {
-      postSchema: [
-        {
-          type: 'string' as const,
-          name: 'title',
-          label: 'Title',
-          required: true,
-        },
-      ],
-    }
-
-    await expect(validateEntrySchemaRegistry(registry, testDir)).resolves.toBeUndefined()
-  })
-})

package/src/entry-schema-registry.ts

@@ -1,121 +0,0 @@
-import type { EntrySchema } from './config'
-import type { EntrySchemaRegistry } from './schema/types'
-
-/**
- * Creates a type-safe entry schema registry with runtime validation.
- *
- * Maps entry schema names to their field definitions. These names are
- * referenced by `.collection.json` files via the `"schema"` property.
- *
- * @example
- * ```typescript
- * import { createEntrySchemaRegistry } from 'canopycms/server'
- *
- * export const entrySchemaRegistry = createEntrySchemaRegistry({
- *   postSchema: [
- *     { type: 'string', name: 'title', label: 'Title', required: true },
- *     { type: 'markdown', name: 'body', label: 'Body' },
- *   ],
- *   authorSchema: [
- *     { type: 'string', name: 'name', label: 'Name', required: true },
- *   ],
- * })
- * ```
- */
-export function createEntrySchemaRegistry<T extends Record<string, EntrySchema>>(registry: T): T {
-  // Validate that registry is not empty
-  if (!registry || typeof registry !== 'object') {
-    throw new Error('Entry schema registry must be an object')
-  }
-
-  const keys = Object.keys(registry)
-  if (keys.length === 0) {
-    throw new Error('Entry schema registry cannot be empty')
-  }
-
-  // Validate each entry schema
-  for (const [key, schema] of Object.entries(registry)) {
-    if (!Array.isArray(schema)) {
-      throw new Error(`Entry schema registry entry "${key}" must be an array of FieldConfig`)
-    }
-    if (schema.length === 0) {
-      throw new Error(`Entry schema registry entry "${key}" cannot be empty`)
-    }
-  }
-
-  return registry
-}
-
-/**
- * Validates that entry schema references in .collection.json files exist in the registry.
- *
- * Useful for build-time validation to catch schema reference errors early
- * rather than at runtime on first request.
- *
- * @param entrySchemaRegistry - The entry schema registry mapping names to field definitions
- * @param contentPath - Path to the content directory containing .collection.json files
- * @returns Promise that resolves if validation passes, rejects with descriptive error if not
- *
- * @example
- * ```typescript
- * import { validateEntrySchemaRegistry } from 'canopycms/server'
- * import { entrySchemaRegistry } from './schemas'
- *
- * await validateEntrySchemaRegistry(entrySchemaRegistry, './content')
- * ```
- */
-export async function validateEntrySchemaRegistry(
-  entrySchemaRegistry: EntrySchemaRegistry,
-  contentPath: string,
-): Promise<void> {
-  const { loadCollectionMetaFiles } = await import('./schema')
-  const { access } = await import('fs/promises')
-
-  // Check if content directory exists
-  try {
-    await access(contentPath)
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error(`Content directory not found: ${contentPath}`)
-    }
-    throw err
-  }
-
-  // Load all .collection.json files
-  const metaFiles = await loadCollectionMetaFiles(contentPath)
-
-  const availableSchemas = Object.keys(entrySchemaRegistry)
-  const errors: string[] = []
-
-  // Validate root entry type references
-  if (metaFiles.root?.entries) {
-    for (const entryType of metaFiles.root.entries) {
-      if (!entrySchemaRegistry[entryType.schema]) {
-        errors.push(
-          `Root entry type "${entryType.name}" references entry schema "${entryType.schema}" which does not exist in registry. ` +
-            `Available: ${availableSchemas.join(', ')}`,
-        )
-      }
-    }
-  }
-
-  // Validate collection entry type references
-  for (const collection of metaFiles.collections) {
-    if (collection.entries) {
-      for (const entryType of collection.entries) {
-        if (!entrySchemaRegistry[entryType.schema]) {
-          errors.push(
-            `Entry type "${entryType.name}" in collection "${collection.name}" (${collection.path}) references entry schema "${entryType.schema}" which does not exist in registry. ` +
-              `Available: ${availableSchemas.join(', ')}`,
-          )
-        }
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    throw new Error(
-      `Entry schema registry validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`,
-    )
-  }
-}

package/src/entry-schema.ts

@@ -1,84 +0,0 @@
-type InferableField = {
-  name: string
-  type: string
-  required?: boolean
-  list?: boolean
-  fields?: readonly InferableField[]
-  templates?: ReadonlyArray<{ name: string; fields: readonly InferableField[] }>
-}
-
-type RequiredValue<F extends InferableField, V> = F['required'] extends false ? V | undefined : V
-
-type ScalarValue<F extends InferableField, V> = RequiredValue<F, F['list'] extends true ? V[] : V>
-
-type ObjectValue<F extends InferableField & { fields: readonly InferableField[] }> = RequiredValue<
-  F,
-  F['list'] extends true ? Array<InferContentShape<F['fields']>> : InferContentShape<F['fields']>
->
-
-type BlockValue<
-  F extends InferableField & {
-    templates: ReadonlyArray<{
-      name: string
-      fields: readonly InferableField[]
-    }>
-  },
-> = RequiredValue<
-  F,
-  Array<
-    F['templates'][number] extends { name: infer N; fields: infer Fields }
-      ? {
-          template: N & string
-          value: InferContentShape<Extract<Fields, readonly InferableField[]>>
-        }
-      : never
-  >
->
-
-type FieldValue<F extends InferableField> = F extends {
-  type: 'object'
-  fields: infer Fields
-}
-  ? ObjectValue<F & { fields: Extract<Fields, readonly InferableField[]> }>
-  : F extends { type: 'block'; templates: infer Templates }
-    ? BlockValue<
-        F & {
-          templates: NonNullable<
-            Extract<Templates, ReadonlyArray<{ name: string; fields: readonly InferableField[] }>>
-          >
-        }
-      >
-    : F extends { type: 'select' }
-      ? ScalarValue<F, string | number>
-      : F extends { type: 'reference' }
-        ? ScalarValue<F, Record<string, unknown> | null>
-        : F extends { type: 'boolean' }
-          ? ScalarValue<F, boolean>
-          : F extends { type: 'number' }
-            ? ScalarValue<F, number>
-            : F extends { type: 'date' }
-              ? ScalarValue<F, string>
-              : ScalarValue<F, string>
-
-/**
- * Infer a TypeScript data shape from a CanopyCMS FieldConfig-like array.
- * - Objects become nested objects
- * - Blocks become arrays of tagged templates with their value shapes
- * - Lists become arrays of the scalar/object type
- * - Non-required fields include `undefined`
- *
- * Works with any structurally compatible array; importing FieldConfig is not required.
- */
-type InferContentShape<Fields extends readonly InferableField[]> = {
-  [F in Fields[number] as F['name']]: FieldValue<F>
-}
-
-/**
- * Helper to define entry schema field arrays with literal inference without sprinkling `as const`.
- */
-export const defineEntrySchema = <const T extends readonly InferableField[]>(fields: T): T => fields
-
-/**
- * Convenience alias to derive the content shape from a `defineEntrySchema` result.
- */
-export type TypeFromEntrySchema<T extends readonly InferableField[]> = InferContentShape<T>