@payloadcms/figma 0.0.1-alpha.51 → 0.0.1-alpha.52

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

@@ -151,4 +151,12 @@ export type BootstrapInfo = {
  * @param environmentName - Optional environment name filter
  */
 export declare function getBootstrapInfo(accessToken: string, cmsResourceId: string, environmentName?: string): Promise<BootstrapInfo>;
+/**
+ * Resolve a CMS Resource ID from a legacy dataset (content system) ID.
+ * Maps to: GET /v1/cms/dataset/:datasetId
+ *
+ * Used during upgrade migration to convert old FIGMA_CONTENT_API_CONTENT_SYSTEM_ID
+ * into the new FIGMA_PROJECT_ID (CMS Resource ID).
+ */
+export declare function getCmsResourceId(accessToken: string, datasetId: string): Promise<string>;
 //# sourceMappingURL=control-plane.d.ts.map

package/dist/api/control-plane.js

@@ -276,6 +276,27 @@ import * as log from '../utils/log.js';
         }
     };
 }
+/**
+ * Resolve a CMS Resource ID from a legacy dataset (content system) ID.
+ * Maps to: GET /v1/cms/dataset/:datasetId
+ *
+ * Used during upgrade migration to convert old FIGMA_CONTENT_API_CONTENT_SYSTEM_ID
+ * into the new FIGMA_PROJECT_ID (CMS Resource ID).
+ */ export async function getCmsResourceId(accessToken, datasetId) {
+    const url = `${getControlPlaneBaseUrl()}/v1/cms/dataset/${datasetId}`;
+    log.debug(`Calling getCmsResourceId API at ${url}`);
+    const response = await controlPlaneFetch({
+        context: 'get CMS resource ID from dataset',
+        options: {
+            headers: {
+                Authorization: `Bearer ${accessToken}`
+            }
+        },
+        url
+    });
+    const data = await response.json();
+    return data.meta.cms_resource_id;
+}
 const MAX_RETRIES = 3;
 const INITIAL_RETRY_DELAY = 1000;
 function sleep(ms) {

package/dist/cli.js

@@ -10,6 +10,7 @@ import { listTokensCommand } from './commands/list-tokens.js';
 import { loginCommand } from './commands/login.js';
 import { logoutCommand } from './commands/logout.js';
 import { setInfraEnvironment } from './constants.js';
+import { handleUpgrade } from './utils/handle-upgrade.js';
 import { helpMessage } from './utils/messages.js';
 /**
  * Entrypoint for bin/cli.js
@@ -85,6 +86,15 @@ class Main {
                 helpMessage();
                 process.exit(0);
             }
+            // Check for upgrade migrations
+            try {
+                const upgradeChanges = await handleUpgrade(process.cwd());
+                if (upgradeChanges.length > 0) {
+                    p.log.info(`Migrated project: ${upgradeChanges.join(', ')}`);
+                }
+            } catch  {
+            // Never block CLI execution due to upgrade check
+            }
             // Debug command outputs plain text for copy-paste — skip styled intro
             if (subcommand === 'debug') {
                 await debugCommand();

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

@@ -8,20 +8,16 @@ import type { Config, SanitizedConfig } from 'payload';
  * - `editor`: Optional (defaults to lexicalEditor() if not provided)
  *
  * @example
- * // Minimal config
+ * // Minimal config (contentSystemId resolved from bootstrap data)
  * const config: FigmaConfig = {
- *   figma: {
- *     contentSystemId: process.env.FIGMA_CONTENT_API_CONTENT_SYSTEM_ID!
- *   },
+ *   figma: {},
  *   collections: [...]
  * }
  *
  * @example
  * // With custom editor
  * const config: FigmaConfig = {
- *   figma: {
- *     contentSystemId: process.env.FIGMA_CONTENT_API_CONTENT_SYSTEM_ID!
- *   },
+ *   figma: {},
  *   collections: [...],
  *   editor: lexicalEditor({ features: [...] })
  * }
@@ -30,7 +26,6 @@ import type { Config, SanitizedConfig } from 'payload';
  * // Disable Content System (use custom db)
  * const config: FigmaConfig = {
  *   figma: {
- *     contentSystemId: process.env.FIGMA_CONTENT_API_CONTENT_SYSTEM_ID!,
  *     useContentSystem: false
  *   },
  *   db: mongooseAdapter({ url: process.env.DATABASE_URI }),
@@ -41,7 +36,7 @@ export type FigmaConfig = {
     editor?: Config['editor'];
 } & {
     figma: {
-        contentSystemId: string;
+        contentSystemId?: string;
         storage?: boolean;
         useContentSystem?: boolean;
     };

package/dist/plugin/build-config.js

@@ -62,6 +62,18 @@ function missingOAuthCredential(name) {
     }
 }
 export async function buildFigmaConfig(config) {
+    // Auto-migrate old env vars in local dev (never in Lambda/production)
+    if (process.env.NODE_ENV !== 'production' && !process.env.AWS_LAMBDA_FUNCTION_NAME) {
+        try {
+            const { handleEnvUpgrade } = await import('../utils/handle-upgrade.js');
+            const upgradeChanges = await handleEnvUpgrade(process.cwd());
+            if (upgradeChanges.length > 0) {
+                log.warning(`Auto-migrated .env: ${upgradeChanges.join(', ')}`);
+            }
+        } catch  {
+        // Never block config build due to upgrade check
+        }
+    }
     const envConfig = getEnvConfig();
     // Resolve contentSystemId: config first, then local store fallback (dev)
     let { contentSystemId } = config.figma;

package/dist/utils/env-management.d.ts

@@ -22,4 +22,12 @@ export declare function getEnvVarSync(projectPath: string, key: string): null |
  * @param value - Environment variable value
  */
 export declare function addOrUpdateEnvVar(projectPath: string, key: string, value: string): Promise<void>;
+/**
+ * Remove an environment variable from .env file
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
+ */
+export declare function removeEnvVar(projectPath: string, key: string): Promise<boolean>;
 //# sourceMappingURL=env-management.d.ts.map

package/dist/utils/env-management.js

@@ -115,5 +115,39 @@ import path from 'path';
         throw new Error(`Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+/**
+ * Remove an environment variable from .env file
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
+ */ export async function removeEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const filteredLines = [];
+        let found = false;
+        for (const line of lines){
+            if (line.trim() && !line.trim().startsWith('#') && line.includes('=')) {
+                const equalsIndex = line.indexOf('=');
+                const lineKey = line.substring(0, equalsIndex).trim();
+                if (lineKey === key) {
+                    found = true;
+                    continue;
+                }
+            }
+            filteredLines.push(line);
+        }
+        if (found) {
+            // Collapse consecutive blank lines and trim leading/trailing blank lines
+            const collapsed = filteredLines.join('\n').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '');
+            await fs.writeFile(envPath, collapsed, 'utf-8');
+        }
+        return found;
+    } catch  {
+        return false;
+    }
+}
 
 //# sourceMappingURL=env-management.js.map

package/dist/utils/handle-upgrade.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Migrate .env file from old env var format to new format.
+ * Non-blocking — returns list of changes made, never throws.
+ */
+export declare function handleEnvUpgrade(projectPath: string): Promise<string[]>;
+/**
+ * Full upgrade migration: .env + payload.config.ts AST changes + version sync.
+ * Called from CLI entry point before command routing.
+ * Non-blocking — returns list of changes made, never throws.
+ */
+export declare function handleUpgrade(projectPath: string): Promise<string[]>;
+//# sourceMappingURL=handle-upgrade.d.ts.map

package/dist/utils/handle-upgrade.js

@@ -0,0 +1,242 @@
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { Project } from 'ts-morph';
+import { fileURLToPath } from 'url';
+import { getBootstrapInfo, getCmsResourceId } from '../api/control-plane.js';
+import { getValidAccessToken } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { cacheAllEnvironments } from './cache-bootstrap.js';
+import { addOrUpdateEnvVar, getEnvVar, removeEnvVar } from './env-management.js';
+import { formatFile } from './formatter.js';
+import * as log from './log.js';
+import { getPackageManager } from './package-manager.js';
+import { removeFigmaContentSystemId } from './payload-config-ast.js';
+import { findPayloadConfig } from './payload-config-finder.js';
+import { checkPackageInstalled, installPackage } from './payload-package-check.js';
+import { getOwnVersion } from './version-check.js';
+const OLD_ENV_VARS = [
+    'FIGMA_ENV',
+    'FIGMA_CONTENT_API_CONTENT_SYSTEM_ID',
+    'FIGMA_TENANT_ID',
+    'FIGMA_OAUTH_CLIENT_ID',
+    'FIGMA_OAUTH_CLIENT_SECRET'
+];
+const REMOVABLE_ENV_VARS = [
+    'FIGMA_CONTENT_API_CONTENT_SYSTEM_ID',
+    'FIGMA_TENANT_ID',
+    'FIGMA_OAUTH_CLIENT_ID',
+    'FIGMA_OAUTH_CLIENT_SECRET'
+];
+/**
+ * Walk up from a directory to find the nearest package.json with name "@payloadcms/figma".
+ */ async function findPackageRoot(startDir) {
+    let dir = startDir;
+    while(true){
+        const pkgPath = path.join(dir, 'package.json');
+        try {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+            if (pkg.name === '@payloadcms/figma') {
+                return dir;
+            }
+        } catch  {
+        // No package.json here
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+/**
+ * Build and pack the local @payloadcms/figma package, returning the tgz path.
+ */ function packLocalPackage(pkgDir) {
+    execSync('pnpm build', {
+        cwd: pkgDir,
+        stdio: 'pipe'
+    });
+    const tgzOutput = execSync('pnpm pack', {
+        cwd: pkgDir,
+        stdio: 'pipe'
+    }).toString().trim();
+    const tgzName = tgzOutput.split('\n').pop();
+    const tgzPath = path.join(pkgDir, tgzName);
+    return tgzPath;
+}
+/**
+ * Attempt to resolve bootstrap data: check cache first, then API call.
+ */ async function resolveBootstrapData(projectId, environmentName) {
+    const store = getTokenStore();
+    const cached = store.getBootstrapData(projectId, environmentName);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const accessToken = await getValidAccessToken(store);
+        if (!accessToken) {
+            return null;
+        }
+        const bootstrapInfo = await getBootstrapInfo(accessToken, projectId);
+        cacheAllEnvironments(store, projectId, bootstrapInfo);
+        return store.getBootstrapData(projectId, environmentName);
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Migrate .env file from old env var format to new format.
+ * Non-blocking — returns list of changes made, never throws.
+ */ export async function handleEnvUpgrade(projectPath) {
+    try {
+        const oldValues = {};
+        let hasOldVars = false;
+        for (const key of OLD_ENV_VARS){
+            const value = await getEnvVar(projectPath, key);
+            oldValues[key] = value;
+            if (value !== null) {
+                hasOldVars = true;
+            }
+        }
+        if (!hasOldVars) {
+            return [];
+        }
+        const changes = [];
+        // Rename FIGMA_ENV → FIGMA_INFRA_ENV
+        if (oldValues.FIGMA_ENV !== null) {
+            await addOrUpdateEnvVar(projectPath, 'FIGMA_INFRA_ENV', oldValues.FIGMA_ENV);
+            await removeEnvVar(projectPath, 'FIGMA_ENV');
+            changes.push('Renamed FIGMA_ENV → FIGMA_INFRA_ENV');
+        }
+        // Remove old vars if bootstrap data is available
+        const projectId = await getEnvVar(projectPath, 'FIGMA_PROJECT_ID');
+        const environmentName = await getEnvVar(projectPath, 'FIGMA_ENVIRONMENT_NAME') ?? 'production';
+        if (projectId) {
+            const bootstrapData = await resolveBootstrapData(projectId, environmentName);
+            if (bootstrapData) {
+                const removed = [];
+                for (const key of REMOVABLE_ENV_VARS){
+                    if (oldValues[key] !== null) {
+                        await removeEnvVar(projectPath, key);
+                        removed.push(key);
+                    }
+                }
+                if (removed.length > 0) {
+                    changes.push(`Removed deprecated env vars: ${removed.join(', ')}`);
+                }
+            } else {
+                log.warning('Could not resolve bootstrap data — keeping deprecated env vars. ' + 'Run `npx @payloadcms/figma init` to complete migration.');
+            }
+        }
+        return changes;
+    } catch (error) {
+        log.warning(`Upgrade migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return [];
+    }
+}
+/**
+ * Full upgrade migration: .env + payload.config.ts AST changes + version sync.
+ * Called from CLI entry point before command routing.
+ * Non-blocking — returns list of changes made, never throws.
+ */ export async function handleUpgrade(projectPath) {
+    const changes = await handleEnvUpgrade(projectPath);
+    // Resolve CMS Resource ID from old content system ID via dataset API
+    try {
+        const existingProjectId = await getEnvVar(projectPath, 'FIGMA_PROJECT_ID');
+        if (!existingProjectId) {
+            const oldContentSystemId = await getEnvVar(projectPath, 'FIGMA_CONTENT_API_CONTENT_SYSTEM_ID');
+            if (oldContentSystemId) {
+                const store = getTokenStore();
+                const accessToken = await getValidAccessToken(store);
+                if (accessToken) {
+                    const cmsResourceId = await getCmsResourceId(accessToken, oldContentSystemId);
+                    await addOrUpdateEnvVar(projectPath, 'FIGMA_PROJECT_ID', cmsResourceId);
+                    await addOrUpdateEnvVar(projectPath, 'FIGMA_ENVIRONMENT_NAME', 'production');
+                    changes.push('Resolved FIGMA_PROJECT_ID from content system ID');
+                    // Fetch bootstrap data and cache it, then remove old vars
+                    try {
+                        const bootstrapInfo = await getBootstrapInfo(accessToken, cmsResourceId);
+                        cacheAllEnvironments(store, cmsResourceId, bootstrapInfo);
+                        const removed = [];
+                        for (const key of REMOVABLE_ENV_VARS){
+                            const value = await getEnvVar(projectPath, key);
+                            if (value !== null) {
+                                await removeEnvVar(projectPath, key);
+                                removed.push(key);
+                            }
+                        }
+                        if (removed.length > 0) {
+                            changes.push(`Removed deprecated env vars: ${removed.join(', ')}`);
+                        }
+                    } catch  {
+                        log.warning('Could not fetch bootstrap data — keeping deprecated env vars. ' + 'Run `npx @payloadcms/figma init` to complete migration.');
+                    }
+                } else {
+                    log.warning('Not authenticated — could not resolve FIGMA_PROJECT_ID. ' + 'Run `npx @payloadcms/figma init` to complete migration.');
+                }
+            }
+        }
+    } catch (error) {
+        log.warning(`Project ID migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    try {
+        const configPath = await findPayloadConfig(projectPath);
+        if (configPath) {
+            const project = new Project({
+                skipAddingFilesFromTsConfig: true
+            });
+            const sourceFile = project.addSourceFileAtPath(configPath);
+            const removed = removeFigmaContentSystemId(sourceFile);
+            if (removed) {
+                await sourceFile.save();
+                try {
+                    const packageManager = await getPackageManager(projectPath);
+                    await formatFile(configPath, packageManager);
+                } catch  {
+                // Formatting is best-effort
+                }
+                changes.push('Removed contentSystemId from payload.config.ts');
+            }
+        }
+    } catch (error) {
+        log.warning(`Config migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    // Sync @payloadcms/figma version in project's package.json
+    try {
+        const isInstalled = await checkPackageInstalled(projectPath, '@payloadcms/figma');
+        if (isInstalled) {
+            const cliDir = path.dirname(fileURLToPath(import.meta.url));
+            const isFromRegistry = cliDir.includes('node_modules') || cliDir.includes('.npm');
+            if (isFromRegistry) {
+                // Registry install: sync to CLI version
+                const cliVersion = await getOwnVersion();
+                const pkgJsonPath = path.join(projectPath, 'package.json');
+                const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, 'utf-8'));
+                const installedVersion = pkgJson.dependencies?.['@payloadcms/figma']?.replace(/^[\^~>=<]+/, '');
+                if (installedVersion && installedVersion !== cliVersion) {
+                    const packageManager = await getPackageManager(projectPath);
+                    await installPackage(projectPath, '@payloadcms/figma', packageManager, cliVersion);
+                    changes.push(`Updated @payloadcms/figma ${installedVersion} → ${cliVersion}`);
+                }
+            } else {
+                // Local CLI: pack and install tgz into the project
+                const pkgDir = await findPackageRoot(cliDir);
+                if (pkgDir) {
+                    log.debug('CLI running from local path — packing and installing into project...');
+                    const packageManager = await getPackageManager(projectPath);
+                    const tgzPath = packLocalPackage(pkgDir);
+                    const destTgz = path.join(projectPath, path.basename(tgzPath));
+                    await fs.rename(tgzPath, destTgz);
+                    await installPackage(projectPath, destTgz, packageManager);
+                    await fs.unlink(destTgz).catch(()=>{});
+                    changes.push('Installed @payloadcms/figma from local build');
+                }
+            }
+        }
+    } catch (error) {
+        log.warning(`Package version sync failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    return changes;
+}
+
+//# sourceMappingURL=handle-upgrade.js.map

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

@@ -62,4 +62,11 @@ export declare function addFigmaProperty(sourceFile: SourceFile, config: FigmaPr
  * Returns the figma object if it exists, null otherwise
  */
 export declare function readFigmaConfig(sourceFile: SourceFile): FigmaPropertyConfig | null;
+/**
+ * Remove the contentSystemId property from figma config object.
+ * Used during upgrade migration — contentSystemId is now resolved from bootstrap data.
+ *
+ * @returns true if the property was found and removed
+ */
+export declare function removeFigmaContentSystemId(sourceFile: SourceFile): boolean;
 //# sourceMappingURL=payload-config-ast.d.ts.map

package/dist/utils/payload-config-ast.js

@@ -472,5 +472,39 @@ import * as log from './log.js';
         useContentSystem
     };
 }
+/**
+ * Remove the contentSystemId property from figma config object.
+ * Used during upgrade migration — contentSystemId is now resolved from bootstrap data.
+ *
+ * @returns true if the property was found and removed
+ */ export function removeFigmaContentSystemId(sourceFile) {
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const buildConfigCall = callExpressions.find((ce)=>{
+        const expr = ce.getExpression();
+        const text = expr.getText();
+        return text === 'buildFigmaConfig' || text.endsWith('.buildFigmaConfig');
+    });
+    if (!buildConfigCall) {
+        return false;
+    }
+    const configArg = buildConfigCall.getArguments()[0];
+    if (!configArg || !Node.isObjectLiteralExpression(configArg)) {
+        return false;
+    }
+    const figmaProperty = configArg.getProperty('figma');
+    if (!figmaProperty || !Node.isPropertyAssignment(figmaProperty)) {
+        return false;
+    }
+    const initializer = figmaProperty.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+        return false;
+    }
+    const contentSystemIdProp = initializer.getProperty('contentSystemId');
+    if (!contentSystemIdProp) {
+        return false;
+    }
+    contentSystemIdProp.remove();
+    return true;
+}
 
 //# sourceMappingURL=payload-config-ast.js.map

package/dist/utils/payload-package-check.js

@@ -42,7 +42,7 @@ import * as log from './log.js';
  */ export async function installPackage(projectPath, packageName, packageManager, version = 'latest') {
     return new Promise((resolve, reject)=>{
         const command = packageManager;
-        const packageSpec = `${packageName}@${version}`;
+        const packageSpec = packageName.endsWith('.tgz') ? packageName : `${packageName}@${version}`;
         const args = [
             'add',
             packageSpec

package/package.json

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