@cms0/cms0 0.2.7 → 0.2.9

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
@@ -698,6 +872,140 @@ function buildSearchParams(query) {
     }
     return params;
 }
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function cloneValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneValue(item));
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] = cloneValue(child);
+        }
+        return out;
+    }
+    return value;
+}
+function normalizeProjectionPaths(input) {
+    if (!input)
+        return [];
+    const values = Array.isArray(input) ? input : [input];
+    const unique = new Set();
+    for (const raw of values) {
+        for (const candidate of raw.split(",")) {
+            const path = candidate.trim();
+            if (!path)
+                continue;
+            const normalized = path
+                .split(".")
+                .map((part) => part.trim())
+                .filter(Boolean)
+                .join(".");
+            if (!normalized)
+                continue;
+            unique.add(normalized);
+        }
+    }
+    return Array.from(unique).map((path) => path.split("."));
+}
+function mergeProjectedValue(existing, incoming) {
+    if (incoming === undefined)
+        return existing;
+    if (existing === undefined)
+        return cloneValue(incoming);
+    if (Array.isArray(existing) && Array.isArray(incoming)) {
+        const max = Math.max(existing.length, incoming.length);
+        const out = [];
+        for (let index = 0; index < max; index++) {
+            const next = mergeProjectedValue(existing[index], incoming[index]);
+            if (next !== undefined)
+                out.push(next);
+        }
+        return out;
+    }
+    if (isPlainObject(existing) && isPlainObject(incoming)) {
+        const out = { ...existing };
+        for (const [key, child] of Object.entries(incoming)) {
+            out[key] = mergeProjectedValue(out[key], child);
+        }
+        return out;
+    }
+    return cloneValue(incoming);
+}
+function projectValueByPath(value, tokens) {
+    if (!tokens.length)
+        return cloneValue(value);
+    if (Array.isArray(value)) {
+        const projectedItems = value
+            .map((item) => projectValueByPath(item, tokens))
+            .filter((item) => item !== undefined);
+        return projectedItems.length ? projectedItems : undefined;
+    }
+    if (!isPlainObject(value))
+        return undefined;
+    const [head, ...rest] = tokens;
+    if (!head || !(head in value))
+        return undefined;
+    const child = projectValueByPath(value[head], rest);
+    if (child === undefined)
+        return undefined;
+    return { [head]: child };
+}
+function excludeValueByPath(value, tokens) {
+    if (!tokens.length)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.map((item) => excludeValueByPath(item, tokens));
+    }
+    if (!isPlainObject(value))
+        return value;
+    const [head, ...rest] = tokens;
+    if (!head || !(head in value))
+        return cloneValue(value);
+    const out = { ...value };
+    if (!rest.length) {
+        delete out[head];
+        return out;
+    }
+    const next = excludeValueByPath(out[head], rest);
+    if (next === undefined) {
+        delete out[head];
+    }
+    else {
+        out[head] = next;
+    }
+    return out;
+}
+function applyFieldProjection(value, fields, exclude) {
+    const includePaths = normalizeProjectionPaths(fields);
+    const excludePaths = normalizeProjectionPaths(exclude);
+    let projected = value;
+    if (includePaths.length) {
+        let included = undefined;
+        for (const pathTokens of includePaths) {
+            const partial = projectValueByPath(value, pathTokens);
+            included = mergeProjectedValue(included, partial);
+        }
+        projected =
+            included === undefined
+                ? Array.isArray(value)
+                    ? []
+                    : isPlainObject(value)
+                        ? {}
+                        : undefined
+                : included;
+    }
+    if (excludePaths.length) {
+        let excluded = projected;
+        for (const pathTokens of excludePaths) {
+            excluded = excludeValueByPath(excluded, pathTokens);
+        }
+        projected = excluded;
+    }
+    return projected;
+}
 async function requestJson(baseUrl, apiKey, path, options) {
     const params = buildSearchParams(options?.query);
     const url = `${baseUrl}/${path}${params.toString() ? `?${params.toString()}` : ""}`;
@@ -759,6 +1067,16 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
     const query = {
         ...(options?.query ?? {}),
     };
+    if (options?.fields !== undefined && query.fields === undefined) {
+        query.fields = Array.isArray(options.fields)
+            ? options.fields.join(",")
+            : options.fields;
+    }
+    if (options?.exclude !== undefined && query.exclude === undefined) {
+        query.exclude = Array.isArray(options.exclude)
+            ? options.exclude.join(",")
+            : options.exclude;
+    }
     const shouldNormalize = responseMode !== "raw";
     if (shouldNormalize && query.raw === undefined) {
         query.raw = 1;
@@ -808,7 +1126,7 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
         });
     }
     if (!shouldNormalize) {
-        return rawData;
+        return applyFieldProjection(rawData, options?.fields, options?.exclude);
     }
     const modelDescriptors = new Map();
     for (const modelName of Object.keys(descriptor.models ?? {})) {
@@ -843,9 +1161,10 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
             };
         const normalizedItems = await normalizeArrayField(descriptorForCollection, resource.path, envelope, context, new Set());
         if (responseMode === "envelope") {
+            const projectedItems = applyFieldProjection(normalizedItems, options?.fields, options?.exclude);
             validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
             return {
-                items: normalizedItems,
+                items: Array.isArray(projectedItems) ? projectedItems : normalizedItems,
                 total: envelope.total,
             };
         }
@@ -854,7 +1173,7 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
     }
     const normalized = await normalizeField(resource.descriptor, normalizePath, rawData, context, new Set(), false);
     validateResult(resource, normalized, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-    return normalized;
+    return applyFieldProjection(normalized, options?.fields, options?.exclude);
 }
 function createCmsClient(descriptor, config) {
     const baseUrl = normalizeBaseUrl(config.apiConfig?.baseUrl);
@@ -917,3 +1236,8 @@ function createCmsClient(descriptor, config) {
 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; } });