payload 4.0.0-internal.2fddfc0 → 4.0.0-internal.31ba7ee

package/dist/utilities/entityInputSchema/sanitizeEntitySchema.js

@@ -0,0 +1,384 @@
+/**
+ * Refines Payload's `input`-variant JSON Schema into an agent-friendly create/update input schema.
+ * The variant already covers correctness (ID-only relationships, no managed/virtual/join fields);
+ * the passes here reshape fields for models and shrink the result while keeping every node valid
+ * JSON Schema draft 2020-12. Each is tagged **Correctness**, **Size**, or **LLM ergonomics**, with a
+ * before/after example on its definition.
+ */ export const sanitizeEntitySchema = (schema)=>{
+    // Work on a copy — the caller reuses the original schema elsewhere (e.g. when listing tools).
+    let result = structuredClone(schema);
+    // LLM ergonomics — drop the redundant `'null'` from optional arrays/objects (`['array','null']` → `'array'`).
+    result = collapseOptionalContainerTypes(result);
+    // LLM ergonomics — rewrite point fields from a `[number, number]` tuple into a `{ longitude, latitude }` object.
+    result = pointFieldsToObjects(result);
+    // Size — strip inert type-gen leftovers that only bloat the schema (`tsType`, block-collision notes).
+    result = removeTypeGenArtifacts(result);
+    // Size — where a `const` already pins a value, the sibling `type` is redundant; remove it.
+    result = dropRedundantConstType(result);
+    // Size — fold per-collection relationship/upload variants (identical but for `relationTo`) into one `enum`.
+    result = mergeConstDiscriminatedUnions(result);
+    // Size — pull any subschema that appears more than once into a single shared `$defs` entry.
+    result = deduplicateIntoDefinitions(result);
+    // LLM ergonomics — give `$defs` short, readable names (`Code`, `paragraph`, `node`) so the `$ref`s read nicely.
+    result = shortenDefinitionNames(result);
+    return result;
+};
+/**
+ * Rebuilds a schema bottom-up, calling `visit` on each node after its children. Shared by the
+ * transforms that need to touch every node in the tree.
+ */ const mapNodes = (node, visit)=>{
+    if (Array.isArray(node)) {
+        return node.map((child)=>mapNodes(child, visit));
+    }
+    if (!node || typeof node !== 'object') {
+        return node;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(node)){
+        out[key] = mapNodes(value, visit);
+    }
+    return visit(out);
+};
+/**
+ * **LLM ergonomics.** Collapses optional array/object types (`['array', 'null']` → `'array'`) via
+ * {@link collapseNullableType}, recursing through `properties` and array items. The `required` list
+ * already conveys optionality, so the `'null'` is redundant noise for the model.
+ *
+ * @example
+ * { properties: { tags: { type: ['array', 'null'], items: {} } }, required: [] }
+ * → { properties: { tags: { type: 'array', items: {} } }, required: [] }
+ */ const collapseOptionalContainerTypes = (schema)=>{
+    if (schema.properties && typeof schema.properties === 'object') {
+        for (const key of Object.keys(schema.properties)){
+            const prop = schema.properties[key];
+            if (!prop || typeof prop !== 'object') {
+                continue;
+            }
+            const isRequired = Array.isArray(schema.required) && schema.required.includes(key);
+            collapseNullableType(prop, isRequired);
+            if (prop.properties) {
+                collapseOptionalContainerTypes(prop);
+            }
+            if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {
+                collapseOptionalContainerTypes(prop.items);
+            }
+        }
+    }
+    return schema;
+};
+/**
+ * Drops the `'null'` from an optional array/object type (`['array', 'null']` → `'array'`, likewise
+ * `'object'`). Payload marks a field optional by unioning its type with `'null'`, but a create/update
+ * tool already conveys "optional" through the `required` list - the client just omits the field - so the
+ * `'null'` is redundant here. Dropping it shows the model a plain `type: 'array'` instead of implying it
+ * should send a literal `null`.
+ *
+ * We never touch the `required` list, so this can't change whether a field is required. And we skip fields
+ * that ARE required (`isRequired`): there a `'null'` is a value the field genuinely accepts, not optionality
+ * encoding. Nullable scalars (`['string', 'null']`) are also left alone - they read fine as `string | null`.
+ *
+ * @example
+ * optional { type: ['array', 'null'] } → { type: 'array' }   (still optional, just no longer null-valued)
+ * required { type: ['array', 'null'] } → unchanged
+ * { type: ['string', 'null'] } → unchanged
+ */ const collapseNullableType = (schema, isRequired)=>{
+    if (isRequired || !Array.isArray(schema.type)) {
+        return;
+    }
+    const nonNullTypes = schema.type.filter((t)=>t !== 'null');
+    if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {
+        schema.type = nonNullTypes[0];
+    }
+};
+/**
+ * **LLM ergonomics.** Rewrites a point field (stored as a two-number tuple) into a `{ longitude, latitude }` object, which
+ * is far easier for the model to fill in than a positional array. This is input-only and lossless: the
+ * create/update handler converts the object back to the `[longitude, latitude]` tuple Payload stores,
+ * via `transformPointDataToPayload`.
+ *
+ * @example
+ * { type: 'array', items: [{ type: 'number' }, { type: 'number' }] }
+ * → { type: 'object', properties: { longitude: { type: 'number' }, latitude: { type: 'number' } }, required: ['longitude', 'latitude'] }
+ */ const pointFieldsToObjects = (schema)=>{
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const transformed = {
+        ...schema
+    };
+    if (transformed.properties && typeof transformed.properties === 'object') {
+        transformed.properties = Object.fromEntries(Object.entries(transformed.properties).map(([key, value])=>{
+            if (!value || typeof value !== 'object') {
+                return [
+                    key,
+                    value
+                ];
+            }
+            const isArrayType = value.type === 'array' || Array.isArray(value.type) && value.type.includes('array');
+            const isPointField = isArrayType && Array.isArray(value.items) && value.items.length === 2 && value.items.every((item)=>item && typeof item === 'object' && item.type === 'number');
+            if (isPointField) {
+                const isNullable = Array.isArray(value.type) && value.type.includes('null');
+                return [
+                    key,
+                    {
+                        type: isNullable ? [
+                            'object',
+                            'null'
+                        ] : 'object',
+                        description: value.description || 'Geographic coordinates (longitude, latitude)',
+                        properties: {
+                            latitude: {
+                                type: 'number',
+                                description: 'Latitude coordinate'
+                            },
+                            longitude: {
+                                type: 'number',
+                                description: 'Longitude coordinate'
+                            }
+                        },
+                        required: [
+                            'longitude',
+                            'latitude'
+                        ]
+                    }
+                ];
+            }
+            return [
+                key,
+                pointFieldsToObjects(value)
+            ];
+        }));
+    }
+    if (transformed.items && typeof transformed.items === 'object' && !Array.isArray(transformed.items)) {
+        transformed.items = pointFieldsToObjects(transformed.items);
+    }
+    return transformed;
+};
+/**
+ * **Size.** Strips type-generation leftovers that bloat the schema without helping the model: the `tsType`
+ * hint (a `json-schema-to-typescript` extension; JSON Schema validators just ignore it, they don't reject it)
+ * and the block-interface-collision note Payload adds to some block descriptions (the
+ * `block-interface-name-collisions` docs link set in `registerBlockInterface`, see configToJSONSchema.ts).
+ * Both are inert here - removing them only shrinks the schema (and spares the model irrelevant noise).
+ *
+ * @example
+ * { type: 'object', tsType: 'SerializedBlockNode', description: 'see …#block-interface-name-collisions' }
+ * → { type: 'object' }
+ */ const removeTypeGenArtifacts = (schema)=>mapNodes(schema, (node)=>{
+        delete node.tsType;
+        const { description } = node;
+        if (typeof description === 'string' && description.includes('block-interface-name-collisions')) {
+            delete node.description;
+        }
+        return node;
+    });
+/**
+ * **Size.** Removes `type` whenever a `const` sits next to it — the constant already fixes the value.
+ *
+ * @example
+ * { type: 'string', const: 'paragraph' } → { const: 'paragraph' }
+ */ const dropRedundantConstType = (schema)=>mapNodes(schema, (node)=>{
+        if ('const' in node && 'type' in node) {
+            delete node.type;
+        }
+        return node;
+    });
+/**
+ * **Size.** Merges the members of a `oneOf`/`anyOf` that are identical except for one `const`-valued property
+ * into a single member with that property as an `enum`. Since the members differ only by that one
+ * constant, the `enum` form accepts exactly the same values - it's just smaller. This folds the
+ * per-collection relationship and upload variants, which differ only in their `relationTo` constant.
+ *
+ * @example
+ * { oneOf: [
+ *   { properties: { relationTo: { const: 'posts' }, value: { type: 'string' } } },
+ *   { properties: { relationTo: { const: 'pages' }, value: { type: 'string' } } },
+ * ] }
+ * → { properties: { relationTo: { enum: ['posts', 'pages'] }, value: { type: 'string' } } }
+ */ const mergeConstDiscriminatedUnions = (schema)=>mapNodes(schema, (node)=>{
+        for (const keyword of [
+            'oneOf',
+            'anyOf'
+        ]){
+            const members = node[keyword];
+            if (Array.isArray(members) && members.length > 1) {
+                const merged = mergeMembersByConst(members);
+                if (merged) {
+                    delete node[keyword];
+                    Object.assign(node, merged);
+                }
+            }
+        }
+        return node;
+    });
+/** Returns the merged member for {@link mergeConstDiscriminatedUnions}, or `null` if they can't merge. */ const mergeMembersByConst = (members)=>{
+    const objects = members.filter((member)=>typeof member === 'object' && member !== null && typeof member.properties === 'object');
+    if (objects.length < 2 || objects.length !== members.length) {
+        return null;
+    }
+    for (const discriminator of Object.keys(objects[0].properties)){
+        // Each member must pin this property to a `const`...
+        const constValues = [];
+        const everyMemberPinsConst = objects.every((member)=>{
+            const prop = member.properties[discriminator];
+            if (prop && typeof prop === 'object' && 'const' in prop) {
+                constValues.push(prop.const);
+                return true;
+            }
+            return false;
+        });
+        if (!everyMemberPinsConst) {
+            continue;
+        }
+        // ...and be otherwise identical (compare each member with the discriminator removed).
+        const fingerprintWithoutDiscriminator = (member)=>{
+            const { [discriminator]: _discriminator, ...otherProperties } = member.properties;
+            return JSON.stringify({
+                ...member,
+                properties: otherProperties
+            });
+        };
+        if (new Set(objects.map(fingerprintWithoutDiscriminator)).size !== 1) {
+            continue;
+        }
+        const uniqueConstValues = [
+            ...new Set(constValues)
+        ];
+        if (uniqueConstValues.length < 2) {
+            continue;
+        }
+        // Replace the per-member `const` with a single `enum` of every value.
+        const merged = structuredClone(objects[0]);
+        const discriminatorProp = merged.properties[discriminator];
+        if (discriminatorProp && typeof discriminatorProp === 'object') {
+            delete discriminatorProp.const;
+            discriminatorProp.enum = uniqueConstValues;
+        }
+        return merged;
+    }
+    return null;
+};
+// A `$ref` costs ~30 characters once names are shortened, so sharing a subschema only pays off when
+// it's larger than that and appears more than once.
+const MIN_SHARED_SIZE = 64;
+/** A subschema worth sharing: a standalone object/union/described schema, not a `$ref` or a primitive. */ const isShareable = (node)=>{
+    if (!node || typeof node !== 'object' || Array.isArray(node) || '$ref' in node) {
+        return false;
+    }
+    const schema = node;
+    return Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf) || Boolean(schema.properties) || Boolean(schema.items) || typeof schema.description === 'string';
+};
+/**
+ * **Size.** Replaces any subschema that appears more than once with a single shared `$defs` entry referenced by
+ * `$ref`. Lossless — only the serialized size shrinks. A collection with several rich-text fields, for
+ * example, inlines the same large lexical node schema once per field; this collapses them into one.
+ *
+ * @example
+ * { properties: { billing: address, shipping: address } }
+ * → { properties: { billing: { $ref: '#/$defs/shared_0' }, shipping: { $ref: '#/$defs/shared_0' } }, $defs: { shared_0: address } }
+ */ const deduplicateIntoDefinitions = (schema)=>{
+    // Count how often each shareable subschema appears, keyed by its serialized form.
+    const counts = new Map();
+    const count = (node)=>{
+        if (isShareable(node)) {
+            const key = JSON.stringify(node);
+            if (key.length >= MIN_SHARED_SIZE) {
+                counts.set(key, (counts.get(key) ?? 0) + 1);
+            }
+        }
+        if (Array.isArray(node)) {
+            node.forEach(count);
+        } else if (node && typeof node === 'object') {
+            Object.values(node).forEach(count);
+        }
+    };
+    count(schema);
+    if (![
+        ...counts.values()
+    ].some((n)=>n >= 2)) {
+        return schema;
+    }
+    // Replace each subschema seen 2+ times with a `$ref`. The first time we meet one it becomes a shared
+    // entry; we never descend into a stored entry, so shared entries never reference one another.
+    const sharedEntries = {};
+    const nameByKey = new Map();
+    const share = (node)=>{
+        if (isShareable(node)) {
+            const key = JSON.stringify(node);
+            if ((counts.get(key) ?? 0) >= 2) {
+                let name = nameByKey.get(key);
+                if (!name) {
+                    name = `shared_${nameByKey.size}`;
+                    nameByKey.set(key, name);
+                    sharedEntries[name] = node;
+                }
+                return {
+                    $ref: `#/$defs/${name}`
+                };
+            }
+        }
+        if (Array.isArray(node)) {
+            return node.map(share);
+        }
+        if (node && typeof node === 'object') {
+            return Object.fromEntries(Object.entries(node).map(([childKey, value])=>[
+                    childKey,
+                    share(value)
+                ]));
+        }
+        return node;
+    };
+    const result = share(schema);
+    result.$defs = {
+        ...result.$defs,
+        ...sharedEntries
+    };
+    return result;
+};
+/**
+ * **LLM ergonomics.** Renames `$defs` entries to short, readable names so the `$ref`s stay legible to the model: a block's
+ * `blockType` (`Code`), a node's `type` (`paragraph`), `node` for a rich-text node union, otherwise the
+ * generated name with its disambiguating hash dropped. A numeric suffix keeps collisions unique.
+ *
+ * @example
+ * { properties: { body: { $ref: '#/$defs/LexicalNodes_9FBEC708' } }, $defs: { LexicalNodes_9FBEC708: {} } }
+ * → { properties: { body: { $ref: '#/$defs/node' } }, $defs: { node: {} } }
+ */ const shortenDefinitionNames = (schema)=>{
+    const definitions = schema.$defs;
+    if (!definitions || Object.keys(definitions).length === 0) {
+        return schema;
+    }
+    const shortNameFor = (name, definition)=>{
+        const properties = typeof definition === 'object' && definition.properties || {};
+        const constString = (key)=>{
+            const prop = properties[key];
+            return prop && typeof prop === 'object' && typeof prop.const === 'string' ? prop.const : undefined;
+        };
+        const members = typeof definition === 'object' ? definition.anyOf ?? definition.oneOf : undefined;
+        const isNodeUnion = Array.isArray(members) && members.some((m)=>typeof m === 'object' && Boolean(m.$ref || m.properties?.type));
+        return constString('blockType') ?? constString('type') ?? (isNodeUnion ? 'node' : undefined) ?? name.replace(/_[0-9A-F]{6,}$/i, '');
+    };
+    const prefix = '#/$defs/';
+    const usedNames = new Map();
+    const rename = new Map();
+    for (const [name, definition] of Object.entries(definitions)){
+        const shortName = shortNameFor(name, definition);
+        const used = usedNames.get(shortName) ?? 0;
+        usedNames.set(shortName, used + 1);
+        rename.set(name, used === 0 ? shortName : `${shortName}${used + 1}`);
+    }
+    const result = mapNodes(schema, (node)=>{
+        if (typeof node.$ref === 'string' && node.$ref.startsWith(prefix)) {
+            const name = node.$ref.slice(prefix.length);
+            node.$ref = `${prefix}${rename.get(name) ?? name}`;
+        }
+        return node;
+    });
+    result.$defs = Object.fromEntries(Object.entries(result.$defs).map(([name, body])=>[
+            rename.get(name) ?? name,
+            body
+        ]));
+    return result;
+};
+
+//# sourceMappingURL=sanitizeEntitySchema.js.map

package/dist/utilities/entityInputSchema/sanitizeEntitySchema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/entityInputSchema/sanitizeEntitySchema.ts"],"sourcesContent":["import type { EntityInputSchema as JsonSchemaType } from './types.js'\n\n/**\n * Refines Payload's `input`-variant JSON Schema into an agent-friendly create/update input schema.\n * The variant already covers correctness (ID-only relationships, no managed/virtual/join fields);\n * the passes here reshape fields for models and shrink the result while keeping every node valid\n * JSON Schema draft 2020-12. Each is tagged **Correctness**, **Size**, or **LLM ergonomics**, with a\n * before/after example on its definition.\n */\nexport const sanitizeEntitySchema = (schema: JsonSchemaType): JsonSchemaType => {\n  // Work on a copy — the caller reuses the original schema elsewhere (e.g. when listing tools).\n  let result = structuredClone(schema)\n\n  // LLM ergonomics — drop the redundant `'null'` from optional arrays/objects (`['array','null']` → `'array'`).\n  result = collapseOptionalContainerTypes(result)\n\n  // LLM ergonomics — rewrite point fields from a `[number, number]` tuple into a `{ longitude, latitude }` object.\n  result = pointFieldsToObjects(result)\n\n  // Size — strip inert type-gen leftovers that only bloat the schema (`tsType`, block-collision notes).\n  result = removeTypeGenArtifacts(result)\n\n  // Size — where a `const` already pins a value, the sibling `type` is redundant; remove it.\n  result = dropRedundantConstType(result)\n\n  // Size — fold per-collection relationship/upload variants (identical but for `relationTo`) into one `enum`.\n  result = mergeConstDiscriminatedUnions(result)\n\n  // Size — pull any subschema that appears more than once into a single shared `$defs` entry.\n  result = deduplicateIntoDefinitions(result)\n\n  // LLM ergonomics — give `$defs` short, readable names (`Code`, `paragraph`, `node`) so the `$ref`s read nicely.\n  result = shortenDefinitionNames(result)\n\n  return result\n}\n\n/**\n * Rebuilds a schema bottom-up, calling `visit` on each node after its children. Shared by the\n * transforms that need to touch every node in the tree.\n */\nconst mapNodes = (node: unknown, visit: (node: JsonSchemaType) => JsonSchemaType): unknown => {\n  if (Array.isArray(node)) {\n    return node.map((child) => mapNodes(child, visit))\n  }\n  if (!node || typeof node !== 'object') {\n    return node\n  }\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(node)) {\n    out[key] = mapNodes(value, visit)\n  }\n  return visit(out)\n}\n\n/**\n * **LLM ergonomics.** Collapses optional array/object types (`['array', 'null']` → `'array'`) via\n * {@link collapseNullableType}, recursing through `properties` and array items. The `required` list\n * already conveys optionality, so the `'null'` is redundant noise for the model.\n *\n * @example\n * { properties: { tags: { type: ['array', 'null'], items: {} } }, required: [] }\n * → { properties: { tags: { type: 'array', items: {} } }, required: [] }\n */\nconst collapseOptionalContainerTypes = (schema: JsonSchemaType): JsonSchemaType => {\n  if (schema.properties && typeof schema.properties === 'object') {\n    for (const key of Object.keys(schema.properties)) {\n      const prop = schema.properties[key] as JsonSchemaType\n      if (!prop || typeof prop !== 'object') {\n        continue\n      }\n      const isRequired = Array.isArray(schema.required) && schema.required.includes(key)\n      collapseNullableType(prop, isRequired)\n      if (prop.properties) {\n        collapseOptionalContainerTypes(prop)\n      }\n      if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {\n        collapseOptionalContainerTypes(prop.items)\n      }\n    }\n  }\n\n  return schema\n}\n\n/**\n * Drops the `'null'` from an optional array/object type (`['array', 'null']` → `'array'`, likewise\n * `'object'`). Payload marks a field optional by unioning its type with `'null'`, but a create/update\n * tool already conveys \"optional\" through the `required` list - the client just omits the field - so the\n * `'null'` is redundant here. Dropping it shows the model a plain `type: 'array'` instead of implying it\n * should send a literal `null`.\n *\n * We never touch the `required` list, so this can't change whether a field is required. And we skip fields\n * that ARE required (`isRequired`): there a `'null'` is a value the field genuinely accepts, not optionality\n * encoding. Nullable scalars (`['string', 'null']`) are also left alone - they read fine as `string | null`.\n *\n * @example\n * optional { type: ['array', 'null'] } → { type: 'array' }   (still optional, just no longer null-valued)\n * required { type: ['array', 'null'] } → unchanged\n * { type: ['string', 'null'] } → unchanged\n */\nconst collapseNullableType = (schema: JsonSchemaType, isRequired: boolean): void => {\n  if (isRequired || !Array.isArray(schema.type)) {\n    return\n  }\n  const nonNullTypes = schema.type.filter((t) => t !== 'null')\n  if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {\n    schema.type = nonNullTypes[0]\n  }\n}\n\n/**\n * **LLM ergonomics.** Rewrites a point field (stored as a two-number tuple) into a `{ longitude, latitude }` object, which\n * is far easier for the model to fill in than a positional array. This is input-only and lossless: the\n * create/update handler converts the object back to the `[longitude, latitude]` tuple Payload stores,\n * via `transformPointDataToPayload`.\n *\n * @example\n * { type: 'array', items: [{ type: 'number' }, { type: 'number' }] }\n * → { type: 'object', properties: { longitude: { type: 'number' }, latitude: { type: 'number' } }, required: ['longitude', 'latitude'] }\n */\nconst pointFieldsToObjects = (schema: JsonSchemaType): JsonSchemaType => {\n  if (!schema || typeof schema !== 'object') {\n    return schema\n  }\n\n  const transformed = { ...schema }\n\n  if (transformed.properties && typeof transformed.properties === 'object') {\n    transformed.properties = Object.fromEntries(\n      Object.entries(transformed.properties).map(([key, value]) => {\n        if (!value || typeof value !== 'object') {\n          return [key, value]\n        }\n        const isArrayType =\n          value.type === 'array' || (Array.isArray(value.type) && value.type.includes('array'))\n        const isPointField =\n          isArrayType &&\n          Array.isArray(value.items) &&\n          value.items.length === 2 &&\n          value.items.every((item) => item && typeof item === 'object' && item.type === 'number')\n\n        if (isPointField) {\n          const isNullable = Array.isArray(value.type) && value.type.includes('null')\n          return [\n            key,\n            {\n              type: isNullable ? ['object', 'null'] : 'object',\n              description: value.description || 'Geographic coordinates (longitude, latitude)',\n              properties: {\n                latitude: { type: 'number', description: 'Latitude coordinate' },\n                longitude: { type: 'number', description: 'Longitude coordinate' },\n              },\n              required: ['longitude', 'latitude'],\n            },\n          ]\n        }\n\n        return [key, pointFieldsToObjects(value)]\n      }),\n    )\n  }\n\n  if (\n    transformed.items &&\n    typeof transformed.items === 'object' &&\n    !Array.isArray(transformed.items)\n  ) {\n    transformed.items = pointFieldsToObjects(transformed.items)\n  }\n\n  return transformed\n}\n\n/**\n * **Size.** Strips type-generation leftovers that bloat the schema without helping the model: the `tsType`\n * hint (a `json-schema-to-typescript` extension; JSON Schema validators just ignore it, they don't reject it)\n * and the block-interface-collision note Payload adds to some block descriptions (the\n * `block-interface-name-collisions` docs link set in `registerBlockInterface`, see configToJSONSchema.ts).\n * Both are inert here - removing them only shrinks the schema (and spares the model irrelevant noise).\n *\n * @example\n * { type: 'object', tsType: 'SerializedBlockNode', description: 'see …#block-interface-name-collisions' }\n * → { type: 'object' }\n */\nconst removeTypeGenArtifacts = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    delete (node as { tsType?: unknown }).tsType\n    const { description } = node as { description?: string }\n    if (\n      typeof description === 'string' &&\n      description.includes('block-interface-name-collisions')\n    ) {\n      delete (node as { description?: unknown }).description\n    }\n    return node\n  }) as JsonSchemaType\n\n/**\n * **Size.** Removes `type` whenever a `const` sits next to it — the constant already fixes the value.\n *\n * @example\n * { type: 'string', const: 'paragraph' } → { const: 'paragraph' }\n */\nconst dropRedundantConstType = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    if ('const' in node && 'type' in node) {\n      delete (node as { type?: unknown }).type\n    }\n    return node\n  }) as JsonSchemaType\n\n/**\n * **Size.** Merges the members of a `oneOf`/`anyOf` that are identical except for one `const`-valued property\n * into a single member with that property as an `enum`. Since the members differ only by that one\n * constant, the `enum` form accepts exactly the same values - it's just smaller. This folds the\n * per-collection relationship and upload variants, which differ only in their `relationTo` constant.\n *\n * @example\n * { oneOf: [\n *   { properties: { relationTo: { const: 'posts' }, value: { type: 'string' } } },\n *   { properties: { relationTo: { const: 'pages' }, value: { type: 'string' } } },\n * ] }\n * → { properties: { relationTo: { enum: ['posts', 'pages'] }, value: { type: 'string' } } }\n */\nconst mergeConstDiscriminatedUnions = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    for (const keyword of ['oneOf', 'anyOf'] as const) {\n      const members = node[keyword]\n      if (Array.isArray(members) && members.length > 1) {\n        const merged = mergeMembersByConst(members)\n        if (merged) {\n          delete node[keyword]\n          Object.assign(node, merged)\n        }\n      }\n    }\n    return node\n  }) as JsonSchemaType\n\n/** Returns the merged member for {@link mergeConstDiscriminatedUnions}, or `null` if they can't merge. */\nconst mergeMembersByConst = (members: Array<boolean | JsonSchemaType>): JsonSchemaType | null => {\n  const objects = members.filter(\n    (member): member is JsonSchemaType =>\n      typeof member === 'object' && member !== null && typeof member.properties === 'object',\n  )\n  if (objects.length < 2 || objects.length !== members.length) {\n    return null\n  }\n\n  for (const discriminator of Object.keys(objects[0]!.properties!)) {\n    // Each member must pin this property to a `const`...\n    const constValues: unknown[] = []\n    const everyMemberPinsConst = objects.every((member) => {\n      const prop = member.properties![discriminator]\n      if (prop && typeof prop === 'object' && 'const' in prop) {\n        constValues.push(prop.const)\n        return true\n      }\n      return false\n    })\n    if (!everyMemberPinsConst) {\n      continue\n    }\n\n    // ...and be otherwise identical (compare each member with the discriminator removed).\n    const fingerprintWithoutDiscriminator = (member: JsonSchemaType): string => {\n      const { [discriminator]: _discriminator, ...otherProperties } = member.properties!\n      return JSON.stringify({ ...member, properties: otherProperties })\n    }\n    if (new Set(objects.map(fingerprintWithoutDiscriminator)).size !== 1) {\n      continue\n    }\n\n    const uniqueConstValues = [...new Set(constValues)]\n    if (uniqueConstValues.length < 2) {\n      continue\n    }\n\n    // Replace the per-member `const` with a single `enum` of every value.\n    const merged = structuredClone(objects[0]!)\n    const discriminatorProp = merged.properties![discriminator]\n    if (discriminatorProp && typeof discriminatorProp === 'object') {\n      delete discriminatorProp.const\n      discriminatorProp.enum = uniqueConstValues\n    }\n    return merged\n  }\n  return null\n}\n\n// A `$ref` costs ~30 characters once names are shortened, so sharing a subschema only pays off when\n// it's larger than that and appears more than once.\nconst MIN_SHARED_SIZE = 64\n\n/** A subschema worth sharing: a standalone object/union/described schema, not a `$ref` or a primitive. */\nconst isShareable = (node: unknown): node is Record<string, unknown> => {\n  if (!node || typeof node !== 'object' || Array.isArray(node) || '$ref' in node) {\n    return false\n  }\n  const schema = node as JsonSchemaType\n  return (\n    Array.isArray(schema.oneOf) ||\n    Array.isArray(schema.anyOf) ||\n    Boolean(schema.properties) ||\n    Boolean(schema.items) ||\n    typeof schema.description === 'string'\n  )\n}\n\n/**\n * **Size.** Replaces any subschema that appears more than once with a single shared `$defs` entry referenced by\n * `$ref`. Lossless — only the serialized size shrinks. A collection with several rich-text fields, for\n * example, inlines the same large lexical node schema once per field; this collapses them into one.\n *\n * @example\n * { properties: { billing: address, shipping: address } }\n * → { properties: { billing: { $ref: '#/$defs/shared_0' }, shipping: { $ref: '#/$defs/shared_0' } }, $defs: { shared_0: address } }\n */\nconst deduplicateIntoDefinitions = (schema: JsonSchemaType): JsonSchemaType => {\n  // Count how often each shareable subschema appears, keyed by its serialized form.\n  const counts = new Map<string, number>()\n  const count = (node: unknown): void => {\n    if (isShareable(node)) {\n      const key = JSON.stringify(node)\n      if (key.length >= MIN_SHARED_SIZE) {\n        counts.set(key, (counts.get(key) ?? 0) + 1)\n      }\n    }\n    if (Array.isArray(node)) {\n      node.forEach(count)\n    } else if (node && typeof node === 'object') {\n      Object.values(node).forEach(count)\n    }\n  }\n  count(schema)\n\n  if (![...counts.values()].some((n) => n >= 2)) {\n    return schema\n  }\n\n  // Replace each subschema seen 2+ times with a `$ref`. The first time we meet one it becomes a shared\n  // entry; we never descend into a stored entry, so shared entries never reference one another.\n  const sharedEntries: Record<string, JsonSchemaType> = {}\n  const nameByKey = new Map<string, string>()\n  const share = (node: unknown): unknown => {\n    if (isShareable(node)) {\n      const key = JSON.stringify(node)\n      if ((counts.get(key) ?? 0) >= 2) {\n        let name = nameByKey.get(key)\n        if (!name) {\n          name = `shared_${nameByKey.size}`\n          nameByKey.set(key, name)\n          sharedEntries[name] = node\n        }\n        return { $ref: `#/$defs/${name}` }\n      }\n    }\n    if (Array.isArray(node)) {\n      return node.map(share)\n    }\n    if (node && typeof node === 'object') {\n      return Object.fromEntries(\n        Object.entries(node).map(([childKey, value]) => [childKey, share(value)]),\n      )\n    }\n    return node\n  }\n\n  const result = share(schema) as JsonSchemaType\n  result.$defs = { ...result.$defs, ...sharedEntries }\n  return result\n}\n\n/**\n * **LLM ergonomics.** Renames `$defs` entries to short, readable names so the `$ref`s stay legible to the model: a block's\n * `blockType` (`Code`), a node's `type` (`paragraph`), `node` for a rich-text node union, otherwise the\n * generated name with its disambiguating hash dropped. A numeric suffix keeps collisions unique.\n *\n * @example\n * { properties: { body: { $ref: '#/$defs/LexicalNodes_9FBEC708' } }, $defs: { LexicalNodes_9FBEC708: {} } }\n * → { properties: { body: { $ref: '#/$defs/node' } }, $defs: { node: {} } }\n */\nconst shortenDefinitionNames = (schema: JsonSchemaType): JsonSchemaType => {\n  const definitions = schema.$defs\n  if (!definitions || Object.keys(definitions).length === 0) {\n    return schema\n  }\n\n  const shortNameFor = (name: string, definition: boolean | JsonSchemaType): string => {\n    const properties = (typeof definition === 'object' && definition.properties) || {}\n    const constString = (key: string): string | undefined => {\n      const prop = properties[key]\n      return prop && typeof prop === 'object' && typeof prop.const === 'string'\n        ? prop.const\n        : undefined\n    }\n    const members =\n      typeof definition === 'object' ? (definition.anyOf ?? definition.oneOf) : undefined\n    const isNodeUnion =\n      Array.isArray(members) &&\n      members.some((m) => typeof m === 'object' && Boolean(m.$ref || m.properties?.type))\n    return (\n      constString('blockType') ??\n      constString('type') ??\n      (isNodeUnion ? 'node' : undefined) ??\n      name.replace(/_[0-9A-F]{6,}$/i, '')\n    )\n  }\n\n  const prefix = '#/$defs/'\n  const usedNames = new Map<string, number>()\n  const rename = new Map<string, string>()\n  for (const [name, definition] of Object.entries(definitions)) {\n    const shortName = shortNameFor(name, definition)\n    const used = usedNames.get(shortName) ?? 0\n    usedNames.set(shortName, used + 1)\n    rename.set(name, used === 0 ? shortName : `${shortName}${used + 1}`)\n  }\n\n  const result = mapNodes(schema, (node) => {\n    if (typeof node.$ref === 'string' && node.$ref.startsWith(prefix)) {\n      const name = node.$ref.slice(prefix.length)\n      node.$ref = `${prefix}${rename.get(name) ?? name}`\n    }\n    return node\n  }) as JsonSchemaType\n  result.$defs = Object.fromEntries(\n    Object.entries(result.$defs!).map(([name, body]) => [rename.get(name) ?? name, body]),\n  )\n  return result\n}\n"],"names":["sanitizeEntitySchema","schema","result","structuredClone","collapseOptionalContainerTypes","pointFieldsToObjects","removeTypeGenArtifacts","dropRedundantConstType","mergeConstDiscriminatedUnions","deduplicateIntoDefinitions","shortenDefinitionNames","mapNodes","node","visit","Array","isArray","map","child","out","key","value","Object","entries","properties","keys","prop","isRequired","required","includes","collapseNullableType","items","type","nonNullTypes","filter","t","length","transformed","fromEntries","isArrayType","isPointField","every","item","isNullable","description","latitude","longitude","tsType","keyword","members","merged","mergeMembersByConst","assign","objects","member","discriminator","constValues","everyMemberPinsConst","push","const","fingerprintWithoutDiscriminator","_discriminator","otherProperties","JSON","stringify","Set","size","uniqueConstValues","discriminatorProp","enum","MIN_SHARED_SIZE","isShareable","oneOf","anyOf","Boolean","counts","Map","count","set","get","forEach","values","some","n","sharedEntries","nameByKey","share","name","$ref","childKey","$defs","definitions","shortNameFor","definition","constString","undefined","isNodeUnion","m","replace","prefix","usedNames","rename","shortName","used","startsWith","slice","body"],"mappings":"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"}

package/dist/utilities/entityInputSchema/types.d.ts

@@ -0,0 +1,16 @@
+export type EntityInputSchema = {
+    $defs?: Record<string, boolean | EntityInputSchema>;
+    $ref?: string;
+    [key: string]: unknown;
+    additionalProperties?: boolean | EntityInputSchema;
+    anyOf?: Array<boolean | EntityInputSchema>;
+    const?: unknown;
+    description?: string;
+    enum?: unknown[];
+    items?: EntityInputSchema | EntityInputSchema[];
+    oneOf?: Array<boolean | EntityInputSchema>;
+    properties?: Record<string, EntityInputSchema>;
+    required?: string[];
+    type?: string | string[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/utilities/entityInputSchema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utilities/entityInputSchema/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAAC,CAAA;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IACtB,oBAAoB,CAAC,EAAE,OAAO,GAAG,iBAAiB,CAAA;IAClD,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,iBAAiB,CAAC,CAAA;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;IAChB,KAAK,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,CAAA;IAC/C,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,iBAAiB,CAAC,CAAA;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC9C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CACzB,CAAA"}

package/dist/utilities/entityInputSchema/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/utilities/entityInputSchema/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/entityInputSchema/types.ts"],"sourcesContent":["export type EntityInputSchema = {\n  $defs?: Record<string, boolean | EntityInputSchema>\n  $ref?: string\n  [key: string]: unknown\n  additionalProperties?: boolean | EntityInputSchema\n  anyOf?: Array<boolean | EntityInputSchema>\n  const?: unknown\n  description?: string\n  enum?: unknown[]\n  items?: EntityInputSchema | EntityInputSchema[]\n  oneOf?: Array<boolean | EntityInputSchema>\n  properties?: Record<string, EntityInputSchema>\n  required?: string[]\n  type?: string | string[]\n}\n"],"names":[],"mappings":"AAAA,WAcC"}

package/dist/utilities/entityInputSchema/validateEntityData.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionSlug, GlobalSlug, PayloadRequest } from '../../index.js';
+export declare const validateCollectionData: ({ slug, data, partial, req, }: {
+    data: Record<string, unknown>;
+    partial?: boolean;
+    req: PayloadRequest;
+    slug: CollectionSlug;
+}) => void;
+export declare const validateGlobalData: ({ slug, data, req, }: {
+    data: Record<string, unknown>;
+    req: PayloadRequest;
+    slug: GlobalSlug;
+}) => void;
+//# sourceMappingURL=validateEntityData.d.ts.map

package/dist/utilities/entityInputSchema/validateEntityData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateEntityData.d.ts","sourceRoot":"","sources":["../../../src/utilities/entityInputSchema/validateEntityData.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAMhF,eAAO,MAAM,sBAAsB,kCAKhC;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,GAAG,EAAE,cAAc,CAAA;IACnB,IAAI,EAAE,cAAc,CAAA;CACrB,KAAG,IAIH,CAAA;AAED,eAAO,MAAM,kBAAkB,yBAI5B;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,GAAG,EAAE,cAAc,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;CACjB,KAAG,IAIH,CAAA"}

package/dist/utilities/entityInputSchema/validateEntityData.js

@@ -0,0 +1,138 @@
+import { fromJSONSchema } from 'zod';
+import { ValidationError } from '../../errors/ValidationError.js';
+import { getCollectionInputSchema, getGlobalInputSchema } from './getEntityInputSchema.js';
+export const validateCollectionData = ({ slug, data, partial, req })=>{
+    const schema = getCollectionInputSchema({
+        collectionSlug: slug,
+        req
+    });
+    validateEntityData({
+        slug,
+        data,
+        entity: 'collection',
+        partial,
+        req,
+        schema
+    });
+};
+export const validateGlobalData = ({ slug, data, req })=>{
+    const schema = getGlobalInputSchema({
+        globalSlug: slug,
+        req
+    });
+    validateEntityData({
+        slug,
+        data,
+        entity: 'global',
+        partial: true,
+        req,
+        schema
+    });
+};
+const validateEntityData = ({ slug, data, entity, partial, req, schema })=>{
+    if (!schema) {
+        return;
+    }
+    const validationSchema = partial ? withoutRequired(schema) : schema;
+    const result = fromJSONSchema(validationSchema).safeParse(data);
+    if (result.success) {
+        return;
+    }
+    throw new ValidationError({
+        [entity]: slug,
+        errors: getUsefulIssues(result.error.issues).map(({ message, path })=>({
+                message,
+                path: formatDataPath(path)
+            })),
+        req
+    });
+};
+/** Updates and drafts accept partial data, including partial nested objects and array rows. */ const withoutRequired = (schema)=>{
+    const { $defs, additionalProperties, anyOf, items, oneOf, properties, required: _required, ...partialSchema } = schema;
+    return {
+        ...partialSchema,
+        ...$defs ? {
+            $defs: mapSchemaRecord($defs)
+        } : {},
+        ...typeof additionalProperties === 'object' ? {
+            additionalProperties: withoutRequired(additionalProperties)
+        } : additionalProperties !== undefined ? {
+            additionalProperties
+        } : {},
+        ...anyOf ? {
+            anyOf: anyOf.map(makeSchemaPartial)
+        } : {},
+        ...items ? {
+            items: Array.isArray(items) ? items.map((item)=>withoutRequired(item)) : withoutRequired(items)
+        } : {},
+        ...oneOf ? {
+            oneOf: oneOf.map(makeSchemaPartial)
+        } : {},
+        ...properties ? {
+            properties: mapSchemaRecord(properties)
+        } : {}
+    };
+};
+const makeSchemaPartial = (schema)=>typeof schema === 'boolean' ? schema : withoutRequired(schema);
+const mapSchemaRecord = (schemas)=>Object.fromEntries(Object.entries(schemas).map(([name, schema])=>[
+            name,
+            makeSchemaPartial(schema)
+        ]));
+/**
+ * Zod keeps every failed recursive-union branch. Select the closest matching branch instead of
+ * returning a very large error tree to CLI and MCP clients.
+ */ const getUsefulIssues = (issues, parentPath = [])=>{
+    const selectedIssues = issues.flatMap((issue)=>{
+        if (issue.code !== 'invalid_union') {
+            return [
+                {
+                    ...issue,
+                    path: [
+                        ...parentPath,
+                        ...issue.path
+                    ]
+                }
+            ];
+        }
+        const unionPath = [
+            ...parentPath,
+            ...issue.path
+        ];
+        const closestBranch = issue.errors.filter((branch)=>branch.length > 0).sort(compareIssueBranches)[0];
+        return closestBranch ? getUsefulIssues(closestBranch, unionPath) : [
+            {
+                ...issue,
+                path: unionPath
+            }
+        ];
+    });
+    const uniqueIssues = new Map();
+    for (const issue of selectedIssues){
+        const key = `${issue.path.map(String).join('.')}:${issue.message}`;
+        if (!uniqueIssues.has(key)) {
+            uniqueIssues.set(key, issue);
+        }
+    }
+    return [
+        ...uniqueIssues.values()
+    ].slice(0, 10);
+};
+const compareIssueBranches = (left, right)=>{
+    const discriminatorDifference = countDiscriminatorIssues(left) - countDiscriminatorIssues(right);
+    if (discriminatorDifference !== 0) {
+        return discriminatorDifference;
+    }
+    const pathDepthDifference = getDeepestPath(right) - getDeepestPath(left);
+    if (pathDepthDifference !== 0) {
+        return pathDepthDifference;
+    }
+    return left.length - right.length;
+};
+const countDiscriminatorIssues = (issues)=>issues.filter((issue)=>{
+        const field = issue.path.at(-1);
+        return field === 'blockType' || field === 'relationTo' || field === 'type';
+    }).length;
+const getDeepestPath = (issues)=>Math.max(0, ...issues.map((issue)=>issue.path.length));
+const formatDataPath = (path)=>path.reduce((result, segment)=>typeof segment === 'number' ? `${result}[${segment}]` : `${result}.${String(segment)}`, 'data');
+
+//# sourceMappingURL=validateEntityData.js.map