canopycms 0.0.0 → 0.0.2

package/src/validation/__tests__/field-traversal.test.ts

@@ -1,263 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { traverseFields, findFieldsByType } from '../field-traversal'
-import type { FieldConfig } from '../../config'
-
-describe('field-traversal', () => {
-  describe('traverseFields', () => {
-    it('visits simple fields', () => {
-      const schema: FieldConfig[] = [
-        { name: 'title', type: 'string', label: 'Title' },
-        { name: 'count', type: 'number', label: 'Count' },
-      ]
-      const data = { title: 'Hello', count: 42 }
-
-      const visited: string[] = []
-      traverseFields(schema, data, ({ field, path }) => {
-        visited.push(`${path}:${field.type}`)
-        return []
-      })
-
-      expect(visited).toEqual(['title:string', 'count:number'])
-    })
-
-    it('skips undefined and null values', () => {
-      const schema: FieldConfig[] = [
-        { name: 'title', type: 'string', label: 'Title' },
-        { name: 'subtitle', type: 'string', label: 'Subtitle' },
-        { name: 'count', type: 'number', label: 'Count' },
-      ]
-      const data = { title: 'Hello', subtitle: null, count: undefined }
-
-      const visited: string[] = []
-      traverseFields(schema, data, ({ path }) => {
-        visited.push(path)
-        return []
-      })
-
-      expect(visited).toEqual(['title'])
-    })
-
-    it('recurses into object fields', () => {
-      const schema: FieldConfig[] = [
-        {
-          name: 'author',
-          type: 'object',
-          label: 'Author',
-          fields: [
-            { name: 'name', type: 'string', label: 'Name' },
-            { name: 'email', type: 'string', label: 'Email' },
-          ],
-        },
-      ]
-      const data = {
-        author: { name: 'Alice', email: 'alice@example.com' },
-      }
-
-      const visited: string[] = []
-      traverseFields(schema, data, ({ path, field }) => {
-        visited.push(`${path}:${field.type}`)
-        return []
-      })
-
-      expect(visited).toEqual(['author:object', 'author.name:string', 'author.email:string'])
-    })
-
-    it('recurses into block fields', () => {
-      const schema: FieldConfig[] = [
-        {
-          name: 'blocks',
-          type: 'block',
-          label: 'Blocks',
-          templates: [
-            {
-              name: 'text',
-              label: 'Text Block',
-              fields: [{ name: 'content', type: 'string', label: 'Content' }],
-            },
-            {
-              name: 'image',
-              label: 'Image Block',
-              fields: [{ name: 'src', type: 'string', label: 'Source' }],
-            },
-          ],
-        },
-      ]
-      const data = {
-        blocks: [
-          { _type: 'text', content: 'Hello' },
-          { _type: 'image', src: '/img.png' },
-        ],
-      }
-
-      const visited: string[] = []
-      traverseFields(schema, data, ({ path, field }) => {
-        visited.push(`${path}:${field.type}`)
-        return []
-      })
-
-      expect(visited).toEqual(['blocks:block', 'blocks[0].content:string', 'blocks[1].src:string'])
-    })
-
-    it('collects results from visitor', () => {
-      const schema: FieldConfig[] = [
-        {
-          name: 'author',
-          type: 'reference',
-          label: 'Author',
-          collections: ['authors'],
-        },
-        {
-          name: 'tags',
-          type: 'reference',
-          label: 'Tags',
-          collections: ['tags'],
-        },
-        { name: 'title', type: 'string', label: 'Title' },
-      ]
-      const data = {
-        author: 'author-123',
-        tags: ['tag-1', 'tag-2'],
-        title: 'My Post',
-      }
-
-      const refs = traverseFields(schema, data, ({ field, value, path }) => {
-        if (field.type === 'reference') {
-          return [{ path, value }]
-        }
-        return []
-      })
-
-      expect(refs).toEqual([
-        { path: 'author', value: 'author-123' },
-        { path: 'tags', value: ['tag-1', 'tag-2'] },
-      ])
-    })
-
-    it('handles deeply nested structures', () => {
-      const schema: FieldConfig[] = [
-        {
-          name: 'sections',
-          type: 'block',
-          label: 'Sections',
-          templates: [
-            {
-              name: 'content',
-              label: 'Content Section',
-              fields: [
-                {
-                  name: 'metadata',
-                  type: 'object',
-                  label: 'Metadata',
-                  fields: [
-                    {
-                      name: 'ref',
-                      type: 'reference',
-                      label: 'Reference',
-                      collections: ['docs'],
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      ]
-      const data = {
-        sections: [
-          {
-            _type: 'content',
-            metadata: { ref: 'doc-1' },
-          },
-          {
-            _type: 'content',
-            metadata: { ref: 'doc-2' },
-          },
-        ],
-      }
-
-      const refs = traverseFields(schema, data, ({ field, value, path }) => {
-        if (field.type === 'reference') {
-          return [{ path, value }]
-        }
-        return []
-      })
-
-      expect(refs).toEqual([
-        { path: 'sections[0].metadata.ref', value: 'doc-1' },
-        { path: 'sections[1].metadata.ref', value: 'doc-2' },
-      ])
-    })
-
-    it('handles missing block template gracefully', () => {
-      const schema: FieldConfig[] = [
-        {
-          name: 'blocks',
-          type: 'block',
-          label: 'Blocks',
-          templates: [
-            {
-              name: 'text',
-              label: 'Text',
-              fields: [{ name: 'content', type: 'string', label: 'Content' }],
-            },
-          ],
-        },
-      ]
-      const data = {
-        blocks: [
-          { _type: 'unknown', content: 'Hello' }, // Unknown type
-          { _type: 'text', content: 'World' },
-        ],
-      }
-
-      const visited: string[] = []
-      traverseFields(schema, data, ({ path }) => {
-        visited.push(path)
-        return []
-      })
-
-      // Only the valid block should have its content visited
-      expect(visited).toEqual(['blocks', 'blocks[1].content'])
-    })
-  })
-
-  describe('findFieldsByType', () => {
-    it('finds all reference fields', () => {
-      const schema: FieldConfig[] = [
-        { name: 'title', type: 'string', label: 'Title' },
-        {
-          name: 'author',
-          type: 'reference',
-          label: 'Author',
-          collections: ['authors'],
-        },
-        {
-          name: 'meta',
-          type: 'object',
-          label: 'Meta',
-          fields: [
-            {
-              name: 'reviewer',
-              type: 'reference',
-              label: 'Reviewer',
-              collections: ['users'],
-            },
-          ],
-        },
-      ]
-      const data = {
-        title: 'My Post',
-        author: 'author-1',
-        meta: { reviewer: 'user-1' },
-      }
-
-      const refs = findFieldsByType(schema, data, 'reference')
-
-      expect(refs).toHaveLength(2)
-      expect(refs[0].path).toBe('author')
-      expect(refs[0].value).toBe('author-1')
-      expect(refs[1].path).toBe('meta.reviewer')
-      expect(refs[1].value).toBe('user-1')
-    })
-  })
-})

package/src/validation/deletion-checker.ts

@@ -1,234 +0,0 @@
-import type { ContentStore } from '../content-store'
-import type { ContentIdIndex } from '../content-id-index'
-import type { FieldConfig, ObjectFieldConfig, BlockFieldConfig } from '../config'
-import { type LogicalPath, type EntrySlug, type PhysicalPath } from '../paths'
-
-export interface ReferenceInfo {
-  entryPath: string
-  entryTitle?: string
-  collection: LogicalPath
-  slug: EntrySlug
-  fields: string[] // Field paths where the reference was found
-}
-
-export interface DeletionCheckResult {
-  canDelete: boolean
-  referencedBy: ReferenceInfo[]
-}
-
-/**
- * DeletionChecker finds all references to an entry before deletion.
- *
- * This class provides referential integrity checking by:
- * - Scanning all entries for references to a target ID
- * - Identifying which entries and fields reference the target
- * - Preventing deletion of entries that are still referenced
- *
- * Usage:
- *   const checker = new DeletionChecker(store, idIndex, schema)
- *   const result = await checker.canDelete(targetId)
- *   if (!result.canDelete) {
- *     console.log('Cannot delete:', result.referencedBy)
- *   }
- */
-export class DeletionChecker {
-  constructor(
-    private store: ContentStore,
-    private idIndex: ContentIdIndex,
-    private collections: Map<LogicalPath, { fields: FieldConfig[] }>,
-  ) {}
-
-  /**
-   * Check if an entry can be safely deleted.
-   *
-   * @param id - The content ID to check
-   * @returns Result indicating if deletion is safe and what references exist
-   */
-  async canDelete(id: string): Promise<DeletionCheckResult> {
-    const referencedBy = await this.findReferences(id)
-    return {
-      canDelete: referencedBy.length === 0,
-      referencedBy,
-    }
-  }
-
-  /**
-   * Find all entries that reference the target ID.
-   *
-   * @param targetId - The content ID to search for
-   * @returns Array of reference info for each referencing entry
-   */
-  async findReferences(targetId: string): Promise<ReferenceInfo[]> {
-    const references: ReferenceInfo[] = []
-
-    // Scan all collections for references
-    for (const [collectionPath, collectionDef] of this.collections.entries()) {
-      const refs = await this.scanCollection(collectionPath, collectionDef.fields, targetId)
-      references.push(...refs)
-    }
-
-    return references
-  }
-
-  /**
-   * Scan a single collection for references to the target ID.
-   */
-  private async scanCollection(
-    collectionPath: LogicalPath,
-    fields: FieldConfig[],
-    targetId: string,
-  ): Promise<ReferenceInfo[]> {
-    const references: ReferenceInfo[] = []
-
-    // Get all entries in this collection from the ID index
-    const entries = this.listEntriesInCollection(collectionPath)
-
-    for (const entry of entries) {
-      try {
-        const doc = await this.store.read(entry.collection, entry.slug)
-        const refs = this.findIdInData(doc.data, targetId, fields)
-
-        if (refs.length > 0) {
-          const id = this.idIndex.findByPath(entry.relativePath)
-          references.push({
-            entryPath: id || '',
-            entryTitle: doc.data.title as string | undefined,
-            collection: entry.collection,
-            slug: entry.slug,
-            fields: refs,
-          })
-        }
-      } catch {
-        // Skip entries that can't be read
-        continue
-      }
-    }
-
-    return references
-  }
-
-  /**
-   * Find all occurrences of target ID in entry data.
-   * Returns field paths where the ID was found.
-   */
-  private findIdInData(
-    data: Record<string, unknown>,
-    targetId: string,
-    schema: FieldConfig[],
-    pathPrefix = '',
-  ): string[] {
-    const found: string[] = []
-
-    for (const field of schema) {
-      const fieldPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name
-      const value = data[field.name]
-
-      if (value === undefined || value === null) continue
-
-      if (field.type === 'reference') {
-        // Check if this reference field contains the target ID
-        if (Array.isArray(value)) {
-          if (value.includes(targetId)) {
-            found.push(fieldPath)
-          }
-        } else if (value === targetId) {
-          found.push(fieldPath)
-        }
-      } else if (field.type === 'object') {
-        // Recurse into object fields
-        const objectField = field as ObjectFieldConfig
-        if (objectField.fields && typeof value === 'object' && !Array.isArray(value)) {
-          found.push(
-            ...this.findIdInData(
-              value as Record<string, unknown>,
-              targetId,
-              objectField.fields,
-              fieldPath,
-            ),
-          )
-        }
-      } else if (field.type === 'block') {
-        // Handle block fields
-        const blockField = field as BlockFieldConfig
-        if (Array.isArray(value)) {
-          value.forEach((item, index) => {
-            if (typeof item === 'object' && item !== null) {
-              const blockType = (item as Record<string, unknown>)._type
-              const blockDef = blockField.templates?.find((b) => b.name === blockType)
-              if (blockDef && blockDef.fields) {
-                found.push(
-                  ...this.findIdInData(
-                    item as Record<string, unknown>,
-                    targetId,
-                    blockDef.fields,
-                    `${fieldPath}[${index}]`,
-                  ),
-                )
-              }
-            }
-          })
-        }
-      } else if (field.type === 'array') {
-        // Handle array fields
-        const arrayField = field as FieldConfig & {
-          of?: { type: string; fields?: FieldConfig[] }
-        }
-        if (Array.isArray(value) && arrayField.of) {
-          const ofFields = arrayField.of.fields
-          if (arrayField.of.type === 'object' && ofFields) {
-            value.forEach((item, index) => {
-              if (typeof item === 'object' && item !== null) {
-                found.push(
-                  ...this.findIdInData(
-                    item as Record<string, unknown>,
-                    targetId,
-                    ofFields,
-                    `${fieldPath}[${index}]`,
-                  ),
-                )
-              }
-            })
-          }
-        }
-      }
-    }
-
-    return found
-  }
-
-  /**
-   * Helper to list all entries in a collection from the ID index.
-   */
-  private listEntriesInCollection(collectionPath: LogicalPath): Array<{
-    relativePath: PhysicalPath
-    collection: LogicalPath
-    slug: EntrySlug
-  }> {
-    const entries: Array<{
-      relativePath: PhysicalPath
-      collection: LogicalPath
-      slug: EntrySlug
-    }> = []
-
-    // Get all locations from the index
-    const allLocations = this.idIndex.getAllLocations()
-
-    for (const location of allLocations) {
-      if (location.type === 'entry') {
-        // Check if this entry is in the target collection
-        if (
-          location.collection === collectionPath ||
-          location.collection?.startsWith(collectionPath + '/')
-        ) {
-          entries.push({
-            relativePath: location.relativePath,
-            collection: location.collection,
-            slug: location.slug!,
-          })
-        }
-      }
-    }
-
-    return entries
-  }
-}

package/src/validation/field-traversal.ts

@@ -1,146 +0,0 @@
-/**
- * Shared field traversal utility for schema-aware data traversal.
- *
- * This module provides a generic way to traverse nested data structures
- * according to a schema, handling objects, blocks, and arrays with their
- * own schemas.
- */
-
-import type { FieldConfig, ObjectFieldConfig, BlockFieldConfig } from '../config'
-
-/**
- * Context provided to the visitor function for each field.
- */
-export interface TraversalContext {
-  /** The field configuration from the schema */
-  field: FieldConfig
-  /** The value at this field in the data */
-  value: unknown
-  /** The dot-notation path to this field (e.g., "author.name" or "blocks[0].title") */
-  path: string
-}
-
-/**
- * Visitor function that receives each field and can return results.
- * Return an empty array to skip this field, or return items to collect.
- */
-export type FieldVisitor<T> = (context: TraversalContext) => T[]
-
-/**
- * Get the nested fields for a block template by looking up _type.
- */
-function getBlockTemplateFields(
-  blockField: BlockFieldConfig,
-  item: Record<string, unknown>,
-): FieldConfig[] | undefined {
-  const blockType = item._type as string | undefined
-  if (!blockType) return undefined
-
-  // Block fields use 'templates' property
-  const template = blockField.templates?.find((t) => t.name === blockType)
-  return template?.fields
-}
-
-/**
- * Recursively traverse fields in data according to schema.
- *
- * This function walks through data following the schema structure, calling
- * the visitor function for each field. It handles:
- * - Simple fields (string, number, boolean, reference, etc.)
- * - Object fields with nested schemas
- * - Block fields (arrays of typed objects with different schemas)
- * - Array fields containing objects with schemas
- *
- * @param fields - The schema fields to traverse
- * @param data - The data object to traverse
- * @param visitor - Function called for each field, returns items to collect
- * @param pathPrefix - Current path prefix for nested fields
- * @returns Array of all items returned by the visitor
- *
- * @example
- * ```ts
- * // Find all reference field values
- * const refs = traverseFields(schema, data, ({ field, value, path }) => {
- *   if (field.type === 'reference') {
- *     return [{ path, ids: Array.isArray(value) ? value : [value] }]
- *   }
- *   return []
- * })
- * ```
- */
-export function traverseFields<T>(
-  fields: readonly FieldConfig[],
-  data: Record<string, unknown>,
-  visitor: FieldVisitor<T>,
-  pathPrefix = '',
-): T[] {
-  const results: T[] = []
-
-  for (const field of fields) {
-    const fieldPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name
-    const value = data[field.name]
-
-    // Skip undefined/null values
-    if (value === undefined || value === null) continue
-
-    // Let visitor handle this field first
-    results.push(...visitor({ field, value, path: fieldPath }))
-
-    // Then recurse into nested structures
-    if (field.type === 'object') {
-      const objectField = field as ObjectFieldConfig
-      if (objectField.fields && typeof value === 'object' && !Array.isArray(value)) {
-        results.push(
-          ...traverseFields(
-            objectField.fields,
-            value as Record<string, unknown>,
-            visitor,
-            fieldPath,
-          ),
-        )
-      }
-    } else if (field.type === 'block') {
-      const blockField = field as BlockFieldConfig
-      if (Array.isArray(value)) {
-        value.forEach((item, index) => {
-          if (typeof item === 'object' && item !== null) {
-            const blockFields = getBlockTemplateFields(blockField, item as Record<string, unknown>)
-            if (blockFields) {
-              results.push(
-                ...traverseFields(
-                  blockFields,
-                  item as Record<string, unknown>,
-                  visitor,
-                  `${fieldPath}[${index}]`,
-                ),
-              )
-            }
-          }
-        })
-      }
-    }
-  }
-
-  return results
-}
-
-/**
- * Find all fields of a specific type in the data.
- *
- * @param fields - The schema fields
- * @param data - The data to search
- * @param fieldType - The field type to find (e.g., 'reference', 'string')
- * @returns Array of { field, value, path } for matching fields
- */
-export function findFieldsByType(
-  fields: readonly FieldConfig[],
-  data: Record<string, unknown>,
-  fieldType: string,
-): TraversalContext[] {
-  return traverseFields(fields, data, (ctx) => {
-    if (ctx.field.type === fieldType) {
-      return [ctx]
-    }
-    return []
-  })
-}