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

package/dist/utils/package-manager.js

@@ -23,6 +23,59 @@ import path from 'path';
         return 'npm';
     }
 }
+/**
+ * Resolve package manager for a project directory.
+ * Checks lockfiles first, falls back to environment detection.
+ *
+ * @param projectDir - Project directory to check
+ * @returns Resolved package manager
+ */ export async function resolvePackageManager(projectDir) {
+    const fromLockfile = await getPackageManager(projectDir);
+    if (fromLockfile !== 'npm') {
+        return fromLockfile;
+    }
+    // Check if there's actually a package-lock.json (explicit npm choice)
+    if (await fileExists(path.join(projectDir, 'package-lock.json'))) {
+        return 'npm';
+    }
+    // No lockfile found — check environment
+    return detectPackageManagerFromEnvironment();
+}
+/**
+ * Detect package manager from npm_config_user_agent environment variable.
+ * Set automatically by npm/pnpm/yarn when running via npx/pnpm dlx/yarn dlx.
+ *
+ * @returns Detected package manager, defaults to npm
+ */ export function detectPackageManagerFromEnvironment() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent) {
+        return 'npm';
+    }
+    if (userAgent.startsWith('pnpm/')) {
+        return 'pnpm';
+    }
+    if (userAgent.startsWith('yarn/')) {
+        return 'yarn';
+    }
+    return 'npm';
+}
+/**
+ * Get the run command prefix for a package manager.
+ * npm needs "npm run", pnpm/yarn can run scripts directly.
+ */ export function getRunCommand(packageManager) {
+    return packageManager === 'npm' ? 'npm run' : packageManager;
+}
+/**
+ * Get the add/install command for a package manager.
+ */ export function getAddCommand(packageManager) {
+    if (packageManager === 'npm') {
+        return 'npm install';
+    }
+    if (packageManager === 'pnpm') {
+        return 'pnpm add';
+    }
+    return 'yarn add';
+}
 /**
  * Check if file exists
  */ async function fileExists(filePath) {
@@ -33,5 +86,3 @@ import path from 'path';
         return false;
     }
 }
-
-//# sourceMappingURL=package-manager.js.map

package/dist/utils/parse-template-spec.d.ts

@@ -0,0 +1,11 @@
+import type { TemplateSource } from './download-template.js';
+export declare class TemplateSpecParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parse a --template spec string into a partial TemplateSource override.
+ *
+ * Format: [<owner>/<repo>#]<ref>:<template-path>
+ * Shorthand: a bare token with no `#` and no `:` is treated as the template path.
+ */
+export declare function parseTemplateSpec(spec: string): Partial<TemplateSource>;

package/dist/utils/parse-template-spec.js

@@ -0,0 +1,60 @@
+export class TemplateSpecParseError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'TemplateSpecParseError';
+    }
+}
+/**
+ * Parse a --template spec string into a partial TemplateSource override.
+ *
+ * Format: [<owner>/<repo>#]<ref>:<template-path>
+ * Shorthand: a bare token with no `#` and no `:` is treated as the template path.
+ */ export function parseTemplateSpec(spec) {
+    const trimmed = spec.trim();
+    if (!trimmed) {
+        throw new TemplateSpecParseError('Template spec is empty');
+    }
+    let rest = trimmed;
+    const result = {};
+    const hashIndex = rest.indexOf('#');
+    if (hashIndex !== -1) {
+        const repoPart = rest.slice(0, hashIndex);
+        rest = rest.slice(hashIndex + 1);
+        const slashCount = (repoPart.match(/\//g) ?? []).length;
+        if (slashCount !== 1) {
+            throw new TemplateSpecParseError(`Expected "<owner>/<repo>" before "#", got "${repoPart}"`);
+        }
+        const [owner, repo] = repoPart.split('/');
+        if (!owner || !repo) {
+            throw new TemplateSpecParseError(`Invalid owner/repo: "${repoPart}"`);
+        }
+        result.owner = owner;
+        result.repo = repo;
+    } else {
+        // Check for slash only in the portion before the first colon (the ref part).
+        // Slashes after the colon are valid multi-segment template paths.
+        const beforeColon = rest.includes(':') ? rest.slice(0, rest.indexOf(':')) : rest;
+        if (beforeColon.includes('/')) {
+            throw new TemplateSpecParseError(`"<owner>/<repo>" must be followed by "#<ref>" (got "${trimmed}")`);
+        }
+    }
+    const colonIndex = rest.indexOf(':');
+    if (colonIndex !== -1) {
+        const ref = rest.slice(0, colonIndex);
+        const templatePath = rest.slice(colonIndex + 1);
+        if (!ref) {
+            throw new TemplateSpecParseError('Ref before ":" is empty');
+        }
+        if (!templatePath) {
+            throw new TemplateSpecParseError('Template path after ":" is empty');
+        }
+        result.ref = ref;
+        result.templatePath = templatePath;
+        return result;
+    }
+    if (hashIndex !== -1) {
+        throw new TemplateSpecParseError('Spec with "<owner>/<repo>#<ref>" must include ":<template-path>"');
+    }
+    result.templatePath = rest;
+    return result;
+}

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

@@ -1,19 +1,39 @@
 import type { SourceFile } from 'ts-morph';
+/**
+ * Result of detecting what changes are needed in a payload config file
+ */
 export type DetectionResult = {
+    /** Database adapter configuration if present */
     dbProperty?: {
+        /** Name of the adapter function (e.g., 'mongooseAdapter', 'postgresAdapter') */
         adapter: string;
+        /** NPM package the adapter is imported from (e.g., '@payloadcms/db-mongodb') */
         importSource: string;
     };
+    /** Editor configuration if present */
     editorProperty?: {
+        /** NPM package the editor is imported from (e.g., '@payloadcms/richtext-lexical') */
         importSource: string;
+        /** Whether this is a default editor with no custom configuration */
         isDefault: boolean;
     };
+    /** Whether the config already has a `figma` property */
     figmaObjectExists: boolean;
+    /** Whether buildConfig/buildFigmaConfig uses an import alias (e.g., 'buildConfig as createConfig') */
     hasAlias: boolean;
+    /** Whether a buildConfig or buildFigmaConfig call was found (undefined if not checked) */
     hasBuildConfig?: boolean;
+    /** Whether there are other imports from 'payload' besides buildConfig (e.g., types) */
     hasOtherPayloadImports: boolean;
+    /** Whether the import needs to be changed from 'payload' to '@payloadcms/figma' */
     needsImportChange: boolean;
+    /** Whether a `secret` property exists in the config */
     secretProperty?: boolean;
+    /** Sharp configuration if present */
+    sharpProperty?: {
+        /** NPM package sharp is imported from (always 'sharp') */
+        importSource: string;
+    };
 };
 /**
  * Detect what changes are needed in the payload config file
@@ -29,9 +49,8 @@ export type ASTModificationResult = {
  */
 export declare function applyModifications(sourceFile: SourceFile, detection: DetectionResult): ASTModificationResult;
 export type FigmaPropertyConfig = {
-    region: string;
-    tenantId: string;
-    useContentSystem: boolean;
+    contentSystemId: string;
+    useContentSystem?: boolean;
 };
 /**
  * Add figma property to buildConfig if it doesn't exist
@@ -39,8 +58,9 @@ export type FigmaPropertyConfig = {
  */
 export declare function addFigmaProperty(sourceFile: SourceFile, config: FigmaPropertyConfig): ASTModificationResult;
 /**
- * Read figma configuration from payload.config.ts
- * Returns the figma object if it exists, null otherwise
+ * 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 readFigmaConfig(sourceFile: SourceFile): FigmaPropertyConfig | null;
-//# sourceMappingURL=payload-config-ast.d.ts.map
+export declare function removeFigmaContentSystemId(sourceFile: SourceFile): boolean;

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

@@ -9,9 +9,9 @@ import * as log from './log.js';
         hasOtherPayloadImports: false,
         needsImportChange: false
     };
-    // Find buildConfig import
+    // Find buildConfig import — prefer @payloadcms/figma (already migrated) over payload
     const imports = sourceFile.getImportDeclarations();
-    const payloadImport = imports.find((imp)=>imp.getModuleSpecifierValue() === 'payload' || imp.getModuleSpecifierValue() === '@payloadcms/figma');
+    const payloadImport = imports.find((imp)=>imp.getModuleSpecifierValue() === '@payloadcms/figma') || imports.find((imp)=>imp.getModuleSpecifierValue() === 'payload');
     if (!payloadImport) {
         log.debug('No payload or @payloadcms/figma import found');
         result.hasBuildConfig = false;
@@ -20,15 +20,18 @@ import * as log from './log.js';
     log.debug(`Found import from: ${payloadImport.getModuleSpecifierValue()}`);
     const moduleSpecifier = payloadImport.getModuleSpecifierValue();
     const namedImports = payloadImport.getNamedImports();
-    // Check if buildConfig is imported
-    const buildConfigImport = namedImports.find((ni)=>ni.getName() === 'buildConfig');
+    // Determine which function name to look for based on the import source
+    // - From 'payload': look for buildConfig (needs migration)
+    // - From '@payloadcms/figma': look for buildFigmaConfig (already migrated)
+    const expectedFunctionName = moduleSpecifier === 'payload' ? 'buildConfig' : 'buildFigmaConfig';
+    const buildConfigImport = namedImports.find((ni)=>ni.getName() === expectedFunctionName);
     if (!buildConfigImport) {
         result.hasBuildConfig = false;
         return result;
     }
     // Check for alias and get the actual name used in code
     const aliasNode = buildConfigImport.getAliasNode();
-    const buildConfigName = aliasNode ? aliasNode.getText() : 'buildConfig';
+    const buildConfigName = aliasNode ? aliasNode.getText() : expectedFunctionName;
     if (aliasNode) {
         result.hasAlias = true;
     }
@@ -109,6 +112,15 @@ import * as log from './log.js';
             }
         }
     }
+    // Check for sharp property
+    const sharpProperty = configArg.getProperty('sharp');
+    if (sharpProperty) {
+        // Find the import source for sharp
+        const sharpImport = imports.find((imp)=>imp.getModuleSpecifierValue() === 'sharp' || imp.getNamedImports().some((ni)=>ni.getName() === 'sharp'));
+        result.sharpProperty = {
+            importSource: sharpImport?.getModuleSpecifierValue() || 'sharp'
+        };
+    }
     // Check for figma property
     const figmaProperty = configArg.getProperty('figma');
     if (figmaProperty) {
@@ -145,9 +157,27 @@ import * as log from './log.js';
     // Remove duplicates and sort in reverse order to avoid position shifts
     const uniqueRanges = Array.from(new Set(ranges.map((r)=>JSON.stringify(r)))).map((r)=>JSON.parse(r));
     uniqueRanges.sort((a, b)=>b[0] - a[0]);
-    // Remove each comment range
+    // Remove each comment range, extending to the full line when the comment is the only content
     for (const [pos, end] of uniqueRanges){
-        sourceFile.removeText(pos, end);
+        const fullText = sourceFile.getFullText();
+        let removeStart = pos;
+        let removeEnd = end;
+        // Find the start of the line containing this comment
+        let lineStart = pos;
+        while(lineStart > 0 && fullText[lineStart - 1] !== '\n'){
+            lineStart--;
+        }
+        const beforeComment = fullText.substring(lineStart, pos);
+        const nextNewline = fullText.indexOf('\n', end);
+        const afterComment = fullText.substring(end, nextNewline === -1 ? fullText.length : nextNewline);
+        // If the comment is the only content on this line, remove the entire line
+        if (beforeComment.trim() === '' && afterComment.trim() === '') {
+            removeStart = lineStart > 0 ? lineStart - 1 : lineStart;
+            if (nextNewline !== -1) {
+                removeEnd = nextNewline + 1;
+            }
+        }
+        sourceFile.removeText(removeStart, removeEnd);
     }
     return true;
 }
@@ -240,7 +270,16 @@ import * as log from './log.js';
             modified = true;
         }
     }
-    // 4. Update buildConfig import
+    // 4. Remove sharp property
+    if (detection.sharpProperty) {
+        const sharpProperty = configArg.getProperty('sharp');
+        if (sharpProperty) {
+            sharpProperty.remove();
+            changes.push('Removed sharp property');
+            modified = true;
+        }
+    }
+    // 5. Update buildConfig import
     if (detection.needsImportChange) {
         if (payloadImport) {
             if (detection.hasOtherPayloadImports) {
@@ -258,19 +297,38 @@ import * as log from './log.js';
                 sourceFile.addImportDeclaration({
                     moduleSpecifier: '@payloadcms/figma',
                     namedImports: [
-                        'buildConfig'
+                        'buildFigmaConfig'
                     ]
                 });
+                // Rename all usages of 'buildConfig' to 'buildFigmaConfig'
+                const identifiers = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier);
+                identifiers.forEach((identifier)=>{
+                    if (identifier.getText() === 'buildConfig') {
+                        identifier.replaceWithText('buildFigmaConfig');
+                    }
+                });
                 changes.push('Split buildConfig import to @payloadcms/figma');
             } else {
-                // Replace entire import
+                // Replace entire import: change module specifier and rename all references
+                const buildConfigImport = payloadImport.getNamedImports().find((ni)=>ni.getName() === 'buildConfig');
+                if (buildConfigImport) {
+                    // Change the import name
+                    buildConfigImport.setName('buildFigmaConfig');
+                    // Find and rename all usages of 'buildConfig' in the file
+                    const identifiers = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier);
+                    identifiers.forEach((identifier)=>{
+                        if (identifier.getText() === 'buildConfig') {
+                            identifier.replaceWithText('buildFigmaConfig');
+                        }
+                    });
+                }
                 payloadImport.setModuleSpecifier('@payloadcms/figma');
                 changes.push('Changed buildConfig import to @payloadcms/figma');
             }
             modified = true;
         }
     }
-    // 5. Remove orphaned imports
+    // 6. Remove orphaned imports
     // Re-fetch imports after each removal to avoid stale references
     if (detection.dbProperty) {
         const currentImports = sourceFile.getImportDeclarations();
@@ -290,6 +348,15 @@ import * as log from './log.js';
             modified = true;
         }
     }
+    if (detection.sharpProperty) {
+        const currentImports = sourceFile.getImportDeclarations();
+        const sharpImport = currentImports.find((imp)=>imp.getModuleSpecifierValue() === 'sharp');
+        if (sharpImport) {
+            sharpImport.remove();
+            changes.push('Removed sharp import');
+            modified = true;
+        }
+    }
     return {
         changes,
         modified
@@ -301,15 +368,15 @@ import * as log from './log.js';
  */ export function addFigmaProperty(sourceFile, config) {
     const changes = [];
     let modified = false;
-    // Find buildConfig call
+    // Find buildFigmaConfig call (this function is only used with Figma configs)
     const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
     const buildConfigCall = callExpressions.find((ce)=>{
         const expr = ce.getExpression();
         const text = expr.getText();
-        return text === 'buildConfig' || text.endsWith('.buildConfig');
+        return text === 'buildFigmaConfig' || text.endsWith('.buildFigmaConfig');
     });
     if (!buildConfigCall) {
-        log.debug('No buildConfig call found');
+        log.debug('No buildFigmaConfig call found');
         return {
             changes: [],
             modified: false
@@ -336,15 +403,14 @@ import * as log from './log.js';
         };
     }
     // Add figma property
+    // contentSystemId is resolved automatically by buildFigmaConfig from env vars or bootstrap cache.
+    // useContentSystem defaults to true, so we only generate it when explicitly false.
+    const figmaObj = config.useContentSystem === false ? `{\nuseContentSystem: false,\n}` : '{}';
     configArg.addPropertyAssignment({
         name: 'figma',
-        initializer: `{
-    region: '${config.region}',
-    tenantId: '${config.tenantId}',
-    useContentSystem: ${config.useContentSystem},
-  }`
+        initializer: figmaObj
     });
-    changes.push(`Added figma property (region: ${config.region}, tenantId: ${config.tenantId}, useContentSystem: ${config.useContentSystem})`);
+    changes.push(`Added figma property (contentSystemId: ${config.contentSystemId})`);
     modified = true;
     return {
         changes,
@@ -352,60 +418,40 @@ import * as log from './log.js';
     };
 }
 /**
- * Read figma configuration from payload.config.ts
- * Returns the figma object if it exists, null otherwise
- */ export function readFigmaConfig(sourceFile) {
-    // Find buildConfig call
+ * 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 === 'buildConfig' || text.endsWith('.buildConfig');
+        return text === 'buildFigmaConfig' || text.endsWith('.buildFigmaConfig');
     });
     if (!buildConfigCall) {
-        log.debug('No buildConfig call found');
-        return null;
+        return false;
     }
-    // Get config object argument
     const configArg = buildConfigCall.getArguments()[0];
     if (!configArg || !Node.isObjectLiteralExpression(configArg)) {
-        log.debug('buildConfig argument is not an object literal');
-        return null;
+        return false;
     }
-    // Find figma property
     const figmaProperty = configArg.getProperty('figma');
     if (!figmaProperty || !Node.isPropertyAssignment(figmaProperty)) {
-        log.debug('No figma property found in buildConfig');
-        return null;
+        return false;
     }
-    // Get initializer (the object value)
     const initializer = figmaProperty.getInitializer();
     if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
-        log.debug('figma property is not an object literal');
-        return null;
-    }
-    // Extract values
-    const regionProp = initializer.getProperty('region');
-    const tenantIdProp = initializer.getProperty('tenantId');
-    const useContentSystemProp = initializer.getProperty('useContentSystem');
-    if (!regionProp || !tenantIdProp) {
-        log.debug('Missing required figma properties (region or tenantId)');
-        return null;
-    }
-    // Extract string values (remove quotes)
-    const region = Node.isPropertyAssignment(regionProp) ? regionProp.getInitializer()?.getText().replace(/['"]/g, '') : undefined;
-    const tenantId = Node.isPropertyAssignment(tenantIdProp) ? tenantIdProp.getInitializer()?.getText().replace(/['"]/g, '') : undefined;
-    const useContentSystem = Node.isPropertyAssignment(useContentSystemProp) ? useContentSystemProp.getInitializer()?.getText() === 'true' : true // Default to true if not specified
-    ;
-    if (!region || !tenantId) {
-        log.debug('Could not extract region or tenantId values');
-        return null;
+        return false;
     }
-    return {
-        region,
-        tenantId,
-        useContentSystem
-    };
+    const contentSystemIdProp = initializer.getProperty('contentSystemId');
+    if (!contentSystemIdProp) {
+        return false;
+    }
+    contentSystemIdProp.remove();
+    // Collapse empty object to avoid ts-morph whitespace artifacts
+    if (initializer.getProperties().length === 0) {
+        initializer.replaceWithText('{}');
+    }
+    return true;
 }
-
-//# sourceMappingURL=payload-config-ast.js.map

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

@@ -1,9 +1,8 @@
 /**
- * Find the Payload config file using Payload's built-in finder
- * Changes to project directory temporarily and restores afterward
+ * Find the Payload config file using Payload's built-in finder when available,
+ * with fallback to simple file search for npx environments where payload isn't installed.
  *
  * @param projectPath - Absolute path to project directory
  * @returns Absolute path to config file, or null if not found
  */
 export declare function findPayloadConfig(projectPath: string): Promise<null | string>;
-//# sourceMappingURL=payload-config-finder.d.ts.map

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

@@ -1,26 +1,63 @@
-import { findConfig } from 'payload/node';
+import fs from 'fs/promises';
+import path from 'path';
+import * as log from './log.js';
+// Standard Payload config file names in priority order
+const CONFIG_FILES = [
+    'payload.config.ts',
+    'payload.config.js',
+    'src/payload.config.ts',
+    'src/payload.config.js'
+];
 /**
- * Find the Payload config file using Payload's built-in finder
- * Changes to project directory temporarily and restores afterward
+ * Find the Payload config file using Payload's built-in finder when available,
+ * with fallback to simple file search for npx environments where payload isn't installed.
  *
  * @param projectPath - Absolute path to project directory
  * @returns Absolute path to config file, or null if not found
  */ export async function findPayloadConfig(projectPath) {
+    // First, try using Payload's official config finder (if payload is installed)
+    const configFromPayload = await findConfigWithPayload(projectPath);
+    if (configFromPayload) {
+        return configFromPayload;
+    }
+    // Fallback: Simple file search for standard config locations
+    // This works when running via npx before payload is installed
+    log.debug('Payload not available, using fallback config finder');
+    return findConfigFallback(projectPath);
+}
+/**
+ * Try to find config using Payload's findConfig function.
+ * Returns null if payload is not installed (dynamic import fails).
+ */ async function findConfigWithPayload(projectPath) {
     const originalCwd = process.cwd();
     try {
+        // Dynamic import - will fail gracefully if payload is not installed
+        const { findConfig } = await import('payload/node');
         // findConfig requires being in the project directory
         process.chdir(projectPath);
-        // Use Payload's official config finder
         const configPath = findConfig();
-        // Wrap in Promise.resolve to satisfy async requirement
-        return await Promise.resolve(configPath || null);
-    } catch  {
-        // Config not found or error occurred
+        return configPath || null;
+    } catch (error) {
+        // payload not installed or other error - return null to use fallback
+        log.debug(`Could not use Payload findConfig: ${error instanceof Error ? error.message : 'unknown'}`);
         return null;
     } finally{
-        // Always restore original working directory
         process.chdir(originalCwd);
     }
 }
-
-//# sourceMappingURL=payload-config-finder.js.map
+/**
+ * Fallback config finder that checks standard locations.
+ * Used when payload is not installed (e.g., running via npx).
+ */ async function findConfigFallback(projectPath) {
+    for (const configFile of CONFIG_FILES){
+        const fullPath = path.join(projectPath, configFile);
+        try {
+            await fs.access(fullPath);
+            log.debug(`Found config at: ${fullPath}`);
+            return fullPath;
+        } catch  {
+        // File doesn't exist, try next
+        }
+    }
+    return null;
+}

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

@@ -15,5 +15,4 @@ export declare function ensurePayloadFigmaConfig(projectPath: string, packageMan
 /**
  * Display manual configuration instructions
  */
-export declare function displayManualInstructions(reason: string): void;
-//# sourceMappingURL=payload-config-modifier.d.ts.map
+export declare function displayManualInstructions(reason: string, packageManager?: PackageManager): void;