@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.61

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

@@ -0,0 +1,168 @@
+/**
+ * Upload API types extracted from Content API OpenAPI spec.
+ * These are kept separate to avoid breaking changes when the main spec is regenerated.
+ */
+export type UploadPaths = {
+    '/api/v0/uploads/{collectionId}/{filename}': {
+        delete: {
+            parameters: {
+                path: {
+                    collectionId: string;
+                    filename: string;
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            success: true;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/download/sign': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        expiresIn: number;
+                        filename: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            url: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/multipart/abort': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        filename: string;
+                        uploadId: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            success: true;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/multipart/complete': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        filename: string;
+                        parts: Array<{
+                            ETag: string;
+                            PartNumber: number;
+                        }>;
+                        uploadId: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            success: true;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/multipart/initiate': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        contentType: string;
+                        filename: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            uploadId: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/multipart/parts': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        expiresIn: number;
+                        filename: string;
+                        partNumbers: number[];
+                        uploadId: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            parts: Array<{
+                                partNumber: number;
+                                url: string;
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    '/api/v0/uploads/sign': {
+        post: {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        collectionId: string;
+                        contentType?: string;
+                        expiresIn: number;
+                        filename: string;
+                    };
+                };
+            };
+            responses: {
+                200: {
+                    content: {
+                        'application/json': {
+                            url: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=api-types.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * Upload API types extracted from Content API OpenAPI spec.
+ * These are kept separate to avoid breaking changes when the main spec is regenerated.
+ */ export { };
+
+//# sourceMappingURL=api-types.js.map

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

@@ -0,0 +1,9 @@
+export declare const ContentApiClientUploadHandler: ({ children, collectionSlug, enabled, extra, prefix, serverHandlerPath, }: {
+    children: import("react").ReactNode;
+    collectionSlug: import("payload").UploadCollectionSlug;
+    enabled?: boolean;
+    extra: Record<string, unknown>;
+    prefix?: string;
+    serverHandlerPath: `/${string}`;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=ClientUploadHandler.d.ts.map

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

@@ -0,0 +1,42 @@
+'use client';
+import { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client';
+export const ContentApiClientUploadHandler = createClientUploadHandler({
+    handler: async ({ apiRoute, collectionSlug, file, prefix, serverHandlerPath, serverURL })=>{
+        // Build endpoint URL: serverURL + apiRoute + serverHandlerPath
+        const endpointRoute = `${serverURL}${apiRoute}${serverHandlerPath}`;
+        const response = await fetch(endpointRoute, {
+            body: JSON.stringify({
+                collectionSlug,
+                filename: file.name,
+                mimeType: file.type
+            }),
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get presigned URL: ${response.status} ${response.statusText}`);
+        }
+        const { filename: safeFilename, url } = await response.json();
+        const uploadFilename = safeFilename || file.name;
+        const uploadResponse = await fetch(url, {
+            body: file,
+            headers: {
+                'Content-Type': file.type
+            },
+            method: 'PUT'
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(`Failed to upload to S3: ${uploadResponse.status} ${uploadResponse.statusText}`);
+        }
+        return {
+            clientUploaded: true,
+            filename: uploadFilename,
+            prefix
+        };
+    }
+});
+
+//# sourceMappingURL=ClientUploadHandler.js.map

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

@@ -0,0 +1,13 @@
+import type { PayloadHandler } from 'payload';
+import type { StorageClient } from '../client.js';
+type ClientUploadsAccess = (args: {
+    collectionSlug: string;
+    req: Parameters<PayloadHandler>[0];
+}) => boolean | Promise<boolean>;
+type Args = {
+    access?: ClientUploadsAccess;
+    client: StorageClient;
+};
+export declare const getGenerateSignedURLHandler: ({ access, client, }: Args) => PayloadHandler;
+export {};
+//# sourceMappingURL=generateSignedURL.d.ts.map

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

@@ -0,0 +1,39 @@
+import { APIError, Forbidden } from 'payload';
+import { getSafeFilename } from '../utilities/index.js';
+const defaultAccess = ({ req })=>!!req.user;
+export const getGenerateSignedURLHandler = ({ access = defaultAccess, client })=>{
+    return async (req)=>{
+        if (!req.json) {
+            throw new APIError('Content-Type expected to be application/json', 400);
+        }
+        const { collectionSlug, filename, mimeType } = await req.json();
+        if (!await access({
+            collectionSlug,
+            req
+        })) {
+            throw new Forbidden();
+        }
+        const safeFilename = await getSafeFilename({
+            collectionSlug,
+            desiredFilename: filename,
+            req
+        });
+        const { data, error } = await client.POST('/api/v0/uploads/sign', {
+            body: {
+                collectionId: collectionSlug,
+                contentType: mimeType,
+                expiresIn: 3600,
+                filename: safeFilename
+            }
+        });
+        if (error || !data) {
+            throw new APIError(`Failed to get presigned upload URL: ${JSON.stringify(error)}`);
+        }
+        return Response.json({
+            filename: safeFilename,
+            url: data.url
+        });
+    };
+};
+
+//# sourceMappingURL=generateSignedURL.js.map

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

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,36 @@
+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(auth.tokenStore, contentSystemId);
+                    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;
+        }
+    };
+}
+
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,7 @@
+import type { GenerateURL } from '@payloadcms/plugin-cloud-storage/types';
+type Args = {
+    baseUrl: string;
+};
+export declare const getGenerateURL: ({ baseUrl }: Args) => GenerateURL;
+export {};
+//# sourceMappingURL=generateURL.d.ts.map

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

@@ -0,0 +1,8 @@
+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)}`;
+    };
+
+//# sourceMappingURL=generateURL.js.map

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

@@ -0,0 +1,8 @@
+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 {};
+//# sourceMappingURL=handleDelete.d.ts.map

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

@@ -0,0 +1,17 @@
+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
+                }
+            }
+        });
+    };
+};
+
+//# sourceMappingURL=handleDelete.js.map

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

@@ -0,0 +1,11 @@
+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 {};
+//# sourceMappingURL=handleUpload.d.ts.map

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