@payloadcms/figma 0.0.1-alpha.63 → 0.0.1-alpha.65

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

@@ -213,7 +213,7 @@ async function createVersion(args) {
             contentSystemId: this.contentSystemId,
             versionDoc: {
                 createdAt: args.createdAt,
-                latest: !args.autosave,
+                latest: true,
                 parent: String(args.parent),
                 updatedAt: args.updatedAt,
                 version: dataToContentAPI(this.payload, args.collectionSlug, args.versionData, {
@@ -365,6 +365,7 @@ async function updateMany(args) {
             contentSystemId: this.contentSystemId,
             createOnMissing: false,
             doc: dataToContentAPI(this.payload, args.collection, args.data),
+            environmentName: this.environmentName,
             limit: args.limit,
             locale,
             returning: {},
@@ -411,6 +412,7 @@ async function updateOne(args) {
             contentSystemId: this.contentSystemId,
             createOnMissing: false,
             doc: dataToContentAPI(this.payload, args.collection, args.data),
+            environmentName: this.environmentName,
             locale,
             returning: {},
             where: convertPayloadWhereToContentAPI(where),
@@ -447,6 +449,7 @@ async function deleteMany(args) {
         body: {
             collection: args.collection,
             contentSystemId: this.contentSystemId,
+            environmentName: this.environmentName,
             locale,
             where: convertPayloadWhereToContentAPI(args.where),
             ...buildMeta(this.payload, {
@@ -466,6 +469,7 @@ async function deleteOne(args) {
         body: {
             collection: args.collection,
             contentSystemId: this.contentSystemId,
+            environmentName: this.environmentName,
             locale,
             returning: {},
             where: convertPayloadWhereToContentAPI(args.where),
@@ -525,6 +529,7 @@ async function create(args) {
                 }),
                 id
             },
+            environmentName: this.environmentName,
             locale,
             ...buildMeta(this.payload, {
                 collection: args.collection,
@@ -643,6 +648,7 @@ async function upsert(args) {
                 applyDefaults: true,
                 createdAt: true
             }),
+            environmentName: this.environmentName,
             locale,
             where: convertPayloadWhereToContentAPI(args.where),
             ...buildMeta(this.payload, {
@@ -673,41 +679,6 @@ async function upsert(args) {
         payload: this.payload
     });
 }
-// Mirrors MAX_DOCUMENT_UPDATES in the content API's updateDocuments.ts.
-// updateJobs may be called with larger limits (e.g. 150), so we batch sequentially.
-const CONTENT_API_MAX_UPDATES = 20;
-// Issues a single update request against payload-jobs and returns the unwrapped docs.
-async function updateJobsBatch({ batchSize, docData, meta, sortClause, whereQuery }) {
-    const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
-        body: {
-            collection: 'payload-jobs',
-            contentSystemId: this.contentSystemId,
-            createOnMissing: false,
-            doc: docData,
-            ...batchSize != null && {
-                limit: batchSize
-            },
-            returning: {},
-            sort: sortClause,
-            where: whereQuery,
-            ...meta
-        }
-    });
-    if (error) {
-        throw new Error(`Content API updateJobs error: ${JSON.stringify(error)}`);
-    }
-    if (!response) {
-        throw new Error('No response from updateJobs');
-    }
-    if (!response.result || !('data' in response.result)) {
-        return [];
-    }
-    return response.result.data.map((doc)=>unwrapDocument({
-            collectionSlug: 'payload-jobs',
-            doc,
-            payload: this.payload
-        }));
-}
 async function updateJobs(args) {
     const { id, limit, returning, sort, where } = args;
     if (id == null && where == null) {
@@ -737,49 +708,39 @@ async function updateJobs(args) {
         locale: undefined,
         where: whereClause
     });
-    // When limit exceeds the content API's per-request cap, batch sequentially.
-    const needsBatching = limit != null && limit > CONTENT_API_MAX_UPDATES;
-    if (!needsBatching) {
-        const docs = await updateJobsBatch.call(this, {
-            batchSize: limit,
-            docData,
-            meta,
-            sortClause,
-            whereQuery
-        });
-        if (returning === false) {
-            return null;
-        }
-        return docs;
-    }
-    // Batched path: issue sequential requests of ≤ CONTENT_API_MAX_UPDATES each.
-    // This relies on the update itself causing matched jobs to no longer satisfy the where
-    // clause on subsequent batches (e.g. setting processing: true removes them from a
-    // "processing: false" query). If a future updateJobs call in Payload core updates jobs
-    // in a way that does NOT change their match status, the same jobs could be updated
-    // multiple times across batches.
-    const allDocs = [];
-    let remaining = limit;
-    while(remaining > 0){
-        const batchSize = Math.min(remaining, CONTENT_API_MAX_UPDATES);
-        const batchDocs = await updateJobsBatch.call(this, {
-            batchSize,
-            docData,
-            meta,
-            sortClause,
-            whereQuery
-        });
-        allDocs.push(...batchDocs);
-        remaining -= batchSize;
-        // Stop early when this batch returned fewer docs than requested — no more matching docs.
-        if (batchDocs.length < batchSize) {
-            break;
+    const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
+        body: {
+            collection: 'payload-jobs',
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            doc: docData,
+            environmentName: this.environmentName,
+            ...limit != null && {
+                limit
+            },
+            returning: {},
+            sort: sortClause,
+            where: whereQuery,
+            ...meta
         }
+    });
+    if (error) {
+        throw new Error(`Content API updateJobs error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from updateJobs');
     }
     if (returning === false) {
         return null;
     }
-    return allDocs;
+    if (!response.result || !('data' in response.result)) {
+        return [];
+    }
+    return response.result.data.map((doc)=>unwrapDocument({
+            collectionSlug: 'payload-jobs',
+            doc,
+            payload: this.payload
+        }));
 }
 function createGlobal(args) {
     // Globals are singletons identified by their slug. Use upsert so concurrent calls
@@ -908,6 +869,7 @@ export const contentAPIAdapter = (opts)=>({
                 deleteMany: deleteMany,
                 deleteOne: deleteOne,
                 deleteVersions: deleteVersions,
+                environmentName: opts.environmentName,
                 find: find,
                 findDistinct: findDistinct,
                 findGlobal: findGlobal,

package/dist/lib/download-skill.d.ts

@@ -0,0 +1,13 @@
+export type DownloadSkillResult = {
+    detail?: string;
+    ok: false;
+    reason: 'already-installed' | 'empty-extract' | 'error' | 'fetch-failed';
+} | {
+    ok: true;
+};
+export declare function downloadSkill(args: {
+    branch?: string;
+    debug?: boolean;
+    projectDir: string;
+}): Promise<DownloadSkillResult>;
+//# sourceMappingURL=download-skill.d.ts.map

package/dist/lib/download-skill.js

@@ -0,0 +1,79 @@
+import fs from 'fs/promises';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import path from 'path';
+import { x } from 'tar';
+export async function downloadSkill(args) {
+    const { branch = 'main', debug, projectDir } = args;
+    const destDir = path.join(projectDir, '.claude', 'skills', 'payload');
+    if (await pathExists(path.join(destDir, 'SKILL.md'))) {
+        return {
+            ok: false,
+            reason: 'already-installed'
+        };
+    }
+    const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${branch}`;
+    const filter = `payload-${branch.replace(/^v/, '').replaceAll('/', '-')}/tools/claude-plugin/skills/payload/`;
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.log(`[download-skill] url=${url} dest=${destDir}`);
+    }
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            return {
+                detail: `${res.status} ${res.statusText}`,
+                ok: false,
+                reason: 'fetch-failed'
+            };
+        }
+        if (!res.body) {
+            return {
+                detail: 'empty response body',
+                ok: false,
+                reason: 'fetch-failed'
+            };
+        }
+        await fs.mkdir(destDir, {
+            recursive: true
+        });
+        await pipeline(Readable.from(res.body), x({
+            cwd: destDir,
+            filter: (p)=>p.includes(filter),
+            strip: filter.split('/').length - 1
+        }));
+        if (!await pathExists(path.join(destDir, 'SKILL.md'))) {
+            await fs.rm(destDir, {
+                force: true,
+                recursive: true
+            });
+            return {
+                ok: false,
+                reason: 'empty-extract'
+            };
+        }
+        return {
+            ok: true
+        };
+    } catch (err) {
+        await fs.rm(destDir, {
+            force: true,
+            recursive: true
+        }).catch(()=>{});
+        return {
+            detail: err instanceof Error ? err.message : String(err),
+            ok: false,
+            reason: 'error'
+        };
+    }
+}
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=download-skill.js.map

package/dist/oauth/endpoints/getLoginEndpoint.js

@@ -1,11 +1,10 @@
-import { APIError, generateCookie, parseCookies } from 'payload';
+import { APIError, parseCookies } from 'payload';
 import { formatAdminURL, getSafeRedirect } from 'payload/shared';
-import { getProjectToken, getUserInfo } from '../../api/figma-api.js';
-import { createCookieOptions } from '../utilities/createCookieOptions.js';
 import { createDebugLogger } from '../utilities/createDebugLogger.js';
+import { establishSession } from '../utilities/establishSession.js';
+import { exchangeCodeForAccessToken } from '../utilities/exchangeCodeForAccessToken.js';
 import { extractOrigin } from '../utilities/extractOrigin.js';
-import { getCookieExpiration } from '../utilities/getCookieExpiration.js';
-const isAbsoluteURL = (url)=>/^[a-z][a-z\d+.-]*:/.test(url);
+import { isAbsoluteURL } from '../utilities/isAbsoluteURL.js';
 export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug, pluginOptions, strategy })=>({
         handler: async (req)=>{
             const { config } = req.payload;
@@ -127,32 +126,21 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                     });
                     return Response.redirect(failedRedirect);
                 }
-                const body = {
-                    client_id: strategy.clientID,
-                    code,
-                    code_verifier: req.payload.decrypt(state.verifier),
-                    grant_type: 'authorization_code',
-                    redirect_uri: formatAdminURL({
-                        apiRoute: config.routes?.api || '/api',
-                        path: `/${collection.slug}/${endpointSlug}/login`,
-                        serverURL: redirectServerURL
-                    })
-                };
-                if (strategy.collectionOptions.clientSecret) {
-                    body.client_secret = strategy.collectionOptions.clientSecret;
-                }
+                const redirectUri = formatAdminURL({
+                    apiRoute: config.routes?.api || '/api',
+                    path: `/${collection.slug}/${endpointSlug}/login`,
+                    serverURL: redirectServerURL
+                });
                 debugLogger.info({
                     msg: 'Exchanging code for access token',
-                    path,
-                    requestBody: body
+                    path
+                });
+                const tokenRes = await exchangeCodeForAccessToken({
+                    code,
+                    codeVerifier: req.payload.decrypt(state.verifier),
+                    redirectUri,
+                    strategy
                 });
-                const tokenRes = await fetch(strategy.meta?.token_endpoint, {
-                    body: new URLSearchParams(body),
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded'
-                    },
-                    method: 'POST'
-                }).then((r)=>r.json());
                 debugLogger.info({
                     msg: 'Token Response',
                     path,
@@ -167,25 +155,6 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                     });
                     return Response.redirect(failedRedirect);
                 }
-                // Fetch Figma user info for handle and profile image
-                let figmaUserInfo = null;
-                try {
-                    const oauthCredential = {
-                        type: 'oauth',
-                        token: access_token
-                    };
-                    figmaUserInfo = await getUserInfo(oauthCredential);
-                    debugLogger.info({
-                        figmaUserInfo,
-                        msg: 'Fetched Figma user info'
-                    });
-                } catch (err) {
-                    // Non-fatal: user will just not have handle/image
-                    debugLogger.error({
-                        err,
-                        msg: 'Failed to fetch Figma user info'
-                    });
-                }
                 if (!access_token) {
                     const errMsg = 'No access_token was returned from the identity provider.';
                     req.payload.logger.error({
@@ -195,30 +164,6 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                     });
                     throw new APIError(errMsg);
                 }
-                // Swap for project token
-                const oauthCredential = {
-                    type: 'oauth',
-                    token: access_token
-                };
-                const project_token = await getProjectToken(oauthCredential, config.custom.figma.contentSystemId);
-                const refresh_token = access_token;
-                // Store project token as access_token
-                const token = project_token.token;
-                const expiresIn = project_token.expiresAt;
-                if (!token) {
-                    const errMsg = `No ${collectionOptions.token || 'access_token'} was returned from the identity provider.`;
-                    req.payload.logger.error({
-                        msg: errMsg,
-                        path
-                    });
-                    throw new APIError(errMsg);
-                }
-                const cookieOptions = createCookieOptions({
-                    collection,
-                    headers: req.headers,
-                    pluginOptions
-                });
-                // get the payloadRedirect cookie value
                 const cookies = parseCookies(req.headers);
                 const payloadRedirect = 'payloadRedirect' in cookies ? cookies.payloadRedirect : '';
                 if (!req.responseHeaders) {
@@ -232,43 +177,17 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                     }
                     req.responseHeaders.append('Set-Cookie', `payloadRedirect=${redirectToUse}; Max-Age=0; Path=/;`);
                 }
-                if (refresh_token && !collectionOptions.usePayloadJWT) {
-                    debugLogger.info('Setting refresh token cookie');
-                    const refreshCookie = generateCookie({
-                        returnCookieAsObject: false,
-                        ...cookieOptions,
-                        name: `${strategy.cookieName}-refresh`,
-                        value: refresh_token,
-                        // Default to 1 year if no expiration
-                        expires: getCookieExpiration(cookieOptions?.expires ?? refreshTokenExpires ?? 31_556_952)
-                    });
-                    req.responseHeaders.append('Set-Cookie', refreshCookie);
-                }
-                const tokenExpires = cookieOptions?.expires ? getCookieExpiration(cookieOptions.expires) : new Date(expiresIn) // Project token uses epoch time
-                ;
-                const tokenCookie = generateCookie({
-                    ...cookieOptions,
-                    name: strategy.cookieName,
-                    expires: tokenExpires,
-                    returnCookieAsObject: false,
-                    value: token
+                await establishSession({
+                    accessToken: access_token,
+                    collection,
+                    collectionOptions,
+                    contentSystemId: config.custom.figma.contentSystemId,
+                    debugLogger,
+                    pluginOptions,
+                    refreshTokenExpiresIn: refreshTokenExpires,
+                    req,
+                    strategy
                 });
-                req.responseHeaders.append('Set-Cookie', tokenCookie);
-                // Store user info in short-lived cookie for defaultVerify to consume
-                if (figmaUserInfo) {
-                    const userInfoValue = Buffer.from(JSON.stringify({
-                        handle: figmaUserInfo.handle,
-                        img_url: figmaUserInfo.img_url
-                    })).toString('base64');
-                    const userInfoCookie = generateCookie({
-                        ...cookieOptions,
-                        name: pluginOptions?.userInfoCookieName ?? 'figma-user-info',
-                        expires: new Date(Date.now() + 60_000),
-                        returnCookieAsObject: false,
-                        value: userInfoValue
-                    });
-                    req.responseHeaders.append('Set-Cookie', userInfoCookie);
-                }
                 return Response.redirect(redirectToUse);
             } catch (err) {
                 req.payload.logger.error({

package/dist/oauth/endpoints/getTokenLoginEndpoint.d.ts

@@ -0,0 +1,17 @@
+import type { CollectionConfig, Endpoint } from 'payload';
+import type { Strategy } from '../strategy/index.js';
+import type { CollectionOptions, PluginOptions } from '../types.js';
+interface Args {
+    collection: CollectionConfig;
+    collectionOptions: CollectionOptions;
+    endpointSlug: string;
+    pluginOptions: PluginOptions;
+    strategy: Strategy;
+}
+/**
+ * Auto-login endpoint for embedded contexts where the interactive OAuth flow
+ * cannot run.
+ */
+export declare const getTokenLoginEndpoint: ({ collection, collectionOptions, endpointSlug, pluginOptions, strategy, }: Args) => Endpoint;
+export {};
+//# sourceMappingURL=getTokenLoginEndpoint.d.ts.map

package/dist/oauth/endpoints/getTokenLoginEndpoint.js

@@ -0,0 +1,105 @@
+import { formatAdminURL, getSafeRedirect } from 'payload/shared';
+import { createDebugLogger } from '../utilities/createDebugLogger.js';
+import { establishSession } from '../utilities/establishSession.js';
+import { exchangeCodeForAccessToken } from '../utilities/exchangeCodeForAccessToken.js';
+import { isAbsoluteURL } from '../utilities/isAbsoluteURL.js';
+/**
+ * Auto-login endpoint for embedded contexts where the interactive OAuth flow
+ * cannot run.
+ */ export const getTokenLoginEndpoint = ({ collection, collectionOptions, endpointSlug, pluginOptions, strategy })=>({
+        handler: async (req)=>{
+            const { config } = req.payload;
+            const adminRoute = config.routes?.admin || '/admin';
+            const debugLogger = createDebugLogger(req.payload, pluginOptions.debug);
+            const adminURL = formatAdminURL({
+                adminRoute,
+                serverURL: config.serverURL
+            });
+            const failedRedirect = formatAdminURL({
+                adminRoute,
+                path: '/login',
+                serverURL: config.serverURL
+            });
+            try {
+                await strategy.ensureMeta();
+                const code = req.query.code;
+                const redirectQuery = req.query.redirect;
+                let redirectToUse = adminURL;
+                if (typeof redirectQuery === 'string' && redirectQuery.length > 0) {
+                    const safeRedirect = getSafeRedirect({
+                        allowAbsoluteUrls: false,
+                        redirectTo: redirectQuery
+                    });
+                    if (safeRedirect && !isAbsoluteURL(safeRedirect)) {
+                        redirectToUse = `${config.serverURL ?? ''}${safeRedirect}`;
+                    }
+                }
+                if (typeof code !== 'string' || code.length === 0) {
+                    debugLogger.error({
+                        msg: 'token_login: missing code'
+                    });
+                    return Response.redirect(failedRedirect);
+                }
+                if (!strategy.meta?.token_endpoint) {
+                    debugLogger.error({
+                        msg: 'token_login: no token_endpoint discovered from identity provider'
+                    });
+                    return Response.redirect(failedRedirect);
+                }
+                debugLogger.info({
+                    msg: 'token_login: exchanging code for access token'
+                });
+                const tokenRes = await exchangeCodeForAccessToken({
+                    code,
+                    redirectUri: formatAdminURL({
+                        apiRoute: config.routes?.api || '/api',
+                        path: `/${collection.slug}/${endpointSlug}/token_login`,
+                        serverURL: config.serverURL
+                    }),
+                    strategy
+                });
+                const { access_token, error, error_description, expires_in } = tokenRes;
+                if (error) {
+                    req.payload.logger.error({
+                        err: error,
+                        error_description,
+                        msg: 'token_login: error exchanging code for access token'
+                    });
+                    return Response.redirect(failedRedirect);
+                }
+                if (typeof access_token !== 'string' || access_token.length === 0) {
+                    req.payload.logger.error({
+                        msg: 'token_login: no access_token returned from identity provider'
+                    });
+                    return Response.redirect(failedRedirect);
+                }
+                await establishSession({
+                    accessToken: access_token,
+                    collection,
+                    collectionOptions,
+                    contentSystemId: config.custom.figma.contentSystemId,
+                    debugLogger,
+                    pluginOptions,
+                    refreshTokenExpiresIn: expires_in,
+                    req,
+                    strategy
+                });
+                return Response.redirect(redirectToUse);
+            } catch (err) {
+                req.payload.logger.error({
+                    err,
+                    msg: 'Error during token_login',
+                    path: req.pathname
+                });
+                return Response.json({
+                    error: 'Error during token_login'
+                }, {
+                    status: 500
+                });
+            }
+        },
+        method: 'get',
+        path: `/${endpointSlug}/token_login`
+    });
+
+//# sourceMappingURL=getTokenLoginEndpoint.js.map

package/dist/oauth/index.js

@@ -4,6 +4,7 @@ import { getLoginEndpoint } from './endpoints/getLoginEndpoint.js';
 import { getLogoutEndpoint } from './endpoints/getLogoutEndpoint.js';
 import { getMetaEndpoint } from './endpoints/getMetaEndpoint.js';
 import { getRedirectToLoginEndpoint } from './endpoints/getRedirectToLoginEndpoint.js';
+import { getTokenLoginEndpoint } from './endpoints/getTokenLoginEndpoint.js';
 import { getAfterLogout } from './hooks/afterLogout.js';
 import { getMeHook } from './hooks/me.js';
 import { getRefreshHook } from './hooks/refresh.js';
@@ -206,6 +207,13 @@ export const oAuth2Plugin = (pluginOptions)=>(config)=>{
                             endpointSlug,
                             pluginOptions,
                             strategy
+                        }),
+                        getTokenLoginEndpoint({
+                            collection: existingCollection,
+                            collectionOptions,
+                            endpointSlug,
+                            pluginOptions,
+                            strategy
                         })
                     ],
                     fields,

package/dist/oauth/utilities/establishSession.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionConfig, PayloadRequest } from 'payload';
+import type { Strategy } from '../strategy/index.js';
+import type { CollectionOptions, DebugLogger, PluginOptions } from '../types.js';
+interface Args {
+    accessToken: string;
+    collection: CollectionConfig;
+    collectionOptions: CollectionOptions;
+    contentSystemId: string;
+    debugLogger: DebugLogger;
+    pluginOptions: PluginOptions;
+    /** From the IdP token response (`expires_in`); used as a refresh-cookie expiry fallback. */
+    refreshTokenExpiresIn?: number;
+    req: PayloadRequest;
+    strategy: Strategy;
+}
+/**
+ * Given a valid OAuth access_token: fetch user info (non-fatal), mint a
+ * project token, and write the main + refresh + user-info cookies to
+ * `req.responseHeaders`. Throws `APIError` if the project token mint fails.
+ */
+export declare const establishSession: ({ accessToken, collection, collectionOptions, contentSystemId, debugLogger, pluginOptions, refreshTokenExpiresIn, req, strategy, }: Args) => Promise<void>;
+export {};
+//# sourceMappingURL=establishSession.d.ts.map