@payloadcms/figma 0.1.0-alpha.0 → 0.1.0-internal.e071575

package/dist/db-content-api/utilities/data/convertRelationshipIds.js

@@ -0,0 +1,109 @@
+import { valueIsValueWithRelation } from 'payload/shared';
+import { matchAtomicOperation, RELATIONSHIP_ATOMIC_OPERATORS } from './atomicOperations.js';
+import { isLocaleMap } from './isLocaleMap.js';
+export function convertRelationshipFieldIdsFromWire(options) {
+    return convertRelationshipFieldIds({
+        ...options,
+        direction: 'fromWire'
+    });
+}
+export function convertRelationshipFieldIdsToWire(options) {
+    return convertRelationshipFieldIds({
+        ...options,
+        direction: 'toWire'
+    });
+}
+/**
+ * Converts the id(s) inside a relationship/upload field value between Payload's
+ * representation (numeric ids kept as numbers) and the Content API wire form
+ * (all ids as strings). No-op for uuid/text targets. Preserves has-many arrays,
+ * polymorphic shapes, localized locale-maps, and atomic operators.
+ */ export function convertRelationshipFieldIds(options) {
+    const { direction, field, payload, value } = options;
+    if (value == null) {
+        return value;
+    }
+    const relationTo = field.relationTo;
+    const localized = field.localized ?? false;
+    const hasMany = field.hasMany ?? false;
+    // The value shape is fully determined by the localized × hasMany combination:
+    //   !localized, !hasMany → a single value
+    //   !localized,  hasMany → an array of values (or a `$push`/`$remove` wrapper)
+    //    localized, !hasMany → a locale-map of single values
+    //    localized,  hasMany → a locale-map of arrays
+    // Localized values arrive as a locale-map on write and all-locales reads, but
+    // as the bare per-locale value on single-locale reads, so a localized field
+    // dispatches through `convertLocalized`, which handles both.
+    const convertValue = (entry)=>hasMany ? convertHasManyValue(entry, relationTo, payload, direction) : convertSingleValue(entry, relationTo, payload, direction);
+    return localized ? convertLocalized(value, convertValue) : convertValue(value);
+}
+// Applies `convertValue` to each entry of a localized locale-map. A single-locale
+// read delivers the bare per-locale value instead of a map (a plain object then
+// is a polymorphic ref, not a locale-map), so that case is converted directly.
+function convertLocalized(value, convertValue) {
+    if (!isLocaleMap(value)) {
+        return convertValue(value);
+    }
+    const out = {};
+    for (const [locale, localeValue] of Object.entries(value)){
+        out[locale] = localeValue == null ? localeValue : convertValue(localeValue);
+    }
+    return out;
+}
+// A has-many value normalizes to an array of single values: Payload may pass a
+// lone value (e.g. `children: 'uuid'`), which is wrapped into a single-element
+// array. Writes may instead wrap the value in an atomic `$push`/`$remove`
+// operator, which is preserved — its payload is converted but not array-wrapped,
+// since those operators accept a single value or an array.
+function convertHasManyValue(value, relationTo, payload, direction) {
+    const atomic = matchAtomicOperation(value, RELATIONSHIP_ATOMIC_OPERATORS);
+    if (atomic) {
+        return {
+            [atomic.operator]: convertAtomicPayload(atomic.inner, relationTo, payload, direction)
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry)=>convertSingleValue(entry, relationTo, payload, direction));
+    }
+    return [
+        convertSingleValue(value, relationTo, payload, direction)
+    ];
+}
+// The payload of a `$push`/`$remove` operator may be a single value or an array;
+// convert either without changing its arity.
+function convertAtomicPayload(value, relationTo, payload, direction) {
+    return Array.isArray(value) ? value.map((entry)=>convertSingleValue(entry, relationTo, payload, direction)) : convertSingleValue(value, relationTo, payload, direction);
+}
+// A single relationship value is a polymorphic `{ relationTo, value }` (when the
+// field targets multiple collections) or a bare id (when it targets one). The id
+// type comes from the referenced collection.
+function convertSingleValue(value, relationTo, payload, direction) {
+    if (value == null) {
+        return value;
+    }
+    if (valueIsValueWithRelation(value)) {
+        return {
+            ...value,
+            value: convertLeafId(value.value, customIdTypeFor(payload, value.relationTo), direction)
+        };
+    }
+    // A non-polymorphic field targets a single collection (string `relationTo`).
+    const customIDType = typeof relationTo === 'string' ? customIdTypeFor(payload, relationTo) : undefined;
+    return convertLeafId(value, customIDType, direction);
+}
+function customIdTypeFor(payload, slug) {
+    return payload.collections?.[slug]?.customIDType;
+}
+function convertLeafId(id, customIDType, direction) {
+    if (id == null || id === '') {
+        return id;
+    }
+    // Only numeric custom ids differ between Payload (number) and the wire (string).
+    if (customIDType !== 'number') {
+        return id;
+    }
+    if (direction === 'toWire') {
+        return typeof id === 'number' ? String(id) : id;
+    }
+    return typeof id === 'string' ? Number(id) : id;
+}

package/dist/db-content-api/utilities/data/index.js

@@ -1,21 +1,14 @@
 import { flattenAllFields, traverseFields } from 'payload';
 import { applyDefaults } from './applyDefaults.js';
+import { ATOMIC_OPERATORS, isAtomicOperation } from './atomicOperations.js';
 import { castFieldValue } from './castFieldValue.js';
+import { convertRelationshipFieldIds } from './convertRelationshipIds.js';
+import { decodePointFromRead, encodePointForWrite } from './pointShape.js';
 import { removeVirtualFields } from './removeVirtualFields.js';
+import { resolveFieldLocalization } from './resolveFieldLocalization.js';
+import { decodeRichTextFromRead, encodeRichTextForWrite } from './richTextShape.js';
 import { stripFields } from './stripFields.js';
 import { transformToLocalizeStatus } from './transformPublishedLocale.js';
-const ATOMIC_OPERATION_KEYS = [
-    '$push',
-    '$remove',
-    '$inc'
-];
-function isAtomicOperation(value) {
-    if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    const keys = Object.keys(value);
-    return keys.length === 1 && ATOMIC_OPERATION_KEYS.includes(keys[0]);
-}
 /**
  * Transform data before sending to Content API (WRITE operations)
  *
@@ -49,16 +42,21 @@ function isAtomicOperation(value) {
         applyDefaults(transformed, collectionConfig.fields, payload.config.blocks);
     }
     // Use Payload's traverseFields to iterate over all fields for transformations
-    const callback = ({ field, ref })=>{
-        if (!('name' in field) || !field.name) {
+    const callback = ({ field: declaredField, parentIsLocalized, ref })=>{
+        if (!('name' in declaredField) || declaredField.name == null) {
             return;
         }
         if (!ref || typeof ref !== 'object') {
             return;
         }
+        const fieldName = declaredField.name;
+        const field = resolveFieldLocalization({
+            field: declaredField,
+            isAbsorbed: parentIsLocalized
+        });
         const current = ref;
-        let value = current[field.name];
-        if (isAtomicOperation(value)) {
+        let value = current[fieldName];
+        if (isAtomicOperation(value, ATOMIC_OPERATORS) && field.type !== 'relationship' && field.type !== 'upload') {
             return;
         }
         // null → [] for non-localized array-like fields. SQL adapters return null for empty join
@@ -68,25 +66,33 @@ function isAtomicOperation(value) {
             const isArrayLike = field.type === 'array' || field.type === 'blocks';
             const isHasManySelect = field.type === 'select' && 'hasMany' in field && field.hasMany;
             if (isHasManyArray || isArrayLike || isHasManySelect) {
-                current[field.name] = [];
+                current[fieldName] = [];
                 return;
             }
         }
         if (value !== null && value !== undefined) {
-            value = castFieldValue(field, value);
-            current[field.name] = value;
-            // Normalize non-localized hasMany relationship/upload: single value → array.
-            // Payload may not wrap in array before calling db.update (e.g. children: 'uuid').
-            const isNonLocalizedHasMany = !('localized' in field && field.localized) && (field.type === 'relationship' || field.type === 'upload') && 'hasMany' in field && field.hasMany;
-            if (isNonLocalizedHasMany && !Array.isArray(value)) {
-                current[field.name] = [
+            if (field.type === 'relationship' || field.type === 'upload') {
+                // Convert ids that point at a numeric-custom-id collection to strings —
+                // the wire (and the server's relationshipSchema) only accepts string ids —
+                // and normalize a has-many value to an array.
+                current[fieldName] = convertRelationshipFieldIds({
+                    direction: 'toWire',
+                    field,
+                    payload,
                     value
-                ];
+                });
+                return;
             }
-            // RichText: object -> JSON string
-            if (field.type === 'richText' && typeof value !== 'string') {
-                current[field.name] = JSON.stringify(value);
+            if (field.type === 'point') {
+                current[fieldName] = encodePointForWrite(field, value);
+                return;
             }
+            if (field.type === 'richText') {
+                current[fieldName] = encodeRichTextForWrite(field, value);
+                return;
+            }
+            value = castFieldValue(field, value);
+            current[fieldName] = value;
         }
     };
     traverseFields({
@@ -103,8 +109,7 @@ function isAtomicOperation(value) {
             fields: collectionConfig.fields
         }),
         reservedKeys: [
-            'id',
-            'globalType'
+            'id'
         ]
     });
     removeVirtualFields(transformed, collectionConfig.fields);
@@ -169,21 +174,28 @@ export function dataFromContentAPI(payload, collectionSlug, data, locale) {
     }
     const isAllLocales = locale === 'all' || locale === '*';
     // Use Payload's traverseFields to iterate over all fields
-    const callback = ({ field, parentPath, ref })=>{
-        if (!('name' in field) || !field.name) {
+    const callback = ({ field: declaredField, parentIsLocalized, parentPath, ref })=>{
+        if (!('name' in declaredField) || !declaredField.name) {
             return;
         }
         if (!ref || typeof ref !== 'object') {
             return;
         }
+        // Value shaping below depends on whether locale keys appear at this path, so
+        // work from the resolved field rather than the declared one.
+        const fieldName = declaredField.name;
+        const field = resolveFieldLocalization({
+            field: declaredField,
+            isAbsorbed: parentIsLocalized
+        });
         const current = ref;
-        const value = current[field.name];
-        const isLocalized = 'localized' in field && field.localized;
+        const value = current[fieldName];
+        const isLocalized = 'localized' in field && field.localized === true;
         // Group fields must always be an object so Payload can traverse sub-fields
         // (e.g. join fields inside a group). A null/undefined group crashes afterRead.
         if (field.type === 'group') {
             if (value == null || typeof value !== 'object') {
-                current[field.name] = {};
+                current[fieldName] = {};
             }
             return;
         }
@@ -191,7 +203,7 @@ export function dataFromContentAPI(payload, collectionSlug, data, locale) {
         // Content API returns join data directly at the field path (e.g. { docs: [...] }),
         // but Payload's afterRead expects localized fields as { [locale]: value }.
         if (field.type === 'join' && isLocalized && value !== undefined && !isAllLocales && locale) {
-            current[field.name] = {
+            current[fieldName] = {
                 [locale]: value
             };
             return;
@@ -202,22 +214,36 @@ export function dataFromContentAPI(payload, collectionSlug, data, locale) {
             const isRequired = 'required' in field && field.required;
             const isJoin = field.type === 'join';
             if (!isRequired && !isJoin) {
-                current[field.name] = isLocalized && isAllLocales ? {} : null;
+                current[fieldName] = isLocalized && isAllLocales ? {} : null;
             }
             return;
         }
         // null localized field in all-locales mode → {} (empty locale map)
         if (value === null && isLocalized && isAllLocales) {
-            current[field.name] = {};
+            current[fieldName] = {};
             return;
         }
         if (value !== null) {
-            // hasMany relationships: normalize to array (non-localized only).
-            // We store raw JSON so a single value stays as-is; Payload expects arrays.
-            if (field.type === 'relationship' && field.hasMany && !Array.isArray(value) && !('localized' in field && field.localized)) {
-                current[field.name] = [
+            if (field.type === 'relationship' || field.type === 'upload') {
+                // The Content API returns ids as strings; convert back to numbers for
+                // relationships that point at a numeric-custom-id collection so Payload
+                // sees its native type, and normalize a has-many value to an array.
+                current[fieldName] = convertRelationshipFieldIds({
+                    direction: 'fromWire',
+                    field,
+                    payload,
                     value
-                ];
+                });
+                return;
+            }
+            if (field.type === 'point') {
+                current[fieldName] = decodePointFromRead(field, value);
+                return;
+            }
+            if (field.type === 'richText') {
+                const fieldPath = parentPath ? `${parentPath}.${field.name}` : field.name;
+                current[fieldName] = decodeRichTextFromRead(field, value, payload, fieldPath, collectionSlug);
+                return;
             }
             // Localized array/blocks: empty per-locale arrays → null in single-locale mode.
             // Payload's afterRead fallback triggers on null (not []), matching SQL adapter behavior.
@@ -232,25 +258,15 @@ export function dataFromContentAPI(payload, collectionSlug, data, locale) {
             }
             // Localized fields: JSON string → parsed object (locale map).
             // Simple strings that fail to parse as objects are kept as-is (expected for single-locale).
-            if ('localized' in field && field.localized && typeof value === 'string') {
+            if (isLocalized && typeof value === 'string') {
                 try {
                     const parsed = JSON.parse(value);
                     if (typeof parsed === 'object' && parsed !== null) {
-                        current[field.name] = parsed;
+                        current[fieldName] = parsed;
                     }
                 } catch  {
                 // Not valid JSON - keep original value
                 }
-            } else if (field.type === 'richText' && typeof value === 'string') {
-                try {
-                    current[field.name] = JSON.parse(value);
-                } catch (error) {
-                    const fieldPath = parentPath ? `${parentPath}.${field.name}` : field.name;
-                    payload.logger.warn({
-                        err: error instanceof Error ? error : new Error(String(error)),
-                        msg: `Failed to parse richtext field '${fieldPath}' in collection '${collectionSlug}'`
-                    });
-                }
             }
         // Date fields: Already ISO strings from Content API, no conversion needed
         }

package/dist/db-content-api/utilities/data/isLocaleMap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A locale-map is a plain object keyed by locale (e.g. `{ en: 'id', fr: 'id' }`) —
+ * distinct from the other object shapes a field value can take: a polymorphic
+ * relationship ref (`{ relationTo, value }`) or an atomic wrapper (`{ $push: … }`).
+ *
+ * Localized values arrive as a locale-map on write and all-locales reads, but as
+ * the bare per-locale value on single-locale reads, so a localized field cannot
+ * assume the map and has to discriminate on the shape.
+ */
+export declare function isLocaleMap(value: unknown): value is Record<string, unknown>;

package/dist/db-content-api/utilities/data/isLocaleMap.js

@@ -0,0 +1,13 @@
+import { valueIsValueWithRelation } from 'payload/shared';
+import { ATOMIC_OPERATORS, isAtomicOperation } from './atomicOperations.js';
+/**
+ * A locale-map is a plain object keyed by locale (e.g. `{ en: 'id', fr: 'id' }`) —
+ * distinct from the other object shapes a field value can take: a polymorphic
+ * relationship ref (`{ relationTo, value }`) or an atomic wrapper (`{ $push: … }`).
+ *
+ * Localized values arrive as a locale-map on write and all-locales reads, but as
+ * the bare per-locale value on single-locale reads, so a localized field cannot
+ * assume the map and has to discriminate on the shape.
+ */ export function isLocaleMap(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && !valueIsValueWithRelation(value) && !isAtomicOperation(value, ATOMIC_OPERATORS);
+}

package/dist/db-content-api/utilities/data/resolveFieldLocalization.d.ts

@@ -0,0 +1,18 @@
+import type { Field, TabAsField } from 'payload';
+interface ResolveFieldLocalizationOptions<TField extends Field | TabAsField> {
+    field: TField;
+    isAbsorbed: boolean;
+}
+/**
+ * Returns the field with `localized` collapsed to whether locale keys actually
+ * appear in its data — `false` for a field whose localized ancestor already
+ * absorbed them (see `createIsLocaleAbsorbed`).
+ *
+ * Every value-shaping helper keys off `field.localized` to decide whether it is
+ * looking at a locale map or a bare value, so handing them the resolved field
+ * keeps that decision correct without each one needing to know about absorption.
+ * The field is returned as-is when nothing changes, so the common path allocates
+ * nothing and any narrowing the caller has already done survives.
+ */
+export declare function resolveFieldLocalization<TField extends Field | TabAsField>({ field, isAbsorbed, }: ResolveFieldLocalizationOptions<TField>): TField;
+export {};

package/dist/db-content-api/utilities/data/resolveFieldLocalization.js

@@ -0,0 +1,21 @@
+/**
+ * Returns the field with `localized` collapsed to whether locale keys actually
+ * appear in its data — `false` for a field whose localized ancestor already
+ * absorbed them (see `createIsLocaleAbsorbed`).
+ *
+ * Every value-shaping helper keys off `field.localized` to decide whether it is
+ * looking at a locale map or a bare value, so handing them the resolved field
+ * keeps that decision correct without each one needing to know about absorption.
+ * The field is returned as-is when nothing changes, so the common path allocates
+ * nothing and any narrowing the caller has already done survives.
+ */ export function resolveFieldLocalization({ field, isAbsorbed }) {
+    if (!isAbsorbed || !('localized' in field) || field.localized !== true) {
+        return field;
+    }
+    // Only `localized` changes, so the result is still the same field type; TypeScript
+    // cannot see that through a spread of a generic union member.
+    return {
+        ...field,
+        localized: false
+    };
+}

package/dist/db-content-api/utilities/data/validateRelationships.js

@@ -1,17 +1,26 @@
 import { traverseFields } from 'payload';
+import { valueIsValueWithRelation } from 'payload/shared';
+import { RELATIONSHIP_ATOMIC_OPERATORS, unwrapAtomicOperation } from './atomicOperations.js';
+import { resolveFieldLocalization } from './resolveFieldLocalization.js';
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function collectRelationshipValues({ data, fields }) {
     const relationships = [];
-    const callback = ({ field, ref })=>{
-        if (!('name' in field) || !field.name) {
+    const callback = ({ field: declaredField, parentIsLocalized, ref })=>{
+        if (!('name' in declaredField) || !declaredField.name) {
             return;
         }
-        if (field.type !== 'relationship' && field.type !== 'upload') {
+        if (declaredField.type !== 'relationship' && declaredField.type !== 'upload') {
             return;
         }
         if (!ref || typeof ref !== 'object') {
             return;
         }
+        // Only a field whose locale keys were not absorbed by a localized ancestor
+        // holds a locale map; an absorbed one holds the relationship value directly.
+        const field = resolveFieldLocalization({
+            field: declaredField,
+            isAbsorbed: parentIsLocalized
+        });
         const rawValue = ref[field.name];
         if (rawValue == null || rawValue === '') {
             return;
@@ -38,21 +47,19 @@ function collectRelationshipValues({ data, fields }) {
     });
     return relationships;
 }
-function parseRelationshipValues(value, relationTo, relationships) {
+function parseRelationshipValues(rawValue, relationTo, relationships) {
+    const value = unwrapAtomicOperation(rawValue, RELATIONSHIP_ATOMIC_OPERATORS);
     if (Array.isArray(relationTo)) {
         // Polymorphic (single or hasMany): value is { relationTo, value } or array of them
         const values = Array.isArray(value) ? value : [
             value
         ];
         for (const v of values){
-            if (v && typeof v === 'object' && 'relationTo' in v && 'value' in v) {
-                const obj = v;
-                if (obj.value != null && obj.value !== '') {
-                    relationships.push({
-                        collection: obj.relationTo,
-                        value: obj.value
-                    });
-                }
+            if (valueIsValueWithRelation(v) && v.value != null && v.value !== '') {
+                relationships.push({
+                    collection: v.relationTo,
+                    value: v.value
+                });
             }
         }
     } else {

package/dist/db-content-api/utilities/joins.d.ts

@@ -1,6 +1,6 @@
 import type { JoinQuery, Payload } from 'payload';
 import type { components } from '../generated/content-api-types.js';
-type ContentAPIJoin = components['schemas']['JoinClause'][number];
+type ContentAPIJoin = components['schemas']['JoinClauseV1'][number];
 /**
  * Convert Payload's JoinQuery to Content API's join format.
  *
@@ -32,10 +32,8 @@ type ContentAPIJoin = components['schemas']['JoinClause'][number];
  *   }
  * }
  *
- * Content API's join format:
+ * Content API's v1 join format:
  * [{
- *   collectionId: 'posts',     // collection to join FROM
- *   on: 'group.category',      // field in joined collection pointing to this doc
  *   path: 'group.relatedPosts', // where to put results
  *   count: false,
  *   where: { ... },            // Content API where format
@@ -44,9 +42,9 @@ type ContentAPIJoin = components['schemas']['JoinClause'][number];
  *   page: 2
  * }]
  *
- * The mapping requires the collection config to resolve:
- * - Which collection each join field refers to
- * - What the 'on' field is for each join
+ * v1 resolves the joined collection and key from the document schema, so the
+ * adapter no longer emits collectionId/on. The collection config is still read
+ * to resolve default limit and sort for each join path.
  */
-export declare function convertPayloadJoinsToContentAPI(payload: Payload, collectionSlug: string, joins: false | JoinQuery | undefined, locale?: string): ContentAPIJoin[] | undefined;
+export declare function convertPayloadJoinsToContentAPI(payload: Payload, collectionSlug: string, joins: false | JoinQuery | undefined): ContentAPIJoin[] | undefined;
 export {};

package/dist/db-content-api/utilities/joins.js

@@ -31,10 +31,8 @@ import { convertPayloadWhereToContentAPI } from './where.js';
  *   }
  * }
  *
- * Content API's join format:
+ * Content API's v1 join format:
  * [{
- *   collectionId: 'posts',     // collection to join FROM
- *   on: 'group.category',      // field in joined collection pointing to this doc
  *   path: 'group.relatedPosts', // where to put results
  *   count: false,
  *   where: { ... },            // Content API where format
@@ -43,10 +41,10 @@ import { convertPayloadWhereToContentAPI } from './where.js';
  *   page: 2
  * }]
  *
- * The mapping requires the collection config to resolve:
- * - Which collection each join field refers to
- * - What the 'on' field is for each join
- */ export function convertPayloadJoinsToContentAPI(payload, collectionSlug, joins, locale) {
+ * v1 resolves the joined collection and key from the document schema, so the
+ * adapter no longer emits collectionId/on. The collection config is still read
+ * to resolve default limit and sort for each join path.
+ */ export function convertPayloadJoinsToContentAPI(payload, collectionSlug, joins) {
     const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
     if (!collectionConfig) {
         return undefined;
@@ -72,14 +70,10 @@ import { convertPayloadWhereToContentAPI } from './where.js';
         for (const [collectionSlug, sanitizedJoins] of Object.entries(collectionConfig.joins)){
             for (const sanitizedJoin of sanitizedJoins){
                 if (sanitizedJoin.joinPath === joinPath) {
-                    const on = locale && sanitizedJoin.getForeignPath ? sanitizedJoin.getForeignPath({
-                        locale
-                    }) : sanitizedJoin.field.on;
                     foundJoin = {
                         collectionSlug,
                         defaultLimit: sanitizedJoin.field.defaultLimit,
-                        defaultSort: sanitizedJoin.field.defaultSort,
-                        on
+                        defaultSort: sanitizedJoin.field.defaultSort
                     };
                     break;
                 }
@@ -92,14 +86,9 @@ import { convertPayloadWhereToContentAPI } from './where.js';
         if (!foundJoin) {
             for (const sanitizedJoin of collectionConfig.polymorphicJoins){
                 if (sanitizedJoin.joinPath === joinPath) {
-                    const collections = sanitizedJoin.field.collection;
-                    const on = locale && sanitizedJoin.getForeignPath ? sanitizedJoin.getForeignPath({
-                        locale
-                    }) : sanitizedJoin.field.on;
                     foundJoin = {
-                        collectionSlug: collections,
-                        defaultSort: sanitizedJoin.field.defaultSort,
-                        on
+                        collectionSlug: sanitizedJoin.field.collection,
+                        defaultSort: sanitizedJoin.field.defaultSort
                     };
                     break;
                 }
@@ -114,9 +103,7 @@ import { convertPayloadWhereToContentAPI } from './where.js';
         // Add fallback sort for the joined collection
         const sortWithFallback = addFallbackSort(joinQuery.sort, payload, foundJoin.collectionSlug, foundJoin.defaultSort);
         const contentAPIJoin = {
-            collectionId: foundJoin.collectionSlug,
             count: joinQuery.count ?? false,
-            on: foundJoin.on,
             path: joinPath,
             ...effectiveLimit !== undefined && {
                 limit: effectiveLimit

package/dist/db-content-api/utilities/schema/buildDocumentSchema.d.ts

@@ -1,10 +1,19 @@
-import type { Config } from 'payload';
+import type { Config, SanitizedConfig } from 'payload';
 /**
  * Wire form of the v1 `DocumentSchema` sent on every request so the server can
  * classify each queried path against the index tables. Paths are
  * period-delimited (e.g. `author.name`).
+ *
+ * `localized` on a path is the flag *declared* by the Payload field, not a
+ * statement about where locale keys appear in the data. Payload nests locale keys
+ * at the outermost localized field on a path and stores everything beneath it
+ * plainly; the Content API resolves that absorption itself while walking a path,
+ * because a block entity is shared across the schema and can be referenced from
+ * both a localized and a non-localized `blocks` field. Read paths that need the
+ * resolved flag on this side use `isLocaleAbsorbed`.
  */
 export interface DocumentSchemaWire {
+    blocks: Record<string, WireBlockSchema>;
     collections: Record<string, WireCollectionSchema>;
     version: 1;
 }
@@ -13,11 +22,19 @@ interface WireCollectionSchema {
     name: string;
     paths: Record<string, WireFieldSchema>;
 }
+interface WireBlockSchema {
+    name: string;
+    paths: Record<string, WireFieldSchema>;
+}
 type WireHint = {
     paths: string[];
     type: 'unique';
 };
 type WireFieldSchema = {
+    blocks: Record<string, string>;
+    localized: boolean;
+    type: 'blocks';
+} | {
     collection: string | string[];
     on: string;
     type: 'join';
@@ -42,14 +59,14 @@ type WireFieldSchema = {
     unique: boolean;
 } | {
     localized: boolean;
-    type: 'array' | 'blocks';
+    type: 'array';
 } | {
     localized: boolean;
     type: 'checkbox' | 'date' | 'json' | 'radio';
 } | {
     localized: boolean;
-    type: 'code' | 'email' | 'point' | 'textarea';
+    type: 'code' | 'email' | 'point' | 'slug' | 'textarea';
     unique: boolean;
 };
-export declare function buildDocumentSchema(config: Config): DocumentSchemaWire;
+export declare function buildDocumentSchema(config: Config | SanitizedConfig): DocumentSchemaWire;
 export {};