canopycms 0.0.0

package/src/schema/schema-store.ts

@@ -0,0 +1,795 @@
+/**
+ * Schema Store - handles reading and writing .collection.json files.
+ *
+ * This module provides CRUD operations for collection schema metadata:
+ * - Create/update/delete collections
+ * - Add/update/remove entry types
+ * - Update ordering of items within collections
+ *
+ * All mutations are branch-specific (like content edits).
+ */
+
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { z } from 'zod'
+
+import type { ContentFormat } from '../config'
+import type { EntrySchemaRegistry } from './types'
+import { resolveCollectionPath } from '../content-id-index'
+import { generateId, isValidId } from '../id'
+import { createLogicalPath, validateAndNormalizePath } from '../paths'
+import type { LogicalPath, ContentId } from '../paths/types'
+import type { CanopyServices } from '../services'
+
+// Re-export types from client-safe module
+export type {
+  CreateCollectionInput,
+  CreateEntryTypeInput,
+  UpdateCollectionInput,
+  UpdateEntryTypeInput,
+} from './schema-store-types'
+
+// Import types for internal use
+import type {
+  CreateCollectionInput,
+  CreateEntryTypeInput,
+  UpdateCollectionInput,
+  UpdateEntryTypeInput,
+} from './schema-store-types'
+
+/**
+ * Raw collection meta as stored in .collection.json
+ */
+interface CollectionMetaFile {
+  name: string
+  label?: string
+  entries?: Array<{
+    name: string
+    label?: string
+    format: ContentFormat
+    schema: string
+    default?: boolean
+    maxItems?: number
+  }>
+  order?: string[]
+}
+
+/**
+ * Raw root collection meta as stored in content/.collection.json
+ */
+interface RootCollectionMetaFile {
+  label?: string
+  entries?: Array<{
+    name: string
+    label?: string
+    format: ContentFormat
+    schema: string
+    default?: boolean
+    maxItems?: number
+  }>
+  order?: string[]
+}
+
+// ============================================================================
+// Zod Schemas for Validation
+// ============================================================================
+
+/** Max length for names and slugs (filesystem path safety) */
+const MAX_NAME_LENGTH = 64
+/** Max length for labels */
+const MAX_LABEL_LENGTH = 128
+
+const entryTypeInputSchema = z.object({
+  name: z.string().min(1).max(MAX_NAME_LENGTH),
+  label: z.string().max(MAX_LABEL_LENGTH).optional(),
+  format: z.enum(['md', 'mdx', 'json']),
+  schema: z.string().min(1),
+  default: z.boolean().optional(),
+  maxItems: z.number().int().positive().optional(),
+})
+
+const createCollectionInputSchema = z.object({
+  name: z.string().min(1).max(MAX_NAME_LENGTH),
+  label: z.string().max(MAX_LABEL_LENGTH).optional(),
+  parentPath: z.string().optional(),
+  entries: z.array(entryTypeInputSchema).min(1, 'Collection must have at least one entry type'),
+})
+
+const updateCollectionInputSchema = z.object({
+  name: z.string().min(1).max(MAX_NAME_LENGTH).optional(),
+  label: z.string().max(MAX_LABEL_LENGTH).optional(),
+  slug: z.string().min(1).max(MAX_NAME_LENGTH).optional(), // Directory name (e.g., "posts" in "posts.{id}/")
+  order: z.array(z.string()).optional(),
+})
+
+const updateEntryTypeInputSchema = z.object({
+  label: z.string().max(MAX_LABEL_LENGTH).optional(),
+  format: z.enum(['md', 'mdx', 'json']).optional(),
+  schema: z.string().min(1).optional(),
+  default: z.boolean().optional(),
+  maxItems: z.number().int().positive().optional(),
+})
+
+// ============================================================================
+// SchemaOps Class
+// ============================================================================
+
+export class SchemaOps {
+  constructor(
+    private readonly contentRoot: string,
+    private readonly entrySchemaRegistry: EntrySchemaRegistry,
+    private readonly services?: CanopyServices,
+  ) {}
+
+  // --------------------------------------------------------------------------
+  // Cache Invalidation
+  // --------------------------------------------------------------------------
+
+  /**
+   * Invalidate schema cache for this branch after mutations.
+   * This marks the cache as stale so the next schema load will regenerate it.
+   */
+  private async invalidateSchemaCache(): Promise<void> {
+    if (this.services) {
+      // Get branchRoot from contentRoot (parent directory)
+      const branchRoot = path.dirname(this.contentRoot)
+      await this.services.branchSchemaCache.invalidate(branchRoot)
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Validation Helpers
+  // --------------------------------------------------------------------------
+
+  /**
+   * Validate that a schema reference exists in the registry
+   */
+  validateSchemaReference(schemaKey: string): boolean {
+    return schemaKey in this.entrySchemaRegistry
+  }
+
+  /**
+   * Validate all schema references in entry types
+   */
+  private validateEntryTypeSchemas(entryTypes: CreateEntryTypeInput[]): {
+    valid: boolean
+    error?: string
+  } {
+    for (const entryType of entryTypes) {
+      if (!this.validateSchemaReference(entryType.schema)) {
+        const available = Object.keys(this.entrySchemaRegistry).join(', ')
+        return {
+          valid: false,
+          error: `Schema reference "${entryType.schema}" not found. Available: ${available}`,
+        }
+      }
+    }
+    return { valid: true }
+  }
+
+  /**
+   * Validate path to prevent traversal attacks
+   */
+  private validatePath(targetPath: string): {
+    valid: boolean
+    normalizedPath?: string
+    error?: string
+  } {
+    const result = validateAndNormalizePath(this.contentRoot, targetPath)
+    if (!result.valid) {
+      return { valid: false, error: result.error || 'Invalid path' }
+    }
+    return { valid: true, normalizedPath: result.normalizedPath }
+  }
+
+  // --------------------------------------------------------------------------
+  // Read Operations
+  // --------------------------------------------------------------------------
+
+  /**
+   * Read a collection's .collection.json file
+   */
+  async readCollectionMeta(collectionPath: LogicalPath): Promise<CollectionMetaFile | null> {
+    // Resolve logical path to physical path with embedded IDs
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      return null
+    }
+
+    const metaPath = path.join(physicalPath, '.collection.json')
+    try {
+      const content = await fs.readFile(metaPath, 'utf-8')
+      return JSON.parse(content) as CollectionMetaFile
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null
+      }
+      throw err
+    }
+  }
+
+  /**
+   * Read root collection meta (content/.collection.json)
+   */
+  async readRootCollectionMeta(): Promise<RootCollectionMetaFile | null> {
+    const metaPath = path.join(this.contentRoot, '.collection.json')
+    try {
+      const content = await fs.readFile(metaPath, 'utf-8')
+      return JSON.parse(content) as RootCollectionMetaFile
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null
+      }
+      throw err
+    }
+  }
+
+  /**
+   * Check if a collection is empty (has no content files or child collections)
+   */
+  async isCollectionEmpty(collectionPath: LogicalPath): Promise<boolean> {
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      // Collection doesn't exist, consider it empty
+      return true
+    }
+
+    try {
+      const entries = await fs.readdir(physicalPath, { withFileTypes: true })
+      for (const entry of entries) {
+        // Content files mean not empty
+        if (entry.isFile() && entry.name !== '.collection.json') {
+          return false
+        }
+        // Child collection directories mean not empty
+        if (entry.isDirectory()) {
+          try {
+            await fs.access(path.join(physicalPath, entry.name, '.collection.json'))
+            return false
+          } catch {
+            // Not a collection directory, ignore
+          }
+        }
+      }
+      return true
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return true
+      }
+      throw err
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Write Operations
+  // --------------------------------------------------------------------------
+
+  /**
+   * Write a collection's .collection.json file
+   */
+  private async writeCollectionMeta(physicalPath: string, meta: CollectionMetaFile): Promise<void> {
+    const metaPath = path.join(physicalPath, '.collection.json')
+    const content = JSON.stringify(meta, null, 2) + '\n'
+    await fs.writeFile(metaPath, content, 'utf-8')
+  }
+
+  /**
+   * Write root collection meta
+   */
+  private async writeRootCollectionMeta(meta: RootCollectionMetaFile): Promise<void> {
+    const metaPath = path.join(this.contentRoot, '.collection.json')
+    const content = JSON.stringify(meta, null, 2) + '\n'
+    await fs.writeFile(metaPath, content, 'utf-8')
+  }
+
+  // --------------------------------------------------------------------------
+  // Collection Operations
+  // --------------------------------------------------------------------------
+
+  /**
+   * Create a new collection
+   */
+  async createCollection(
+    input: CreateCollectionInput,
+  ): Promise<{ collectionPath: LogicalPath; contentId: ContentId }> {
+    // Validate input
+    const parseResult = createCollectionInputSchema.safeParse(input)
+    if (!parseResult.success) {
+      throw new Error(`Invalid input: ${parseResult.error.message}`)
+    }
+
+    // Validate schema references
+    const schemaValidation = this.validateEntryTypeSchemas(input.entries)
+    if (!schemaValidation.valid) {
+      throw new Error(schemaValidation.error)
+    }
+
+    // Determine parent directory
+    let parentPhysicalPath: string
+    if (input.parentPath) {
+      const resolved = await resolveCollectionPath(this.contentRoot, input.parentPath)
+      if (!resolved) {
+        throw new Error(`Parent collection not found: ${input.parentPath}`)
+      }
+      parentPhysicalPath = resolved
+    } else {
+      parentPhysicalPath = this.contentRoot
+    }
+
+    // Generate embedded ID for new collection
+    const contentId = generateId()
+    const dirName = `${input.name}.${contentId}`
+    const physicalPath = path.join(parentPhysicalPath, dirName)
+
+    // Create directory
+    await fs.mkdir(physicalPath, { recursive: true })
+
+    // Build collection meta with empty order array (required for ordering support)
+    const meta: CollectionMetaFile = {
+      name: input.name,
+      label: input.label,
+      entries: input.entries.map((et) => ({
+        name: et.name,
+        label: et.label,
+        format: et.format,
+        schema: et.schema,
+        default: et.default,
+        maxItems: et.maxItems,
+      })),
+      order: [], // Initialize with empty order array
+    }
+
+    // Write .collection.json
+    await this.writeCollectionMeta(physicalPath, meta)
+
+    // Add new collection's contentId to parent's order array
+    // For root-level collections (empty parentPath), we don't update parent order
+    const parentLogicalPath = input.parentPath
+      ? createLogicalPath(input.parentPath)
+      : createLogicalPath('')
+    const parentMeta = input.parentPath ? await this.readCollectionMeta(parentLogicalPath) : null
+    if (parentMeta) {
+      // Initialize parent's order array if it doesn't exist
+      const existingOrder = parentMeta.order ?? []
+      parentMeta.order = [...existingOrder, contentId]
+      await this.writeCollectionMeta(parentPhysicalPath, parentMeta)
+    }
+
+    // Build logical path
+    const logicalPath = input.parentPath
+      ? createLogicalPath(`${input.parentPath}/${input.name}`)
+      : createLogicalPath(input.name)
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+
+    return { collectionPath: logicalPath, contentId }
+  }
+
+  /**
+   * Update a collection's metadata
+   */
+  async updateCollection(
+    collectionPath: LogicalPath,
+    updates: UpdateCollectionInput,
+  ): Promise<void> {
+    // Validate input
+    const parseResult = updateCollectionInputSchema.safeParse(updates)
+    if (!parseResult.success) {
+      throw new Error(`Invalid input: ${parseResult.error.message}`)
+    }
+
+    // Check if this is the root collection (path equals contentRoot basename, e.g., "content")
+    const contentRootName = path.basename(this.contentRoot)
+    if (collectionPath === contentRootName) {
+      // Update root collection meta
+      let meta = await this.readRootCollectionMeta()
+      if (!meta) {
+        meta = {}
+      }
+      // Root only supports label and order updates (no name)
+      if (updates.label !== undefined) {
+        meta.label = updates.label
+      }
+      if (updates.order !== undefined) {
+        meta.order = updates.order
+      }
+      await this.writeRootCollectionMeta(meta)
+      // Invalidate schema cache after mutation
+      await this.invalidateSchemaCache()
+      return
+    }
+
+    // Strip contentRoot prefix to get relative path for regular collection
+    // E.g., "content/posts" -> "posts"
+    const relativePath = collectionPath.startsWith(`${contentRootName}/`)
+      ? collectionPath.slice(contentRootName.length + 1)
+      : collectionPath
+
+    // Resolve path for regular collection
+    const physicalPath = await resolveCollectionPath(
+      this.contentRoot,
+      createLogicalPath(relativePath),
+    )
+    if (!physicalPath) {
+      throw new Error(`Collection not found: ${collectionPath}`)
+    }
+
+    // Read existing meta
+    const meta = await this.readCollectionMeta(relativePath as LogicalPath)
+    if (!meta) {
+      throw new Error(`Collection meta not found: ${collectionPath}`)
+    }
+
+    // Handle slug change (directory rename) if provided
+    let finalPhysicalPath = physicalPath
+    if (updates.slug !== undefined) {
+      // Extract current slug and ID from physical path
+      // Format: /path/to/{slug}.{12-char-id}
+      const dirName = path.basename(physicalPath)
+      const parts = dirName.split('.')
+
+      if (parts.length !== 2 || !isValidId(parts[1])) {
+        throw new Error(`Invalid collection directory format: ${dirName}`)
+      }
+
+      const currentSlug = parts[0]
+      const contentId = parts[1]
+
+      // Only rename if slug is actually different
+      if (updates.slug !== currentSlug) {
+        // Validate new slug (alphanumeric + hyphens, lowercase)
+        if (!/^[a-z][a-z0-9-]*$/.test(updates.slug)) {
+          throw new Error(
+            'Slug must start with a letter and contain only lowercase letters, numbers, and hyphens',
+          )
+        }
+
+        // Build new path with new slug + same ID
+        const parentDir = path.dirname(physicalPath)
+        const newDirName = `${updates.slug}.${contentId}`
+        const newPhysicalPath = path.join(parentDir, newDirName)
+
+        // Check if any collection with this slug already exists
+        // Need to check for any directory matching {slug}.{any-id}
+        try {
+          const entries = await fs.readdir(parentDir, { withFileTypes: true })
+          for (const entry of entries) {
+            if (entry.isDirectory() && entry.name.startsWith(`${updates.slug}.`)) {
+              const parts = entry.name.split('.')
+              if (parts.length === 2 && isValidId(parts[1])) {
+                throw new Error(`Collection with slug "${updates.slug}" already exists`)
+              }
+            }
+          }
+        } catch (err) {
+          // Re-throw "already exists" errors
+          if ((err as Error).message.includes('already exists')) {
+            throw err
+          }
+          // Ignore other errors (e.g., ENOENT if parent dir doesn't exist somehow)
+        }
+
+        // Atomically rename the directory
+        await fs.rename(physicalPath, newPhysicalPath)
+        finalPhysicalPath = newPhysicalPath
+
+        // Note: Content ID index will rebuild lazily on next access
+      }
+    }
+
+    // Apply metadata updates
+    if (updates.name !== undefined) {
+      meta.name = updates.name
+    }
+    if (updates.label !== undefined) {
+      meta.label = updates.label
+    }
+    if (updates.order !== undefined) {
+      meta.order = updates.order
+    }
+
+    // Write back to the (potentially renamed) path
+    await this.writeCollectionMeta(finalPhysicalPath, meta)
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+  }
+
+  /**
+   * Delete a collection (must be empty)
+   */
+  async deleteCollection(collectionPath: LogicalPath): Promise<void> {
+    // Check if empty
+    const isEmpty = await this.isCollectionEmpty(collectionPath)
+    if (!isEmpty) {
+      throw new Error('Collection must be empty before deletion. Delete all entries first.')
+    }
+
+    // Resolve path
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      throw new Error(`Collection not found: ${collectionPath}`)
+    }
+
+    // Delete the directory (including .collection.json)
+    await fs.rm(physicalPath, { recursive: true })
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+  }
+
+  // --------------------------------------------------------------------------
+  // Entry Type Operations
+  // --------------------------------------------------------------------------
+
+  /**
+   * Add an entry type to a collection
+   */
+  async addEntryType(collectionPath: LogicalPath, entryType: CreateEntryTypeInput): Promise<void> {
+    // Validate input
+    const parseResult = entryTypeInputSchema.safeParse(entryType)
+    if (!parseResult.success) {
+      throw new Error(`Invalid input: ${parseResult.error.message}`)
+    }
+
+    // Validate schema reference
+    if (!this.validateSchemaReference(entryType.schema)) {
+      const available = Object.keys(this.entrySchemaRegistry).join(', ')
+      throw new Error(`Schema reference "${entryType.schema}" not found. Available: ${available}`)
+    }
+
+    // Resolve path
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      throw new Error(`Collection not found: ${collectionPath}`)
+    }
+
+    // Read existing meta
+    const meta = await this.readCollectionMeta(collectionPath)
+    if (!meta) {
+      throw new Error(`Collection meta not found: ${collectionPath}`)
+    }
+
+    // Check for duplicate name
+    if (meta.entries?.some((et) => et.name === entryType.name)) {
+      throw new Error(`Entry type "${entryType.name}" already exists in this collection`)
+    }
+
+    // Add entry type
+    meta.entries = meta.entries || []
+    meta.entries.push({
+      name: entryType.name,
+      label: entryType.label,
+      format: entryType.format,
+      schema: entryType.schema,
+      default: entryType.default,
+      maxItems: entryType.maxItems,
+    })
+
+    // Write back
+    await this.writeCollectionMeta(physicalPath, meta)
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+  }
+
+  /**
+   * Update an entry type in a collection
+   */
+  async updateEntryType(
+    collectionPath: LogicalPath,
+    entryTypeName: string,
+    updates: UpdateEntryTypeInput,
+  ): Promise<void> {
+    // Validate input
+    const parseResult = updateEntryTypeInputSchema.safeParse(updates)
+    if (!parseResult.success) {
+      throw new Error(`Invalid input: ${parseResult.error.message}`)
+    }
+
+    // Validate schema reference if provided
+    if (updates.schema && !this.validateSchemaReference(updates.schema)) {
+      const available = Object.keys(this.entrySchemaRegistry).join(', ')
+      throw new Error(`Schema reference "${updates.schema}" not found. Available: ${available}`)
+    }
+
+    // Resolve path
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      throw new Error(`Collection not found: ${collectionPath}`)
+    }
+
+    // Read existing meta
+    const meta = await this.readCollectionMeta(collectionPath)
+    if (!meta) {
+      throw new Error(`Collection meta not found: ${collectionPath}`)
+    }
+
+    // Find entry type
+    const entryType = meta.entries?.find((et) => et.name === entryTypeName)
+    if (!entryType) {
+      throw new Error(`Entry type "${entryTypeName}" not found in collection`)
+    }
+
+    // Apply updates
+    if (updates.label !== undefined) {
+      entryType.label = updates.label
+    }
+    if (updates.format !== undefined) {
+      entryType.format = updates.format
+    }
+    if (updates.schema !== undefined) {
+      entryType.schema = updates.schema
+    }
+    if (updates.default !== undefined) {
+      entryType.default = updates.default
+    }
+    if (updates.maxItems !== undefined) {
+      entryType.maxItems = updates.maxItems
+    }
+
+    // Write back
+    await this.writeCollectionMeta(physicalPath, meta)
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+  }
+
+  /**
+   * Remove an entry type from a collection
+   */
+  async removeEntryType(collectionPath: LogicalPath, entryTypeName: string): Promise<void> {
+    // Resolve path
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      throw new Error(`Collection not found: ${collectionPath}`)
+    }
+
+    // Read existing meta
+    const meta = await this.readCollectionMeta(collectionPath)
+    if (!meta) {
+      throw new Error(`Collection meta not found: ${collectionPath}`)
+    }
+
+    // Check entry type exists
+    const index = meta.entries?.findIndex((et) => et.name === entryTypeName) ?? -1
+    if (index === -1) {
+      throw new Error(`Entry type "${entryTypeName}" not found in collection`)
+    }
+
+    // Ensure at least one entry type remains
+    if (meta.entries!.length === 1) {
+      throw new Error(
+        'Cannot remove last entry type. Collection must have at least one entry type.',
+      )
+    }
+
+    // Check for entries still using this type
+    const usageCount = await this.countEntriesUsingType(collectionPath, entryTypeName)
+    if (usageCount > 0) {
+      throw new Error(
+        `Cannot remove entry type "${entryTypeName}": ${usageCount} ${usageCount === 1 ? 'entry still uses' : 'entries still use'} it. ` +
+          'Delete or migrate those entries first.',
+      )
+    }
+
+    // Remove entry type
+    meta.entries!.splice(index, 1)
+
+    // Write back
+    await this.writeCollectionMeta(physicalPath, meta)
+
+    // Invalidate schema cache after mutation
+    await this.invalidateSchemaCache()
+  }
+
+  // --------------------------------------------------------------------------
+  // Usage Counting
+  // --------------------------------------------------------------------------
+
+  /**
+   * Count the number of entries using a specific entry type in a collection.
+   * This is used to prevent breaking changes to entry types that have existing content.
+   *
+   * @param collectionPath - Logical path to the collection (e.g., "content/posts")
+   * @param entryTypeName - Name of the entry type to count
+   * @returns Number of entries using this entry type
+   *
+   * @example
+   * ```ts
+   * const count = await store.countEntriesUsingType('content/posts', 'post')
+   * if (count > 0) {
+   *   // Cannot modify schema/format
+   * }
+   * ```
+   */
+  async countEntriesUsingType(collectionPath: LogicalPath, entryTypeName: string): Promise<number> {
+    // Resolve collection physical path
+    const physicalPath = await resolveCollectionPath(this.contentRoot, collectionPath)
+    if (!physicalPath) {
+      // Collection doesn't exist yet - return 0
+      return 0
+    }
+
+    try {
+      // Read directory entries
+      const entries = await fs.readdir(physicalPath, { withFileTypes: true })
+
+      // Count files matching pattern: {entryTypeName}.{slug}.{id}.{ext}
+      let count = 0
+      for (const entry of entries) {
+        // Skip directories and hidden files
+        if (entry.isDirectory() || entry.name.startsWith('.')) {
+          continue
+        }
+
+        // Parse filename: type.slug.id.ext
+        const parts = entry.name.split('.')
+
+        // Need at least 4 parts: type, slug, id, ext
+        if (parts.length < 4) {
+          continue
+        }
+
+        // Check if first part matches entry type name
+        if (parts[0] !== entryTypeName) {
+          continue
+        }
+
+        // Check if second-to-last part is a valid 12-char ID
+        const candidateId = parts[parts.length - 2]
+        if (isValidId(candidateId)) {
+          count++
+        }
+      }
+
+      return count
+    } catch (err) {
+      // Directory might not exist yet
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return 0
+      }
+      throw err
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Order Operations
+  // --------------------------------------------------------------------------
+
+  /**
+   * Update the order of items in a collection
+   */
+  async updateOrder(collectionPath: LogicalPath, order: string[]): Promise<void> {
+    // Check if this is the root collection (path equals contentRoot basename, e.g., "content")
+    const contentRootName = path.basename(this.contentRoot)
+    if (collectionPath === contentRootName) {
+      // Update root collection meta
+      let meta = await this.readRootCollectionMeta()
+      if (!meta) {
+        meta = {}
+      }
+      meta.order = order
+      await this.writeRootCollectionMeta(meta)
+      // Invalidate schema cache after mutation
+      await this.invalidateSchemaCache()
+      return
+    }
+
+    // Update regular collection (handles contentRoot prefix stripping internally)
+    // Note: updateCollection already invalidates cache, so no need to do it again
+    await this.updateCollection(collectionPath, { order })
+  }
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export {
+  createCollectionInputSchema,
+  updateCollectionInputSchema,
+  entryTypeInputSchema,
+  updateEntryTypeInputSchema,
+}