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

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

@@ -3,12 +3,14 @@ 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';
 import { createAuthMiddleware, createErrorMiddleware } from './utilities/auth.js';
 import { getClientVersionHeaders } from './utilities/clientVersionHeaders.js';
 import { dataToContentAPI, resolveVersionContent } from './utilities/data/index.js';
+import { injectGlobalType } from './utilities/data/injectGlobalType.js';
 import { validateRelationshipIds } from './utilities/data/validateRelationships.js';
 import { convertPayloadJoinsToContentAPI } from './utilities/joins.js';
 import { addFallbackLocale } from './utilities/locale/index.js';
@@ -121,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: {
@@ -133,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) {
@@ -165,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: {
@@ -280,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) {
@@ -301,9 +303,12 @@ async function updateVersion(args) {
     });
 }
 async function deleteVersions(args) {
-    const collection = args.collection;
+    // Globals are addressed by `globalSlug` and map to the `_global-<slug>` collection.
+    // Only one of `collection`/`globalSlug` is set.
+    const globalSlug = args.globalSlug != null ? getGlobalSlug(args.globalSlug) : undefined;
+    const collection = args.collection ?? globalSlug;
     if (collection == null) {
-        throw new Error('deleteVersions requires a collection');
+        throw new Error('deleteVersions requires a collection or globalSlug');
     }
     const locale = addFallbackLocale(args.locale, this.payload);
     const { error, response: httpResponse } = await this.client.POST('/api/v1/document_versions:delete', {
@@ -312,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) {
@@ -342,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) {
@@ -375,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) {
@@ -415,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) {
@@ -447,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) {
@@ -463,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) {
@@ -521,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) {
@@ -570,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) {
@@ -591,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) {
@@ -604,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) {
@@ -621,21 +639,27 @@ async function upsert(args) {
         data: args.data,
         payload: this.payload
     });
+    // `createdAt` is create-time metadata, so seed it on `createOnMissing` (used only when no
+    // document matches) rather than on `doc`. The server preserves an existing document's
+    // `createdAt` on update precisely because `doc` omits it; `updatedAt` is still refreshed on
+    // every write via `dataToContentAPI`. Sending `createdAt` on `doc` would overwrite it on
+    // every update (e.g. repeated `updateGlobal` calls).
+    const createdAt = new Date().toISOString();
     const { data: contentAPIResponse, error, response: httpResponse } = await this.client.POST('/api/v1/documents:update', {
         body: {
             collection: args.collection,
             contentSystemId: this.contentSystemId,
             createOnMissing: {
-                id: documentId
+                id: documentId,
+                createdAt
             },
             doc: dataToContentAPI(this.payload, args.collection, args.data, {
-                applyDefaults: true,
-                createdAt: true
+                applyDefaults: true
             }),
             environmentName: this.environmentName,
             locale,
             schema: this.documentSchema(),
-            where: convertPayloadWhereToContentAPI(args.where)
+            where: convertPayloadWhereToContentAPI(args.where, this.payload, args.collection, false)
         }
     });
     if (error) {
@@ -682,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,
@@ -716,13 +740,13 @@ async function updateJobs(args) {
             payload: this.payload
         }));
 }
-function createGlobal(args) {
+async function createGlobal(args) {
     // Globals are singletons identified by their slug. Use upsert so concurrent calls
     // (e.g. handleSchedules processing multiple queueables with the same null jobStats)
     // don't fail with "A record with this field already exists". The deep-merge semantics
     // of the update path are safe here: callers that want a fresh create (first run) get
     // an effective create, and callers that race a prior create get a merge instead.
-    return this.upsert({
+    const doc = await this.upsert({
         collection: getGlobalSlug(args.slug),
         data: {
             ...args.data,
@@ -734,6 +758,7 @@ function createGlobal(args) {
             }
         }
     });
+    return injectGlobalType(doc, args.slug);
 }
 async function findGlobal(args) {
     const doc = await this.findOne({
@@ -741,17 +766,10 @@ async function findGlobal(args) {
         locale: args.locale,
         where: args.where ?? {}
     });
-    if (doc != null) {
-        ;
-        doc.globalType = args.slug;
-    }
-    return doc;
+    return injectGlobalType(doc, args.slug);
 }
 async function updateGlobal(args) {
-    // TODO: upsert's `createOnMissing` path generates a new `createdAt` on every call,
-    // which overwrites the original timestamp on updates. The fix belongs in the Content API:
-    // `createOnMissing` should preserve `createdAt` on updates and only set it on creates.
-    return this.upsert({
+    const doc = await this.upsert({
         collection: getGlobalSlug(args.slug),
         data: args.data,
         where: {
@@ -760,6 +778,7 @@ async function updateGlobal(args) {
             }
         }
     });
+    return injectGlobalType(doc, args.slug);
 }
 // TODO: remove Omit when this PR is released: https://github.com/payloadcms/payload/pull/15183
 function findGlobalVersions(args) {

package/dist/db-content-api/utilities/data/injectGlobalType.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Payload expects globals to carry a `globalType` (their slug) alongside the stored data.
+ * Globals are stored as `_global-<slug>` collections that have no such column, so the adapter
+ * attaches it to every global document it returns.
+ */
+export declare function injectGlobalType<T>(doc: T, slug: string): T;

package/dist/db-content-api/utilities/data/injectGlobalType.js

@@ -0,0 +1,11 @@
+import { isRecord } from '../isRecord.js';
+/**
+ * Payload expects globals to carry a `globalType` (their slug) alongside the stored data.
+ * Globals are stored as `_global-<slug>` collections that have no such column, so the adapter
+ * attaches it to every global document it returns.
+ */ export function injectGlobalType(doc, slug) {
+    return isRecord(doc) ? {
+        ...doc,
+        globalType: slug
+    } : doc;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * A plain, string-keyed object — the shape that can safely be spread and have
+ * properties read off it without tripping over arrays, `null`, or exotic objects.
+ *
+ * Objects carrying symbol-keyed own properties are rejected: symbol keys are how
+ * libraries tag a value as something more than data, and a spread copies only the
+ * string keys, so treating such a value as a record silently strips the tag.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

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

@@ -0,0 +1,19 @@
+/**
+ * A plain, string-keyed object — the shape that can safely be spread and have
+ * properties read off it without tripping over arrays, `null`, or exotic objects.
+ *
+ * Objects carrying symbol-keyed own properties are rejected: symbol keys are how
+ * libraries tag a value as something more than data, and a spread copies only the
+ * string keys, so treating such a value as a record silently strips the tag.
+ */ export function isRecord(value) {
+    if (value == null) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return false;
+    }
+    return Object.getOwnPropertySymbols(value).length === 0;
+}

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,4 +1,21 @@
-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) {
@@ -10,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)=>{
@@ -42,7 +59,7 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
                 conditions.push({
                     operator: 'equals',
                     path: fieldPath,
-                    value: fieldPath === 'id' && typeof value === 'number' ? String(value) : value
+                    value
                 });
                 continue;
             }
@@ -67,12 +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.
-                if (fieldPath === 'id' && typeof finalValue === 'number') {
-                    finalValue = String(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';