@open-aih/payload-ddb 3.1.0

package/dist/updateMany.js

@@ -0,0 +1,48 @@
+import { PutCommand } from '@aws-sdk/lib-dynamodb';
+import { applySorts } from './utilities/applySorts.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { queryMatching } from './utilities/queryMatching.js';
+import { projectForCollection } from './utilities/resolveSchema.js';
+/**
+ * v1 strategy: query-and-collect matches, sort, slice to `limit`, then
+ * read-merge-write each in parallel. Same merge semantics as `updateOne`:
+ * `data` is overlaid on the target and `id` is preserved from the target.
+ *
+ * `Promise.all` is order-preserving, so the returned array matches the
+ * sorted target order. Bulk DynamoDB transact-writes (`TransactWriteItems`,
+ * 100-item / 4 MB cap) are the natural next optimization but require the
+ * transaction wiring we deliberately stubbed out for now.
+ */ export const updateMany = async function updateMany({ collection, data, limit, returning, sort, where }) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolvePartition(collection);
+    const matched = await queryMatching(this, partition, where);
+    applySorts(matched, sort);
+    const targets = limit && limit > 0 ? matched.slice(0, limit) : matched;
+    // Hoisted so every row in the batch shares one timestamp — keeps audit-style
+    // queries deterministic. Explicit `updatedAt` in `data` still wins.
+    const updatedAt = data['updatedAt'] ?? new Date().toISOString();
+    const updated = await Promise.all(targets.map(async (target)=>{
+        const merged = {
+            ...target,
+            ...data,
+            id: target['id'],
+            updatedAt
+        };
+        const projected = projectForCollection(this, collection, merged);
+        await docClient.send(new PutCommand({
+            TableName: this.tableName,
+            Item: normalizeForDynamo({
+                ...projected,
+                pk: partition,
+                sk: String(projected['id'])
+            })
+        }));
+        return projected;
+    }));
+    return returning === false ? null : updated;
+};
+
+//# sourceMappingURL=updateMany.js.map

package/dist/updateMany.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/updateMany.ts"],"sourcesContent":["import type { UpdateMany } from 'payload'\n\nimport { PutCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\n\n/**\n * v1 strategy: query-and-collect matches, sort, slice to `limit`, then\n * read-merge-write each in parallel. Same merge semantics as `updateOne`:\n * `data` is overlaid on the target and `id` is preserved from the target.\n *\n * `Promise.all` is order-preserving, so the returned array matches the\n * sorted target order. Bulk DynamoDB transact-writes (`TransactWriteItems`,\n * 100-item / 4 MB cap) are the natural next optimization but require the\n * transaction wiring we deliberately stubbed out for now.\n */\nexport const updateMany: UpdateMany = async function updateMany(\n  this: DynamoAdapter,\n  { collection, data, limit, returning, sort, where },\n) {\n  const docClient = this.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const partition = this.resolvePartition(collection)\n  const matched = await queryMatching(this, partition, where)\n  applySorts(matched, sort)\n\n  const targets = limit && limit > 0 ? matched.slice(0, limit) : matched\n\n  // Hoisted so every row in the batch shares one timestamp — keeps audit-style\n  // queries deterministic. Explicit `updatedAt` in `data` still wins.\n  const updatedAt = data['updatedAt'] ?? new Date().toISOString()\n\n  const updated = await Promise.all(\n    targets.map(async (target) => {\n      const merged: Record<string, unknown> = {\n        ...target,\n        ...data,\n        id: target['id'],\n        updatedAt,\n      }\n      const projected = projectForCollection(this, collection, merged)\n      await docClient.send(\n        new PutCommand({\n          TableName: this.tableName,\n          Item: normalizeForDynamo({\n            ...projected,\n            pk: partition,\n            sk: String(projected['id']),\n          }),\n        }),\n      )\n      return projected\n    }),\n  )\n\n  return returning === false ? null : updated\n}\n"],"names":["PutCommand","applySorts","normalizeForDynamo","queryMatching","projectForCollection","updateMany","collection","data","limit","returning","sort","where","docClient","Error","partition","resolvePartition","matched","targets","slice","updatedAt","Date","toISOString","updated","Promise","all","map","target","merged","id","projected","send","TableName","tableName","Item","pk","sk","String"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAIlD,SAASC,UAAU,QAAQ,4BAA2B;AACtD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE;;;;;;;;;CASC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,IAAI,EAAEC,KAAK,EAAEC,SAAS,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAEnD,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACT;IACxC,MAAMU,UAAU,MAAMb,cAAc,IAAI,EAAEW,WAAWH;IACrDV,WAAWe,SAASN;IAEpB,MAAMO,UAAUT,SAASA,QAAQ,IAAIQ,QAAQE,KAAK,CAAC,GAAGV,SAASQ;IAE/D,6EAA6E;IAC7E,oEAAoE;IACpE,MAAMG,YAAYZ,IAAI,CAAC,YAAY,IAAI,IAAIa,OAAOC,WAAW;IAE7D,MAAMC,UAAU,MAAMC,QAAQC,GAAG,CAC/BP,QAAQQ,GAAG,CAAC,OAAOC;QACjB,MAAMC,SAAkC;YACtC,GAAGD,MAAM;YACT,GAAGnB,IAAI;YACPqB,IAAIF,MAAM,CAAC,KAAK;YAChBP;QACF;QACA,MAAMU,YAAYzB,qBAAqB,IAAI,EAAEE,YAAYqB;QACzD,MAAMf,UAAUkB,IAAI,CAClB,IAAI9B,WAAW;YACb+B,WAAW,IAAI,CAACC,SAAS;YACzBC,MAAM/B,mBAAmB;gBACvB,GAAG2B,SAAS;gBACZK,IAAIpB;gBACJqB,IAAIC,OAAOP,SAAS,CAAC,KAAK;YAC5B;QACF;QAEF,OAAOA;IACT;IAGF,OAAOpB,cAAc,QAAQ,OAAOa;AACtC,EAAC"}

package/dist/updateOne.d.ts

@@ -0,0 +1,13 @@
+import type { UpdateOne } from 'payload';
+/**
+ * v1 strategy: read-merge-write rather than building an `UpdateExpression`.
+ * Payload sends a partial `data` patch; DynamoDB `UpdateItem` would let us
+ * push the diff server-side, but its expression syntax (reserved words,
+ * nested attribute paths, list indexing, removal semantics) is enough work to
+ * earn its own milestone. Two round-trips is acceptable for now.
+ *
+ * `id` on the resulting item always comes from the located target — we don't
+ * let `data` rewrite the primary key, which would silently orphan the row.
+ */
+export declare const updateOne: UpdateOne;
+//# sourceMappingURL=updateOne.d.ts.map

package/dist/updateOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateOne.d.ts","sourceRoot":"","sources":["../src/updateOne.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAWxC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,SAwDvB,CAAA"}

package/dist/updateOne.js

@@ -0,0 +1,68 @@
+import { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectForCollection } from './utilities/resolveSchema.js';
+import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+/**
+ * v1 strategy: read-merge-write rather than building an `UpdateExpression`.
+ * Payload sends a partial `data` patch; DynamoDB `UpdateItem` would let us
+ * push the diff server-side, but its expression syntax (reserved words,
+ * nested attribute paths, list indexing, removal semantics) is enough work to
+ * earn its own milestone. Two round-trips is acceptable for now.
+ *
+ * `id` on the resulting item always comes from the located target — we don't
+ * let `data` rewrite the primary key, which would silently orphan the row.
+ */ export const updateOne = async function updateOne(args) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolvePartition(args.collection);
+    let target = null;
+    if (args.id !== undefined && args.id !== null) {
+        const result = await docClient.send(new GetCommand({
+            TableName: this.tableName,
+            Key: {
+                pk: partition,
+                sk: String(args.id)
+            },
+            ConsistentRead: true
+        }));
+        target = result.Item ? stripInternalKeys(result.Item) : null;
+    } else if (args.where) {
+        target = await findFirst(this, {
+            partition,
+            where: args.where
+        });
+    }
+    if (!target) {
+        return null;
+    }
+    const merged = {
+        ...target,
+        ...args.data,
+        id: target['id'],
+        // Bump `updatedAt` automatically. Explicit timestamps in `data` (e.g. from
+        // version restores or migrations) still win because they land in the
+        // spread above and we only override here when `data` didn't supply one.
+        updatedAt: args.data['updatedAt'] ?? new Date().toISOString()
+    };
+    // Strip the merged result against the collection schema. Catches both
+    // unknown keys in the incoming patch and any pre-existing leaked keys on
+    // the persisted target — every update doubles as incremental cleanup.
+    const projected = projectForCollection(this, args.collection, merged);
+    await docClient.send(new PutCommand({
+        TableName: this.tableName,
+        Item: normalizeForDynamo({
+            ...projected,
+            pk: partition,
+            sk: String(projected['id'])
+        })
+    }));
+    if (args.returning === false) {
+        return null;
+    }
+    return projected;
+};
+
+//# sourceMappingURL=updateOne.js.map

package/dist/updateOne.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/updateOne.ts"],"sourcesContent":["import type { UpdateOne } from 'payload'\n\nimport { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * v1 strategy: read-merge-write rather than building an `UpdateExpression`.\n * Payload sends a partial `data` patch; DynamoDB `UpdateItem` would let us\n * push the diff server-side, but its expression syntax (reserved words,\n * nested attribute paths, list indexing, removal semantics) is enough work to\n * earn its own milestone. Two round-trips is acceptable for now.\n *\n * `id` on the resulting item always comes from the located target — we don't\n * let `data` rewrite the primary key, which would silently orphan the row.\n */\nexport const updateOne: UpdateOne = async function updateOne(this: DynamoAdapter, args) {\n  const docClient = this.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const partition = this.resolvePartition(args.collection)\n\n  let target: null | Record<string, unknown> = null\n\n  if (args.id !== undefined && args.id !== null) {\n    const result = await docClient.send(\n      new GetCommand({\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(args.id) },\n        ConsistentRead: true,\n      }),\n    )\n    target = result.Item ? stripInternalKeys(result.Item) : null\n  } else if (args.where) {\n    target = await findFirst(this, { partition, where: args.where })\n  }\n\n  if (!target) {\n    return null as never\n  }\n\n  const merged: Record<string, unknown> = {\n    ...target,\n    ...args.data,\n    id: target['id'],\n    // Bump `updatedAt` automatically. Explicit timestamps in `data` (e.g. from\n    // version restores or migrations) still win because they land in the\n    // spread above and we only override here when `data` didn't supply one.\n    updatedAt: args.data['updatedAt'] ?? new Date().toISOString(),\n  }\n  // Strip the merged result against the collection schema. Catches both\n  // unknown keys in the incoming patch and any pre-existing leaked keys on\n  // the persisted target — every update doubles as incremental cleanup.\n  const projected = projectForCollection(this, args.collection, merged)\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: partition,\n        sk: String(projected['id']),\n      }),\n    }),\n  )\n\n  if (args.returning === false) {\n    return null as never\n  }\n  return projected as never\n}\n"],"names":["GetCommand","PutCommand","findFirst","normalizeForDynamo","projectForCollection","stripInternalKeys","updateOne","args","docClient","Error","partition","resolvePartition","collection","target","id","undefined","result","send","TableName","tableName","Key","pk","sk","String","ConsistentRead","Item","where","merged","data","updatedAt","Date","toISOString","projected","returning"],"mappings":"AAEA,SAASA,UAAU,EAAEC,UAAU,QAAQ,wBAAuB;AAI9D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;;;;;;CASC,GACD,OAAO,MAAMC,YAAuB,eAAeA,UAA+BC,IAAI;IACpF,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACJ,KAAKK,UAAU;IAEvD,IAAIC,SAAyC;IAE7C,IAAIN,KAAKO,EAAE,KAAKC,aAAaR,KAAKO,EAAE,KAAK,MAAM;QAC7C,MAAME,SAAS,MAAMR,UAAUS,IAAI,CACjC,IAAIjB,WAAW;YACbkB,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIX;gBAAWY,IAAIC,OAAOhB,KAAKO,EAAE;YAAE;YAC1CU,gBAAgB;QAClB;QAEFX,SAASG,OAAOS,IAAI,GAAGpB,kBAAkBW,OAAOS,IAAI,IAAI;IAC1D,OAAO,IAAIlB,KAAKmB,KAAK,EAAE;QACrBb,SAAS,MAAMX,UAAU,IAAI,EAAE;YAAEQ;YAAWgB,OAAOnB,KAAKmB,KAAK;QAAC;IAChE;IAEA,IAAI,CAACb,QAAQ;QACX,OAAO;IACT;IAEA,MAAMc,SAAkC;QACtC,GAAGd,MAAM;QACT,GAAGN,KAAKqB,IAAI;QACZd,IAAID,MAAM,CAAC,KAAK;QAChB,2EAA2E;QAC3E,qEAAqE;QACrE,wEAAwE;QACxEgB,WAAWtB,KAAKqB,IAAI,CAAC,YAAY,IAAI,IAAIE,OAAOC,WAAW;IAC7D;IACA,sEAAsE;IACtE,yEAAyE;IACzE,sEAAsE;IACtE,MAAMC,YAAY5B,qBAAqB,IAAI,EAAEG,KAAKK,UAAU,EAAEe;IAE9D,MAAMnB,UAAUS,IAAI,CAClB,IAAIhB,WAAW;QACbiB,WAAW,IAAI,CAACC,SAAS;QACzBM,MAAMtB,mBAAmB;YACvB,GAAG6B,SAAS;YACZX,IAAIX;YACJY,IAAIC,OAAOS,SAAS,CAAC,KAAK;QAC5B;IACF;IAGF,IAAIzB,KAAK0B,SAAS,KAAK,OAAO;QAC5B,OAAO;IACT;IACA,OAAOD;AACT,EAAC"}

package/dist/updateVersion.d.ts

@@ -0,0 +1,15 @@
+import type { UpdateVersion } from 'payload';
+/**
+ * Read-merge-write against the versions partition. `versionData` is
+ * splatted onto the existing row, which means Payload-passed metadata
+ * (`createdAt`, `updatedAt`, `latest`, `parent`, `publishedLocale`) and the
+ * inner `version` payload all overlay correctly.
+ *
+ * The adapter does not cascade `latest=true` flips — Payload is responsible
+ * for clearing the previous latest by issuing a separate `updateVersion`
+ * call. This matches the `createVersion` boundary: `createVersion` owns the
+ * cascade because it knows it's making a new latest; `updateVersion` writes
+ * exactly what it's told.
+ */
+export declare const updateVersion: UpdateVersion;
+//# sourceMappingURL=updateVersion.d.ts.map

package/dist/updateVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateVersion.d.ts","sourceRoot":"","sources":["../src/updateVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAW5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,EAAE,aA2D3B,CAAA"}

package/dist/updateVersion.js

@@ -0,0 +1,69 @@
+import { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectVersionRow } from './utilities/resolveSchema.js';
+import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+/**
+ * Read-merge-write against the versions partition. `versionData` is
+ * splatted onto the existing row, which means Payload-passed metadata
+ * (`createdAt`, `updatedAt`, `latest`, `parent`, `publishedLocale`) and the
+ * inner `version` payload all overlay correctly.
+ *
+ * The adapter does not cascade `latest=true` flips — Payload is responsible
+ * for clearing the previous latest by issuing a separate `updateVersion`
+ * call. This matches the `createVersion` boundary: `createVersion` owns the
+ * cascade because it knows it's making a new latest; `updateVersion` writes
+ * exactly what it's told.
+ */ export const updateVersion = async function updateVersion(args) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolveVersionsPartition(args.collection);
+    let target = null;
+    if (args.id !== undefined && args.id !== null) {
+        const result = await docClient.send(new GetCommand({
+            TableName: this.tableName,
+            Key: {
+                pk: partition,
+                sk: String(args.id)
+            },
+            ConsistentRead: true
+        }));
+        target = result.Item ? stripInternalKeys(result.Item) : null;
+    } else if (args.where) {
+        target = await findFirst(this, {
+            partition,
+            where: args.where
+        });
+    }
+    if (!target) {
+        return null;
+    }
+    const merged = {
+        ...target,
+        ...args.versionData,
+        id: target['id']
+    };
+    // Project both the version-row metadata layer and the inner `version`
+    // snapshot. Catches stray keys at either layer plus stale leaks already
+    // persisted on the target.
+    const projected = projectVersionRow(this, {
+        kind: 'collection',
+        slug: args.collection
+    }, merged);
+    await docClient.send(new PutCommand({
+        TableName: this.tableName,
+        Item: normalizeForDynamo({
+            ...projected,
+            pk: partition,
+            sk: String(projected['id'])
+        })
+    }));
+    if (args.returning === false) {
+        return null;
+    }
+    return projected;
+};
+
+//# sourceMappingURL=updateVersion.js.map

package/dist/updateVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/updateVersion.ts"],"sourcesContent":["import type { UpdateVersion } from 'payload'\n\nimport { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectVersionRow } from './utilities/resolveSchema.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * Read-merge-write against the versions partition. `versionData` is\n * splatted onto the existing row, which means Payload-passed metadata\n * (`createdAt`, `updatedAt`, `latest`, `parent`, `publishedLocale`) and the\n * inner `version` payload all overlay correctly.\n *\n * The adapter does not cascade `latest=true` flips — Payload is responsible\n * for clearing the previous latest by issuing a separate `updateVersion`\n * call. This matches the `createVersion` boundary: `createVersion` owns the\n * cascade because it knows it's making a new latest; `updateVersion` writes\n * exactly what it's told.\n */\nexport const updateVersion: UpdateVersion = async function updateVersion(\n  this: DynamoAdapter,\n  args,\n) {\n  const docClient = this.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const partition = this.resolveVersionsPartition(args.collection)\n\n  let target: null | Record<string, unknown> = null\n\n  if (args.id !== undefined && args.id !== null) {\n    const result = await docClient.send(\n      new GetCommand({\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(args.id) },\n        ConsistentRead: true,\n      }),\n    )\n    target = result.Item ? stripInternalKeys(result.Item) : null\n  } else if (args.where) {\n    target = await findFirst(this, { partition, where: args.where })\n  }\n\n  if (!target) {\n    return null as never\n  }\n\n  const merged: Record<string, unknown> = {\n    ...target,\n    ...args.versionData,\n    id: target['id'],\n  }\n  // Project both the version-row metadata layer and the inner `version`\n  // snapshot. Catches stray keys at either layer plus stale leaks already\n  // persisted on the target.\n  const projected = projectVersionRow(\n    this,\n    { kind: 'collection', slug: args.collection },\n    merged,\n  )\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: partition,\n        sk: String(projected['id']),\n      }),\n    }),\n  )\n\n  if (args.returning === false) {\n    return null as never\n  }\n  return projected as never\n}\n"],"names":["GetCommand","PutCommand","findFirst","normalizeForDynamo","projectVersionRow","stripInternalKeys","updateVersion","args","docClient","Error","partition","resolveVersionsPartition","collection","target","id","undefined","result","send","TableName","tableName","Key","pk","sk","String","ConsistentRead","Item","where","merged","versionData","projected","kind","slug","returning"],"mappings":"AAEA,SAASA,UAAU,EAAEC,UAAU,QAAQ,wBAAuB;AAI9D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,iBAAiB,QAAQ,+BAA8B;AAChE,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzDC,IAAI;IAEJ,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACJ,KAAKK,UAAU;IAE/D,IAAIC,SAAyC;IAE7C,IAAIN,KAAKO,EAAE,KAAKC,aAAaR,KAAKO,EAAE,KAAK,MAAM;QAC7C,MAAME,SAAS,MAAMR,UAAUS,IAAI,CACjC,IAAIjB,WAAW;YACbkB,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIX;gBAAWY,IAAIC,OAAOhB,KAAKO,EAAE;YAAE;YAC1CU,gBAAgB;QAClB;QAEFX,SAASG,OAAOS,IAAI,GAAGpB,kBAAkBW,OAAOS,IAAI,IAAI;IAC1D,OAAO,IAAIlB,KAAKmB,KAAK,EAAE;QACrBb,SAAS,MAAMX,UAAU,IAAI,EAAE;YAAEQ;YAAWgB,OAAOnB,KAAKmB,KAAK;QAAC;IAChE;IAEA,IAAI,CAACb,QAAQ;QACX,OAAO;IACT;IAEA,MAAMc,SAAkC;QACtC,GAAGd,MAAM;QACT,GAAGN,KAAKqB,WAAW;QACnBd,IAAID,MAAM,CAAC,KAAK;IAClB;IACA,sEAAsE;IACtE,wEAAwE;IACxE,2BAA2B;IAC3B,MAAMgB,YAAYzB,kBAChB,IAAI,EACJ;QAAE0B,MAAM;QAAcC,MAAMxB,KAAKK,UAAU;IAAC,GAC5Ce;IAGF,MAAMnB,UAAUS,IAAI,CAClB,IAAIhB,WAAW;QACbiB,WAAW,IAAI,CAACC,SAAS;QACzBM,MAAMtB,mBAAmB;YACvB,GAAG0B,SAAS;YACZR,IAAIX;YACJY,IAAIC,OAAOM,SAAS,CAAC,KAAK;QAC5B;IACF;IAGF,IAAItB,KAAKyB,SAAS,KAAK,OAAO;QAC5B,OAAO;IACT;IACA,OAAOH;AACT,EAAC"}

package/dist/upsert.d.ts

@@ -0,0 +1,10 @@
+import type { Upsert } from 'payload';
+/**
+ * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.
+ *
+ * Inlined rather than dispatching to `create`/`updateOne` via `.call(this)` —
+ * piping through their `this`-typed signatures requires casts that obscure
+ * the small amount of logic this function actually owns.
+ */
+export declare const upsert: Upsert;
+//# sourceMappingURL=upsert.d.ts.map

package/dist/upsert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../src/upsert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAWrC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,MAgDpB,CAAA"}

package/dist/upsert.js

@@ -0,0 +1,55 @@
+import { PutCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'node:crypto';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectForCollection } from './utilities/resolveSchema.js';
+/**
+ * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.
+ *
+ * Inlined rather than dispatching to `create`/`updateOne` via `.call(this)` —
+ * piping through their `this`-typed signatures requires casts that obscure
+ * the small amount of logic this function actually owns.
+ */ export const upsert = async function upsert({ collection, data, returning, where }) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolvePartition(collection);
+    const found = await findFirst(this, {
+        partition,
+        where
+    });
+    const now = new Date().toISOString();
+    let item;
+    if (found) {
+        // Bump `updatedAt` automatically; explicit value in `data` still wins.
+        item = {
+            ...found,
+            ...data,
+            id: found['id'],
+            updatedAt: data['updatedAt'] ?? now
+        };
+    } else {
+        const id = data['id'] ?? randomUUID();
+        // Same nullish-coalesce pattern as `create`: explicit values in `data`
+        // win, but a payload-passed `undefined` doesn't wipe the default.
+        item = {
+            ...data,
+            id,
+            createdAt: data['createdAt'] ?? now,
+            updatedAt: data['updatedAt'] ?? now
+        };
+    }
+    const projected = projectForCollection(this, collection, item);
+    await docClient.send(new PutCommand({
+        TableName: this.tableName,
+        Item: normalizeForDynamo({
+            ...projected,
+            pk: partition,
+            sk: String(projected['id'])
+        })
+    }));
+    return returning === false ? null : projected;
+};
+
+//# sourceMappingURL=upsert.js.map

package/dist/upsert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/upsert.ts"],"sourcesContent":["import type { Upsert } from 'payload'\n\nimport { PutCommand } from '@aws-sdk/lib-dynamodb'\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\n\n/**\n * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.\n *\n * Inlined rather than dispatching to `create`/`updateOne` via `.call(this)` —\n * piping through their `this`-typed signatures requires casts that obscure\n * the small amount of logic this function actually owns.\n */\nexport const upsert: Upsert = async function upsert(\n  this: DynamoAdapter,\n  { collection, data, returning, where },\n) {\n  const docClient = this.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const partition = this.resolvePartition(collection)\n  const found = await findFirst(this, { partition, where })\n\n  const now = new Date().toISOString()\n  let item: Record<string, unknown>\n  if (found) {\n    // Bump `updatedAt` automatically; explicit value in `data` still wins.\n    item = {\n      ...found,\n      ...data,\n      id: found['id'],\n      updatedAt: data['updatedAt'] ?? now,\n    }\n  } else {\n    const id = data['id'] ?? randomUUID()\n    // Same nullish-coalesce pattern as `create`: explicit values in `data`\n    // win, but a payload-passed `undefined` doesn't wipe the default.\n    item = {\n      ...data,\n      id,\n      createdAt: data['createdAt'] ?? now,\n      updatedAt: data['updatedAt'] ?? now,\n    }\n  }\n\n  const projected = projectForCollection(this, collection, item)\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: partition,\n        sk: String(projected['id']),\n      }),\n    }),\n  )\n\n  return returning === false ? (null as never) : (projected as never)\n}\n"],"names":["PutCommand","randomUUID","findFirst","normalizeForDynamo","projectForCollection","upsert","collection","data","returning","where","docClient","Error","partition","resolvePartition","found","now","Date","toISOString","item","id","updatedAt","createdAt","projected","send","TableName","tableName","Item","pk","sk","String"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAClD,SAASC,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE;;;;;;CAMC,GACD,OAAO,MAAMC,SAAiB,eAAeA,OAE3C,EAAEC,UAAU,EAAEC,IAAI,EAAEC,SAAS,EAAEC,KAAK,EAAE;IAEtC,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACP;IACxC,MAAMQ,QAAQ,MAAMZ,UAAU,IAAI,EAAE;QAAEU;QAAWH;IAAM;IAEvD,MAAMM,MAAM,IAAIC,OAAOC,WAAW;IAClC,IAAIC;IACJ,IAAIJ,OAAO;QACT,uEAAuE;QACvEI,OAAO;YACL,GAAGJ,KAAK;YACR,GAAGP,IAAI;YACPY,IAAIL,KAAK,CAAC,KAAK;YACfM,WAAWb,IAAI,CAAC,YAAY,IAAIQ;QAClC;IACF,OAAO;QACL,MAAMI,KAAKZ,IAAI,CAAC,KAAK,IAAIN;QACzB,uEAAuE;QACvE,kEAAkE;QAClEiB,OAAO;YACL,GAAGX,IAAI;YACPY;YACAE,WAAWd,IAAI,CAAC,YAAY,IAAIQ;YAChCK,WAAWb,IAAI,CAAC,YAAY,IAAIQ;QAClC;IACF;IAEA,MAAMO,YAAYlB,qBAAqB,IAAI,EAAEE,YAAYY;IAEzD,MAAMR,UAAUa,IAAI,CAClB,IAAIvB,WAAW;QACbwB,WAAW,IAAI,CAACC,SAAS;QACzBC,MAAMvB,mBAAmB;YACvB,GAAGmB,SAAS;YACZK,IAAIf;YACJgB,IAAIC,OAAOP,SAAS,CAAC,KAAK;QAC5B;IACF;IAGF,OAAOd,cAAc,QAAS,OAAkBc;AAClD,EAAC"}

package/dist/utilities/applySorts.d.ts

@@ -0,0 +1,11 @@
+import type { Sort } from 'payload';
+/**
+ * Sort an array in place according to Payload's sort convention:
+ * `'field'` ascending, `'-field'` descending. Multiple sort keys are applied
+ * as tiebreakers in order.
+ *
+ * Sorts in JS because DynamoDB `Scan` returns rows in indeterminate order;
+ * Query-on-GSI sort comes when we wire access patterns up later.
+ */
+export declare function applySorts(items: Record<string, unknown>[], sort: Sort | undefined): void;
+//# sourceMappingURL=applySorts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applySorts.d.ts","sourceRoot":"","sources":["../../src/utilities/applySorts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAInC;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,IAAI,CAmBzF"}

package/dist/utilities/applySorts.js

@@ -0,0 +1,47 @@
+import { getByPath } from './getByPath.js';
+/**
+ * Sort an array in place according to Payload's sort convention:
+ * `'field'` ascending, `'-field'` descending. Multiple sort keys are applied
+ * as tiebreakers in order.
+ *
+ * Sorts in JS because DynamoDB `Scan` returns rows in indeterminate order;
+ * Query-on-GSI sort comes when we wire access patterns up later.
+ */ export function applySorts(items, sort) {
+    if (!sort) return;
+    const keys = Array.isArray(sort) ? sort : [
+        sort
+    ];
+    if (keys.length === 0) return;
+    items.sort((a, b)=>{
+        for (const raw of keys){
+            if (!raw) continue;
+            const descending = raw.startsWith('-');
+            const path = descending ? raw.slice(1) : raw;
+            const av = getByPath(a, path);
+            const bv = getByPath(b, path);
+            const cmp = compare(av, bv);
+            if (cmp !== 0) {
+                return descending ? -cmp : cmp;
+            }
+        }
+        return 0;
+    });
+}
+function compare(a, b) {
+    if (a === b) return 0;
+    // Nullish values sort before defined values, ascending. Matches Mongo's
+    // default behavior and avoids undefined-vs-string comparison NaNs.
+    const aMissing = a === undefined || a === null;
+    const bMissing = b === undefined || b === null;
+    if (aMissing && bMissing) return 0;
+    if (aMissing) return -1;
+    if (bMissing) return 1;
+    if (typeof a === 'number' && typeof b === 'number') return a - b;
+    // Fall back to lexicographic string compare for everything else (dates as
+    // ISO strings, booleans, etc.).
+    const as = String(a);
+    const bs = String(b);
+    return as < bs ? -1 : as > bs ? 1 : 0;
+}
+
+//# sourceMappingURL=applySorts.js.map

package/dist/utilities/applySorts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/applySorts.ts"],"sourcesContent":["import type { Sort } from 'payload'\n\nimport { getByPath } from './getByPath.js'\n\n/**\n * Sort an array in place according to Payload's sort convention:\n * `'field'` ascending, `'-field'` descending. Multiple sort keys are applied\n * as tiebreakers in order.\n *\n * Sorts in JS because DynamoDB `Scan` returns rows in indeterminate order;\n * Query-on-GSI sort comes when we wire access patterns up later.\n */\nexport function applySorts(items: Record<string, unknown>[], sort: Sort | undefined): void {\n  if (!sort) return\n  const keys = Array.isArray(sort) ? sort : [sort]\n  if (keys.length === 0) return\n\n  items.sort((a, b) => {\n    for (const raw of keys) {\n      if (!raw) continue\n      const descending = raw.startsWith('-')\n      const path = descending ? raw.slice(1) : raw\n      const av = getByPath(a, path)\n      const bv = getByPath(b, path)\n      const cmp = compare(av, bv)\n      if (cmp !== 0) {\n        return descending ? -cmp : cmp\n      }\n    }\n    return 0\n  })\n}\n\nfunction compare(a: unknown, b: unknown): number {\n  if (a === b) return 0\n  // Nullish values sort before defined values, ascending. Matches Mongo's\n  // default behavior and avoids undefined-vs-string comparison NaNs.\n  const aMissing = a === undefined || a === null\n  const bMissing = b === undefined || b === null\n  if (aMissing && bMissing) return 0\n  if (aMissing) return -1\n  if (bMissing) return 1\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  // Fall back to lexicographic string compare for everything else (dates as\n  // ISO strings, booleans, etc.).\n  const as = String(a)\n  const bs = String(b)\n  return as < bs ? -1 : as > bs ? 1 : 0\n}\n"],"names":["getByPath","applySorts","items","sort","keys","Array","isArray","length","a","b","raw","descending","startsWith","path","slice","av","bv","cmp","compare","aMissing","undefined","bMissing","as","String","bs"],"mappings":"AAEA,SAASA,SAAS,QAAQ,iBAAgB;AAE1C;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,KAAgC,EAAEC,IAAsB;IACjF,IAAI,CAACA,MAAM;IACX,MAAMC,OAAOC,MAAMC,OAAO,CAACH,QAAQA,OAAO;QAACA;KAAK;IAChD,IAAIC,KAAKG,MAAM,KAAK,GAAG;IAEvBL,MAAMC,IAAI,CAAC,CAACK,GAAGC;QACb,KAAK,MAAMC,OAAON,KAAM;YACtB,IAAI,CAACM,KAAK;YACV,MAAMC,aAAaD,IAAIE,UAAU,CAAC;YAClC,MAAMC,OAAOF,aAAaD,IAAII,KAAK,CAAC,KAAKJ;YACzC,MAAMK,KAAKf,UAAUQ,GAAGK;YACxB,MAAMG,KAAKhB,UAAUS,GAAGI;YACxB,MAAMI,MAAMC,QAAQH,IAAIC;YACxB,IAAIC,QAAQ,GAAG;gBACb,OAAON,aAAa,CAACM,MAAMA;YAC7B;QACF;QACA,OAAO;IACT;AACF;AAEA,SAASC,QAAQV,CAAU,EAAEC,CAAU;IACrC,IAAID,MAAMC,GAAG,OAAO;IACpB,wEAAwE;IACxE,mEAAmE;IACnE,MAAMU,WAAWX,MAAMY,aAAaZ,MAAM;IAC1C,MAAMa,WAAWZ,MAAMW,aAAaX,MAAM;IAC1C,IAAIU,YAAYE,UAAU,OAAO;IACjC,IAAIF,UAAU,OAAO,CAAC;IACtB,IAAIE,UAAU,OAAO;IACrB,IAAI,OAAOb,MAAM,YAAY,OAAOC,MAAM,UAAU,OAAOD,IAAIC;IAC/D,0EAA0E;IAC1E,gCAAgC;IAChC,MAAMa,KAAKC,OAAOf;IAClB,MAAMgB,KAAKD,OAAOd;IAClB,OAAOa,KAAKE,KAAK,CAAC,IAAIF,KAAKE,KAAK,IAAI;AACtC"}

package/dist/utilities/buildFilterExpression.d.ts

@@ -0,0 +1,42 @@
+import type { Where } from 'payload';
+/**
+ * Compile a Payload `Where` into a DynamoDB `FilterExpression` plus its
+ * companion `ExpressionAttributeNames` / `ExpressionAttributeValues` maps.
+ *
+ * Return contract:
+ *  - `undefined` — no filter to apply (empty/missing `where`, or only no-op
+ *    clauses like `and: []`). Callers should query without a filter.
+ *  - `null` — the predicate is structurally always-false (e.g. an empty
+ *    `id: { in: [] }`). Callers should short-circuit and return zero rows
+ *    without ever hitting DynamoDB. Payload uses empty `in` as a "match
+ *    nothing" sentinel (typically from access control resolving to no IDs);
+ *    surfacing it as a filter would mean throwing or constructing an
+ *    invalid `IN ()` clause.
+ *  - `FilterExpression` — actual predicate to push down.
+ *
+ * Throws on any operator outside `operators.ts`'s supported set, identical
+ * to `matchesWhere` — coverage is enforced from one source so the in-JS
+ * path and the pushdown path can never disagree.
+ *
+ * Implementation notes:
+ *  - Every field path segment becomes an `#nN` placeholder, sidestepping
+ *    DynamoDB's reserved-word list entirely. Segments are deduped per-call so
+ *    repeated fields produce one `#name` entry rather than many.
+ *  - Every value becomes a `:vN` placeholder. We don't dedupe values because
+ *    array members and repeated literals are cheap and the placeholder count
+ *    keeps the expression readable.
+ *  - Dotted paths in `where` keys are split on `.` so DynamoDB document-path
+ *    syntax (`#a.#b`) is produced for nested fields.
+ *  - `in: []` propagates a NEVER sentinel through the AND/OR algebra:
+ *    AND with NEVER → NEVER (whole result `null`); OR with NEVER drops the
+ *    NEVER branch; an OR whose every branch is NEVER itself becomes NEVER.
+ *  - `not_in: []` is treated as no constraint (the complement of an empty
+ *    set is everything, so omitting it from the expression matches semantics).
+ */
+export type FilterExpression = {
+    expression: string;
+    names: Record<string, string>;
+    values: Record<string, unknown>;
+};
+export declare function buildFilterExpression(where: undefined | Where): FilterExpression | null | undefined;
+//# sourceMappingURL=buildFilterExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildFilterExpression.d.ts","sourceRoot":"","sources":["../../src/utilities/buildFilterExpression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC,CAAA;AAaD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,gBAAgB,GAAG,IAAI,GAAG,SAAS,CAoBrC"}

package/dist/utilities/buildFilterExpression.js

@@ -0,0 +1,137 @@
+import { normalizeForDynamo } from './normalizeForDynamo.js';
+import { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js';
+const NEVER = Symbol('payload-ddb-filter-never');
+export function buildFilterExpression(where) {
+    if (!where) return undefined;
+    const ctx = {
+        nameByPlaceholder: {},
+        nameCounter: 0,
+        placeholderBySegment: new Map(),
+        valueCounter: 0,
+        values: {}
+    };
+    const expression = compile(where, ctx);
+    if (expression === NEVER) return null;
+    if (!expression) return undefined;
+    return {
+        expression,
+        names: ctx.nameByPlaceholder,
+        values: ctx.values
+    };
+}
+function compile(where, ctx) {
+    const parts = [];
+    for (const [key, raw] of Object.entries(where)){
+        if (key === 'and') {
+            const inner = compileGroup(raw, ctx, 'AND');
+            if (inner === NEVER) return NEVER;
+            if (inner) parts.push(inner);
+            continue;
+        }
+        if (key === 'or') {
+            const inner = compileGroup(raw, ctx, 'OR');
+            if (inner === NEVER) return NEVER;
+            if (inner) parts.push(inner);
+            continue;
+        }
+        if (!raw || typeof raw !== 'object') continue;
+        const path = pathRef(ctx, key);
+        const operators = raw;
+        for (const [operator, expected] of Object.entries(operators)){
+            if (!SUPPORTED_OPERATORS.has(operator)) {
+                throw unsupportedOperatorError(operator, key);
+            }
+            const expr = operatorToExpression(operator, path, expected, ctx);
+            if (expr === NEVER) return NEVER;
+            if (expr) parts.push(expr);
+        }
+    }
+    if (parts.length === 0) return '';
+    if (parts.length === 1) return parts[0];
+    return parts.join(' AND ');
+}
+function compileGroup(raw, ctx, joiner) {
+    if (!Array.isArray(raw)) return '';
+    const subs = [];
+    let neverCount = 0;
+    let consideredCount = 0;
+    for (const sub of raw){
+        if (!sub || typeof sub !== 'object') continue;
+        consideredCount++;
+        const expr = compile(sub, ctx);
+        if (expr === NEVER) {
+            if (joiner === 'AND') return NEVER;
+            neverCount++;
+            continue;
+        }
+        if (expr) subs.push(expr);
+    }
+    // OR over branches that all collapsed to NEVER is NEVER itself.
+    if (joiner === 'OR' && consideredCount > 0 && neverCount === consideredCount) {
+        return NEVER;
+    }
+    if (subs.length === 0) return '';
+    if (subs.length === 1) return subs[0];
+    return `(${subs.join(` ${joiner} `)})`;
+}
+function pathRef(ctx, path) {
+    return path.split('.').map((segment)=>segmentRef(ctx, segment)).join('.');
+}
+function segmentRef(ctx, segment) {
+    const cached = ctx.placeholderBySegment.get(segment);
+    if (cached) return cached;
+    const placeholder = `#n${ctx.nameCounter++}`;
+    ctx.nameByPlaceholder[placeholder] = segment;
+    ctx.placeholderBySegment.set(segment, placeholder);
+    return placeholder;
+}
+function valueRef(ctx, value) {
+    const placeholder = `:v${ctx.valueCounter++}`;
+    // Normalize so Date literals in `where` compare against the ISO strings we
+    // actually stored. Without this, `{ updatedAt: { greater_than: new Date() } }`
+    // would push an empty map literal into the filter and DynamoDB would reject
+    // the comparison.
+    ctx.values[placeholder] = normalizeForDynamo(value);
+    return placeholder;
+}
+function operatorToExpression(operator, path, expected, ctx) {
+    switch(operator){
+        case 'equals':
+            return `${path} = ${valueRef(ctx, expected)}`;
+        case 'not_equals':
+            return `${path} <> ${valueRef(ctx, expected)}`;
+        case 'greater_than':
+            return `${path} > ${valueRef(ctx, expected)}`;
+        case 'greater_than_equal':
+            return `${path} >= ${valueRef(ctx, expected)}`;
+        case 'less_than':
+            return `${path} < ${valueRef(ctx, expected)}`;
+        case 'less_than_equal':
+            return `${path} <= ${valueRef(ctx, expected)}`;
+        case 'exists':
+            return expected ? `attribute_exists(${path})` : `attribute_not_exists(${path})`;
+        case 'like':
+            // JS-only: `whereHasJsOnlyOperator` should have steered the helpers
+            // away from compiling this `where` server-side. Returning '' is a
+            // belt-and-braces no-op in case a caller compiles directly.
+            return '';
+        case 'in':
+            {
+                if (!Array.isArray(expected)) return '';
+                if (expected.length === 0) return NEVER;
+                const refs = expected.map((v)=>valueRef(ctx, v));
+                return `${path} IN (${refs.join(', ')})`;
+            }
+        case 'not_in':
+            {
+                if (!Array.isArray(expected) || expected.length === 0) return '';
+                const refs = expected.map((v)=>valueRef(ctx, v));
+                return `NOT (${path} IN (${refs.join(', ')}))`;
+            }
+        default:
+            // Unreachable — gated by SUPPORTED_OPERATORS check above. Belt-and-braces.
+            throw unsupportedOperatorError(operator, path);
+    }
+}
+
+//# sourceMappingURL=buildFilterExpression.js.map

package/dist/utilities/buildFilterExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/buildFilterExpression.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { normalizeForDynamo } from './normalizeForDynamo.js'\nimport { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js'\n\n/**\n * Compile a Payload `Where` into a DynamoDB `FilterExpression` plus its\n * companion `ExpressionAttributeNames` / `ExpressionAttributeValues` maps.\n *\n * Return contract:\n *  - `undefined` — no filter to apply (empty/missing `where`, or only no-op\n *    clauses like `and: []`). Callers should query without a filter.\n *  - `null` — the predicate is structurally always-false (e.g. an empty\n *    `id: { in: [] }`). Callers should short-circuit and return zero rows\n *    without ever hitting DynamoDB. Payload uses empty `in` as a \"match\n *    nothing\" sentinel (typically from access control resolving to no IDs);\n *    surfacing it as a filter would mean throwing or constructing an\n *    invalid `IN ()` clause.\n *  - `FilterExpression` — actual predicate to push down.\n *\n * Throws on any operator outside `operators.ts`'s supported set, identical\n * to `matchesWhere` — coverage is enforced from one source so the in-JS\n * path and the pushdown path can never disagree.\n *\n * Implementation notes:\n *  - Every field path segment becomes an `#nN` placeholder, sidestepping\n *    DynamoDB's reserved-word list entirely. Segments are deduped per-call so\n *    repeated fields produce one `#name` entry rather than many.\n *  - Every value becomes a `:vN` placeholder. We don't dedupe values because\n *    array members and repeated literals are cheap and the placeholder count\n *    keeps the expression readable.\n *  - Dotted paths in `where` keys are split on `.` so DynamoDB document-path\n *    syntax (`#a.#b`) is produced for nested fields.\n *  - `in: []` propagates a NEVER sentinel through the AND/OR algebra:\n *    AND with NEVER → NEVER (whole result `null`); OR with NEVER drops the\n *    NEVER branch; an OR whose every branch is NEVER itself becomes NEVER.\n *  - `not_in: []` is treated as no constraint (the complement of an empty\n *    set is everything, so omitting it from the expression matches semantics).\n */\nexport type FilterExpression = {\n  expression: string\n  names: Record<string, string>\n  values: Record<string, unknown>\n}\n\nconst NEVER = Symbol('payload-ddb-filter-never')\ntype Compiled = string | typeof NEVER\n\ntype Ctx = {\n  nameByPlaceholder: Record<string, string>\n  nameCounter: number\n  placeholderBySegment: Map<string, string>\n  valueCounter: number\n  values: Record<string, unknown>\n}\n\nexport function buildFilterExpression(\n  where: undefined | Where,\n): FilterExpression | null | undefined {\n  if (!where) return undefined\n\n  const ctx: Ctx = {\n    nameByPlaceholder: {},\n    nameCounter: 0,\n    placeholderBySegment: new Map(),\n    valueCounter: 0,\n    values: {},\n  }\n\n  const expression = compile(where, ctx)\n  if (expression === NEVER) return null\n  if (!expression) return undefined\n\n  return {\n    expression,\n    names: ctx.nameByPlaceholder,\n    values: ctx.values,\n  }\n}\n\nfunction compile(where: Where, ctx: Ctx): Compiled {\n  const parts: string[] = []\n\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and') {\n      const inner = compileGroup(raw, ctx, 'AND')\n      if (inner === NEVER) return NEVER\n      if (inner) parts.push(inner)\n      continue\n    }\n    if (key === 'or') {\n      const inner = compileGroup(raw, ctx, 'OR')\n      if (inner === NEVER) return NEVER\n      if (inner) parts.push(inner)\n      continue\n    }\n\n    if (!raw || typeof raw !== 'object') continue\n\n    const path = pathRef(ctx, 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      const expr = operatorToExpression(operator, path, expected, ctx)\n      if (expr === NEVER) return NEVER\n      if (expr) parts.push(expr)\n    }\n  }\n\n  if (parts.length === 0) return ''\n  if (parts.length === 1) return parts[0]!\n  return parts.join(' AND ')\n}\n\nfunction compileGroup(raw: unknown, ctx: Ctx, joiner: 'AND' | 'OR'): Compiled {\n  if (!Array.isArray(raw)) return ''\n  const subs: string[] = []\n  let neverCount = 0\n  let consideredCount = 0\n  for (const sub of raw) {\n    if (!sub || typeof sub !== 'object') continue\n    consideredCount++\n    const expr = compile(sub as Where, ctx)\n    if (expr === NEVER) {\n      if (joiner === 'AND') return NEVER\n      neverCount++\n      continue\n    }\n    if (expr) subs.push(expr)\n  }\n  // OR over branches that all collapsed to NEVER is NEVER itself.\n  if (joiner === 'OR' && consideredCount > 0 && neverCount === consideredCount) {\n    return NEVER\n  }\n  if (subs.length === 0) return ''\n  if (subs.length === 1) return subs[0]!\n  return `(${subs.join(` ${joiner} `)})`\n}\n\nfunction pathRef(ctx: Ctx, path: string): string {\n  return path\n    .split('.')\n    .map((segment) => segmentRef(ctx, segment))\n    .join('.')\n}\n\nfunction segmentRef(ctx: Ctx, segment: string): string {\n  const cached = ctx.placeholderBySegment.get(segment)\n  if (cached) return cached\n  const placeholder = `#n${ctx.nameCounter++}`\n  ctx.nameByPlaceholder[placeholder] = segment\n  ctx.placeholderBySegment.set(segment, placeholder)\n  return placeholder\n}\n\nfunction valueRef(ctx: Ctx, value: unknown): string {\n  const placeholder = `:v${ctx.valueCounter++}`\n  // Normalize so Date literals in `where` compare against the ISO strings we\n  // actually stored. Without this, `{ updatedAt: { greater_than: new Date() } }`\n  // would push an empty map literal into the filter and DynamoDB would reject\n  // the comparison.\n  ctx.values[placeholder] = normalizeForDynamo(value)\n  return placeholder\n}\n\nfunction operatorToExpression(\n  operator: string,\n  path: string,\n  expected: unknown,\n  ctx: Ctx,\n): Compiled {\n  switch (operator) {\n    case 'equals':\n      return `${path} = ${valueRef(ctx, expected)}`\n    case 'not_equals':\n      return `${path} <> ${valueRef(ctx, expected)}`\n    case 'greater_than':\n      return `${path} > ${valueRef(ctx, expected)}`\n    case 'greater_than_equal':\n      return `${path} >= ${valueRef(ctx, expected)}`\n    case 'less_than':\n      return `${path} < ${valueRef(ctx, expected)}`\n    case 'less_than_equal':\n      return `${path} <= ${valueRef(ctx, expected)}`\n    case 'exists':\n      return expected ? `attribute_exists(${path})` : `attribute_not_exists(${path})`\n    case 'like':\n      // JS-only: `whereHasJsOnlyOperator` should have steered the helpers\n      // away from compiling this `where` server-side. Returning '' is a\n      // belt-and-braces no-op in case a caller compiles directly.\n      return ''\n    case 'in': {\n      if (!Array.isArray(expected)) return ''\n      if (expected.length === 0) return NEVER\n      const refs = expected.map((v) => valueRef(ctx, v))\n      return `${path} IN (${refs.join(', ')})`\n    }\n    case 'not_in': {\n      if (!Array.isArray(expected) || expected.length === 0) return ''\n      const refs = expected.map((v) => valueRef(ctx, v))\n      return `NOT (${path} IN (${refs.join(', ')}))`\n    }\n    default:\n      // Unreachable — gated by SUPPORTED_OPERATORS check above. Belt-and-braces.\n      throw unsupportedOperatorError(operator, path)\n  }\n}\n"],"names":["normalizeForDynamo","SUPPORTED_OPERATORS","unsupportedOperatorError","NEVER","Symbol","buildFilterExpression","where","undefined","ctx","nameByPlaceholder","nameCounter","placeholderBySegment","Map","valueCounter","values","expression","compile","names","parts","key","raw","Object","entries","inner","compileGroup","push","path","pathRef","operators","operator","expected","has","expr","operatorToExpression","length","join","joiner","Array","isArray","subs","neverCount","consideredCount","sub","split","map","segment","segmentRef","cached","get","placeholder","set","valueRef","value","refs","v"],"mappings":"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"}