canopycms 0.0.0

package/src/editor/theme.tsx

@@ -0,0 +1,119 @@
+'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

@@ -0,0 +1,39 @@
+/**
+ * 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

@@ -0,0 +1,281 @@
+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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,84 @@
+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>