canopycms 0.0.0

package/src/config/__tests__/config.test.ts

@@ -0,0 +1,513 @@
+import { describe, expect, it } from 'vitest'
+
+import type { CanopyConfigFragment, CollectionConfig } from '../types'
+import type { ContentId } from '../../paths/types'
+import { ROOT_COLLECTION_ID } from '../../paths/types'
+import { composeCanopyConfig, defineCanopyConfig } from '../helpers'
+import { flattenSchema } from '../flatten'
+import { validateCanopyConfig } from '../validation'
+
+const gitAuthor = {
+  gitBotAuthorName: 'Test Bot',
+  gitBotAuthorEmail: 'bot@example.com',
+}
+
+describe('config validation', () => {
+  it('accepts a valid config with mdx collection and blocks', () => {
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          entries: [
+            {
+              name: 'entry',
+              format: 'mdx' as const,
+              schema: [
+                { name: 'title', type: 'string' as const, required: true },
+                { name: 'body', type: 'mdx' as const, required: true },
+                { name: 'tags', type: 'string' as const, list: true },
+                {
+                  name: 'layout',
+                  type: 'block' as const,
+                  templates: [
+                    {
+                      name: 'hero',
+                      label: 'Hero',
+                      fields: [
+                        {
+                          name: 'headline',
+                          type: 'string' as const,
+                          required: true,
+                        },
+                        { name: 'ctaLabel', type: 'string' as const },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    defineCanopyConfig({
+      ...gitAuthor,
+      media: { adapter: 's3', bucket: 'my-bucket', region: 'us-east-1' },
+    })
+
+    // Verify schema is valid on its own (config no longer contains schema)
+    expect(schema.collections).toBeDefined()
+    expect(schema.collections[0].name).toBe('posts')
+  })
+
+  it('rejects select fields without options', () => {
+    expect(() =>
+      validateCanopyConfig({
+        ...gitAuthor,
+      }),
+    ).not.toThrow() // Config validation no longer includes schema validation
+  })
+
+  it('allows config without schema (schema loaded from .collection.json)', () => {
+    // Schema is loaded from .collection.json meta files, not from config
+    expect(() =>
+      validateCanopyConfig({
+        ...gitAuthor,
+      }),
+    ).not.toThrow()
+  })
+
+  it('composes config fragments from multiple files', () => {
+    const posts: CanopyConfigFragment = {
+      ...gitAuthor,
+    }
+    const pages: CanopyConfigFragment = {
+      ...gitAuthor,
+      media: { adapter: 'local' as const },
+    }
+
+    const config = composeCanopyConfig(posts, pages)
+
+    expect(config.media?.adapter).toBe('local')
+  })
+
+  it('flattens nested paths relative to parents', () => {
+    const schema = {
+      collections: [
+        {
+          name: 'content',
+          path: 'content',
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'pages',
+              path: 'pages',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const configBundle = defineCanopyConfig({
+      ...gitAuthor,
+    })
+    const cfg = configBundle.server
+    const flat = flattenSchema(schema, cfg.contentRoot || 'content')
+
+    const contentCollection = flat.find((item) => item.logicalPath === 'content/content')
+    const pagesCollection = flat.find((item) => item.logicalPath === 'content/content/pages')
+
+    expect(contentCollection).toBeDefined()
+    expect(contentCollection?.type).toBe('collection')
+    expect(pagesCollection).toBeDefined()
+    expect(pagesCollection?.type).toBe('collection')
+    expect(pagesCollection?.parentPath).toBe('content/content')
+  })
+
+  it('handles deeply nested collections with correct paths', () => {
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'md' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'api',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'md' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v2',
+                  path: 'v2',
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'md' as const,
+                      schema: [{ name: 'content', type: 'markdown' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const configBundle = defineCanopyConfig({
+      ...gitAuthor,
+    })
+    const cfg = configBundle.server
+    const flat = flattenSchema(schema, cfg.contentRoot || 'content')
+
+    const docsCollection = flat.find((item) => item.logicalPath === 'content/docs')
+    const apiCollection = flat.find((item) => item.logicalPath === 'content/docs/api')
+    const v2Collection = flat.find((item) => item.logicalPath === 'content/docs/api/v2')
+
+    expect(docsCollection).toBeDefined()
+    expect(docsCollection?.type).toBe('collection')
+
+    expect(apiCollection).toBeDefined()
+    expect(apiCollection?.type).toBe('collection')
+    expect(apiCollection?.parentPath).toBe('content/docs')
+
+    expect(v2Collection).toBeDefined()
+    expect(v2Collection?.type).toBe('collection')
+    expect(v2Collection?.parentPath).toBe('content/docs/api')
+  })
+
+  it('correctly flattens nested collections without path duplication', () => {
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs',
+          entries: [
+            {
+              name: 'entry',
+              format: 'mdx' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'api',
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'mdx' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v1',
+                  path: 'v1',
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'mdx' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const configBundle = defineCanopyConfig({
+      ...gitAuthor,
+    })
+    const cfg = configBundle.server
+    const flat = flattenSchema(schema, cfg.contentRoot || 'content')
+
+    // Find all collections
+    const docs = flat.find((item) => item.type === 'collection' && item.name === 'docs')
+    const api = flat.find((item) => item.type === 'collection' && item.name === 'api')
+    const v1 = flat.find((item) => item.type === 'collection' && item.name === 'v1')
+
+    // Verify docs collection (child of content root)
+    expect(docs).toBeDefined()
+    expect(docs?.logicalPath).toBe('content/docs')
+    expect(docs?.parentPath).toBe('content') // Now has content root as parent
+
+    // Verify api collection (nested under docs)
+    expect(api).toBeDefined()
+    expect(api?.logicalPath).toBe('content/docs/api')
+    expect(api?.parentPath).toBe('content/docs')
+
+    // Verify v1 collection (nested under api)
+    expect(v1).toBeDefined()
+    expect(v1?.logicalPath).toBe('content/docs/api/v1')
+    expect(v1?.parentPath).toBe('content/docs/api')
+  })
+
+  it('handles schema-meta-loader nested structure correctly (from .collection.json pattern)', () => {
+    // This simulates the structure created by schema-meta-loader
+    // where nested collections have FULL paths (e.g., "docs/api") not relative paths (e.g., "api")
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs', // Top-level path
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'docs/api', // FULL path from content root (as set by schema-meta-loader)
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'json' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v1',
+                  path: 'docs/api/v1', // FULL path from content root
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'json' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const configBundle = defineCanopyConfig({
+      ...gitAuthor,
+    })
+    const cfg = configBundle.server
+    const flat = flattenSchema(schema, cfg.contentRoot || 'content')
+
+    // Find all collections
+    const docs = flat.find((item) => item.type === 'collection' && item.name === 'docs')
+    const api = flat.find((item) => item.type === 'collection' && item.name === 'api')
+    const v1 = flat.find((item) => item.type === 'collection' && item.name === 'v1')
+
+    // Verify docs collection (child of content root)
+    expect(docs).toBeDefined()
+    expect(docs?.logicalPath).toBe('content/docs')
+    expect(docs?.parentPath).toBe('content') // Now has content root as parent
+
+    // Verify api collection (nested under docs)
+    expect(api).toBeDefined()
+    expect(api?.logicalPath).toBe('content/docs/api') // Should NOT be 'content/docs/docs/api'
+    expect(api?.parentPath).toBe('content/docs')
+
+    // Verify v1 collection (nested under api)
+    expect(v1).toBeDefined()
+    expect(v1?.logicalPath).toBe('content/docs/api/v1') // Should NOT be 'content/docs/docs/api/api/v1'
+    expect(v1?.parentPath).toBe('content/docs/api')
+  })
+
+  it('strips embedded IDs from collection paths for logical identity', () => {
+    // This test verifies that embedded IDs in directory names are stripped from logical paths
+    // Directory on disk: "docs.bChqT78gcaLd", but logical path should be "docs"
+    // This keeps IDs hidden from URLs and the editor while still using them for filesystem uniqueness
+    const schema = {
+      collections: [
+        {
+          name: 'docs',
+          path: 'docs', // Logical path without ID
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'api',
+              path: 'docs/api', // Logical path without ID
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'json' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+              collections: [
+                {
+                  name: 'v1',
+                  path: 'docs/api/v1', // Logical path without ID
+                  entries: [
+                    {
+                      name: 'entry',
+                      format: 'json' as const,
+                      schema: [{ name: 'title', type: 'string' as const }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: 'posts',
+          path: 'posts', // Logical path without ID
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    } as const
+
+    const configBundle = defineCanopyConfig({
+      ...gitAuthor,
+    })
+    const cfg = configBundle.server
+    const flat = flattenSchema(schema, cfg.contentRoot || 'content')
+
+    // Find all collections
+    const docs = flat.find((item) => item.type === 'collection' && item.name === 'docs')
+    const api = flat.find((item) => item.type === 'collection' && item.name === 'api')
+    const v1 = flat.find((item) => item.type === 'collection' && item.name === 'v1')
+    const posts = flat.find((item) => item.type === 'collection' && item.name === 'posts')
+
+    // Verify docs collection (child of content root) - NO embedded ID in logical path
+    expect(docs).toBeDefined()
+    expect(docs?.logicalPath).toBe('content/docs')
+    expect(docs?.parentPath).toBe('content') // Now has content root as parent
+
+    // Verify api collection (nested under docs) - NO embedded ID in logical path
+    expect(api).toBeDefined()
+    expect(api?.logicalPath).toBe('content/docs/api')
+    expect(api?.parentPath).toBe('content/docs')
+
+    // Verify v1 collection (nested under api) - NO embedded ID in logical path
+    expect(v1).toBeDefined()
+    expect(v1?.logicalPath).toBe('content/docs/api/v1')
+    expect(v1?.parentPath).toBe('content/docs/api')
+
+    // Verify posts collection (child of content root) - NO embedded ID in logical path
+    expect(posts).toBeDefined()
+    expect(posts?.logicalPath).toBe('content/posts')
+    expect(posts?.parentPath).toBe('content') // Now has content root as parent
+  })
+
+  it('threads contentId from CollectionConfig through to FlatSchemaItem', () => {
+    const TEST_ID = 'a1b2c3d4e5f6' as ContentId
+    const CHILD_ID = 'Xz9kL2mN4pQr' as ContentId
+
+    const schema = {
+      collections: [
+        {
+          name: 'posts',
+          path: 'posts',
+          contentId: TEST_ID,
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+          collections: [
+            {
+              name: 'drafts',
+              path: 'posts/drafts',
+              contentId: CHILD_ID,
+              entries: [
+                {
+                  name: 'entry',
+                  format: 'json' as const,
+                  schema: [{ name: 'title', type: 'string' as const }],
+                },
+              ],
+            },
+          ],
+        } satisfies CollectionConfig,
+      ],
+    }
+
+    const flat = flattenSchema(schema, 'content')
+
+    const root = flat.find((item) => item.type === 'collection' && item.logicalPath === 'content')
+    const posts = flat.find((item) => item.type === 'collection' && item.name === 'posts')
+    const drafts = flat.find((item) => item.type === 'collection' && item.name === 'drafts')
+
+    // Root collection gets the sentinel
+    expect(root).toBeDefined()
+    expect(root?.type === 'collection' && root.contentId).toBe(ROOT_COLLECTION_ID)
+
+    // Child collections carry their own contentId
+    expect(posts?.type === 'collection' && posts.contentId).toBe(TEST_ID)
+    expect(drafts?.type === 'collection' && drafts.contentId).toBe(CHILD_ID)
+  })
+
+  it('leaves contentId undefined when CollectionConfig has no contentId', () => {
+    const schema = {
+      collections: [
+        {
+          name: 'pages',
+          path: 'pages',
+          // No contentId — simulates static config (not loaded from filesystem)
+          entries: [
+            {
+              name: 'entry',
+              format: 'json' as const,
+              schema: [{ name: 'title', type: 'string' as const }],
+            },
+          ],
+        },
+      ],
+    }
+
+    const flat = flattenSchema(schema, 'content')
+    const pages = flat.find((item) => item.type === 'collection' && item.name === 'pages')
+
+    expect(pages).toBeDefined()
+    expect(pages?.type === 'collection' && pages.contentId).toBeUndefined()
+  })
+})

package/src/config/flatten.ts

@@ -0,0 +1,174 @@
+/**
+ * Schema flattening utilities for O(1) lookups.
+ */
+
+import { join, normalize } from 'pathe'
+
+import type {
+  CollectionConfig,
+  EntryTypeConfig,
+  FlatSchemaItem,
+  RootCollectionConfig,
+} from './types'
+import { createLogicalPath } from '../paths/normalize'
+import { ROOT_COLLECTION_ID } from '../paths/types'
+
+/**
+ * Normalize a path value by splitting, filtering empty segments, and rejoining.
+ */
+export const normalizePathValue = (val: string): string =>
+  normalize(val).split('/').filter(Boolean).join('/')
+
+/**
+ * Normalize all paths in the root collection schema.
+ * Recursively processes nested collections.
+ */
+export const normalizeSchemaPathsRoot = (root: RootCollectionConfig): RootCollectionConfig => {
+  const normalizeCollection = (collection: CollectionConfig, parentPath = ''): CollectionConfig => {
+    const logicalPath = parentPath ? join(parentPath, collection.path) : collection.path
+    const normalizedFull = normalizePathValue(logicalPath)
+    if (!normalizedFull || normalizedFull.includes('..')) {
+      throw new Error(`Invalid path for collection "${collection.name}"`)
+    }
+
+    return {
+      ...collection,
+      path: normalizePathValue(collection.path),
+      collections: collection.collections?.map((c: CollectionConfig) =>
+        normalizeCollection(c, normalizedFull),
+      ),
+    }
+  }
+
+  return {
+    ...root,
+    collections: root.collections?.map((c: CollectionConfig) => normalizeCollection(c)),
+  }
+}
+
+/**
+ * Flatten the root collection schema into a flat array for O(1) lookups.
+ * Traverses the nested schema structure and returns all collections and entry types
+ * with their full paths resolved.
+ *
+ * @param root - The root collection configuration
+ * @param basePath - Optional base path to prepend (e.g., 'content')
+ * @returns Array of flattened schema items with full paths
+ *
+ * @example
+ * const flat = flattenSchema(config.schema, 'content')
+ * const map = new Map(flat.map(item => [item.logicalPath, item]))
+ * const item = map.get('content/posts') // O(1) lookup
+ */
+export const flattenSchema = (root: RootCollectionConfig, basePath = ''): FlatSchemaItem[] => {
+  const flat: FlatSchemaItem[] = []
+  const base = normalizePathValue(basePath || '')
+
+  const walkCollection = (collection: CollectionConfig, parentPath: string) => {
+    const normalizedPath = normalizePathValue(collection.path)
+    // Build logical path: if we have a parent, join with parent; otherwise use collection path
+    let logicalPath: string
+    if (parentPath && parentPath !== base) {
+      // Nested child collection: use only the collection name (leaf segment), not the full path
+      // The full path from collection.path includes parent path segments that are already in parentPath
+      logicalPath = join(parentPath, collection.name)
+    } else if (parentPath === base) {
+      // Root-level collection (direct child of content root): use collection path
+      logicalPath = join(base, normalizedPath)
+    } else {
+      // No parent and no base: use collection path as-is
+      logicalPath = normalizedPath
+    }
+    const normalizedFull = normalizePathValue(logicalPath)
+
+    // Add the collection itself
+    flat.push({
+      type: 'collection',
+      logicalPath: createLogicalPath(normalizedFull),
+      name: collection.name,
+      label: collection.label,
+      description: collection.description,
+      contentId: collection.contentId,
+      parentPath: parentPath ? createLogicalPath(parentPath) : undefined,
+      entries: collection.entries,
+      collections: collection.collections,
+      order: collection.order,
+    })
+
+    // Add entry types in this collection
+    if (collection.entries) {
+      for (const entryType of collection.entries as readonly EntryTypeConfig[]) {
+        // Entry type path is collection path + entry type name
+        const entryTypePath = join(normalizedFull, entryType.name)
+        flat.push({
+          type: 'entry-type',
+          logicalPath: createLogicalPath(normalizePathValue(entryTypePath)),
+          name: entryType.name,
+          label: entryType.label,
+          description: entryType.description,
+          parentPath: createLogicalPath(normalizedFull),
+          format: entryType.format,
+          schema: entryType.schema,
+          schemaRef: entryType.schemaRef,
+          default: entryType.default,
+          maxItems: entryType.maxItems,
+        })
+      }
+    }
+
+    // Recursively process nested collections
+    if (collection.collections) {
+      for (const child of collection.collections) {
+        walkCollection(child, normalizedFull)
+      }
+    }
+  }
+
+  // Add the root collection itself as a normal collection (if we have a base path)
+  // This makes content root behave exactly like any other collection, just without a parent
+  if (base) {
+    flat.push({
+      type: 'collection',
+      logicalPath: createLogicalPath(base),
+      name: base, // Use base path as the name (e.g., 'content')
+      label: undefined, // Root collection has no label
+      contentId: ROOT_COLLECTION_ID, // Sentinel — root dir has no embedded ID
+      parentPath: undefined, // No parent - this is the root
+      entries: root.entries,
+      collections: root.collections,
+      order: root.order,
+    })
+  }
+
+  // Add root-level entry types
+  // Now their parentPath will reference the root collection we just added above
+  if (root.entries) {
+    for (const entryType of root.entries as readonly EntryTypeConfig[]) {
+      // Root entry type path is base + entry type name
+      const entryTypePath = base ? join(base, entryType.name) : entryType.name
+      flat.push({
+        type: 'entry-type',
+        logicalPath: createLogicalPath(normalizePathValue(entryTypePath)),
+        name: entryType.name,
+        label: entryType.label,
+        description: entryType.description,
+        parentPath: base ? createLogicalPath(base) : createLogicalPath(''), // Now references the root collection (e.g., 'content')
+        format: entryType.format,
+        schema: entryType.schema,
+        schemaRef: entryType.schemaRef,
+        default: entryType.default,
+        maxItems: entryType.maxItems,
+      })
+    }
+  }
+
+  // Process root-level collections
+  // Pass base as parentPath so they are children of the content root collection
+  if (root.collections) {
+    for (const collection of root.collections) {
+      walkCollection(collection, base || '')
+    }
+  }
+
+  return flat
+}