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

package/dist/storage-content-api/client-uploads/generate.js

@@ -0,0 +1,69 @@
+import path from 'path';
+import { APIError, Forbidden } from 'payload';
+import { getSafeFilename } from '../utilities/index.js';
+const defaultAccess = ({ req })=>!!req.user;
+/**
+ * v4 client-upload entry point. Payload core calls this from
+ * `POST /api/upload-instructions`; we sign a Content API upload URL and hand the
+ * browser an `http` PUT instruction plus an `uploadReference` that
+ * `handleUpload`/`staticHandler` use to recognize the already-uploaded file.
+ */ export const getGenerateUploadInstructions = ({ access = defaultAccess, client })=>{
+    const generate = async ({ collectionSlug, docPrefix, filename, filesize, mimeType, overrideAccess, req })=>{
+        if (!overrideAccess && !await access({
+            collectionSlug,
+            req
+        })) {
+            throw new Forbidden();
+        }
+        const safeFilename = await getSafeFilename({
+            collectionSlug,
+            desiredFilename: filename,
+            req
+        });
+        // Key by `<prefix>/<filename>` to match the read path (staticHandler/generateURL
+        // via getFilePrefix) and handleUpload. The Figma plugin sets no prefix, so
+        // docPrefix is blank today and this is just the filename.
+        const fileKey = path.posix.join(docPrefix ?? '', safeFilename);
+        const { data, error, response } = await client.POST('/api/v0/uploads/sign', {
+            body: {
+                collectionId: collectionSlug,
+                contentType: mimeType,
+                expiresIn: 3600,
+                filename: fileKey
+            }
+        });
+        if (error) {
+            throw new APIError(`Failed to get presigned upload URL: ${error.message}`, response.status, {
+                code: error.code
+            });
+        }
+        if (!data) {
+            throw new Error('No response while getting presigned upload URL');
+        }
+        return {
+            type: 'http',
+            file: {
+                collectionSlug,
+                filename: safeFilename,
+                mimeType,
+                size: filesize,
+                uploadReference: {
+                    clientUploaded: true,
+                    filename: safeFilename,
+                    mimeType,
+                    prefix: docPrefix ?? ''
+                }
+            },
+            // The presigned URL is signed with `contentType: mimeType`, so the browser
+            // PUT must carry a matching Content-Type header or S3 rejects the signature.
+            request: {
+                headers: {
+                    'Content-Type': mimeType
+                },
+                method: 'PUT',
+                url: data.url
+            }
+        };
+    };
+    return generate;
+};

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

@@ -0,0 +1,5 @@
+import createClient from 'openapi-fetch';
+import type { UploadPaths } from './api-types.js';
+import type { StorageClientConfig } from './types.js';
+export type StorageClient = ReturnType<typeof createClient<UploadPaths>>;
+export declare function createStorageClient(config: StorageClientConfig): StorageClient;

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

@@ -0,0 +1,37 @@
+import createClient from 'openapi-fetch';
+import { getValidProjectToken } from '../auth/project-token.js';
+import { fetchDevJwt } from '../db-content-api/utilities/auth.js';
+export function createStorageClient(config) {
+    const client = createClient({
+        baseUrl: config.baseUrl
+    });
+    client.use(createStorageAuthMiddleware(config));
+    return client;
+}
+function createStorageAuthMiddleware(config) {
+    return {
+        async onRequest ({ request }) {
+            if ('contentApiKey' in config) {
+                request.headers.set('X-Api-Key', config.contentApiKey);
+            } else {
+                const { auth, contentSystemId } = config;
+                if (auth.mode === 'apiKey') {
+                    request.headers.set('X-Api-Key', auth.apiKey);
+                } else if (auth.mode === 'tokenStore') {
+                    const token = await getValidProjectToken({
+                        tenantId: contentSystemId,
+                        tokenStore: auth.tokenStore
+                    });
+                    if (!token) {
+                        throw new Error('Authentication required. Run `npx @payloadcms/figma login` to authenticate.');
+                    }
+                    request.headers.set('Authorization', `Bearer ${token}`);
+                } else {
+                    const token = await fetchDevJwt(config.baseUrl, contentSystemId);
+                    request.headers.set('Authorization', `Bearer ${token}`);
+                }
+            }
+            return request;
+        }
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { GenerateURL } from '@payloadcms/plugin-cloud-storage/types';
+type Args = {
+    baseUrl: string;
+};
+export declare const getGenerateURL: ({ baseUrl }: Args) => GenerateURL;
+export {};

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

@@ -0,0 +1,6 @@
+import path from 'path';
+export const getGenerateURL = ({ baseUrl })=>({ collection, filename, prefix = '' })=>{
+        const collectionId = collection.slug;
+        const fileKey = path.posix.join(prefix, filename);
+        return `${baseUrl}/api/v0/uploads/download/${collectionId}/${encodeURIComponent(fileKey)}`;
+    };

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

@@ -0,0 +1,7 @@
+import type { HandleDelete } from '@payloadcms/plugin-cloud-storage/types';
+import type { StorageClient } from './client.js';
+type Args = {
+    client: StorageClient;
+};
+export declare const getHandleDelete: ({ client }: Args) => HandleDelete;
+export {};

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

@@ -0,0 +1,15 @@
+import path from 'path';
+export const getHandleDelete = ({ client })=>{
+    return async ({ collection, doc: { prefix = '' }, filename })=>{
+        const collectionId = collection.slug;
+        const fileKey = path.posix.join(prefix, filename);
+        await client.DELETE('/api/v0/uploads/{collectionId}/{filename}', {
+            params: {
+                path: {
+                    collectionId,
+                    filename: fileKey
+                }
+            }
+        });
+    };
+};

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

@@ -0,0 +1,10 @@
+import type { HandleUpload } from '@payloadcms/plugin-cloud-storage/types';
+import type { CollectionConfig } from 'payload';
+import type { StorageClient } from './client.js';
+type Args = {
+    client: StorageClient;
+    collection: CollectionConfig;
+    prefix?: string;
+};
+export declare const getHandleUpload: ({ client, collection, prefix }: Args) => HandleUpload;
+export {};

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

@@ -0,0 +1,162 @@
+import fs from 'fs';
+import path from 'path';
+import { APIError } from 'payload';
+import { parseUploadReference } from './utilities/index.js';
+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 ({ data, file })=>{
+        // Skip if the client already uploaded THIS SPECIFIC file. Resized versions
+        // (different filename) should still be uploaded.
+        const reference = parseUploadReference(file.uploadReference);
+        const isOriginalClientUploaded = reference.clientUploaded === true && file.filename === reference.filename;
+        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, response } = await client.POST('/api/v0/uploads/sign', {
+        body: {
+            collectionId,
+            contentType: mimeType,
+            expiresIn: 3600,
+            filename: fileKey
+        }
+    });
+    if (error) {
+        throw new APIError(`Failed to get presigned upload URL: ${error.message}`, response.status, {
+            code: error.code
+        });
+    }
+    if (!data) {
+        throw new Error('No response while getting presigned upload URL');
+    }
+    const uploadResponse = await fetch(data.url, {
+        // TS's BodyInit type rejects Buffer<ArrayBufferLike>; wrap as Uint8Array
+        // (a valid ArrayBufferView) — byte-identical.
+        body: new Uint8Array(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, response: initiateResponse } = await client.POST('/api/v0/uploads/multipart/initiate', {
+        body: {
+            collectionId,
+            contentType: mimeType,
+            filename: fileKey
+        }
+    });
+    if (initiateError) {
+        throw new APIError(`Failed to initiate multipart upload: ${initiateError.message}`, initiateResponse.status, {
+            code: initiateError.code
+        });
+    }
+    if (!initiateData) {
+        throw new Error('No response while initiating multipart upload');
+    }
+    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, response: partsResponse } = await client.POST('/api/v0/uploads/multipart/parts', {
+            body: {
+                collectionId,
+                expiresIn: 3600,
+                filename: fileKey,
+                partNumbers,
+                uploadId
+            }
+        });
+        if (partsError) {
+            throw new APIError(`Failed to get part URLs: ${partsError.message}`, partsResponse.status, {
+                code: partsError.code
+            });
+        }
+        if (!partsData) {
+            throw new Error('No response while getting part URLs');
+        }
+        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, response: completeResponse } = await client.POST('/api/v0/uploads/multipart/complete', {
+            body: {
+                collectionId,
+                filename: fileKey,
+                parts: uploadedParts,
+                uploadId
+            }
+        });
+        if (completeError) {
+            throw new APIError(`Failed to complete multipart upload: ${completeError.message}`, completeResponse.status, {
+                code: completeError.code
+            });
+        }
+    } catch (error) {
+        try {
+            await client.POST('/api/v0/uploads/multipart/abort', {
+                body: {
+                    collectionId,
+                    filename: fileKey,
+                    uploadId
+                }
+            });
+        } catch  {
+        // Ignore abort errors
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,4 @@
+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;

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

@@ -0,0 +1,37 @@
+import { createStorageClient } from './client.js';
+import { getGenerateUploadInstructions } from './client-uploads/generate.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
+            }),
+            uploadInstructions: {
+                enabled: true,
+                generate: getGenerateUploadInstructions({
+                    client
+                }),
+                useInAdmin: true
+            }
+        };
+    };
+}

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

@@ -0,0 +1,9 @@
+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 {};

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

@@ -0,0 +1,61 @@
+import { getFilePrefix } from '@payloadcms/plugin-cloud-storage/utilities';
+import path from 'path';
+import { isImage } from 'payload/shared';
+import { parseUploadReference } from './utilities/index.js';
+export const getHandler = ({ client, collection })=>{
+    return async (req, { params: { filename, uploadReference } })=>{
+        try {
+            const prefix = await getFilePrefix({
+                collection,
+                filename,
+                req,
+                uploadReference
+            });
+            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
+                });
+            }
+            // On a client-upload fetch-back, core reads this response body into req.file.data to
+            // size the image; a 302's empty body crashes getImageSize. Return real bytes for
+            // images (and unknown mimetypes, to be safe), but keep the redirect otherwise so we
+            // don't download large non-images server-side.
+            if (uploadReference) {
+                const { mimeType } = parseUploadReference(uploadReference);
+                if (!mimeType || isImage(mimeType)) {
+                    const fileResponse = await fetch(data.url);
+                    if (!fileResponse.ok) {
+                        req.payload.logger.error(`Failed to fetch file for client-upload buffer fetch-back: ${fileResponse.status}`);
+                        return new Response('Internal Server Error', {
+                            status: 500
+                        });
+                    }
+                    const contentType = fileResponse.headers.get('Content-Type') ?? mimeType ?? 'application/octet-stream';
+                    return new Response(await fileResponse.arrayBuffer(), {
+                        headers: {
+                            'Content-Type': contentType
+                        }
+                    });
+                }
+            }
+            return Response.redirect(data.url, 302);
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: 'Error in staticHandler'
+            });
+            return new Response('Internal Server Error', {
+                status: 500
+            });
+        }
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { AuthMode } from '../db-content-api/utilities/auth.js';
+export type StorageClientConfig = {
+    auth: AuthMode;
+    baseUrl: string;
+    contentSystemId: string;
+} | {
+    baseUrl: string;
+    contentApiKey: string;
+};

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

@@ -0,0 +1 @@
+export { };

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

@@ -0,0 +1,11 @@
+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>;

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

@@ -0,0 +1,59 @@
+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;
+}

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

@@ -0,0 +1,2 @@
+export { getSafeFilename } from './getSafeFilename.js';
+export { type ContentApiUploadReference, parseUploadReference } from './parseUploadReference.js';

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

@@ -0,0 +1,2 @@
+export { getSafeFilename } from './getSafeFilename.js';
+export { parseUploadReference } from './parseUploadReference.js';

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

@@ -0,0 +1,17 @@
+/**
+ * Shape of the `uploadReference` this adapter attaches to client-uploaded files
+ * (via the `generate` upload-instructions handler). Payload exposes it as
+ * `unknown`, so it must be narrowed at runtime before use.
+ */
+export type ContentApiUploadReference = {
+    clientUploaded?: boolean;
+    filename?: string;
+    mimeType?: string;
+    prefix?: string;
+};
+/**
+ * Safely narrows an `unknown` uploadReference into the adapter's known shape,
+ * keeping only properties present with the expected type. Returns an empty
+ * object for any non-object input.
+ */
+export declare const parseUploadReference: (reference: unknown) => ContentApiUploadReference;

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

@@ -0,0 +1,27 @@
+/**
+ * Shape of the `uploadReference` this adapter attaches to client-uploaded files
+ * (via the `generate` upload-instructions handler). Payload exposes it as
+ * `unknown`, so it must be narrowed at runtime before use.
+ */ /**
+ * Safely narrows an `unknown` uploadReference into the adapter's known shape,
+ * keeping only properties present with the expected type. Returns an empty
+ * object for any non-object input.
+ */ export const parseUploadReference = (reference)=>{
+    if (!reference || typeof reference !== 'object') {
+        return {};
+    }
+    const result = {};
+    if ('clientUploaded' in reference && typeof reference.clientUploaded === 'boolean') {
+        result.clientUploaded = reference.clientUploaded;
+    }
+    if ('filename' in reference && typeof reference.filename === 'string') {
+        result.filename = reference.filename;
+    }
+    if ('mimeType' in reference && typeof reference.mimeType === 'string') {
+        result.mimeType = reference.mimeType;
+    }
+    if ('prefix' in reference && typeof reference.prefix === 'string') {
+        result.prefix = reference.prefix;
+    }
+    return result;
+};

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,10 +26,9 @@ 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 */
     payloadVersion?: string;
 }
-//# sourceMappingURL=config.d.ts.map

package/dist/types/config.js

@@ -1,9 +1,5 @@
 /**
  * Figma CMS Configuration Types
  */ /**
- * Tenant instance from Control Plane API
- */ /**
  * Project information from detection
  */ export { };
-
-//# sourceMappingURL=config.js.map