payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/utilities/entityInputSchema/sanitizeEntitySchema.js

@@ -0,0 +1,409 @@
+/**
+ * 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, shouldKeepDeprecatedProperties = false })=>{
+    // 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);
+    // LLM ergonomics — hide optional properties marked `deprecated` (e.g. Lexical's node `version`).
+    if (!shouldKeepDeprecatedProperties) {
+        result = removeDeprecatedProperties(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;
+};
+/**
+ * **LLM ergonomics.** Removes optional properties marked `deprecated`, so the model never has to
+ * consider sending them. The schema used for validation keeps them, which keeps existing data that
+ * still contains them valid. Required properties are never removed, so data that matches the shown
+ * schema always passes validation.
+ *
+ * @example
+ * { properties: { text: { type: 'string' }, version: { type: 'integer', deprecated: true } }, required: ['text'] }
+ * → { properties: { text: { type: 'string' } }, required: ['text'] }
+ */ const removeDeprecatedProperties = (schema)=>mapNodes(schema, (node)=>{
+        if (!node.properties || typeof node.properties !== 'object') {
+            return node;
+        }
+        for (const [key, property] of Object.entries(node.properties)){
+            const isRequired = Array.isArray(node.required) && node.required.includes(key);
+            if (!isRequired && property?.deprecated === true) {
+                delete node.properties[key];
+            }
+        }
+        return node;
+    });
+/**
+ * **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 = ({\n  schema,\n  shouldKeepDeprecatedProperties = false,\n}: {\n  schema: JsonSchemaType\n  /**\n   * Keep optional properties marked `deprecated` instead of hiding them. Validation needs them, so\n   * that existing data that still contains them stays valid input.\n   */\n  shouldKeepDeprecatedProperties?: boolean\n}): 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  // LLM ergonomics — hide optional properties marked `deprecated` (e.g. Lexical's node `version`).\n  if (!shouldKeepDeprecatedProperties) {\n    result = removeDeprecatedProperties(result)\n  }\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 * **LLM ergonomics.** Removes optional properties marked `deprecated`, so the model never has to\n * consider sending them. The schema used for validation keeps them, which keeps existing data that\n * still contains them valid. Required properties are never removed, so data that matches the shown\n * schema always passes validation.\n *\n * @example\n * { properties: { text: { type: 'string' }, version: { type: 'integer', deprecated: true } }, required: ['text'] }\n * → { properties: { text: { type: 'string' } }, required: ['text'] }\n */\nconst removeDeprecatedProperties = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    if (!node.properties || typeof node.properties !== 'object') {\n      return node\n    }\n    for (const [key, property] of Object.entries(node.properties)) {\n      const isRequired = Array.isArray(node.required) && node.required.includes(key)\n      if (!isRequired && property?.deprecated === true) {\n        delete node.properties[key]\n      }\n    }\n    return node\n  }) as JsonSchemaType\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","shouldKeepDeprecatedProperties","result","structuredClone","collapseOptionalContainerTypes","pointFieldsToObjects","removeDeprecatedProperties","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","property","deprecated","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,18 @@
+export type EntityInputSchema = {
+    $defs?: Record<string, boolean | EntityInputSchema>;
+    $ref?: string;
+    [key: string]: unknown;
+    additionalProperties?: boolean | EntityInputSchema;
+    anyOf?: Array<boolean | EntityInputSchema>;
+    const?: unknown;
+    /** Hidden from the schema shown to agents unless required. Validation still accepts it. */
+    deprecated?: boolean;
+    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,2FAA2F;IAC3F,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,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  /** Hidden from the schema shown to agents unless required. Validation still accepts it. */\n  deprecated?: boolean\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,WAgBC"}

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,IAQH,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"}