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

package/dist/types.d.ts

@@ -1,13 +1,23 @@
 import type arg from 'arg';
 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;
+    '--template': StringConstructor;
     '--yes': BooleanConstructor;
+    '-e': string;
     '-f': string;
     '-h': string;
+    '-n': string;
+    '-t': string;
     '-y': string;
 }
 export type CliArgs = arg.Result<Args>;
@@ -37,7 +47,6 @@ interface Template {
     name: string;
     type: ProjectTemplate['type'];
 }
-export type PackageManager = 'bun' | 'npm' | 'pnpm' | 'yarn';
 export type DbType = 'd1-sqlite' | 'mongodb' | 'postgres' | 'sqlite' | 'vercel-postgres';
 export type DbDetails = {
     dbUri?: string;
@@ -57,4 +66,3 @@ export type NextAppDetails = {
 export type NextConfigType = 'cjs' | 'esm' | 'ts';
 export type StorageAdapterType = 'localDisk' | 'r2Storage' | 'vercelBlobStorage';
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,3 +1 @@
 export { };
-
-//# sourceMappingURL=types.js.map

package/dist/utils/adapters/nextjs.d.ts

@@ -0,0 +1,8 @@
+import type { AssetCollection, DeployAdapter, LambdaBundle, PageCollection } from '../deploy-adapter.js';
+export declare class NextjsAdapter implements DeployAdapter {
+    name: "nextjs";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string): Promise<LambdaBundle>;
+}
+export declare const nextjsAdapter: NextjsAdapter;

package/dist/utils/adapters/nextjs.js

@@ -0,0 +1,61 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { collectSSGAssets, collectStaticAssets } from '../asset-collection.js';
+import { buildLambdaZip } from '../build-lambda-zip.js';
+import { collectFilesRecursive } from '../fs-utils.js';
+export class NextjsAdapter {
+    name = 'nextjs';
+    async collectAssets(projectPath) {
+        // Bundle assets: .next/static/ → _next/static/
+        const staticAssets = await collectStaticAssets(projectPath);
+        // Public assets: public/ directory
+        const publicDir = path.join(projectPath, 'public');
+        let publicAssets = [];
+        try {
+            await fs.stat(publicDir);
+            publicAssets = await collectFilesRecursive(publicDir, publicDir);
+        } catch  {
+        // No public directory
+        }
+        const allKeys = [
+            ...staticAssets,
+            ...publicAssets
+        ];
+        const pathMap = {};
+        for (const key of staticAssets){
+            pathMap[key] = key.replace(/^_next\//, '.next/');
+        }
+        for (const key of publicAssets){
+            pathMap[key] = path.join('public', key);
+        }
+        return {
+            pathMap,
+            routes: allKeys.map((k)=>`/${k}`),
+            uploadKeys: allKeys
+        };
+    }
+    async collectPages(projectPath) {
+        const ssg = await collectSSGAssets(projectPath);
+        // Build route → asset keys mapping and extract unique routes
+        const routeAssetMap = {};
+        for (const key of ssg.keys){
+            // Strip extension to get the base, then derive the route
+            const base = key.replace(/\.(?:html|rsc|meta)$/, '');
+            const route = base === 'index' ? '/' : `/${base}`;
+            if (!routeAssetMap[route]) {
+                routeAssetMap[route] = [];
+            }
+            routeAssetMap[route].push(key);
+        }
+        return {
+            pathMap: ssg.pathMap,
+            routeAssetMap,
+            routes: Object.keys(routeAssetMap),
+            uploadKeys: ssg.keys
+        };
+    }
+    async prepareLambdaBundle(projectPath) {
+        return buildLambdaZip(projectPath);
+    }
+}
+export const nextjsAdapter = new NextjsAdapter();

package/dist/utils/adapters/nitro.d.ts

@@ -0,0 +1,8 @@
+import type { AssetCollection, DeployAdapter, LambdaBundle, PageCollection } from '../deploy-adapter.js';
+export declare class NitroAdapter implements DeployAdapter {
+    name: "nitro";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string): Promise<LambdaBundle>;
+}
+export declare const nitroAdapter: NitroAdapter;

package/dist/utils/adapters/nitro.js

@@ -0,0 +1,172 @@
+import archiver from 'archiver';
+import { createWriteStream, statSync } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+import { collectFilesRecursive, getDirectorySize } from '../fs-utils.js';
+const RUN_SCRIPT = `#!/bin/bash -x
+[ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
+NODE_ENV=production exec node server/index.mjs
+`;
+/** Directories in .output/public/ that are NOT pre-rendered pages */ const NON_PAGE_DIRS = new Set([
+    '_next',
+    'assets'
+]);
+export class NitroAdapter {
+    name = 'nitro';
+    async collectAssets(projectPath) {
+        const publicDir = path.join(projectPath, '.output', 'public');
+        const assets = [];
+        const pathMap = {};
+        // Collect flat files in .output/public/ (public dir assets)
+        try {
+            const entries = await fs.readdir(publicDir, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                if (entry.isFile()) {
+                    assets.push(entry.name);
+                    pathMap[entry.name] = path.join('.output', 'public', entry.name);
+                }
+            }
+        } catch  {
+        // No public directory
+        }
+        // Collect bundle assets from .output/public/_next/static/
+        const bundleDir = path.join(publicDir, '_next', 'static');
+        try {
+            const bundleFiles = await collectFilesRecursive(bundleDir, bundleDir);
+            for (const file of bundleFiles){
+                const key = `_next/static/${file}`;
+                assets.push(key);
+                pathMap[key] = path.join('.output', 'public', '_next', 'static', file);
+            }
+        } catch  {
+        // No bundle directory
+        }
+        return {
+            pathMap,
+            routes: assets.map((k)=>`/${k}`),
+            uploadKeys: assets
+        };
+    }
+    async collectPages(projectPath) {
+        const publicDir = path.join(projectPath, '.output', 'public');
+        const pages = await scanForPages(publicDir, publicDir);
+        const routes = pages.map((p)=>p === 'index' ? '/' : `/${p}`);
+        const uploadKeys = pages.map((p)=>p === 'index' ? 'index.html' : `${p}/index.html`);
+        const pathMap = {};
+        const routeAssetMap = {};
+        for(let i = 0; i < uploadKeys.length; i++){
+            pathMap[uploadKeys[i]] = path.join('.output', 'public', uploadKeys[i]);
+            routeAssetMap[routes[i]] = [
+                uploadKeys[i]
+            ];
+        }
+        return {
+            pathMap,
+            routeAssetMap,
+            routes,
+            uploadKeys
+        };
+    }
+    async prepareLambdaBundle(projectPath) {
+        const zipPath = path.join(projectPath, 'lambda.zip');
+        const serverDir = path.join(projectPath, '.output', 'server');
+        const publicDir = path.join(projectPath, '.output', 'public');
+        // Verify server directory exists
+        try {
+            await fs.stat(serverDir);
+        } catch  {
+            throw new Error('Nitro server build not found at .output/server. Run build first.');
+        }
+        // Write run.sh to a temp location
+        const runShPath = path.join(projectPath, '.output', 'run.sh');
+        await fs.writeFile(runShPath, RUN_SCRIPT, {
+            mode: 0o755
+        });
+        // Create zip: server/ + public/ + run.sh
+        await createZip(zipPath, [
+            {
+                prefix: 'server/',
+                source: serverDir
+            },
+            {
+                prefix: 'public/',
+                source: publicDir
+            },
+            {
+                prefix: '',
+                source: runShPath
+            }
+        ]);
+        const runShStat = await fs.stat(runShPath);
+        const unzippedBytes = await getDirectorySize(serverDir) + await getDirectorySize(publicDir) + runShStat.size;
+        // Clean up temp run.sh
+        await fs.rm(runShPath, {
+            force: true
+        });
+        return {
+            unzippedBytes,
+            zipPath
+        };
+    }
+}
+export const nitroAdapter = new NitroAdapter();
+/**
+ * Recursively scan for pre-rendered pages (directories containing index.html).
+ * Skips known non-page directories (_next/, assets/).
+ */ async function scanForPages(dir, baseDir) {
+    const pages = [];
+    // Check if this directory has an index.html (it's a page)
+    const indexPath = path.join(dir, 'index.html');
+    try {
+        await fs.stat(indexPath);
+        const relative = path.relative(baseDir, dir);
+        pages.push(relative || 'index'); // root dir -> 'index'
+    } catch  {
+    // Not a page directory
+    }
+    // Recurse into subdirectories
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isDirectory() && !NON_PAGE_DIRS.has(entry.name)) {
+                const subPages = await scanForPages(path.join(dir, entry.name), baseDir);
+                pages.push(...subPages);
+            }
+        }
+    } catch  {
+    // Directory not readable
+    }
+    return pages;
+}
+async function createZip(zipPath, entries) {
+    return new Promise((resolve, reject)=>{
+        const output = createWriteStream(zipPath);
+        const archive = archiver('zip', {
+            zlib: {
+                level: 9
+            }
+        });
+        output.on('close', ()=>resolve());
+        archive.on('error', (err)=>reject(err));
+        archive.pipe(output);
+        for (const entry of entries){
+            try {
+                const stat = statSync(entry.source);
+                if (stat.isDirectory()) {
+                    archive.directory(entry.source, entry.prefix.replace(/\/$/, '') || false);
+                } else {
+                    archive.file(entry.source, {
+                        name: entry.prefix + path.basename(entry.source)
+                    });
+                }
+            } catch  {
+            // Skip missing entries
+            }
+        }
+        void archive.finalize();
+    });
+}

package/dist/utils/adapters/vite.d.ts

@@ -0,0 +1,9 @@
+import type { AssetCollection, DeployAdapter, LambdaBundle, PageCollection } from '../deploy-adapter.js';
+export declare class ViteAdapter implements DeployAdapter {
+    fallback: string;
+    name: "vite";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(): Promise<PageCollection>;
+    prepareLambdaBundle(): Promise<LambdaBundle | null>;
+}
+export declare const viteAdapter: ViteAdapter;

package/dist/utils/adapters/vite.js

@@ -0,0 +1,31 @@
+import path from 'path';
+import { collectFilesRecursive } from '../fs-utils.js';
+export class ViteAdapter {
+    fallback = '/index.html';
+    name = 'vite';
+    async collectAssets(projectPath) {
+        const distDir = path.join(projectPath, 'dist');
+        const files = await collectFilesRecursive(distDir, distDir);
+        const pathMap = {};
+        for (const file of files){
+            pathMap[file] = path.join('dist', file);
+        }
+        return {
+            pathMap,
+            routes: files.map((k)=>`/${k}`),
+            uploadKeys: files
+        };
+    }
+    collectPages() {
+        return Promise.resolve({
+            pathMap: {},
+            routeAssetMap: {},
+            routes: [],
+            uploadKeys: []
+        });
+    }
+    prepareLambdaBundle() {
+        return Promise.resolve(null);
+    }
+}
+export const viteAdapter = new ViteAdapter();

package/dist/utils/asset-collection.d.ts

@@ -16,15 +16,35 @@ export declare function getFileSize(filePath: string): Promise<number>;
  */
 export declare function collectStaticAssets(projectPath: string): Promise<string[]>;
 /**
- * Create Lambda deployment zip using build_for_lambda.sh
+ * Result from collecting SSG assets
+ */
+export type SSGAssets = {
+    /** S3 keys for all SSG files (route-path based, no leading slash) */
+    keys: string[];
+    /** Map of S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+};
+/**
+ * Collect SSG asset paths by parsing .next/prerender-manifest.json
+ *
+ * For each route in the manifest's `routes` object, collects three files:
+ * - {route}.html  (full HTML)
+ * - {route}.rsc   (React Server Components payload)
+ * - {route}.meta  (response headers JSON)
+ *
+ * S3 keys use the route path without leading slash.
+ * Filesystem paths point to .next/server/app/{route}.{ext}
+ *
+ * @param projectPath - Path to project root
+ * @returns SSG asset keys and a pathMap for filesystem resolution
+ */
+export declare function collectSSGAssets(projectPath: string): Promise<SSGAssets>;
+/**
+ * Create Lambda deployment zip
  *
- * This script:
- * - Copies static files to standalone build
- * - Creates lambda.zip from .next/standalone/
- * - Places zip at project root
+ * Uses cross-platform Node.js implementation instead of shell script.
  *
  * @param projectPath - Path to project root
- * @throws Error if script missing or execution fails
+ * @throws Error if build missing or zip creation fails
  */
 export declare function createLambdaZip(projectPath: string): Promise<void>;
-//# sourceMappingURL=asset-collection.d.ts.map

package/dist/utils/asset-collection.js

@@ -1,9 +1,7 @@
-import { exec } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
-import { promisify } from 'util';
+import { buildLambdaZip } from './build-lambda-zip.js';
 import * as log from './log.js';
-const execAsync = promisify(exec);
 // Maximum file size for static assets (S3 limitation)
 const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
 ;
@@ -75,43 +73,72 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
         return [];
     }
     const files = await collectFiles(staticDir, projectPath);
-    // Convert .next/static to _next/static (Next.js convention)
-    return files.map((file)=>file.replace(/^\.next\//, '_next/'));
+    // Normalize paths to forward slashes (cross-platform) and convert prefix
+    return files.map((file)=>{
+        const normalized = file.split(path.sep).join('/');
+        return normalized.replace(/^\.next\//, '_next/');
+    });
 }
 /**
- * Create Lambda deployment zip using build_for_lambda.sh
+ * Collect SSG asset paths by parsing .next/prerender-manifest.json
  *
- * This script:
- * - Copies static files to standalone build
- * - Creates lambda.zip from .next/standalone/
- * - Places zip at project root
+ * For each route in the manifest's `routes` object, collects three files:
+ * - {route}.html  (full HTML)
+ * - {route}.rsc   (React Server Components payload)
+ * - {route}.meta  (response headers JSON)
+ *
+ * S3 keys use the route path without leading slash.
+ * Filesystem paths point to .next/server/app/{route}.{ext}
  *
  * @param projectPath - Path to project root
- * @throws Error if script missing or execution fails
- */ export async function createLambdaZip(projectPath) {
-    const scriptPath = path.join(projectPath, 'build_for_lambda.sh');
-    // Check if script exists
+ * @returns SSG asset keys and a pathMap for filesystem resolution
+ */ export async function collectSSGAssets(projectPath) {
+    const manifestPath = path.join(projectPath, '.next', 'prerender-manifest.json');
+    let manifest;
     try {
-        await fs.stat(scriptPath);
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        manifest = JSON.parse(raw);
     } catch  {
-        throw new Error('build_for_lambda.sh not found. Run init command to set up project.');
+        return {
+            keys: [],
+            pathMap: {}
+        };
     }
-    // Execute script
-    try {
-        await execAsync('./build_for_lambda.sh', {
-            cwd: projectPath
-        });
-    } catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        throw new Error(`Failed to create Lambda zip: ${message}`);
+    if (!manifest.routes || typeof manifest.routes !== 'object') {
+        return {
+            keys: [],
+            pathMap: {}
+        };
     }
-    // Verify zip was created
-    const zipPath = path.join(projectPath, 'lambda.zip');
-    try {
-        await fs.stat(zipPath);
-    } catch  {
-        throw new Error('lambda.zip was not created by build_for_lambda.sh');
+    const keys = [];
+    const pathMap = {};
+    const extensions = [
+        '.html',
+        '.rsc',
+        '.meta'
+    ];
+    for (const routeKey of Object.keys(manifest.routes)){
+        // Strip leading slash for S3 key; handle root "/" → "index"
+        const stripped = routeKey === '/' ? 'index' : routeKey.replace(/^\//, '');
+        for (const ext of extensions){
+            const s3Key = `${stripped}${ext}`;
+            const fsPath = path.join('.next', 'server', 'app', `${stripped}${ext}`);
+            keys.push(s3Key);
+            pathMap[s3Key] = fsPath;
+        }
     }
+    return {
+        keys,
+        pathMap
+    };
+}
+/**
+ * Create Lambda deployment zip
+ *
+ * Uses cross-platform Node.js implementation instead of shell script.
+ *
+ * @param projectPath - Path to project root
+ * @throws Error if build missing or zip creation fails
+ */ export async function createLambdaZip(projectPath) {
+    await buildLambdaZip(projectPath);
 }
-
-//# sourceMappingURL=asset-collection.js.map

package/dist/utils/build-detection.d.ts

@@ -2,24 +2,18 @@
  * Information about a detected build
  */
 export interface BuildInfo {
-    /** Build ID from .next/BUILD_ID */
+    /** Build identifier */
     buildId: string;
     /** Whether lambda.zip already exists */
     hasLambdaZip: boolean;
-    /** Path to .next/standalone */
+    /** Path to build output directory */
     path: string;
-    /** Build timestamp from server.js mtime */
+    /** Build timestamp */
     timestamp: Date;
 }
 /**
- * Detect if a valid Lambda-ready build exists
- *
- * Checks for:
- * - .next/standalone/server.js (required for Lambda)
- * - .next/BUILD_ID (Next.js build identifier)
- *
- * @param projectPath - Path to project root
- * @returns Build info if valid build found, null otherwise
+ * Detect a valid build across supported frameworks.
+ * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */
 export declare function detectBuild(projectPath: string): Promise<BuildInfo | null>;
 /**
@@ -29,4 +23,3 @@ export declare function detectBuild(projectPath: string): Promise<BuildInfo | nu
  * @returns Build command string if found, null otherwise
  */
 export declare function getBuildCommand(projectPath: string): Promise<null | string>;
-//# sourceMappingURL=build-detection.d.ts.map

package/dist/utils/build-detection.js

@@ -1,23 +1,34 @@
 import fs from 'fs/promises';
 import path from 'path';
 /**
- * Detect if a valid Lambda-ready build exists
- *
- * Checks for:
- * - .next/standalone/server.js (required for Lambda)
- * - .next/BUILD_ID (Next.js build identifier)
- *
- * @param projectPath - Path to project root
- * @returns Build info if valid build found, null otherwise
+ * Detect a valid build across supported frameworks.
+ * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */ export async function detectBuild(projectPath) {
+    // Try NextJS first
+    const nextjsBuild = await detectNextjsBuild(projectPath);
+    if (nextjsBuild) {
+        return nextjsBuild;
+    }
+    // Try Nitro
+    const nitroBuild = await detectNitroBuild(projectPath);
+    if (nitroBuild) {
+        return nitroBuild;
+    }
+    // Try Vite
+    const viteBuild = await detectViteBuild(projectPath);
+    if (viteBuild) {
+        return viteBuild;
+    }
+    return null;
+}
+/**
+ * Detect NextJS standalone build (.next/standalone/server.js + .next/BUILD_ID)
+ */ async function detectNextjsBuild(projectPath) {
     try {
-        // Check for .next/standalone/server.js
         const serverPath = path.join(projectPath, '.next', 'standalone', 'server.js');
         const serverStat = await fs.stat(serverPath);
-        // Check for .next/BUILD_ID
         const buildIdPath = path.join(projectPath, '.next', 'BUILD_ID');
         const buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();
-        // Check for lambda.zip
         const lambdaZipPath = path.join(projectPath, 'lambda.zip');
         let hasLambdaZip = false;
         try {
@@ -36,6 +47,58 @@ import path from 'path';
         return null;
     }
 }
+/**
+ * Detect Nitro build (.output/server/index.mjs)
+ * Build ID parsed from .output/nitro.json date field, or mtime of index.mjs
+ */ async function detectNitroBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, '.output', 'server', 'index.mjs');
+        const indexStat = await fs.stat(indexPath);
+        let buildId = indexStat.mtime.toISOString();
+        try {
+            const nitroJsonPath = path.join(projectPath, '.output', 'nitro.json');
+            const nitroJson = JSON.parse(await fs.readFile(nitroJsonPath, 'utf-8'));
+            if (nitroJson.date) {
+                buildId = nitroJson.date;
+            }
+        } catch  {
+        // nitro.json missing or unparseable — fall back to mtime
+        }
+        const lambdaZipPath = path.join(projectPath, 'lambda.zip');
+        let hasLambdaZip = false;
+        try {
+            await fs.stat(lambdaZipPath);
+            hasLambdaZip = true;
+        } catch  {
+            hasLambdaZip = false;
+        }
+        return {
+            buildId,
+            hasLambdaZip,
+            path: '.output',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Detect Vite build (dist/index.html)
+ * Build ID is mtime of index.html as ISO string. No server, so hasLambdaZip is always false.
+ */ async function detectViteBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, 'dist', 'index.html');
+        const indexStat = await fs.stat(indexPath);
+        return {
+            buildId: indexStat.mtime.toISOString(),
+            hasLambdaZip: false,
+            path: 'dist',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
 /**
  * Get the build command from package.json
  *
@@ -51,5 +114,3 @@ import path from 'path';
         return null;
     }
 }
-
-//# sourceMappingURL=build-detection.js.map

package/dist/utils/build-lambda-zip.d.ts

@@ -0,0 +1,25 @@
+import type { LambdaBundle } from './deploy-adapter.js';
+/**
+ * AWS Lambda's hard limit on unzipped deployment code size (250 MB). The unzipped
+ * total must be strictly less than this value, so a bundle exactly equal to it is
+ * rejected. The server enforces this too and now returns a clear message, so a
+ * client-side check against this value is an early-exit convenience, not the
+ * source of truth.
+ */
+export declare const LAMBDA_MAX_UNZIPPED_BYTES: number;
+/**
+ * Build Lambda deployment zip using pure Node.js
+ *
+ * Cross-platform replacement for build_for_lambda.sh:
+ * 1. Copies .next/static to .next/standalone/.next/static
+ * 2. Copies run.sh to .next/standalone/run.sh
+ * 3. Creates lambda.zip from .next/standalone/
+ *
+ * Note: public/ is NOT included in the zip — those files are uploaded
+ * as static assets and served via CDN, not from the Lambda function.
+ *
+ * @param projectPath - Path to project root
+ * @returns The built bundle: its unzipped byte size and the absolute zip path.
+ * @throws Error if standalone directory missing or zip creation fails
+ */
+export declare function buildLambdaZip(projectPath: string): Promise<LambdaBundle>;