@open-aih/payload-ddb 3.1.0 → 4.1.0

package/README.md

@@ -3,22 +3,35 @@
 An unofficial database adapter for [PayloadCMS](https://payloadcms.com) that
 stores data in [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
 
-> **Status:** all `BaseDatabaseAdapter` methods are implemented end-to-end. The
-> common access patterns (CRUD, drafts, versions, globals, locales-as-fields)
-> work today. The current strategy is "correct first, optimize later" — single
-> shared table with a `Query`-per-collection access pattern, no GSIs, no range
-> operators in `FilterExpression`. Suitable for development and
-> small-to-medium workloads; large collections will want the optimization
-> milestones tracked in the issues.
+> **Status:** all `BaseDatabaseAdapter` methods are implemented end-to-end:
+> CRUD, drafts, versions, globals, localization, every `where` operator, join
+> fields and unique fields. The current strategy is "correct first, optimize
+> later" — a single shared table with a `Query`-per-collection access pattern
+> and no GSIs. Suitable for development and small-to-medium workloads; large
+> collections will want the optimizations listed under *Known limits*.
+
+## Requirements
+
+- **Payload 3.x.** The peer range is `payload >=3.0.0`; the test suite runs
+  against 3.93.
+- **Node.js as your Payload version requires.** Payload 3.92 and later need
+  Node 22.23.4+ or 24.22.1+. This repo's CI runs on Node 24.
 
 ## Installation
 
+The package is published under two names with the same contents:
+
 ```bash
+# Public npm registry — minor and major releases
+pnpm add @open-aih/payload-ddb
+
+# GitHub Packages — every release, including patches
 pnpm add @aih-software/payload-ddb
-# or
-npm install @aih-software/payload-ddb
 ```
 
+The examples below import from `@aih-software/payload-ddb`; use
+`@open-aih/payload-ddb` instead if that is the one you installed.
+
 ## Quick start (DynamoDB Local)
 
 ```ts
@@ -75,6 +88,7 @@ value in the same physical table.
 | `translateConfig` | `TranslateConfig` | `removeUndefinedValues: true`, `convertClassInstanceToMap: true` | Marshalling options forwarded to `DynamoDBDocumentClient.from`. |
 | `tableName` | `string` | `'payload'` | The single DynamoDB table backing every collection, global, and versions stream. |
 | `ensureTables` | `boolean` | `false` | When true, auto-creates the table at init if it doesn't exist. Dev-loop convenience; turn off in production. |
+| `migrationDir` | `string` | `'migrations'` | Directory Payload reads and writes migration files in. |
 
 ## Data layout
 
@@ -88,7 +102,12 @@ value in the same physical table.
 - **Sort key is always String.** Number-typed collection ids are coerced to
   strings for `sk` while the original numeric `id` attribute is preserved on
   the row.
-- **No GSIs or LSIs in v2.** Per-collection reads are `Query`s scoped by `pk`;
+- **Revision counter.** Every row also carries `_rev`, bumped on each write
+  and stripped on read. Updates are conditional on it, so two writers can't
+  silently overwrite each other.
+- **Unique guards:** `pk = "<slug>#unique#<field path>"`, `sk = "<value>"`,
+  one small row per value of a `unique: true` field. See *Unique fields*.
+- **No GSIs or LSIs.** Per-collection reads are `Query`s scoped by `pk`;
   predicates beyond `pk` get pushed to `FilterExpression` (DynamoDB still
   reads every row in the partition before filtering).
 
@@ -97,14 +116,91 @@ value in the same physical table.
 All `BaseDatabaseAdapter` methods: `create`, `find`, `findOne`, `findDistinct`,
 `count`, `updateOne`, `updateMany`, `deleteOne`, `deleteMany`, `upsert`,
 `createGlobal`/`findGlobal`/`updateGlobal`, the five collection version methods,
-the four global version methods, and `queryDrafts`.
+the four global version methods, `queryDrafts`, and `updateJobs`.
+
+### Queries
+
+Every Payload `where` operator is supported: `equals`, `not_equals`,
+`greater_than`, `greater_than_equal`, `less_than`, `less_than_equal`, `in`,
+`not_in`, `all`, `exists`, `like`, `not_like`, `contains`, `near`, `within`,
+`intersects`, plus `and` / `or` composition.
+
+- **Pushdown where possible, JS for the rest.** Clauses DynamoDB can express
+  go into a `FilterExpression`. The others — the case-insensitive text
+  operators (`like`, `not_like`, `contains`), `all`, the geo operators, and
+  any path that runs through a list — are evaluated in JS on the rows that
+  come back. A `where` that mixes both kinds still narrows the read
+  server-side.
+- **Lists behave as in MongoDB.** A `hasMany` field, an `array` or `blocks`
+  field, or a list inside `json` is transparent in a path: `tags equals 'x'`
+  matches when any element is `'x'`, `items.label equals 'x'` when any row
+  has that label. Negative operators hold only when no element matches.
+- **Relationship paths.** `author.name equals 'Ada'` is resolved by querying
+  the related collection and filtering on the ids it returns; multi-hop paths
+  work the same way.
+- **Localized fields.** With localization enabled, filters and sorts on a
+  localized field address the request's locale (`title` → `title.en`), or the
+  locale written into the path.
+- **Operand casting.** Operands are cast to the field's stored type, so
+  filters sent as strings (REST query strings, admin list filters) behave:
+  numeric strings on `number` fields, `'true'`/`'false'` on `checkbox` fields,
+  date strings on `date` fields, ids on relationships to numeric-id
+  collections, and comma-delimited lists for `in` / `not_in` / `all`.
+  DynamoDB compares strictly by type, so an operand the adapter can't cast
+  (an unknown path) is compared as given.
+- **`exists`** treats a field stored as `null` the same as a missing one, and
+  for text-like fields an empty string as well.
+- **Geo operators** work on `point` fields. Distances are great-circle
+  metres; polygon tests are planar.
+
+### Join fields
+
+`join` fields are resolved for `find`, `findByID` and draft queries: one query
+per target collection for all returned documents, grouped in memory, with
+`limit`, `page`, `sort`, `where` and `count` applied per parent document.
+Polymorphic joins (`collection: [...]`) return `{ relationTo, value }` entries.
+Joined documents are read from the target's published rows.
+
+### Write guarantees
+
+- **`create` is insert-only.** An id that is already taken is rejected with a
+  `ValidationError` on `id` rather than replacing the existing document.
+- **No lost updates.** Updates are read-merge-write, conditional on the row's
+  revision. If another writer gets in first, the patch is re-applied to the
+  fresh row, so concurrent updates to different fields both land. This holds
+  per adapter call: Payload's own `update` operation fills the fields missing
+  from a patch with the values it read beforehand, so two concurrent
+  `payload.update` calls on one document can still overwrite each other.
+- **Jobs are claimed once.** `updateJobs` uses the same check, so two workers
+  polling the queue can't both take the same job.
+- **Bulk writes are bounded.** `updateMany`, `deleteMany` and `deleteVersions`
+  keep at most 25 requests in flight.
+- **Oversized documents fail clearly.** DynamoDB caps an item at 400 KB;
+  exceeding it raises a 413 naming the document instead of a bare
+  `ValidationException`.
 
-Supported `where` operators: `equals`, `not_equals`, `greater_than`,
-`greater_than_equal`, `less_than`, `less_than_equal`, `in`, `not_in`, `exists`,
-`like`, plus `and` / `or` composition. Anything else throws by design so
-coverage gaps surface loudly. `like` is case-insensitive and evaluated in JS
-(DynamoDB's `contains()` is case-sensitive, so the adapter doesn't push it
-down).
+### Unique fields
+
+`unique: true` is enforced for scalar fields at the top level or inside groups
+and named tabs, including localized fields (per locale) and an auth
+collection's `email` / `username`. Each value is claimed by a guard row
+written in the same transaction as the document, so a duplicate is rejected
+with a `ValidationError` on the field — also under concurrent writes. Blank
+values (`null`, `''`) are not guarded. Unique fields inside arrays or blocks,
+and `hasMany` fields, are not enforced.
+
+Writes to a collection with unique fields are transactional and cost twice the
+write units; collections without them are unaffected.
+
+Documents written before this was enforced have no guards until they are next
+saved. To cover them in one pass:
+
+```ts
+import { backfillUniqueGuards } from '@aih-software/payload-ddb'
+
+const report = await backfillUniqueGuards(payload)
+// report.collections[slug].conflicts lists pre-existing duplicates
+```
 
 ## Known limits / future work
 
@@ -118,12 +214,22 @@ down).
   commit/rollback do nothing. Per-method atomicity (e.g. `createVersion`'s
   flip+put) uses DynamoDB `TransactWriteItems` already; full Payload-context
   transaction buffering across multiple adapter calls is its own milestone.
+- **Filters cost a partition read.** Clauses evaluated in JS, relationship
+  paths and joins all read the partitions involved in full (a relationship
+  path or join adds one read of the related collection). Fine at CMS scale;
+  the GSI milestone is what removes it.
+- **Joins don't see unpublished drafts** of the joined collection.
+- **`locale: 'all'`** in a filter or sort falls back to the default locale.
+- **`like` matches its operand as one substring.** Payload's Mongo adapter
+  splits the operand into words and requires each of them to match.
+- **Items are limited to 400 KB**, including a version row's full snapshot.
 
 ## Development
 
 The package ships with a vitest integration test harness that boots Payload
 against DynamoDB Local. Each spec file uses a unique table name so vitest
-workers can run in parallel against a single shared container. Also make sure port 8000 is open.
+workers can run in parallel against a single shared container, which listens
+on port 8001. Use Node 24, the version CI runs.
 
 ```bash
 pnpm install
@@ -141,6 +247,23 @@ reachable. Override the host/port with `PAYLOAD_DDB_TEST_HOST` /
 See [`test/README.md`](./test/README.md) for the harness layout and how to
 add a new spec.
 
+### Releasing
+
+Releases are cut by CI on every push to `main` that carries a
+[changeset](https://github.com/changesets/changesets) (`pnpm changeset`):
+
+1. The integration tests run.
+2. The version is bumped, committed as `chore(release): vX.Y.Z` and tagged.
+3. The package is published to GitHub Packages as
+   `@aih-software/payload-ddb`, and a GitHub Release is created.
+4. For minor and major bumps, the same build is published to the public npm
+   registry as `@open-aih/payload-ddb`.
+
+The public publish uses npm
+[trusted publishing](https://docs.npmjs.com/trusted-publishers), so there is
+no npm token to rotate. The trusted publisher configured on npmjs.com must
+name this repository and the workflow file `release.yml`.
+
 ## License
 
 MIT

package/dist/count.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../src/count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAMpC,eAAO,MAAM,KAAK,EAAE,KAGnB,CAAA"}
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../src/count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAOpC,eAAO,MAAM,KAAK,EAAE,KAInB,CAAA"}

package/dist/count.js

@@ -1,6 +1,8 @@
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { queryCount } from './utilities/queryCount.js';
-export const count = async function count({ collection, where }) {
-    const totalDocs = await queryCount(this, this.resolvePartition(collection), where);
+export const count = async function count({ collection, locale, where }) {
+    const cast = await prepareCollectionWhere(this, collection, where, locale);
+    const totalDocs = await queryCount(this, this.resolvePartition(collection), cast);
     return {
         totalDocs
     };

package/dist/count.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/count.ts"],"sourcesContent":["import type { Count } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const count: Count = async function count(this: DynamoAdapter, { collection, where }) {\n  const totalDocs = await queryCount(this, this.resolvePartition(collection), where)\n  return { totalDocs }\n}\n"],"names":["queryCount","count","collection","where","totalDocs","resolvePartition"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,QAAe,eAAeA,MAA2B,EAAEC,UAAU,EAAEC,KAAK,EAAE;IACzF,MAAMC,YAAY,MAAMJ,WAAW,IAAI,EAAE,IAAI,CAACK,gBAAgB,CAACH,aAAaC;IAC5E,OAAO;QAAEC;IAAU;AACrB,EAAC"}
+{"version":3,"sources":["../src/count.ts"],"sourcesContent":["import type { Count } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const count: Count = async function count(this: DynamoAdapter, { collection, locale, where }) {\n  const cast = await prepareCollectionWhere(this, collection, where, locale)\n  const totalDocs = await queryCount(this, this.resolvePartition(collection), cast)\n  return { totalDocs }\n}\n"],"names":["prepareCollectionWhere","queryCount","count","collection","locale","where","cast","totalDocs","resolvePartition"],"mappings":"AAIA,SAASA,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,QAAe,eAAeA,MAA2B,EAAEC,UAAU,EAAEC,MAAM,EAAEC,KAAK,EAAE;IACjG,MAAMC,OAAO,MAAMN,uBAAuB,IAAI,EAAEG,YAAYE,OAAOD;IACnE,MAAMG,YAAY,MAAMN,WAAW,IAAI,EAAE,IAAI,CAACO,gBAAgB,CAACL,aAAaG;IAC5E,OAAO;QAAEC;IAAU;AACrB,EAAC"}

package/dist/countGlobalVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"countGlobalVersions.d.ts","sourceRoot":"","sources":["../src/countGlobalVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAMlD,eAAO,MAAM,mBAAmB,EAAE,mBAMjC,CAAA"}
+{"version":3,"file":"countGlobalVersions.d.ts","sourceRoot":"","sources":["../src/countGlobalVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAOlD,eAAO,MAAM,mBAAmB,EAAE,mBAOjC,CAAA"}

package/dist/countGlobalVersions.js

@@ -1,5 +1,10 @@
+import { prepareVersionsWhere } from './utilities/prepareWhere.js';
 import { queryCount } from './utilities/queryCount.js';
-export const countGlobalVersions = async function countGlobalVersions({ global, where }) {
+export const countGlobalVersions = async function countGlobalVersions({ global, locale, where: rawWhere }) {
+    const where = await prepareVersionsWhere(this, {
+        kind: 'global',
+        slug: global
+    }, rawWhere, locale);
     const totalDocs = await queryCount(this, this.resolveVersionsPartition(global), where);
     return {
         totalDocs

package/dist/countGlobalVersions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/countGlobalVersions.ts"],"sourcesContent":["import type { CountGlobalVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const countGlobalVersions: CountGlobalVersions = async function countGlobalVersions(\n  this: DynamoAdapter,\n  { global, where },\n) {\n  const totalDocs = await queryCount(this, this.resolveVersionsPartition(global), where)\n  return { totalDocs }\n}\n"],"names":["queryCount","countGlobalVersions","global","where","totalDocs","resolveVersionsPartition"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,sBAA2C,eAAeA,oBAErE,EAAEC,MAAM,EAAEC,KAAK,EAAE;IAEjB,MAAMC,YAAY,MAAMJ,WAAW,IAAI,EAAE,IAAI,CAACK,wBAAwB,CAACH,SAASC;IAChF,OAAO;QAAEC;IAAU;AACrB,EAAC"}
+{"version":3,"sources":["../src/countGlobalVersions.ts"],"sourcesContent":["import type { CountGlobalVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const countGlobalVersions: CountGlobalVersions = async function countGlobalVersions(\n  this: DynamoAdapter,\n  { global, locale, where: rawWhere },\n) {\n  const where = await prepareVersionsWhere(this, { kind: 'global', slug: global }, rawWhere, locale)\n  const totalDocs = await queryCount(this, this.resolveVersionsPartition(global), where)\n  return { totalDocs }\n}\n"],"names":["prepareVersionsWhere","queryCount","countGlobalVersions","global","locale","where","rawWhere","kind","slug","totalDocs","resolveVersionsPartition"],"mappings":"AAIA,SAASA,oBAAoB,QAAQ,8BAA6B;AAClE,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,sBAA2C,eAAeA,oBAErE,EAAEC,MAAM,EAAEC,MAAM,EAAEC,OAAOC,QAAQ,EAAE;IAEnC,MAAMD,QAAQ,MAAML,qBAAqB,IAAI,EAAE;QAAEO,MAAM;QAAUC,MAAML;IAAO,GAAGG,UAAUF;IAC3F,MAAMK,YAAY,MAAMR,WAAW,IAAI,EAAE,IAAI,CAACS,wBAAwB,CAACP,SAASE;IAChF,OAAO;QAAEI;IAAU;AACrB,EAAC"}

package/dist/countVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"countVersions.d.ts","sourceRoot":"","sources":["../src/countVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C,eAAO,MAAM,aAAa,EAAE,aAM3B,CAAA"}
+{"version":3,"file":"countVersions.d.ts","sourceRoot":"","sources":["../src/countVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAO5C,eAAO,MAAM,aAAa,EAAE,aAO3B,CAAA"}

package/dist/countVersions.js

@@ -1,5 +1,10 @@
+import { prepareVersionsWhere } from './utilities/prepareWhere.js';
 import { queryCount } from './utilities/queryCount.js';
-export const countVersions = async function countVersions({ collection, where }) {
+export const countVersions = async function countVersions({ collection, locale, where: rawWhere }) {
+    const where = await prepareVersionsWhere(this, {
+        kind: 'collection',
+        slug: collection
+    }, rawWhere, locale);
     const totalDocs = await queryCount(this, this.resolveVersionsPartition(collection), where);
     return {
         totalDocs

package/dist/countVersions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/countVersions.ts"],"sourcesContent":["import type { CountVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const countVersions: CountVersions = async function countVersions(\n  this: DynamoAdapter,\n  { collection, where },\n) {\n  const totalDocs = await queryCount(this, this.resolveVersionsPartition(collection), where)\n  return { totalDocs }\n}\n"],"names":["queryCount","countVersions","collection","where","totalDocs","resolveVersionsPartition"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EAAEC,UAAU,EAAEC,KAAK,EAAE;IAErB,MAAMC,YAAY,MAAMJ,WAAW,IAAI,EAAE,IAAI,CAACK,wBAAwB,CAACH,aAAaC;IACpF,OAAO;QAAEC;IAAU;AACrB,EAAC"}
+{"version":3,"sources":["../src/countVersions.ts"],"sourcesContent":["import type { CountVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryCount } from './utilities/queryCount.js'\n\nexport const countVersions: CountVersions = async function countVersions(\n  this: DynamoAdapter,\n  { collection, locale, where: rawWhere },\n) {\n  const where = await prepareVersionsWhere(this, { kind: 'collection', slug: collection }, rawWhere, locale)\n  const totalDocs = await queryCount(this, this.resolveVersionsPartition(collection), where)\n  return { totalDocs }\n}\n"],"names":["prepareVersionsWhere","queryCount","countVersions","collection","locale","where","rawWhere","kind","slug","totalDocs","resolveVersionsPartition"],"mappings":"AAIA,SAASA,oBAAoB,QAAQ,8BAA6B;AAClE,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EAAEC,UAAU,EAAEC,MAAM,EAAEC,OAAOC,QAAQ,EAAE;IAEvC,MAAMD,QAAQ,MAAML,qBAAqB,IAAI,EAAE;QAAEO,MAAM;QAAcC,MAAML;IAAW,GAAGG,UAAUF;IACnG,MAAMK,YAAY,MAAMR,WAAW,IAAI,EAAE,IAAI,CAACS,wBAAwB,CAACP,aAAaE;IACpF,OAAO;QAAEI;IAAU;AACrB,EAAC"}

package/dist/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAUrC,eAAO,MAAM,MAAM,EAAE,MAuCpB,CAAA"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAWrC,eAAO,MAAM,MAAM,EAAE,MA+CpB,CAAA"}

package/dist/create.js

@@ -1,12 +1,9 @@
-import { PutCommand } from '@aws-sdk/lib-dynamodb';
 import { randomUUID } from 'node:crypto';
-import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { backoff, conflictError, getById, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js';
 import { projectForCollection } from './utilities/resolveSchema.js';
-export const create = async function create({ collection, customID, data, returning }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
+import { mustBeUniqueError, rethrowUniqueViolation } from './utilities/writeErrors.js';
+import { isConditionalCheckFailed, putItem } from './utilities/writeItems.js';
+export const create = async function create({ collection, customID, data, req, returning }) {
     const id = customID ?? data['id'] ?? randomUUID();
     const now = new Date().toISOString();
     // Spread `data` first, then nullish-coalesce timestamps. Explicit values
@@ -24,14 +21,33 @@ export const create = async function create({ collection, customID, data, return
     // layer, so without this any stray request-body key (notoriously the
     // registration form's `confirm-password`) would persist verbatim.
     const projected = projectForCollection(this, collection, item);
-    await docClient.send(new PutCommand({
-        TableName: this.tableName,
-        Item: normalizeForDynamo({
-            ...projected,
-            pk: this.resolvePartition(collection),
-            sk: String(id)
-        })
-    }));
+    const partition = this.resolvePartition(collection);
+    for(let attempt = 1;; attempt++){
+        try {
+            // Insert-only: a plain `PutItem` would replace whatever row already
+            // sits at this id, so a caller-supplied id that collides with an
+            // existing doc would silently destroy it. `unique` adds a guard row per
+            // unique field in the same transaction.
+            await putItem(this, partition, projected, {
+                mustNotExist: true,
+                unique: {
+                    collection
+                }
+            });
+            break;
+        } catch (err) {
+            rethrowUniqueViolation(err, collection, req);
+            if (!isConditionalCheckFailed(err)) throw err;
+            // Either the id is taken, or this write collided with a concurrent one
+            // over a unique value. Surface the first the way the Mongo and Postgres
+            // adapters surface a duplicate primary key — a `ValidationError` on
+            // `id` — and retry the second, which resolves to a clean success or a
+            // unique violation.
+            if (await getById(this, partition, id)) throw mustBeUniqueError('id', collection, req);
+            if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError();
+            await backoff(attempt);
+        }
+    }
     return returning === false ? null : projected;
 };
 

package/dist/create.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/create.ts"],"sourcesContent":["import type { Create } from 'payload'\n\nimport { PutCommand } from '@aws-sdk/lib-dynamodb'\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\n\nexport const create: Create = async function create(\n  this: DynamoAdapter,\n  { collection, customID, data, returning },\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 id = customID ?? data['id'] ?? randomUUID()\n  const now = new Date().toISOString()\n  // Spread `data` first, then nullish-coalesce timestamps. Explicit values\n  // in `data` (versions/restore, migrations backdating) still win, but a\n  // payload-passed `data.createdAt = undefined` no longer wipes the default\n  // back to undefined — which the marshaller would then drop with\n  // `removeUndefinedValues: true`, leaving the row without timestamps.\n  const item: Record<string, unknown> = {\n    ...data,\n    id,\n    createdAt: data['createdAt'] ?? now,\n    updatedAt: data['updatedAt'] ?? now,\n  }\n  // Project against the collection's declared fields. DDB has no schema\n  // layer, so without this any stray request-body key (notoriously the\n  // registration form's `confirm-password`) would persist verbatim.\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: this.resolvePartition(collection),\n        sk: String(id),\n      }),\n    }),\n  )\n\n  return returning === false ? (null as never) : projected\n}\n"],"names":["PutCommand","randomUUID","normalizeForDynamo","projectForCollection","create","collection","customID","data","returning","docClient","Error","id","now","Date","toISOString","item","createdAt","updatedAt","projected","send","TableName","tableName","Item","pk","resolvePartition","sk","String"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAClD,SAASC,UAAU,QAAQ,cAAa;AAIxC,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE,OAAO,MAAMC,SAAiB,eAAeA,OAE3C,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,SAAS,EAAE;IAEzC,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,KAAKL,YAAYC,IAAI,CAAC,KAAK,IAAIN;IACrC,MAAMW,MAAM,IAAIC,OAAOC,WAAW;IAClC,yEAAyE;IACzE,uEAAuE;IACvE,0EAA0E;IAC1E,gEAAgE;IAChE,qEAAqE;IACrE,MAAMC,OAAgC;QACpC,GAAGR,IAAI;QACPI;QACAK,WAAWT,IAAI,CAAC,YAAY,IAAIK;QAChCK,WAAWV,IAAI,CAAC,YAAY,IAAIK;IAClC;IACA,sEAAsE;IACtE,qEAAqE;IACrE,kEAAkE;IAClE,MAAMM,YAAYf,qBAAqB,IAAI,EAAEE,YAAYU;IAEzD,MAAMN,UAAUU,IAAI,CAClB,IAAInB,WAAW;QACboB,WAAW,IAAI,CAACC,SAAS;QACzBC,MAAMpB,mBAAmB;YACvB,GAAGgB,SAAS;YACZK,IAAI,IAAI,CAACC,gBAAgB,CAACnB;YAC1BoB,IAAIC,OAAOf;QACb;IACF;IAGF,OAAOH,cAAc,QAAS,OAAiBU;AACjD,EAAC"}
+{"version":3,"sources":["../src/create.ts"],"sourcesContent":["import type { Create } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { backoff, conflictError, getById, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js'\nimport { projectForCollection } from './utilities/resolveSchema.js'\nimport { mustBeUniqueError, rethrowUniqueViolation } from './utilities/writeErrors.js'\nimport { isConditionalCheckFailed, putItem } from './utilities/writeItems.js'\n\nexport const create: Create = async function create(\n  this: DynamoAdapter,\n  { collection, customID, data, req, returning },\n) {\n  const id = customID ?? data['id'] ?? randomUUID()\n  const now = new Date().toISOString()\n  // Spread `data` first, then nullish-coalesce timestamps. Explicit values\n  // in `data` (versions/restore, migrations backdating) still win, but a\n  // payload-passed `data.createdAt = undefined` no longer wipes the default\n  // back to undefined — which the marshaller would then drop with\n  // `removeUndefinedValues: true`, leaving the row without timestamps.\n  const item: Record<string, unknown> = {\n    ...data,\n    id,\n    createdAt: data['createdAt'] ?? now,\n    updatedAt: data['updatedAt'] ?? now,\n  }\n  // Project against the collection's declared fields. DDB has no schema\n  // layer, so without this any stray request-body key (notoriously the\n  // registration form's `confirm-password`) would persist verbatim.\n  const projected = projectForCollection(this, collection, item)\n  const partition = this.resolvePartition(collection)\n\n  for (let attempt = 1; ; attempt++) {\n    try {\n      // Insert-only: a plain `PutItem` would replace whatever row already\n      // sits at this id, so a caller-supplied id that collides with an\n      // existing doc would silently destroy it. `unique` adds a guard row per\n      // unique field in the same transaction.\n      await putItem(this, partition, projected, { mustNotExist: true, unique: { collection } })\n      break\n    } catch (err) {\n      rethrowUniqueViolation(err, collection, req)\n      if (!isConditionalCheckFailed(err)) throw err\n\n      // Either the id is taken, or this write collided with a concurrent one\n      // over a unique value. Surface the first the way the Mongo and Postgres\n      // adapters surface a duplicate primary key — a `ValidationError` on\n      // `id` — and retry the second, which resolves to a clean success or a\n      // unique violation.\n      if (await getById(this, partition, id)) throw mustBeUniqueError('id', collection, req)\n      if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError()\n      await backoff(attempt)\n    }\n  }\n\n  return returning === false ? (null as never) : projected\n}\n"],"names":["randomUUID","backoff","conflictError","getById","MAX_WRITE_ATTEMPTS","projectForCollection","mustBeUniqueError","rethrowUniqueViolation","isConditionalCheckFailed","putItem","create","collection","customID","data","req","returning","id","now","Date","toISOString","item","createdAt","updatedAt","projected","partition","resolvePartition","attempt","mustNotExist","unique","err"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,OAAO,EAAEC,aAAa,EAAEC,OAAO,EAAEC,kBAAkB,QAAQ,4BAA2B;AAC/F,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,iBAAiB,EAAEC,sBAAsB,QAAQ,6BAA4B;AACtF,SAASC,wBAAwB,EAAEC,OAAO,QAAQ,4BAA2B;AAE7E,OAAO,MAAMC,SAAiB,eAAeA,OAE3C,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,GAAG,EAAEC,SAAS,EAAE;IAE9C,MAAMC,KAAKJ,YAAYC,IAAI,CAAC,KAAK,IAAIb;IACrC,MAAMiB,MAAM,IAAIC,OAAOC,WAAW;IAClC,yEAAyE;IACzE,uEAAuE;IACvE,0EAA0E;IAC1E,gEAAgE;IAChE,qEAAqE;IACrE,MAAMC,OAAgC;QACpC,GAAGP,IAAI;QACPG;QACAK,WAAWR,IAAI,CAAC,YAAY,IAAII;QAChCK,WAAWT,IAAI,CAAC,YAAY,IAAII;IAClC;IACA,sEAAsE;IACtE,qEAAqE;IACrE,kEAAkE;IAClE,MAAMM,YAAYlB,qBAAqB,IAAI,EAAEM,YAAYS;IACzD,MAAMI,YAAY,IAAI,CAACC,gBAAgB,CAACd;IAExC,IAAK,IAAIe,UAAU,IAAKA,UAAW;QACjC,IAAI;YACF,oEAAoE;YACpE,iEAAiE;YACjE,wEAAwE;YACxE,wCAAwC;YACxC,MAAMjB,QAAQ,IAAI,EAAEe,WAAWD,WAAW;gBAAEI,cAAc;gBAAMC,QAAQ;oBAAEjB;gBAAW;YAAE;YACvF;QACF,EAAE,OAAOkB,KAAK;YACZtB,uBAAuBsB,KAAKlB,YAAYG;YACxC,IAAI,CAACN,yBAAyBqB,MAAM,MAAMA;YAE1C,uEAAuE;YACvE,wEAAwE;YACxE,oEAAoE;YACpE,sEAAsE;YACtE,oBAAoB;YACpB,IAAI,MAAM1B,QAAQ,IAAI,EAAEqB,WAAWR,KAAK,MAAMV,kBAAkB,MAAMK,YAAYG;YAClF,IAAIY,WAAWtB,oBAAoB,MAAMF;YACzC,MAAMD,QAAQyB;QAChB;IACF;IAEA,OAAOX,cAAc,QAAS,OAAiBQ;AACjD,EAAC"}

package/dist/createGlobal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createGlobal.d.ts","sourceRoot":"","sources":["../src/createGlobal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,YAwB1B,CAAA"}
+{"version":3,"file":"createGlobal.d.ts","sourceRoot":"","sources":["../src/createGlobal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAO3C;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}

package/dist/createGlobal.js

@@ -1,28 +1,16 @@
-import { PutCommand } from '@aws-sdk/lib-dynamodb';
-import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
 import { projectForGlobal } from './utilities/resolveSchema.js';
+import { putItem } from './utilities/writeItems.js';
 /**
  * Insert a global's singleton row. The slug is forced as the row's `id` —
  * this is what makes `findGlobal`/`updateGlobal` deterministic single-key
  * reads (`pk = slug`, `sk = slug`).
  */ export const createGlobal = async function createGlobal({ slug, data, returning }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
     const item = {
         ...data,
         id: slug
     };
     const projected = projectForGlobal(this, slug, item);
-    await docClient.send(new PutCommand({
-        TableName: this.tableName,
-        Item: normalizeForDynamo({
-            ...projected,
-            pk: this.resolvePartition(slug),
-            sk: slug
-        })
-    }));
+    await putItem(this, this.resolvePartition(slug), projected);
     return returning === false ? null : projected;
 };
 

package/dist/createGlobal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/createGlobal.ts"],"sourcesContent":["import type { CreateGlobal } from 'payload'\n\nimport { PutCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectForGlobal } from './utilities/resolveSchema.js'\n\n/**\n * Insert a global's singleton row. The slug is forced as the row's `id` —\n * this is what makes `findGlobal`/`updateGlobal` deterministic single-key\n * reads (`pk = slug`, `sk = slug`).\n */\nexport const createGlobal: CreateGlobal = async function createGlobal(\n  this: DynamoAdapter,\n  { slug, data, returning },\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 item: Record<string, unknown> = { ...data, id: slug }\n  const projected = projectForGlobal(this, slug, item)\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: this.resolvePartition(slug),\n        sk: slug,\n      }),\n    }),\n  )\n\n  return returning === false ? (null as never) : (projected as never)\n}\n"],"names":["PutCommand","normalizeForDynamo","projectForGlobal","createGlobal","slug","data","returning","docClient","Error","item","id","projected","send","TableName","tableName","Item","pk","resolvePartition","sk"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAIlD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,gBAAgB,QAAQ,+BAA8B;AAE/D;;;;CAIC,GACD,OAAO,MAAMC,eAA6B,eAAeA,aAEvD,EAAEC,IAAI,EAAEC,IAAI,EAAEC,SAAS,EAAE;IAEzB,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,OAAgC;QAAE,GAAGJ,IAAI;QAAEK,IAAIN;IAAK;IAC1D,MAAMO,YAAYT,iBAAiB,IAAI,EAAEE,MAAMK;IAE/C,MAAMF,UAAUK,IAAI,CAClB,IAAIZ,WAAW;QACba,WAAW,IAAI,CAACC,SAAS;QACzBC,MAAMd,mBAAmB;YACvB,GAAGU,SAAS;YACZK,IAAI,IAAI,CAACC,gBAAgB,CAACb;YAC1Bc,IAAId;QACN;IACF;IAGF,OAAOE,cAAc,QAAS,OAAkBK;AAClD,EAAC"}
+{"version":3,"sources":["../src/createGlobal.ts"],"sourcesContent":["import type { CreateGlobal } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { projectForGlobal } from './utilities/resolveSchema.js'\nimport { putItem } from './utilities/writeItems.js'\n\n/**\n * Insert a global's singleton row. The slug is forced as the row's `id` —\n * this is what makes `findGlobal`/`updateGlobal` deterministic single-key\n * reads (`pk = slug`, `sk = slug`).\n */\nexport const createGlobal: CreateGlobal = async function createGlobal(\n  this: DynamoAdapter,\n  { slug, data, returning },\n) {\n  const item: Record<string, unknown> = { ...data, id: slug }\n  const projected = projectForGlobal(this, slug, item)\n\n  await putItem(this, this.resolvePartition(slug), projected)\n\n  return returning === false ? (null as never) : (projected as never)\n}\n"],"names":["projectForGlobal","putItem","createGlobal","slug","data","returning","item","id","projected","resolvePartition"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,+BAA8B;AAC/D,SAASC,OAAO,QAAQ,4BAA2B;AAEnD;;;;CAIC,GACD,OAAO,MAAMC,eAA6B,eAAeA,aAEvD,EAAEC,IAAI,EAAEC,IAAI,EAAEC,SAAS,EAAE;IAEzB,MAAMC,OAAgC;QAAE,GAAGF,IAAI;QAAEG,IAAIJ;IAAK;IAC1D,MAAMK,YAAYR,iBAAiB,IAAI,EAAEG,MAAMG;IAE/C,MAAML,QAAQ,IAAI,EAAE,IAAI,CAACQ,gBAAgB,CAACN,OAAOK;IAEjD,OAAOH,cAAc,QAAS,OAAkBG;AAClD,EAAC"}

package/dist/createGlobalVersion.d.ts

@@ -2,7 +2,7 @@ import type { CreateGlobalVersion } from 'payload';
 /**
  * Like `createVersion` but for global singletons: there's no `parent`, and
  * the "latest" scope is the entire global's versions partition. Same atomic
- * flip+put via `TransactWriteItems`. See `createVersion` for rationale.
+ * flip+put via `putVersionAsLatest`. See `createVersion` for rationale.
  */
 export declare const createGlobalVersion: CreateGlobalVersion;
 //# sourceMappingURL=createGlobalVersion.d.ts.map

package/dist/createGlobalVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createGlobalVersion.d.ts","sourceRoot":"","sources":["../src/createGlobalVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAWlD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBA2EjC,CAAA"}
+{"version":3,"file":"createGlobalVersion.d.ts","sourceRoot":"","sources":["../src/createGlobalVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAUlD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAwCjC,CAAA"}

package/dist/createGlobalVersion.js

@@ -1,17 +1,12 @@
-import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
 import { randomUUID } from 'node:crypto';
 import { findFirst } from './utilities/findFirst.js';
-import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
 import { projectVersionSnapshot } from './utilities/resolveSchema.js';
+import { putVersionAsLatest } from './utilities/writeItems.js';
 /**
  * Like `createVersion` but for global singletons: there's no `parent`, and
  * the "latest" scope is the entire global's versions partition. Same atomic
- * flip+put via `TransactWriteItems`. See `createVersion` for rationale.
+ * flip+put via `putVersionAsLatest`. See `createVersion` for rationale.
  */ export const createGlobalVersion = async function createGlobalVersion({ autosave, createdAt, globalSlug, publishedLocale, returning, snapshot, updatedAt, versionData }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
     const partition = this.resolveVersionsPartition(globalSlug);
     const previousLatest = await findFirst(this, {
         partition,
@@ -40,40 +35,7 @@ import { projectVersionSnapshot } from './utilities/resolveSchema.js';
             publishedLocale
         } : {}
     };
-    const putItem = normalizeForDynamo({
-        ...item,
-        pk: partition,
-        sk: id
-    });
-    const transactItems = [];
-    if (previousLatest) {
-        transactItems.push({
-            Update: {
-                TableName: this.tableName,
-                Key: {
-                    pk: partition,
-                    sk: String(previousLatest['id'])
-                },
-                UpdateExpression: 'SET #latest = :false',
-                ExpressionAttributeNames: {
-                    '#latest': 'latest'
-                },
-                ExpressionAttributeValues: {
-                    ':false': false
-                },
-                ConditionExpression: 'attribute_exists(pk)'
-            }
-        });
-    }
-    transactItems.push({
-        Put: {
-            TableName: this.tableName,
-            Item: putItem
-        }
-    });
-    await docClient.send(new TransactWriteCommand({
-        TransactItems: transactItems
-    }));
+    await putVersionAsLatest(this, partition, item, previousLatest);
     return returning === false ? null : item;
 };
 

package/dist/createGlobalVersion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/createGlobalVersion.ts"],"sourcesContent":["import type { CreateGlobalVersion } from 'payload'\n\nimport { TransactWriteCommand } 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 { projectVersionSnapshot } from './utilities/resolveSchema.js'\n\n/**\n * Like `createVersion` but for global singletons: there's no `parent`, and\n * the \"latest\" scope is the entire global's versions partition. Same atomic\n * flip+put via `TransactWriteItems`. See `createVersion` for rationale.\n */\nexport const createGlobalVersion: CreateGlobalVersion = async function createGlobalVersion(\n  this: DynamoAdapter,\n  {\n    autosave,\n    createdAt,\n    globalSlug,\n    publishedLocale,\n    returning,\n    snapshot,\n    updatedAt,\n    versionData,\n  },\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(globalSlug)\n\n  const previousLatest = await findFirst(this, {\n    partition,\n    where: { latest: { equals: true } },\n  })\n\n  const id = randomUUID()\n  const sanitizedVersionData = projectVersionSnapshot(\n    this,\n    { kind: 'global', slug: globalSlug },\n    versionData as Record<string, unknown>,\n  )\n  const item: Record<string, unknown> = {\n    id,\n    version: sanitizedVersionData,\n    createdAt,\n    updatedAt,\n    latest: true,\n    autosave,\n    ...(snapshot ? { snapshot: true } : {}),\n    ...(publishedLocale !== undefined ? { publishedLocale } : {}),\n  }\n\n  const putItem = normalizeForDynamo({\n    ...item,\n    pk: partition,\n    sk: id,\n  })\n\n  const transactItems: NonNullable<\n    ConstructorParameters<typeof TransactWriteCommand>[0]['TransactItems']\n  > = []\n\n  if (previousLatest) {\n    transactItems.push({\n      Update: {\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(previousLatest['id']) },\n        UpdateExpression: 'SET #latest = :false',\n        ExpressionAttributeNames: { '#latest': 'latest' },\n        ExpressionAttributeValues: { ':false': false },\n        ConditionExpression: 'attribute_exists(pk)',\n      },\n    })\n  }\n\n  transactItems.push({\n    Put: {\n      TableName: this.tableName,\n      Item: putItem,\n    },\n  })\n\n  await docClient.send(new TransactWriteCommand({ TransactItems: transactItems }))\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["TransactWriteCommand","randomUUID","findFirst","normalizeForDynamo","projectVersionSnapshot","createGlobalVersion","autosave","createdAt","globalSlug","publishedLocale","returning","snapshot","updatedAt","versionData","docClient","Error","partition","resolveVersionsPartition","previousLatest","where","latest","equals","id","sanitizedVersionData","kind","slug","item","version","undefined","putItem","pk","sk","transactItems","push","Update","TableName","tableName","Key","String","UpdateExpression","ExpressionAttributeNames","ExpressionAttributeValues","ConditionExpression","Put","Item","send","TransactItems"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,wBAAuB;AAC5D,SAASC,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,sBAAsB,QAAQ,+BAA8B;AAErE;;;;CAIC,GACD,OAAO,MAAMC,sBAA2C,eAAeA,oBAErE,EACEC,QAAQ,EACRC,SAAS,EACTC,UAAU,EACVC,eAAe,EACfC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACZ;IAED,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACT;IAEhD,MAAMU,iBAAiB,MAAMhB,UAAU,IAAI,EAAE;QAC3Cc;QACAG,OAAO;YAAEC,QAAQ;gBAAEC,QAAQ;YAAK;QAAE;IACpC;IAEA,MAAMC,KAAKrB;IACX,MAAMsB,uBAAuBnB,uBAC3B,IAAI,EACJ;QAAEoB,MAAM;QAAUC,MAAMjB;IAAW,GACnCK;IAEF,MAAMa,OAAgC;QACpCJ;QACAK,SAASJ;QACThB;QACAK;QACAQ,QAAQ;QACRd;QACA,GAAIK,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBmB,YAAY;YAAEnB;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,MAAMoB,UAAU1B,mBAAmB;QACjC,GAAGuB,IAAI;QACPI,IAAId;QACJe,IAAIT;IACN;IAEA,MAAMU,gBAEF,EAAE;IAEN,IAAId,gBAAgB;QAClBc,cAAcC,IAAI,CAAC;YACjBC,QAAQ;gBACNC,WAAW,IAAI,CAACC,SAAS;gBACzBC,KAAK;oBAAEP,IAAId;oBAAWe,IAAIO,OAAOpB,cAAc,CAAC,KAAK;gBAAE;gBACvDqB,kBAAkB;gBAClBC,0BAA0B;oBAAE,WAAW;gBAAS;gBAChDC,2BAA2B;oBAAE,UAAU;gBAAM;gBAC7CC,qBAAqB;YACvB;QACF;IACF;IAEAV,cAAcC,IAAI,CAAC;QACjBU,KAAK;YACHR,WAAW,IAAI,CAACC,SAAS;YACzBQ,MAAMf;QACR;IACF;IAEA,MAAMf,UAAU+B,IAAI,CAAC,IAAI7C,qBAAqB;QAAE8C,eAAed;IAAc;IAE7E,OAAOtB,cAAc,QAAS,OAAkBgB;AAClD,EAAC"}
+{"version":3,"sources":["../src/createGlobalVersion.ts"],"sourcesContent":["import type { CreateGlobalVersion } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { projectVersionSnapshot } from './utilities/resolveSchema.js'\nimport { putVersionAsLatest } from './utilities/writeItems.js'\n\n/**\n * Like `createVersion` but for global singletons: there's no `parent`, and\n * the \"latest\" scope is the entire global's versions partition. Same atomic\n * flip+put via `putVersionAsLatest`. See `createVersion` for rationale.\n */\nexport const createGlobalVersion: CreateGlobalVersion = async function createGlobalVersion(\n  this: DynamoAdapter,\n  {\n    autosave,\n    createdAt,\n    globalSlug,\n    publishedLocale,\n    returning,\n    snapshot,\n    updatedAt,\n    versionData,\n  },\n) {\n  const partition = this.resolveVersionsPartition(globalSlug)\n\n  const previousLatest = await findFirst(this, {\n    partition,\n    where: { latest: { equals: true } },\n  })\n\n  const id = randomUUID()\n  const sanitizedVersionData = projectVersionSnapshot(\n    this,\n    { kind: 'global', slug: globalSlug },\n    versionData as Record<string, unknown>,\n  )\n  const item: Record<string, unknown> = {\n    id,\n    version: sanitizedVersionData,\n    createdAt,\n    updatedAt,\n    latest: true,\n    autosave,\n    ...(snapshot ? { snapshot: true } : {}),\n    ...(publishedLocale !== undefined ? { publishedLocale } : {}),\n  }\n\n  await putVersionAsLatest(this, partition, item, previousLatest)\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["randomUUID","findFirst","projectVersionSnapshot","putVersionAsLatest","createGlobalVersion","autosave","createdAt","globalSlug","publishedLocale","returning","snapshot","updatedAt","versionData","partition","resolveVersionsPartition","previousLatest","where","latest","equals","id","sanitizedVersionData","kind","slug","item","version","undefined"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,+BAA8B;AACrE,SAASC,kBAAkB,QAAQ,4BAA2B;AAE9D;;;;CAIC,GACD,OAAO,MAAMC,sBAA2C,eAAeA,oBAErE,EACEC,QAAQ,EACRC,SAAS,EACTC,UAAU,EACVC,eAAe,EACfC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACZ;IAED,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACP;IAEhD,MAAMQ,iBAAiB,MAAMd,UAAU,IAAI,EAAE;QAC3CY;QACAG,OAAO;YAAEC,QAAQ;gBAAEC,QAAQ;YAAK;QAAE;IACpC;IAEA,MAAMC,KAAKnB;IACX,MAAMoB,uBAAuBlB,uBAC3B,IAAI,EACJ;QAAEmB,MAAM;QAAUC,MAAMf;IAAW,GACnCK;IAEF,MAAMW,OAAgC;QACpCJ;QACAK,SAASJ;QACTd;QACAK;QACAM,QAAQ;QACRZ;QACA,GAAIK,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBiB,YAAY;YAAEjB;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,MAAML,mBAAmB,IAAI,EAAEU,WAAWU,MAAMR;IAEhD,OAAON,cAAc,QAAS,OAAkBc;AAClD,EAAC"}

package/dist/createVersion.d.ts

@@ -5,11 +5,12 @@ import type { CreateVersion } from 'payload';
  *
  * Two round trips:
  *  1. `Query` the versions partition for the previous `latest=true` row.
- *  2. `TransactWriteItems` to flip that row's `latest` to false and put the
- *     new row in one atomic call. If a crash occurs mid-flow neither
- *     mutation lands, so we never end up with two `latest=true` rows or
- *     zero. The Update carries `attribute_exists(pk)` so the transaction
- *     fails cleanly if the previous row was deleted between (1) and (2).
+ *  2. `putVersionAsLatest` flips that row's `latest` to false and puts the
+ *     new row in one atomic `TransactWriteItems` call. If a crash occurs
+ *     mid-flow neither mutation lands, so we never end up with two
+ *     `latest=true` rows or zero. The flip carries `attribute_exists(pk)` so
+ *     the transaction fails cleanly if the previous row was deleted between
+ *     (1) and (2).
  *
  * `autosave` is persisted on the row even though it isn't surfaced in
  * `TypeWithVersion` — `findVersions` filters by it.

package/dist/createVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createVersion.d.ts","sourceRoot":"","sources":["../src/createVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAW5C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,EAAE,aAmF3B,CAAA"}
+{"version":3,"file":"createVersion.d.ts","sourceRoot":"","sources":["../src/createVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAU5C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,aA6C3B,CAAA"}