@cms0/cms0 0.2.6 → 0.2.8

package/README.md

@@ -11,11 +11,15 @@ pnpm add @cms0/cms0
 ## Usage
 
 ```ts
-import { cms0 } from "@cms0/cms0";
-import type { Image } from "@cms0/cms0/custom-types";
+import { cms0, toNextMetadata } from "@cms0/cms0";
+import type { Metadata } from "next";
+import type { Image, Seo } from "@cms0/cms0/custom-types";
 
 type RootSchema = {
-  images: Image[];
+  homePage: {
+    heroImage: Image;
+    seo: Seo;
+  };
 };
 
 export const data = cms0<RootSchema>({
@@ -24,6 +28,9 @@ export const data = cms0<RootSchema>({
     key: import.meta.env.VITE_CMS0_API_KEY,
   },
 });
+
+const page = await data.homePage();
+const metadata = toNextMetadata<Metadata>(page.seo, { locale: "en" });
 ```
 
 ## Custom Types

package/dist/cjs/custom-types/registry.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.customInlineTypeNames = exports.customModelTypeNames = exports.customTypeNames = exports.customTypeDescriptors = exports.customInlineTypeMetadata = exports.customInlineDescriptors = exports.customModelDescriptors = void 0;
 exports.getCustomInlineTypeMetadata = getCustomInlineTypeMetadata;
 exports.resolveCustomTypeDependencies = resolveCustomTypeDependencies;
+const shared_1 = require("@cms0/shared");
 const primitive = (type) => ({
     kind: "primitive",
     type,
@@ -54,6 +55,237 @@ const localizedRichTextDescriptor = {
     type: "json",
     customType: "LocalizedRichText",
 };
+function createUnionDescriptor(branches) {
+    return {
+        kind: "union",
+        anyOf: branches,
+        branchKeys: (0, shared_1.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,
+        },
+    },
+};
 exports.customModelDescriptors = {
     File: fileDescriptor,
     Image: imageDescriptor,
@@ -63,6 +295,7 @@ exports.customInlineDescriptors = {
     RichText: richTextDescriptor,
     LocalizedString: localizedStringDescriptor,
     LocalizedRichText: localizedRichTextDescriptor,
+    Seo: seoDescriptor,
 };
 exports.customInlineTypeMetadata = {
     RichText: {},
@@ -72,6 +305,7 @@ exports.customInlineTypeMetadata = {
     LocalizedRichText: {
         includeId: { mapLikeFields: ["locales"] },
     },
+    Seo: {},
 };
 exports.customTypeDescriptors = {
     ...exports.customModelDescriptors,
@@ -90,13 +324,20 @@ function resolveCustomTypeDependencies(names) {
         const name = queue.shift();
         if (!name || resolved.has(name))
             continue;
-        const descriptor = exports.customModelDescriptors[name];
+        const modelDescriptor = exports.customModelDescriptors[name];
+        const inlineDescriptor = exports.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 (exports.customTypeDescriptors[ref] && !resolved.has(ref)) {
@@ -111,11 +352,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/cjs/index.cjs

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTwitter = exports.toOpenGraph = exports.toNextMetadata = exports.resolveLocalized = void 0;
 exports.createCmsClient = createCmsClient;
 exports.cms0 = cms0;
 const schema_descriptors_1 = require("@cms0/cms0/schema-descriptors");
@@ -109,6 +110,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;
@@ -149,6 +153,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";
 }
@@ -166,7 +179,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;
@@ -362,6 +375,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)
@@ -377,8 +407,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 = (0, shared_1.decodeTaggedUnionValue)(raw);
+    if (!decoded)
+        return null;
+    const branches = Array.isArray(descriptor.anyOf)
+        ? descriptor.anyOf
+        : [];
+    if (!branches.length)
+        return null;
+    const branchKeys = (0, shared_1.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 };
@@ -450,12 +553,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)) {
@@ -543,16 +642,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;
@@ -583,6 +680,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
@@ -595,10 +746,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
@@ -885,14 +1059,25 @@ 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) {
@@ -901,14 +1086,13 @@ 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;
 }
 function cms0(config) {
     return createCmsClient(schema_descriptors_1.schemaDescriptor, config);
 }
+var seo_js_1 = require("./seo.cjs");
+Object.defineProperty(exports, "resolveLocalized", { enumerable: true, get: function () { return seo_js_1.resolveLocalized; } });
+Object.defineProperty(exports, "toNextMetadata", { enumerable: true, get: function () { return seo_js_1.toNextMetadata; } });
+Object.defineProperty(exports, "toOpenGraph", { enumerable: true, get: function () { return seo_js_1.toOpenGraph; } });
+Object.defineProperty(exports, "toTwitter", { enumerable: true, get: function () { return seo_js_1.toTwitter; } });