@payloadcms/figma 0.0.1-alpha.55 → 0.0.1-alpha.57

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

@@ -7,7 +7,7 @@ import { getGlobalSlug } from './temp-utilities/slug.js';
 import { addFallbackSort } from './temp-utilities/sorting.js';
 import { unwrapDocument, unwrapFindResponse } from './temp-utilities/unwrapDocument.js';
 import { createAuthMiddleware, createErrorMiddleware } from './utilities/auth.js';
-import { dataToContentAPI } from './utilities/data/index.js';
+import { dataToContentAPI, resolveVersionContent } from './utilities/data/index.js';
 import { convertPayloadJoinsToContentAPI } from './utilities/joins.js';
 import { addFallbackLocale } from './utilities/locale/index.js';
 import { buildMeta } from './utilities/meta/buildMeta.js';
@@ -225,8 +225,8 @@ async function updateVersion(args) {
         }
     };
     const locale = addFallbackLocale(args.locale, this.payload);
-    // versionData contains version metadata plus nested version content
     const { publishedLocale, version, ...versionMeta } = args.versionData;
+    const resolvedVersion = resolveVersionContent(version, versionMeta);
     const { data: response, error } = await this.client.POST('/api/v0/document_versions:update', {
         body: {
             collection: args.collection,
@@ -238,7 +238,7 @@ async function updateVersion(args) {
                 latest: versionMeta.latest,
                 parent: versionMeta.parent != null ? String(versionMeta.parent) : undefined,
                 updatedAt: versionMeta.updatedAt,
-                version: dataToContentAPI(this.payload, args.collection, version, {
+                version: dataToContentAPI(this.payload, args.collection, resolvedVersion, {
                     publishedLocale
                 })
             },
@@ -299,6 +299,37 @@ async function findOne(args) {
     });
     return docs[0] ?? null;
 }
+async function findDistinct(args) {
+    const locale = addFallbackLocale(args.locale, this.payload);
+    const { data: response, error } = await this.client.POST('/api/v0/documents:findDistinct', {
+        body: {
+            collection: args.collection,
+            contentSystemId: this.contentSystemId,
+            distinctBy: args.field,
+            limit: args.limit,
+            locale,
+            page: args.page ?? 1,
+            sort: addFallbackSort(args.sort, this.payload, args.collection),
+            where: convertPayloadWhereToContentAPI(args.where ?? {}),
+            ...buildMeta(this.payload, {
+                collection: args.collection,
+                locale,
+                where: args.where
+            })
+        }
+    });
+    if (error) {
+        throw new Error(`Content API findDistinct error: ${JSON.stringify(error)}`);
+    }
+    const { data, ...pagination } = response.result;
+    return {
+        ...pagination,
+        // Content API returns flat values; Payload expects objects keyed by field name.
+        values: data.map((value)=>({
+                [args.field]: value
+            }))
+    };
+}
 async function updateMany(args) {
     const locale = addFallbackLocale(args.locale, this.payload);
     const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
@@ -418,7 +449,18 @@ async function deleteOne(args) {
 async function create(args) {
     const isGlobalCollection = args.collection.startsWith('_global-');
     const customIDType = this.payload.collections[args.collection]?.customIDType;
-    const id = (isGlobalCollection || customIDType || this.allowIDOnCreate) && args.data.id != null && (typeof args.data.id === 'string' || typeof args.data.id === 'number') ? String(args.data.id) : uuid();
+    // See test: "should allow creating docs with payload.db.create with custom ID".
+    // TODO: customID is not yet in our installed types. Remove this when it is.
+    // When provided (e.g. from payload.db.create), it takes priority over data.id.
+    const customID = args.customID;
+    let id;
+    if (customID != null) {
+        id = String(customID);
+    } else if ((isGlobalCollection || customIDType || this.allowIDOnCreate) && args.data.id != null && (typeof args.data.id === 'string' || typeof args.data.id === 'number')) {
+        id = String(args.data.id);
+    } else {
+        id = uuid();
+    }
     const locale = addFallbackLocale(args.locale, this.payload);
     const { data: response, error } = await this.client.POST('/api/v0/documents:create', {
         body: {
@@ -434,6 +476,7 @@ async function create(args) {
             locale,
             ...buildMeta(this.payload, {
                 collection: args.collection,
+                data: args.data,
                 locale
             })
         }
@@ -542,6 +585,7 @@ async function upsert(args) {
             where: convertPayloadWhereToContentAPI(args.where),
             ...buildMeta(this.payload, {
                 collection: args.collection,
+                data: args.data,
                 locale,
                 where: args.where
             })
@@ -580,8 +624,9 @@ function findGlobal(args) {
     });
 }
 async function updateGlobal(args) {
-    // Use upsert to ensure the global exists
-    // Use slug as the consistent document ID for globals
+    // TODO: upsert's `createOnMissing` path generates a new `createdAt` on every call,
+    // which overwrites the original timestamp on updates. The fix belongs in the Content API:
+    // `createOnMissing` should preserve `createdAt` on updates and only set it on creates.
     return this.upsert({
         collection: getGlobalSlug(args.slug),
         data: args.data,
@@ -678,11 +723,12 @@ export const contentAPIAdapter = (opts)=>({
                 deleteOne: deleteOne,
                 deleteVersions: deleteVersions,
                 find: find,
-                findDistinct: ()=>Promise.reject(new Error('findDistinct is not yet implemented for Content API adapter')),
+                findDistinct: findDistinct,
                 findGlobal: findGlobal,
                 findGlobalVersions: findGlobalVersions,
                 findOne: findOne,
                 findVersions: findVersions,
+                idType: 'uuid',
                 init,
                 packageName: '@payloadcms/db-content-api',
                 payload,

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

@@ -37,6 +37,13 @@ export declare function dataToContentAPI(payload: Payload, collectionSlug: strin
  * Note: Date fields come as ISO strings from Content API and stay as strings
  * (matching MongoDB and other adapters' behavior)
  */
+/**
+ * Extract version content from versionData that may be flat (no nested `version` key).
+ * Some callers spread version content at the top level alongside metadata
+ * (e.g. `{ ...version.version, createdAt }`), so we reconstruct the `version`
+ * object by filtering out known metadata keys.
+ */
+export declare function resolveVersionContent(version: unknown, versionMeta: Record<string, unknown>): unknown;
 export declare function dataFromContentAPI(payload: Payload, collectionSlug: string, data: unknown): unknown;
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -84,10 +84,16 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
         transformed.id = String(transformed.id);
     }
     // Add timestamps (Content API no longer auto-sets these in DB)
-    // updatedAt is always set, createdAt only on create operations
+    // Preserve existing timestamps when already present (e.g. version data that carries
+    // the parent document's timestamps), otherwise generate new ones.
+    // Explicit null means "don't change" — strip it so the API keeps the existing value.
     const now = new Date().toISOString();
-    transformed.updatedAt = now;
-    if (options?.createdAt) {
+    if (transformed.updatedAt === null) {
+        delete transformed.updatedAt;
+    } else if (transformed.updatedAt === undefined) {
+        transformed.updatedAt = now;
+    }
+    if (options?.createdAt && !transformed.createdAt) {
         transformed.createdAt = now;
     }
     return transformed;
@@ -101,7 +107,24 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
  *
  * Note: Date fields come as ISO strings from Content API and stay as strings
  * (matching MongoDB and other adapters' behavior)
- */ export function dataFromContentAPI(payload, collectionSlug, data) {
+ */ /**
+ * Extract version content from versionData that may be flat (no nested `version` key).
+ * Some callers spread version content at the top level alongside metadata
+ * (e.g. `{ ...version.version, createdAt }`), so we reconstruct the `version`
+ * object by filtering out known metadata keys.
+ */ export function resolveVersionContent(version, versionMeta) {
+    if (version !== undefined) {
+        return version;
+    }
+    const metaKeys = [
+        'createdAt',
+        'updatedAt',
+        'latest',
+        'parent'
+    ];
+    return Object.fromEntries(Object.entries(versionMeta).filter(([key])=>!metaKeys.includes(key)));
+}
+export function dataFromContentAPI(payload, collectionSlug, data) {
     if (!data || typeof data !== 'object') {
         return data;
     }
@@ -134,6 +157,15 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
             return;
         }
         if (value !== null) {
+            // hasMany relationships: normalize to array (non-localized only).
+            // Unlike Drizzle (which reconstructs arrays from join tables), we store raw JSON,
+            // so a single-item input like `{ value, relationTo }` stays as-is. Payload expects arrays.
+            // Localized fields are skipped because their value is a locale map, not a relationship value.
+            if (field.type === 'relationship' && field.hasMany && !Array.isArray(value) && !('localized' in field && field.localized)) {
+                current[field.name] = [
+                    value
+                ];
+            }
             // Localized fields: JSON string -> parsed object
             // Content API may store localized fields as JSON strings like "{\"en\":\"value\"}"
             // so we need to parse them back to objects.

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

@@ -11,6 +11,9 @@ import type { PathTypesRecord } from '../../temp-utilities/types.js';
 export interface ContentAPIMeta {
     localizedPaths?: string[];
     pathTypes?: PathTypesRecord;
+    uniquePaths?: {
+        paths: string[];
+    }[];
 }
 /**
  * The type that Content API currently expects (from generated types).
@@ -19,6 +22,8 @@ export interface ContentAPIMeta {
 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;
 }

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

@@ -1,5 +1,6 @@
 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).
@@ -8,7 +9,7 @@ import { buildPathTypes } from './buildPathTypes.js';
  * @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, locale, where } = 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);
@@ -22,6 +23,13 @@ import { buildPathTypes } from './buildPathTypes.js';
             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.

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

@@ -0,0 +1,13 @@
+import type { Payload } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+type UniquePath = components['schemas']['UniquePath'];
+/**
+ * Builds a UniquePath[] from the collection's field config by collecting
+ * all fields with `unique: true` that have a non-null value in the data.
+ *
+ * Fields with null/undefined values are excluded to match sparse unique index
+ * behavior (multiple documents can have null for a unique field).
+ */
+export declare function buildUniquePaths(payload: Payload, collectionSlug: string, data: Record<string, unknown>): UniquePath[];
+export {};
+//# sourceMappingURL=buildUniquePaths.d.ts.map

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

@@ -0,0 +1,62 @@
+/**
+ * Builds a UniquePath[] from the collection's field config by collecting
+ * all fields with `unique: true` that have a non-null value in the data.
+ *
+ * Fields with null/undefined values are excluded to match sparse unique index
+ * behavior (multiple documents can have null for a unique field).
+ */ export function buildUniquePaths(payload, collectionSlug, data) {
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const config = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!config?.fields) {
+        return [];
+    }
+    const unique = [];
+    collectUniqueFields(config.fields, '', data, unique);
+    return unique;
+}
+function getValueAtPath(data, path) {
+    const segments = path.split('.');
+    let current = data;
+    for (const segment of segments){
+        if (current == null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function collectUniqueFields(fields, prefix, data, result) {
+    for (const field of fields){
+        if (field.type === 'row' || field.type === 'collapsible') {
+            collectUniqueFields(field.fields, prefix, data, result);
+            continue;
+        }
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                const tabPrefix = 'name' in tab && tab.name ? `${prefix}${tab.name}.` : prefix;
+                collectUniqueFields(tab.fields, tabPrefix, data, result);
+            }
+            continue;
+        }
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        const path = prefix + field.name;
+        if ('unique' in field && field.unique) {
+            const value = getValueAtPath(data, path);
+            if (value != null) {
+                result.push({
+                    paths: [
+                        path
+                    ]
+                });
+            }
+        }
+        if (field.type === 'group' && 'fields' in field) {
+            collectUniqueFields(field.fields, `${path}.`, data, result);
+        }
+    }
+}
+
+//# sourceMappingURL=buildUniquePaths.js.map

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

@@ -85,7 +85,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 conditions.push({
                     operator: 'equals',
                     path: fieldPath,
-                    value
+                    value: fieldPath === 'id' && typeof value === 'number' ? String(value) : value
                 });
                 continue;
             }
@@ -106,6 +106,12 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 if (op === 'exists' && typeof operatorValue === 'string') {
                     finalValue = operatorValue === 'true';
                 }
+                // 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,

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

@@ -0,0 +1,11 @@
+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;
+//# sourceMappingURL=schedule-extract-plugin.d.ts.map

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

@@ -0,0 +1,34 @@
+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;
+    };
+}
+
+//# sourceMappingURL=schedule-extract-plugin.js.map

package/dist/plugin/build-config.d.ts

@@ -6,9 +6,10 @@ import type { Config, SanitizedConfig } from 'payload';
  * - `db`: Omitted (auto-injected by Figma platform)
  * - `secret`: Omitted (auto-injected by Figma platform)
  * - `editor`: Optional (defaults to lexicalEditor() if not provided)
+ * - `contentSystemId`: Optional (resolved automatically from env vars or bootstrap cache)
  *
  * @example
- * // Minimal config (contentSystemId resolved from bootstrap data)
+ * // Minimal config (contentSystemId resolved automatically)
  * const config: FigmaConfig = {
  *   figma: {},
  *   collections: [...]

package/dist/plugin/build-config.js

@@ -7,6 +7,7 @@ import { getValidAccessToken } from '../auth/oauth-flow.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getEnvConfig } from '../constants.js';
 import { contentAPIAdapter } from '../db-content-api/index.js';
+import { scheduleExtractPlugin } from '../deploy/schedule-extract-plugin.js';
 import { health } from '../endpoints/health.js';
 import { schema } from '../endpoints/schema.js';
 import { oAuth2Plugin } from '../oauth/index.js';
@@ -67,6 +68,7 @@ export async function buildFigmaConfig(config) {
     let { contentSystemId } = config.figma;
     contentSystemId ??= process.env.FIGMA_CONTENT_API_CONTENT_SYSTEM_ID;
     let bootstrapData = null;
+    // Local dev: resolve from project ID + bootstrap cache
     if (!contentSystemId) {
         const projectId = process.env.FIGMA_PROJECT_ID;
         const environmentName = process.env.FIGMA_ENVIRONMENT_NAME;
@@ -219,7 +221,8 @@ export async function buildFigmaConfig(config) {
                 ],
                 debug: !!process.env.DEBUG,
                 disabled: false
-            })
+            }),
+            scheduleExtractPlugin()
         ]
     };
     // Inject figma fields into users collection

package/dist/types.d.ts

@@ -3,15 +3,19 @@ export interface Args extends arg.Spec {
     '--debug': BooleanConstructor;
     '--dry-run': BooleanConstructor;
     '--env': StringConstructor;
+    '--environment': string;
     '--force': BooleanConstructor;
     '--help': BooleanConstructor;
     '--id': StringConstructor;
     '--infra-env': StringConstructor;
     '--list': BooleanConstructor;
     '--logout': BooleanConstructor;
+    '--name': StringConstructor;
     '--yes': BooleanConstructor;
+    '-e': string;
     '-f': string;
     '-h': string;
+    '-n': string;
     '-y': string;
 }
 export type CliArgs = arg.Result<Args>;

package/dist/utils/build-lambda-zip.js

@@ -20,7 +20,7 @@ import path from 'path';
     const runShPath = path.join(projectPath, 'run.sh');
     const zipPath = path.join(projectPath, 'lambda.zip');
     if (!await isDirectory(standalonePath)) {
-        throw new Error('Standalone build not found at .next/standalone. ' + 'Ensure next.config.js has output: "standalone" and run build first.');
+        throw new Error('Standalone build not found at .next/standalone. ' + 'Ensure next.config has output: "standalone" and run build first.');
     }
     if (await isDirectory(staticPath)) {
         const destStatic = path.join(standalonePath, '.next', 'static');

package/dist/utils/formatter.js

@@ -1,9 +1,13 @@
 import spawn from 'cross-spawn';
 import path from 'path';
+import * as log from './log.js';
 /**
  * Format file with Prettier
  * Returns warning if formatting fails but does not throw
  */ export async function formatFile(filePath, packageManager) {
+    const cmd = `${packageManager} exec prettier --write ${filePath}`;
+    const cwd = path.dirname(filePath);
+    log.debug(`Running formatter: ${cmd} (cwd: ${cwd})`);
     return new Promise((resolve)=>{
         try {
             const child = spawn(packageManager, [
@@ -12,31 +16,41 @@ import path from 'path';
                 '--write',
                 filePath
             ], {
-                cwd: path.dirname(filePath),
+                cwd,
                 stdio: 'pipe'
             });
+            let stderr = '';
+            child.stderr?.on('data', (data)=>{
+                stderr += data.toString();
+            });
             child.on('close', (code)=>{
                 if (code === 0) {
+                    log.debug('Prettier formatting succeeded');
                     resolve({
                         success: true
                     });
                 } else {
+                    const detail = stderr.trim();
+                    log.debug(`Prettier exited with code ${code}${detail ? `: ${detail}` : ''}`);
                     resolve({
                         success: false,
-                        warning: 'Could not format file with Prettier'
+                        warning: `Could not format file with Prettier (exit code ${code})${detail ? `: ${detail}` : ''}`
                     });
                 }
             });
-            child.on('error', ()=>{
+            child.on('error', (err)=>{
+                log.debug(`Prettier spawn error: ${err.message}`);
                 resolve({
                     success: false,
-                    warning: 'Could not format file with Prettier'
+                    warning: `Could not format file with Prettier: ${err.message}`
                 });
             });
-        } catch  {
+        } catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            log.debug(`Prettier failed to spawn: ${message}`);
             resolve({
                 success: false,
-                warning: 'Could not format file with Prettier'
+                warning: `Could not format file with Prettier: ${message}`
             });
         }
     });