canopycms 0.0.0 → 0.0.2

package/src/schema/meta-loader.ts

@@ -1,366 +0,0 @@
-import { promises as fs } from 'fs'
-import { join } from 'pathe'
-import { z } from 'zod'
-import chokidar from 'chokidar'
-
-import type {
-  ContentFormat,
-  CollectionConfig,
-  RootCollectionConfig,
-  EntryTypeConfig,
-} from '../config'
-import type { ContentId } from '../paths/types'
-import type { EntrySchemaRegistry } from './types'
-import { extractSlugFromFilename, extractIdFromFilename } from '../content-id-index'
-
-/**
- * Zod schema for entry type metadata in .collection.json files.
- * Each entry type has a name, format, and schema reference to the entry schema registry.
- */
-const entryTypeMetaSchema = z.object({
-  name: z.string().min(1),
-  format: z.enum(['md', 'mdx', 'json']),
-  schema: z.string().min(1), // Entry schema registry key (validated at resolution time)
-  label: z.string().optional(),
-  default: z.boolean().optional(),
-  maxItems: z.number().int().positive().optional(),
-})
-
-/**
- * Zod schema for .collection.json files
- *
- * A collection folder can contain:
- * - entries: Array of entry types with their own schemas
- * - collections: Nested collections (discovered via their own .collection.json files)
- *
- * Note: We can't validate `schema` against entry schema registry keys at parse time because:
- * 1. Entry schema registry is passed at runtime (not available during Zod schema definition)
- * 2. Would create circular dependency (loader → services → config → loader)
- *
- * Validation of schema references happens in resolution functions with clear error messages.
- */
-const collectionMetaSchema = z
-  .object({
-    name: z.string().min(1),
-    label: z.string().optional(),
-    entries: z.array(entryTypeMetaSchema).optional(),
-    order: z.array(z.string()), // Embedded IDs for ordering items (required)
-  })
-  .refine((data) => data.entries && data.entries.length > 0, {
-    message: 'Collection must have at least one entry type',
-  })
-
-/**
- * Zod schema for root .collection.json file (content/.collection.json)
- * Like other collections but no name/path (derived from contentRoot)
- */
-const rootCollectionMetaSchema = z.object({
-  label: z.string().optional(),
-  entries: z.array(entryTypeMetaSchema).optional(),
-  order: z.array(z.string()).optional(), // Embedded IDs for ordering items
-})
-
-export type EntryTypeMeta = {
-  name: string
-  format: 'md' | 'mdx' | 'json'
-  schema: string // Entry schema registry key
-  label?: string
-  default?: boolean
-  maxItems?: number
-}
-
-export type CollectionMeta = {
-  name: string
-  label?: string
-  entries?: EntryTypeMeta[]
-  order: string[] // Embedded IDs for ordering items (required)
-}
-
-export type RootCollectionMeta = {
-  label?: string
-  entries?: EntryTypeMeta[]
-  order?: string[] // Embedded IDs for ordering items
-}
-
-/**
- * Recursively scans a directory for .collection.json files.
- *
- * Discovery Rules:
- * - Scans recursively from the base directory (content root)
- * - Each directory can have at most ONE .collection.json file
- * - Collection path is derived from the directory structure (e.g., "docs/api" for content/docs/api/)
- * - Collection name comes from the "name" field in .collection.json, NOT the directory name
- * - Directories without .collection.json are still scanned for nested collections
- * - Invalid .collection.json files cause the entire scan to fail with a descriptive error
- *
- * @param baseDir - The directory to scan (absolute path)
- * @param relativePath - Current path relative to content root (used for recursion)
- * @returns Array of collection metadata with resolved paths
- */
-
-/**
- * Strip embedded ID from a directory or file name.
- * e.g., "docs.bChqT78gcaLd" -> "docs"
- * e.g., "home.home.agfzDt2RLpSn.json" -> "home"
- */
-function stripEmbeddedIdFromName(name: string): string {
-  // Use extractSlugFromFilename which handles the ID extraction logic
-  return extractSlugFromFilename(name)
-}
-
-async function scanForCollectionMeta(
-  baseDir: string,
-  relativePath: string = '',
-): Promise<Array<CollectionMeta & { path: string; contentId?: ContentId }>> {
-  const collections: Array<CollectionMeta & { path: string; contentId?: ContentId }> = []
-
-  try {
-    const entries = await fs.readdir(baseDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-
-      const folderName = entry.name
-      // Strip embedded ID from folder name for logical path
-      // e.g., "docs.bChqT78gcaLd" -> "docs"
-      const logicalName = stripEmbeddedIdFromName(folderName)
-      // Extract embedded ContentId from directory name (e.g., "posts.a1b2c3d4e5f6" → "a1b2c3d4e5f6")
-      const collectionContentId = extractIdFromFilename(folderName) ?? undefined
-      const folderPath = relativePath ? `${relativePath}/${logicalName}` : logicalName
-      const absolutePath = join(baseDir, folderName)
-      const metaPath = join(absolutePath, '.collection.json')
-
-      // Try to load collection meta file
-      try {
-        await fs.access(metaPath)
-        const content = await fs.readFile(metaPath, 'utf-8')
-        const parsed = JSON.parse(content)
-
-        // Validate with Zod
-        const meta = collectionMetaSchema.parse(parsed) as CollectionMeta
-
-        collections.push({
-          ...meta,
-          path: folderPath, // Path derived from folder name
-          contentId: collectionContentId,
-        })
-
-        // Recursively scan for nested collection folders (they'll have their own .collection.json files)
-        const nestedCollections = await scanForCollectionMeta(absolutePath, folderPath)
-        collections.push(...nestedCollections)
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-          // File exists but is invalid
-          console.error(`Error loading ${metaPath}:`, err)
-          throw new Error(`Invalid .collection.json in ${folderPath}: ${(err as Error).message}`)
-        }
-        // No .collection.json - still scan subfolders in case they have collections
-        const nestedCollections = await scanForCollectionMeta(absolutePath, folderPath)
-        collections.push(...nestedCollections)
-      }
-    }
-
-    return collections
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      return []
-    }
-    throw err
-  }
-}
-
-/**
- * Loads all .collection.json meta files from contentRoot, including root.
- *
- * This function orchestrates the complete discovery process:
- * 1. Attempts to load the root .collection.json (contentRoot/.collection.json) - optional
- * 2. Recursively scans all subdirectories for .collection.json files
- * 3. Returns both root configuration and nested collections
- *
- * Meta File Structure:
- * - Root: contentRoot/.collection.json (optional, defines root-level entry types)
- * - Collections: contentRoot/[path]/.collection.json (defines collection in that directory)
- *
- * @param contentRoot - Absolute path to the content directory
- * @returns Object containing root meta (if exists) and array of collection metas with paths
- * @throws Error if any .collection.json file is malformed or invalid
- */
-export async function loadCollectionMetaFiles(contentRoot: string): Promise<{
-  root: RootCollectionMeta | null
-  collections: Array<CollectionMeta & { path: string; contentId?: ContentId }>
-}> {
-  // Load root .collection.json (optional)
-  let root: RootCollectionMeta | null = null
-  const rootMetaPath = join(contentRoot, '.collection.json')
-
-  try {
-    await fs.access(rootMetaPath)
-  } catch (err) {
-    // No root .collection.json - that's okay
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      // File doesn't exist, that's fine
-    } else {
-      throw err
-    }
-  }
-
-  // If file exists, try to read and parse it
-  try {
-    const content = await fs.readFile(rootMetaPath, 'utf-8')
-    const parsed = JSON.parse(content)
-    root = rootCollectionMetaSchema.parse(parsed) as RootCollectionMeta
-  } catch (err) {
-    // Only handle errors if the file exists (not ENOENT)
-    const errno = (err as NodeJS.ErrnoException).code
-    if (errno !== 'ENOENT') {
-      throw new Error(`Invalid root .collection.json`)
-    }
-  }
-
-  // Scan for collection folders
-  const collections = await scanForCollectionMeta(contentRoot)
-
-  return { root, collections }
-}
-
-/**
- * Resolve schema references for entry types
- */
-function resolveEntryTypes(
-  entryTypes: EntryTypeMeta[],
-  entrySchemaRegistry: EntrySchemaRegistry,
-  contextName: string,
-): EntryTypeConfig[] {
-  return entryTypes.map((entryType) => {
-    const resolvedSchema = entrySchemaRegistry[entryType.schema]
-    if (!resolvedSchema) {
-      throw new Error(
-        `Schema reference "${entryType.schema}" in entry type "${entryType.name}" (${contextName}) not found in registry. ` +
-          `Available schemas: ${Object.keys(entrySchemaRegistry).join(', ')}`,
-      )
-    }
-
-    return {
-      name: entryType.name,
-      label: entryType.label,
-      format: entryType.format as ContentFormat,
-      schema: resolvedSchema,
-      schemaRef: entryType.schema,
-      default: entryType.default,
-      maxItems: entryType.maxItems,
-    }
-  })
-}
-
-/**
- * Resolve schema references for a single collection
- */
-function resolveCollectionMeta(
-  meta: CollectionMeta & { path: string; contentId?: ContentId },
-  entrySchemaRegistry: EntrySchemaRegistry,
-  allCollections: Array<CollectionMeta & { path: string; contentId?: ContentId }>,
-): CollectionConfig {
-  // Resolve entry types
-  const entries =
-    meta.entries && meta.entries.length > 0
-      ? resolveEntryTypes(meta.entries, entrySchemaRegistry, `collection "${meta.name}"`)
-      : undefined
-
-  // Find nested collections (subfolders with .collection.json)
-  const nestedCollections = allCollections.filter((col) => {
-    return (
-      col.path.startsWith(`${meta.path}/`) &&
-      col.path.split('/').length === meta.path.split('/').length + 1
-    )
-  })
-
-  const collections =
-    nestedCollections.length > 0
-      ? nestedCollections.map((nestedMeta) =>
-          resolveCollectionMeta(nestedMeta, entrySchemaRegistry, allCollections),
-        )
-      : undefined
-
-  return {
-    name: meta.name,
-    label: meta.label,
-    path: meta.path,
-    contentId: meta.contentId,
-    ...(entries && { entries }),
-    ...(meta.order && { order: meta.order }),
-    ...(collections && { collections }),
-  }
-}
-
-/**
- * Resolve schema references for root collection and all collections.
- *
- * This function takes the loaded meta files (which contain string references like "postSchema")
- * and resolves them to actual EntrySchema arrays from the entry schema registry.
- *
- * Resolution Process:
- * 1. Root entry types: Resolve "schema" string to entry schema registry lookup
- * 2. Top-level collections: Resolve recursively, building nested tree structure
- * 3. Nested collections: Automatically grouped under their parent collections
- *
- * @param metaFiles - Loaded meta files from loadCollectionMetaFiles()
- * @param entrySchemaRegistry - Map of schema names to EntrySchema arrays
- * @returns Fully resolved root collection config ready for use by CanopyCMS
- * @throws Error if any schema reference doesn't exist in registry (with helpful suggestions)
- */
-export function resolveCollectionReferences(
-  metaFiles: {
-    root: RootCollectionMeta | null
-    collections: Array<CollectionMeta & { path: string; contentId?: ContentId }>
-  },
-  entrySchemaRegistry: EntrySchemaRegistry,
-): RootCollectionConfig {
-  // Build result object dynamically to avoid readonly conflicts
-  const result: Record<string, unknown> = {}
-
-  // Pass through root label if present
-  if (metaFiles.root?.label) {
-    result.label = metaFiles.root.label
-  }
-
-  // Resolve root entry types
-  if (metaFiles.root?.entries && metaFiles.root.entries.length > 0) {
-    result.entries = resolveEntryTypes(
-      metaFiles.root.entries,
-      entrySchemaRegistry,
-      'root collection',
-    )
-  }
-
-  // Pass through root order array (embedded IDs for sorting)
-  if (metaFiles.root?.order) {
-    result.order = metaFiles.root.order
-  }
-
-  // Resolve top-level collections (no slashes in path)
-  const topLevelCollections = metaFiles.collections.filter((meta) => !meta.path.includes('/'))
-
-  if (topLevelCollections.length > 0) {
-    result.collections = topLevelCollections.map((meta) =>
-      resolveCollectionMeta(meta, entrySchemaRegistry, metaFiles.collections),
-    )
-  }
-
-  return result as RootCollectionConfig
-}
-
-/**
- * Watch for changes to .collection.json files
- */
-export function watchCollectionMetaFiles(contentRoot: string, onChange: () => void): () => void {
-  const watcher = chokidar.watch(`${contentRoot}/**/.collection.json`, {
-    ignoreInitial: true,
-  })
-
-  watcher.on('add', onChange)
-  watcher.on('change', onChange)
-  watcher.on('unlink', onChange)
-
-  // Return cleanup function
-  return () => watcher.close()
-}

package/src/schema/resolver.ts

@@ -1,83 +0,0 @@
-/**
- * Schema resolver for CanopyCMS.
- *
- * Loads and resolves schema from .collection.json files in the content directory.
- * This is the single source of truth for collection structure.
- *
- * Field schemas are defined in the entry schema registry and referenced by name
- * in .collection.json files for reusability and type safety.
- */
-
-import type { RootCollectionConfig } from '../config'
-import type { EntrySchemaRegistry, SchemaResolutionResult, SchemaSourceInfo } from './types'
-import { loadCollectionMetaFiles, resolveCollectionReferences } from './meta-loader'
-
-/**
- * Resolve schema from .collection.json files.
- *
- * This is the primary entry point for loading schema configuration.
- * It discovers all .collection.json files in the content directory
- * and resolves schema references using the provided registry.
- *
- * @param contentRoot - Path to the content directory
- * @param entrySchemaRegistry - Map of entry schema names to field definitions
- * @returns Resolved schema configuration
- * @throws Error if schema references cannot be resolved
- */
-export async function resolveSchema(
-  contentRoot: string,
-  entrySchemaRegistry: EntrySchemaRegistry,
-): Promise<SchemaResolutionResult> {
-  // Load all .collection.json meta files
-  const metaFiles = await loadCollectionMetaFiles(contentRoot)
-
-  // Build source info for debugging
-  const sources: SchemaSourceInfo[] = []
-
-  if (metaFiles.root) {
-    sources.push({
-      path: '.collection.json',
-      type: 'root',
-      collections: [],
-    })
-  }
-
-  for (const collection of metaFiles.collections) {
-    sources.push({
-      path: `${collection.path}/.collection.json`,
-      type: 'collection',
-      collections: [collection.name],
-    })
-  }
-
-  // Resolve schema references to actual field definitions
-  const schema = resolveCollectionReferences(metaFiles, entrySchemaRegistry)
-
-  return { schema, sources }
-}
-
-/**
- * Check if content root has any .collection.json files.
- *
- * @param contentRoot - Path to the content directory
- * @returns true if at least one .collection.json file exists
- */
-export async function hasSchemaFiles(contentRoot: string): Promise<boolean> {
-  const metaFiles = await loadCollectionMetaFiles(contentRoot)
-  return metaFiles.root !== null || metaFiles.collections.length > 0
-}
-
-/**
- * Validate schema completeness.
- *
- * Checks that the resolved schema has at least one collection or
- * root entries definition.
- *
- * @param schema - Resolved schema to validate
- * @returns true if schema is valid
- */
-export function isValidSchema(schema: RootCollectionConfig): boolean {
-  const hasEntries = !!(schema.entries && schema.entries.length > 0)
-  const hasCollections = !!(schema.collections && schema.collections.length > 0)
-  return hasEntries || hasCollections
-}

package/src/schema/schema-store-types.ts

@@ -1,56 +0,0 @@
-/**
- * Schema Store Types - Client-safe type definitions for schema CRUD operations.
- *
- * These types are separated from schema-store.ts to allow client-side code
- * to import them without pulling in Node.js dependencies (fs, path).
- */
-
-import type { ContentFormat } from '../config'
-import type { LogicalPath } from '../paths/types'
-
-// ============================================================================
-// Input Types
-// ============================================================================
-
-/**
- * Input for creating a new collection
- */
-export interface CreateCollectionInput {
-  name: string
-  label?: string
-  parentPath?: LogicalPath // Parent collection path (empty/undefined for root-level)
-  entries: CreateEntryTypeInput[]
-}
-
-/**
- * Input for creating a new entry type
- */
-export interface CreateEntryTypeInput {
-  name: string
-  label?: string
-  format: ContentFormat
-  schema: string // Entry schema registry key
-  default?: boolean
-  maxItems?: number
-}
-
-/**
- * Input for updating a collection
- */
-export interface UpdateCollectionInput {
-  name?: string
-  label?: string
-  slug?: string // Directory name for renaming (e.g., "posts" in "posts.{id}/")
-  order?: string[] // Embedded IDs for ordering
-}
-
-/**
- * Input for updating an entry type
- */
-export interface UpdateEntryTypeInput {
-  label?: string
-  format?: ContentFormat
-  schema?: string // Entry schema registry key
-  default?: boolean
-  maxItems?: number
-}