canopycms 0.0.0 → 0.0.2

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

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

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