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

package/dist/plugin/build-config.js

@@ -1,26 +1,202 @@
+import { cloudStoragePlugin } from '@payloadcms/plugin-cloud-storage';
+import { initClientUploads } from '@payloadcms/plugin-cloud-storage/utilities';
 import { lexicalEditor } from '@payloadcms/richtext-lexical';
 import { buildConfig as payloadBuildConfig } from 'payload';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { getValidAccessToken } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getEnvConfig } from '../constants.js';
+import { contentAPIAdapter } from '../db-content-api/index.js';
+import { health } from '../endpoints/health.js';
+import { schema } from '../endpoints/schema.js';
 import { oAuth2Plugin } from '../oauth/index.js';
-import { figmaContentSystem } from './adapter.js';
+import { createStorageClient } from '../storage-content-api/client.js';
+import { getGenerateSignedURLHandler } from '../storage-content-api/client-uploads/generateSignedURL.js';
+import { contentApiStorageAdapter } from '../storage-content-api/index.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import * as log from '../utils/log.js';
 /**
- * Figma platform wrapper for Payload's buildConfig.
- * Automatically injects:
- * - Figma database adapter
- * - Secret (platform-provided)
- * - Default lexicalEditor (if no custom editor specified)
- *
- * @param config - Payload configuration (db and secret omitted, editor optional)
- * @returns Promise<SanitizedConfig> - Built Payload configuration
- */ export async function buildConfig(config) {
+ * Fields added to users collection for Figma profile info
+ */ const figmaUserFields = [
+    {
+        name: 'figmaHandle',
+        type: 'text',
+        admin: {
+            readOnly: true
+        },
+        label: 'Name'
+    },
+    {
+        name: 'figmaImageUrl',
+        type: 'text',
+        admin: {
+            components: {
+                Cell: '@payloadcms/figma/client#FigmaAvatarCell'
+            },
+            disableBulkEdit: true,
+            hidden: true,
+            readOnly: true
+        },
+        label: 'Profile Picture'
+    }
+];
+function missingOAuthCredential(name) {
+    log.warning(`${name} could not be resolved. OAuth login will not work until this is configured. ` + 'Run `npx @payloadcms/figma init` to set up your project.');
+    return '';
+}
+/**
+ * Fetch bootstrap data from the API and cache all environments locally.
+ * Returns the requested environment's data, or null if resolution fails.
+ */ async function resolveAndCacheBootstrap(store, projectId, environmentName) {
+    try {
+        const accessToken = await getValidAccessToken(store);
+        if (!accessToken) {
+            return null;
+        }
+        const bootstrapInfo = await getBootstrapInfo(accessToken, projectId);
+        cacheAllEnvironments(store, projectId, bootstrapInfo);
+        return store.getBootstrapData(projectId, environmentName);
+    } catch (error) {
+        log.warning(`Failed to resolve bootstrap data: ${error instanceof Error ? error.message : 'Unknown error'}. ` + 'Try running `npx @payloadcms/figma login` to refresh authentication.');
+        return null;
+    }
+}
+export async function buildFigmaConfig(config) {
+    const envConfig = getEnvConfig();
+    // Resolve contentSystemId: config first, then local store fallback (dev)
+    let { contentSystemId } = config.figma;
+    let bootstrapData = null;
+    if (!contentSystemId) {
+        const projectId = process.env.FIGMA_PROJECT_ID;
+        const environmentName = process.env.FIGMA_ENVIRONMENT_NAME;
+        if (projectId && environmentName) {
+            const store = getTokenStore();
+            bootstrapData = store.getBootstrapData(projectId, environmentName);
+            // Runtime fallback: fetch from API if not cached (e.g. environment switch without re-init)
+            if (!bootstrapData) {
+                bootstrapData = await resolveAndCacheBootstrap(store, projectId, environmentName);
+            }
+            if (bootstrapData) {
+                contentSystemId = bootstrapData.contentSystemId;
+            }
+        }
+    }
+    if (!contentSystemId) {
+        throw new Error('Content System ID could not be resolved. ' + 'Run `npx @payloadcms/figma init` to set up your project.');
+    }
+    const url = process.env.FIGMA_CONTENT_API_URL || envConfig.contentApiUrl;
+    const isProduction = process.env.NODE_ENV === 'production';
+    // Determine database adapter based on environment
+    let db;
+    if (config.figma.useContentSystem === false) {
+        db = config.db;
+    } else if (process.env.FIGMA_CONTENT_API_ACCESS_KEY) {
+        db = contentAPIAdapter({
+            auth: {
+                apiKey: process.env.FIGMA_CONTENT_API_ACCESS_KEY,
+                mode: 'apiKey'
+            },
+            contentSystemId,
+            url
+        });
+    } else if (process.env.FIGMA_DEV_JWT === 'true') {
+        db = contentAPIAdapter({
+            auth: {
+                mode: 'devJwt'
+            },
+            contentSystemId,
+            url
+        });
+    } else {
+        db = contentAPIAdapter({
+            auth: {
+                mode: 'tokenStore',
+                tokenStore: getTokenStore()
+            },
+            contentSystemId,
+            url
+        });
+    }
+    // Build storage plugin if there are upload collections and storage is not disabled
+    const uploadCollections = (config.collections || []).filter((c)=>c.upload);
+    let storagePlugin;
+    if (uploadCollections.length > 0 && config.figma.storage !== false) {
+        const storageConfig = process.env.FIGMA_CONTENT_API_ACCESS_KEY ? {
+            baseUrl: url,
+            contentApiKey: process.env.FIGMA_CONTENT_API_ACCESS_KEY
+        } : process.env.FIGMA_DEV_JWT === 'true' ? {
+            auth: {
+                mode: 'devJwt'
+            },
+            baseUrl: url,
+            contentSystemId
+        } : {
+            auth: {
+                mode: 'tokenStore',
+                tokenStore: getTokenStore()
+            },
+            baseUrl: url,
+            contentSystemId
+        };
+        const adapter = contentApiStorageAdapter(storageConfig);
+        const storageClient = createStorageClient(storageConfig);
+        const collectionsMap = uploadCollections.reduce((acc, c)=>{
+            acc[c.slug] = {
+                adapter,
+                disableLocalStorage: true
+            };
+            return acc;
+        }, {});
+        initClientUploads({
+            clientHandler: '@payloadcms/figma/client#ContentApiClientUploadHandler',
+            collections: collectionsMap,
+            config: config,
+            enabled: true,
+            serverHandler: getGenerateSignedURLHandler({
+                client: storageClient
+            }),
+            serverHandlerPath: '/content-api-storage-signed-url'
+        });
+        storagePlugin = cloudStoragePlugin({
+            collections: collectionsMap
+        });
+    }
     // Build complete config with Figma platform defaults
     const configWithFigmaDefaults = {
         ...config,
-        db: config.figma.useContentSystem ? figmaContentSystem() : config.db,
+        admin: {
+            // Auto-refresh tokens before expiry to prevent unexpected logouts.
+            autoRefresh: true,
+            avatar: {
+                Component: '@payloadcms/figma/client#FigmaAvatar'
+            },
+            ...config.admin
+        },
+        custom: {
+            figma: {
+                ...config.figma,
+                contentSystemId
+            }
+        },
+        db,
         editor: config.editor ?? lexicalEditor(),
+        endpoints: [
+            ...config.endpoints ?? [],
+            health,
+            schema
+        ],
+        ...isProduction && !config.logger ? {
+            logger: {
+                options: {}
+            }
+        } : {},
         secret: 'MY_SECRET',
         // Add oauth to plugins if not already present
         plugins: [
             ...config.plugins ?? [],
+            ...storagePlugin ? [
+                storagePlugin
+            ] : [],
             oAuth2Plugin({
                 collections: [
                     {
@@ -30,9 +206,9 @@ import { figmaContentSystem } from './adapter.js';
                             response_mode: 'query',
                             response_type: 'code'
                         },
-                        clientID: process.env.FIGMA_OAUTH_CLIENT_ID,
-                        clientSecret: process.env.FIGMA_OAUTH_CLIENT_SECRET,
-                        identityMetadata: 'https://staging.figma.com/.well-known/openid-configuration',
+                        clientID: process.env.FIGMA_OAUTH_CLIENT_ID ?? bootstrapData?.oauthClientId ?? missingOAuthCredential('FIGMA_OAUTH_CLIENT_ID'),
+                        clientSecret: process.env.FIGMA_OAUTH_CLIENT_SECRET ?? bootstrapData?.oauthClientSecret,
+                        identityMetadata: envConfig.identityMetadata,
                         scope: [
                             'current_user:read'
                         ],
@@ -40,12 +216,27 @@ import { figmaContentSystem } from './adapter.js';
                         usernameField: 'email'
                     }
                 ],
-                debug: true,
-                disabled: false,
-                redirectServerURL: 'http://localhost:3000'
+                debug: !!process.env.DEBUG,
+                disabled: false
             })
         ]
     };
+    // Inject figma fields into users collection
+    const collections = configWithFigmaDefaults.collections?.map((col)=>{
+        if (col.slug === 'users') {
+            return {
+                ...col,
+                fields: [
+                    ...col.fields || [],
+                    ...figmaUserFields
+                ]
+            };
+        }
+        return col;
+    });
+    if (collections) {
+        configWithFigmaDefaults.collections = collections;
+    }
     // Delegate to Payload's buildConfig
     return await payloadBuildConfig(configWithFigmaDefaults);
 }

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