@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/updateMany.d.ts

@@ -1,10 +1,16 @@
 import type { UpdateMany } from 'payload';
 /**
  * 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.
+ * read-merge-write each, at most `WRITE_CONCURRENCY` at a time. 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
+ * Each write is conditional on its row being unchanged since it was read. A
+ * row that changed underneath is re-read and re-checked against `where`: if
+ * it still matches, the patch is re-applied to the fresh row; if it no longer
+ * matches (or is gone), it is skipped and left out of the result.
+ *
+ * `mapWithConcurrency` 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.

package/dist/updateMany.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateMany.d.ts","sourceRoot":"","sources":["../src/updateMany.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAWzC;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE,UA2CxB,CAAA"}
+{"version":3,"file":"updateMany.d.ts","sourceRoot":"","sources":["../src/updateMany.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAczC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,EAAE,UA2CxB,CAAA"}

package/dist/updateMany.js

@@ -1,48 +1,65 @@
-import { PutCommand } from '@aws-sdk/lib-dynamodb';
 import { applySorts } from './utilities/applySorts.js';
-import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { mapWithConcurrency } from './utilities/mapWithConcurrency.js';
+import { matchesWhere } from './utilities/matchesWhere.js';
+import { getById, writeWithRetry } from './utilities/optimistic.js';
+import { prepareCollectionWhere, prepareSort } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
 import { projectForCollection } from './utilities/resolveSchema.js';
+import { rethrowUniqueViolation } from './utilities/writeErrors.js';
+import { putItem, WRITE_CONCURRENCY } from './utilities/writeItems.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.
+ * read-merge-write each, at most `WRITE_CONCURRENCY` at a time. 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
+ * Each write is conditional on its row being unchanged since it was read. A
+ * row that changed underneath is re-read and re-checked against `where`: if
+ * it still matches, the patch is re-applied to the fresh row; if it no longer
+ * matches (or is gone), it is skipped and left out of the result.
+ *
+ * `mapWithConcurrency` 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.');
-    }
+ */ export const updateMany = async function updateMany({ collection, data, limit, locale, req, returning, sort, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere, locale);
     const partition = this.resolvePartition(collection);
     const matched = await queryMatching(this, partition, where);
-    applySorts(matched, sort);
+    applySorts(matched, prepareSort(this, {
+        kind: 'collection',
+        slug: collection
+    }, sort, locale));
     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;
+    let updated;
+    try {
+        updated = await mapWithConcurrency(targets, WRITE_CONCURRENCY, (target)=>writeWithRetry(target, async ()=>{
+                const fresh = await getById(this, partition, target['id']);
+                return fresh && matchesWhere(fresh, where) ? fresh : null;
+            }, async (current)=>{
+                const merged = {
+                    ...current,
+                    ...data,
+                    id: current['id'],
+                    updatedAt
+                };
+                const projected = projectForCollection(this, collection, merged);
+                await putItem(this, partition, projected, {
+                    replaces: current,
+                    unique: {
+                        collection
+                    }
+                });
+                return projected;
+            }));
+    } catch (err) {
+        rethrowUniqueViolation(err, collection, req);
+        throw err;
+    }
+    return returning === false ? null : updated.filter((doc)=>doc !== null);
 };
 
 //# sourceMappingURL=updateMany.js.map

package/dist/updateMany.js.map

@@ -1 +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"}
+{"version":3,"sources":["../src/updateMany.ts"],"sourcesContent":["import type { UpdateMany } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { mapWithConcurrency } from './utilities/mapWithConcurrency.js'\nimport { matchesWhere } from './utilities/matchesWhere.js'\nimport { getById, writeWithRetry } from './utilities/optimistic.js'\nimport { prepareCollectionWhere, prepareSort } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\nimport { rethrowUniqueViolation } from './utilities/writeErrors.js'\nimport { putItem, WRITE_CONCURRENCY } from './utilities/writeItems.js'\n\n/**\n * v1 strategy: query-and-collect matches, sort, slice to `limit`, then\n * read-merge-write each, at most `WRITE_CONCURRENCY` at a time. Same merge\n * semantics as `updateOne`: `data` is overlaid on the target and `id` is\n * preserved from the target.\n *\n * Each write is conditional on its row being unchanged since it was read. A\n * row that changed underneath is re-read and re-checked against `where`: if\n * it still matches, the patch is re-applied to the fresh row; if it no longer\n * matches (or is gone), it is skipped and left out of the result.\n *\n * `mapWithConcurrency` 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, locale, req, returning, sort, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere, locale)\n  const partition = this.resolvePartition(collection)\n  const matched = await queryMatching(this, partition, where)\n  applySorts(matched, prepareSort(this, { kind: 'collection', slug: collection }, sort, locale))\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  let updated: (null | Record<string, unknown>)[]\n  try {\n    updated = await mapWithConcurrency(targets, WRITE_CONCURRENCY, (target) =>\n      writeWithRetry(\n        target,\n        async () => {\n          const fresh = await getById(this, partition, target['id'])\n          return fresh && matchesWhere(fresh, where) ? fresh : null\n        },\n        async (current) => {\n          const merged: Record<string, unknown> = {\n            ...current,\n            ...data,\n            id: current['id'],\n            updatedAt,\n          }\n          const projected = projectForCollection(this, collection, merged)\n          await putItem(this, partition, projected, { replaces: current, unique: { collection } })\n          return projected\n        },\n      ),\n    )\n  } catch (err) {\n    rethrowUniqueViolation(err, collection, req)\n    throw err\n  }\n\n  return returning === false ? null : updated.filter((doc) => doc !== null)\n}\n"],"names":["applySorts","mapWithConcurrency","matchesWhere","getById","writeWithRetry","prepareCollectionWhere","prepareSort","queryMatching","projectForCollection","rethrowUniqueViolation","putItem","WRITE_CONCURRENCY","updateMany","collection","data","limit","locale","req","returning","sort","where","rawWhere","partition","resolvePartition","matched","kind","slug","targets","slice","updatedAt","Date","toISOString","updated","target","fresh","current","merged","id","projected","replaces","unique","err","filter","doc"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,YAAY,QAAQ,8BAA6B;AAC1D,SAASC,OAAO,EAAEC,cAAc,QAAQ,4BAA2B;AACnE,SAASC,sBAAsB,EAAEC,WAAW,QAAQ,8BAA6B;AACjF,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,sBAAsB,QAAQ,6BAA4B;AACnE,SAASC,OAAO,EAAEC,iBAAiB,QAAQ,4BAA2B;AAEtE;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,GAAG,EAAEC,SAAS,EAAEC,IAAI,EAAEC,OAAOC,QAAQ,EAAE;IAE1E,MAAMD,QAAQ,MAAMf,uBAAuB,IAAI,EAAEQ,YAAYQ,UAAUL;IACvE,MAAMM,YAAY,IAAI,CAACC,gBAAgB,CAACV;IACxC,MAAMW,UAAU,MAAMjB,cAAc,IAAI,EAAEe,WAAWF;IACrDpB,WAAWwB,SAASlB,YAAY,IAAI,EAAE;QAAEmB,MAAM;QAAcC,MAAMb;IAAW,GAAGM,MAAMH;IAEtF,MAAMW,UAAUZ,SAASA,QAAQ,IAAIS,QAAQI,KAAK,CAAC,GAAGb,SAASS;IAE/D,6EAA6E;IAC7E,oEAAoE;IACpE,MAAMK,YAAYf,IAAI,CAAC,YAAY,IAAI,IAAIgB,OAAOC,WAAW;IAE7D,IAAIC;IACJ,IAAI;QACFA,UAAU,MAAM/B,mBAAmB0B,SAAShB,mBAAmB,CAACsB,SAC9D7B,eACE6B,QACA;gBACE,MAAMC,QAAQ,MAAM/B,QAAQ,IAAI,EAAEmB,WAAWW,MAAM,CAAC,KAAK;gBACzD,OAAOC,SAAShC,aAAagC,OAAOd,SAASc,QAAQ;YACvD,GACA,OAAOC;gBACL,MAAMC,SAAkC;oBACtC,GAAGD,OAAO;oBACV,GAAGrB,IAAI;oBACPuB,IAAIF,OAAO,CAAC,KAAK;oBACjBN;gBACF;gBACA,MAAMS,YAAY9B,qBAAqB,IAAI,EAAEK,YAAYuB;gBACzD,MAAM1B,QAAQ,IAAI,EAAEY,WAAWgB,WAAW;oBAAEC,UAAUJ;oBAASK,QAAQ;wBAAE3B;oBAAW;gBAAE;gBACtF,OAAOyB;YACT;IAGN,EAAE,OAAOG,KAAK;QACZhC,uBAAuBgC,KAAK5B,YAAYI;QACxC,MAAMwB;IACR;IAEA,OAAOvB,cAAc,QAAQ,OAAOc,QAAQU,MAAM,CAAC,CAACC,MAAQA,QAAQ;AACtE,EAAC"}

package/dist/updateOne.d.ts

@@ -4,7 +4,12 @@ import type { UpdateOne } from 'payload';
  * 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.
+ * earn its own milestone.
+ *
+ * The write is conditional on the row still being at the revision that was
+ * read. If another writer got in first, the patch is re-applied to the fresh
+ * row (`writeWithRetry`), so concurrent updates to different fields both
+ * land.
  *
  * `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.

package/dist/updateOne.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"updateOne.d.ts","sourceRoot":"","sources":["../src/updateOne.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAWxC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,EAAE,SA0CvB,CAAA"}

package/dist/updateOne.js

@@ -1,68 +1,68 @@
-import { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
 import { findFirst } from './utilities/findFirst.js';
-import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { getById, writeWithRetry } from './utilities/optimistic.js';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { projectForCollection } from './utilities/resolveSchema.js';
-import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+import { rethrowUniqueViolation } from './utilities/writeErrors.js';
+import { putItem } from './utilities/writeItems.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.
+ * earn its own milestone.
+ *
+ * The write is conditional on the row still being at the revision that was
+ * read. If another writer got in first, the patch is re-applied to the fresh
+ * row (`writeWithRetry`), so concurrent updates to different fields both
+ * land.
  *
  * `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, {
+    const { collection, data } = args;
+    const partition = this.resolvePartition(collection);
+    const byId = args.id !== undefined && args.id !== null;
+    const where = byId ? undefined : await prepareCollectionWhere(this, collection, args.where, args.locale);
+    const read = ()=>{
+        if (byId) return getById(this, partition, args.id);
+        return where ? findFirst(this, {
             partition,
-            where: args.where
+            where
+        }) : Promise.resolve(null);
+    };
+    let updated;
+    try {
+        updated = await writeWithRetry(await read(), read, async (target)=>{
+            const merged = {
+                ...target,
+                ...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: 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, collection, merged);
+            await putItem(this, partition, projected, {
+                replaces: target,
+                unique: {
+                    collection
+                }
+            });
+            return projected;
         });
+    } catch (err) {
+        rethrowUniqueViolation(err, collection, args.req);
+        throw err;
     }
-    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) {
+    if (!updated || args.returning === false) {
         return null;
     }
-    return projected;
+    return updated;
 };
 
 //# sourceMappingURL=updateOne.js.map

package/dist/updateOne.js.map

@@ -1 +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"}
+{"version":3,"sources":["../src/updateOne.ts"],"sourcesContent":["import type { UpdateOne } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { getById, writeWithRetry } from './utilities/optimistic.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\nimport { rethrowUniqueViolation } from './utilities/writeErrors.js'\nimport { putItem } from './utilities/writeItems.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.\n *\n * The write is conditional on the row still being at the revision that was\n * read. If another writer got in first, the patch is re-applied to the fresh\n * row (`writeWithRetry`), so concurrent updates to different fields both\n * land.\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 { collection, data } = args\n  const partition = this.resolvePartition(collection)\n\n  const byId = args.id !== undefined && args.id !== null\n  const where = byId\n    ? undefined\n    : await prepareCollectionWhere(this, collection, args.where, args.locale)\n  const read = () => {\n    if (byId) return getById(this, partition, args.id)\n    return where ? findFirst(this, { partition, where }) : Promise.resolve(null)\n  }\n\n  let updated: null | Record<string, unknown>\n  try {\n    updated = await writeWithRetry(await read(), read, async (target) => {\n      const merged: Record<string, unknown> = {\n        ...target,\n        ...data,\n        id: target['id'],\n        // Bump `updatedAt` automatically. Explicit timestamps in `data` (e.g.\n        // from version restores or migrations) still win because they land in\n        // the spread above and we only override here when `data` didn't\n        // supply one.\n        updatedAt: 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\n      // on the persisted target — every update doubles as incremental cleanup.\n      const projected = projectForCollection(this, collection, merged)\n      await putItem(this, partition, projected, { replaces: target, unique: { collection } })\n      return projected\n    })\n  } catch (err) {\n    rethrowUniqueViolation(err, collection, args.req)\n    throw err\n  }\n\n  if (!updated || args.returning === false) {\n    return null as never\n  }\n  return updated as never\n}\n"],"names":["findFirst","getById","writeWithRetry","prepareCollectionWhere","projectForCollection","rethrowUniqueViolation","putItem","updateOne","args","collection","data","partition","resolvePartition","byId","id","undefined","where","locale","read","Promise","resolve","updated","target","merged","updatedAt","Date","toISOString","projected","replaces","unique","err","req","returning"],"mappings":"AAIA,SAASA,SAAS,QAAQ,2BAA0B;AACpD,SAASC,OAAO,EAAEC,cAAc,QAAQ,4BAA2B;AACnE,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,sBAAsB,QAAQ,6BAA4B;AACnE,SAASC,OAAO,QAAQ,4BAA2B;AAEnD;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,YAAuB,eAAeA,UAA+BC,IAAI;IACpF,MAAM,EAAEC,UAAU,EAAEC,IAAI,EAAE,GAAGF;IAC7B,MAAMG,YAAY,IAAI,CAACC,gBAAgB,CAACH;IAExC,MAAMI,OAAOL,KAAKM,EAAE,KAAKC,aAAaP,KAAKM,EAAE,KAAK;IAClD,MAAME,QAAQH,OACVE,YACA,MAAMZ,uBAAuB,IAAI,EAAEM,YAAYD,KAAKQ,KAAK,EAAER,KAAKS,MAAM;IAC1E,MAAMC,OAAO;QACX,IAAIL,MAAM,OAAOZ,QAAQ,IAAI,EAAEU,WAAWH,KAAKM,EAAE;QACjD,OAAOE,QAAQhB,UAAU,IAAI,EAAE;YAAEW;YAAWK;QAAM,KAAKG,QAAQC,OAAO,CAAC;IACzE;IAEA,IAAIC;IACJ,IAAI;QACFA,UAAU,MAAMnB,eAAe,MAAMgB,QAAQA,MAAM,OAAOI;YACxD,MAAMC,SAAkC;gBACtC,GAAGD,MAAM;gBACT,GAAGZ,IAAI;gBACPI,IAAIQ,MAAM,CAAC,KAAK;gBAChB,sEAAsE;gBACtE,sEAAsE;gBACtE,gEAAgE;gBAChE,cAAc;gBACdE,WAAWd,IAAI,CAAC,YAAY,IAAI,IAAIe,OAAOC,WAAW;YACxD;YACA,sEAAsE;YACtE,sEAAsE;YACtE,yEAAyE;YACzE,MAAMC,YAAYvB,qBAAqB,IAAI,EAAEK,YAAYc;YACzD,MAAMjB,QAAQ,IAAI,EAAEK,WAAWgB,WAAW;gBAAEC,UAAUN;gBAAQO,QAAQ;oBAAEpB;gBAAW;YAAE;YACrF,OAAOkB;QACT;IACF,EAAE,OAAOG,KAAK;QACZzB,uBAAuByB,KAAKrB,YAAYD,KAAKuB,GAAG;QAChD,MAAMD;IACR;IAEA,IAAI,CAACT,WAAWb,KAAKwB,SAAS,KAAK,OAAO;QACxC,OAAO;IACT;IACA,OAAOX;AACT,EAAC"}

package/dist/updateVersion.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"updateVersion.d.ts","sourceRoot":"","sources":["../src/updateVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,EAAE,aAK3B,CAAA"}

package/dist/updateVersion.js

@@ -1,8 +1,4 @@
-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';
+import { updateVersionRow } from './utilities/updateVersionRow.js';
 /**
  * Read-merge-write against the versions partition. `versionData` is
  * splatted onto the existing row, which means Payload-passed metadata
@@ -15,55 +11,10 @@ import { stripInternalKeys } from './utilities/stripInternalKeys.js';
  * 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, {
+    return updateVersionRow(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;
+    }, args);
 };
 
 //# sourceMappingURL=updateVersion.js.map

package/dist/updateVersion.js.map

@@ -1 +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"}
+{"version":3,"sources":["../src/updateVersion.ts"],"sourcesContent":["import type { UpdateVersion } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { updateVersionRow } from './utilities/updateVersionRow.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  return updateVersionRow(this, { kind: 'collection', slug: args.collection }, args) as never\n}\n"],"names":["updateVersionRow","updateVersion","args","kind","slug","collection"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,kCAAiC;AAElE;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzDC,IAAI;IAEJ,OAAOF,iBAAiB,IAAI,EAAE;QAAEG,MAAM;QAAcC,MAAMF,KAAKG,UAAU;IAAC,GAAGH;AAC/E,EAAC"}

package/dist/upsert.d.ts

@@ -2,6 +2,12 @@ import type { Upsert } from 'payload';
 /**
  * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.
  *
+ * Both branches are conditional — the update on the row being unchanged
+ * since it was read, the insert on no row having appeared at that id — and
+ * the whole locate-then-write is retried when the condition fails, so two
+ * concurrent upserts of the same thing converge instead of clobbering each
+ * other.
+ *
  * 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.

package/dist/upsert.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../src/upsert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAarC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,EAAE,MA+CpB,CAAA"}

package/dist/upsert.js

@@ -1,55 +1,71 @@
-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 { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { projectForCollection } from './utilities/resolveSchema.js';
+import { rethrowUniqueViolation } from './utilities/writeErrors.js';
+import { isConditionalCheckFailed, putItem } from './utilities/writeItems.js';
 /**
  * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.
  *
+ * Both branches are conditional — the update on the row being unchanged
+ * since it was read, the insert on no row having appeared at that id — and
+ * the whole locate-then-write is retried when the condition fails, so two
+ * concurrent upserts of the same thing converge instead of clobbering each
+ * other.
+ *
  * 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.');
-    }
+ */ export const upsert = async function upsert({ collection, data, locale, req, returning, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere, locale);
     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
-        };
+    for(let attempt = 1;; attempt++){
+        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);
+        try {
+            await putItem(this, partition, projected, {
+                ...found ? {
+                    replaces: found
+                } : {
+                    mustNotExist: true
+                },
+                unique: {
+                    collection
+                }
+            });
+            return returning === false ? null : projected;
+        } catch (err) {
+            rethrowUniqueViolation(err, collection, req);
+            if (!isConditionalCheckFailed(err)) throw err;
+            if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError();
+            await backoff(attempt);
+        }
     }
-    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

@@ -1 +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"}
+{"version":3,"sources":["../src/upsert.ts"],"sourcesContent":["import type { Upsert } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\nimport { rethrowUniqueViolation } from './utilities/writeErrors.js'\nimport { isConditionalCheckFailed, putItem } from './utilities/writeItems.js'\n\n/**\n * Locate by `where`; merge-and-put if found, put-with-fresh-id otherwise.\n *\n * Both branches are conditional — the update on the row being unchanged\n * since it was read, the insert on no row having appeared at that id — and\n * the whole locate-then-write is retried when the condition fails, so two\n * concurrent upserts of the same thing converge instead of clobbering each\n * other.\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, locale, req, returning, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere, locale)\n  const partition = this.resolvePartition(collection)\n\n  for (let attempt = 1; ; attempt++) {\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    try {\n      await putItem(this, partition, projected, {\n        ...(found ? { replaces: found } : { mustNotExist: true }),\n        unique: { collection },\n      })\n      return returning === false ? (null as never) : (projected as never)\n    } catch (err) {\n      rethrowUniqueViolation(err, collection, req)\n      if (!isConditionalCheckFailed(err)) throw err\n      if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError()\n      await backoff(attempt)\n    }\n  }\n}\n"],"names":["randomUUID","findFirst","backoff","conflictError","MAX_WRITE_ATTEMPTS","prepareCollectionWhere","projectForCollection","rethrowUniqueViolation","isConditionalCheckFailed","putItem","upsert","collection","data","locale","req","returning","where","rawWhere","partition","resolvePartition","attempt","found","now","Date","toISOString","item","id","updatedAt","createdAt","projected","replaces","mustNotExist","unique","err"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,OAAO,EAAEC,aAAa,EAAEC,kBAAkB,QAAQ,4BAA2B;AACtF,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,sBAAsB,QAAQ,6BAA4B;AACnE,SAASC,wBAAwB,EAAEC,OAAO,QAAQ,4BAA2B;AAE7E;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,SAAiB,eAAeA,OAE3C,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,GAAG,EAAEC,SAAS,EAAEC,OAAOC,QAAQ,EAAE;IAE7D,MAAMD,QAAQ,MAAMX,uBAAuB,IAAI,EAAEM,YAAYM,UAAUJ;IACvE,MAAMK,YAAY,IAAI,CAACC,gBAAgB,CAACR;IAExC,IAAK,IAAIS,UAAU,IAAKA,UAAW;QACjC,MAAMC,QAAQ,MAAMpB,UAAU,IAAI,EAAE;YAAEiB;YAAWF;QAAM;QAEvD,MAAMM,MAAM,IAAIC,OAAOC,WAAW;QAClC,IAAIC;QACJ,IAAIJ,OAAO;YACT,uEAAuE;YACvEI,OAAO;gBACL,GAAGJ,KAAK;gBACR,GAAGT,IAAI;gBACPc,IAAIL,KAAK,CAAC,KAAK;gBACfM,WAAWf,IAAI,CAAC,YAAY,IAAIU;YAClC;QACF,OAAO;YACL,MAAMI,KAAKd,IAAI,CAAC,KAAK,IAAIZ;YACzB,uEAAuE;YACvE,kEAAkE;YAClEyB,OAAO;gBACL,GAAGb,IAAI;gBACPc;gBACAE,WAAWhB,IAAI,CAAC,YAAY,IAAIU;gBAChCK,WAAWf,IAAI,CAAC,YAAY,IAAIU;YAClC;QACF;QAEA,MAAMO,YAAYvB,qBAAqB,IAAI,EAAEK,YAAYc;QAEzD,IAAI;YACF,MAAMhB,QAAQ,IAAI,EAAES,WAAWW,WAAW;gBACxC,GAAIR,QAAQ;oBAAES,UAAUT;gBAAM,IAAI;oBAAEU,cAAc;gBAAK,CAAC;gBACxDC,QAAQ;oBAAErB;gBAAW;YACvB;YACA,OAAOI,cAAc,QAAS,OAAkBc;QAClD,EAAE,OAAOI,KAAK;YACZ1B,uBAAuB0B,KAAKtB,YAAYG;YACxC,IAAI,CAACN,yBAAyByB,MAAM,MAAMA;YAC1C,IAAIb,WAAWhB,oBAAoB,MAAMD;YACzC,MAAMD,QAAQkB;QAChB;IACF;AACF,EAAC"}