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

package/dist/api/control-plane.d.ts

@@ -28,6 +28,10 @@ export interface CreateTenantOptions {
  * Options for creating a new deployment
  */
 export interface CreateDeploymentOptions {
+    /** Pages keyed by route, each with its associated asset keys */
+    pages: Record<string, {
+        assets: string[];
+    }>;
     /** List of static asset paths that need upload URLs */
     staticAssets: string[];
 }
@@ -39,6 +43,8 @@ export interface CreateDeploymentResponse {
     codeUploadUrl: string;
     /** Unique deployment ID */
     deploymentId: string;
+    /** Map of page asset paths to their signed S3 upload URLs */
+    pageUploadUrls: Record<string, string>;
     /** Map of static asset paths to their signed S3 upload URLs */
     staticAssetUploadUrls: Record<string, string>;
 }
@@ -47,6 +53,7 @@ export interface CreateDeploymentApiResponse {
     meta: {
         deployment_id: string;
         lambda_zip_upload_url: string;
+        page_upload_urls: Record<string, string>;
         static_asset_upload_urls: Record<string, string>;
     };
     status: number;

package/dist/api/control-plane.js

@@ -158,21 +158,38 @@ import * as log from '../utils/log.js';
             const encodedPath = encodeURIComponent(assetPath);
             staticAssetUploadUrls[assetPath] = `${mockBaseUrl}/${tenantId}/${deploymentId}/static/${encodedPath}?X-Amz-Signature=mock`;
         }
+        // Generate mock signed URLs for page assets
+        const pageUploadUrls = {};
+        for (const pageData of Object.values(options.pages)){
+            for (const assetPath of pageData.assets){
+                const encodedPath = encodeURIComponent(assetPath);
+                pageUploadUrls[assetPath] = `${mockBaseUrl}/${tenantId}/${deploymentId}/pages/${encodedPath}?X-Amz-Signature=mock`;
+            }
+        }
         // Generate mock signed URL for code zip
         const codeUploadUrl = `${mockBaseUrl}/${tenantId}/${deploymentId}/lambda.zip?X-Amz-Signature=mock`;
         return {
             codeUploadUrl,
             deploymentId,
+            pageUploadUrls,
             staticAssetUploadUrls
         };
     }
     const url = `${getControlPlaneBaseUrl()}/v1/cms/tenant/${tenantId}/deploy/create`;
     log.debug(`Calling createDeployment API at ${url}`);
+    // Build pages payload: { route: { assets: [...] } }
+    const pages = {};
+    for (const [route, pageData] of Object.entries(options.pages)){
+        pages[route] = {
+            assets: pageData.assets
+        };
+    }
     // REAL API IMPLEMENTATION
     const response = await controlPlaneFetch({
         context: 'create deployment',
         options: {
             body: JSON.stringify({
+                pages,
                 static_assets: options.staticAssets
             }),
             headers: {
@@ -188,6 +205,7 @@ import * as log from '../utils/log.js';
     return {
         codeUploadUrl: data.meta.lambda_zip_upload_url,
         deploymentId: data.meta.deployment_id,
+        pageUploadUrls: data.meta.page_upload_urls,
         staticAssetUploadUrls: data.meta.static_asset_upload_urls
     };
 }

package/dist/commands/deploy.js

@@ -197,14 +197,6 @@ import { loginCommand } from './login.js';
         spinner.start('Collecting assets...');
         const pages = await adapter.collectPages(projectPath);
         const assets = await adapter.collectAssets(projectPath);
-        const allAssetKeys = [
-            ...pages.uploadKeys,
-            ...assets.uploadKeys
-        ];
-        const combinedPathMap = {
-            ...pages.pathMap,
-            ...assets.pathMap
-        };
         spinner.stop(pc.green(`✓ ${pages.routes.length} pages, ${assets.routes.length} assets detected`));
         // Create deployment package (if server adapter)
         let zipPath = null;
@@ -226,7 +218,7 @@ import { loginCommand } from './login.js';
         if (zipPath) {
             log.debug(`Lambda zip size: ${formatBytes(zipSize)}`);
         }
-        log.debug(`Pages: ${pages.routes.length} routes`);
+        log.debug(`Pages: ${pages.routes.length} routes (${pages.uploadKeys.length} files)`);
         log.debug(`Assets: ${assets.routes.length} files`);
         // ===== DEPLOYMENT CONFIRMATION =====
         if (!options.yes) {
@@ -234,19 +226,28 @@ import { loginCommand } from './login.js';
                 `${pc.cyan('Adapter:')} ${adapter.name}`,
                 `${pc.cyan('Build ID:')} ${buildInfo.buildId}`,
                 zipPath ? `${pc.cyan('Code size:')} ${formatBytes(zipSize)}` : `${pc.cyan('Code:')} No server`,
-                `${pc.cyan('Pages:')} ${pages.routes.length} routes`,
-                `${pc.cyan('Assets:')} ${assets.routes.length} files`
+                `${pc.cyan('Pages:')} ${pages.routes.length} routes (${pages.uploadKeys.length} files)`,
+                `${pc.cyan('Assets:')} ${assets.uploadKeys.length} files`
             ].join('\n'), 'Details');
         }
         // ===== DEPLOYMENT EXECUTION =====
         // Step 1: Create deployment
         spinner.start('Creating deployment...');
+        // Build pages payload from route → asset keys mapping
+        const pagesPayload = {};
+        for (const [route, assetKeys] of Object.entries(pages.routeAssetMap)){
+            pagesPayload[route] = {
+                assets: assetKeys
+            };
+        }
         const createResponse = await createDeployment(credential, tenantInstanceId, {
-            staticAssets: allAssetKeys
+            pages: pagesPayload,
+            staticAssets: assets.uploadKeys
         });
         const deploymentId = createResponse.deploymentId;
         const codeUploadUrl = createResponse.codeUploadUrl;
         const staticAssetUploadUrls = createResponse.staticAssetUploadUrls;
+        const pageUploadUrls = createResponse.pageUploadUrls;
         log.debug(`Deployment ID: ${deploymentId}`);
         // Step 2: Upload code (skip for static sites)
         if (zipPath) {
@@ -254,23 +255,46 @@ import { loginCommand } from './login.js';
             await uploadLambdaZip(zipPath, codeUploadUrl);
             spinner.stop(pc.green(`✓ Code uploaded (${formatBytes(zipSize)})`));
         }
-        // Step 3: Upload static assets
-        if (allAssetKeys.length > 0) {
+        // Step 3: Upload page assets
+        const totalUploadCount = pages.uploadKeys.length + assets.uploadKeys.length;
+        let totalUploaded = 0;
+        let totalFailed = 0;
+        let totalBytes = 0;
+        if (pages.uploadKeys.length > 0) {
+            spinner.start('Uploading pages...');
+            const pageResults = await uploadStaticAssets({
+                assetUrls: pageUploadUrls,
+                onProgress: (uploaded, total)=>{
+                    spinner.message(`Uploading pages (${uploaded}/${total})...`);
+                },
+                pathMap: pages.pathMap,
+                projectPath
+            });
+            totalUploaded += pageResults.assetsUploaded;
+            totalFailed += pageResults.assetsFailed;
+            totalBytes += pageResults.totalBytesUploaded;
+            spinner.stop(pc.green(`✓ ${pageResults.assetsUploaded} page files uploaded`));
+        }
+        // Step 4: Upload static assets
+        if (assets.uploadKeys.length > 0) {
             spinner.start('Uploading assets...');
-            const uploadResults = await uploadStaticAssets({
+            const assetResults = await uploadStaticAssets({
                 assetUrls: staticAssetUploadUrls,
                 onProgress: (uploaded, total)=>{
                     spinner.message(`Uploading assets (${uploaded}/${total})...`);
                 },
-                pathMap: combinedPathMap,
+                pathMap: assets.pathMap,
                 projectPath
             });
-            if (uploadResults.assetsFailed > 0) {
-                spinner.stop(pc.yellow(`⚠ ${uploadResults.assetsUploaded}/${allAssetKeys.length} assets uploaded (${uploadResults.assetsFailed} failed)`));
-                p.log.warning(`${uploadResults.assetsFailed} assets failed to upload. Deployment may be incomplete.`);
-            } else {
-                spinner.stop(pc.green(`✓ Assets uploaded (${uploadResults.assetsUploaded} files, ${formatBytes(uploadResults.totalBytesUploaded)})`));
-            }
+            totalUploaded += assetResults.assetsUploaded;
+            totalFailed += assetResults.assetsFailed;
+            totalBytes += assetResults.totalBytesUploaded;
+            spinner.stop(pc.green(`✓ ${assetResults.assetsUploaded} asset files uploaded`));
+        }
+        if (totalFailed > 0) {
+            p.log.warning(`${totalFailed}/${totalUploadCount} files failed to upload. Deployment may be incomplete.`);
+        } else if (totalUploaded > 0) {
+            p.log.success(pc.green(`✓ All files uploaded (${totalUploaded} files, ${formatBytes(totalBytes)})`));
         }
         // Step 4: Perform deployment
         spinner.start('Performing deployment...');

package/dist/db-content-api/generated/content-api-types.d.ts

@@ -3310,6 +3310,8 @@ export type components = {
         UniquePath: {
             paths: string[];
         };
+        /** @enum {string} */
+        PathTypeArray: 'array';
         PathTypeRelationship: {
             /** @enum {string} */
             type: 'relationship';
@@ -3326,7 +3328,7 @@ export type components = {
         /** @enum {string} */
         PathTypeBlocks: 'blocks';
         /** @example array */
-        PathType: 'array' | components['schemas']['PathTypeRelationship'] | components['schemas']['PathTypeJoin'] | components['schemas']['PathTypeBlocks'];
+        PathType: components['schemas']['PathTypeArray'] | components['schemas']['PathTypeRelationship'] | components['schemas']['PathTypeJoin'] | components['schemas']['PathTypeBlocks'];
         /**
          * @example {
          *       "author.tagIds": "array",
@@ -3441,7 +3443,7 @@ export type components = {
          *     ]
          */
         JoinClause: {
-            collectionId: string;
+            collectionId: string | string[];
             on: string;
             path: string;
             count: boolean;
@@ -3461,9 +3463,7 @@ export type components = {
          *     }
          */
         IncludeSelectClause: {
-            [key: string]: true | {
-                [key: string]: components['schemas']['IncludeSelectClause'];
-            };
+            [key: string]: true | components['schemas']['IncludeSelectClause'];
         };
         /**
          * @example {
@@ -3476,9 +3476,7 @@ export type components = {
          *     }
          */
         ExcludeSelectClause: {
-            [key: string]: false | {
-                [key: string]: components['schemas']['ExcludeSelectClause'];
-            };
+            [key: string]: false | components['schemas']['ExcludeSelectClause'];
         };
         /** @description Field selection - use include mode (true) or exclude mode (false), but not both */
         SelectClause: components['schemas']['IncludeSelectClause'] | components['schemas']['ExcludeSelectClause'];
@@ -3599,9 +3597,9 @@ export type components = {
             /** @example posts */
             collection: string;
             /** @example false */
-            createOnMissing: false | {
+            createOnMissing: false | (components['schemas']['DocumentData'] & {
                 id: string;
-            };
+            });
             doc: components['schemas']['DataWithOperations'];
             /** @example 10 */
             limit?: number;
@@ -3772,8 +3770,15 @@ export type components = {
             collection: string;
             /** @example false */
             createOnMissing: false | {
-                parent: string;
+                /** @example true */
                 latest: boolean;
+                /** @example doc-key */
+                parent: string;
+                /** @example 2024-01-01T00:00:00Z */
+                createdAt?: string | null;
+                /** @example 2024-01-01T00:00:00Z */
+                updatedAt?: string | null;
+                version?: components['schemas']['DocumentData'] & unknown;
             };
             versionDoc: {
                 /** @example 2024-01-01T00:00:00Z */

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

@@ -11,6 +11,7 @@ import { dataToContentAPI, resolveVersionContent } from './utilities/data/index.
 import { convertPayloadJoinsToContentAPI } from './utilities/joins.js';
 import { addFallbackLocale } from './utilities/locale/index.js';
 import { buildMeta } from './utilities/meta/buildMeta.js';
+import { normalizeLocaleInWhere } from './utilities/meta/normalizeLocaleInWhere.js';
 import { convertPayloadWhereToContentAPI } from './utilities/where.js';
 async function syncCollections() {
     let existingIds;
@@ -93,6 +94,7 @@ async function createCollection(collectionId) {
 }
 async function findMany({ collection, joins, limit, locale: localeArg, page, pagination: _pagination, sort, where }) {
     const locale = addFallbackLocale(localeArg, this.payload);
+    const normalizedWhere = normalizeLocaleInWhere(where, this.payload, collection, locale);
     const { data: response, error } = await this.client.POST('/api/v0/documents:find', {
         body: {
             collection,
@@ -102,11 +104,11 @@ async function findMany({ collection, joins, limit, locale: localeArg, page, pag
             locale,
             page: page ?? 1,
             sort: addFallbackSort(sort, this.payload, collection),
-            where: convertPayloadWhereToContentAPI(where ?? {}),
+            where: convertPayloadWhereToContentAPI(normalizedWhere ?? {}),
             ...buildMeta(this.payload, {
                 collection,
                 locale,
-                where
+                where: normalizedWhere
             })
         }
     });

package/dist/db-content-api/temp-utilities/sorting.d.ts

@@ -1,3 +1,3 @@
 import type { Payload } from 'payload';
-export declare function addFallbackSort(sort: string | string[] | undefined, payload: Payload, collectionSlug: string, defaultSort?: string | string[]): string | string[] | undefined;
+export declare function addFallbackSort(sort: string | string[] | undefined, payload: Payload, collectionSlug: string | string[], defaultSort?: string | string[]): string | string[] | undefined;
 //# sourceMappingURL=sorting.d.ts.map

package/dist/db-content-api/temp-utilities/sorting.js

@@ -1,9 +1,14 @@
 // Add fallback sort to ensure consistent ordering when sorting by non-unique fields
 // Matches MongoDB adapter behavior
+// If multiple collections are joined, we need to ensure fallback sort fields are consistent across them to avoid conflicts.
+// If all collections have timestamps, use createdAt, otherwise use id.
 // TO-DECIDE: Should this live here or in content-api?
 export function addFallbackSort(sort, payload, collectionSlug, defaultSort) {
-    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
-    if (!sort || !collectionConfig) {
+    const collectionsArray = Array.isArray(collectionSlug) ? collectionSlug : [
+        collectionSlug
+    ];
+    const collectionConfigs = collectionsArray.map((slug)=>payload.config.collections.find((c)=>c.slug === slug)).filter((collection)=>collection != null);
+    if (sort == null || collectionConfigs.length === 0) {
         if (defaultSort) {
             return addFallbackSort(defaultSort, payload, collectionSlug);
         }
@@ -13,12 +18,11 @@ export function addFallbackSort(sort, payload, collectionSlug, defaultSort) {
         sort
     ];
     // Determine fallback sort field
-    let fallbackSort = '-id';
-    if (collectionConfig.timestamps !== false) {
-        fallbackSort = '-createdAt';
-    }
+    // If all collections have timestamps, use createdAt, otherwise use id
+    const fallbackSort = collectionConfigs.every((config)=>config.timestamps) ? '-createdAt' : '-id';
+    const fallbackInverse = fallbackSort.startsWith('-') ? fallbackSort.substring(1) : `-${fallbackSort}`;
     // Check if fallback sort is already included
-    const hasFallback = sortArray.some((item)=>item === fallbackSort || item === fallbackSort.replace('-', ''));
+    const hasFallback = sortArray.some((item)=>item === fallbackSort || item === fallbackInverse);
     if (hasFallback) {
         return sort;
     }

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

@@ -4,6 +4,18 @@ import { castFieldValue } from './castFieldValue.js';
 import { removeVirtualFields } from './removeVirtualFields.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)
  *
@@ -46,6 +58,9 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
         }
         const current = ref;
         let value = current[field.name];
+        if (isAtomicOperation(value)) {
+            return;
+        }
         // null → [] for non-localized array-like fields. SQL adapters return null for empty join
         // tables; Content API stores JSON null which breaks jsonb_array_elements queries.
         if (value === null && !('localized' in field && field.localized)) {
@@ -168,7 +183,8 @@ export function dataFromContentAPI(payload, collectionSlug, data, locale) {
         // In all-locales mode, localized fields use {} so afterRead can safely iterate locale keys.
         if (value === undefined) {
             const isRequired = 'required' in field && field.required;
-            if (!isRequired) {
+            const isJoin = field.type === 'join';
+            if (!isRequired && !isJoin) {
                 current[field.name] = isLocalized && isAllLocales ? {} : null;
             }
             return;

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

@@ -43,7 +43,7 @@ type ContentAPIJoin = components['schemas']['JoinClause'][number];
  *   where: { ... },            // Content API where format
  *   sort: '-title',
  *   limit: 10,
- *   offset: 10                 // offset-based pagination
+ *   page: 2
  * }]
  *
  * The mapping requires the collection config to resolve:

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

@@ -42,7 +42,7 @@ import { convertPayloadWhereToContentAPI } from './where.js';
  *   where: { ... },            // Content API where format
  *   sort: '-title',
  *   limit: 10,
- *   offset: 10                 // offset-based pagination
+ *   page: 2
  * }]
  *
  * The mapping requires the collection config to resolve:
@@ -91,10 +91,9 @@ import { convertPayloadWhereToContentAPI } from './where.js';
         if (!foundJoin) {
             for (const sanitizedJoin of collectionConfig.polymorphicJoins){
                 if (sanitizedJoin.joinPath === joinPath) {
-                    // For polymorphic joins, collection is an array - use first one
                     const collections = sanitizedJoin.field.collection;
                     foundJoin = {
-                        collectionSlug: Array.isArray(collections) ? collections[0] : collections,
+                        collectionSlug: collections,
                         defaultSort: sanitizedJoin.field.defaultSort,
                         on: sanitizedJoin.field.on
                     };
@@ -106,12 +105,8 @@ import { convertPayloadWhereToContentAPI } from './where.js';
             payload.logger.warn(`Join path '${joinPath}' not found in collection config for '${collectionConfig.slug}'`);
             continue;
         }
-        // Convert pagination: Payload uses page, Content API JoinClause uses offset
+        // Fall back to the default limit if not specified in the query
         const effectiveLimit = joinQuery.limit ?? foundJoin.defaultLimit;
-        let offset;
-        if (joinQuery.page && joinQuery.page > 1 && effectiveLimit) {
-            offset = (joinQuery.page - 1) * effectiveLimit;
-        }
         // Add fallback sort for the joined collection
         const sortWithFallback = addFallbackSort(joinQuery.sort, payload, foundJoin.collectionSlug, foundJoin.defaultSort);
         const contentAPIJoin = {
@@ -119,13 +114,11 @@ import { convertPayloadWhereToContentAPI } from './where.js';
             count: joinQuery.count ?? false,
             on: foundJoin.on,
             path: joinPath,
-            ...joinQuery.limit !== undefined ? {
-                limit: joinQuery.limit
-            } : foundJoin.defaultLimit !== undefined && {
-                limit: foundJoin.defaultLimit
+            ...effectiveLimit !== undefined && {
+                limit: effectiveLimit
             },
-            ...offset !== undefined && {
-                offset
+            ...joinQuery.page && {
+                page: joinQuery.page
             },
             ...sortWithFallback && {
                 sort: sortWithFallback

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

@@ -8,6 +8,10 @@ import type { PathTypesRecord } from '../../temp-utilities/types.js';
  * - 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

@@ -90,19 +90,31 @@
     return null;
 }
 /**
- * Finds a field in the collection schema by its path
- * Supports nested paths like "access.read.users"
+ * 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
@@ -118,8 +130,19 @@
                     } else if ('tabs' in field && field.type === 'tabs') {
                         // Check all tabs
                         for (const tab of field.tabs){
-                            currentField = tab.fields.find((f)=>'name' in f && f.name === segment);
-                            if (currentField) {
+                            // 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;
                             }
                         }
@@ -140,9 +163,12 @@
             } else if (currentField.type === 'array' && 'fields' in currentField) {
                 currentFields = currentField.fields;
             } else if (currentField.type === 'blocks' && 'blocks' in currentField) {
-                // For blocks, we can't determine the exact field without knowing the block type
-                // Return the blocks field itself
-                return 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;
@@ -168,10 +194,15 @@
  * - 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){
@@ -183,8 +214,23 @@
             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;

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

@@ -0,0 +1,10 @@
+import type { Payload, Where } from 'payload';
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */
+export declare function normalizeLocaleInWhere(where: undefined | Where, payload: Payload, collectionSlug: string, locale: string | undefined): undefined | Where;
+//# sourceMappingURL=normalizeLocaleInWhere.d.ts.map

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

@@ -0,0 +1,102 @@
+/**
+ * Collects paths of localized array/blocks fields in a collection.
+ * These fields are stored as locale maps (e.g. {"en": [...], "es": [...]}) rather than
+ * direct arrays, so queries must include the locale key in the path.
+ */ function collectLocalizedArrayPaths(fields, prefix, paths) {
+    for (const field of fields){
+        if (!('name' in field) || !field.name) {
+            // Unnamed container (row, collapsible) — recurse into its fields
+            if ('fields' in field && Array.isArray(field.fields)) {
+                collectLocalizedArrayPaths(field.fields, prefix, paths);
+            }
+            if ('tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs){
+                    const tabPath = tab.name ? prefix ? `${prefix}.${tab.name}` : tab.name : prefix;
+                    if (tab.fields) {
+                        collectLocalizedArrayPaths(tab.fields, tabPath, paths);
+                    }
+                }
+            }
+            continue;
+        }
+        const fieldPath = prefix ? `${prefix}.${field.name}` : field.name;
+        if ('localized' in field && field.localized && (field.type === 'array' || field.type === 'blocks')) {
+            paths.push(fieldPath);
+        // Don't recurse further — child paths are accessed via locale key, handled separately
+        } else if (field.type === 'group' && 'fields' in field) {
+            collectLocalizedArrayPaths(field.fields, fieldPath, paths);
+        }
+    }
+}
+/**
+ * Returns the paths of all localized array/blocks fields for the given collection.
+ */ function getLocalizedArrayPaths(payload, collectionSlug) {
+    const config = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!config) {
+        return [];
+    }
+    const paths = [];
+    collectLocalizedArrayPaths(config.fields, '', paths);
+    return paths;
+}
+/**
+ * Transforms a single path by inserting the locale after a localized array/blocks prefix
+ * if the path goes through one without an explicit locale key.
+ *
+ * Example:
+ *   path "localizedBlocks.richText.children.text", localizedArrayPaths ["localizedBlocks"],
+ *   locale "en", localeCodes ["en", "es"]
+ *   → "localizedBlocks.en.richText.children.text"
+ *
+ *   path "localizedBlocks.en.richText.children.text" (already has locale)
+ *   → unchanged
+ */ function insertLocaleInPath(path, localizedArrayPaths, locale, localeCodes) {
+    for (const lpath of localizedArrayPaths){
+        if (path.startsWith(lpath + '.')) {
+            const rest = path.slice(lpath.length + 1);
+            const firstSegment = rest.split('.')[0];
+            if (!localeCodes.includes(firstSegment)) {
+                return `${lpath}.${locale}.${rest}`;
+            }
+        }
+    }
+    return path;
+}
+/**
+ * Recursively transforms all condition paths in a Where clause by inserting the locale key
+ * after any localized array/blocks field prefix that is missing one.
+ *
+ * This is needed because localized array/blocks fields are stored as locale maps
+ * (e.g. data.localizedBlocks.en = [...]) rather than flat arrays. Without the locale
+ * key, the path would point to the locale map object, causing jsonb_array_elements to fail.
+ */ function transformWhere(where, localizedArrayPaths, locale, localeCodes) {
+    const result = {};
+    for (const [key, value] of Object.entries(where)){
+        if (key === 'and' || key === 'or') {
+            result[key] = value.map((clause)=>transformWhere(clause, localizedArrayPaths, locale, localeCodes));
+        } else {
+            const normalizedKey = insertLocaleInPath(key, localizedArrayPaths, locale, localeCodes);
+            result[normalizedKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */ export function normalizeLocaleInWhere(where, payload, collectionSlug, locale) {
+    if (!where || !locale || !payload.config.localization) {
+        return where;
+    }
+    const localeCodes = payload.config.localization.localeCodes;
+    const localizedArrayPaths = getLocalizedArrayPaths(payload, collectionSlug);
+    if (localizedArrayPaths.length === 0) {
+        return where;
+    }
+    return transformWhere(where, localizedArrayPaths, locale, localeCodes);
+}
+
+//# sourceMappingURL=normalizeLocaleInWhere.js.map

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

@@ -8,7 +8,8 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
     }
     const conditions = [];
     for (const [key, value] of Object.entries(where)){
-        if (key === 'and' || key === 'or') {
+        const keyLower = key.toLowerCase();
+        if (keyLower === 'and' || keyLower === 'or') {
             const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
                     ...options,
                     insideLogicalOperator: true
@@ -21,7 +22,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 }
                 return true;
             });
-            if (key === 'and') {
+            if (keyLower === 'and') {
                 conditions.push(...nestedConditions);
             } else if (nestedConditions.length > 0) {
                 conditions.push({

package/dist/utils/adapters/nextjs.js

@@ -36,16 +36,21 @@ export class NextjsAdapter {
     }
     async collectPages(projectPath) {
         const ssg = await collectSSGAssets(projectPath);
-        // Extract route paths from S3 keys: "products.html" → "/products", "index.html" → "/"
-        const routes = [
-            ...new Set(ssg.keys.filter((k)=>k.endsWith('.html')).map((k)=>{
-                const stripped = k.replace(/\.html$/, '');
-                return stripped === 'index' ? '/' : `/${stripped}`;
-            }))
-        ];
+        // Build route → asset keys mapping and extract unique routes
+        const routeAssetMap = {};
+        for (const key of ssg.keys){
+            // Strip extension to get the base, then derive the route
+            const base = key.replace(/\.(?:html|rsc|meta)$/, '');
+            const route = base === 'index' ? '/' : `/${base}`;
+            if (!routeAssetMap[route]) {
+                routeAssetMap[route] = [];
+            }
+            routeAssetMap[route].push(key);
+        }
         return {
             pathMap: ssg.pathMap,
-            routes,
+            routeAssetMap,
+            routes: Object.keys(routeAssetMap),
             uploadKeys: ssg.keys
         };
     }

package/dist/utils/adapters/nitro.js

@@ -55,11 +55,16 @@ export class NitroAdapter {
         const routes = pages.map((p)=>p === 'index' ? '/' : `/${p}`);
         const uploadKeys = pages.map((p)=>p === 'index' ? 'index.html' : `${p}/index.html`);
         const pathMap = {};
+        const routeAssetMap = {};
         for(let i = 0; i < uploadKeys.length; i++){
             pathMap[uploadKeys[i]] = path.join('.output', 'public', uploadKeys[i]);
+            routeAssetMap[routes[i]] = [
+                uploadKeys[i]
+            ];
         }
         return {
             pathMap,
+            routeAssetMap,
             routes,
             uploadKeys
         };

package/dist/utils/adapters/vite.js

@@ -19,6 +19,7 @@ export class ViteAdapter {
     collectPages() {
         return Promise.resolve({
             pathMap: {},
+            routeAssetMap: {},
             routes: [],
             uploadKeys: []
         });

package/dist/utils/deploy-adapter.d.ts

@@ -1,6 +1,8 @@
 export interface PageCollection {
     /** S3 key → relative filesystem path from project root */
     pathMap: Record<string, string>;
+    /** Route → S3 upload keys for that route (e.g., { "/products": ["products.html", "products.rsc"] }) */
+    routeAssetMap: Record<string, string[]>;
     /** Route paths for the manifest pages array (e.g., ["/products", "/blog"]) */
     routes: string[];
     /** S3 keys to upload (e.g., ["products.html", "products.rsc", "products.meta"]) */

package/dist/utils/s3-upload.js

@@ -11,6 +11,37 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  */ function sleep(ms) {
     return new Promise((resolve)=>setTimeout(resolve, ms));
 }
+/** Common MIME types for web assets, keyed by file extension */ const MIME_TYPES = {
+    '.avif': 'image/avif',
+    '.css': 'text/css',
+    '.csv': 'text/csv',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.gif': 'image/gif',
+    '.html': 'text/html',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.map': 'application/json',
+    '.meta': 'application/json',
+    '.mjs': 'application/javascript',
+    '.mp4': 'video/mp4',
+    '.otf': 'font/otf',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.rsc': 'text/x-component',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain',
+    '.wasm': 'application/wasm',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip'
+};
 /**
  * Check if a signed URL is a mock URL
  */ function isMockUrl(signedUrl) {
@@ -44,14 +75,8 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
     let lastError = null;
     for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
         try {
-            // Content-type only needed if css or js, else let S3 infer
             const ext = path.extname(filePath).toLowerCase();
-            let determinedContentType = contentType;
-            if (ext === '.js') {
-                determinedContentType = 'application/javascript';
-            } else if (ext === '.css') {
-                determinedContentType = 'text/css';
-            }
+            const determinedContentType = contentType ?? MIME_TYPES[ext];
             const response = await fetch(signedUrl, {
                 body: fileBuffer,
                 headers: determinedContentType ? {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.0.1-alpha.59",
+  "version": "0.0.1-alpha.60",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {