@payloadcms/figma 0.0.1-alpha.9 → 0.1.0-alpha.1

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

@@ -0,0 +1,100 @@
+/**
+ * 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);
+}

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

@@ -0,0 +1,19 @@
+import type { Block, FlattenedBlock } from 'payload';
+/**
+ * Dereferences a blocks field's entries into full block definitions.
+ *
+ * v4 stores block-reference-by-slug: a blocks field's `blocks` array may contain
+ * string slugs pointing at config-level shared blocks (`config.blocks`) instead of
+ * inline block definitions. Callers that need each block's `fields` must resolve
+ * those string references first. Unresolvable references are dropped.
+ */
+export declare function resolveBlocks(blocks: (Block | string)[], configBlocks?: FlattenedBlock[]): Block[];
+/**
+ * Resolves the flattened block definition matching a given `blockType`, following
+ * config-level string references. Returns `undefined` when no block matches.
+ */
+export declare function resolveFlattenedBlock({ blocks, blockType, configBlocks, }: {
+    blocks: (FlattenedBlock | string)[];
+    blockType: unknown;
+    configBlocks?: FlattenedBlock[];
+}): FlattenedBlock | undefined;

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

@@ -0,0 +1,31 @@
+/**
+ * Dereferences a blocks field's entries into full block definitions.
+ *
+ * v4 stores block-reference-by-slug: a blocks field's `blocks` array may contain
+ * string slugs pointing at config-level shared blocks (`config.blocks`) instead of
+ * inline block definitions. Callers that need each block's `fields` must resolve
+ * those string references first. Unresolvable references are dropped.
+ */ export function resolveBlocks(blocks, configBlocks) {
+    const resolved = [];
+    for (const block of blocks){
+        if (typeof block !== 'string') {
+            resolved.push(block);
+            continue;
+        }
+        const match = configBlocks?.find((each)=>each.slug === block);
+        if (match) {
+            resolved.push(match);
+        }
+    }
+    return resolved;
+}
+/**
+ * Resolves the flattened block definition matching a given `blockType`, following
+ * config-level string references. Returns `undefined` when no block matches.
+ */ export function resolveFlattenedBlock({ blocks, blockType, configBlocks }) {
+    const match = blocks.find((each)=>(typeof each === 'string' ? each : each.slug) === blockType);
+    if (typeof match !== 'string') {
+        return match;
+    }
+    return configBlocks?.find((each)=>each.slug === match);
+}

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

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

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

@@ -0,0 +1,264 @@
+// 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. 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 globalBlocksBySlug = new Map();
+    for (const block of config.blocks ?? []){
+        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, blockRegistry);
+    }
+    for (const global of config.globals ?? []){
+        const slug = `_global-${global.slug}`;
+        collections[slug] = buildCollectionSchema(slug, global.fields, blockRegistry);
+    }
+    return {
+        blocks: blockRegistry.blocksById,
+        collections,
+        version: 1
+    };
+}
+function buildCollectionSchema(name, fields, blockRegistry) {
+    const paths = {};
+    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
+    // is no way to add it to just one. However, fields present in the collection schema but
+    // not in the request payload are ignored, so this is safe to add to both.
+    if (!('_payloadAutosave' in paths)) {
+        paths._payloadAutosave = {
+            type: 'checkbox',
+            localized: false
+        };
+    }
+    return {
+        name,
+        hints: [],
+        paths
+    };
+}
+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, paths, context);
+            continue;
+        }
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                if ('name' in tab && tab.name) {
+                    paths[`${prefix}${tab.name}`] = {
+                        type: 'group',
+                        hasMany: false,
+                        localized: 'localized' in tab && tab.localized === true
+                    };
+                    collectPaths(tab.fields, paths, {
+                        ...context,
+                        prefix: `${prefix}${tab.name}.`
+                    });
+                } else {
+                    collectPaths(tab.fields, paths, context);
+                }
+            }
+            continue;
+        }
+        if (field.type === 'ui' || !('name' in field) || !field.name) {
+            continue;
+        }
+        collectNamedField(field, paths, context);
+    }
+}
+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. 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;
+    const hasMany = 'hasMany' in field ? Boolean(field.hasMany) : false;
+    const unique = 'unique' in field ? Boolean(field.unique) : false;
+    switch(field.type){
+        case 'array':
+            paths[path] = {
+                type: 'array',
+                localized
+            };
+            collectPaths(field.fields, paths, {
+                ...context,
+                prefix: `${path}.`
+            });
+            return;
+        case 'blocks':
+            {
+                const blocks = collectBlocks(field, context);
+                paths[path] = {
+                    type: 'blocks',
+                    blocks,
+                    localized
+                };
+                return;
+            }
+        case 'checkbox':
+        case 'date':
+        case 'json':
+        case 'radio':
+            paths[path] = {
+                type: field.type,
+                localized
+            };
+            return;
+        case 'code':
+        case 'email':
+        case 'point':
+        case 'slug':
+        case 'textarea':
+            paths[path] = {
+                type: field.type,
+                localized,
+                unique
+            };
+            return;
+        case 'group':
+            paths[path] = {
+                type: 'group',
+                hasMany,
+                localized
+            };
+            collectPaths(field.fields, paths, {
+                ...context,
+                prefix: `${path}.`
+            });
+            return;
+        case 'join':
+            paths[path] = {
+                type: 'join',
+                collection: field.collection,
+                on: field.on
+            };
+            return;
+        case 'number':
+        case 'select':
+        case 'text':
+            paths[path] = {
+                type: field.type,
+                hasMany,
+                localized,
+                unique
+            };
+            return;
+        case 'relationship':
+        case 'upload':
+            paths[path] = {
+                type: field.type,
+                collection: field.relationTo,
+                hasMany,
+                localized,
+                unique
+            };
+            return;
+        case 'richText':
+            paths[path] = {
+                type: 'richText',
+                format: 'lexical',
+                localized
+            };
+            return;
+        default:
+            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

@@ -0,0 +1,9 @@
+import type { Where } from 'payload';
+import type { components } from '../generated/content-api-types.js';
+type WhereClauseV1 = components['schemas']['WhereClauseV1'];
+type ConvertOptions = {
+    /** Internal flag to track if we're inside a logical operator (and/or) */
+    insideLogicalOperator?: boolean;
+};
+export declare function convertPayloadWhereToContentAPI(where: undefined | Where, options?: ConvertOptions): WhereClauseV1;
+export {};

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

@@ -0,0 +1,95 @@
+export function convertPayloadWhereToContentAPI(where, options = {}) {
+    // Empty where {} should be { and: [] } not undefined
+    // Content API requires a where clause structure even for "no filter"
+    if (!where || Object.keys(where).length === 0) {
+        return {
+            and: []
+        };
+    }
+    const conditions = [];
+    for (const [key, value] of Object.entries(where)){
+        const keyLower = key.toLowerCase();
+        if (keyLower === 'and' || keyLower === 'or') {
+            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
+                    ...options,
+                    insideLogicalOperator: true
+                })).filter((condition)=>{
+                if ('and' in condition) {
+                    return condition.and.length > 0;
+                }
+                if ('or' in condition) {
+                    return condition.or.length > 0;
+                }
+                return true;
+            });
+            if (keyLower === 'and') {
+                conditions.push(...nestedConditions);
+            } else if (nestedConditions.length > 0) {
+                conditions.push({
+                    or: nestedConditions
+                });
+            }
+        } else {
+            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 } }
+            // If value is a primitive (string, number, boolean, null) or not a plain object,
+            // treat it as an implicit 'equals' operator
+            const isPrimitive = value === null || typeof value !== 'object' || Array.isArray(value);
+            if (isPrimitive) {
+                // Shorthand format: { id: "some-value" } means { id: { equals: "some-value" } }
+                conditions.push({
+                    operator: 'equals',
+                    path: fieldPath,
+                    value: fieldPath === 'id' && typeof value === 'number' ? String(value) : value
+                });
+                continue;
+            }
+            const operators = value;
+            // Skip empty operator objects { fieldName: {} }
+            if (Object.keys(operators).length === 0) {
+                continue;
+            }
+            for (const [op, operatorValue] of Object.entries(operators)){
+                // Skip operators with undefined values (e.g., { equals: undefined })
+                // This can happen when Payload sends incomplete where clauses
+                if (operatorValue === undefined) {
+                    continue;
+                }
+                let finalValue = operatorValue;
+                // Convert string booleans to actual booleans for exists operator
+                // REST API sends "true"/"false" as strings, but Content API requires boolean
+                if (op === 'exists' && typeof operatorValue === 'string') {
+                    finalValue = operatorValue === 'true';
+                }
+                // REST API sends "null" as a string; convert to actual null
+                if (finalValue === 'null') {
+                    finalValue = null;
+                }
+                // Content API stores all document IDs as strings.
+                // Payload sends numeric values for collections with custom numeric ID fields,
+                // so we must stringify to match.
+                if (fieldPath === 'id' && typeof finalValue === 'number') {
+                    finalValue = String(finalValue);
+                }
+                conditions.push({
+                    operator: op,
+                    path: fieldPath,
+                    value: finalValue
+                });
+            }
+        }
+    }
+    if (conditions.length === 0) {
+        return {
+            and: []
+        };
+    }
+    if (options.insideLogicalOperator && conditions.length === 1) {
+        return conditions[0];
+    }
+    return {
+        and: conditions
+    };
+}

package/dist/deploy/schedule-extract-plugin.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from 'payload';
+/**
+ * Payload plugin that extracts cron schedule metadata and writes
+ * `.next/static/payload-schedules.json` during `figma deploy` builds.
+ *
+ * Only runs when `FIGMA_EXTRACT_SCHEDULES=true`, which is set exclusively by
+ * the deploy CLI before spawning `next build`. At Lambda runtime and during
+ * local development the env var is absent and this plugin is a no-op.
+ */
+export declare function scheduleExtractPlugin(): (config: Config) => Config;

package/dist/deploy/schedule-extract-plugin.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Payload plugin that extracts cron schedule metadata and writes
+ * `.next/static/payload-schedules.json` during `figma deploy` builds.
+ *
+ * Only runs when `FIGMA_EXTRACT_SCHEDULES=true`, which is set exclusively by
+ * the deploy CLI before spawning `next build`. At Lambda runtime and during
+ * local development the env var is absent and this plugin is a no-op.
+ */ export function scheduleExtractPlugin() {
+    return (config)=>{
+        if (process.env.FIGMA_EXTRACT_SCHEDULES !== 'true') {
+            return config;
+        }
+        const schedules = [
+            ...(config.jobs?.tasks ?? []).flatMap((task)=>(task.schedule ?? []).map((sched)=>({
+                        slug: task.slug,
+                        cron: sched.cron
+                    }))),
+            ...(config.jobs?.workflows ?? []).flatMap((workflow)=>(workflow.schedule ?? []).map((sched)=>({
+                        slug: workflow.slug,
+                        cron: sched.cron
+                    })))
+        ];
+        const outDir = path.join(process.cwd(), '.next', 'static');
+        fs.mkdirSync(outDir, {
+            recursive: true
+        });
+        fs.writeFileSync(path.join(outDir, 'payload-schedules.json'), JSON.stringify(schedules));
+        return config;
+    };
+}

package/dist/endpoints/health.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare const health: Endpoint;

package/dist/endpoints/health.js

@@ -0,0 +1,9 @@
+export const health = {
+    handler: ()=>{
+        return Response.json({
+            status: 200
+        });
+    },
+    method: 'get',
+    path: '/health'
+};

package/dist/endpoints/schema.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare const schema: Endpoint;