canopycms 0.0.0

package/dist/api/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/api/schema.ts"],"names":[],"mappings":"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"}

package/dist/api/schema.js

@@ -0,0 +1,656 @@
+/**
+ * Schema API - endpoints for managing collection structure.
+ *
+ * Provides CRUD operations for:
+ * - Collections (create, read, update, delete)
+ * - Entry types (add, update, remove)
+ * - Ordering (update item order within collections)
+ *
+ * All mutations require Admin group membership.
+ * Schema changes are branch-specific (like content edits).
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import { defineEndpoint } from './route-builder';
+import { getErrorMessage } from '../utils/error';
+import { branchNameSchema, logicalPathSchema } from './validators';
+import { SchemaOps, createCollectionInputSchema, updateCollectionInputSchema, entryTypeInputSchema, updateEntryTypeInputSchema, } from '../schema/schema-store';
+import { parseLogicalPath } from '../paths';
+/**
+ * Resolve the schemaRef for an entry type. Uses the explicit schemaRef if set,
+ * otherwise does a reverse lookup in the registry by matching the schema array.
+ */
+function resolveSchemaRef(et, registry) {
+    if (et.schemaRef)
+        return et.schemaRef;
+    // Reverse lookup: find which registry key maps to this entry type's schema
+    for (const [key, value] of Object.entries(registry)) {
+        if (value === et.schema)
+            return key;
+    }
+    throw new Error(`Cannot resolve schemaRef for entry type "${et.name}". ` +
+        `No matching entry found in the entry schema registry. ` +
+        `This may indicate a stale schema cache — try invalidating it.`);
+}
+function toWireEntryType(et, registry) {
+    return {
+        name: et.name,
+        format: et.format,
+        schemaRef: resolveSchemaRef(et, registry),
+        ...(et.label !== undefined && { label: et.label }),
+        ...(et.default !== undefined && { default: et.default }),
+        ...(et.maxItems !== undefined && { maxItems: et.maxItems }),
+    };
+}
+function toWireCollection(col, registry) {
+    return {
+        name: col.name,
+        path: col.path,
+        ...(col.label !== undefined && { label: col.label }),
+        ...(col.entries && {
+            entries: col.entries.map((et) => toWireEntryType(et, registry)),
+        }),
+        ...(col.collections && {
+            collections: col.collections.map((c) => toWireCollection(c, registry)),
+        }),
+        ...(col.order && { order: col.order }),
+    };
+}
+function toWireFlatSchema(items, registry) {
+    return items.map((item) => {
+        if (item.type === 'collection') {
+            return {
+                type: 'collection',
+                logicalPath: item.logicalPath,
+                name: item.name,
+                ...(item.label !== undefined && { label: item.label }),
+                ...(item.contentId !== undefined && { contentId: item.contentId }),
+                ...(item.parentPath !== undefined && { parentPath: item.parentPath }),
+                ...(item.entries && {
+                    entries: item.entries.map((et) => toWireEntryType(et, registry)),
+                }),
+                ...(item.collections && {
+                    collections: item.collections.map((c) => toWireCollection(c, registry)),
+                }),
+                ...(item.order && { order: item.order }),
+            };
+        }
+        return {
+            type: 'entry-type',
+            logicalPath: item.logicalPath,
+            name: item.name,
+            ...(item.label !== undefined && { label: item.label }),
+            parentPath: item.parentPath,
+            format: item.format,
+            schemaRef: resolveSchemaRef(item, registry),
+            ...(item.default !== undefined && { default: item.default }),
+            ...(item.maxItems !== undefined && { maxItems: item.maxItems }),
+        };
+    });
+}
+// ============================================================================
+// Zod Schemas for Params
+// ============================================================================
+const branchParamsSchema = z.object({
+    branch: branchNameSchema,
+});
+const collectionParamsSchema = z.object({
+    branch: branchNameSchema,
+    collectionPath: logicalPathSchema,
+});
+const entryTypeParamsSchema = z.object({
+    branch: branchNameSchema,
+    collectionPath: logicalPathSchema,
+    entryTypeName: z.string().min(1),
+});
+// Body schemas for mutations
+const createCollectionBodySchema = createCollectionInputSchema;
+const updateCollectionBodySchema = updateCollectionInputSchema;
+const addEntryTypeBodySchema = entryTypeInputSchema;
+const updateEntryTypeBodySchema = updateEntryTypeInputSchema;
+const updateOrderBodySchema = z.object({
+    order: z.array(z.string()),
+});
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Get a SchemaOps instance for a branch
+ */
+async function getSchemaOps(ctx, branchName) {
+    const context = await ctx.getBranchContext(branchName);
+    if (!context) {
+        return { error: 'Branch not found', status: 404 };
+    }
+    const contentRoot = path.join(context.branchRoot, 'content');
+    const store = new SchemaOps(contentRoot, ctx.services.entrySchemaRegistry, ctx.services);
+    return { store, branchRoot: context.branchRoot };
+}
+/**
+ * Decode a collection path from URL params.
+ * The path is validated by Zod before decoding, then re-validated after
+ * decoding to prevent double-encoding path traversal attacks.
+ */
+function decodeCollectionPath(collectionPath) {
+    const decoded = decodeURIComponent(collectionPath);
+    if (decoded === collectionPath) {
+        return { ok: true, path: collectionPath };
+    }
+    const result = parseLogicalPath(decoded);
+    if (!result.ok) {
+        return { ok: false, error: `Invalid collection path after decoding: ${result.error}` };
+    }
+    return { ok: true, path: result.path };
+}
+// ============================================================================
+// Handlers
+// ============================================================================
+/**
+ * GET /:branch/schema - Get full schema tree
+ */
+const getSchemaHandler = async (gc, ctx, _req, _params) => {
+    const { branchContext } = gc;
+    return {
+        ok: true,
+        status: 200,
+        data: {
+            flatSchema: toWireFlatSchema(branchContext.flatSchema, ctx.services.entrySchemaRegistry),
+            entrySchemas: ctx.services.entrySchemaRegistry,
+        },
+    };
+};
+/**
+ * GET /:branch/schema/collection/...collectionPath - Get single collection details
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+const getCollectionHandler = async (gc, ctx, req, params) => {
+    const { branchContext } = gc;
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    // Find collection in per-branch flat schema
+    const flatSchema = branchContext.flatSchema;
+    const item = flatSchema.find((i) => i.type === 'collection' && i.logicalPath === collectionPath);
+    if (!item || item.type !== 'collection') {
+        return {
+            ok: true,
+            status: 200,
+            data: { collection: null },
+        };
+    }
+    // Build wire-format collection from FlatSchemaItem
+    const registry = ctx.services.entrySchemaRegistry;
+    const collection = {
+        name: item.name,
+        path: item.logicalPath,
+        ...(item.label !== undefined && { label: item.label }),
+        ...(item.entries && {
+            entries: item.entries.map((et) => toWireEntryType(et, registry)),
+        }),
+        ...(item.collections && {
+            collections: item.collections.map((c) => toWireCollection(c, registry)),
+        }),
+        ...(item.order && { order: item.order }),
+    };
+    // Compute usage counts for each entry type
+    // Read from raw collection meta to get entry schema registry keys (strings), not resolved EntrySchema
+    let entryTypesWithUsage;
+    if (item.entries && item.entries.length > 0) {
+        const storeResult = await getSchemaOps(ctx, params.branch);
+        if ('error' in storeResult) {
+            return { ok: false, status: storeResult.status, error: storeResult.error };
+        }
+        // Read raw collection meta to get string schema references
+        const rawMeta = await storeResult.store.readCollectionMeta(collectionPath);
+        if (rawMeta?.entries) {
+            entryTypesWithUsage = await Promise.all(rawMeta.entries.map(async (et) => {
+                const usageCount = await storeResult.store.countEntriesUsingType(collectionPath, et.name);
+                return {
+                    name: et.name,
+                    label: et.label,
+                    format: et.format,
+                    schemaRef: et.schema, // String reference to entry schema registry
+                    default: et.default,
+                    maxItems: et.maxItems,
+                    usageCount,
+                };
+            }));
+        }
+    }
+    return {
+        ok: true,
+        status: 200,
+        data: { collection, entryTypesWithUsage },
+    };
+};
+/**
+ * POST /:branch/schema/collections - Create collection
+ */
+const createCollectionHandler = async (_gc, ctx, req, params, body) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    try {
+        const result = await storeResult.store.createCollection(body);
+        return {
+            ok: true,
+            status: 201,
+            data: result,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * PATCH /:branch/schema/collection/...collectionPath - Update collection
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+const updateCollectionHandler = async (_gc, ctx, req, params, body) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    try {
+        await storeResult.store.updateCollection(collectionPath, body);
+        return {
+            ok: true,
+            status: 200,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * DELETE /:branch/schema/collection/...collectionPath - Delete collection
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+const deleteCollectionHandler = async (_gc, ctx, req, params) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    try {
+        await storeResult.store.deleteCollection(collectionPath);
+        return {
+            ok: true,
+            status: 200,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * POST /:branch/schema/entry-types/...collectionPath - Add entry type
+ * Note: Restructured URL with catch-all at end to support paths with slashes
+ */
+const addEntryTypeHandler = async (_gc, ctx, req, params, body) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    try {
+        await storeResult.store.addEntryType(collectionPath, body);
+        return {
+            ok: true,
+            status: 201,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * PATCH /:branch/schema/entry-types/:entryTypeName/...collectionPath - Update entry type
+ * Note: Restructured URL with entry type name before catch-all path
+ */
+const updateEntryTypeHandler = async (_gc, ctx, req, params, body) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    // Check if format or schema are being changed (breaking changes)
+    const isBreakingChange = body.format !== undefined || body.schema !== undefined;
+    if (isBreakingChange) {
+        // Count existing entries using this type
+        const usageCount = await storeResult.store.countEntriesUsingType(collectionPath, params.entryTypeName);
+        if (usageCount > 0) {
+            const entryWord = usageCount === 1 ? 'entry' : 'entries';
+            return {
+                ok: false,
+                status: 400,
+                error: `Cannot modify schema or format for entry type with existing ${entryWord}. ${usageCount} ${entryWord} currently use this type.`,
+            };
+        }
+    }
+    try {
+        await storeResult.store.updateEntryType(collectionPath, params.entryTypeName, body);
+        return {
+            ok: true,
+            status: 200,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * DELETE /:branch/schema/entry-types/:entryTypeName/...collectionPath - Remove entry type
+ * Note: Restructured URL with entry type name before catch-all path
+ */
+const removeEntryTypeHandler = async (_gc, ctx, req, params) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    try {
+        await storeResult.store.removeEntryType(collectionPath, params.entryTypeName);
+        return {
+            ok: true,
+            status: 200,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * PATCH /:branch/schema/order/...collectionPath - Update item order
+ * Note: Restructured URL with catch-all at end to support paths with slashes
+ */
+const updateOrderHandler = async (_gc, ctx, req, params, body) => {
+    const storeResult = await getSchemaOps(ctx, params.branch);
+    if ('error' in storeResult) {
+        return { ok: false, status: storeResult.status, error: storeResult.error };
+    }
+    const decodedPath = decodeCollectionPath(params.collectionPath);
+    if (!decodedPath.ok) {
+        return { ok: false, status: 400, error: decodedPath.error };
+    }
+    const collectionPath = decodedPath.path;
+    try {
+        await storeResult.store.updateOrder(collectionPath, body.order);
+        return {
+            ok: true,
+            status: 200,
+            data: { success: true },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: getErrorMessage(err),
+        };
+    }
+};
+/**
+ * POST /:branch/schema/invalidate-cache - Invalidate schema cache (for debugging/manual refresh)
+ */
+const invalidateSchemaCacheHandler = async (gc, ctx, _req, _params) => {
+    const { branchContext } = gc;
+    try {
+        await ctx.services.branchSchemaCache.invalidate(branchContext.branchRoot);
+        return {
+            ok: true,
+            status: 200,
+            data: {
+                success: true,
+                message: 'Schema cache invalidated. Next schema load will regenerate cache.',
+            },
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 500,
+            error: getErrorMessage(err),
+        };
+    }
+};
+// ============================================================================
+// Route Definitions
+// ============================================================================
+/**
+ * GET /:branch/schema - Get full schema
+ */
+export const getSchema = defineEndpoint({
+    namespace: 'schema',
+    name: 'get',
+    method: 'GET',
+    path: '/:branch/schema',
+    params: branchParamsSchema,
+    responseType: 'GetSchemaApiResponse',
+    response: {},
+    defaultMockData: { flatSchema: [], entrySchemas: {} },
+    guards: ['branchAccessWithSchema'],
+    handler: getSchemaHandler,
+});
+/**
+ * GET /:branch/schema/collection/...collectionPath - Get single collection
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+export const getCollection = defineEndpoint({
+    namespace: 'schema',
+    name: 'getCollection',
+    method: 'GET',
+    path: '/:branch/schema/collection/...collectionPath',
+    params: collectionParamsSchema,
+    responseType: 'GetCollectionApiResponse',
+    response: {},
+    defaultMockData: { collection: null },
+    guards: ['branchAccessWithSchema'],
+    handler: getCollectionHandler,
+});
+/**
+ * POST /:branch/schema/collections - Create collection
+ */
+export const createCollection = defineEndpoint({
+    namespace: 'schema',
+    name: 'createCollection',
+    method: 'POST',
+    path: '/:branch/schema/collections',
+    params: branchParamsSchema,
+    body: createCollectionBodySchema,
+    bodyType: 'CreateCollectionInput',
+    responseType: 'CreateCollectionApiResponse',
+    response: {},
+    defaultMockData: { collectionPath: '', contentId: '' },
+    mockDataCasts: {
+        collectionPath: 'createLogicalPath',
+        contentId: 'as ContentId',
+    },
+    guards: ['admin'],
+    handler: createCollectionHandler,
+});
+/**
+ * PATCH /:branch/schema/collection/...collectionPath - Update collection
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+export const updateCollection = defineEndpoint({
+    namespace: 'schema',
+    name: 'updateCollection',
+    method: 'PATCH',
+    path: '/:branch/schema/collection/...collectionPath',
+    params: collectionParamsSchema,
+    body: updateCollectionBodySchema,
+    bodyType: 'UpdateCollectionInput',
+    responseType: 'UpdateCollectionApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: updateCollectionHandler,
+});
+/**
+ * DELETE /:branch/schema/collection/...collectionPath - Delete collection
+ * Note: Uses 'collection' (singular) with catch-all to support paths with slashes
+ */
+export const deleteCollection = defineEndpoint({
+    namespace: 'schema',
+    name: 'deleteCollection',
+    method: 'DELETE',
+    path: '/:branch/schema/collection/...collectionPath',
+    params: collectionParamsSchema,
+    responseType: 'DeleteCollectionApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: deleteCollectionHandler,
+});
+/**
+ * POST /:branch/schema/entry-types/...collectionPath - Add entry type
+ * Note: Restructured URL with catch-all at end to support paths with slashes
+ */
+export const addEntryType = defineEndpoint({
+    namespace: 'schema',
+    name: 'addEntryType',
+    method: 'POST',
+    path: '/:branch/schema/entry-types/...collectionPath',
+    params: collectionParamsSchema,
+    body: addEntryTypeBodySchema,
+    bodyType: 'CreateEntryTypeInput',
+    responseType: 'AddEntryTypeApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: addEntryTypeHandler,
+});
+/**
+ * PATCH /:branch/schema/entry-types/:entryTypeName/...collectionPath - Update entry type
+ * Note: Restructured URL with entry type name before catch-all path
+ */
+export const updateEntryType = defineEndpoint({
+    namespace: 'schema',
+    name: 'updateEntryType',
+    method: 'PATCH',
+    path: '/:branch/schema/entry-types/:entryTypeName/...collectionPath',
+    params: entryTypeParamsSchema,
+    body: updateEntryTypeBodySchema,
+    bodyType: 'UpdateEntryTypeInput',
+    responseType: 'UpdateEntryTypeApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: updateEntryTypeHandler,
+});
+/**
+ * DELETE /:branch/schema/entry-types/:entryTypeName/...collectionPath - Remove entry type
+ * Note: Restructured URL with entry type name before catch-all path
+ */
+export const removeEntryType = defineEndpoint({
+    namespace: 'schema',
+    name: 'removeEntryType',
+    method: 'DELETE',
+    path: '/:branch/schema/entry-types/:entryTypeName/...collectionPath',
+    params: entryTypeParamsSchema,
+    responseType: 'RemoveEntryTypeApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: removeEntryTypeHandler,
+});
+/**
+ * PATCH /:branch/schema/order/...collectionPath - Update item order
+ * Note: Restructured URL with catch-all at end to support paths with slashes
+ */
+export const updateOrder = defineEndpoint({
+    namespace: 'schema',
+    name: 'updateOrder',
+    method: 'PATCH',
+    path: '/:branch/schema/order/...collectionPath',
+    params: collectionParamsSchema,
+    body: updateOrderBodySchema,
+    bodyType: 'UpdateOrderBody',
+    responseType: 'UpdateOrderApiResponse',
+    response: {},
+    defaultMockData: { success: true },
+    guards: ['admin'],
+    handler: updateOrderHandler,
+});
+/**
+ * POST /:branch/schema/invalidate-cache - Invalidate schema cache
+ */
+export const invalidateSchemaCache = defineEndpoint({
+    namespace: 'schema',
+    name: 'invalidateSchemaCache',
+    method: 'POST',
+    path: '/:branch/schema/invalidate-cache',
+    params: branchParamsSchema,
+    responseType: 'InvalidateSchemaCacheApiResponse',
+    response: {},
+    defaultMockData: { success: true, message: 'Cache invalidated' },
+    guards: ['admin', 'branch'],
+    handler: invalidateSchemaCacheHandler,
+});
+export const SCHEMA_ROUTES = {
+    get: getSchema,
+    getCollection,
+    createCollection,
+    updateCollection,
+    deleteCollection,
+    addEntryType,
+    updateEntryType,
+    removeEntryType,
+    updateOrder,
+    invalidateSchemaCache,
+};
+//# sourceMappingURL=schema.js.map