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

package/dist/commands/deploy.js

@@ -184,7 +184,7 @@ import { loginCommand } from './login.js';
             buildInfo = await detectBuild(projectPath);
             if (!buildInfo) {
                 p.log.error(pc.red('✗ Build completed but standalone build not found'));
-                p.note('Ensure next.config.js has output: "standalone"', 'Check Lambda Configuration');
+                p.note('Ensure next.config has output: "standalone"', 'Check Lambda Configuration');
                 process.exit(1);
             }
         }

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

@@ -476,6 +476,7 @@ async function create(args) {
             locale,
             ...buildMeta(this.payload, {
                 collection: args.collection,
+                data: args.data,
                 locale
             })
         }
@@ -584,6 +585,7 @@ async function upsert(args) {
             where: convertPayloadWhereToContentAPI(args.where),
             ...buildMeta(this.payload, {
                 collection: args.collection,
+                data: args.data,
                 locale,
                 where: args.where
             })

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

@@ -157,6 +157,15 @@ export function dataFromContentAPI(payload, collectionSlug, data) {
             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/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/lambda-config.js

@@ -1,6 +1,6 @@
-import { parseModule, Syntax } from 'esprima-next';
 import fs from 'fs/promises';
 import path from 'path';
+import { IndentationText, Node, Project, SyntaxKind } from 'ts-morph';
 const RUN_SH_CONTENT = `#!/bin/bash -x
 
 [ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
@@ -36,11 +36,11 @@ NODE_ENV=production exec node server.js
     await addLambdaBuildScript(projectPath, packageManager);
 }
 /**
- * Find the Next.js config file (next.config.js or next.config.mjs)
- *
- * @todo Support TypeScript config files in future
+ * Find the Next.js config file, checking TS extensions first
  */ async function findNextConfigPath(projectPath) {
     const configFiles = [
+        'next.config.ts',
+        'next.config.mts',
         'next.config.js',
         'next.config.mjs'
     ];
@@ -53,83 +53,85 @@ NODE_ENV=production exec node server.js
         // File doesn't exist, try next one
         }
     }
-    throw new Error('Could not find next.config.js or next.config.mjs');
+    throw new Error('Could not find next.config.ts, next.config.mts, next.config.js, or next.config.mjs');
 }
 /**
- * Add required Next.js config properties using AST parsing
+ * Add required Next.js config properties using ts-morph AST parsing
  * - output: 'standalone' (for Lambda deployment)
  * - eslint: { ignoreDuringBuilds: true } (allow builds with lint errors)
  */ async function addNextConfigProperties(projectPath) {
     const nextConfigPath = await findNextConfigPath(projectPath);
-    const content = await fs.readFile(nextConfigPath, 'utf-8');
-    // Check which properties already exist
-    const hasOutput = content.includes('output:');
-    const hasEslint = content.includes('eslint:');
-    // Early exit if both already configured
-    if (hasOutput && hasEslint) {
-        return;
-    }
-    const ast = parseModule(content, {
-        loc: true
+    const project = new Project({
+        compilerOptions: {
+            allowJs: true
+        },
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces
+        },
+        skipAddingFilesFromTsConfig: true
     });
-    // Find export default declaration
-    const exportDefaultDeclaration = ast.body.find((p)=>p.type === Syntax.ExportDefaultDeclaration);
-    if (!exportDefaultDeclaration?.declaration?.loc) {
-        throw new Error(`Could not find export default declaration in ${path.basename(nextConfigPath)}`);
-    }
-    // Find the object expression to modify
-    let targetObjectExpression;
-    if (exportDefaultDeclaration.declaration.type === 'ObjectExpression') {
-        // Direct export: export default { ... }
-        targetObjectExpression = exportDefaultDeclaration.declaration;
-    } else if (exportDefaultDeclaration.declaration.type === 'CallExpression') {
-        // Wrapped export: export default withPayload(nextConfig, ...)
-        const callExpr = exportDefaultDeclaration.declaration;
-        const firstArg = callExpr.arguments?.[0];
-        if (firstArg?.type === 'Identifier') {
-            // Find the variable declaration for this identifier
-            const configVarName = firstArg.name;
-            const varDeclaration = ast.body.find((node)=>{
-                if (node.type === Syntax.VariableDeclaration) {
-                    const varNode = node;
-                    return varNode.declarations?.some((decl)=>decl.id?.type === 'Identifier' && decl.id.name === configVarName && decl.init?.type === 'ObjectExpression');
-                }
-                return false;
-            });
-            if (varDeclaration) {
-                const declarator = varDeclaration.declarations?.find((decl)=>decl.id?.type === 'Identifier' && decl.id.name === configVarName);
-                if (declarator?.init?.type === 'ObjectExpression') {
-                    targetObjectExpression = declarator.init;
-                }
-            }
-        }
-    }
-    if (!targetObjectExpression?.loc) {
+    const sourceFile = project.addSourceFileAtPath(nextConfigPath);
+    // Find the config object to modify
+    const configObject = findConfigObject(sourceFile);
+    if (!configObject) {
         throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
     }
-    const { loc } = targetObjectExpression;
-    const lines = content.split(/\r?\n/);
-    // Build insertion string based on what's missing
-    const parts = [];
+    // Check which properties already exist using AST (avoids false positives from comments)
+    const hasOutput = configObject.getProperty('output') !== undefined;
+    const hasEslint = configObject.getProperty('eslint') !== undefined;
+    if (hasOutput && hasEslint) {
+        return;
+    }
     if (!hasOutput) {
-        parts.push("output: 'standalone',");
+        configObject.addPropertyAssignment({
+            name: 'output',
+            initializer: "'standalone'"
+        });
     }
     if (!hasEslint) {
-        parts.push(`eslint: {
-    ignoreDuringBuilds: true,
-  },`);
+        configObject.addPropertyAssignment({
+            name: 'eslint',
+            initializer: `{ ignoreDuringBuilds: true }`
+        });
+    }
+    await sourceFile.save();
+}
+/**
+ * Find the config object literal from either:
+ * - Direct export: `export default { ... }`
+ * - Wrapped export: `export default withPayload(configVar, ...)`
+ *   where configVar is a variable declaration with an object literal
+ */ function findConfigObject(sourceFile) {
+    const exportDefault = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+    if (!exportDefault) {
+        return undefined;
+    }
+    const expression = exportDefault.getExpression();
+    // Direct export: export default { ... }
+    if (Node.isObjectLiteralExpression(expression)) {
+        return expression;
     }
-    const insertString = '\n  ' + parts.join('\n  ');
-    // Insert after opening brace
-    const insertLine = loc.start.line - 1;
-    const insertColumn = loc.start.column + 1;
-    const targetLine = lines[insertLine];
-    if (!targetLine) {
-        throw new Error(`Could not find target line in ${path.basename(nextConfigPath)}`);
+    // Wrapped export: export default withPayload(configVar, ...)
+    if (Node.isCallExpression(expression)) {
+        const firstArg = expression.getArguments()[0];
+        // Variable reference: export default withPayload(configVar)
+        if (firstArg && Node.isIdentifier(firstArg)) {
+            const configVarName = firstArg.getText();
+            // Find the variable declaration
+            const varStatements = sourceFile.getVariableStatements();
+            for (const statement of varStatements){
+                for (const decl of statement.getDeclarations()){
+                    if (decl.getName() === configVarName) {
+                        const initializer = decl.getInitializer();
+                        if (initializer && Node.isObjectLiteralExpression(initializer)) {
+                            return initializer;
+                        }
+                    }
+                }
+            }
+        }
     }
-    lines[insertLine] = targetLine.slice(0, insertColumn) + insertString + targetLine.slice(insertColumn);
-    const modifiedContent = lines.join('\n');
-    await fs.writeFile(nextConfigPath, modifiedContent, 'utf-8');
+    return undefined;
 }
 /**
  * Add lambda:buildzip script to package.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.0.1-alpha.56",
+  "version": "0.0.1-alpha.57",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
@@ -34,7 +34,6 @@
     "arg": "^5.0.2",
     "conf": "^13.0.1",
     "cross-spawn": "7.0.6",
-    "esprima-next": "^6.0.2",
     "figures": "^6.1.0",
     "jose": "6.0.12",
     "jsonwebtoken": "9.0.3",