@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.60

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

@@ -0,0 +1,55 @@
+import type { JoinQuery, Payload } from 'payload';
+import type { components } from '../generated/content-api-types.js';
+type ContentAPIJoin = components['schemas']['JoinClause'][number];
+/**
+ * Convert Payload's JoinQuery to Content API's join format.
+ *
+ * ## Content API Join Limitations
+ *
+ * The following Payload join features are NOT YET supported by Content API:
+ *
+ * 1. **hasMany relationships** - Content API's join uses `data#>'{path}'#>>'{}'` to extract
+ *    a single ID. HasMany relationships store arrays `["id1", "id2"]` which can't match.
+ *
+ * 2. **Array field relationships** - `on: 'array.category'` expects iteration over array
+ *    elements, but Content API treats the path as a single JSONB extraction.
+ *
+ * 3. **Polymorphic relationships** - Stored as `{ relationTo, value }` objects, but
+ *    Content API expects a simple ID string.
+ *
+ * 4. **Localized relationship fields** - Locale-aware joins not implemented.
+ *
+ * Note: "Where querying through joins" (e.g., `where: { 'relatedPosts.title': { equals: 'x' } }`)
+ * is a separate Payload feature that filters documents based on joined data. This is NOT
+ * a join feature but a where clause feature, and would need separate Content API support.
+ *
+ * Payload's JoinQuery format (at runtime):
+ * {
+ *   'group.relatedPosts': {    // joinPath - where results go in the document
+ *     sort: '-title',
+ *     limit: 10,
+ *     page: 2,                 // page-based pagination
+ *     where: { ... },          // Payload where format
+ *     count: true
+ *   }
+ * }
+ *
+ * Content API's 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
+ *   sort: '-title',
+ *   limit: 10,
+ *   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 declare function convertPayloadJoinsToContentAPI(payload: Payload, collectionSlug: string, joins: false | JoinQuery | undefined): ContentAPIJoin[] | undefined;
+export {};
+//# sourceMappingURL=joins.d.ts.map

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

@@ -0,0 +1,135 @@
+import { addFallbackSort } from '../temp-utilities/sorting.js';
+import { convertPayloadWhereToContentAPI } from './where.js';
+/**
+ * Convert Payload's JoinQuery to Content API's join format.
+ *
+ * ## Content API Join Limitations
+ *
+ * The following Payload join features are NOT YET supported by Content API:
+ *
+ * 1. **hasMany relationships** - Content API's join uses `data#>'{path}'#>>'{}'` to extract
+ *    a single ID. HasMany relationships store arrays `["id1", "id2"]` which can't match.
+ *
+ * 2. **Array field relationships** - `on: 'array.category'` expects iteration over array
+ *    elements, but Content API treats the path as a single JSONB extraction.
+ *
+ * 3. **Polymorphic relationships** - Stored as `{ relationTo, value }` objects, but
+ *    Content API expects a simple ID string.
+ *
+ * 4. **Localized relationship fields** - Locale-aware joins not implemented.
+ *
+ * Note: "Where querying through joins" (e.g., `where: { 'relatedPosts.title': { equals: 'x' } }`)
+ * is a separate Payload feature that filters documents based on joined data. This is NOT
+ * a join feature but a where clause feature, and would need separate Content API support.
+ *
+ * Payload's JoinQuery format (at runtime):
+ * {
+ *   'group.relatedPosts': {    // joinPath - where results go in the document
+ *     sort: '-title',
+ *     limit: 10,
+ *     page: 2,                 // page-based pagination
+ *     where: { ... },          // Payload where format
+ *     count: true
+ *   }
+ * }
+ *
+ * Content API's 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
+ *   sort: '-title',
+ *   limit: 10,
+ *   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) {
+    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!collectionConfig) {
+        return undefined;
+    }
+    // joins === false means explicitly disable all joins
+    // joins === undefined means use defaults (no custom query params)
+    if (joins === false || !joins) {
+        return undefined;
+    }
+    const result = [];
+    // Iterate through all join paths in the query
+    for (const [joinPath, joinQueryValue] of Object.entries(joins)){
+        // joinQuery === false means skip this specific join
+        if (joinQueryValue === false) {
+            continue;
+        }
+        // Normalize undefined/empty to empty object
+        const joinQuery = joinQueryValue ?? {};
+        // Find the SanitizedJoin config for this joinPath
+        // SanitizedJoins is indexed by the collection being joined FROM
+        let foundJoin;
+        // Search through all collections in the joins config
+        for (const [collectionSlug, sanitizedJoins] of Object.entries(collectionConfig.joins)){
+            for (const sanitizedJoin of sanitizedJoins){
+                if (sanitizedJoin.joinPath === joinPath) {
+                    foundJoin = {
+                        collectionSlug,
+                        defaultLimit: sanitizedJoin.field.defaultLimit,
+                        defaultSort: sanitizedJoin.field.defaultSort,
+                        on: sanitizedJoin.field.on
+                    };
+                    break;
+                }
+            }
+            if (foundJoin) {
+                break;
+            }
+        }
+        // Also check polymorphic joins
+        if (!foundJoin) {
+            for (const sanitizedJoin of collectionConfig.polymorphicJoins){
+                if (sanitizedJoin.joinPath === joinPath) {
+                    const collections = sanitizedJoin.field.collection;
+                    foundJoin = {
+                        collectionSlug: collections,
+                        defaultSort: sanitizedJoin.field.defaultSort,
+                        on: sanitizedJoin.field.on
+                    };
+                    break;
+                }
+            }
+        }
+        if (!foundJoin) {
+            payload.logger.warn(`Join path '${joinPath}' not found in collection config for '${collectionConfig.slug}'`);
+            continue;
+        }
+        // Fall back to the default limit if not specified in the query
+        const effectiveLimit = joinQuery.limit ?? foundJoin.defaultLimit;
+        // 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
+            },
+            ...joinQuery.page && {
+                page: joinQuery.page
+            },
+            ...sortWithFallback && {
+                sort: sortWithFallback
+            },
+            ...joinQuery.where && {
+                where: convertPayloadWhereToContentAPI(joinQuery.where)
+            }
+        };
+        result.push(contentAPIJoin);
+    }
+    return result.length > 0 ? result : undefined;
+}
+
+//# sourceMappingURL=joins.js.map

package/dist/db-content-api/utilities/locale/index.d.ts

@@ -0,0 +1,10 @@
+import type { Payload } from 'payload';
+/**
+ * Determines what locale to send to Content API based on request locale value
+ * and config's defaultLocale.
+ *
+ * If no locale is provided, falls back to the default locale from config.
+ * Returns undefined for 'all' and '*' (special Payload values for returning all locales).
+ */
+export declare function addFallbackLocale(locale: null | string | undefined, payload: Payload): string | undefined;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * Determines what locale to send to Content API based on request locale value
+ * and config's defaultLocale.
+ *
+ * If no locale is provided, falls back to the default locale from config.
+ * Returns undefined for 'all' and '*' (special Payload values for returning all locales).
+ */ export function addFallbackLocale(locale, payload) {
+    const defaultLocale = payload.config.localization ? payload.config.localization.defaultLocale : undefined;
+    if (locale) {
+        // 'all' and '*' are special Payload values meaning "return all locales" - don't send to Content API
+        if (locale === 'all' || locale === '*') {
+            return undefined;
+        }
+        return locale;
+    } else if (defaultLocale) {
+        return defaultLocale;
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/db-content-api/utilities/meta/buildLocalizedPaths.d.ts

@@ -0,0 +1,11 @@
+import type { Payload } from 'payload';
+/**
+ * Extracts all localized field paths from a collection's field configuration.
+ * Recursively traverses nested structures (groups, arrays, blocks, tabs) to find fields marked as localized.
+ *
+ * @param payload - The Payload instance containing collection configurations
+ * @param collectionSlug - The slug of the collection to extract localized paths from
+ * @returns Array of dot-notation paths to localized fields (e.g., ['title', 'metadata.description'])
+ */
+export declare function buildLocalizedPaths(payload: Payload, collectionSlug: string): string[];
+//# sourceMappingURL=buildLocalizedPaths.d.ts.map

package/dist/db-content-api/utilities/meta/buildLocalizedPaths.js

@@ -0,0 +1,74 @@
+/**
+ * Extracts all localized field paths from a collection's field configuration.
+ * Recursively traverses nested structures (groups, arrays, blocks, tabs) to find fields marked as localized.
+ *
+ * @param payload - The Payload instance containing collection configurations
+ * @param collectionSlug - The slug of the collection to extract localized paths from
+ * @returns Array of dot-notation paths to localized fields (e.g., ['title', 'metadata.description'])
+ */ export function buildLocalizedPaths(payload, collectionSlug) {
+    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!collectionConfig) {
+        return [];
+    }
+    const localizedPaths = [];
+    traverseFields(collectionConfig.fields, localizedPaths);
+    // Add _status to localized paths if localizeStatus is enabled for this collection
+    // _status is a base field added by Payload when versions.drafts is enabled,
+    // and it becomes localized when versions.drafts.localizeStatus is true
+    // localizeStatus requires both experimental flag AND collection-level config
+    const experimentalLocalizeStatus = 'experimental' in payload.config && payload.config.experimental && typeof payload.config.experimental === 'object' && 'localizeStatus' in payload.config.experimental && payload.config.experimental.localizeStatus === true;
+    const drafts = collectionConfig.versions && typeof collectionConfig.versions === 'object' ? collectionConfig.versions.drafts : false;
+    const collectionLocalizeStatus = drafts && typeof drafts === 'object' && 'localizeStatus' in drafts && drafts.localizeStatus === true;
+    const hasLocalizeStatus = payload.config.localization && experimentalLocalizeStatus && collectionLocalizeStatus;
+    if (hasLocalizeStatus && !localizedPaths.includes('_status')) {
+        localizedPaths.push('_status');
+    }
+    return localizedPaths;
+}
+/** Recursively traverses fields to find and collect localized paths */ function traverseFields(fields, localizedPaths, parentPath = '', parentIsLocalized = false) {
+    for (const field of fields){
+        // Unnamed layout fields (row, collapsible, unnamed group, unnamed tabs) don't store data
+        // at their own level, but their child fields may be localized. Recurse into them with
+        // the same parent path so localized fields bubble up correctly.
+        if (!('name' in field)) {
+            if ('fields' in field && Array.isArray(field.fields)) {
+                traverseFields(field.fields, localizedPaths, parentPath, parentIsLocalized);
+            }
+            if ('tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs){
+                    if (tab.fields) {
+                        const tabPath = tab.name ? buildPath(parentPath, tab.name) : parentPath;
+                        traverseFields(tab.fields, localizedPaths, tabPath, parentIsLocalized);
+                    }
+                }
+            }
+            continue;
+        }
+        const fieldPath = buildPath(parentPath, field.name);
+        const isLocalized = 'localized' in field && field.localized === true;
+        const includeNestedPaths = isLocalized || parentIsLocalized;
+        // Add field to results if localized or parent is localized
+        if (includeNestedPaths) {
+            localizedPaths.push(fieldPath);
+        }
+        // Handle blocks field - has a special 'blocks' array structure and each block has its own nested fields
+        if (field.type === 'blocks' && 'blocks' in field) {
+            for (const block of field.blocks){
+                if ('fields' in block) {
+                    traverseFields(block.fields, localizedPaths, fieldPath, includeNestedPaths);
+                }
+            }
+            continue;
+        }
+        // Handle field type that support nested fields
+        // Recursively handle nested structures (groups, arrays, tab, etc)
+        if ('fields' in field) {
+            traverseFields(field.fields, localizedPaths, fieldPath, includeNestedPaths);
+        }
+    }
+}
+/** Builds a dot-notation path from parent path and field name */ function buildPath(parentPath, fieldName) {
+    return parentPath ? `${parentPath}.${fieldName}` : fieldName;
+}
+
+//# sourceMappingURL=buildLocalizedPaths.js.map

package/dist/db-content-api/utilities/meta/buildMeta.d.ts

@@ -0,0 +1,42 @@
+import type { Payload, Where } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+import type { PathTypesRecord } from '../../temp-utilities/types.js';
+/**
+ * Metadata sent to Content API for query processing.
+ *
+ * TODO: This interface is defined here temporarily so Content API can test the integration.
+ * Once Content API implements support for pathTypes with relationship info, this type
+ * should be generated from openapi.json and ContentAPIMeta can be removed.
+ */
+export interface ContentAPIMeta {
+    localizedPaths?: string[];
+    pathTypes?: PathTypesRecord;
+    uniquePaths?: {
+        paths: string[];
+    }[];
+}
+/**
+ * The type that Content API currently expects (from generated types).
+ * This is more restrictive than ContentAPIMeta until Content API is updated.
+ */
+type ContentAPIMetaGenerated = components['schemas']['RequestMeta'];
+export interface BuildMetaOptions {
+    collection: string;
+    /** Document data — when provided, unique field constraints are included in meta. */
+    data?: Record<string, unknown>;
+    locale: string | undefined;
+    where?: Where;
+}
+/**
+ * Builds the `meta` object for Content API requests.
+ * Combines pathTypes (for array field handling) and localizedPaths (for locale queries).
+ *
+ * @param payload - The Payload instance
+ * @param options - Options including collection slug, locale, and where clause
+ * @returns Object with meta property ready to spread into request body, or empty object if no meta needed
+ */
+export declare function buildMeta(payload: Payload, options: BuildMetaOptions): {
+    meta?: ContentAPIMetaGenerated;
+};
+export {};
+//# sourceMappingURL=buildMeta.d.ts.map

package/dist/db-content-api/utilities/meta/buildMeta.js

@@ -0,0 +1,41 @@
+import { buildLocalizedPaths } from './buildLocalizedPaths.js';
+import { buildPathTypes } from './buildPathTypes.js';
+import { buildUniquePaths } from './buildUniquePaths.js';
+/**
+ * Builds the `meta` object for Content API requests.
+ * Combines pathTypes (for array field handling) and localizedPaths (for locale queries).
+ *
+ * @param payload - The Payload instance
+ * @param options - Options including collection slug, locale, and where clause
+ * @returns Object with meta property ready to spread into request body, or empty object if no meta needed
+ */ export function buildMeta(payload, options) {
+    const { collection, data, locale, where } = options;
+    const meta = {};
+    // Add pathTypes if there are array fields in the where clause
+    const pathTypes = buildPathTypes(payload, collection, where);
+    if (Object.keys(pathTypes).length > 0) {
+        meta.pathTypes = pathTypes;
+    }
+    // Add localizedPaths if locale is specified (but not 'all')
+    if (locale && locale !== 'all') {
+        const localizedPaths = buildLocalizedPaths(payload, collection);
+        if (localizedPaths.length > 0) {
+            meta.localizedPaths = localizedPaths;
+        }
+    }
+    // Add uniquePaths when data is provided (create/upsert operations)
+    if (data) {
+        const uniquePaths = buildUniquePaths(payload, collection, data);
+        if (uniquePaths.length > 0) {
+            meta.uniquePaths = uniquePaths;
+        }
+    }
+    // Cast to generated type - Content API will need to be updated to handle
+    // the new pathTypes format with relationship info. Until then, it will
+    // ignore the extra fields but still receive the data for testing.
+    return Object.keys(meta).length > 0 ? {
+        meta: meta
+    } : {};
+}
+
+//# sourceMappingURL=buildMeta.js.map

package/dist/db-content-api/utilities/meta/buildPathTypes.d.ts

@@ -0,0 +1,17 @@
+import type { Payload, Where } from 'payload';
+import type { PathTypesRecord } from '../../temp-utilities/types.js';
+/**
+ * Builds pathTypes metadata for Content API request.
+ * Returns a record of paths with their types for proper query generation.
+ *
+ * Includes:
+ * - Array fields (type: "array")
+ * - Relationship fields (type: { type: "relationship", collection, hasMany })
+ * - Join fields (type: { type: "join", collection, hasMany, on })
+ *
+ * Localized array/blocks fields (stored as locale maps) are handled specially:
+ * - The localized field itself is NOT marked as 'array' (it's a locale map object)
+ * - The locale-specific path (e.g. "localizedBlocks.en") IS marked as 'array'
+ */
+export declare function buildPathTypes(payload: Payload, collectionSlug: string, where: undefined | Where): PathTypesRecord;
+//# sourceMappingURL=buildPathTypes.d.ts.map

package/dist/db-content-api/utilities/meta/buildPathTypes.js

@@ -0,0 +1,244 @@
+/**
+ * Extracts all field paths from a where clause recursively
+ */ function extractPathsFromWhere(where, paths = new Set()) {
+    if (!where || typeof where !== 'object') {
+        return paths;
+    }
+    // Handle 'and' operator
+    if ('and' in where && Array.isArray(where.and)) {
+        for (const clause of where.and){
+            extractPathsFromWhere(clause, paths);
+        }
+        return paths;
+    }
+    // Handle 'or' operator
+    if ('or' in where && Array.isArray(where.or)) {
+        for (const clause of where.or){
+            extractPathsFromWhere(clause, paths);
+        }
+        return paths;
+    }
+    // Handle regular conditions - keys are field paths
+    for(const key in where){
+        if (key === 'and' || key === 'or') {
+            continue;
+        }
+        // Add the path
+        paths.add(key.replace(/__/g, '.'));
+        // Check if the value is a nested where clause (for relationships)
+        const value = where[key];
+        if (value && typeof value === 'object' && !('equals' in value) && !('in' in value)) {
+            // Might be a nested where, recurse
+            extractPathsFromWhere(value, paths);
+        }
+    }
+    return paths;
+}
+/**
+ * Determines the type of a field based on its configuration.
+ * Returns PathTypeValue for fields that need special handling in Content API queries.
+ */ function getFieldType(field) {
+    // Array field
+    if (field.type === 'array') {
+        return 'array';
+    }
+    // Blocks field (array of objects)
+    if (field.type === 'blocks') {
+        return 'array';
+    }
+    // Relationship field - always include for JOIN support
+    if (field.type === 'relationship') {
+        const { hasMany = false, relationTo: collection } = field;
+        return {
+            type: 'relationship',
+            collection,
+            hasMany
+        };
+    }
+    // Upload field - treated like relationship
+    if (field.type === 'upload') {
+        const { hasMany = false, relationTo: collection } = field;
+        return {
+            type: 'relationship',
+            collection,
+            hasMany
+        };
+    }
+    // Join field - virtual reverse lookup
+    if (field.type === 'join') {
+        const { collection, on } = field;
+        return {
+            type: 'join',
+            collection,
+            hasMany: true,
+            on
+        };
+    }
+    // Text field with hasMany (array of strings)
+    if (field.type === 'text' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Number field with hasMany (array of numbers)
+    if (field.type === 'number' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Select field with hasMany (array)
+    if (field.type === 'select' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Objects (group, collapsible, row, tabs) don't need traversal
+    return null;
+}
+/**
+ * Finds a field in the collection schema by its path.
+ * Supports nested paths like "access.read.users".
+ * For localized array/blocks fields, locale key segments (e.g. "en") are skipped transparently,
+ * so "localizedBlocks.en.richText" resolves to the richText field inside localizedBlocks.
+ */ function findFieldByPath(payload, collectionSlug, path) {
+    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!collectionConfig) {
+        return undefined;
+    }
+    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
+    const pathSegments = path.split('.');
+    // Walk through the path segments to find the field
+    let currentFields = collectionConfig.fields;
+    let currentField = undefined;
+    for(let i = 0; i < pathSegments.length; i++){
+        const segment = pathSegments[i];
+        // If this segment is a locale key for the previously found localized array/blocks field,
+        // skip it transparently (the locale key is the wrapping object key, not a real field).
+        if (localeCodes.includes(segment) && currentField && 'localized' in currentField && currentField.localized && (currentField.type === 'blocks' || currentField.type === 'array')) {
+            if (i === pathSegments.length - 1) {
+                // Last segment is a locale key → return the localized field (represents locale-specific array)
+                return currentField;
+            }
+            continue;
+        }
+        // First try to find a direct match
+        currentField = currentFields.find((f)=>'name' in f && f.name === segment);
+        // If not found, check if any unnamed container fields (collapsible, row) contain it
+        if (!currentField) {
+            for (const field of currentFields){
+                if (!('name' in field) || !field.name) {
+                    // This is an unnamed field, check its contents
+                    if ('fields' in field && field.type === 'collapsible' || 'fields' in field && field.type === 'row' || 'fields' in field && field.type === 'group') {
+                        currentField = field.fields.find((f)=>'name' in f && f.name === segment);
+                        if (currentField) {
+                            break;
+                        }
+                    } else if ('tabs' in field && field.type === 'tabs') {
+                        // Check all tabs
+                        for (const tab of field.tabs){
+                            // Named tab: the tab name itself is a path segment (acts like a group)
+                            if ('name' in tab && tab.name === segment) {
+                                currentField = {
+                                    name: tab.name,
+                                    type: 'group',
+                                    fields: tab.fields
+                                };
+                                break;
+                            }
+                            // Unnamed tab: search its fields for the segment
+                            const found = tab.fields.find((f)=>'name' in f && f.name === segment);
+                            if (found) {
+                                currentField = found;
+                                break;
+                            }
+                        }
+                        if (currentField) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!currentField) {
+            return undefined;
+        }
+        // If we're not at the end, get nested fields
+        if (i < pathSegments.length - 1) {
+            if (currentField.type === 'group' && 'fields' in currentField) {
+                currentFields = currentField.fields;
+            } else if (currentField.type === 'array' && 'fields' in currentField) {
+                currentFields = currentField.fields;
+            } else if (currentField.type === 'blocks' && 'blocks' in currentField) {
+                // Collect all fields from all block definitions to continue traversal
+                const allBlockFields = [];
+                for (const block of currentField.blocks){
+                    allBlockFields.push(...block.fields);
+                }
+                currentFields = allBlockFields;
+            } else if ((currentField.type === 'relationship' || currentField.type === 'upload') && typeof currentField.relationTo === 'string') {
+                // Traverse into the related collection's fields
+                const { relationTo } = currentField;
+                const relatedConfig = payload.config.collections.find((c)=>c.slug === relationTo);
+                if (relatedConfig) {
+                    currentFields = relatedConfig.fields;
+                } else {
+                    return undefined;
+                }
+            } else {
+                // Field doesn't have nested fields, can't continue
+                return undefined;
+            }
+        }
+    }
+    return currentField;
+}
+/**
+ * Builds pathTypes metadata for Content API request.
+ * Returns a record of paths with their types for proper query generation.
+ *
+ * Includes:
+ * - Array fields (type: "array")
+ * - Relationship fields (type: { type: "relationship", collection, hasMany })
+ * - Join fields (type: { type: "join", collection, hasMany, on })
+ *
+ * Localized array/blocks fields (stored as locale maps) are handled specially:
+ * - The localized field itself is NOT marked as 'array' (it's a locale map object)
+ * - The locale-specific path (e.g. "localizedBlocks.en") IS marked as 'array'
+ */ export function buildPathTypes(payload, collectionSlug, where) {
+    if (!where) {
+        return {};
+    }
+    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
+    const pathTypes = {};
+    const paths = extractPathsFromWhere(where);
+    for (const path of paths){
+        // For each path, we need to check all segments to see if any intermediate ones are arrays/relationships
+        const segments = path.split('.');
+        for(let i = 0; i < segments.length; i++){
+            const partialPath = segments.slice(0, i + 1).join('.');
+            // Skip if we already have this path
+            if (partialPath in pathTypes) {
+                continue;
+            }
+            // If the current segment is a locale code and the parent field is a localized array/blocks,
+            // mark this locale-specific path as 'array' (the per-locale content is the actual array).
+            if (i > 0 && localeCodes.includes(segments[i])) {
+                const parentPath = segments.slice(0, i).join('.');
+                const parentField = findFieldByPath(payload, collectionSlug, parentPath);
+                if (parentField && 'localized' in parentField && parentField.localized && (parentField.type === 'blocks' || parentField.type === 'array')) {
+                    pathTypes[partialPath] = 'array';
+                    continue;
+                }
+            }
+            const field = findFieldByPath(payload, collectionSlug, partialPath);
+            if (field) {
+                // Localized array/blocks fields are stored as locale maps (not arrays).
+                // Skip them here — the locale-specific path (e.g. "localizedBlocks.en") is marked above.
+                if ('localized' in field && field.localized && (field.type === 'blocks' || field.type === 'array')) {
+                    continue;
+                }
+                const fieldType = getFieldType(field);
+                if (fieldType !== null) {
+                    pathTypes[partialPath] = fieldType;
+                }
+            }
+        }
+    }
+    return pathTypes;
+}
+
+//# sourceMappingURL=buildPathTypes.js.map