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

package/dist/db-content-api/utilities/schema/buildDocumentSchema.js

@@ -1,32 +1,53 @@
 // Built-in document fields the Content API manages itself (stored as columns and
 // injected into every schema). They must never be sent as declared fields, so any
-// top-level field with one of these names is dropped.
+// top-level field with one of these names is dropped. This applies only to
+// documents: blocks have no built-in fields, so a block field named `id` or
+// `createdAt` is a real declared field and must be kept.
 const BUILT_IN_FIELD_NAMES = new Set([
     'createdAt',
     'id',
     'updatedAt'
 ]);
+const BLOCK_TYPE_FIELD_NAME = 'blockType';
+// The implicit block-type discriminator carried on every block row. It is not a
+// declared block field, so it is injected into each block entity's paths.
+const BLOCK_TYPE_FIELD = {
+    type: 'text',
+    hasMany: false,
+    localized: false,
+    unique: false
+};
 export function buildDocumentSchema(config) {
-    const collections = {};
-    const blocksBySlug = new Map();
+    const globalBlocksBySlug = new Map();
     for (const block of config.blocks ?? []){
-        blocksBySlug.set(block.slug, block);
+        globalBlocksBySlug.set(block.slug, block);
     }
+    const blockRegistry = {
+        blocksById: {},
+        globalBlocksBySlug,
+        idByBlock: new Map()
+    };
+    const collections = {};
     for (const collection of config.collections ?? []){
-        collections[collection.slug] = buildCollectionSchema(collection.slug, collection.fields, blocksBySlug);
+        collections[collection.slug] = buildCollectionSchema(collection.slug, collection.fields, blockRegistry);
     }
     for (const global of config.globals ?? []){
         const slug = `_global-${global.slug}`;
-        collections[slug] = buildCollectionSchema(slug, global.fields, blocksBySlug);
+        collections[slug] = buildCollectionSchema(slug, global.fields, blockRegistry);
     }
     return {
+        blocks: blockRegistry.blocksById,
         collections,
         version: 1
     };
 }
-function buildCollectionSchema(name, fields, blocksBySlug) {
+function buildCollectionSchema(name, fields, blockRegistry) {
     const paths = {};
-    collectPaths(fields, '', false, paths, blocksBySlug);
+    collectPaths(fields, paths, {
+        blockRegistry,
+        inBlock: false,
+        prefix: ''
+    });
     // `_payloadAutosave` marks a version as an autosave draft. The Content API wraps
     // version schemas under the `version` envelope, so this becomes `version._payloadAutosave`
     // there. This adds the field to both the document and document version schemas as there
@@ -44,24 +65,27 @@ function buildCollectionSchema(name, fields, blocksBySlug) {
         paths
     };
 }
-function collectPaths(fields, prefix, absorbed, paths, blocksBySlug) {
+function collectPaths(fields, paths, context) {
+    const { prefix } = context;
     for (const field of fields){
         if (field.type === 'row' || field.type === 'collapsible' || field.type === 'group' && (!('name' in field) || !field.name)) {
-            collectPaths(field.fields, prefix, absorbed, paths, blocksBySlug);
+            collectPaths(field.fields, paths, context);
             continue;
         }
         if (field.type === 'tabs') {
             for (const tab of field.tabs){
-                const tabOwnLocalized = 'localized' in tab && tab.localized === true;
                 if ('name' in tab && tab.name) {
                     paths[`${prefix}${tab.name}`] = {
                         type: 'group',
                         hasMany: false,
-                        localized: tabOwnLocalized && !absorbed
+                        localized: 'localized' in tab && tab.localized === true
                     };
-                    collectPaths(tab.fields, `${prefix}${tab.name}.`, absorbed || tabOwnLocalized, paths, blocksBySlug);
+                    collectPaths(tab.fields, paths, {
+                        ...context,
+                        prefix: `${prefix}${tab.name}.`
+                    });
                 } else {
-                    collectPaths(tab.fields, prefix, absorbed, paths, blocksBySlug);
+                    collectPaths(tab.fields, paths, context);
                 }
             }
             continue;
@@ -69,20 +93,21 @@ function collectPaths(fields, prefix, absorbed, paths, blocksBySlug) {
         if (field.type === 'ui' || !('name' in field) || !field.name) {
             continue;
         }
-        collectNamedField(field, prefix, absorbed, paths, blocksBySlug);
+        collectNamedField(field, paths, context);
     }
 }
-function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
+function collectNamedField(field, paths, context) {
+    const { inBlock, prefix } = context;
     if (!('name' in field) || !field.name) {
         return;
     }
-    // Built-in fields are supplied by the Content API, never declared here.
-    if (prefix === '' && BUILT_IN_FIELD_NAMES.has(field.name)) {
+    // Built-in fields are supplied by the Content API, never declared here. Blocks
+    // have no built-ins, so their fields are never pruned.
+    if (prefix === '' && !inBlock && BUILT_IN_FIELD_NAMES.has(field.name)) {
         return;
     }
     const path = `${prefix}${field.name}`;
-    const localized = 'localized' in field && field.localized === true && !absorbed;
-    const childAbsorbed = absorbed || 'localized' in field && field.localized === true;
+    const localized = 'localized' in field && field.localized === true;
     const hasMany = 'hasMany' in field ? Boolean(field.hasMany) : false;
     const unique = 'unique' in field ? Boolean(field.unique) : false;
     switch(field.type){
@@ -91,28 +116,19 @@ function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
                 type: 'array',
                 localized
             };
-            collectPaths(field.fields, `${path}.`, childAbsorbed, paths, blocksBySlug);
+            collectPaths(field.fields, paths, {
+                ...context,
+                prefix: `${path}.`
+            });
             return;
         case 'blocks':
             {
+                const blocks = collectBlocks(field, context);
                 paths[path] = {
                     type: 'blocks',
+                    blocks,
                     localized
                 };
-                paths[`${path}.blockType`] = {
-                    type: 'text',
-                    hasMany: false,
-                    localized: false,
-                    unique: false
-                };
-                const blockFields = [];
-                for (const block of field.blocks){
-                    const resolved = typeof block === 'string' ? blocksBySlug.get(block) : block;
-                    if (resolved) {
-                        blockFields.push(...resolved.fields);
-                    }
-                }
-                collectPaths(blockFields, `${path}.`, childAbsorbed, paths, blocksBySlug);
                 return;
             }
         case 'checkbox':
@@ -127,6 +143,7 @@ function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
         case 'code':
         case 'email':
         case 'point':
+        case 'slug':
         case 'textarea':
             paths[path] = {
                 type: field.type,
@@ -140,7 +157,10 @@ function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
                 hasMany,
                 localized
             };
-            collectPaths(field.fields, `${path}.`, childAbsorbed, paths, blocksBySlug);
+            collectPaths(field.fields, paths, {
+                ...context,
+                prefix: `${path}.`
+            });
             return;
         case 'join':
             paths[path] = {
@@ -180,3 +200,65 @@ function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
             return;
     }
 }
+function collectBlocks(field, context) {
+    const blocks = {};
+    // Each block type is stored as its own entity; the field records only the
+    // block-type -> entity-id mapping. This lets same-named fields across block
+    // types keep independent schemas instead of collapsing to one shape.
+    for (const ref of field.blocks){
+        const blockId = resolveBlockId(ref, context);
+        if (blockId != null) {
+            const slug = typeof ref === 'string' ? ref : ref.slug;
+            blocks[slug] = blockId;
+        }
+    }
+    return blocks;
+}
+// Resolves the block a field references (by inline config or slug), applying
+// Payload's block-type resolution: a globally-registered block wins over a
+// field-local inline block of the same slug. Returns the assigned entity id, or
+// `null` when the slug cannot be resolved.
+function resolveBlockId(ref, context) {
+    const { blockRegistry } = context;
+    const block = resolveBlockReferenceToBlock(ref, context);
+    if (block == null) {
+        return null;
+    }
+    const existingBlockId = blockRegistry.idByBlock.get(block);
+    if (existingBlockId != null) {
+        return existingBlockId;
+    }
+    const newBlockId = `block_${blockRegistry.idByBlock.size}`;
+    blockRegistry.idByBlock.set(block, newBlockId);
+    const newBlockPaths = {
+        [BLOCK_TYPE_FIELD_NAME]: {
+            ...BLOCK_TYPE_FIELD
+        }
+    };
+    // A block entity is its own path namespace, so prefixing resets here. A block
+    // entity is shared by every `blocks` field that references it — including a
+    // localized one — so it records each field's declared `localized` flag and
+    // lets the Content API resolve locale absorption per reference while walking
+    // the path. Everything collected below lives in a block, not a document.
+    collectPaths(block.fields, newBlockPaths, {
+        blockRegistry,
+        inBlock: true,
+        prefix: ''
+    });
+    blockRegistry.blocksById[newBlockId] = {
+        name: block.slug,
+        paths: newBlockPaths
+    };
+    return newBlockId;
+}
+function resolveBlockReferenceToBlock(ref, context) {
+    // Local blocks are stored inline in the field definition.
+    const slug = typeof ref === 'string' ? ref : ref.slug;
+    const localBlock = typeof ref === 'string' ? undefined : ref;
+    // Global blocks are stored as slugs that reference blocks
+    // defined at the config level.
+    const globalBlock = context.blockRegistry.globalBlocksBySlug.get(slug);
+    // Global blocks must take precedence. This mirrors existing Payload
+    // behavior.
+    return globalBlock ?? localBlock;
+}

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

@@ -1,19 +1,9 @@
 import type { Where } from 'payload';
 import type { components } from '../generated/content-api-types.js';
-type WhereClause = components['schemas']['WhereClause'];
+type WhereClauseV1 = components['schemas']['WhereClauseV1'];
 type ConvertOptions = {
     /** Internal flag to track if we're inside a logical operator (and/or) */
     insideLogicalOperator?: boolean;
-    /** If true, transform 'parent' field to 'documentId' (used for version queries) */
-    parentToDocumentId?: boolean;
-    /**
-     * If true, strip 'version.' prefix from field paths (used for version queries).
-     *
-     * Payload queries version content with paths like 'version._status.en', but Content API
-     * stores version data directly in the 'data' column (not nested under 'version').
-     * The 'version' wrapper is only added in API responses for client compatibility.
-     */
-    stripVersionPrefix?: boolean;
 };
-export declare function convertPayloadWhereToContentAPI(where: undefined | Where, options?: ConvertOptions): WhereClause;
+export declare function convertPayloadWhereToContentAPI(where: undefined | Where, options?: ConvertOptions): WhereClauseV1;
 export {};

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

@@ -30,18 +30,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 });
             }
         } else {
-            // TODO: fix this in content api
-            // WORKAROUND: Payload uses 'parent' for version queries, but Content API expects 'documentId'
-            let fieldPath = key.replace(/__/g, '.');
-            if (options.parentToDocumentId && key === 'parent') {
-                fieldPath = 'documentId';
-            }
-            // Strip 'version.' prefix from field paths for version queries
-            // Payload uses paths like 'version._status.en' but Content API stores version data
-            // directly in the 'data' column, not nested under 'version'
-            if (options.stripVersionPrefix && fieldPath.startsWith('version.')) {
-                fieldPath = fieldPath.slice('version.'.length);
-            }
+            const fieldPath = key.replace(/__/g, '.');
             // Convert field conditions: { fieldName: { operator: value } }
             // to: { path: fieldName, operator, value }
             // Handle Payload's shorthand: { fieldName: value } → { fieldName: { equals: value } }

package/dist/plugin/build-config.js

@@ -18,6 +18,7 @@ import * as log from '../utils/log.js';
 import { logMissingCliAuth } from './auth-preflight.js';
 import { logMissingContentSystemId } from './bootstrap-preflight.js';
 import { getDevCookieNames } from './dev-cookie-names.js';
+import { createSandboxUploadFetchPlugin } from './sandbox-upload-fetch.js';
 /**
  * Worker-trusted marker injected by Figma's sites-worker after it validates the
  * X-Figma-Job-Queues-Auth-Bypass secret on a Payload jobs endpoint. The default
@@ -392,7 +393,10 @@ export async function buildFigmaConfig(config) {
                 debug: !!process.env.DEBUG,
                 disabled: false
             }),
-            scheduleExtractPlugin()
+            scheduleExtractPlugin(),
+            // Not folded into createStoragePlugin: that one is skipped when
+            // figma.storage is false, which would break remote uploads for those apps.
+            createSandboxUploadFetchPlugin()
         ]
     };
     // Inject figma fields into users collection

package/dist/plugin/sandbox-upload-fetch.d.ts

@@ -0,0 +1,30 @@
+import type { Config } from 'payload';
+/**
+ * True inside the Make sandbox. agentplat injects `FIGMA=1` into every sandbox
+ * process; it is absent locally and in the deployed Lambda. `FIGMA=true` is
+ * accepted because the Make app template's `vite.config.ts` treats both as
+ * sandbox markers.
+ *
+ * KEEP_IN_SYNC(services/agentplat/scriptrun/script_runner.go): EnvFigma
+ */
+export declare function isMakeSandbox(): boolean;
+/**
+ * Lets upload collections fetch remote files inside the Make sandbox, where DNS
+ * maps external hostnames to unique-local IPv6 addresses (`fc00::/7`) and
+ * `safeFetch` rejects every resolved range that is not `unicast`. Outside the
+ * sandbox this is a no-op.
+ *
+ * `skipSafeFetch` is forced rather than defaulted with `??`, because
+ * `@payloadcms/plugin-cloud-storage` recomputes it on every upload collection
+ * and a nullish default would never fire. An app's own setting loses here.
+ *
+ * `externalFileHeaderFilter` is deliberately left unset: it replaces Payload's
+ * cookie logic wholesale, including the branch that forwards cookies for
+ * relative URLs.
+ *
+ * Accepted risks, all bounded by the auth gate on the upload routes and the
+ * sandbox's network limits: `getExternalFile` re-validates its three redirect
+ * hops only against `pasteURL.allowList`; any session can make the server GET
+ * an arbitrary URL and read the body; request cookies reach the fetch target.
+ */
+export declare function createSandboxUploadFetchPlugin(): (config: Config) => Config;

package/dist/plugin/sandbox-upload-fetch.js

@@ -0,0 +1,59 @@
+import * as log from '../utils/log.js';
+/**
+ * True inside the Make sandbox. agentplat injects `FIGMA=1` into every sandbox
+ * process; it is absent locally and in the deployed Lambda. `FIGMA=true` is
+ * accepted because the Make app template's `vite.config.ts` treats both as
+ * sandbox markers.
+ *
+ * KEEP_IN_SYNC(services/agentplat/scriptrun/script_runner.go): EnvFigma
+ */ export function isMakeSandbox() {
+    return process.env.FIGMA === '1' || process.env.FIGMA === 'true';
+}
+/**
+ * Lets upload collections fetch remote files inside the Make sandbox, where DNS
+ * maps external hostnames to unique-local IPv6 addresses (`fc00::/7`) and
+ * `safeFetch` rejects every resolved range that is not `unicast`. Outside the
+ * sandbox this is a no-op.
+ *
+ * `skipSafeFetch` is forced rather than defaulted with `??`, because
+ * `@payloadcms/plugin-cloud-storage` recomputes it on every upload collection
+ * and a nullish default would never fire. An app's own setting loses here.
+ *
+ * `externalFileHeaderFilter` is deliberately left unset: it replaces Payload's
+ * cookie logic wholesale, including the branch that forwards cookies for
+ * relative URLs.
+ *
+ * Accepted risks, all bounded by the auth gate on the upload routes and the
+ * sandbox's network limits: `getExternalFile` re-validates its three redirect
+ * hops only against `pasteURL.allowList`; any session can make the server GET
+ * an arbitrary URL and read the body; request cookies reach the fetch target.
+ */ export function createSandboxUploadFetchPlugin() {
+    return (config)=>{
+        if (!isMakeSandbox()) {
+            return config;
+        }
+        const modifiedSlugs = [];
+        const collections = (config.collections ?? []).map((collection)=>{
+            if (!collection.upload) {
+                return collection;
+            }
+            modifiedSlugs.push(collection.slug);
+            const upload = collection.upload === true ? {} : collection.upload;
+            return {
+                ...collection,
+                upload: {
+                    ...upload,
+                    skipSafeFetch: true
+                }
+            };
+        });
+        if (modifiedSlugs.length === 0) {
+            return config;
+        }
+        log.debug(`Make sandbox detected: upload collections skip safeFetch (${modifiedSlugs.join(', ')})`);
+        return {
+            ...config,
+            collections
+        };
+    };
+}

package/dist/utils/load-payload-config.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from 'payload';
+import type { SanitizedConfig } from 'payload';
 /**
  * Load a project's Payload config without initializing Payload or connecting to its database.
  *
@@ -6,4 +6,4 @@ import type { Config } from 'payload';
  * project's Payload installation so this also works with strict package-manager layouts where
  * tsx is not a direct dependency of @payloadcms/figma.
  */
-export declare function loadPayloadConfig(projectPath: string): Promise<Config>;
+export declare function loadPayloadConfig(projectPath: string): Promise<SanitizedConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-internal.e071575",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
@@ -49,7 +49,7 @@
   "devDependencies": {
     "@payloadcms/eslint-config": "3.28.0",
     "@payloadcms/eslint-plugin": "3.28.0",
-    "@payloadcms/next": "4.0.0-canary.17",
+    "@payloadcms/next": "4.0.0-canary.20",
     "@swc/cli": "0.7.7",
     "@types/archiver": "7.0.0",
     "@types/cross-spawn": "6.0.6",
@@ -66,9 +66,9 @@
     "vitest": "4.0.15"
   },
   "peerDependencies": {
-    "@payloadcms/plugin-cloud-storage": ">=4.0.0-canary.17 <4.0.0-internal",
-    "@payloadcms/richtext-lexical": ">=4.0.0-canary.17 <4.0.0-internal",
-    "payload": ">=4.0.0-canary.17 <4.0.0-internal"
+    "@payloadcms/plugin-cloud-storage": ">=4.0.0-canary.20 <4.0.0-internal",
+    "@payloadcms/richtext-lexical": ">=4.0.0-canary.20 <4.0.0-internal",
+    "payload": ">=4.0.0-canary.20 <4.0.0-internal"
   },
   "peerDependenciesMeta": {
     "@payloadcms/plugin-cloud-storage": {
@@ -97,6 +97,7 @@
     "generate:types": "tsx scripts/generate-types.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "payload:cli": "tsx scripts/payload-cli.ts",
     "start": "pnpm build && node ./bin/cli.js",
     "test": "TEST_UNIT=true vitest run",
     "test:int": "TEST_INT=true vitest run --config vitest.config.int.ts",

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

@@ -1,10 +0,0 @@
-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[];

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

@@ -1,71 +0,0 @@
-import { resolveBlocks } from '../resolveBlocks.js';
-/**
- * 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, '', false, payload.config.blocks);
-    // 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, configBlocks) {
-    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, configBlocks);
-            }
-            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, configBlocks);
-                    }
-                }
-            }
-            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 resolveBlocks(field.blocks, configBlocks)){
-                traverseFields(block.fields, localizedPaths, fieldPath, includeNestedPaths, configBlocks);
-            }
-            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, configBlocks);
-        }
-    }
-}
-/** Builds a dot-notation path from parent path and field name */ function buildPath(parentPath, fieldName) {
-    return parentPath ? `${parentPath}.${fieldName}` : fieldName;
-}

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

@@ -1,41 +0,0 @@
-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 {};

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

@@ -1,39 +0,0 @@
-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
-    } : {};
-}

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

@@ -1,16 +0,0 @@
-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;