@payloadcms/figma 0.1.0-alpha.4 → 0.1.0-alpha.5

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

@@ -3,6 +3,7 @@ import { APIError, createDatabaseAdapter, ValidationError } from 'payload';
 import { v4 as uuid } from 'uuid';
 import { FigmaApiError } from '../api/figma-api.js';
 import { CONTENT_SYSTEM_NOT_FOUND_MESSAGE } from '../constants.js';
+import { redirectInitialAutosaveCreate } from '../plugin/cloud-limits/server/redirectInitialAutosaveCreate.js';
 import { getGlobalSlug } from './temp-utilities/slug.js';
 import { addFallbackSort } from './temp-utilities/sorting.js';
 import { unwrapDocument, unwrapFindResponse } from './temp-utilities/unwrapDocument.js';
@@ -122,7 +123,7 @@ async function createCollection(collectionId) {
 }
 async function findMany({ collection, joins, limit, locale: localeArg, page, pagination: _pagination, sort, where }) {
     const locale = addFallbackLocale(localeArg, this.payload);
-    const normalizedWhere = normalizeLocaleInWhere(where, this.payload, collection, locale);
+    const localeNormalizedWhere = normalizeLocaleInWhere(where, this.payload, collection, locale);
     const joinClause = convertPayloadJoinsToContentAPI(this.payload, collection, joins);
     const { data: response, error, response: httpResponse } = await this.client.POST('/api/v1/documents:find', {
         body: {
@@ -134,7 +135,7 @@ async function findMany({ collection, joins, limit, locale: localeArg, page, pag
             page: page ?? 1,
             schema: this.documentSchema(),
             sort: addFallbackSort(sort, this.payload, collection),
-            where: convertPayloadWhereToContentAPI(normalizedWhere ?? {})
+            where: convertPayloadWhereToContentAPI(localeNormalizedWhere, this.payload, collection, false)
         }
     });
     if (error) {
@@ -166,7 +167,7 @@ async function find(args) {
 // TODO: remove Omit when this PR is released: https://github.com/payloadcms/payload/pull/15183
 async function findVersions(args) {
     const sortWithFallback = addFallbackSort(args.sort || '-updatedAt', this.payload, args.collection);
-    const whereClause = convertPayloadWhereToContentAPI(args.where ?? {});
+    const whereClause = convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, true);
     const locale = addFallbackLocale(args.locale, this.payload);
     const { data: response, error, response: httpResponse } = await this.client.POST('/api/v1/document_versions:find', {
         body: {
@@ -281,7 +282,7 @@ async function updateVersion(args) {
                 updatedAt: versionMeta.updatedAt,
                 version: versionContent
             },
-            where: convertPayloadWhereToContentAPI(where)
+            where: convertPayloadWhereToContentAPI(where, this.payload, args.collection, true)
         }
     });
     if (error) {
@@ -316,7 +317,7 @@ async function deleteVersions(args) {
             contentSystemId: this.contentSystemId,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, collection, true)
         }
     });
     if (error) {
@@ -346,7 +347,7 @@ async function findDistinct(args) {
             page: args.page ?? 1,
             schema: this.documentSchema(),
             sort: addFallbackSort(args.sort, this.payload, args.collection),
-            where: convertPayloadWhereToContentAPI(args.where ?? {})
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -379,7 +380,7 @@ async function updateMany(args) {
             locale,
             schema: this.documentSchema(),
             sort: addFallbackSort(args.sort || '-updatedAt', this.payload, args.collection),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -419,7 +420,7 @@ async function updateOne(args) {
             environmentName: this.environmentName,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(where)
+            where: convertPayloadWhereToContentAPI(where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -451,7 +452,7 @@ async function deleteMany(args) {
             environmentName: this.environmentName,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -467,7 +468,7 @@ async function deleteOne(args) {
             environmentName: this.environmentName,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -525,6 +526,12 @@ async function create(args) {
         }
     });
     if (error) {
+        redirectInitialAutosaveCreate({
+            collectionSlug: args.collection,
+            errorCode: error.code,
+            payload: this.payload,
+            req: args.req
+        });
         throw createDocumentContentAPIError(this, 'create', error, httpResponse.status, args.collection);
     }
     if (!contentAPIResponse) {
@@ -574,7 +581,7 @@ async function count(args) {
             contentSystemId: this.contentSystemId,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -595,7 +602,7 @@ async function countVersions(args) {
             contentSystemId: this.contentSystemId,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, true)
         }
     });
     if (error) {
@@ -608,12 +615,19 @@ async function countVersions(args) {
         totalDocs: response.result.count
     };
 }
+// Content API document ids are text. A document id is only ever a string or a number
+// (a custom numeric id), so coerce those to a string and treat anything else as absent.
+function toIdString(value) {
+    return typeof value === 'string' || typeof value === 'number' ? String(value) : undefined;
+}
 async function upsert(args) {
-    let documentId = args.data.id;
+    // The Content API stores every document id as text; a custom numeric id arrives as a
+    // number, so coerce it (matching `create`) before it becomes `createOnMissing.id`.
+    let documentId = toIdString(args.data.id);
     if (!documentId && args.where && 'id' in args.where) {
         const idClause = args.where.id;
-        if (idClause && 'equals' in idClause) {
-            documentId = idClause.equals;
+        if (idClause) {
+            documentId = toIdString(idClause.equals);
         }
     }
     if (!documentId) {
@@ -645,7 +659,7 @@ async function upsert(args) {
             environmentName: this.environmentName,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -692,7 +706,7 @@ async function updateJobs(args) {
     } : where;
     const docData = dataToContentAPI(this.payload, collection, data);
     const sortClause = addFallbackSort(sort || '-updatedAt', this.payload, collection);
-    const whereQuery = convertPayloadWhereToContentAPI(whereClause);
+    const whereQuery = convertPayloadWhereToContentAPI(whereClause, this.payload, collection, false);
     const { data: response, error, response: httpResponse } = await this.client.POST('/api/v1/documents:update', {
         body: {
             collection,

package/dist/db-content-api/utilities/joins.js

@@ -102,6 +102,10 @@ import { convertPayloadWhereToContentAPI } from './where.js';
         const effectiveLimit = joinQuery.limit ?? foundJoin.defaultLimit;
         // Add fallback sort for the joined collection
         const sortWithFallback = addFallbackSort(joinQuery.sort, payload, foundJoin.collectionSlug, foundJoin.defaultSort);
+        // A join's `where` filters the *joined* collection, so id coercion resolves against
+        // that collection (the first target for a polymorphic join; `id` is coerced regardless).
+        const joinedSlug = Array.isArray(foundJoin.collectionSlug) ? foundJoin.collectionSlug[0] : foundJoin.collectionSlug;
+        const whereConverted = convertPayloadWhereToContentAPI(joinQuery.where, payload, joinedSlug, false);
         const contentAPIJoin = {
             count: joinQuery.count ?? false,
             path: joinPath,
@@ -115,7 +119,7 @@ import { convertPayloadWhereToContentAPI } from './where.js';
                 sort: sortWithFallback
             },
             ...joinQuery.where && {
-                where: convertPayloadWhereToContentAPI(joinQuery.where)
+                where: whereConverted
             }
         };
         result.push(contentAPIJoin);

package/dist/db-content-api/utilities/meta/resolvesToRelationshipValue.d.ts

@@ -0,0 +1,10 @@
+import type { Field, Payload } from 'payload';
+export interface ResolveContext {
+    readonly fieldCache: Map<string, boolean>;
+    readonly fields: Field[];
+    readonly isVersions: boolean;
+    readonly payload: Payload;
+}
+/** Walks a path's segments against a field list, reporting whether it lands on a
+ * relationship/upload field's id-bearing value. */
+export declare function resolvesToRelationshipValue(segments: string[], fields: Field[], ctx: ResolveContext): boolean;

package/dist/db-content-api/utilities/meta/resolvesToRelationshipValue.js

@@ -0,0 +1,95 @@
+import { resolveBlocks } from '../resolveBlocks.js';
+/** Walks a path's segments against a field list, reporting whether it lands on a
+ * relationship/upload field's id-bearing value. */ export function resolvesToRelationshipValue(segments, fields, ctx) {
+    const [head, ...rest] = segments;
+    if (head == null) {
+        return false;
+    }
+    const field = findNamedField(fields, head);
+    if (field == null) {
+        return false;
+    }
+    switch(field.type){
+        case 'array':
+            return 'fields' in field && resolvesToRelationshipValue(skipLocaleSegment(rest, field, ctx), field.fields, ctx);
+        case 'blocks':
+            {
+                if (!('blocks' in field)) {
+                    return false;
+                }
+                // Any block whose fields the remaining path resolves through makes it id-bearing:
+                // one path can only mean one thing, whichever block supplied the field.
+                const childSegments = skipLocaleSegment(rest, field, ctx);
+                return resolveBlocks(field.blocks, ctx.payload.config.blocks).some((block)=>resolvesToRelationshipValue(childSegments, block.fields, ctx));
+            }
+        case 'group':
+            return 'fields' in field && resolvesToRelationshipValue(rest, field.fields, ctx);
+        case 'relationship':
+        case 'upload':
+            // A polymorphic field's id sits at `<path>.value`; its `.relationTo` is a slug.
+            if (Array.isArray(field.relationTo)) {
+                return rest.length === 1 && rest[0] === 'value';
+            }
+            // A single-target field's id sits at the field's own path.
+            if (rest.length === 0) {
+                return true;
+            }
+            // Payload accepts an explicit `<path>.id` for that same value —
+            // `getTableColumnFromPath` treats the bare path and `.id` as one column — which the
+            // Content API resolves as a traversal into the related collection's, equally text, id.
+            return rest.length === 1 && rest[0] === 'id';
+        default:
+            return false;
+    }
+}
+/** Finds the field a path segment names. Unnamed containers (row, collapsible, unnamed tab)
+ * are transparent to query paths, so their children are searched too; a named tab nests its
+ * fields under its own name, exactly like a group. */ function findNamedField(fields, name) {
+    for (const field of fields){
+        if ('name' in field && field.name) {
+            // A named container's children need its name consumed first, so only match the
+            // container itself here.
+            if (field.name === name) {
+                return field;
+            }
+            continue;
+        }
+        if ('fields' in field && Array.isArray(field.fields)) {
+            const match = findNamedField(field.fields, name);
+            if (match) {
+                return match;
+            }
+        }
+        if ('tabs' in field && Array.isArray(field.tabs)) {
+            for (const tab of field.tabs){
+                if (!tab.fields) {
+                    continue;
+                }
+                if (!tab.name) {
+                    const match = findNamedField(tab.fields, name);
+                    if (match) {
+                        return match;
+                    }
+                } else if (tab.name === name) {
+                    return {
+                        name: tab.name,
+                        type: 'group',
+                        fields: tab.fields
+                    };
+                }
+            }
+        }
+    }
+    return undefined;
+}
+// A localized array/blocks field is stored as a locale map, so its children's paths carry a
+// locale key (`items.en.rel`) — see `normalizeLocaleInWhere`, which runs before this.
+// Locale keys are *only* added to `array` and `blocks`.
+function skipLocaleSegment(segments, field, ctx) {
+    const localization = ctx.payload.config.localization;
+    if (!localization || !('localized' in field) || !field.localized) {
+        return segments;
+    }
+    const [head] = segments;
+    return head != null && localization.localeCodes.includes(head) ? segments.slice(1) : segments;
+}

package/dist/db-content-api/utilities/meta/stringifyIdsInWhere.d.ts

@@ -0,0 +1,9 @@
+import type { Payload, Where } from 'payload';
+/**
+ * Stringifies numeric operands on a Where clause's id-bearing paths (`id`, `parent` for
+ * versions, and relationship-value paths), so a custom-numeric-id filter matches the
+ * Content API's text storage. Returns the clause untouched when there is nothing to
+ * convert. `isVersions` treats `parent` (the parent document's id) as id-bearing and looks
+ * for the collection's own fields under `version.`.
+ */
+export declare function stringifyIdsInWhere(where: undefined | Where, payload: Payload, collectionSlug: string, isVersions: boolean): undefined | Where;

package/dist/db-content-api/utilities/meta/stringifyIdsInWhere.js

@@ -0,0 +1,112 @@
+import { resolvesToRelationshipValue } from './resolvesToRelationshipValue.js';
+// The Content API stores every document id and every relationship value as text, but
+// Payload keeps a collection's custom numeric id as a `number`. So a filter that carries
+// a numeric id would never match the stored string form. This is the sole place the
+// adapter translates those query-side ids to the wire's string form (the data-side
+// counterpart is `convertRelationshipIds`); `convertPayloadWhereToContentAPI` itself is
+// purely structural.
+//
+// A condition's path is id-bearing when it resolves to:
+//   - `id` — the document's own id (always).
+//   - `parent` — the parent document's id, on a *versions* query (`isVersions`).
+//   - a relationship/upload field's value: the field's own path for a single-target field
+//     (`rel: { equals: 999 }`), or `<path>.value` for a polymorphic one
+//     (`rel.value: { equals: 999 }`). A polymorphic field's `.relationTo` is a slug, not
+//     an id, so it is deliberately left alone.
+//
+// Every stored id is text, so a bare "stringify any numeric operand on this path" is
+// sufficient — no per-target id-type resolution is needed (which also handles a
+// polymorphic `in` array that mixes targets).
+/**
+ * Stringifies numeric operands on a Where clause's id-bearing paths (`id`, `parent` for
+ * versions, and relationship-value paths), so a custom-numeric-id filter matches the
+ * Content API's text storage. Returns the clause untouched when there is nothing to
+ * convert. `isVersions` treats `parent` (the parent document's id) as id-bearing and looks
+ * for the collection's own fields under `version.`.
+ */ export function stringifyIdsInWhere(where, payload, collectionSlug, isVersions) {
+    if (!where) {
+        return where;
+    }
+    // An unknown slug names no fields, but `id` (and `parent` on a versions query) is
+    // id-bearing regardless of the config, so still walk the clause with an empty field list:
+    // discarding it here would turn the query into a match-all.
+    const config = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    const fields = config?.fields ?? [];
+    const fieldCache = new Map();
+    return transformWhere(where, {
+        fieldCache,
+        fields,
+        isVersions,
+        payload
+    });
+}
+/** Recursively transforms a Where clause, stringifying numeric operands on any condition
+ * whose path is id-bearing. */ function transformWhere(where, context) {
+    const result = {};
+    for (const [key, value] of Object.entries(where)){
+        const keyLower = key.toLowerCase();
+        if (keyLower === 'and' || keyLower === 'or') {
+            const targetValue = where[key];
+            if (targetValue == null || !Array.isArray(targetValue)) {
+                continue;
+            }
+            result[key] = targetValue.map((clause)=>transformWhere(clause, context));
+        } else if (isIdBearingPath(key, context)) {
+            result[key] = stringifyNumericOperands(value);
+        } else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/** Whether a condition's path resolves to an id. */ function isIdBearingPath(path, context) {
+    const cachedResult = context.fieldCache.get(path);
+    if (cachedResult != null) {
+        return cachedResult;
+    }
+    // GraphQL spells a nested path with `__`, since dots are invalid in GraphQL names; the
+    // structural conversion normalizes those the same way.
+    const segments = path.replace(/__/g, '.').split('.');
+    // The document's own id — on a versions query, the version document's own id.
+    if (segments.length === 1 && segments[0] === 'id') {
+        return true;
+    }
+    if (context.isVersions) {
+        // `parent` is a version-only field that contains an ID.
+        if (segments.length === 1) {
+            return segments[0] === 'parent';
+        }
+        // The only other paths that can contain IDs are in the version envelope.
+        if (segments[0] !== 'version') {
+            return false;
+        }
+    }
+    // Normalize the path segments by removing the `version` envelope for paths
+    // in document versions.
+    const normalizedSegments = context.isVersions ? segments.slice(1) : segments;
+    return resolvesToRelationshipValue(normalizedSegments, context.fields, context);
+}
+function stringifyNumericOperands(condition) {
+    // Payload's shorthand — `{ id: 999 }` rather than `{ id: { equals: 999 } }` — carries the
+    // operand directly, with no operator keys to walk. The structural conversion reads it as
+    // an implicit `equals`, so coerce it in place: walking a primitive as an operator map
+    // would drop the condition entirely and turn the query into a match-all.
+    if (condition === null || typeof condition !== 'object' || Array.isArray(condition)) {
+        return stringifyNumbers(condition);
+    }
+    const result = {};
+    for (const [operator, operand] of Object.entries(condition)){
+        result[operator] = stringifyNumbers(operand);
+    }
+    return result;
+}
+/** A number becomes its string form; a number inside an array does too (e.g. `in`);
+ * everything else passes through untouched. */ function stringifyNumbers(value) {
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry)=>typeof entry === 'number' ? String(entry) : entry);
+    }
+    return value;
+}

package/dist/db-content-api/utilities/where.d.ts

@@ -1,9 +1,5 @@
-import type { Where } from 'payload';
+import type { Payload, Where } from 'payload';
 import type { components } from '../generated/content-api-types.js';
 type WhereClauseV1 = components['schemas']['WhereClauseV1'];
-type ConvertOptions = {
-    /** Internal flag to track if we're inside a logical operator (and/or) */
-    insideLogicalOperator?: boolean;
-};
-export declare function convertPayloadWhereToContentAPI(where: undefined | Where, options?: ConvertOptions): WhereClauseV1;
+export declare function convertPayloadWhereToContentAPI(where: undefined | Where, payload: Payload, collectionSlug: string, isVersions: boolean): WhereClauseV1;
 export {};

package/dist/db-content-api/utilities/where.js

@@ -1,5 +1,21 @@
-import { stringifyNumericIds } from './data/stringifyNumericIds.js';
-export function convertPayloadWhereToContentAPI(where, options = {}) {
+import { stringifyIdsInWhere } from './meta/stringifyIdsInWhere.js';
+// Payload's format: { fieldName: { operator: value }, and: [...], or: [...] }
+// Content API expects: { and: [{ path, operator, value }], or: [{ path, operator, value }] }
+//
+// The format stays different. This allows the Content API to evolve its filter schema,
+// for example to support composite types like Point, which are not lexicographically sortable.
+// Semantics must remain identical to Payload.
+export function convertPayloadWhereToContentAPI(where, payload, collectionSlug, isVersions) {
+    // Normalize id-bearing operands to the wire's string form (custom numeric ids), then
+    // convert Payload's where shape to the Content API's. The two steps are inseparable —
+    // every id filter must be coerced — so they live behind this single entry point.
+    return convertStructure(stringifyIdsInWhere(where, payload, collectionSlug, isVersions), {
+        insideLogicalOperator: false
+    });
+}
+// The structural Payload → Content API conversion. Assumes id operands have already been
+// coerced to the wire's string form (see `convertPayloadWhereToContentAPI`).
+function convertStructure(where, options) {
     // Empty where {} should be { and: [] } not undefined
     // Content API requires a where clause structure even for "no filter"
     if (!where || Object.keys(where).length === 0) {
@@ -11,7 +27,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
     for (const [key, value] of Object.entries(where)){
         const keyLower = key.toLowerCase();
         if (keyLower === 'and' || keyLower === 'or') {
-            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
+            const nestedConditions = value.map((item)=>convertStructure(item, {
                     ...options,
                     insideLogicalOperator: true
                 })).filter((condition)=>{
@@ -43,7 +59,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 conditions.push({
                     operator: 'equals',
                     path: fieldPath,
-                    value: fieldPath === 'id' ? stringifyNumericIds(value) : value
+                    value
                 });
                 continue;
             }
@@ -68,13 +84,6 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 if (finalValue === 'null') {
                     finalValue = null;
                 }
-                // Content API stores all document IDs as strings.
-                // Payload sends numeric values for collections with custom numeric ID fields,
-                // so we must stringify to match. This includes the `in`/`not_in` arrays that
-                // Payload's relationship-population dataloader always uses ({ id: { in: [...] } }).
-                if (fieldPath === 'id') {
-                    finalValue = stringifyNumericIds(finalValue);
-                }
                 conditions.push({
                     operator: op,
                     path: fieldPath,

package/dist/exports/views.d.ts

@@ -0,0 +1 @@
+export { LimitReachedView } from '../plugin/cloud-limits/LimitReachedView/index.js';

package/dist/exports/views.js

@@ -0,0 +1 @@
+export { LimitReachedView } from '../plugin/cloud-limits/LimitReachedView/index.js';

package/dist/imageSizeOptions.d.ts

@@ -0,0 +1,23 @@
+import type { RequestInitCfPropertiesImage } from '@cloudflare/workers-types';
+type CloudflareWorkerImageOptions = RequestInitCfPropertiesImage;
+export declare const supportedCloudflareImageOptionKeys: readonly ["anim", "background", "blur", "border", "brightness", "compression", "contrast", "dpr", "fit", "flip", "format", "gamma", "gravity", "height", "metadata", "quality", "rotate", "saturation", "segment", "sharpen", "trim", "upscale", "width", "zoom"];
+type SupportedCloudflareImageOptionKey = (typeof supportedCloudflareImageOptionKeys)[number];
+type SupportedCloudflareImageOptions = Pick<CloudflareWorkerImageOptions, SupportedCloudflareImageOptionKey>;
+type CloudflareImageSizeFormat = Exclude<NonNullable<SupportedCloudflareImageOptions['format']>, 'json' | 'svg'>;
+type CloudflareImageSizeOptionsExceptFormat = Omit<SupportedCloudflareImageOptions, 'format'>;
+/**
+ * Options accepted for a reusable Payload image-size preset.
+ *
+ * Presets can control the generated image, but cannot use remote overlays or
+ * forward authentication to an image origin. Formats that do not produce a
+ * supported stored image are also excluded.
+ */
+export type CloudflareImageSizeOptions = {
+    format?: CloudflareImageSizeFormat;
+} & CloudflareImageSizeOptionsExceptFormat;
+declare module 'payload' {
+    interface RegisteredImageSizeOptions {
+        figma: CloudflareImageSizeOptions;
+    }
+}
+export {};

package/dist/imageSizeOptions.js

@@ -0,0 +1,26 @@
+export const supportedCloudflareImageOptionKeys = [
+    'anim',
+    'background',
+    'blur',
+    'border',
+    'brightness',
+    'compression',
+    'contrast',
+    'dpr',
+    'fit',
+    'flip',
+    'format',
+    'gamma',
+    'gravity',
+    'height',
+    'metadata',
+    'quality',
+    'rotate',
+    'saturation',
+    'segment',
+    'sharpen',
+    'trim',
+    'upscale',
+    'width',
+    'zoom'
+];

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { contentAPIAdapter } from './db-content-api/index.js';
+export type { CloudflareImageSizeOptions } from './imageSizeOptions.js';
 export { figmaContentSystem } from './plugin/adapter.js';
 export type { FigmaContentSystemOptions } from './plugin/adapter.js';
 export { buildFigmaConfig } from './plugin/build-config.js';

package/dist/oauth/defaults.d.ts

@@ -1,6 +1,7 @@
 import type { CollectionConfig, EmailField, TextField } from 'payload';
 import type { VerifyFunction } from './types.js';
 export declare const DEFAULT_USER_INFO_COOKIE_NAME = "figma-user-info";
+export declare const FIGMA_OAUTH_CALLBACK_PATH = "/users/sso/login";
 export declare const defaultScope: string[];
 export declare const defaultUsernameField: TextField;
 export declare const defaultVerify: ({ collection, strategyName, userInfoCookieName, usernameField, }: {

package/dist/oauth/defaults.js

@@ -3,6 +3,7 @@ import { v4 as uuid } from 'uuid';
 import { hasUserTokenPropsChanged } from './utilities/hasUserTokenPropsChanged.js';
 import { isDuplicateKeyError } from './utilities/isDuplicateKeyError.js';
 export const DEFAULT_USER_INFO_COOKIE_NAME = 'figma-user-info';
+export const FIGMA_OAUTH_CALLBACK_PATH = '/users/sso/login';
 function getFigmaUserInfo(headers, cookieName) {
     try {
         const cookies = parseCookies(headers);

package/dist/oauth/endpoints/getLoginEndpoint.js

@@ -6,7 +6,8 @@ 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 { buildCsrfCookieClearHeader, OAUTH_STATE_CSRF_COOKIE_NAME } from '../utilities/getAuthorizeURL.js';
+import { getAdminCollectionSlug } from '../utilities/getAdminCollectionSlug.js';
+import { buildCsrfCookieClearHeader, getOAuthCallbackPath, OAUTH_STATE_CSRF_COOKIE_NAME } from '../utilities/getAuthorizeURL.js';
 import { isAbsoluteURL } from '../utilities/isAbsoluteURL.js';
 export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug, pluginOptions, strategy })=>({
         handler: async (req)=>{
@@ -151,7 +152,11 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                 }
                 const redirectUri = formatAdminURL({
                     apiRoute: config.routes?.api || '/api',
-                    path: `/${collection.slug}/${endpointSlug}/login`,
+                    path: getOAuthCallbackPath({
+                        adminCollectionSlug: getAdminCollectionSlug(config),
+                        collection,
+                        endpointSlug
+                    }),
                     serverURL: redirectServerURL
                 });
                 debugLogger.info({

package/dist/oauth/index.js

@@ -1,5 +1,5 @@
 import { fieldAffectsData } from 'payload/shared';
-import { defaultVerify } from './defaults.js';
+import { defaultVerify, FIGMA_OAUTH_CALLBACK_PATH } from './defaults.js';
 import { getLoginEndpoint } from './endpoints/getLoginEndpoint.js';
 import { getLogoutEndpoint } from './endpoints/getLogoutEndpoint.js';
 import { getMetaEndpoint } from './endpoints/getMetaEndpoint.js';
@@ -50,6 +50,7 @@ export const oAuth2Plugin = (pluginOptions)=>(config)=>{
                 path: '@payloadcms/figma/client#DefaultLoginButton'
             };
         }
+        let callbackEndpoint;
         return {
             ...config,
             admin: {
@@ -148,6 +149,20 @@ export const oAuth2Plugin = (pluginOptions)=>(config)=>{
                         usernameField
                     })
                 });
+                const loginEndpoint = getLoginEndpoint({
+                    collection: existingCollection,
+                    collectionOptions,
+                    endpointSlug,
+                    pluginOptions,
+                    strategy
+                });
+                const collectionCallbackPath = `/${existingCollection.slug}/${endpointSlug}/login`;
+                if (existingCollection.slug === adminCollectionSlug && FIGMA_OAUTH_CALLBACK_PATH !== collectionCallbackPath) {
+                    callbackEndpoint = {
+                        ...loginEndpoint,
+                        path: FIGMA_OAUTH_CALLBACK_PATH
+                    };
+                }
                 const authStrategy = {
                     name: `${existingCollection.slug}-${strategyName}`,
                     // Bind 'this' to ensure the authenticate function has the correct context
@@ -180,13 +195,7 @@ export const oAuth2Plugin = (pluginOptions)=>(config)=>{
                     },
                     endpoints: [
                         ...existingCollection.endpoints || [],
-                        getLoginEndpoint({
-                            collection: existingCollection,
-                            collectionOptions,
-                            endpointSlug,
-                            pluginOptions,
-                            strategy
-                        }),
+                        loginEndpoint,
                         getMetaEndpoint({
                             collection: existingCollection,
                             collectionOptions,
@@ -237,6 +246,12 @@ export const oAuth2Plugin = (pluginOptions)=>(config)=>{
                         ]
                     }
                 };
-            })
+            }),
+            endpoints: [
+                ...config.endpoints ?? [],
+                ...callbackEndpoint ? [
+                    callbackEndpoint
+                ] : []
+            ]
         };
     };