@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.50

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

@@ -0,0 +1,211 @@
+import { flattenAllFields, traverseFields } from 'payload';
+import { applyDefaults } from './applyDefaults.js';
+import { castFieldValue } from './castFieldValue.js';
+import { removeVirtualFields } from './removeVirtualFields.js';
+import { stripFields } from './stripFields.js';
+import { transformToLocalizeStatus } from './transformPublishedLocale.js';
+/**
+ * Transform data before sending to Content API (WRITE operations)
+ *
+ * Conversions applied:
+ * - Default values: Apply static defaults for undefined fields (when applyDefaults=true)
+ * - Type casting: Convert values to match field types (e.g., number -> string for text fields)
+ * - RichText fields: Objects -> JSON strings
+ * - Virtual fields: Remove fields with `virtual: true` (pure virtual fields should never be saved)
+ * - Timestamps: Add updatedAt (always), and createdAt (when createdAt=true)
+ * - publishedLocale: Transform to localizeStatus format (when publishedLocale is provided)
+ *
+ * Note: Date fields are automatically converted to ISO strings by JSON.stringify()
+ */ export function dataToContentAPI(payload, collectionSlug, data, options) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Transform publishedLocale to localizeStatus format before other transformations
+    const dataWithLocalizedStatus = transformToLocalizeStatus(data, options?.publishedLocale);
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(dataWithLocalizedStatus));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    // Apply static defaults recursively to handle nested structures (arrays, groups)
+    // This must happen before traverseFields to ensure defaults are in place
+    if (options?.applyDefaults) {
+        applyDefaults(transformed, collectionConfig.fields);
+    }
+    // Use Payload's traverseFields to iterate over all fields for transformations
+    const callback = ({ field, ref })=>{
+        if (!('name' in field) || !field.name) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        const current = ref;
+        let value = current[field.name];
+        // Transform existing values
+        if (value !== null && value !== undefined) {
+            // Step 1: Apply type casting (e.g., number -> string for text fields)
+            value = castFieldValue(field, value);
+            current[field.name] = value;
+            // Step 2: Apply Content API specific transformations
+            // RichText: object -> JSON string
+            if (field.type === 'richText' && typeof value !== 'string') {
+                current[field.name] = JSON.stringify(value);
+            }
+        // Date fields are already handled by JSON.stringify() which converts Date -> ISO string
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        fillEmpty: false,
+        ref: transformed
+    });
+    stripFields({
+        config: payload.config,
+        data: transformed,
+        fields: flattenAllFields({
+            cache: true,
+            fields: collectionConfig.fields
+        }),
+        reservedKeys: [
+            'id',
+            'globalType'
+        ]
+    });
+    removeVirtualFields(transformed, collectionConfig.fields);
+    // Convert numeric ID to string for Content API
+    const customIDType = payload.collections?.[collectionSlug]?.customIDType;
+    if (customIDType === 'number') {
+        transformed.id = String(transformed.id);
+    }
+    // Add timestamps (Content API no longer auto-sets these in DB)
+    // updatedAt is always set, createdAt only on create operations
+    const now = new Date().toISOString();
+    transformed.updatedAt = now;
+    if (options?.createdAt) {
+        transformed.createdAt = now;
+    }
+    return transformed;
+}
+/**
+ * Transform data received from Content API (READ operations)
+ *
+ * Conversions applied:
+ * - RichText fields: JSON strings -> Objects
+ * - Virtual fields: Remove fields with `virtual: true` (should not be in DB but Content API backend may add them)
+ *
+ * Note: Date fields come as ISO strings from Content API and stay as strings
+ * (matching MongoDB and other adapters' behavior)
+ */ export function dataFromContentAPI(payload, collectionSlug, data) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(data));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    // Use Payload's traverseFields to iterate over all fields
+    const callback = ({ field, parentPath, ref })=>{
+        if (!('name' in field) || !field.name) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        const current = ref;
+        const value = current[field.name];
+        // Normalize undefined → null for optional fields
+        // Content API may omit fields (undefined) but Payload expects null for optional fields
+        if (value === undefined) {
+            const isRequired = 'required' in field && field.required;
+            if (!isRequired) {
+                current[field.name] = null;
+            }
+            return;
+        }
+        if (value !== null) {
+            // Localized fields: JSON string -> parsed object
+            // Content API may store localized fields as JSON strings like "{\"en\":\"value\"}"
+            // so we need to parse them back to objects.
+            // Note: We return the full locale object - Payload Core handles flattening to requested locale.
+            // When requesting a specific locale (not 'all'), values are simple strings that won't parse.
+            // In that case, we silently keep the original value.
+            if ('localized' in field && field.localized && typeof value === 'string') {
+                try {
+                    const parsed = JSON.parse(value);
+                    // Only use parsed value if it's actually an object (locale -> value mapping)
+                    // Simple strings like "EN Title" would parse to themselves, which we don't want
+                    if (typeof parsed === 'object' && parsed !== null) {
+                        current[field.name] = parsed;
+                    }
+                } catch  {
+                // Not valid JSON - keep original value (this is expected for single-locale requests)
+                }
+            } 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
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        fillEmpty: false,
+        ref: transformed
+    });
+    // Convert string ID to number if collection uses numeric custom ID
+    const customIDType = payload.collections?.[collectionSlug]?.customIDType;
+    if (customIDType === 'number') {
+        transformed.id = Number(transformed.id);
+    }
+    stripFields({
+        config: payload.config,
+        data: transformed,
+        fields: flattenAllFields({
+            cache: true,
+            fields: collectionConfig.fields
+        }),
+        reservedKeys: [
+            'id',
+            'globalType'
+        ]
+    });
+    // Remove virtual fields - must happen AFTER stripFields
+    removeVirtualFields(transformed, collectionConfig.fields);
+    // Handle auth-specific fields that aren't in the field schema
+    // When these fields are null in DB, Content API omits them from response (undefined)
+    // But Payload expects them to be null, not undefined
+    // Only add them if the collection has auth enabled
+    if ('auth' in collectionConfig && collectionConfig.auth) {
+        const authFields = [
+            'resetPasswordExpiration',
+            'lockUntil'
+        ];
+        for (const fieldName of authFields){
+            if (!(fieldName in transformed)) {
+                transformed[fieldName] = null;
+            }
+        }
+    }
+    return transformed;
+}
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,12 @@
+import type { CollectionConfig } from 'payload';
+/**
+ * Removes virtual fields (fields with virtual: true) from data recursively.
+ * Virtual fields should never be persisted in the database.
+ *
+ * @todo It might be a good idea to combine `stripFields` with `stripFields`
+ *  in a new utility that receives a callback with conditions. I didn't do
+ * it now because `stripFields` was copied from db-mongo and I'd like to
+ * find a way to unify everything.
+ */
+export declare function removeVirtualFields(data: Record<string, unknown>, fieldConfigs: CollectionConfig['fields']): void;
+//# sourceMappingURL=removeVirtualFields.d.ts.map

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

@@ -0,0 +1,54 @@
+/**
+ * Removes virtual fields (fields with virtual: true) from data recursively.
+ * Virtual fields should never be persisted in the database.
+ *
+ * @todo It might be a good idea to combine `stripFields` with `stripFields`
+ *  in a new utility that receives a callback with conditions. I didn't do
+ * it now because `stripFields` was copied from db-mongo and I'd like to
+ * find a way to unify everything.
+ */ export function removeVirtualFields(data, fieldConfigs) {
+    for (const field of fieldConfigs){
+        // Handle UI fields (row, collapsible, tabs) - they don't have names
+        // but contain other fields that might be virtual
+        if (field.type === 'row' || field.type === 'collapsible') {
+            if ('fields' in field) {
+                removeVirtualFields(data, field.fields);
+            }
+            continue;
+        }
+        if (field.type === 'tabs' && 'tabs' in field) {
+            for (const tab of field.tabs){
+                if ('fields' in tab) {
+                    removeVirtualFields(data, tab.fields);
+                }
+            }
+            continue;
+        }
+        // Skip fields without names
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        // Remove field if it has virtual: true
+        if ('virtual' in field && field.virtual === true) {
+            delete data[field.name];
+            continue;
+        }
+        // Recursively handle nested structures (groups, arrays with items, etc.)
+        if ('fields' in field && field.name in data) {
+            const value = data[field.name];
+            if (field.type === 'array' && Array.isArray(value)) {
+                // Process each array item
+                for (const item of value){
+                    if (item && typeof item === 'object') {
+                        removeVirtualFields(item, field.fields);
+                    }
+                }
+            } else if (field.type === 'group' && value && typeof value === 'object') {
+                // Process group
+                removeVirtualFields(value, field.fields);
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=removeVirtualFields.js.map

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

@@ -0,0 +1,48 @@
+import type { FlattenedField, SanitizedConfig } from 'payload';
+/**
+ * Strips fields from data that are not defined in the schema or are invalid.
+ *
+ * This function was copied from the MongoDB adapter's implementation:
+ * @see packages/db-mongodb/src/utilities/transform.ts (stripFields function)
+ *
+ * @description
+ * This utility performs deep sanitization of document data by:
+ * 1. **Removing undefined fields**: Strips any field not present in the collection's schema
+ *    (e.g., sensitive fields like `password`, `apiKey`, or any extra fields not in config)
+ * 2. **Removing invalid locales**: Deletes locale keys that don't exist in `config.localization.localeCodes`
+ *    (e.g., if data contains `{ "es-MX": "..." }` but only `"en"` is configured)
+ * 3. **Removing invalid blocks**: Filters out blocks with unknown `blockType` values
+ *    (prevents data corruption from blocks that don't exist in the schema)
+ * 4. **Recursive sanitization**: Processes nested structures (arrays, groups, blocks, localized fields)
+ *    to ensure deep data integrity
+ *
+ * @remarks
+ * Unlike MongoDB's adapter which uses Mongoose schemas with `strict: true` (rejecting extra fields
+ * on write), Content API uses flexible JSONB storage that accepts any fields. Therefore, this
+ * function is called on **both read and write operations** to ensure data consistency.
+ *
+ * The MongoDB adapter also supports an `allowAdditionalKeys` option that allows reading/writing
+ * fields not in the schema. For now, Content API does not support this feature - we always
+ * sanitize data. If users request this functionality in the future, we can consider adding it.
+ *
+ * @todo
+ * 1. Consider moving this utility to `payload/shared` so both MongoDB and Content API adapters
+ *    can use the same implementation, reducing code duplication and maintenance burden.
+ *
+ * 2. Performance optimization: This function iterates through all fields recursively.
+ *    The `dataToContentAPI` and `dataFromContentAPI` functions in
+ *    `packages/figma/src/db-content-api/utilities/data.ts` also iterate through fields
+ *    to transform richText (object ↔ JSON string), custom IDs (number ↔ string), and dates.
+ *    Consider combining both traversals into a single abstraction to avoid iterating twice.
+ *
+ * 3. Feature parity: MongoDB adapter has `allowAdditionalKeys` option. We currently always
+ *    strip additional keys, but could add this as a configurable option if users need it.
+ */
+export declare const stripFields: ({ config, data, fields, parentIsLocalized, reservedKeys, }: {
+    config: SanitizedConfig;
+    data: any;
+    fields: FlattenedField[];
+    parentIsLocalized?: boolean;
+    reservedKeys?: string[];
+}) => void;
+//# sourceMappingURL=stripFields.d.ts.map

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

@@ -0,0 +1,195 @@
+import { fieldShouldBeLocalized } from 'payload/shared';
+/**
+ * Strips fields from data that are not defined in the schema or are invalid.
+ *
+ * This function was copied from the MongoDB adapter's implementation:
+ * @see packages/db-mongodb/src/utilities/transform.ts (stripFields function)
+ *
+ * @description
+ * This utility performs deep sanitization of document data by:
+ * 1. **Removing undefined fields**: Strips any field not present in the collection's schema
+ *    (e.g., sensitive fields like `password`, `apiKey`, or any extra fields not in config)
+ * 2. **Removing invalid locales**: Deletes locale keys that don't exist in `config.localization.localeCodes`
+ *    (e.g., if data contains `{ "es-MX": "..." }` but only `"en"` is configured)
+ * 3. **Removing invalid blocks**: Filters out blocks with unknown `blockType` values
+ *    (prevents data corruption from blocks that don't exist in the schema)
+ * 4. **Recursive sanitization**: Processes nested structures (arrays, groups, blocks, localized fields)
+ *    to ensure deep data integrity
+ *
+ * @remarks
+ * Unlike MongoDB's adapter which uses Mongoose schemas with `strict: true` (rejecting extra fields
+ * on write), Content API uses flexible JSONB storage that accepts any fields. Therefore, this
+ * function is called on **both read and write operations** to ensure data consistency.
+ *
+ * The MongoDB adapter also supports an `allowAdditionalKeys` option that allows reading/writing
+ * fields not in the schema. For now, Content API does not support this feature - we always
+ * sanitize data. If users request this functionality in the future, we can consider adding it.
+ *
+ * @todo
+ * 1. Consider moving this utility to `payload/shared` so both MongoDB and Content API adapters
+ *    can use the same implementation, reducing code duplication and maintenance burden.
+ *
+ * 2. Performance optimization: This function iterates through all fields recursively.
+ *    The `dataToContentAPI` and `dataFromContentAPI` functions in
+ *    `packages/figma/src/db-content-api/utilities/data.ts` also iterate through fields
+ *    to transform richText (object ↔ JSON string), custom IDs (number ↔ string), and dates.
+ *    Consider combining both traversals into a single abstraction to avoid iterating twice.
+ *
+ * 3. Feature parity: MongoDB adapter has `allowAdditionalKeys` option. We currently always
+ *    strip additional keys, but could add this as a configurable option if users need it.
+ */ export const stripFields = ({ config, data, fields, parentIsLocalized = false, reservedKeys = [] })=>{
+    for(const k in data){
+        if (!fields.some((field)=>field.name === k) && !reservedKeys.includes(k)) {
+            delete data[k];
+        }
+    }
+    for (const field of fields){
+        reservedKeys = [];
+        const fieldData = data[field.name];
+        if (!fieldData || typeof fieldData !== 'object') {
+            continue;
+        }
+        const shouldLocalizeField = fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        });
+        if (field.type === 'blocks') {
+            reservedKeys.push('blockType');
+        }
+        if ('flattenedFields' in field || 'blocks' in field) {
+            if (shouldLocalizeField && config.localization) {
+                for(const localeKey in fieldData){
+                    if (!config.localization.localeCodes.some((code)=>code === localeKey)) {
+                        delete fieldData[localeKey];
+                        continue;
+                    }
+                    const localeData = fieldData[localeKey];
+                    if (!localeData || typeof localeData !== 'object') {
+                        continue;
+                    }
+                    if (field.type === 'array' || field.type === 'blocks') {
+                        if (!Array.isArray(localeData)) {
+                            continue;
+                        }
+                        let hasNull = false;
+                        for(let i = 0; i < localeData.length; i++){
+                            const data = localeData[i];
+                            let fields = null;
+                            if (field.type === 'array') {
+                                fields = field.flattenedFields;
+                            } else {
+                                let maybeBlock = undefined;
+                                if (field.blockReferences) {
+                                    const maybeBlockReference = field.blockReferences.find((each)=>{
+                                        const slug = typeof each === 'string' ? each : each.slug;
+                                        return slug === data.blockType;
+                                    });
+                                    if (maybeBlockReference) {
+                                        if (typeof maybeBlockReference === 'object') {
+                                            maybeBlock = maybeBlockReference;
+                                        } else {
+                                            maybeBlock = config.blocks?.find((each)=>each.slug === maybeBlockReference);
+                                        }
+                                    }
+                                }
+                                if (!maybeBlock) {
+                                    maybeBlock = field.blocks.find((each)=>each.slug === data.blockType);
+                                }
+                                if (maybeBlock) {
+                                    fields = maybeBlock.flattenedFields;
+                                } else {
+                                    localeData[i] = null;
+                                    hasNull = true;
+                                }
+                            }
+                            if (!fields) {
+                                continue;
+                            }
+                            stripFields({
+                                config,
+                                data,
+                                fields,
+                                parentIsLocalized: parentIsLocalized || field.localized,
+                                reservedKeys
+                            });
+                        }
+                        if (hasNull) {
+                            fieldData[localeKey] = localeData.filter(Boolean);
+                        }
+                        continue;
+                    } else {
+                        stripFields({
+                            config,
+                            data: localeData,
+                            fields: field.flattenedFields,
+                            parentIsLocalized: parentIsLocalized || field.localized,
+                            reservedKeys
+                        });
+                    }
+                }
+                continue;
+            }
+            if (field.type === 'array' || field.type === 'blocks') {
+                if (!Array.isArray(fieldData)) {
+                    continue;
+                }
+                let hasNull = false;
+                for(let i = 0; i < fieldData.length; i++){
+                    const data = fieldData[i];
+                    let fields = null;
+                    if (field.type === 'array') {
+                        fields = field.flattenedFields;
+                    } else {
+                        let maybeBlock = undefined;
+                        if (field.blockReferences) {
+                            const maybeBlockReference = field.blockReferences.find((each)=>{
+                                const slug = typeof each === 'string' ? each : each.slug;
+                                return slug === data.blockType;
+                            });
+                            if (maybeBlockReference) {
+                                if (typeof maybeBlockReference === 'object') {
+                                    maybeBlock = maybeBlockReference;
+                                } else {
+                                    maybeBlock = config.blocks?.find((each)=>each.slug === maybeBlockReference);
+                                }
+                            }
+                        }
+                        if (!maybeBlock) {
+                            maybeBlock = field.blocks.find((each)=>each.slug === data.blockType);
+                        }
+                        if (maybeBlock) {
+                            fields = maybeBlock.flattenedFields;
+                        } else {
+                            fieldData[i] = null;
+                            hasNull = true;
+                        }
+                    }
+                    if (!fields) {
+                        continue;
+                    }
+                    stripFields({
+                        config,
+                        data,
+                        fields,
+                        parentIsLocalized: parentIsLocalized || field.localized,
+                        reservedKeys
+                    });
+                }
+                if (hasNull) {
+                    data[field.name] = fieldData.filter(Boolean);
+                }
+                continue;
+            } else {
+                stripFields({
+                    config,
+                    data: fieldData,
+                    fields: field.flattenedFields,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    reservedKeys
+                });
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=stripFields.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * Transform publishedLocale to localizeStatus format
+ *
+ * publishedLocale is a legacy API that is going to be removed in Payload v4 in favor of localizeStatus.
+ * The db-adapter transforms publishedLocale here so Content API doesn't need to know about it.
+ */
+type VersionData = Record<string, unknown>;
+/**
+ * Transforms version data to use localizeStatus format
+ *
+ * If `publishedLocale` is provided and `_status` is a string, transforms to object format.
+ * If `_status` is already an object, leaves it unchanged.
+ *
+ * @example
+ * // Input (old format):
+ * { _status: 'published', text: 'Hello' }, publishedLocale: 'en'
+ *
+ * // Output (new format):
+ * { _status: { en: 'published' }, text: 'Hello' }
+ */
+export declare function transformToLocalizeStatus(versionData: VersionData, publishedLocale?: string): VersionData;
+export {};
+//# sourceMappingURL=transformPublishedLocale.d.ts.map

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

@@ -0,0 +1,42 @@
+/**
+ * Transform publishedLocale to localizeStatus format
+ *
+ * publishedLocale is a legacy API that is going to be removed in Payload v4 in favor of localizeStatus.
+ * The db-adapter transforms publishedLocale here so Content API doesn't need to know about it.
+ */ /**
+ * Transforms version data to use localizeStatus format
+ *
+ * If `publishedLocale` is provided and `_status` is a string, transforms to object format.
+ * If `_status` is already an object, leaves it unchanged.
+ *
+ * @example
+ * // Input (old format):
+ * { _status: 'published', text: 'Hello' }, publishedLocale: 'en'
+ *
+ * // Output (new format):
+ * { _status: { en: 'published' }, text: 'Hello' }
+ */ export function transformToLocalizeStatus(versionData, publishedLocale) {
+    // No publishedLocale provided - no transformation needed
+    if (!publishedLocale) {
+        return versionData;
+    }
+    const status = versionData._status;
+    // If _status is already an object (localizeStatus format), return as-is
+    if (typeof status === 'object' && status !== null) {
+        return versionData;
+    }
+    // Transform: publishedLocale + string status → object status
+    if (typeof status === 'string') {
+        // Only the specified locale gets the status, others remain undefined
+        // (Content API / Payload will handle merging with existing locale statuses)
+        return {
+            ...versionData,
+            _status: {
+                [publishedLocale]: status
+            }
+        };
+    }
+    return versionData;
+}
+
+//# sourceMappingURL=transformPublishedLocale.js.map

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,
+ *   offset: 10                 // offset-based pagination
+ * }]
+ *
+ * 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