@cms0/cms0 0.2.6 → 0.2.8

package/dist/esm/custom-types/registry.js

@@ -1,3 +1,4 @@
+import { computeUnionBranchKeys, } from "@cms0/shared";
 const primitive = (type) => ({
     kind: "primitive",
     type,
@@ -49,6 +50,237 @@ const localizedRichTextDescriptor = {
     type: "json",
     customType: "LocalizedRichText",
 };
+function createUnionDescriptor(branches) {
+    return {
+        kind: "union",
+        anyOf: branches,
+        branchKeys: computeUnionBranchKeys(branches),
+    };
+}
+const localizedOrStringDescriptor = createUnionDescriptor([
+    localizedStringDescriptor,
+    {
+        kind: "primitive",
+        type: "string",
+    },
+]);
+const keywordsDescriptor = createUnionDescriptor([
+    localizedStringDescriptor,
+    {
+        type: "array",
+        items: {
+            kind: "primitive",
+            type: "string",
+        },
+    },
+]);
+const robotsDescriptor = createUnionDescriptor([
+    {
+        kind: "primitive",
+        type: "boolean",
+    },
+    {
+        type: "object",
+        properties: {
+            index: {
+                kind: "primitive",
+                type: "boolean",
+                optional: true,
+                nullable: false,
+            },
+            follow: {
+                kind: "primitive",
+                type: "boolean",
+                optional: true,
+                nullable: false,
+            },
+            nocache: {
+                kind: "primitive",
+                type: "boolean",
+                optional: true,
+                nullable: false,
+            },
+        },
+    },
+]);
+const alternatesDescriptor = {
+    type: "object",
+    properties: {
+        canonical: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        languages: {
+            kind: "primitive",
+            type: "json",
+            optional: true,
+            nullable: false,
+        },
+    },
+};
+const imageOrStringDescriptor = createUnionDescriptor([
+    {
+        kind: "modelRef",
+        model: "Image",
+    },
+    {
+        kind: "primitive",
+        type: "string",
+    },
+]);
+const openGraphDescriptor = {
+    type: "object",
+    properties: {
+        type: {
+            kind: "enum",
+            valueType: "string",
+            values: ["website", "article", "profile"],
+            optional: true,
+            nullable: false,
+        },
+        url: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        siteName: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        title: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        description: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        images: {
+            type: "array",
+            items: imageOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        locale: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        alternateLocale: {
+            type: "array",
+            items: {
+                kind: "primitive",
+                type: "string",
+            },
+            optional: true,
+            nullable: false,
+        },
+    },
+};
+const twitterDescriptor = {
+    type: "object",
+    properties: {
+        card: {
+            kind: "enum",
+            valueType: "string",
+            values: ["summary", "summary_large_image", "app", "player"],
+            optional: true,
+            nullable: false,
+        },
+        site: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        creator: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        title: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        description: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        images: {
+            type: "array",
+            items: imageOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+    },
+};
+const seoDescriptor = {
+    type: "object",
+    customType: "Seo",
+    properties: {
+        title: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        description: {
+            ...localizedOrStringDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        keywords: {
+            ...keywordsDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        canonical: {
+            kind: "primitive",
+            type: "string",
+            optional: true,
+            nullable: false,
+        },
+        robots: {
+            ...robotsDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        alternates: {
+            ...alternatesDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        openGraph: {
+            ...openGraphDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        twitter: {
+            ...twitterDescriptor,
+            optional: true,
+            nullable: false,
+        },
+        jsonLd: {
+            type: "array",
+            items: {
+                kind: "primitive",
+                type: "json",
+            },
+            optional: true,
+            nullable: false,
+        },
+    },
+};
 export const customModelDescriptors = {
     File: fileDescriptor,
     Image: imageDescriptor,
@@ -58,6 +290,7 @@ export const customInlineDescriptors = {
     RichText: richTextDescriptor,
     LocalizedString: localizedStringDescriptor,
     LocalizedRichText: localizedRichTextDescriptor,
+    Seo: seoDescriptor,
 };
 export const customInlineTypeMetadata = {
     RichText: {},
@@ -67,6 +300,7 @@ export const customInlineTypeMetadata = {
     LocalizedRichText: {
         includeId: { mapLikeFields: ["locales"] },
     },
+    Seo: {},
 };
 export const customTypeDescriptors = {
     ...customModelDescriptors,
@@ -85,13 +319,20 @@ export function resolveCustomTypeDependencies(names) {
         const name = queue.shift();
         if (!name || resolved.has(name))
             continue;
-        const descriptor = customModelDescriptors[name];
+        const modelDescriptor = customModelDescriptors[name];
+        const inlineDescriptor = customInlineDescriptors[name];
+        const descriptor = modelDescriptor ?? inlineDescriptor;
         if (!descriptor)
             continue;
         resolved.add(name);
         const refs = new Set();
-        for (const prop of Object.values(descriptor.properties)) {
-            collectModelRefs(prop, refs);
+        if (modelDescriptor) {
+            for (const prop of Object.values(modelDescriptor.properties)) {
+                collectModelRefs(prop, refs);
+            }
+        }
+        else {
+            collectModelRefs(inlineDescriptor, refs);
         }
         refs.forEach((ref) => {
             if (customTypeDescriptors[ref] && !resolved.has(ref)) {
@@ -106,11 +347,15 @@ function collectModelRefs(desc, out) {
         out.add(desc.model);
         return;
     }
-    if (desc.type === "array") {
+    if ("type" in desc && desc.type === "array") {
         collectModelRefs(desc.items, out);
         return;
     }
-    if (desc.type === "object") {
+    if ("type" in desc && desc.type === "object") {
         Object.values(desc.properties).forEach((child) => collectModelRefs(child, out));
+        return;
+    }
+    if (desc.kind === "union") {
+        desc.anyOf.forEach((branch) => collectModelRefs(branch, out));
     }
 }

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 import { schemaDescriptor } from "@cms0/cms0/schema-descriptors";
-import { buildZodSchemasFromDescriptor, } from "@cms0/shared";
+import { buildZodSchemasFromDescriptor, decodeTaggedUnionValue, getUnionBranchKeys, } from "@cms0/shared";
 import { getCustomInlineTypeMetadata } from "./custom-types/registry.js";
 const DEFAULT_MODEL_NORMALIZATION_CONCURRENCY = 8;
 const COLLECTION_SHAPE_ERROR = "Invalid collection response. Expected array or { items, total }.";
@@ -105,6 +105,9 @@ function snakeCaseModelIdKey(modelName) {
         .toLowerCase();
     return `${snake}_id`;
 }
+function isUuidLikeId(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
 function extractModelRefId(raw, modelName, options) {
     if (typeof raw === "string")
         return raw;
@@ -145,6 +148,15 @@ function extractModelRefId(raw, modelName, options) {
 function isPrimitiveDescriptor(desc) {
     return desc.kind === "primitive";
 }
+function isEnumDescriptor(desc) {
+    return desc.kind === "enum" && Array.isArray(desc.values);
+}
+function isUnionDescriptor(desc) {
+    return desc.kind === "union" && Array.isArray(desc.anyOf);
+}
+function isScalarDescriptor(desc) {
+    return isPrimitiveDescriptor(desc) || isEnumDescriptor(desc) || isUnionDescriptor(desc);
+}
 function isModelRefDescriptor(desc) {
     return desc.kind === "modelRef";
 }
@@ -162,7 +174,7 @@ function attachIdIfObject(value, id) {
     }
     return value;
 }
-function attachIdForPrimitiveDescriptor(descriptor, value, id) {
+function attachIdForScalarDescriptor(descriptor, value, id) {
     const withId = attachIdIfObject(value, id);
     if (!withId || typeof withId !== "object" || Array.isArray(withId)) {
         return withId;
@@ -358,6 +370,23 @@ function coerceLocalizedRichTextValue(value, locale, defaultLocale) {
     }
     return projectLocalizedByLocale(normalized, locale);
 }
+function coerceSeoValue(value) {
+    if (value == null)
+        return value;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const source = value;
+    const keys = Object.keys(source).filter((key) => key !== "id");
+    if (keys.length === 1 &&
+        keys[0] === "value" &&
+        source.value &&
+        typeof source.value === "object" &&
+        !Array.isArray(source.value)) {
+        return source.value;
+    }
+    return source;
+}
 function coerceCustomTypeValue(descriptor, value, options) {
     const customType = descriptor.customType;
     if (!customType)
@@ -373,8 +402,81 @@ function coerceCustomTypeValue(descriptor, value, options) {
     if (customType === "LocalizedRichText") {
         return coerceLocalizedRichTextValue(value, options?.locale, options?.defaultLocale);
     }
+    if (customType === "Seo") {
+        return coerceSeoValue(value);
+    }
     return value;
 }
+function coercePrimitiveValueByType(type, value) {
+    if (type === "string") {
+        if (value == null)
+            return "";
+        return typeof value === "string" ? value : String(value);
+    }
+    if (type === "number") {
+        if (typeof value === "number")
+            return Number.isFinite(value) ? value : null;
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    if (type === "boolean") {
+        if (typeof value === "boolean")
+            return value;
+        if (value === "true" || value === "1" || value === 1)
+            return true;
+        if (value === "false" || value === "0" || value === 0)
+            return false;
+        return Boolean(value);
+    }
+    return value;
+}
+function coerceEnumValue(descriptor, value) {
+    const valueType = (descriptor.valueType ?? "string");
+    const coerced = coercePrimitiveValueByType(valueType, value);
+    const values = Array.isArray(descriptor.values)
+        ? descriptor.values
+        : [];
+    if (!values.length)
+        return coerced;
+    if (values.some((entry) => Object.is(entry, coerced))) {
+        return coerced;
+    }
+    return values[0];
+}
+function decodeUnionEnvelope(descriptor, raw) {
+    const decoded = decodeTaggedUnionValue(raw);
+    if (!decoded)
+        return null;
+    const branches = Array.isArray(descriptor.anyOf)
+        ? descriptor.anyOf
+        : [];
+    if (!branches.length)
+        return null;
+    const branchKeys = getUnionBranchKeys(descriptor);
+    const branchIndex = branchKeys.findIndex((key) => key === decoded.branchKey);
+    if (branchIndex < 0 || branchIndex >= branches.length)
+        return null;
+    const branchDescriptor = branches[branchIndex];
+    if (!branchDescriptor)
+        return null;
+    return {
+        branchDescriptor,
+        branchValue: decoded.value,
+    };
+}
+function decodeUnionValueFromRawField(descriptor, raw) {
+    const direct = decodeUnionEnvelope(descriptor, raw);
+    if (direct) {
+        return { ...direct, rowId: extractId(raw) };
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw) && "value" in raw) {
+        const nested = decodeUnionEnvelope(descriptor, raw.value);
+        if (nested) {
+            return { ...nested, rowId: extractId(raw) };
+        }
+    }
+    return null;
+}
 function ensureCollectionEnvelope(data, path) {
     if (Array.isArray(data)) {
         return { items: data, total: data.length };
@@ -446,12 +548,8 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
     const source = raw && typeof raw === "object" ? raw : {};
     const output = {};
     for (const [propertyName, propertyDescriptor] of Object.entries(descriptor.properties)) {
-        if (isPrimitiveDescriptor(propertyDescriptor)) {
-            output[propertyName] = coerceCustomTypeValue(propertyDescriptor, source[propertyName], {
-                locale: context.options.locale,
-                defaultLocale: context.options.defaultLocale,
-                assetUrlBuilder: context.options.assetUrlBuilder,
-            });
+        if (isScalarDescriptor(propertyDescriptor)) {
+            output[propertyName] = await normalizeField(propertyDescriptor, `${path}/${propertyName}`, source[propertyName], context, trail, false);
             continue;
         }
         if (isModelRefDescriptor(propertyDescriptor)) {
@@ -539,16 +637,14 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
 async function normalizeArrayField(descriptor, path, raw, context, trail) {
     const envelope = ensureCollectionEnvelope(raw, path);
     const itemDescriptor = descriptor.items;
-    if (isPrimitiveDescriptor(itemDescriptor)) {
-        return envelope.items.map((row) => {
-            const value = row && typeof row === "object" && "value" in row
-                ? row.value
-                : row;
+    if (isScalarDescriptor(itemDescriptor)) {
+        return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row) => {
+            const normalizedValue = await normalizeField(itemDescriptor, path, row, context, trail, true);
             if (context.options.includeIdMode !== "all") {
-                return value;
+                return normalizedValue;
             }
             const id = extractId(row);
-            const valueWithId = attachIdForPrimitiveDescriptor(itemDescriptor, value, id);
+            const valueWithId = attachIdForScalarDescriptor(itemDescriptor, normalizedValue, id);
             const isObjectValue = valueWithId && typeof valueWithId === "object" && !Array.isArray(valueWithId);
             if (!id) {
                 return valueWithId;
@@ -579,6 +675,60 @@ async function normalizeArrayField(descriptor, path, raw, context, trail) {
     }
     return envelope.items;
 }
+async function normalizeInlineField(descriptor, raw, context, trail, isCollectionItem) {
+    if (isPrimitiveDescriptor(descriptor)) {
+        return coerceCustomTypeValue(descriptor, raw, {
+            locale: context.options.locale,
+            defaultLocale: context.options.defaultLocale,
+            assetUrlBuilder: context.options.assetUrlBuilder,
+        });
+    }
+    if (isEnumDescriptor(descriptor)) {
+        return coerceEnumValue(descriptor, raw);
+    }
+    if (isUnionDescriptor(descriptor)) {
+        if (raw == null)
+            return raw;
+        const decoded = decodeUnionEnvelope(descriptor, raw);
+        if (!decoded) {
+            return null;
+        }
+        return normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem);
+    }
+    if (isModelRefDescriptor(descriptor)) {
+        const refId = extractModelRefId(raw, descriptor.model, {
+            allowObjectIdFallback: true,
+        });
+        if (!refId) {
+            return missingModelRefValue(descriptor);
+        }
+        return normalizeModelRef(descriptor.model, refId, context, trail, isCollectionItem, raw);
+    }
+    if (isArrayDescriptor(descriptor)) {
+        const source = Array.isArray(raw) ? raw : [];
+        const normalized = await mapWithConcurrency(source, context.options.modelNormalizationConcurrency, async (entry) => normalizeInlineField(descriptor.items, entry, context, trail, true));
+        return coerceCustomTypeValue(descriptor, normalized, {
+            locale: context.options.locale,
+            defaultLocale: context.options.defaultLocale,
+            assetUrlBuilder: context.options.assetUrlBuilder,
+        });
+    }
+    if (isObjectDescriptor(descriptor)) {
+        const source = raw && typeof raw === "object" && !Array.isArray(raw)
+            ? raw
+            : {};
+        const output = {};
+        for (const [propertyName, propertyDescriptor] of Object.entries(descriptor.properties)) {
+            output[propertyName] = await normalizeInlineField(propertyDescriptor, source[propertyName], context, trail, false);
+        }
+        return coerceCustomTypeValue(descriptor, output, {
+            locale: context.options.locale,
+            defaultLocale: context.options.defaultLocale,
+            assetUrlBuilder: context.options.assetUrlBuilder,
+        });
+    }
+    return raw;
+}
 async function normalizeField(descriptor, path, raw, context, trail, isCollectionItem) {
     if (isPrimitiveDescriptor(descriptor)) {
         const value = raw && typeof raw === "object" && "value" in raw
@@ -591,10 +741,33 @@ async function normalizeField(descriptor, path, raw, context, trail, isCollectio
         });
         if (shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)) {
             const id = extractId(raw);
-            coerced = attachIdForPrimitiveDescriptor(descriptor, coerced, id);
+            coerced = attachIdForScalarDescriptor(descriptor, coerced, id);
         }
         return coerced;
     }
+    if (isEnumDescriptor(descriptor)) {
+        const value = raw && typeof raw === "object" && "value" in raw
+            ? raw.value
+            : raw;
+        let coerced = coerceEnumValue(descriptor, value);
+        if (shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)) {
+            const id = extractId(raw);
+            coerced = attachIdForScalarDescriptor(descriptor, coerced, id);
+        }
+        return coerced;
+    }
+    if (isUnionDescriptor(descriptor)) {
+        const decoded = decodeUnionValueFromRawField(descriptor, raw);
+        if (!decoded) {
+            return null;
+        }
+        let normalized = await normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem);
+        if (shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)) {
+            const id = decoded.rowId ?? extractId(raw);
+            normalized = attachIdForScalarDescriptor(descriptor, normalized, id);
+        }
+        return normalized;
+    }
     if (isModelRefDescriptor(descriptor)) {
         const inlineModelDescriptor = context.modelDescriptors.get(descriptor.model);
         const inlineModel = inlineModelDescriptor
@@ -881,14 +1054,25 @@ export function createCmsClient(descriptor, config) {
             return buildModelAccessor(modelEntry);
         },
     });
-    const rootProxy = new Proxy({}, {
-        get(_target, property) {
-            if (typeof property !== "string")
-                return undefined;
+    const clientMeta = {
+        locales: config.locales ?? [],
+        defaultLocale: config.defaultLocale,
+        includeIdDefault: !!config.includeId,
+    };
+    const rootProxyTarget = {
+        models: modelsProxy,
+        meta: clientMeta,
+    };
+    const rootProxy = new Proxy(rootProxyTarget, {
+        get(target, property, receiver) {
+            if (typeof property !== "string") {
+                return Reflect.get(target, property, receiver);
+            }
             if (property === "then")
                 return undefined;
-            if (property === "models")
-                return modelsProxy;
+            if (Reflect.has(target, property)) {
+                return Reflect.get(target, property, receiver);
+            }
             const entry = registry.roots.get(property) ??
                 registry.rootsCaseInsensitive.get(property.toLowerCase());
             if (!entry) {
@@ -897,14 +1081,9 @@ export function createCmsClient(descriptor, config) {
             return async (options) => runResource(entry, descriptor, baseUrl, apiKey, config.defaultLocale, assetUrlBuilder, zodSchemas, modelZodSchemas, globalIncludeId, sharedModelInflightCache, options);
         },
     });
-    const client = Object.assign(rootProxy, {
-        models: modelsProxy,
-        locales: config.locales ?? [],
-        defaultLocale: config.defaultLocale,
-        includeIdDefault: !!config.includeId,
-    });
-    return client;
+    return rootProxy;
 }
 export function cms0(config) {
     return createCmsClient(schemaDescriptor, config);
 }
+export { resolveLocalized, toNextMetadata, toOpenGraph, toTwitter, } from "./seo.js";