@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.50

package/dist/storage-content-api/handleUpload.js

@@ -0,0 +1,144 @@
+import fs from 'fs';
+import path from 'path';
+const PART_SIZE = 64 * 1024 * 1024 // 64MB per part
+;
+const MAX_FILE_SIZE_BEFORE_MULTIPART = 100 * 1024 * 1024 // 100MB
+;
+export const getHandleUpload = ({ client, collection, prefix = '' })=>{
+    return async ({ clientUploadContext, data, file })=>{
+        // Skip if client already uploaded THIS SPECIFIC file
+        // clientUploadContext.filename contains the original filename that was client-uploaded
+        // Resized versions (different filename) should still be uploaded
+        const clientUploadedFilename = clientUploadContext && typeof clientUploadContext === 'object' && 'filename' in clientUploadContext ? clientUploadContext.filename : undefined;
+        const isOriginalClientUploaded = clientUploadContext && typeof clientUploadContext === 'object' && 'clientUploaded' in clientUploadContext && clientUploadContext.clientUploaded && file.filename === clientUploadedFilename;
+        if (isOriginalClientUploaded) {
+            return data;
+        }
+        const collectionId = collection.slug;
+        const fileKey = path.posix.join(data.prefix || prefix, file.filename);
+        const fileData = file.tempFilePath ? fs.readFileSync(file.tempFilePath) : file.buffer;
+        const fileSize = file.filesize || fileData.length;
+        if (fileSize > MAX_FILE_SIZE_BEFORE_MULTIPART) {
+            await uploadMultipart({
+                client,
+                collectionId,
+                fileData,
+                fileKey,
+                mimeType: file.mimeType
+            });
+        } else {
+            await uploadSingleFile({
+                client,
+                collectionId,
+                fileData,
+                fileKey,
+                mimeType: file.mimeType
+            });
+        }
+        return data;
+    };
+};
+async function uploadSingleFile({ client, collectionId, fileData, fileKey, mimeType }) {
+    const { data, error } = await client.POST('/api/v0/uploads/sign', {
+        body: {
+            collectionId,
+            contentType: mimeType,
+            expiresIn: 3600,
+            filename: fileKey
+        }
+    });
+    if (error || !data) {
+        throw new Error(`Failed to get presigned upload URL: ${JSON.stringify(error)}`);
+    }
+    const uploadResponse = await fetch(data.url, {
+        body: fileData,
+        headers: {
+            'Content-Type': mimeType
+        },
+        method: 'PUT'
+    });
+    if (!uploadResponse.ok) {
+        throw new Error(`Failed to upload to S3: ${uploadResponse.status} ${uploadResponse.statusText}`);
+    }
+}
+async function uploadMultipart({ client, collectionId, fileData, fileKey, mimeType }) {
+    const { data: initiateData, error: initiateError } = await client.POST('/api/v0/uploads/multipart/initiate', {
+        body: {
+            collectionId,
+            contentType: mimeType,
+            filename: fileKey
+        }
+    });
+    if (initiateError || !initiateData) {
+        throw new Error(`Failed to initiate multipart upload: ${JSON.stringify(initiateError)}`);
+    }
+    const { uploadId } = initiateData;
+    try {
+        const numParts = Math.ceil(fileData.length / PART_SIZE);
+        const partNumbers = Array.from({
+            length: numParts
+        }, (_, i)=>i + 1);
+        const { data: partsData, error: partsError } = await client.POST('/api/v0/uploads/multipart/parts', {
+            body: {
+                collectionId,
+                expiresIn: 3600,
+                filename: fileKey,
+                partNumbers,
+                uploadId
+            }
+        });
+        if (partsError || !partsData) {
+            throw new Error(`Failed to get part URLs: ${JSON.stringify(partsError)}`);
+        }
+        const { parts } = partsData;
+        if (!parts || !Array.isArray(parts)) {
+            throw new Error('Invalid response from part URLs endpoint: parts is not an array');
+        }
+        const uploadedParts = await Promise.all(parts.map(async ({ partNumber, url })=>{
+            const start = (partNumber - 1) * PART_SIZE;
+            const end = Math.min(start + PART_SIZE, fileData.length);
+            const partData = fileData.slice(start, end);
+            const uploadResponse = await fetch(url, {
+                body: partData,
+                headers: {
+                    'Content-Type': mimeType
+                },
+                method: 'PUT'
+            });
+            const etag = uploadResponse.headers.get('ETag');
+            if (!etag) {
+                throw new Error(`No ETag returned for part ${partNumber}`);
+            }
+            return {
+                ETag: etag,
+                PartNumber: partNumber
+            };
+        }));
+        const { error: completeError } = await client.POST('/api/v0/uploads/multipart/complete', {
+            body: {
+                collectionId,
+                filename: fileKey,
+                parts: uploadedParts,
+                uploadId
+            }
+        });
+        if (completeError) {
+            throw new Error(`Failed to complete multipart upload: ${JSON.stringify(completeError)}`);
+        }
+    } catch (error) {
+        try {
+            await client.POST('/api/v0/uploads/multipart/abort', {
+                body: {
+                    collectionId,
+                    filename: fileKey,
+                    uploadId
+                }
+            });
+        } catch  {
+        // Ignore abort errors
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=handleUpload.js.map

package/dist/storage-content-api/index.d.ts

@@ -0,0 +1,5 @@
+import type { Adapter } from '@payloadcms/plugin-cloud-storage/types';
+import type { StorageClientConfig } from './types.js';
+export type { StorageClientConfig } from './types.js';
+export declare function contentApiStorageAdapter(config: StorageClientConfig): Adapter;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,31 @@
+import { createStorageClient } from './client.js';
+import { getGenerateURL } from './generateURL.js';
+import { getHandleDelete } from './handleDelete.js';
+import { getHandleUpload } from './handleUpload.js';
+import { getHandler } from './staticHandler.js';
+export function contentApiStorageAdapter(config) {
+    return ({ collection, prefix })=>{
+        const client = createStorageClient(config);
+        const baseUrl = config.baseUrl;
+        return {
+            name: 'content-api',
+            generateURL: getGenerateURL({
+                baseUrl
+            }),
+            handleDelete: getHandleDelete({
+                client
+            }),
+            handleUpload: getHandleUpload({
+                client,
+                collection,
+                prefix
+            }),
+            staticHandler: getHandler({
+                client,
+                collection
+            })
+        };
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/storage-content-api/staticHandler.d.ts

@@ -0,0 +1,10 @@
+import type { StaticHandler } from '@payloadcms/plugin-cloud-storage/types';
+import type { CollectionConfig } from 'payload';
+import type { StorageClient } from './client.js';
+type Args = {
+    client: StorageClient;
+    collection: CollectionConfig;
+};
+export declare const getHandler: ({ client, collection }: Args) => StaticHandler;
+export {};
+//# sourceMappingURL=staticHandler.d.ts.map

package/dist/storage-content-api/staticHandler.js

@@ -0,0 +1,56 @@
+import { getFilePrefix } from '@payloadcms/plugin-cloud-storage/utilities';
+import path from 'path';
+export const getHandler = ({ client, collection })=>{
+    return async (req, { params: { clientUploadContext, filename } })=>{
+        try {
+            const prefix = await getFilePrefix({
+                clientUploadContext,
+                collection,
+                filename,
+                req
+            });
+            const key = path.posix.join(prefix, filename);
+            const { data, error } = await client.POST('/api/v0/uploads/download/sign', {
+                body: {
+                    collectionId: collection.slug,
+                    expiresIn: 7200,
+                    filename: key
+                }
+            });
+            if (error || !data) {
+                req.payload.logger.error(`Failed to get signed download URL: ${JSON.stringify(error)}`);
+                return new Response('Internal Server Error', {
+                    status: 500
+                });
+            }
+            // Fetch file bytes from S3 (required for Payload's image processing)
+            const fileResponse = await fetch(data.url);
+            if (!fileResponse.ok) {
+                req.payload.logger.error(`S3 fetch failed: ${fileResponse.status} ${fileResponse.statusText}`);
+                return new Response('Failed to fetch file from storage', {
+                    status: 502
+                });
+            }
+            const contentType = fileResponse.headers.get('content-type') || 'application/octet-stream';
+            const contentLength = fileResponse.headers.get('content-length');
+            return new Response(fileResponse.body, {
+                headers: {
+                    'Content-Type': contentType,
+                    ...contentLength && {
+                        'Content-Length': contentLength
+                    }
+                }
+            });
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: 'Error in staticHandler'
+            });
+            return new Response('Internal Server Error', {
+                status: 500
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=staticHandler.js.map

package/dist/storage-content-api/types.d.ts

@@ -0,0 +1,10 @@
+import type { AuthMode } from '../db-content-api/utilities/auth.js';
+export type StorageClientConfig = {
+    auth: AuthMode;
+    baseUrl: string;
+    contentSystemId: string;
+} | {
+    baseUrl: string;
+    contentApiKey: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/storage-content-api/types.js

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

package/dist/storage-content-api/utilities/getSafeFilename.d.ts

@@ -0,0 +1,12 @@
+import type { PayloadRequest } from 'payload';
+/**
+ * Get a safe filename that doesn't collide with existing documents
+ * Similar to Payload's getSafeFileName
+ */
+export declare function getSafeFilename({ collectionSlug, desiredFilename, prefix, req, }: {
+    collectionSlug: string;
+    desiredFilename: string;
+    prefix?: string;
+    req: PayloadRequest;
+}): Promise<string>;
+//# sourceMappingURL=getSafeFilename.d.ts.map

package/dist/storage-content-api/utilities/getSafeFilename.js

@@ -0,0 +1,61 @@
+import sanitize from 'sanitize-filename';
+/**
+ * Check if a document with the given filename already exists in the database
+ * Matches Payload's docWithFilenameExists
+ */ async function docWithFilenameExists({ collectionSlug, filename, prefix, req }) {
+    const where = {
+        filename: {
+            equals: filename
+        }
+    };
+    if (prefix) {
+        where.prefix = {
+            equals: prefix
+        };
+    }
+    const doc = await req.payload.db.findOne({
+        collection: collectionSlug,
+        req,
+        where
+    });
+    return !!doc;
+}
+/**
+ * Increment filename by adding -1, -2, etc. suffix
+ * photo.jpg → photo-1.jpg
+ * photo-1.jpg → photo-2.jpg
+ * Matches Payload's incrementName
+ */ function incrementFilename(name) {
+    const extension = name.split('.').pop();
+    const baseFilename = sanitize(name.substring(0, name.lastIndexOf('.')) || name);
+    let incrementedName = baseFilename;
+    const regex = /(.*)-(\d+)$/;
+    const found = baseFilename.match(regex);
+    if (found === null) {
+        incrementedName += '-1';
+    } else {
+        const matchedName = found[1];
+        const matchedNumber = found[2];
+        const incremented = Number(matchedNumber) + 1;
+        incrementedName = `${matchedName}-${incremented}`;
+    }
+    return `${incrementedName}.${extension}`;
+}
+/**
+ * Get a safe filename that doesn't collide with existing documents
+ * Similar to Payload's getSafeFileName
+ */ export async function getSafeFilename({ collectionSlug, desiredFilename, prefix, req }) {
+    let modifiedFilename = desiredFilename;
+    // Keep incrementing until we find a filename that doesn't exist
+    while(await docWithFilenameExists({
+        collectionSlug,
+        filename: modifiedFilename,
+        prefix,
+        req
+    })){
+        modifiedFilename = incrementFilename(modifiedFilename);
+    }
+    return modifiedFilename;
+}
+
+//# sourceMappingURL=getSafeFilename.js.map

package/dist/storage-content-api/utilities/index.d.ts

@@ -0,0 +1,2 @@
+export { getSafeFilename } from './getSafeFilename.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage-content-api/utilities/index.js

@@ -0,0 +1,3 @@
+export { getSafeFilename } from './getSafeFilename.js';
+
+//# sourceMappingURL=index.js.map

package/dist/templates/.env.example

@@ -0,0 +1,5 @@
+# Figma Project ID (CMS Resource ID)
+FIGMA_PROJECT_ID=
+
+# Environment name (e.g., production, staging)
+FIGMA_ENVIRONMENT_NAME=production

package/dist/templates/README.md

@@ -0,0 +1,19 @@
+# {{PROJECT_NAME}}
+
+A Payload project configured for running on Figma infrastructure.
+
+## Getting Started
+
+{{RUN_COMMAND}} dev
+
+Open http://localhost:3000/admin to access the admin panel.
+
+## Deployment
+
+npx @payloadcms/figma deploy
+
+Deploys to Figma infrastructure.
+
+## Resources
+
+- [Payload Docs](https://payloadcms.com/docs)

package/dist/types/config.d.ts

@@ -1,6 +1,7 @@
 /**
  * Figma CMS Configuration Types
  */
+import type { PackageManager } from '../utils/package-manager.js';
 /**
  * Tenant instance from Control Plane API
  */
@@ -25,7 +26,7 @@ export interface ProjectInfo {
     /** Whether Payload is installed */
     hasPayload: boolean;
     /** Package manager detected (npm, pnpm, yarn) */
-    packageManager?: 'npm' | 'pnpm' | 'yarn';
+    packageManager?: PackageManager;
     /** Project root path */
     path: string;
     /** Payload version if installed */

package/dist/types/config.js

@@ -1,8 +1,6 @@
 /**
  * Figma CMS Configuration Types
  */ /**
- * Tenant instance from Control Plane API
- */ /**
  * Project information from detection
  */ export { };
 

package/dist/types.d.ts

@@ -1,8 +1,11 @@
 import type arg from 'arg';
 export interface Args extends arg.Spec {
     '--debug': BooleanConstructor;
+    '--env': StringConstructor;
     '--force': BooleanConstructor;
     '--help': BooleanConstructor;
+    '--id': StringConstructor;
+    '--infra-env': StringConstructor;
     '--list': BooleanConstructor;
     '--logout': BooleanConstructor;
     '--yes': BooleanConstructor;
@@ -37,7 +40,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;

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

@@ -16,15 +16,12 @@ 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
+ * 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,21 @@ 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
+ * 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 async function createLambdaZip(projectPath) {
-    const scriptPath = path.join(projectPath, 'build_for_lambda.sh');
-    // Check if script exists
-    try {
-        await fs.stat(scriptPath);
-    } catch  {
-        throw new Error('build_for_lambda.sh not found. Run init command to set up project.');
-    }
-    // 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}`);
-    }
-    // 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');
-    }
+    await buildLambdaZip(projectPath);
 }
 
 //# sourceMappingURL=asset-collection.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * 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. Copies public/ to .next/standalone/public/ (if exists)
+ * 4. Creates lambda.zip from .next/standalone/
+ *
+ * @param projectPath - Path to project root
+ * @throws Error if standalone directory missing or zip creation fails
+ */
+export declare function buildLambdaZip(projectPath: string): Promise<void>;
+//# sourceMappingURL=build-lambda-zip.d.ts.map

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

@@ -0,0 +1,81 @@
+import archiver from 'archiver';
+import { createWriteStream } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * 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. Copies public/ to .next/standalone/public/ (if exists)
+ * 4. Creates lambda.zip from .next/standalone/
+ *
+ * @param projectPath - Path to project root
+ * @throws Error if standalone directory missing or zip creation fails
+ */ export async function buildLambdaZip(projectPath) {
+    const standalonePath = path.join(projectPath, '.next', 'standalone');
+    const staticPath = path.join(projectPath, '.next', 'static');
+    const publicPath = path.join(projectPath, 'public');
+    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.');
+    }
+    if (await isDirectory(staticPath)) {
+        const destStatic = path.join(standalonePath, '.next', 'static');
+        await copyDirectory(staticPath, destStatic);
+    }
+    try {
+        await fs.copyFile(runShPath, path.join(standalonePath, 'run.sh'));
+    } catch  {
+    // run.sh may not exist in all setups
+    }
+    if (await isDirectory(publicPath)) {
+        const destPublic = path.join(standalonePath, 'public');
+        await copyDirectory(publicPath, destPublic);
+    }
+    await createZip(standalonePath, zipPath);
+}
+async function isDirectory(dirPath) {
+    try {
+        const stats = await fs.stat(dirPath);
+        return stats.isDirectory();
+    } catch  {
+        return false;
+    }
+}
+async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, {
+        recursive: true
+    });
+    const entries = await fs.readdir(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        } else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+function createZip(sourceDir, zipPath) {
+    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);
+        archive.directory(sourceDir, false);
+        void archive.finalize();
+    });
+}
+
+//# sourceMappingURL=build-lambda-zip.js.map

package/dist/utils/cache-bootstrap.d.ts

@@ -0,0 +1,8 @@
+import type { BootstrapInfo } from '../api/control-plane.js';
+import type { TokenStore } from '../auth/token-store.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */
+export declare function cacheAllEnvironments(tokenStore: TokenStore, projectId: string, bootstrapInfo: BootstrapInfo): void;
+//# sourceMappingURL=cache-bootstrap.d.ts.map

package/dist/utils/cache-bootstrap.js

@@ -0,0 +1,18 @@
+import * as log from './log.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */ export function cacheAllEnvironments(tokenStore, projectId, bootstrapInfo) {
+    const { oauthCredentials } = bootstrapInfo;
+    for (const env of bootstrapInfo.environments){
+        tokenStore.setBootstrapData(projectId, env.name, {
+            contentSystemId: env.contentSystemId,
+            oauthClientId: oauthCredentials.oauthClientId,
+            oauthClientSecret: oauthCredentials.oauthClientSecret,
+            tenantInstanceId: env.tenantInstanceId
+        });
+    }
+    log.debug(`Cached bootstrap data for environments: ${bootstrapInfo.environments.map((e)=>e.name).join(', ')}`);
+}
+
+//# sourceMappingURL=cache-bootstrap.js.map

package/dist/utils/config.js

@@ -19,7 +19,7 @@ const GITIGNORE_FILENAME = '.gitignore';
         }
     }
     // Parse existing entries
-    const existingLines = existingContent.split('\n').filter((line)=>line.trim());
+    const existingLines = existingContent.split(/\r?\n/).filter((line)=>line.trim());
     const existingSet = new Set(existingLines);
     // Add new entries that don't exist
     const newEntries = entries.filter((entry)=>!existingSet.has(entry));