@cms0/cms0 0.2.11 → 0.2.12

package/dist/esm/index.js

@@ -1,3 +1,4 @@
+import { attachCms0ProvenanceRoot, enableCms0ProvenanceTracking, isCms0CanvasTransportEnabled, registerCms0CollectionItemIdentity, } from "@cms0/cms0/provenance";
 import { schemaDescriptor } from "@cms0/cms0/schema-descriptors";
 import { buildZodSchemasFromDescriptor, decodeTaggedUnionValue, getUnionBranchKeys, } from "@cms0/shared";
 import { getCustomInlineTypeMetadata } from "./custom-types/registry.js";
@@ -508,6 +509,44 @@ function ensureCollectionEnvelope(data, path) {
     }
     throw new Error(`${COLLECTION_SHAPE_ERROR} Path: '${path}'.`);
 }
+async function readCanvasModelRefCollectionIdentities(path, descriptor, context) {
+    const cache = context.canvasModelRefCollectionIdentityCache;
+    if (!cache)
+        return null;
+    const cacheKey = [
+        path,
+        descriptor.model,
+        context.options.locale ?? "",
+    ].join("::");
+    const existing = cache.get(cacheKey);
+    if (existing) {
+        return existing;
+    }
+    const pending = (async () => {
+        try {
+            const rawCollection = await context.requestJson(path, {
+                query: {
+                    raw: 1,
+                    includeId: 1,
+                    resolveModelRefs: 0,
+                    ...(context.options.locale ? { locale: context.options.locale } : {}),
+                },
+            });
+            const envelope = ensureCollectionEnvelope(rawCollection, path);
+            return envelope.items.map((row) => ({
+                relationId: extractId(row) ?? "",
+                modelId: extractModelRefId(row, descriptor.model, {
+                    allowObjectIdFallback: false,
+                }) ?? null,
+            }));
+        }
+        catch {
+            return null;
+        }
+    })();
+    cache.set(cacheKey, pending);
+    return pending;
+}
 async function normalizeModelRef(modelName, id, context, trail, isCollectionItem, inlineValue) {
     if (!id)
         return null;
@@ -610,7 +649,7 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
                         ...(context.options.locale ? { locale: context.options.locale } : {}),
                     },
                 });
-            const normalizedChild = await normalizeArrayField(propertyDescriptor, childPath, childRaw, context, trail);
+            const normalizedChild = await normalizeArrayField(propertyDescriptor, childPath, childRaw, context, trail, inlineChildRaw !== undefined);
             output[propertyName] = coerceCustomTypeValue(propertyDescriptor, normalizedChild, {
                 locale: context.options.locale,
                 defaultLocale: context.options.defaultLocale,
@@ -653,7 +692,7 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
     }
     return maybeAttachAssetUrl(output, context.options.assetUrlBuilder);
 }
-async function normalizeArrayField(descriptor, path, raw, context, trail) {
+async function normalizeArrayField(descriptor, path, raw, context, trail, inlineResolvedItems = false) {
     const envelope = ensureCollectionEnvelope(raw, path);
     const itemDescriptor = descriptor.items;
     if (isScalarDescriptor(itemDescriptor)) {
@@ -673,14 +712,29 @@ async function normalizeArrayField(descriptor, path, raw, context, trail) {
     }
     if (isModelRefDescriptor(itemDescriptor)) {
         const inlineModelDescriptor = context.modelDescriptors.get(itemDescriptor.model);
-        return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row) => {
+        const collectionIdentities = await readCanvasModelRefCollectionIdentities(path, itemDescriptor, context);
+        return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row, index) => {
             const inlineModel = inlineModelDescriptor
                 ? extractInlineModelObject(row, inlineModelDescriptor)
                 : null;
             const refId = extractModelRefId(row, itemDescriptor.model, {
                 allowObjectIdFallback: false,
             }) ?? (inlineModel ? extractId(inlineModel) : null);
-            return normalizeModelRef(itemDescriptor.model, refId, context, trail, true, row);
+            const normalized = await normalizeModelRef(itemDescriptor.model, refId, context, trail, true, row);
+            const collectionItemId = collectionIdentities?.[index]?.relationId ??
+                (inlineResolvedItems ? null : extractId(row));
+            if (!collectionItemId ||
+                !normalized ||
+                typeof normalized !== "object" ||
+                Array.isArray(normalized)) {
+                return normalized;
+            }
+            const normalizedClone = {
+                ...normalized,
+            };
+            registerCms0CollectionItemIdentity(normalizedClone, collectionItemId);
+            delete normalizedClone.__cms0CanvasCollectionItemId;
+            return normalizedClone;
         });
     }
     if (isObjectDescriptor(itemDescriptor)) {
@@ -1068,7 +1122,19 @@ function validateResult(resource, result, descriptor, includeIdMode, zodSchemas,
         throw new Error(formatValidationError(modelName, parsed.error));
     }
 }
-async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale, assetUrlBuilder, zodSchemas, modelZodSchemas, globalIncludeId, sharedModelInflightCache, options, byId) {
+function attachResourceProvenance(resource, value) {
+    return attachResourceProvenanceWithOptions(resource, value);
+}
+function attachResourceProvenanceWithOptions(resource, value, options) {
+    if (value === null || value === undefined)
+        return value;
+    enableCms0ProvenanceTracking(true);
+    const rootId = resource.kind === "root"
+        ? resource.key
+        : resource.modelName ?? resource.key;
+    return attachCms0ProvenanceRoot(value, rootId, options);
+}
+async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale, assetUrlBuilder, zodSchemas, modelZodSchemas, globalIncludeId, sharedModelInflightCache, options, byId, provenanceOptions) {
     const responseMode = options?.response ?? "normalized";
     const includeIdMode = resolveIncludeIdMode(options?.includeId, globalIncludeId);
     const resolveModelRefs = options?.resolveModelRefs !== false;
@@ -1154,6 +1220,9 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
         modelDescriptors,
         modelCache: new Map(),
         sharedModelInflightCache,
+        canvasModelRefCollectionIdentityCache: useResolvedEndpoint && isCms0CanvasTransportEnabled()
+            ? new Map()
+            : undefined,
         options: {
             includeIdMode,
             resolveModelRefs,
@@ -1178,16 +1247,16 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
             const projectedItems = applyFieldProjection(normalizedItems, options?.fields, options?.exclude);
             validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
             return {
-                items: Array.isArray(projectedItems) ? projectedItems : normalizedItems,
+                items: attachResourceProvenanceWithOptions(resource, Array.isArray(projectedItems) ? projectedItems : normalizedItems, provenanceOptions),
                 total: envelope.total,
             };
         }
         validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-        return normalizedItems;
+        return attachResourceProvenanceWithOptions(resource, normalizedItems, provenanceOptions);
     }
     const normalized = await normalizeField(resource.descriptor, normalizePath, rawData, context, new Set(), false);
     validateResult(resource, normalized, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-    return applyFieldProjection(normalized, options?.fields, options?.exclude);
+    return attachResourceProvenanceWithOptions(resource, applyFieldProjection(normalized, options?.fields, options?.exclude), provenanceOptions);
 }
 export function createCmsClient(descriptor, config) {
     const baseUrl = normalizeBaseUrl(config.apiConfig?.baseUrl);
@@ -1223,6 +1292,29 @@ export function createCmsClient(descriptor, config) {
         defaultLocale: config.defaultLocale,
         includeIdDefault: !!config.includeId,
     };
+    const readRoot = async (rootId, options) => {
+        const entry = registry.roots.get(rootId) ??
+            registry.rootsCaseInsensitive.get(rootId.toLowerCase());
+        if (!entry) {
+            throw new Error(`cms0: unknown root '${rootId}' for Canvas read-back.`);
+        }
+        return runResource(entry, descriptor, baseUrl, options?.apiKey ?? apiKey, config.defaultLocale, assetUrlBuilder, zodSchemas, modelZodSchemas, globalIncludeId, sharedModelInflightCache, {
+            includeId: options?.includeId ?? true,
+            locale: options?.locale ?? "all",
+        }, undefined, {
+            registerLiveRoot: false,
+        });
+    };
+    globalThis.__CMS0_CANVAS_CLIENT__ = {
+        apiBaseUrl: baseUrl,
+        locales: clientMeta.locales,
+        defaultLocale: clientMeta.defaultLocale,
+        publishTriggerId: typeof config.canvas?.publishTriggerId === "string" &&
+            config.canvas.publishTriggerId.trim().length > 0
+            ? config.canvas.publishTriggerId.trim()
+            : undefined,
+        readRoot,
+    };
     const rootProxyTarget = {
         models: modelsProxy,
         meta: clientMeta,
@@ -1250,4 +1342,5 @@ export function createCmsClient(descriptor, config) {
 export function cms0(config) {
     return createCmsClient(schemaDescriptor, config);
 }
+export { activateCms0CanvasTransport, attachCms0ProvenanceRoot, captureCms0Provenance, enableCms0ProvenanceTracking, readCms0CanvasTransportCollectionItemId, readCms0CollectionItemIdentity, registerCms0LiveRoot, registerCms0CollectionItemIdentity, readCms0LiveRoots, readCms0ProvenanceValueMeta, restoreCms0CanvasTransportMetadata, unwrapCms0CanvasTransportValue, } from "./provenance.js";
 export { resolveLocalized, toNextMetadata, toOpenGraph, toTwitter, } from "./seo.js";

package/dist/esm/libs/cli/descriptor-builder-alt.js

@@ -68,6 +68,65 @@ function collectModelNames(sourceFiles) {
     });
     return names;
 }
+function isDescriptorSourceFile(filePath) {
+    if (filePath.includes("node_modules"))
+        return false;
+    if (filePath.endsWith(".d.ts"))
+        return false;
+    return true;
+}
+function collectTypeSourceFiles(type, sourceFiles, visited) {
+    const { base } = unwrapOptional(type);
+    const aliasSymbol = base.getAliasSymbol();
+    const symbol = base.getSymbol();
+    const key = `${aliasSymbol?.getName() ?? symbol?.getName() ?? "<anon>"}:${base.getText()}`;
+    if (visited.has(key))
+        return;
+    visited.add(key);
+    if (base.isUnion()) {
+        base
+            .getUnionTypes()
+            .forEach((entry) => collectTypeSourceFiles(entry, sourceFiles, visited));
+        return;
+    }
+    if (base.isArray()) {
+        const elem = base.getArrayElementTypeOrThrow();
+        collectTypeSourceFiles(elem, sourceFiles, visited);
+        return;
+    }
+    const customName = resolveCustomTypeName(base);
+    if (customName) {
+        return;
+    }
+    const declarations = [
+        ...(aliasSymbol?.getDeclarations() ?? []),
+        ...(symbol?.getDeclarations() ?? []),
+    ];
+    declarations.forEach((decl) => {
+        const sourceFile = decl.getSourceFile();
+        const filePath = path.resolve(sourceFile.getFilePath());
+        if (!isDescriptorSourceFile(filePath))
+            return;
+        sourceFiles.set(filePath, sourceFile);
+    });
+    if (base.isObject()) {
+        base.getProperties().forEach((prop) => {
+            const decl = prop.getDeclarations()[0];
+            if (!decl)
+                return;
+            collectTypeSourceFiles(decl.getType(), sourceFiles, visited);
+        });
+    }
+}
+function collectRelevantSourceFiles(rootType, entrySourceFile) {
+    const sourceFiles = new Map();
+    const entryFilePath = path.resolve(entrySourceFile.getFilePath());
+    if (isDescriptorSourceFile(entryFilePath)) {
+        sourceFiles.set(entryFilePath, entrySourceFile);
+    }
+    collectTypeSourceFiles(rootType, sourceFiles, new Set());
+    return Array.from(sourceFiles.values());
+}
 function collectReferencedModelNames(type, names, visited, ctx) {
     const { base } = unwrapOptional(type);
     const key = `${ctx}:${base.getText()}`;
@@ -499,19 +558,15 @@ function buildDescriptorAlt(resolved) {
         fs.existsSync(resolved.entryFile)) {
         project.addSourceFileAtPath(resolved.entryFile);
     }
-    const sourceFiles = project.getSourceFiles().filter((sf) => {
-        const filePath = path.resolve(sf.getFilePath());
-        if (filePath.includes("node_modules"))
-            return false;
-        if (filePath.endsWith(".d.ts"))
-            return false;
-        const rel = path.relative(path.dirname(resolved.entryFile), filePath);
-        return rel && !rel.startsWith("..") && !path.isAbsolute(rel);
-    });
-    const invocation = findRootInvocation(sourceFiles);
+    const entrySourceFile = project.getSourceFile(resolved.entryFile);
+    if (!entrySourceFile) {
+        throw new Error(`Could not load cms0 entry file: ${resolved.entryFile}`);
+    }
+    const invocation = findRootInvocation([entrySourceFile]);
     if (!invocation)
         throw new Error("Could not locate cms0<T>() invocation in project sources.");
     const rootType = invocation.rootType;
+    const sourceFiles = collectRelevantSourceFiles(rootType, entrySourceFile);
     // Restrict models to only those referenced by the root type tree and exported in scope.
     const exportedModelNames = collectModelNames(sourceFiles);
     const collisions = Array.from(customTypeNames).filter((name) => exportedModelNames.has(name));

package/dist/esm/libs/cli/publisher.js

@@ -1,4 +1,21 @@
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class PublishHttpError extends Error {
+    status;
+    constructor(status) {
+        super(`status ${status}`);
+        this.name = "PublishHttpError";
+        this.status = status;
+    }
+}
+function isRetryablePublishStatus(status) {
+    return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function shouldRetryPublishError(error) {
+    if (error instanceof PublishHttpError) {
+        return isRetryablePublishStatus(error.status);
+    }
+    return true;
+}
 const startSpinner = (label) => {
     if (!process.stdout.isTTY) {
         console.log(`${label}...`);
@@ -73,7 +90,7 @@ async function publishDescriptor(resolved, descriptor) {
                     body: JSON.stringify(payload),
                 });
                 if (!res.ok) {
-                    throw new Error(`status ${res.status}`);
+                    throw new PublishHttpError(res.status);
                 }
                 const ready = await waitForAdminReady(resolved.apiBaseUrl.replace(/\/$/, ""), headers);
                 if (!ready) {
@@ -83,13 +100,15 @@ async function publishDescriptor(resolved, descriptor) {
                 return;
             }
             catch (err) {
+                const canRetry = attempt < maxAttempts && shouldRetryPublishError(err);
                 const waitMs = Math.min(2000 * attempt, 5000);
-                console.warn(`cms0: publish attempt ${attempt}/${maxAttempts} failed (${err instanceof Error ? err.message : err}).` + (attempt < maxAttempts ? ` retrying in ${waitMs}ms...` : ""));
-                if (attempt < maxAttempts) {
+                console.warn(`cms0: publish attempt ${attempt}/${maxAttempts} failed (${err instanceof Error ? err.message : err}).` + (canRetry ? ` retrying in ${waitMs}ms...` : ""));
+                if (canRetry) {
                     await new Promise((r) => setTimeout(r, waitMs));
                 }
                 else {
                     console.warn("cms0: giving up on publishing descriptor for now.");
+                    return;
                 }
             }
         }
@@ -98,4 +117,4 @@ async function publishDescriptor(resolved, descriptor) {
         console.warn(`cms0: failed to publish descriptor ${err instanceof Error ? err.message : err}`, err);
     }
 }
-export { publishDescriptor };
+export { isRetryablePublishStatus, publishDescriptor };