@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/utilities/mapWithConcurrency.js

@@ -0,0 +1,32 @@
+/**
+ * `Promise.all(items.map(fn))`, but with at most `limit` calls in flight.
+ * Results come back in input order.
+ *
+ * Bulk writes need this: firing one request per row all at once means a
+ * `deleteMany` over a few thousand rows opens a few thousand concurrent
+ * requests, which exhausts the SDK's socket pool and invites throttling.
+ * A rejection stops new work from starting and rejects the whole call, same
+ * as `Promise.all`.
+ */ export async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    let failed = false;
+    const worker = async ()=>{
+        while(!failed && next < items.length){
+            const index = next++;
+            try {
+                results[index] = await fn(items[index], index);
+            } catch (err) {
+                failed = true;
+                throw err;
+            }
+        }
+    };
+    const workers = Math.max(1, Math.min(limit, items.length));
+    await Promise.all(Array.from({
+        length: workers
+    }, worker));
+    return results;
+}
+
+//# sourceMappingURL=mapWithConcurrency.js.map

package/dist/utilities/mapWithConcurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/mapWithConcurrency.ts"],"sourcesContent":["/**\n * `Promise.all(items.map(fn))`, but with at most `limit` calls in flight.\n * Results come back in input order.\n *\n * Bulk writes need this: firing one request per row all at once means a\n * `deleteMany` over a few thousand rows opens a few thousand concurrent\n * requests, which exhausts the SDK's socket pool and invites throttling.\n * A rejection stops new work from starting and rejects the whole call, same\n * as `Promise.all`.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T, index: number) => Promise<R>,\n): Promise<R[]> {\n  const results = new Array<R>(items.length)\n  let next = 0\n  let failed = false\n\n  const worker = async (): Promise<void> => {\n    while (!failed && next < items.length) {\n      const index = next++\n      try {\n        results[index] = await fn(items[index] as T, index)\n      } catch (err) {\n        failed = true\n        throw err\n      }\n    }\n  }\n\n  const workers = Math.max(1, Math.min(limit, items.length))\n  await Promise.all(Array.from({ length: workers }, worker))\n  return results\n}\n"],"names":["mapWithConcurrency","items","limit","fn","results","Array","length","next","failed","worker","index","err","workers","Math","max","min","Promise","all","from"],"mappings":"AAAA;;;;;;;;;CASC,GACD,OAAO,eAAeA,mBACpBC,KAAmB,EACnBC,KAAa,EACbC,EAA0C;IAE1C,MAAMC,UAAU,IAAIC,MAASJ,MAAMK,MAAM;IACzC,IAAIC,OAAO;IACX,IAAIC,SAAS;IAEb,MAAMC,SAAS;QACb,MAAO,CAACD,UAAUD,OAAON,MAAMK,MAAM,CAAE;YACrC,MAAMI,QAAQH;YACd,IAAI;gBACFH,OAAO,CAACM,MAAM,GAAG,MAAMP,GAAGF,KAAK,CAACS,MAAM,EAAOA;YAC/C,EAAE,OAAOC,KAAK;gBACZH,SAAS;gBACT,MAAMG;YACR;QACF;IACF;IAEA,MAAMC,UAAUC,KAAKC,GAAG,CAAC,GAAGD,KAAKE,GAAG,CAACb,OAAOD,MAAMK,MAAM;IACxD,MAAMU,QAAQC,GAAG,CAACZ,MAAMa,IAAI,CAAC;QAAEZ,QAAQM;IAAQ,GAAGH;IAClD,OAAOL;AACT"}

package/dist/utilities/matchesWhere.d.ts

@@ -1,12 +1,32 @@
 import type { Where } from 'payload';
 /**
  * In-memory predicate that evaluates a Payload `Where` against a fetched item.
- * Used as a fallback when the query cannot be reduced to a `GetItem` and we
- * have to `Scan` the table.
+ * This is the adapter's reference evaluator: `buildFilterExpression` pushes
+ * down whatever part of a `where` DynamoDB can express, and every row that
+ * comes back from an inexact pushdown is re-checked here. It also runs alone
+ * for rows that only take their doc shape after projection (drafts
+ * supplements, `queryDrafts`).
  *
- * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.
- * Throws on any other operator so we surface coverage gaps instead of
+ * Where a clause can be evaluated by both, the two must return the same rows
+ * — `test/parity` pins that.
+ *
+ * Paths follow MongoDB's array semantics, which is what Payload's query
+ * language assumes: an array anywhere along a path is transparent, so
+ * `tags equals 'x'` matches a `hasMany` value containing `'x'` and
+ * `items.label equals 'x'` matches when any item has that label. A negative
+ * operator (`not_equals`, `not_in`, `not_like`) holds only when *no* element
+ * matches its positive form.
+ *
+ * Throws on any unsupported operator so we surface coverage gaps instead of
  * silently returning wrong results.
  */
-export declare function matchesWhere(item: Record<string, unknown>, where: Where | undefined): boolean;
+export declare function matchesWhere(item: Record<string, unknown>, where: undefined | Where): boolean;
+/**
+ * Every value a dotted path can reach in `source`, treating arrays as
+ * transparent. A path that ends on an array yields the array itself (so an
+ * array operand can match it whole, and `exists` sees an empty list as a
+ * value) followed by each of its elements. A path that reaches nothing
+ * yields no candidates.
+ */
+export declare function candidatesAt(source: unknown, path: string): unknown[];
 //# sourceMappingURL=matchesWhere.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"matchesWhere.d.ts","sourceRoot":"","sources":["../../src/utilities/matchesWhere.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CA8C7F"}
+{"version":3,"file":"matchesWhere.d.ts","sourceRoot":"","sources":["../../src/utilities/matchesWhere.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAOpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,GAAG,KAAK,GAAG,OAAO,CAuD7F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAIrE"}

package/dist/utilities/matchesWhere.js

@@ -1,12 +1,26 @@
+import { matchesIntersects, matchesNear, matchesWithin } from './geo.js';
 import { getByPath } from './getByPath.js';
-import { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js';
+import { normalizeForDynamo } from './normalizeForDynamo.js';
+import { JS_ONLY_MARKER, SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js';
 /**
  * In-memory predicate that evaluates a Payload `Where` against a fetched item.
- * Used as a fallback when the query cannot be reduced to a `GetItem` and we
- * have to `Scan` the table.
+ * This is the adapter's reference evaluator: `buildFilterExpression` pushes
+ * down whatever part of a `where` DynamoDB can express, and every row that
+ * comes back from an inexact pushdown is re-checked here. It also runs alone
+ * for rows that only take their doc shape after projection (drafts
+ * supplements, `queryDrafts`).
  *
- * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.
- * Throws on any other operator so we surface coverage gaps instead of
+ * Where a clause can be evaluated by both, the two must return the same rows
+ * — `test/parity` pins that.
+ *
+ * Paths follow MongoDB's array semantics, which is what Payload's query
+ * language assumes: an array anywhere along a path is transparent, so
+ * `tags equals 'x'` matches a `hasMany` value containing `'x'` and
+ * `items.label equals 'x'` matches when any item has that label. A negative
+ * operator (`not_equals`, `not_in`, `not_like`) holds only when *no* element
+ * matches its positive form.
+ *
+ * Throws on any unsupported operator so we surface coverage gaps instead of
  * silently returning wrong results.
  */ export function matchesWhere(item, where) {
     if (!where) {
@@ -35,64 +49,162 @@ import { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js';
         if (!raw || typeof raw !== 'object') {
             continue;
         }
-        const fieldValue = getByPath(item, key);
         const operators = raw;
+        let candidates;
         for (const [operator, expected] of Object.entries(operators)){
+            if (operator === JS_ONLY_MARKER) continue;
             if (!SUPPORTED_OPERATORS.has(operator)) {
                 throw unsupportedOperatorError(operator, key);
             }
-            if (!evaluate(fieldValue, operator, expected)) {
+            // Geometry reads the stored point whole — `[lng, lat]` is a value, not
+            // a list of candidates.
+            if (operator === 'near' || operator === 'within' || operator === 'intersects') {
+                if (!evaluateGeo(getByPath(item, key), operator, expected)) return false;
+                continue;
+            }
+            candidates ??= candidatesAt(item, key);
+            if (!evaluate(candidates, operator, expected)) {
                 return false;
             }
         }
     }
     return true;
 }
-function evaluate(actual, operator, expected) {
+/**
+ * Every value a dotted path can reach in `source`, treating arrays as
+ * transparent. A path that ends on an array yields the array itself (so an
+ * array operand can match it whole, and `exists` sees an empty list as a
+ * value) followed by each of its elements. A path that reaches nothing
+ * yields no candidates.
+ */ export function candidatesAt(source, path) {
+    const out = [];
+    collect(source, path.split('.'), 0, out);
+    return out;
+}
+function collect(value, segments, index, out) {
+    if (index === segments.length) {
+        if (value === undefined) return;
+        out.push(value);
+        if (Array.isArray(value)) {
+            for (const member of value){
+                if (member !== undefined) out.push(member);
+            }
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const member of value)collect(member, segments, index, out);
+        return;
+    }
+    if (value === null || typeof value !== 'object') return;
+    collect(value[segments[index]], segments, index + 1, out);
+}
+function evaluateGeo(value, operator, expected) {
+    switch(operator){
+        case 'intersects':
+            return matchesIntersects(value, expected);
+        case 'near':
+            return matchesNear(value, expected);
+        default:
+            return matchesWithin(value, expected);
+    }
+}
+function evaluate(candidates, operator, rawExpected) {
+    // Coerce the operand exactly as `buildFilterExpression` coerces its
+    // expression values (today: `Date` → ISO string, including inside `in` /
+    // `not_in` lists). Rows hold ISO strings, so comparing them against a raw
+    // `Date` would never be equal and would order by `Date#toString()` text.
+    const expected = normalizeForDynamo(rawExpected);
+    const some = (test)=>candidates.some(test);
+    const hasValue = (candidate)=>candidate !== undefined && candidate !== null;
     switch(operator){
+        case 'all':
+            return Array.isArray(expected) && expected.every((member)=>some((candidate)=>valuesEqual(candidate, member)));
+        case 'contains':
+            return asList(expected).some((needle)=>some((candidate)=>containsText(candidate, needle)));
         case 'equals':
-            return actual === expected;
-        case 'not_equals':
-            return actual !== expected;
+            return some((candidate)=>valuesEqual(candidate, expected));
+        case 'exists':
+            return expected ? some(hasValue) : !some(hasValue);
         case 'greater_than':
-            return compareLoose(actual, expected) > 0;
+            return some((candidate)=>compareLoose(candidate, expected) > 0);
         case 'greater_than_equal':
-            return compareLoose(actual, expected) >= 0;
+            return some((candidate)=>compareLoose(candidate, expected) >= 0);
+        case 'in':
+            return Array.isArray(expected) && expected.some((member)=>some((candidate)=>valuesEqual(candidate, member)));
         case 'less_than':
-            return compareLoose(actual, expected) < 0;
+            return some((candidate)=>compareLoose(candidate, expected) < 0);
         case 'less_than_equal':
-            return compareLoose(actual, expected) <= 0;
-        case 'exists':
-            return expected ? actual !== undefined && actual !== null : actual === undefined || actual === null;
-        case 'in':
-            return Array.isArray(expected) && expected.includes(actual);
-        case 'not_in':
-            return Array.isArray(expected) && !expected.includes(actual);
+            return some((candidate)=>compareLoose(candidate, expected) <= 0);
         case 'like':
-            {
-                // Empty needle means "no constraint" — mirrors SQL `LIKE '%%'` and what
-                // Payload's admin search produces when the search input is cleared.
-                if (typeof expected !== 'string' || expected === '') return true;
-                if (typeof actual !== 'string') return false;
-                return actual.toLowerCase().includes(expected.toLowerCase());
-            }
+            return isLike(candidates, expected);
+        case 'not_equals':
+            return !some((candidate)=>valuesEqual(candidate, expected));
+        case 'not_in':
+            return Array.isArray(expected) && !expected.some((member)=>some((candidate)=>valuesEqual(candidate, member)));
+        case 'not_like':
+            return !isLike(candidates, expected);
         default:
             return false;
     }
 }
+const asList = (value)=>Array.isArray(value) ? value : [
+        value
+    ];
+function isLike(candidates, expected) {
+    // Empty needle means "no constraint" — mirrors SQL `LIKE '%%'` and what
+    // Payload's admin search produces when the search input is cleared.
+    if (typeof expected !== 'string' || expected === '') return true;
+    const needle = expected.toLowerCase();
+    return candidates.some((candidate)=>typeof candidate === 'string' && candidate.toLowerCase().includes(needle));
+}
 /**
- * Loose ordered comparison matching DynamoDB's `<`/`>` semantics: numbers and
- * strings (including ISO date strings) compare naturally; nullish on either
- * side yields a non-match by returning `NaN`. Lets `greater_than`/`less_than`
- * mirror the server-side filter evaluator behavior.
+ * `contains`: case-insensitive substring, over text and numbers (a `hasMany`
+ * number field is searched by its digits, as the Mongo adapter does).
+ */ function containsText(candidate, needle) {
+    if (typeof needle !== 'string' && typeof needle !== 'number') return false;
+    if (typeof candidate !== 'string' && typeof candidate !== 'number') return false;
+    return String(candidate).toLowerCase().includes(String(needle).toLowerCase());
+}
+/**
+ * Equality as DynamoDB's `=` defines it: scalars by value and type, lists
+ * element-by-element in order, maps key-by-key regardless of key order. A
+ * plain `===` would compare objects by reference and never match — which
+ * breaks object operands such as a polymorphic relationship's
+ * `{ relationTo, value }`.
+ *
+ * Keys holding `undefined` are ignored on both sides, since the marshaller
+ * drops them before anything reaches DynamoDB (`removeUndefinedValues`).
+ */ function valuesEqual(a, b) {
+    if (a === b) return true;
+    if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+        return a.every((member, index)=>valuesEqual(member, b[index]));
+    }
+    const left = a;
+    const right = b;
+    const definedKeys = (record)=>Object.keys(record).filter((key)=>record[key] !== undefined);
+    const leftKeys = definedKeys(left);
+    if (leftKeys.length !== definedKeys(right).length) return false;
+    return leftKeys.every((key)=>right[key] !== undefined && valuesEqual(left[key], right[key]));
+}
+/**
+ * Ordered comparison matching DynamoDB's `<`/`>` semantics: two numbers or
+ * two strings (including ISO date strings) compare naturally; anything else
+ * — a missing side, or operands of different types — yields a non-match by
+ * returning `NaN`. DynamoDB never orders a number against a string, so
+ * falling back to string comparison here would match rows the pushdown
+ * rejects. `castWhere` is what turns a string operand into the field's real
+ * type before it gets this far.
  */ function compareLoose(a, b) {
-    if (a === undefined || a === null || b === undefined || b === null) return NaN;
     if (typeof a === 'number' && typeof b === 'number') return a - b;
-    const as = String(a);
-    const bs = String(b);
-    if (as < bs) return -1;
-    if (as > bs) return 1;
-    return 0;
+    if (typeof a === 'string' && typeof b === 'string') {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    }
+    return NaN;
 }
 
 //# sourceMappingURL=matchesWhere.js.map

package/dist/utilities/matchesWhere.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/matchesWhere.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { getByPath } from './getByPath.js'\nimport { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js'\n\n/**\n * In-memory predicate that evaluates a Payload `Where` against a fetched item.\n * Used as a fallback when the query cannot be reduced to a `GetItem` and we\n * have to `Scan` the table.\n *\n * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.\n * Throws on any other operator so we surface coverage gaps instead of\n * silently returning wrong results.\n */\nexport function matchesWhere(item: Record<string, unknown>, where: Where | undefined): boolean {\n  if (!where) {\n    return true\n  }\n\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and') {\n      if (!Array.isArray(raw)) continue\n      for (const sub of raw) {\n        if (!matchesWhere(item, sub)) return false\n      }\n      continue\n    }\n\n    if (key === 'or') {\n      if (!Array.isArray(raw)) continue\n      let any = false\n      for (const sub of raw) {\n        if (matchesWhere(item, sub)) {\n          any = true\n          break\n        }\n      }\n      if (!any) return false\n      continue\n    }\n\n    if (!raw || typeof raw !== 'object') {\n      continue\n    }\n\n    const fieldValue = getByPath(item, key)\n    const operators = raw as Record<string, unknown>\n\n    for (const [operator, expected] of Object.entries(operators)) {\n      if (!SUPPORTED_OPERATORS.has(operator)) {\n        throw unsupportedOperatorError(operator, key)\n      }\n\n      if (!evaluate(fieldValue, operator, expected)) {\n        return false\n      }\n    }\n  }\n\n  return true\n}\n\nfunction evaluate(actual: unknown, operator: string, expected: unknown): boolean {\n  switch (operator) {\n    case 'equals':\n      return actual === expected\n    case 'not_equals':\n      return actual !== expected\n    case 'greater_than':\n      return compareLoose(actual, expected) > 0\n    case 'greater_than_equal':\n      return compareLoose(actual, expected) >= 0\n    case 'less_than':\n      return compareLoose(actual, expected) < 0\n    case 'less_than_equal':\n      return compareLoose(actual, expected) <= 0\n    case 'exists':\n      return expected ? actual !== undefined && actual !== null : actual === undefined || actual === null\n    case 'in':\n      return Array.isArray(expected) && expected.includes(actual)\n    case 'not_in':\n      return Array.isArray(expected) && !expected.includes(actual)\n    case 'like': {\n      // Empty needle means \"no constraint\" — mirrors SQL `LIKE '%%'` and what\n      // Payload's admin search produces when the search input is cleared.\n      if (typeof expected !== 'string' || expected === '') return true\n      if (typeof actual !== 'string') return false\n      return actual.toLowerCase().includes(expected.toLowerCase())\n    }\n    default:\n      return false\n  }\n}\n\n/**\n * Loose ordered comparison matching DynamoDB's `<`/`>` semantics: numbers and\n * strings (including ISO date strings) compare naturally; nullish on either\n * side yields a non-match by returning `NaN`. Lets `greater_than`/`less_than`\n * mirror the server-side filter evaluator behavior.\n */\nfunction compareLoose(a: unknown, b: unknown): number {\n  if (a === undefined || a === null || b === undefined || b === null) return NaN\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  const as = String(a)\n  const bs = String(b)\n  if (as < bs) return -1\n  if (as > bs) return 1\n  return 0\n}\n"],"names":["getByPath","SUPPORTED_OPERATORS","unsupportedOperatorError","matchesWhere","item","where","key","raw","Object","entries","Array","isArray","sub","any","fieldValue","operators","operator","expected","has","evaluate","actual","compareLoose","undefined","includes","toLowerCase","a","b","NaN","as","String","bs"],"mappings":"AAEA,SAASA,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,mBAAmB,EAAEC,wBAAwB,QAAQ,iBAAgB;AAE9E;;;;;;;;CAQC,GACD,OAAO,SAASC,aAAaC,IAA6B,EAAEC,KAAwB;IAClF,IAAI,CAACA,OAAO;QACV,OAAO;IACT;IAEA,KAAK,MAAM,CAACC,KAAKC,IAAI,IAAIC,OAAOC,OAAO,CAACJ,OAAQ;QAC9C,IAAIC,QAAQ,OAAO;YACjB,IAAI,CAACI,MAAMC,OAAO,CAACJ,MAAM;YACzB,KAAK,MAAMK,OAAOL,IAAK;gBACrB,IAAI,CAACJ,aAAaC,MAAMQ,MAAM,OAAO;YACvC;YACA;QACF;QAEA,IAAIN,QAAQ,MAAM;YAChB,IAAI,CAACI,MAAMC,OAAO,CAACJ,MAAM;YACzB,IAAIM,MAAM;YACV,KAAK,MAAMD,OAAOL,IAAK;gBACrB,IAAIJ,aAAaC,MAAMQ,MAAM;oBAC3BC,MAAM;oBACN;gBACF;YACF;YACA,IAAI,CAACA,KAAK,OAAO;YACjB;QACF;QAEA,IAAI,CAACN,OAAO,OAAOA,QAAQ,UAAU;YACnC;QACF;QAEA,MAAMO,aAAad,UAAUI,MAAME;QACnC,MAAMS,YAAYR;QAElB,KAAK,MAAM,CAACS,UAAUC,SAAS,IAAIT,OAAOC,OAAO,CAACM,WAAY;YAC5D,IAAI,CAACd,oBAAoBiB,GAAG,CAACF,WAAW;gBACtC,MAAMd,yBAAyBc,UAAUV;YAC3C;YAEA,IAAI,CAACa,SAASL,YAAYE,UAAUC,WAAW;gBAC7C,OAAO;YACT;QACF;IACF;IAEA,OAAO;AACT;AAEA,SAASE,SAASC,MAAe,EAAEJ,QAAgB,EAAEC,QAAiB;IACpE,OAAQD;QACN,KAAK;YACH,OAAOI,WAAWH;QACpB,KAAK;YACH,OAAOG,WAAWH;QACpB,KAAK;YACH,OAAOI,aAAaD,QAAQH,YAAY;QAC1C,KAAK;YACH,OAAOI,aAAaD,QAAQH,aAAa;QAC3C,KAAK;YACH,OAAOI,aAAaD,QAAQH,YAAY;QAC1C,KAAK;YACH,OAAOI,aAAaD,QAAQH,aAAa;QAC3C,KAAK;YACH,OAAOA,WAAWG,WAAWE,aAAaF,WAAW,OAAOA,WAAWE,aAAaF,WAAW;QACjG,KAAK;YACH,OAAOV,MAAMC,OAAO,CAACM,aAAaA,SAASM,QAAQ,CAACH;QACtD,KAAK;YACH,OAAOV,MAAMC,OAAO,CAACM,aAAa,CAACA,SAASM,QAAQ,CAACH;QACvD,KAAK;YAAQ;gBACX,wEAAwE;gBACxE,oEAAoE;gBACpE,IAAI,OAAOH,aAAa,YAAYA,aAAa,IAAI,OAAO;gBAC5D,IAAI,OAAOG,WAAW,UAAU,OAAO;gBACvC,OAAOA,OAAOI,WAAW,GAAGD,QAAQ,CAACN,SAASO,WAAW;YAC3D;QACA;YACE,OAAO;IACX;AACF;AAEA;;;;;CAKC,GACD,SAASH,aAAaI,CAAU,EAAEC,CAAU;IAC1C,IAAID,MAAMH,aAAaG,MAAM,QAAQC,MAAMJ,aAAaI,MAAM,MAAM,OAAOC;IAC3E,IAAI,OAAOF,MAAM,YAAY,OAAOC,MAAM,UAAU,OAAOD,IAAIC;IAC/D,MAAME,KAAKC,OAAOJ;IAClB,MAAMK,KAAKD,OAAOH;IAClB,IAAIE,KAAKE,IAAI,OAAO,CAAC;IACrB,IAAIF,KAAKE,IAAI,OAAO;IACpB,OAAO;AACT"}
+{"version":3,"sources":["../../src/utilities/matchesWhere.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { matchesIntersects, matchesNear, matchesWithin } from './geo.js'\nimport { getByPath } from './getByPath.js'\nimport { normalizeForDynamo } from './normalizeForDynamo.js'\nimport { JS_ONLY_MARKER, SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js'\n\n/**\n * In-memory predicate that evaluates a Payload `Where` against a fetched item.\n * This is the adapter's reference evaluator: `buildFilterExpression` pushes\n * down whatever part of a `where` DynamoDB can express, and every row that\n * comes back from an inexact pushdown is re-checked here. It also runs alone\n * for rows that only take their doc shape after projection (drafts\n * supplements, `queryDrafts`).\n *\n * Where a clause can be evaluated by both, the two must return the same rows\n * — `test/parity` pins that.\n *\n * Paths follow MongoDB's array semantics, which is what Payload's query\n * language assumes: an array anywhere along a path is transparent, so\n * `tags equals 'x'` matches a `hasMany` value containing `'x'` and\n * `items.label equals 'x'` matches when any item has that label. A negative\n * operator (`not_equals`, `not_in`, `not_like`) holds only when *no* element\n * matches its positive form.\n *\n * Throws on any unsupported operator so we surface coverage gaps instead of\n * silently returning wrong results.\n */\nexport function matchesWhere(item: Record<string, unknown>, where: undefined | Where): boolean {\n  if (!where) {\n    return true\n  }\n\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and') {\n      if (!Array.isArray(raw)) continue\n      for (const sub of raw) {\n        if (!matchesWhere(item, sub)) return false\n      }\n      continue\n    }\n\n    if (key === 'or') {\n      if (!Array.isArray(raw)) continue\n      let any = false\n      for (const sub of raw) {\n        if (matchesWhere(item, sub)) {\n          any = true\n          break\n        }\n      }\n      if (!any) return false\n      continue\n    }\n\n    if (!raw || typeof raw !== 'object') {\n      continue\n    }\n\n    const operators = raw as Record<string, unknown>\n    let candidates: undefined | unknown[]\n\n    for (const [operator, expected] of Object.entries(operators)) {\n      if (operator === JS_ONLY_MARKER) continue\n      if (!SUPPORTED_OPERATORS.has(operator)) {\n        throw unsupportedOperatorError(operator, key)\n      }\n\n      // Geometry reads the stored point whole — `[lng, lat]` is a value, not\n      // a list of candidates.\n      if (operator === 'near' || operator === 'within' || operator === 'intersects') {\n        if (!evaluateGeo(getByPath(item, key), operator, expected)) return false\n        continue\n      }\n\n      candidates ??= candidatesAt(item, key)\n      if (!evaluate(candidates, operator, expected)) {\n        return false\n      }\n    }\n  }\n\n  return true\n}\n\n/**\n * Every value a dotted path can reach in `source`, treating arrays as\n * transparent. A path that ends on an array yields the array itself (so an\n * array operand can match it whole, and `exists` sees an empty list as a\n * value) followed by each of its elements. A path that reaches nothing\n * yields no candidates.\n */\nexport function candidatesAt(source: unknown, path: string): unknown[] {\n  const out: unknown[] = []\n  collect(source, path.split('.'), 0, out)\n  return out\n}\n\nfunction collect(value: unknown, segments: string[], index: number, out: unknown[]): void {\n  if (index === segments.length) {\n    if (value === undefined) return\n    out.push(value)\n    if (Array.isArray(value)) {\n      for (const member of value) {\n        if (member !== undefined) out.push(member)\n      }\n    }\n    return\n  }\n  if (Array.isArray(value)) {\n    for (const member of value) collect(member, segments, index, out)\n    return\n  }\n  if (value === null || typeof value !== 'object') return\n  collect((value as Record<string, unknown>)[segments[index]!], segments, index + 1, out)\n}\n\nfunction evaluateGeo(value: unknown, operator: string, expected: unknown): boolean {\n  switch (operator) {\n    case 'intersects':\n      return matchesIntersects(value, expected)\n    case 'near':\n      return matchesNear(value, expected)\n    default:\n      return matchesWithin(value, expected)\n  }\n}\n\nfunction evaluate(candidates: unknown[], operator: string, rawExpected: unknown): boolean {\n  // Coerce the operand exactly as `buildFilterExpression` coerces its\n  // expression values (today: `Date` → ISO string, including inside `in` /\n  // `not_in` lists). Rows hold ISO strings, so comparing them against a raw\n  // `Date` would never be equal and would order by `Date#toString()` text.\n  const expected = normalizeForDynamo(rawExpected)\n  const some = (test: (candidate: unknown) => boolean) => candidates.some(test)\n  const hasValue = (candidate: unknown) => candidate !== undefined && candidate !== null\n\n  switch (operator) {\n    case 'all':\n      return (\n        Array.isArray(expected) &&\n        expected.every((member) => some((candidate) => valuesEqual(candidate, member)))\n      )\n    case 'contains':\n      return asList(expected).some((needle) => some((candidate) => containsText(candidate, needle)))\n    case 'equals':\n      return some((candidate) => valuesEqual(candidate, expected))\n    case 'exists':\n      return expected ? some(hasValue) : !some(hasValue)\n    case 'greater_than':\n      return some((candidate) => compareLoose(candidate, expected) > 0)\n    case 'greater_than_equal':\n      return some((candidate) => compareLoose(candidate, expected) >= 0)\n    case 'in':\n      return (\n        Array.isArray(expected) &&\n        expected.some((member) => some((candidate) => valuesEqual(candidate, member)))\n      )\n    case 'less_than':\n      return some((candidate) => compareLoose(candidate, expected) < 0)\n    case 'less_than_equal':\n      return some((candidate) => compareLoose(candidate, expected) <= 0)\n    case 'like':\n      return isLike(candidates, expected)\n    case 'not_equals':\n      return !some((candidate) => valuesEqual(candidate, expected))\n    case 'not_in':\n      return (\n        Array.isArray(expected) &&\n        !expected.some((member) => some((candidate) => valuesEqual(candidate, member)))\n      )\n    case 'not_like':\n      return !isLike(candidates, expected)\n    default:\n      return false\n  }\n}\n\nconst asList = (value: unknown): unknown[] => (Array.isArray(value) ? value : [value])\n\nfunction isLike(candidates: unknown[], expected: unknown): boolean {\n  // Empty needle means \"no constraint\" — mirrors SQL `LIKE '%%'` and what\n  // Payload's admin search produces when the search input is cleared.\n  if (typeof expected !== 'string' || expected === '') return true\n  const needle = expected.toLowerCase()\n  return candidates.some(\n    (candidate) => typeof candidate === 'string' && candidate.toLowerCase().includes(needle),\n  )\n}\n\n/**\n * `contains`: case-insensitive substring, over text and numbers (a `hasMany`\n * number field is searched by its digits, as the Mongo adapter does).\n */\nfunction containsText(candidate: unknown, needle: unknown): boolean {\n  if (typeof needle !== 'string' && typeof needle !== 'number') return false\n  if (typeof candidate !== 'string' && typeof candidate !== 'number') return false\n  return String(candidate).toLowerCase().includes(String(needle).toLowerCase())\n}\n\n/**\n * Equality as DynamoDB's `=` defines it: scalars by value and type, lists\n * element-by-element in order, maps key-by-key regardless of key order. A\n * plain `===` would compare objects by reference and never match — which\n * breaks object operands such as a polymorphic relationship's\n * `{ relationTo, value }`.\n *\n * Keys holding `undefined` are ignored on both sides, since the marshaller\n * drops them before anything reaches DynamoDB (`removeUndefinedValues`).\n */\nfunction valuesEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true\n  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false\n\n  if (Array.isArray(a) || Array.isArray(b)) {\n    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false\n    return a.every((member, index) => valuesEqual(member, b[index]))\n  }\n\n  const left = a as Record<string, unknown>\n  const right = b as Record<string, unknown>\n  const definedKeys = (record: Record<string, unknown>) =>\n    Object.keys(record).filter((key) => record[key] !== undefined)\n  const leftKeys = definedKeys(left)\n  if (leftKeys.length !== definedKeys(right).length) return false\n  return leftKeys.every((key) => right[key] !== undefined && valuesEqual(left[key], right[key]))\n}\n\n/**\n * Ordered comparison matching DynamoDB's `<`/`>` semantics: two numbers or\n * two strings (including ISO date strings) compare naturally; anything else\n * — a missing side, or operands of different types — yields a non-match by\n * returning `NaN`. DynamoDB never orders a number against a string, so\n * falling back to string comparison here would match rows the pushdown\n * rejects. `castWhere` is what turns a string operand into the field's real\n * type before it gets this far.\n */\nfunction compareLoose(a: unknown, b: unknown): number {\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  if (typeof a === 'string' && typeof b === 'string') {\n    if (a < b) return -1\n    if (a > b) return 1\n    return 0\n  }\n  return NaN\n}\n"],"names":["matchesIntersects","matchesNear","matchesWithin","getByPath","normalizeForDynamo","JS_ONLY_MARKER","SUPPORTED_OPERATORS","unsupportedOperatorError","matchesWhere","item","where","key","raw","Object","entries","Array","isArray","sub","any","operators","candidates","operator","expected","has","evaluateGeo","candidatesAt","evaluate","source","path","out","collect","split","value","segments","index","length","undefined","push","member","rawExpected","some","test","hasValue","candidate","every","valuesEqual","asList","needle","containsText","compareLoose","isLike","toLowerCase","includes","String","a","b","left","right","definedKeys","record","keys","filter","leftKeys","NaN"],"mappings":"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"}

package/dist/utilities/operators.d.ts

@@ -1,26 +1,36 @@
-import type { Where } from 'payload';
 /**
  * The where-operator coverage shared by `matchesWhere` (in-JS evaluator) and
  * `buildFilterExpression` (DynamoDB pushdown). Keeping the set in one place
  * keeps the two paths honest — if an operator is supported in one, it should
  * be supported in the other, since callers can't know which path runs.
+ *
+ * This is Payload's full operator list (`validOperators` in core).
  */
 export declare const SUPPORTED_OPERATORS: Set<string>;
 /**
  * Operators we can't faithfully express in a DynamoDB `FilterExpression` and
- * therefore evaluate in JS after fetching candidate rows. `like` is here
- * because Payload's contract is case-insensitive substring matching while
- * DynamoDB's `contains()` is case-sensitive — pushing it down would silently
- * change semantics. When `where` contains any of these, the read helpers
- * `Query` the partition without server-side filtering and apply
- * `matchesWhere` in memory.
+ * therefore evaluate in JS after fetching candidate rows:
+ *
+ *  - `like` / `not_like` / `contains`: Payload's contract is case-insensitive
+ *    matching, while DynamoDB's `contains()` is case-sensitive — pushing it
+ *    down would silently change semantics.
+ *  - `all`: needs "every operand is a member" over a list; no equivalent.
+ *  - `near` / `within` / `intersects`: geometry.
+ *
+ * A clause using one of these is simply left out of the pushed-down filter
+ * (see `buildFilterExpression`); the rest of the `where` still narrows the
+ * read server-side, and `matchesWhere` re-checks every returned row.
  */
 export declare const JS_ONLY_OPERATORS: Set<string>;
-export declare const SUPPORTED_OPERATORS_DESCRIPTION: string;
-export declare function unsupportedOperatorError(operator: string, field: string): Error;
 /**
- * Walk a `Where` and return true if any leaf clause uses an operator that
- * forces JS-side evaluation. Recurses into `and`/`or` groups.
+ * Pseudo-operator `castWhere` adds to a clause whose *path* can't be pushed
+ * down, whatever its operators: one that runs through an array or a
+ * `hasMany` value (DynamoDB document paths can't mean "any element"), or
+ * into a field whose inner shape the schema doesn't describe. The pushdown
+ * skips the whole clause; `matchesWhere` ignores the marker and evaluates the
+ * real operators with any-element semantics.
  */
-export declare function whereHasJsOnlyOperator(where: undefined | Where): boolean;
+export declare const JS_ONLY_MARKER = "$js";
+export declare const SUPPORTED_OPERATORS_DESCRIPTION: string;
+export declare function unsupportedOperatorError(operator: string, field: string): Error;
 //# sourceMappingURL=operators.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../src/utilities/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,aAW9B,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,aAAoB,CAAA;AAElD,eAAO,MAAM,+BAA+B,QAAoD,CAAA;AAEhG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAK/E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,GAAG,OAAO,CAkBxE"}
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../src/utilities/operators.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,aAiB9B,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,aAQ5B,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAA;AAEnC,eAAO,MAAM,+BAA+B,QAAoD,CAAA;AAEhG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAK/E"}

package/dist/utilities/operators.js

@@ -3,56 +3,61 @@
  * `buildFilterExpression` (DynamoDB pushdown). Keeping the set in one place
  * keeps the two paths honest — if an operator is supported in one, it should
  * be supported in the other, since callers can't know which path runs.
+ *
+ * This is Payload's full operator list (`validOperators` in core).
  */ export const SUPPORTED_OPERATORS = new Set([
+    'all',
+    'contains',
     'equals',
     'exists',
     'greater_than',
     'greater_than_equal',
     'in',
+    'intersects',
     'less_than',
     'less_than_equal',
     'like',
+    'near',
     'not_equals',
-    'not_in'
+    'not_in',
+    'not_like',
+    'within'
 ]);
 /**
  * Operators we can't faithfully express in a DynamoDB `FilterExpression` and
- * therefore evaluate in JS after fetching candidate rows. `like` is here
- * because Payload's contract is case-insensitive substring matching while
- * DynamoDB's `contains()` is case-sensitive — pushing it down would silently
- * change semantics. When `where` contains any of these, the read helpers
- * `Query` the partition without server-side filtering and apply
- * `matchesWhere` in memory.
+ * therefore evaluate in JS after fetching candidate rows:
+ *
+ *  - `like` / `not_like` / `contains`: Payload's contract is case-insensitive
+ *    matching, while DynamoDB's `contains()` is case-sensitive — pushing it
+ *    down would silently change semantics.
+ *  - `all`: needs "every operand is a member" over a list; no equivalent.
+ *  - `near` / `within` / `intersects`: geometry.
+ *
+ * A clause using one of these is simply left out of the pushed-down filter
+ * (see `buildFilterExpression`); the rest of the `where` still narrows the
+ * read server-side, and `matchesWhere` re-checks every returned row.
  */ export const JS_ONLY_OPERATORS = new Set([
-    'like'
+    'all',
+    'contains',
+    'intersects',
+    'like',
+    'near',
+    'not_like',
+    'within'
 ]);
+/**
+ * Pseudo-operator `castWhere` adds to a clause whose *path* can't be pushed
+ * down, whatever its operators: one that runs through an array or a
+ * `hasMany` value (DynamoDB document paths can't mean "any element"), or
+ * into a field whose inner shape the schema doesn't describe. The pushdown
+ * skips the whole clause; `matchesWhere` ignores the marker and evaluates the
+ * real operators with any-element semantics.
+ */ export const JS_ONLY_MARKER = '$js';
 export const SUPPORTED_OPERATORS_DESCRIPTION = `${[
     ...SUPPORTED_OPERATORS
 ].join(', ')}, and, or`;
 export function unsupportedOperatorError(operator, field) {
-    return new Error(`payload-ddb: operator \`${operator}\` is not supported yet on field \`${field}\`. ` + `Supported: ${SUPPORTED_OPERATORS_DESCRIPTION}.`);
-}
-/**
- * Walk a `Where` and return true if any leaf clause uses an operator that
- * forces JS-side evaluation. Recurses into `and`/`or` groups.
- */ export function whereHasJsOnlyOperator(where) {
-    if (!where) return false;
-    for (const [key, raw] of Object.entries(where)){
-        if (key === 'and' || key === 'or') {
-            if (!Array.isArray(raw)) continue;
-            for (const sub of raw){
-                if (sub && typeof sub === 'object' && whereHasJsOnlyOperator(sub)) {
-                    return true;
-                }
-            }
-            continue;
-        }
-        if (!raw || typeof raw !== 'object') continue;
-        for (const op of Object.keys(raw)){
-            if (JS_ONLY_OPERATORS.has(op)) return true;
-        }
-    }
-    return false;
+    return new Error(`payload-ddb: operator \`${operator}\` is not supported on field \`${field}\`. ` + `Supported: ${SUPPORTED_OPERATORS_DESCRIPTION}.`);
 }
 
 //# sourceMappingURL=operators.js.map

package/dist/utilities/operators.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/operators.ts"],"sourcesContent":["import type { Where } from 'payload'\n\n/**\n * The where-operator coverage shared by `matchesWhere` (in-JS evaluator) and\n * `buildFilterExpression` (DynamoDB pushdown). Keeping the set in one place\n * keeps the two paths honest — if an operator is supported in one, it should\n * be supported in the other, since callers can't know which path runs.\n */\nexport const SUPPORTED_OPERATORS = new Set([\n  'equals',\n  'exists',\n  'greater_than',\n  'greater_than_equal',\n  'in',\n  'less_than',\n  'less_than_equal',\n  'like',\n  'not_equals',\n  'not_in',\n])\n\n/**\n * Operators we can't faithfully express in a DynamoDB `FilterExpression` and\n * therefore evaluate in JS after fetching candidate rows. `like` is here\n * because Payload's contract is case-insensitive substring matching while\n * DynamoDB's `contains()` is case-sensitive — pushing it down would silently\n * change semantics. When `where` contains any of these, the read helpers\n * `Query` the partition without server-side filtering and apply\n * `matchesWhere` in memory.\n */\nexport const JS_ONLY_OPERATORS = new Set(['like'])\n\nexport const SUPPORTED_OPERATORS_DESCRIPTION = `${[...SUPPORTED_OPERATORS].join(', ')}, and, or`\n\nexport function unsupportedOperatorError(operator: string, field: string): Error {\n  return new Error(\n    `payload-ddb: operator \\`${operator}\\` is not supported yet on field \\`${field}\\`. ` +\n      `Supported: ${SUPPORTED_OPERATORS_DESCRIPTION}.`,\n  )\n}\n\n/**\n * Walk a `Where` and return true if any leaf clause uses an operator that\n * forces JS-side evaluation. Recurses into `and`/`or` groups.\n */\nexport function whereHasJsOnlyOperator(where: undefined | Where): boolean {\n  if (!where) return false\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and' || key === 'or') {\n      if (!Array.isArray(raw)) continue\n      for (const sub of raw) {\n        if (sub && typeof sub === 'object' && whereHasJsOnlyOperator(sub as Where)) {\n          return true\n        }\n      }\n      continue\n    }\n    if (!raw || typeof raw !== 'object') continue\n    for (const op of Object.keys(raw)) {\n      if (JS_ONLY_OPERATORS.has(op)) return true\n    }\n  }\n  return false\n}\n"],"names":["SUPPORTED_OPERATORS","Set","JS_ONLY_OPERATORS","SUPPORTED_OPERATORS_DESCRIPTION","join","unsupportedOperatorError","operator","field","Error","whereHasJsOnlyOperator","where","key","raw","Object","entries","Array","isArray","sub","op","keys","has"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,MAAMA,sBAAsB,IAAIC,IAAI;IACzC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAC;AAEF;;;;;;;;CAQC,GACD,OAAO,MAAMC,oBAAoB,IAAID,IAAI;IAAC;CAAO,EAAC;AAElD,OAAO,MAAME,kCAAkC,GAAG;OAAIH;CAAoB,CAACI,IAAI,CAAC,MAAM,SAAS,CAAC,CAAA;AAEhG,OAAO,SAASC,yBAAyBC,QAAgB,EAAEC,KAAa;IACtE,OAAO,IAAIC,MACT,CAAC,wBAAwB,EAAEF,SAAS,mCAAmC,EAAEC,MAAM,IAAI,CAAC,GAClF,CAAC,WAAW,EAAEJ,gCAAgC,CAAC,CAAC;AAEtD;AAEA;;;CAGC,GACD,OAAO,SAASM,uBAAuBC,KAAwB;IAC7D,IAAI,CAACA,OAAO,OAAO;IACnB,KAAK,MAAM,CAACC,KAAKC,IAAI,IAAIC,OAAOC,OAAO,CAACJ,OAAQ;QAC9C,IAAIC,QAAQ,SAASA,QAAQ,MAAM;YACjC,IAAI,CAACI,MAAMC,OAAO,CAACJ,MAAM;YACzB,KAAK,MAAMK,OAAOL,IAAK;gBACrB,IAAIK,OAAO,OAAOA,QAAQ,YAAYR,uBAAuBQ,MAAe;oBAC1E,OAAO;gBACT;YACF;YACA;QACF;QACA,IAAI,CAACL,OAAO,OAAOA,QAAQ,UAAU;QACrC,KAAK,MAAMM,MAAML,OAAOM,IAAI,CAACP,KAAM;YACjC,IAAIV,kBAAkBkB,GAAG,CAACF,KAAK,OAAO;QACxC;IACF;IACA,OAAO;AACT"}
+{"version":3,"sources":["../../src/utilities/operators.ts"],"sourcesContent":["/**\n * The where-operator coverage shared by `matchesWhere` (in-JS evaluator) and\n * `buildFilterExpression` (DynamoDB pushdown). Keeping the set in one place\n * keeps the two paths honest — if an operator is supported in one, it should\n * be supported in the other, since callers can't know which path runs.\n *\n * This is Payload's full operator list (`validOperators` in core).\n */\nexport const SUPPORTED_OPERATORS = new Set([\n  'all',\n  'contains',\n  'equals',\n  'exists',\n  'greater_than',\n  'greater_than_equal',\n  'in',\n  'intersects',\n  'less_than',\n  'less_than_equal',\n  'like',\n  'near',\n  'not_equals',\n  'not_in',\n  'not_like',\n  'within',\n])\n\n/**\n * Operators we can't faithfully express in a DynamoDB `FilterExpression` and\n * therefore evaluate in JS after fetching candidate rows:\n *\n *  - `like` / `not_like` / `contains`: Payload's contract is case-insensitive\n *    matching, while DynamoDB's `contains()` is case-sensitive — pushing it\n *    down would silently change semantics.\n *  - `all`: needs \"every operand is a member\" over a list; no equivalent.\n *  - `near` / `within` / `intersects`: geometry.\n *\n * A clause using one of these is simply left out of the pushed-down filter\n * (see `buildFilterExpression`); the rest of the `where` still narrows the\n * read server-side, and `matchesWhere` re-checks every returned row.\n */\nexport const JS_ONLY_OPERATORS = new Set([\n  'all',\n  'contains',\n  'intersects',\n  'like',\n  'near',\n  'not_like',\n  'within',\n])\n\n/**\n * Pseudo-operator `castWhere` adds to a clause whose *path* can't be pushed\n * down, whatever its operators: one that runs through an array or a\n * `hasMany` value (DynamoDB document paths can't mean \"any element\"), or\n * into a field whose inner shape the schema doesn't describe. The pushdown\n * skips the whole clause; `matchesWhere` ignores the marker and evaluates the\n * real operators with any-element semantics.\n */\nexport const JS_ONLY_MARKER = '$js'\n\nexport const SUPPORTED_OPERATORS_DESCRIPTION = `${[...SUPPORTED_OPERATORS].join(', ')}, and, or`\n\nexport function unsupportedOperatorError(operator: string, field: string): Error {\n  return new Error(\n    `payload-ddb: operator \\`${operator}\\` is not supported on field \\`${field}\\`. ` +\n      `Supported: ${SUPPORTED_OPERATORS_DESCRIPTION}.`,\n  )\n}\n"],"names":["SUPPORTED_OPERATORS","Set","JS_ONLY_OPERATORS","JS_ONLY_MARKER","SUPPORTED_OPERATORS_DESCRIPTION","join","unsupportedOperatorError","operator","field","Error"],"mappings":"AAAA;;;;;;;CAOC,GACD,OAAO,MAAMA,sBAAsB,IAAIC,IAAI;IACzC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAC;AAEF;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC,oBAAoB,IAAID,IAAI;IACvC;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAC;AAEF;;;;;;;CAOC,GACD,OAAO,MAAME,iBAAiB,MAAK;AAEnC,OAAO,MAAMC,kCAAkC,GAAG;OAAIJ;CAAoB,CAACK,IAAI,CAAC,MAAM,SAAS,CAAC,CAAA;AAEhG,OAAO,SAASC,yBAAyBC,QAAgB,EAAEC,KAAa;IACtE,OAAO,IAAIC,MACT,CAAC,wBAAwB,EAAEF,SAAS,+BAA+B,EAAEC,MAAM,IAAI,CAAC,GAC9E,CAAC,WAAW,EAAEJ,gCAAgC,CAAC,CAAC;AAEtD"}

package/dist/utilities/optimistic.d.ts

@@ -0,0 +1,29 @@
+import { APIError } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+type Row = Record<string, unknown>;
+/**
+ * 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 declare function getById(adapter: DynamoAdapter, partition: string, id: unknown): Promise<null | Row>;
+/** Enough to ride out a burst of writers on one row; beyond it something is wrong. */
+export declare 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 declare function writeWithRetry<T>(first: null | Row, reread: () => Promise<null | Row>, write: (current: Row) => Promise<T>): Promise<null | T>;
+export declare function conflictError(): APIError;
+/** A short random pause so writers that collided don't collide again in step. */
+export declare function backoff(attempt: number): Promise<void>;
+export {};
+//# sourceMappingURL=optimistic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic.d.ts","sourceRoot":"","sources":["../../src/utilities/optimistic.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKhD,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAElC;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,OAAO,GACV,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,CAerB;AAED,sFAAsF;AACtF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,KAAK,EAAE,IAAI,GAAG,GAAG,EACjB,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,EACjC,KAAK,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC,CAenB;AAED,wBAAgB,aAAa,IAAI,QAAQ,CAOxC;AAED,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtD"}