@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/utilities/optimistic.js

@@ -0,0 +1,58 @@
+import { GetCommand } from '@aws-sdk/lib-dynamodb';
+import { APIError } from 'payload';
+import { stripInternalKeys } from './stripInternalKeys.js';
+import { isConditionalCheckFailed } from './writeItems.js';
+/**
+ * Read one row by id with a strongly consistent `GetItem`. The returned
+ * object carries its revision (see `stripInternalKeys`), so it can be handed
+ * to `putItem` as `replaces`.
+ */ export async function getById(adapter, partition, id) {
+    const docClient = adapter.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const result = await docClient.send(new GetCommand({
+        TableName: adapter.tableName,
+        Key: {
+            pk: partition,
+            sk: String(id)
+        },
+        // Strong consistency — Payload assumes read-after-write visibility.
+        ConsistentRead: true
+    }));
+    return result.Item ? stripInternalKeys(result.Item) : null;
+}
+/** Enough to ride out a burst of writers on one row; beyond it something is wrong. */ export const MAX_WRITE_ATTEMPTS = 10;
+/**
+ * Run a read-merge-write until it lands.
+ *
+ * `write` merges onto the row it's given and puts the result with
+ * `replaces: current`. If another writer got in first, the put's revision
+ * check fails; `reread` then fetches the row as it is now and the merge is
+ * redone on top of it — so two concurrent patches to different fields both
+ * survive, instead of the second silently overwriting the first.
+ *
+ * `reread` returning `null` means the row is gone or no longer qualifies;
+ * the result is then `null` and nothing is written.
+ */ export async function writeWithRetry(first, reread, write) {
+    let current = first;
+    for(let attempt = 1; current; attempt++){
+        try {
+            return await write(current);
+        } catch (err) {
+            if (!isConditionalCheckFailed(err)) throw err;
+            if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError();
+            await backoff(attempt);
+            current = await reread();
+        }
+    }
+    return null;
+}
+export function conflictError() {
+    return new APIError(`payload-ddb: the document kept changing while it was being written; gave up after ${MAX_WRITE_ATTEMPTS} attempts.`, 409, null, true);
+}
+/** A short random pause so writers that collided don't collide again in step. */ export function backoff(attempt) {
+    return new Promise((resolve)=>setTimeout(resolve, Math.random() * 5 * attempt));
+}
+
+//# sourceMappingURL=optimistic.js.map

package/dist/utilities/optimistic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/optimistic.ts"],"sourcesContent":["import { GetCommand } from '@aws-sdk/lib-dynamodb'\nimport { APIError } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { stripInternalKeys } from './stripInternalKeys.js'\nimport { isConditionalCheckFailed } from './writeItems.js'\n\ntype Row = Record<string, unknown>\n\n/**\n * Read one row by id with a strongly consistent `GetItem`. The returned\n * object carries its revision (see `stripInternalKeys`), so it can be handed\n * to `putItem` as `replaces`.\n */\nexport async function getById(\n  adapter: DynamoAdapter,\n  partition: string,\n  id: unknown,\n): Promise<null | Row> {\n  const docClient = adapter.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const result = await docClient.send(\n    new GetCommand({\n      TableName: adapter.tableName,\n      Key: { pk: partition, sk: String(id) },\n      // Strong consistency — Payload assumes read-after-write visibility.\n      ConsistentRead: true,\n    }),\n  )\n  return result.Item ? stripInternalKeys(result.Item) : null\n}\n\n/** Enough to ride out a burst of writers on one row; beyond it something is wrong. */\nexport const MAX_WRITE_ATTEMPTS = 10\n\n/**\n * Run a read-merge-write until it lands.\n *\n * `write` merges onto the row it's given and puts the result with\n * `replaces: current`. If another writer got in first, the put's revision\n * check fails; `reread` then fetches the row as it is now and the merge is\n * redone on top of it — so two concurrent patches to different fields both\n * survive, instead of the second silently overwriting the first.\n *\n * `reread` returning `null` means the row is gone or no longer qualifies;\n * the result is then `null` and nothing is written.\n */\nexport async function writeWithRetry<T>(\n  first: null | Row,\n  reread: () => Promise<null | Row>,\n  write: (current: Row) => Promise<T>,\n): Promise<null | T> {\n  let current = first\n\n  for (let attempt = 1; current; attempt++) {\n    try {\n      return await write(current)\n    } catch (err) {\n      if (!isConditionalCheckFailed(err)) throw err\n      if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError()\n      await backoff(attempt)\n      current = await reread()\n    }\n  }\n\n  return null\n}\n\nexport function conflictError(): APIError {\n  return new APIError(\n    `payload-ddb: the document kept changing while it was being written; gave up after ${MAX_WRITE_ATTEMPTS} attempts.`,\n    409,\n    null,\n    true,\n  )\n}\n\n/** A short random pause so writers that collided don't collide again in step. */\nexport function backoff(attempt: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, Math.random() * 5 * attempt))\n}\n"],"names":["GetCommand","APIError","stripInternalKeys","isConditionalCheckFailed","getById","adapter","partition","id","docClient","Error","result","send","TableName","tableName","Key","pk","sk","String","ConsistentRead","Item","MAX_WRITE_ATTEMPTS","writeWithRetry","first","reread","write","current","attempt","err","conflictError","backoff","Promise","resolve","setTimeout","Math","random"],"mappings":"AAAA,SAASA,UAAU,QAAQ,wBAAuB;AAClD,SAASC,QAAQ,QAAQ,UAAS;AAIlC,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,wBAAwB,QAAQ,kBAAiB;AAI1D;;;;CAIC,GACD,OAAO,eAAeC,QACpBC,OAAsB,EACtBC,SAAiB,EACjBC,EAAW;IAEX,MAAMC,YAAYH,QAAQG,SAAS;IACnC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,SAAS,MAAMF,UAAUG,IAAI,CACjC,IAAIX,WAAW;QACbY,WAAWP,QAAQQ,SAAS;QAC5BC,KAAK;YAAEC,IAAIT;YAAWU,IAAIC,OAAOV;QAAI;QACrC,oEAAoE;QACpEW,gBAAgB;IAClB;IAEF,OAAOR,OAAOS,IAAI,GAAGjB,kBAAkBQ,OAAOS,IAAI,IAAI;AACxD;AAEA,oFAAoF,GACpF,OAAO,MAAMC,qBAAqB,GAAE;AAEpC;;;;;;;;;;;CAWC,GACD,OAAO,eAAeC,eACpBC,KAAiB,EACjBC,MAAiC,EACjCC,KAAmC;IAEnC,IAAIC,UAAUH;IAEd,IAAK,IAAII,UAAU,GAAGD,SAASC,UAAW;QACxC,IAAI;YACF,OAAO,MAAMF,MAAMC;QACrB,EAAE,OAAOE,KAAK;YACZ,IAAI,CAACxB,yBAAyBwB,MAAM,MAAMA;YAC1C,IAAID,WAAWN,oBAAoB,MAAMQ;YACzC,MAAMC,QAAQH;YACdD,UAAU,MAAMF;QAClB;IACF;IAEA,OAAO;AACT;AAEA,OAAO,SAASK;IACd,OAAO,IAAI3B,SACT,CAAC,kFAAkF,EAAEmB,mBAAmB,UAAU,CAAC,EACnH,KACA,MACA;AAEJ;AAEA,+EAA+E,GAC/E,OAAO,SAASS,QAAQH,OAAe;IACrC,OAAO,IAAII,QAAQ,CAACC,UAAYC,WAAWD,SAASE,KAAKC,MAAM,KAAK,IAAIR;AAC1E"}

package/dist/utilities/prepareWhere.d.ts

@@ -0,0 +1,63 @@
+import type { Sort, Where } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+import { type ResolvedPath } from './castWhere.js';
+/**
+ * Adapter-facing entry points that turn the `where` (and `sort`) Payload
+ * hands a method into what the stored rows can answer. Every method that
+ * takes a `where` calls one of the `prepare*Where` functions first.
+ *
+ * Preparation is two passes:
+ *
+ *  1. **Relationship paths are resolved.** `author.name equals 'x'` can't be
+ *     answered from a row that only stores the author's id, so the nested
+ *     part runs as its own query against the related collection and the
+ *     clause becomes `author in [matching ids]`. Multi-hop paths recurse.
+ *     This is the same strategy as Payload's Mongo adapter.
+ *  2. **`castWhere`** casts operands, inserts locale keys and marks paths the
+ *     pushdown can't address.
+ *
+ * Each entry point returns `where` untouched when the slug isn't in the
+ * config — same "skip, don't kill the operation" stance as `resolveSchema`.
+ */
+/** What a `where` is aimed at: one of the four kinds of partition. */
+export type QueryTarget = {
+    kind: 'collection';
+    slug: string;
+} | {
+    kind: 'collectionVersions';
+    slug: string;
+} | {
+    kind: 'global';
+    slug: string;
+} | {
+    kind: 'globalVersions';
+    slug: string;
+};
+/** `where` in document terms, against a collection's main partition. */
+export declare function prepareCollectionWhere(adapter: DynamoAdapter, slug: string, where: undefined | Where, locale?: string): Promise<undefined | Where>;
+/** `where` against a global's singleton row. */
+export declare function prepareGlobalWhere(adapter: DynamoAdapter, slug: string, where: undefined | Where, locale?: string): Promise<undefined | Where>;
+/**
+ * `where` in version-row terms (`parent`, `latest`, `version.<field>`, …),
+ * against the versions partition of a collection or global.
+ */
+export declare function prepareVersionsWhere(adapter: DynamoAdapter, parent: {
+    kind: 'collection' | 'global';
+    slug: string;
+}, where: undefined | Where, locale?: string): Promise<undefined | Where>;
+export declare function prepareWhere(adapter: DynamoAdapter, target: QueryTarget, where: undefined | Where, locale?: string): Promise<undefined | Where>;
+/**
+ * Give each sort key its stored path — today that means inserting the locale
+ * key after a localized field, so `title` sorts by `title.en` rather than by
+ * the `{ en, es }` map it lives in.
+ */
+export declare function prepareSort(adapter: DynamoAdapter, target: QueryTarget, sort: Sort | undefined, locale?: string): Sort | undefined;
+/**
+ * Look a path up in a target's schema for this request: the field it names,
+ * and the path its value is actually stored under (`title` → `title.en`).
+ * For callers that read values back out of rows rather than filter on them.
+ */
+export declare function resolveStoredPath(adapter: DynamoAdapter, target: QueryTarget, path: string, locale?: string): ResolvedPath;
+/** The locale a request resolves to, or `null` when localization is off. */
+export declare function effectiveLocale(adapter: DynamoAdapter, locale?: string): null | string;
+//# sourceMappingURL=prepareWhere.d.ts.map

package/dist/utilities/prepareWhere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareWhere.d.ts","sourceRoot":"","sources":["../../src/utilities/prepareWhere.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAI1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,EAIL,KAAK,YAAY,EAElB,MAAM,gBAAgB,CAAA;AAGvB;;;;;;;;;;;;;;;;;GAiBG;AAEH,sEAAsE;AACtE,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5C,wEAAwE;AACxE,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,GAAG,KAAK,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAE5B;AAED,gDAAgD;AAChD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,GAAG,KAAK,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAE5B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE;IAAE,IAAI,EAAE,YAAY,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACvD,KAAK,EAAE,SAAS,GAAG,KAAK,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAO5B;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,SAAS,GAAG,KAAK,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAK5B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,MAAM,CAAC,EAAE,MAAM,GACd,IAAI,GAAG,SAAS,CAYlB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,YAAY,CAKd;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAItF"}

package/dist/utilities/prepareWhere.js

@@ -0,0 +1,198 @@
+import { buildVersionCollectionFields, buildVersionGlobalFields } from 'payload';
+import { castWhere, resolvePath } from './castWhere.js';
+import { queryMatching } from './queryMatching.js';
+/** `where` in document terms, against a collection's main partition. */ export function prepareCollectionWhere(adapter, slug, where, locale) {
+    return prepareWhere(adapter, {
+        kind: 'collection',
+        slug
+    }, where, locale);
+}
+/** `where` against a global's singleton row. */ export function prepareGlobalWhere(adapter, slug, where, locale) {
+    return prepareWhere(adapter, {
+        kind: 'global',
+        slug
+    }, where, locale);
+}
+/**
+ * `where` in version-row terms (`parent`, `latest`, `version.<field>`, …),
+ * against the versions partition of a collection or global.
+ */ export function prepareVersionsWhere(adapter, parent, where, locale) {
+    return prepareWhere(adapter, {
+        kind: parent.kind === 'collection' ? 'collectionVersions' : 'globalVersions',
+        slug: parent.slug
+    }, where, locale);
+}
+export async function prepareWhere(adapter, target, where, locale) {
+    if (!where) return where;
+    const ctx = contextFor(adapter, target, locale);
+    if (!ctx) return where;
+    return castWhere(await resolveRelationshipPaths(adapter, where, ctx, locale), ctx);
+}
+/**
+ * Give each sort key its stored path — today that means inserting the locale
+ * key after a localized field, so `title` sorts by `title.en` rather than by
+ * the `{ en, es }` map it lives in.
+ */ export function prepareSort(adapter, target, sort, locale) {
+    if (!sort) return sort;
+    const ctx = contextFor(adapter, target, locale);
+    if (!ctx?.localization) return sort;
+    const localize = (key)=>{
+        if (!key) return key;
+        const descending = key.startsWith('-');
+        const { path } = resolvePath(ctx.fields, descending ? key.slice(1) : key, ctx.localization);
+        return descending ? `-${path}` : path;
+    };
+    return Array.isArray(sort) ? sort.map(localize) : localize(sort);
+}
+/**
+ * Look a path up in a target's schema for this request: the field it names,
+ * and the path its value is actually stored under (`title` → `title.en`).
+ * For callers that read values back out of rows rather than filter on them.
+ */ export function resolveStoredPath(adapter, target, path, locale) {
+    const ctx = contextFor(adapter, target, locale);
+    return ctx ? resolvePath(ctx.fields, path, ctx.localization) : {
+        field: null,
+        multi: false,
+        path
+    };
+}
+/** The locale a request resolves to, or `null` when localization is off. */ export function effectiveLocale(adapter, locale) {
+    const localization = adapter.payload?.config?.localization;
+    if (!localization) return null;
+    return locale && locale !== 'all' && locale !== '*' ? locale : localization.defaultLocale;
+}
+/**
+ * Find the first point where a path steps through a relationship into the
+ * related collection's own fields. Polymorphic relationships are skipped:
+ * their sub-keys (`.value`, `.relationTo`) are stored on the row itself, and
+ * a path through them doesn't say which collection to ask.
+ */ function findRelationshipHop(fields, path) {
+    const segments = path.split('.');
+    let current = fields;
+    for(let index = 0; index < segments.length - 1; index++){
+        const field = current.find((candidate)=>candidate.name === segments[index]);
+        if (!field) return null;
+        if (field.type === 'relationship' || field.type === 'upload') {
+            if (typeof field.relationTo !== 'string') return null;
+            return {
+                prefix: segments.slice(0, index + 1).join('.'),
+                relationTo: field.relationTo,
+                rest: segments.slice(index + 1).join('.')
+            };
+        }
+        if ('flattenedFields' in field) {
+            current = field.flattenedFields;
+        } else if (field.type === 'blocks') {
+            current = field.blocks.flatMap((block)=>block.flattenedFields);
+        } else {
+            return null;
+        }
+    }
+    return null;
+}
+async function resolveRelationshipPaths(adapter, where, ctx, locale) {
+    const out = {};
+    const resolved = [];
+    for (const [key, raw] of Object.entries(where)){
+        if (key === 'and' || key === 'or') {
+            out[key] = Array.isArray(raw) ? await Promise.all(raw.map((sub)=>sub && typeof sub === 'object' ? resolveRelationshipPaths(adapter, sub, ctx, locale) : sub)) : raw;
+            continue;
+        }
+        const hop = raw && typeof raw === 'object' && !Array.isArray(raw) ? findRelationshipHop(ctx.fields, key) : null;
+        if (!hop) {
+            out[key] = raw;
+            continue;
+        }
+        if (hop.rest === 'id') {
+            // `author.id` is the value the row already stores under `author`.
+            resolved.push({
+                [hop.prefix]: raw
+            });
+            continue;
+        }
+        const related = await queryMatching(adapter, adapter.resolvePartition(hop.relationTo), // Preparing against the related collection is what makes multi-hop
+        // paths (`author.team.name`) work: the next hop resolves there.
+        await prepareCollectionWhere(adapter, hop.relationTo, {
+            [hop.rest]: raw
+        }, locale));
+        // No matches leaves `in: []`, which both evaluators read as "match
+        // nothing" — the right answer.
+        resolved.push({
+            [hop.prefix]: {
+                in: related.map((doc)=>doc['id'])
+            }
+        });
+    }
+    if (resolved.length > 0) {
+        // AND-ed alongside the rest, so a resolved clause can't overwrite one
+        // the caller put on the relationship field directly.
+        out.and = [
+            ...Array.isArray(out.and) ? out.and : [],
+            ...resolved
+        ];
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Schema lookup
+// ---------------------------------------------------------------------------
+function idTypeOf(adapter, collectionSlug) {
+    return adapter.payload?.collections?.[collectionSlug]?.customIDType ?? adapter.defaultIDType;
+}
+function contextFor(adapter, target, locale) {
+    const fields = fieldsFor(adapter, target);
+    if (!fields) return null;
+    const localization = adapter.payload.config.localization;
+    return {
+        fields,
+        // Only a collection's own rows can have numeric ids; globals are keyed
+        // by slug and version rows by UUIDs the adapter generates.
+        idType: target.kind === 'collection' ? idTypeOf(adapter, target.slug) : 'text',
+        idTypeOf: (related)=>idTypeOf(adapter, related),
+        ...localization ? {
+            localization: {
+                // `all` / `*` ask for every locale at once, which a single stored
+                // path can't express; fall back to the default like a missing one.
+                locale: effectiveLocale(adapter, locale) ?? localization.defaultLocale,
+                localeCodes: localization.localeCodes
+            }
+        } : {}
+    };
+}
+const versionFieldsCache = new WeakMap();
+function fieldsFor(adapter, target) {
+    const config = adapter.payload?.config;
+    if (!config) return null;
+    const collection = ()=>adapter.payload.collections?.[target.slug]?.config;
+    const global = ()=>config.globals?.find((candidate)=>candidate.slug === target.slug);
+    switch(target.kind){
+        case 'collection':
+            return collection()?.flattenedFields ?? null;
+        case 'global':
+            return global()?.flattenedFields ?? null;
+        default:
+            {
+                // Version-row fields are derived, so build them once per slug.
+                let cache = versionFieldsCache.get(adapter);
+                if (!cache) {
+                    cache = new Map();
+                    versionFieldsCache.set(adapter, cache);
+                }
+                const cacheKey = `${target.kind}:${target.slug}`;
+                const cached = cache.get(cacheKey);
+                if (cached) return cached;
+                let fields = null;
+                if (target.kind === 'collectionVersions') {
+                    const entity = collection();
+                    if (entity) fields = buildVersionCollectionFields(config, entity, true);
+                } else {
+                    const entity = global();
+                    if (entity) fields = buildVersionGlobalFields(config, entity, true);
+                }
+                if (fields) cache.set(cacheKey, fields);
+                return fields;
+            }
+    }
+}
+
+//# sourceMappingURL=prepareWhere.js.map

package/dist/utilities/prepareWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/prepareWhere.ts"],"sourcesContent":["import type { FlattenedField, Sort, Where } from 'payload'\n\nimport { buildVersionCollectionFields, buildVersionGlobalFields } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport {\n  type CastContext,\n  castWhere,\n  type IdType,\n  type ResolvedPath,\n  resolvePath,\n} from './castWhere.js'\nimport { queryMatching } from './queryMatching.js'\n\n/**\n * Adapter-facing entry points that turn the `where` (and `sort`) Payload\n * hands a method into what the stored rows can answer. Every method that\n * takes a `where` calls one of the `prepare*Where` functions first.\n *\n * Preparation is two passes:\n *\n *  1. **Relationship paths are resolved.** `author.name equals 'x'` can't be\n *     answered from a row that only stores the author's id, so the nested\n *     part runs as its own query against the related collection and the\n *     clause becomes `author in [matching ids]`. Multi-hop paths recurse.\n *     This is the same strategy as Payload's Mongo adapter.\n *  2. **`castWhere`** casts operands, inserts locale keys and marks paths the\n *     pushdown can't address.\n *\n * Each entry point returns `where` untouched when the slug isn't in the\n * config — same \"skip, don't kill the operation\" stance as `resolveSchema`.\n */\n\n/** What a `where` is aimed at: one of the four kinds of partition. */\nexport type QueryTarget =\n  | { kind: 'collection'; slug: string }\n  | { kind: 'collectionVersions'; slug: string }\n  | { kind: 'global'; slug: string }\n  | { kind: 'globalVersions'; slug: string }\n\n/** `where` in document terms, against a collection's main partition. */\nexport function prepareCollectionWhere(\n  adapter: DynamoAdapter,\n  slug: string,\n  where: undefined | Where,\n  locale?: string,\n): Promise<undefined | Where> {\n  return prepareWhere(adapter, { kind: 'collection', slug }, where, locale)\n}\n\n/** `where` against a global's singleton row. */\nexport function prepareGlobalWhere(\n  adapter: DynamoAdapter,\n  slug: string,\n  where: undefined | Where,\n  locale?: string,\n): Promise<undefined | Where> {\n  return prepareWhere(adapter, { kind: 'global', slug }, where, locale)\n}\n\n/**\n * `where` in version-row terms (`parent`, `latest`, `version.<field>`, …),\n * against the versions partition of a collection or global.\n */\nexport function prepareVersionsWhere(\n  adapter: DynamoAdapter,\n  parent: { kind: 'collection' | 'global'; slug: string },\n  where: undefined | Where,\n  locale?: string,\n): Promise<undefined | Where> {\n  return prepareWhere(\n    adapter,\n    { kind: parent.kind === 'collection' ? 'collectionVersions' : 'globalVersions', slug: parent.slug },\n    where,\n    locale,\n  )\n}\n\nexport async function prepareWhere(\n  adapter: DynamoAdapter,\n  target: QueryTarget,\n  where: undefined | Where,\n  locale?: string,\n): Promise<undefined | Where> {\n  if (!where) return where\n  const ctx = contextFor(adapter, target, locale)\n  if (!ctx) return where\n  return castWhere(await resolveRelationshipPaths(adapter, where, ctx, locale), ctx)\n}\n\n/**\n * Give each sort key its stored path — today that means inserting the locale\n * key after a localized field, so `title` sorts by `title.en` rather than by\n * the `{ en, es }` map it lives in.\n */\nexport function prepareSort(\n  adapter: DynamoAdapter,\n  target: QueryTarget,\n  sort: Sort | undefined,\n  locale?: string,\n): Sort | undefined {\n  if (!sort) return sort\n  const ctx = contextFor(adapter, target, locale)\n  if (!ctx?.localization) return sort\n\n  const localize = (key: string): string => {\n    if (!key) return key\n    const descending = key.startsWith('-')\n    const { path } = resolvePath(ctx.fields, descending ? key.slice(1) : key, ctx.localization)\n    return descending ? `-${path}` : path\n  }\n  return Array.isArray(sort) ? sort.map(localize) : localize(sort)\n}\n\n/**\n * Look a path up in a target's schema for this request: the field it names,\n * and the path its value is actually stored under (`title` → `title.en`).\n * For callers that read values back out of rows rather than filter on them.\n */\nexport function resolveStoredPath(\n  adapter: DynamoAdapter,\n  target: QueryTarget,\n  path: string,\n  locale?: string,\n): ResolvedPath {\n  const ctx = contextFor(adapter, target, locale)\n  return ctx\n    ? resolvePath(ctx.fields, path, ctx.localization)\n    : { field: null, multi: false, path }\n}\n\n/** The locale a request resolves to, or `null` when localization is off. */\nexport function effectiveLocale(adapter: DynamoAdapter, locale?: string): null | string {\n  const localization = adapter.payload?.config?.localization\n  if (!localization) return null\n  return locale && locale !== 'all' && locale !== '*' ? locale : localization.defaultLocale\n}\n\n// ---------------------------------------------------------------------------\n// Relationship paths\n// ---------------------------------------------------------------------------\n\ntype RelationshipHop = {\n  /** Path of the relationship field itself, e.g. `author`. */\n  prefix: string\n  relationTo: string\n  /** What's left to ask of the related collection, e.g. `name`. */\n  rest: string\n}\n\n/**\n * Find the first point where a path steps through a relationship into the\n * related collection's own fields. Polymorphic relationships are skipped:\n * their sub-keys (`.value`, `.relationTo`) are stored on the row itself, and\n * a path through them doesn't say which collection to ask.\n */\nfunction findRelationshipHop(fields: FlattenedField[], path: string): null | RelationshipHop {\n  const segments = path.split('.')\n  let current = fields\n\n  for (let index = 0; index < segments.length - 1; index++) {\n    const field = current.find((candidate) => candidate.name === segments[index])\n    if (!field) return null\n\n    if (field.type === 'relationship' || field.type === 'upload') {\n      if (typeof field.relationTo !== 'string') return null\n      return {\n        prefix: segments.slice(0, index + 1).join('.'),\n        relationTo: field.relationTo,\n        rest: segments.slice(index + 1).join('.'),\n      }\n    }\n\n    if ('flattenedFields' in field) {\n      current = field.flattenedFields\n    } else if (field.type === 'blocks') {\n      current = field.blocks.flatMap((block) => block.flattenedFields)\n    } else {\n      return null\n    }\n  }\n\n  return null\n}\n\nasync function resolveRelationshipPaths(\n  adapter: DynamoAdapter,\n  where: Where,\n  ctx: CastContext,\n  locale: string | undefined,\n): Promise<Where> {\n  const out: Where = {}\n  const resolved: Where[] = []\n\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and' || key === 'or') {\n      out[key] = Array.isArray(raw)\n        ? await Promise.all(\n            raw.map((sub) =>\n              sub && typeof sub === 'object'\n                ? resolveRelationshipPaths(adapter, sub, ctx, locale)\n                : sub,\n            ),\n          )\n        : (raw as Where[])\n      continue\n    }\n\n    const hop =\n      raw && typeof raw === 'object' && !Array.isArray(raw)\n        ? findRelationshipHop(ctx.fields, key)\n        : null\n    if (!hop) {\n      out[key] = raw as Where[string]\n      continue\n    }\n\n    if (hop.rest === 'id') {\n      // `author.id` is the value the row already stores under `author`.\n      resolved.push({ [hop.prefix]: raw as Where[string] })\n      continue\n    }\n\n    const related = await queryMatching(\n      adapter,\n      adapter.resolvePartition(hop.relationTo),\n      // Preparing against the related collection is what makes multi-hop\n      // paths (`author.team.name`) work: the next hop resolves there.\n      await prepareCollectionWhere(\n        adapter,\n        hop.relationTo,\n        { [hop.rest]: raw as Where[string] },\n        locale,\n      ),\n    )\n    // No matches leaves `in: []`, which both evaluators read as \"match\n    // nothing\" — the right answer.\n    resolved.push({ [hop.prefix]: { in: related.map((doc) => doc['id']) as never } })\n  }\n\n  if (resolved.length > 0) {\n    // AND-ed alongside the rest, so a resolved clause can't overwrite one\n    // the caller put on the relationship field directly.\n    out.and = [...(Array.isArray(out.and) ? out.and : []), ...resolved]\n  }\n  return out\n}\n\n// ---------------------------------------------------------------------------\n// Schema lookup\n// ---------------------------------------------------------------------------\n\nfunction idTypeOf(adapter: DynamoAdapter, collectionSlug: string): IdType {\n  return adapter.payload?.collections?.[collectionSlug]?.customIDType ?? adapter.defaultIDType\n}\n\nfunction contextFor(\n  adapter: DynamoAdapter,\n  target: QueryTarget,\n  locale: string | undefined,\n): CastContext | null {\n  const fields = fieldsFor(adapter, target)\n  if (!fields) return null\n\n  const localization = adapter.payload.config.localization\n  return {\n    fields,\n    // Only a collection's own rows can have numeric ids; globals are keyed\n    // by slug and version rows by UUIDs the adapter generates.\n    idType: target.kind === 'collection' ? idTypeOf(adapter, target.slug) : 'text',\n    idTypeOf: (related) => idTypeOf(adapter, related),\n    ...(localization\n      ? {\n          localization: {\n            // `all` / `*` ask for every locale at once, which a single stored\n            // path can't express; fall back to the default like a missing one.\n            locale: effectiveLocale(adapter, locale) ?? localization.defaultLocale,\n            localeCodes: localization.localeCodes,\n          },\n        }\n      : {}),\n  }\n}\n\nconst versionFieldsCache = new WeakMap<DynamoAdapter, Map<string, FlattenedField[]>>()\n\nfunction fieldsFor(adapter: DynamoAdapter, target: QueryTarget): FlattenedField[] | null {\n  const config = adapter.payload?.config\n  if (!config) return null\n\n  const collection = () => adapter.payload.collections?.[target.slug]?.config\n  const global = () => config.globals?.find((candidate) => candidate.slug === target.slug)\n\n  switch (target.kind) {\n    case 'collection':\n      return collection()?.flattenedFields ?? null\n    case 'global':\n      return global()?.flattenedFields ?? null\n    default: {\n      // Version-row fields are derived, so build them once per slug.\n      let cache = versionFieldsCache.get(adapter)\n      if (!cache) {\n        cache = new Map()\n        versionFieldsCache.set(adapter, cache)\n      }\n      const cacheKey = `${target.kind}:${target.slug}`\n      const cached = cache.get(cacheKey)\n      if (cached) return cached\n\n      let fields: FlattenedField[] | null = null\n      if (target.kind === 'collectionVersions') {\n        const entity = collection()\n        if (entity) fields = buildVersionCollectionFields(config, entity, true)\n      } else {\n        const entity = global()\n        if (entity) fields = buildVersionGlobalFields(config, entity, true)\n      }\n      if (fields) cache.set(cacheKey, fields)\n      return fields\n    }\n  }\n}\n"],"names":["buildVersionCollectionFields","buildVersionGlobalFields","castWhere","resolvePath","queryMatching","prepareCollectionWhere","adapter","slug","where","locale","prepareWhere","kind","prepareGlobalWhere","prepareVersionsWhere","parent","target","ctx","contextFor","resolveRelationshipPaths","prepareSort","sort","localization","localize","key","descending","startsWith","path","fields","slice","Array","isArray","map","resolveStoredPath","field","multi","effectiveLocale","payload","config","defaultLocale","findRelationshipHop","segments","split","current","index","length","find","candidate","name","type","relationTo","prefix","join","rest","flattenedFields","blocks","flatMap","block","out","resolved","raw","Object","entries","Promise","all","sub","hop","push","related","resolvePartition","in","doc","and","idTypeOf","collectionSlug","collections","customIDType","defaultIDType","fieldsFor","idType","localeCodes","versionFieldsCache","WeakMap","collection","global","globals","cache","get","Map","set","cacheKey","cached","entity"],"mappings":"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"}

package/dist/utilities/queryCount.d.ts

@@ -1,9 +1,12 @@
 import type { Where } from 'payload';
 import type { DynamoAdapter } from '../types.js';
 /**
- * Paginated count over a single partition with optional `FilterExpression`
- * pushdown. Uses `Select: 'COUNT'` so DynamoDB doesn't ship item bytes —
- * only the post-filter `Count` per page comes back over the wire.
+ * Count the rows of a partition matching `where`.
+ *
+ * When the whole `where` can be pushed down, DynamoDB does the counting
+ * (`Select: 'COUNT'`) and no item bytes cross the wire. Otherwise the only
+ * correct count is "fetch the candidates and count the ones `matchesWhere`
+ * accepts" — which is exactly what `queryMatching` does.
  */
 export declare function queryCount(adapter: DynamoAdapter, partition: string, where: undefined | Where): Promise<number>;
 //# sourceMappingURL=queryCount.d.ts.map

package/dist/utilities/queryCount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryCount.d.ts","sourceRoot":"","sources":["../../src/utilities/queryCount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMhD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,OAAO,CAAC,MAAM,CAAC,CAiDjB"}
+{"version":3,"file":"queryCount.d.ts","sourceRoot":"","sources":["../../src/utilities/queryCount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMhD;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,OAAO,CAAC,MAAM,CAAC,CAgBjB"}

package/dist/utilities/queryCount.js

@@ -1,54 +1,25 @@
-import { QueryCommand } from '@aws-sdk/lib-dynamodb';
 import { buildFilterExpression } from './buildFilterExpression.js';
-import { whereHasJsOnlyOperator } from './operators.js';
 import { queryMatching } from './queryMatching.js';
+import { partitionPages } from './queryPartition.js';
 /**
- * Paginated count over a single partition with optional `FilterExpression`
- * pushdown. Uses `Select: 'COUNT'` so DynamoDB doesn't ship item bytes —
- * only the post-filter `Count` per page comes back over the wire.
+ * Count the rows of a partition matching `where`.
+ *
+ * When the whole `where` can be pushed down, DynamoDB does the counting
+ * (`Select: 'COUNT'`) and no item bytes cross the wire. Otherwise the only
+ * correct count is "fetch the candidates and count the ones `matchesWhere`
+ * accepts" — which is exactly what `queryMatching` does.
  */ export async function queryCount(adapter, partition, where) {
-    const docClient = adapter.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
-    // JS-only operators (e.g. `like`) can't be expressed in `FilterExpression`,
-    // so the only correct count is "fetch and count the matches in memory".
-    // Loses the `Select: 'COUNT'` byte-savings but keeps semantics consistent
-    // with `queryMatching`.
-    if (whereHasJsOnlyOperator(where)) {
-        const matched = await queryMatching(adapter, partition, where);
-        return matched.length;
-    }
-    const filter = buildFilterExpression(where);
+    const compiled = buildFilterExpression(where);
     // Always-false predicate (e.g. `in: []`) → zero rows without a round-trip.
-    if (filter === null) return 0;
+    if (compiled.never) return 0;
+    if (!compiled.exact) {
+        return (await queryMatching(adapter, partition, where)).length;
+    }
     let totalDocs = 0;
-    let exclusiveStartKey;
-    while(true){
-        const result = await docClient.send(new QueryCommand({
-            TableName: adapter.tableName,
-            KeyConditionExpression: '#pk = :pk',
-            ExpressionAttributeNames: {
-                '#pk': 'pk',
-                ...filter?.names ?? {}
-            },
-            ExpressionAttributeValues: {
-                ':pk': partition,
-                ...filter?.values ?? {}
-            },
-            // Strong consistency — see `queryMatching` for rationale.
-            ConsistentRead: true,
-            Select: 'COUNT',
-            ...filter ? {
-                FilterExpression: filter.expression
-            } : {},
-            ...exclusiveStartKey ? {
-                ExclusiveStartKey: exclusiveStartKey
-            } : {}
-        }));
-        totalDocs += result.Count ?? 0;
-        if (!result.LastEvaluatedKey) break;
-        exclusiveStartKey = result.LastEvaluatedKey;
+    for await (const page of partitionPages(adapter, partition, compiled.filter, {
+        countOnly: true
+    })){
+        totalDocs += page.count;
     }
     return totalDocs;
 }

package/dist/utilities/queryCount.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/queryCount.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { QueryCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { buildFilterExpression } from './buildFilterExpression.js'\nimport { whereHasJsOnlyOperator } from './operators.js'\nimport { queryMatching } from './queryMatching.js'\n\n/**\n * Paginated count over a single partition with optional `FilterExpression`\n * pushdown. Uses `Select: 'COUNT'` so DynamoDB doesn't ship item bytes —\n * only the post-filter `Count` per page comes back over the wire.\n */\nexport async function queryCount(\n  adapter: DynamoAdapter,\n  partition: string,\n  where: undefined | Where,\n): Promise<number> {\n  const docClient = adapter.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  // JS-only operators (e.g. `like`) can't be expressed in `FilterExpression`,\n  // so the only correct count is \"fetch and count the matches in memory\".\n  // Loses the `Select: 'COUNT'` byte-savings but keeps semantics consistent\n  // with `queryMatching`.\n  if (whereHasJsOnlyOperator(where)) {\n    const matched = await queryMatching(adapter, partition, where)\n    return matched.length\n  }\n\n  const filter = buildFilterExpression(where)\n  // Always-false predicate (e.g. `in: []`) → zero rows without a round-trip.\n  if (filter === null) return 0\n  let totalDocs = 0\n  let exclusiveStartKey: Record<string, unknown> | undefined\n\n  while (true) {\n    const result = await docClient.send(\n      new QueryCommand({\n        TableName: adapter.tableName,\n        KeyConditionExpression: '#pk = :pk',\n        ExpressionAttributeNames: {\n          '#pk': 'pk',\n          ...(filter?.names ?? {}),\n        },\n        ExpressionAttributeValues: {\n          ':pk': partition,\n          ...(filter?.values ?? {}),\n        },\n        // Strong consistency — see `queryMatching` for rationale.\n        ConsistentRead: true,\n        Select: 'COUNT',\n        ...(filter ? { FilterExpression: filter.expression } : {}),\n        ...(exclusiveStartKey ? { ExclusiveStartKey: exclusiveStartKey } : {}),\n      }),\n    )\n\n    totalDocs += result.Count ?? 0\n\n    if (!result.LastEvaluatedKey) break\n    exclusiveStartKey = result.LastEvaluatedKey\n  }\n\n  return totalDocs\n}\n"],"names":["QueryCommand","buildFilterExpression","whereHasJsOnlyOperator","queryMatching","queryCount","adapter","partition","where","docClient","Error","matched","length","filter","totalDocs","exclusiveStartKey","result","send","TableName","tableName","KeyConditionExpression","ExpressionAttributeNames","names","ExpressionAttributeValues","values","ConsistentRead","Select","FilterExpression","expression","ExclusiveStartKey","Count","LastEvaluatedKey"],"mappings":"AAEA,SAASA,YAAY,QAAQ,wBAAuB;AAIpD,SAASC,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,qBAAoB;AAElD;;;;CAIC,GACD,OAAO,eAAeC,WACpBC,OAAsB,EACtBC,SAAiB,EACjBC,KAAwB;IAExB,MAAMC,YAAYH,QAAQG,SAAS;IACnC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,4EAA4E;IAC5E,wEAAwE;IACxE,0EAA0E;IAC1E,wBAAwB;IACxB,IAAIP,uBAAuBK,QAAQ;QACjC,MAAMG,UAAU,MAAMP,cAAcE,SAASC,WAAWC;QACxD,OAAOG,QAAQC,MAAM;IACvB;IAEA,MAAMC,SAASX,sBAAsBM;IACrC,2EAA2E;IAC3E,IAAIK,WAAW,MAAM,OAAO;IAC5B,IAAIC,YAAY;IAChB,IAAIC;IAEJ,MAAO,KAAM;QACX,MAAMC,SAAS,MAAMP,UAAUQ,IAAI,CACjC,IAAIhB,aAAa;YACfiB,WAAWZ,QAAQa,SAAS;YAC5BC,wBAAwB;YACxBC,0BAA0B;gBACxB,OAAO;gBACP,GAAIR,QAAQS,SAAS,CAAC,CAAC;YACzB;YACAC,2BAA2B;gBACzB,OAAOhB;gBACP,GAAIM,QAAQW,UAAU,CAAC,CAAC;YAC1B;YACA,0DAA0D;YAC1DC,gBAAgB;YAChBC,QAAQ;YACR,GAAIb,SAAS;gBAAEc,kBAAkBd,OAAOe,UAAU;YAAC,IAAI,CAAC,CAAC;YACzD,GAAIb,oBAAoB;gBAAEc,mBAAmBd;YAAkB,IAAI,CAAC,CAAC;QACvE;QAGFD,aAAaE,OAAOc,KAAK,IAAI;QAE7B,IAAI,CAACd,OAAOe,gBAAgB,EAAE;QAC9BhB,oBAAoBC,OAAOe,gBAAgB;IAC7C;IAEA,OAAOjB;AACT"}
+{"version":3,"sources":["../../src/utilities/queryCount.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { buildFilterExpression } from './buildFilterExpression.js'\nimport { queryMatching } from './queryMatching.js'\nimport { partitionPages } from './queryPartition.js'\n\n/**\n * Count the rows of a partition matching `where`.\n *\n * When the whole `where` can be pushed down, DynamoDB does the counting\n * (`Select: 'COUNT'`) and no item bytes cross the wire. Otherwise the only\n * correct count is \"fetch the candidates and count the ones `matchesWhere`\n * accepts\" — which is exactly what `queryMatching` does.\n */\nexport async function queryCount(\n  adapter: DynamoAdapter,\n  partition: string,\n  where: undefined | Where,\n): Promise<number> {\n  const compiled = buildFilterExpression(where)\n  // Always-false predicate (e.g. `in: []`) → zero rows without a round-trip.\n  if (compiled.never) return 0\n\n  if (!compiled.exact) {\n    return (await queryMatching(adapter, partition, where)).length\n  }\n\n  let totalDocs = 0\n  for await (const page of partitionPages(adapter, partition, compiled.filter, {\n    countOnly: true,\n  })) {\n    totalDocs += page.count\n  }\n  return totalDocs\n}\n"],"names":["buildFilterExpression","queryMatching","partitionPages","queryCount","adapter","partition","where","compiled","never","exact","length","totalDocs","page","filter","countOnly","count"],"mappings":"AAIA,SAASA,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,cAAc,QAAQ,sBAAqB;AAEpD;;;;;;;CAOC,GACD,OAAO,eAAeC,WACpBC,OAAsB,EACtBC,SAAiB,EACjBC,KAAwB;IAExB,MAAMC,WAAWP,sBAAsBM;IACvC,2EAA2E;IAC3E,IAAIC,SAASC,KAAK,EAAE,OAAO;IAE3B,IAAI,CAACD,SAASE,KAAK,EAAE;QACnB,OAAO,AAAC,CAAA,MAAMR,cAAcG,SAASC,WAAWC,MAAK,EAAGI,MAAM;IAChE;IAEA,IAAIC,YAAY;IAChB,WAAW,MAAMC,QAAQV,eAAeE,SAASC,WAAWE,SAASM,MAAM,EAAE;QAC3EC,WAAW;IACb,GAAI;QACFH,aAAaC,KAAKG,KAAK;IACzB;IACA,OAAOJ;AACT"}

package/dist/utilities/queryMatching.d.ts

@@ -1,18 +1,19 @@
 import type { Where } from 'payload';
 import type { DynamoAdapter } from '../types.js';
 /**
- * Walk a partition via paginated `Query` (`pk = :partition`), pushing the
- * caller's `where` into `FilterExpression` so non-matching rows are skipped
+ * Walk a partition, pushing as much of the caller's `where` into
+ * `FilterExpression` as DynamoDB can express so non-matching rows are skipped
  * server-side. Returns every matching item materialized in memory — suitable
  * for callers that need the full set (sort, paginate, bulk-mutate).
  *
+ * When the pushed-down filter isn't the whole `where` (a JS-only operator
+ * such as `like`, or a path through an array), each returned row is
+ * re-checked with `matchesWhere`. The expressible clauses still narrow the
+ * read, so a `where` that mixes both kinds no longer pulls the entire
+ * partition over the wire.
+ *
  * Use `findFirst` instead when you only need the first match: that helper
  * stops on the first hit.
- *
- * Cost note: `FilterExpression` reduces network bytes but not RCU
- * consumption. DynamoDB still reads every row in the partition before
- * filtering. The next meaningful optimization is GSIs that mirror specific
- * access patterns (e.g. `email` for auth, `slug` for public collections).
  */
 export declare function queryMatching(adapter: DynamoAdapter, partition: string, where: undefined | Where): Promise<Record<string, unknown>[]>;
 //# sourceMappingURL=queryMatching.d.ts.map

package/dist/utilities/queryMatching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryMatching.d.ts","sourceRoot":"","sources":["../../src/utilities/queryMatching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAOhD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAoDpC"}
+{"version":3,"file":"queryMatching.d.ts","sourceRoot":"","sources":["../../src/utilities/queryMatching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAOhD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAcpC"}

package/dist/utilities/queryMatching.js

@@ -1,69 +1,32 @@
-import { QueryCommand } from '@aws-sdk/lib-dynamodb';
 import { buildFilterExpression } from './buildFilterExpression.js';
 import { matchesWhere } from './matchesWhere.js';
-import { whereHasJsOnlyOperator } from './operators.js';
+import { partitionPages } from './queryPartition.js';
 import { stripInternalKeys } from './stripInternalKeys.js';
 /**
- * Walk a partition via paginated `Query` (`pk = :partition`), pushing the
- * caller's `where` into `FilterExpression` so non-matching rows are skipped
+ * Walk a partition, pushing as much of the caller's `where` into
+ * `FilterExpression` as DynamoDB can express so non-matching rows are skipped
  * server-side. Returns every matching item materialized in memory — suitable
  * for callers that need the full set (sort, paginate, bulk-mutate).
  *
+ * When the pushed-down filter isn't the whole `where` (a JS-only operator
+ * such as `like`, or a path through an array), each returned row is
+ * re-checked with `matchesWhere`. The expressible clauses still narrow the
+ * read, so a `where` that mixes both kinds no longer pulls the entire
+ * partition over the wire.
+ *
  * Use `findFirst` instead when you only need the first match: that helper
  * stops on the first hit.
- *
- * Cost note: `FilterExpression` reduces network bytes but not RCU
- * consumption. DynamoDB still reads every row in the partition before
- * filtering. The next meaningful optimization is GSIs that mirror specific
- * access patterns (e.g. `email` for auth, `slug` for public collections).
  */ export async function queryMatching(adapter, partition, where) {
-    const docClient = adapter.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
-    // When `where` uses an operator we can't faithfully push down (today: `like`,
-    // because Payload's contract is case-insensitive while DynamoDB's
-    // `contains()` isn't), we fetch the whole partition and evaluate in JS.
-    // Recurse with `where = undefined` to reuse the standard pagination loop.
-    if (whereHasJsOnlyOperator(where)) {
-        const all = await queryMatching(adapter, partition, undefined);
-        return all.filter((row)=>matchesWhere(row, where));
-    }
-    const filter = buildFilterExpression(where);
-    // `null` signals an always-false predicate (e.g. `id: { in: [] }` from
-    // access control). Short-circuit so we don't pay for a Query just to
-    // return nothing.
-    if (filter === null) return [];
+    const compiled = buildFilterExpression(where);
+    // Always-false predicate (e.g. `id: { in: [] }` from access control).
+    // Short-circuit so we don't pay for a Query just to return nothing.
+    if (compiled.never) return [];
     const matched = [];
-    let exclusiveStartKey;
-    while(true){
-        const result = await docClient.send(new QueryCommand({
-            TableName: adapter.tableName,
-            KeyConditionExpression: '#pk = :pk',
-            ExpressionAttributeNames: {
-                '#pk': 'pk',
-                ...filter?.names ?? {}
-            },
-            ExpressionAttributeValues: {
-                ':pk': partition,
-                ...filter?.values ?? {}
-            },
-            // Strong consistency by default — Payload assumes read-after-write
-            // visibility (Mongo/Postgres do), and DynamoDB's default eventual
-            // consistency breaks "create-then-list" flows. 2x RCU but correct.
-            ConsistentRead: true,
-            ...filter ? {
-                FilterExpression: filter.expression
-            } : {},
-            ...exclusiveStartKey ? {
-                ExclusiveStartKey: exclusiveStartKey
-            } : {}
-        }));
-        for (const item of result.Items ?? []){
-            matched.push(stripInternalKeys(item));
+    for await (const page of partitionPages(adapter, partition, compiled.filter)){
+        for (const item of page.items){
+            const row = stripInternalKeys(item);
+            if (compiled.exact || matchesWhere(row, where)) matched.push(row);
         }
-        if (!result.LastEvaluatedKey) break;
-        exclusiveStartKey = result.LastEvaluatedKey;
     }
     return matched;
 }