@open-aih/payload-ddb 4.1.0 → 4.2.0-beta.20261113195548

package/README.md

@@ -6,9 +6,11 @@ stores data in [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
 > **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*.
+> later" — a single shared table where lookups by id, unique field or indexed
+> field go straight to the matching rows, and every other filter reads the
+> collection's partition. Suitable for development and small-to-medium
+> workloads; large collections will want the optimizations listed under
+> *Known limits*.
 
 ## Requirements
 
@@ -89,6 +91,7 @@ value in the same physical table.
 | `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. |
+| `indexes` | `boolean` | `true` | Maintain index rows for `index: true` fields and answer lookups by an indexed or unique field from them instead of reading the collection. See *Indexes*. |
 
 ## Data layout
 
@@ -107,9 +110,19 @@ value in the same physical table.
   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).
+- **Index rows:** `pk = "<slug>#index#<field path>"`,
+  `sk = "<value key>#<id>"`, one small row per value of an `index: true`
+  field. Value keys sort the way the values do. See *Indexes*.
+- **Latest-version pointers:** `pk = "<slug>_versions#latest"`,
+  `sk = "<parent key>"`, one row per versioned document naming its latest
+  version.
+- **Index markers:** `pk = "payload-ddb#indexes"`, one row per index that is
+  known to cover every document.
+- **No GSIs or LSIs.** Indexes are ordinary rows in the same table, which is
+  what lets them be read with strong consistency. A filter no index can
+  answer is a `Query` scoped by `pk`, with its predicates pushed to
+  `FilterExpression` (DynamoDB still reads every row in the partition before
+  filtering).
 
 ## What's implemented
 
@@ -153,13 +166,92 @@ Every Payload `where` operator is supported: `equals`, `not_equals`,
 - **Geo operators** work on `point` fields. Distances are great-circle
   metres; polygon tests are planar.
 
+### Indexes
+
+A filter normally reads the collection's whole partition. These clauses avoid
+that and read only the matching documents:
+
+| Clause | Answered from |
+|---|---|
+| `id` `equals` / `in` | the documents' own keys |
+| `equals` / `in` on a `unique: true` field | the field's unique guards |
+| `equals` / `in` on an `index: true` field | index rows |
+| `greater_than(_equal)` / `less_than(_equal)` on an `index: true` field | index rows, which are kept in value order |
+
+The clause has to hold for every result: at the top level or inside `and`.
+An `or` qualifies as a whole when every one of its branches has such a
+clause — the branches are looked up separately and combined — but not when
+one branch would need the partition anyway. The rest of the `where` is then
+evaluated on the documents selected. This covers login by `email`, pages by
+`slug`, relationship population (`id in [...]`), filters on a relationship,
+join fields, date or number ranges, and Payload's lookup of an upload by any
+of its filenames.
+
+- **Which fields.** `index: true` on a `text`, `email`, `number`, `date`,
+  `relationship` or `upload` field — including `hasMany` fields (one row per
+  element), fields in groups and named tabs, and localized fields (per
+  locale). Payload sets the flag itself on the field a join points at.
+  Not indexed: fields in arrays or blocks, polymorphic relationships, types
+  where equality rarely narrows a read (`checkbox`, `select`), and the
+  timestamps Payload manages (`createdAt`, `updatedAt`, `deletedAt`), where
+  an index would turn every insert or update into a transaction.
+- **Sorted pages.** A `find` sorted by one single-valued indexed field walks
+  that field's index in order and stops when the page is full, instead of
+  reading and sorting the collection. With `pagination: false` nothing else
+  is read. With pagination, the total comes from a `COUNT` pass over the
+  partition, which returns no documents but is still billed for the read.
+  Not used on drafts-enabled collections, for sorts on several fields, or
+  for pages more than 2,000 documents deep.
+- **Consistency.** Index rows are written in the same transaction as their
+  document and read with strong consistency, so a lookup sees a document as
+  soon as it is written — which a DynamoDB GSI can't promise.
+- **Write cost.** A write that adds or removes index rows is a transaction:
+  twice the write units for the document, plus the rows. An update that
+  leaves the indexed fields alone costs what it did before. A single-valued
+  indexed field has a row for every document, blank ones included, so
+  inserts into a collection with one are always transactions.
+- **Large matches.** A lookup that finds more than 256 candidate documents
+  falls back to reading the partition, which is the cheaper read by then.
+- **Opting out.** `indexes: false` stops the index rows, the pointers and
+  the routed lookups. Lookups by `id` and unique enforcement are unaffected.
+  Every instance sharing a table must use the same setting.
+
+**Versions.** Version rows are indexed by their `parent`, so listing or
+pruning one document's versions reads only those. Each versioned document
+(and each versioned global) also has a pointer to its latest version: saving
+finds the version to demote in two key reads, and listing drafts fetches one
+version per document rather than every version of every document.
+
+**Existing data.** An index is only used once it is known to cover every
+row. A partition that is empty when the adapter starts qualifies straight
+away, which covers new tables and new collections. For one that already has
+rows — after upgrading, or after adding `index: true` to a field — run the
+backfill once; until then its lookups keep reading the partition:
+
+```ts
+import { backfillIndexes } from '@aih-software/payload-ddb'
+
+const report = await backfillIndexes(payload)
+// report.collections[slug].ready lists the indexes now in use
+// report.versions[slug] covers that collection's or global's versions
+```
+
+The backfill is safe to run while the application is serving, and safe to
+re-run. It also removes stray index rows, which an interrupted write can
+leave behind (lookups ignore them, so they cost a little space, not
+correctness). When upgrading from a version before 4.2, finish the rollout
+first: older instances write rows without their index rows, so run the
+backfill once after the last one is gone.
+
 ### 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.
+`join` fields are resolved for `find`, `findByID` and draft queries: one
+lookup per target collection for all returned documents, grouped in memory,
+with `limit`, `page`, `sort`, `where` and `count` applied per parent document.
+The lookup uses the index on the field the join points at, so it doesn't read
+the target collection's partition. Polymorphic joins (`collection: [...]`)
+return `{ relationTo, value }` entries. Joined documents are read from the
+target's published rows.
 
 ### Write guarantees
 
@@ -171,6 +263,10 @@ Joined documents are read from the target's published rows.
   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.
+- **One latest version.** Creating a version demotes the previous latest and
+  moves the document's pointer in one transaction that checks nobody else got
+  there first, so saving a document several times at once still leaves
+  exactly one version marked latest.
 - **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`
@@ -190,34 +286,42 @@ 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.
+write units.
 
 Documents written before this was enforced have no guards until they are next
-saved. To cover them in one pass:
+saved. `backfillIndexes` (see *Indexes*) covers them in the same pass:
 
 ```ts
-import { backfillUniqueGuards } from '@aih-software/payload-ddb'
-
-const report = await backfillUniqueGuards(payload)
+const report = await backfillIndexes(payload)
 // report.collections[slug].conflicts lists pre-existing duplicates
 ```
 
+A unique field with unresolved duplicates stays out of use for lookups until
+they are fixed and the pass is run again. `backfillUniqueGuards` is kept as an
+alias.
+
 ## Known limits / future work
 
-- **No GSI routing.** Every non-id read is a `Query` against the collection's
-  partition (with `FilterExpression` pushdown — DynamoDB still reads every
-  row in the partition internally, but only matching rows come back over the
-  wire). Adding GSIs that mirror Payload's common access patterns
-  (e.g. `email` for auth, `slug` for public-facing collections) is the
-  highest-impact remaining optimization milestone.
+- **Unindexed filters and sorts read the partition.** That includes the
+  default sort on `createdAt`, sorts on several fields, and any filter with
+  no indexed clause. The matches are sorted and paged in memory.
+- **Totals are counted.** A paginated `find` that reads its page through an
+  index still counts the matches with a pass over the partition.
+- **Drafts are listed in full.** A drafts listing fetches the latest version
+  of every document — one read each, not the whole versions partition — and
+  then filters, sorts and pages in memory. `find` on a drafts-enabled
+  collection does the same for documents it hasn't already matched.
+- **A document's versions are read together.** Payload looks up a document's
+  (or global's) newest version by sort before each save, which reads all of
+  that document's versions — bounded by `versions.maxPerDoc`.
 - **Payload-level transactions are no-op.** `beginTransaction` returns `null`;
   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.
+- **Relationship paths read the related collection.** `author.name equals
+  'Ada'` first finds the matching authors — a partition read unless `name` is
+  indexed — and then looks the documents up through the index on `author`,
+  when it has one.
 - **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
@@ -264,6 +368,12 @@ The public publish uses npm
 no npm token to rotate. The trusted publisher configured on npmjs.com must
 name this repository and the workflow file `release.yml`.
 
+**Prereleases.** To try a change in a real project before releasing it, push
+the commit to the `beta` branch (`git push origin HEAD:beta --force`). The
+same workflow publishes it to both registries as `X.Y.Z-beta.<timestamp>`
+under the `beta` dist-tag — install it with `@open-aih/payload-ddb@beta` —
+and commits, tags and merges nothing. `latest` is untouched.
+
 ## License
 
 MIT

package/dist/create.js

@@ -26,13 +26,11 @@ export const create = async function create({ collection, customID, data, req, r
         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.
+            // existing doc would silently destroy it. `collection` adds the
+            // document's unique guards and index rows to the same transaction.
             await putItem(this, partition, projected, {
-                mustNotExist: true,
-                unique: {
-                    collection
-                }
+                collection,
+                mustNotExist: true
             });
             break;
         } catch (err) {

package/dist/create.js.map

@@ -1 +1 @@
-{"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"}
+{"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. `collection` adds the\n      // document's unique guards and index rows to the same transaction.\n      await putItem(this, partition, projected, { collection, mustNotExist: true })\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","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,gEAAgE;YAChE,mEAAmE;YACnE,MAAMjB,QAAQ,IAAI,EAAEe,WAAWD,WAAW;gBAAEZ;gBAAYgB,cAAc;YAAK;YAC3E;QACF,EAAE,OAAOC,KAAK;YACZrB,uBAAuBqB,KAAKjB,YAAYG;YACxC,IAAI,CAACN,yBAAyBoB,MAAM,MAAMA;YAE1C,uEAAuE;YACvE,wEAAwE;YACxE,oEAAoE;YACpE,sEAAsE;YACtE,oBAAoB;YACpB,IAAI,MAAMzB,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/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;AAUlD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAwCjC,CAAA"}
+{"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,mBA8CjC,CAAA"}

package/dist/createGlobalVersion.js

@@ -1,21 +1,14 @@
 import { randomUUID } from 'node:crypto';
-import { findFirst } from './utilities/findFirst.js';
+import { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js';
 import { projectVersionSnapshot } from './utilities/resolveSchema.js';
-import { putVersionAsLatest } from './utilities/writeItems.js';
+import { findLatestVersion } from './utilities/versionIndex.js';
+import { isConditionalCheckFailed, 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 `putVersionAsLatest`. See `createVersion` for rationale.
  */ export const createGlobalVersion = async function createGlobalVersion({ autosave, createdAt, globalSlug, publishedLocale, returning, snapshot, updatedAt, versionData }) {
     const partition = this.resolveVersionsPartition(globalSlug);
-    const previousLatest = await findFirst(this, {
-        partition,
-        where: {
-            latest: {
-                equals: true
-            }
-        }
-    });
     const id = randomUUID();
     const sanitizedVersionData = projectVersionSnapshot(this, {
         kind: 'global',
@@ -35,7 +28,18 @@ import { putVersionAsLatest } from './utilities/writeItems.js';
             publishedLocale
         } : {}
     };
-    await putVersionAsLatest(this, partition, item, previousLatest);
+    for(let attempt = 1;; attempt++){
+        // A global has one stream of versions, so one pointer and no parent.
+        const { pointer, previous } = await findLatestVersion(this, partition, undefined);
+        try {
+            await putVersionAsLatest(this, partition, item, previous, pointer);
+            break;
+        } catch (err) {
+            if (!isConditionalCheckFailed(err)) throw err;
+            if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError();
+            await backoff(attempt);
+        }
+    }
     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 { 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"}
+{"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 { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js'\nimport { projectVersionSnapshot } from './utilities/resolveSchema.js'\nimport { findLatestVersion } from './utilities/versionIndex.js'\nimport { isConditionalCheckFailed, 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 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  for (let attempt = 1; ; attempt++) {\n    // A global has one stream of versions, so one pointer and no parent.\n    const { pointer, previous } = await findLatestVersion(this, partition, undefined)\n    try {\n      await putVersionAsLatest(this, partition, item, previous, pointer)\n      break\n    } catch (err) {\n      if (!isConditionalCheckFailed(err)) throw err\n      if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError()\n      await backoff(attempt)\n    }\n  }\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["randomUUID","backoff","conflictError","MAX_WRITE_ATTEMPTS","projectVersionSnapshot","findLatestVersion","isConditionalCheckFailed","putVersionAsLatest","createGlobalVersion","autosave","createdAt","globalSlug","publishedLocale","returning","snapshot","updatedAt","versionData","partition","resolveVersionsPartition","id","sanitizedVersionData","kind","slug","item","version","latest","undefined","attempt","pointer","previous","err"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,OAAO,EAAEC,aAAa,EAAEC,kBAAkB,QAAQ,4BAA2B;AACtF,SAASC,sBAAsB,QAAQ,+BAA8B;AACrE,SAASC,iBAAiB,QAAQ,8BAA6B;AAC/D,SAASC,wBAAwB,EAAEC,kBAAkB,QAAQ,4BAA2B;AAExF;;;;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,KAAKnB;IACX,MAAMoB,uBAAuBhB,uBAC3B,IAAI,EACJ;QAAEiB,MAAM;QAAUC,MAAMX;IAAW,GACnCK;IAEF,MAAMO,OAAgC;QACpCJ;QACAK,SAASJ;QACTV;QACAK;QACAU,QAAQ;QACRhB;QACA,GAAIK,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBc,YAAY;YAAEd;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,IAAK,IAAIe,UAAU,IAAKA,UAAW;QACjC,qEAAqE;QACrE,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAG,MAAMxB,kBAAkB,IAAI,EAAEY,WAAWS;QACvE,IAAI;YACF,MAAMnB,mBAAmB,IAAI,EAAEU,WAAWM,MAAMM,UAAUD;YAC1D;QACF,EAAE,OAAOE,KAAK;YACZ,IAAI,CAACxB,yBAAyBwB,MAAM,MAAMA;YAC1C,IAAIH,WAAWxB,oBAAoB,MAAMD;YACzC,MAAMD,QAAQ0B;QAChB;IACF;IAEA,OAAOd,cAAc,QAAS,OAAkBU;AAClD,EAAC"}

package/dist/createVersion.d.ts

@@ -3,14 +3,17 @@ import type { CreateVersion } from 'payload';
  * Insert a new version for a collection's parent doc, maintaining the
  * `latest=true` invariant per parent.
  *
- * Two round trips:
- *  1. `Query` the versions partition for the previous `latest=true` row.
- *  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).
+ * Two steps:
+ *  1. Find the previous `latest=true` row — through the parent's pointer
+ *     (two key reads), or by reading the versions partition while pointers
+ *     aren't complete yet (`findLatestVersion`).
+ *  2. `putVersionAsLatest` flips that row's `latest` to false, puts the new
+ *     row and moves the pointer in one atomic `TransactWriteItems` call. If
+ *     a crash occurs mid-flow none of it lands, so we never end up with two
+ *     `latest=true` rows or zero.
+ *
+ * If another save of the same document got in between the two steps, the
+ * transaction's conditions fail and both steps are repeated.
  *
  * `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;AAU5C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,aA6C3B,CAAA"}
+{"version":3,"file":"createVersion.d.ts","sourceRoot":"","sources":["../src/createVersion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAW5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,EAAE,aAkD3B,CAAA"}

package/dist/createVersion.js

@@ -1,41 +1,28 @@
 import { randomUUID } from 'node:crypto';
-import { findFirst } from './utilities/findFirst.js';
+import { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js';
 import { projectVersionSnapshot } from './utilities/resolveSchema.js';
-import { putVersionAsLatest } from './utilities/writeItems.js';
+import { findLatestVersion } from './utilities/versionIndex.js';
+import { isConditionalCheckFailed, putVersionAsLatest } from './utilities/writeItems.js';
 /**
  * Insert a new version for a collection's parent doc, maintaining the
  * `latest=true` invariant per parent.
  *
- * Two round trips:
- *  1. `Query` the versions partition for the previous `latest=true` row.
- *  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).
+ * Two steps:
+ *  1. Find the previous `latest=true` row — through the parent's pointer
+ *     (two key reads), or by reading the versions partition while pointers
+ *     aren't complete yet (`findLatestVersion`).
+ *  2. `putVersionAsLatest` flips that row's `latest` to false, puts the new
+ *     row and moves the pointer in one atomic `TransactWriteItems` call. If
+ *     a crash occurs mid-flow none of it lands, so we never end up with two
+ *     `latest=true` rows or zero.
+ *
+ * If another save of the same document got in between the two steps, the
+ * transaction's conditions fail and both steps are repeated.
  *
  * `autosave` is persisted on the row even though it isn't surfaced in
  * `TypeWithVersion` — `findVersions` filters by it.
  */ export const createVersion = async function createVersion({ autosave, collectionSlug, createdAt, parent, publishedLocale, returning, snapshot, updatedAt, versionData }) {
     const partition = this.resolveVersionsPartition(collectionSlug);
-    const previousLatest = await findFirst(this, {
-        partition,
-        where: {
-            and: [
-                {
-                    parent: {
-                        equals: parent
-                    }
-                },
-                {
-                    latest: {
-                        equals: true
-                    }
-                }
-            ]
-        }
-    });
     const id = randomUUID();
     // Project the snapshot against the parent collection's schema so that any
     // unknown keys (e.g. registration-form `confirm-password`) don't ride into
@@ -59,7 +46,17 @@ import { putVersionAsLatest } from './utilities/writeItems.js';
             publishedLocale
         } : {}
     };
-    await putVersionAsLatest(this, partition, item, previousLatest);
+    for(let attempt = 1;; attempt++){
+        const { pointer, previous } = await findLatestVersion(this, partition, parent);
+        try {
+            await putVersionAsLatest(this, partition, item, previous, pointer);
+            break;
+        } catch (err) {
+            if (!isConditionalCheckFailed(err)) throw err;
+            if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError();
+            await backoff(attempt);
+        }
+    }
     return returning === false ? null : item;
 };
 

package/dist/createVersion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/createVersion.ts"],"sourcesContent":["import type { CreateVersion } 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 * Insert a new version for a collection's parent doc, maintaining the\n * `latest=true` invariant per parent.\n *\n * Two round trips:\n *  1. `Query` the versions partition for the previous `latest=true` row.\n *  2. `putVersionAsLatest` flips that row's `latest` to false and puts the\n *     new row in one atomic `TransactWriteItems` call. If a crash occurs\n *     mid-flow neither mutation lands, so we never end up with two\n *     `latest=true` rows or zero. The flip carries `attribute_exists(pk)` so\n *     the transaction fails cleanly if the previous row was deleted between\n *     (1) and (2).\n *\n * `autosave` is persisted on the row even though it isn't surfaced in\n * `TypeWithVersion` — `findVersions` filters by it.\n */\nexport const createVersion: CreateVersion = async function createVersion(\n  this: DynamoAdapter,\n  {\n    autosave,\n    collectionSlug,\n    createdAt,\n    parent,\n    publishedLocale,\n    returning,\n    snapshot,\n    updatedAt,\n    versionData,\n  },\n) {\n  const partition = this.resolveVersionsPartition(collectionSlug)\n\n  const previousLatest = await findFirst(this, {\n    partition,\n    where: { and: [{ parent: { equals: parent } }, { latest: { equals: true } }] },\n  })\n\n  const id = randomUUID()\n  // Project the snapshot against the parent collection's schema so that any\n  // unknown keys (e.g. registration-form `confirm-password`) don't ride into\n  // the version row alongside the legitimate doc state.\n  const sanitizedVersionData = projectVersionSnapshot(\n    this,\n    { kind: 'collection', slug: collectionSlug },\n    versionData as Record<string, unknown>,\n  )\n  const item: Record<string, unknown> = {\n    id,\n    parent,\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","createVersion","autosave","collectionSlug","createdAt","parent","publishedLocale","returning","snapshot","updatedAt","versionData","partition","resolveVersionsPartition","previousLatest","where","and","equals","latest","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;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EACEC,QAAQ,EACRC,cAAc,EACdC,SAAS,EACTC,MAAM,EACNC,eAAe,EACfC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACZ;IAED,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACT;IAEhD,MAAMU,iBAAiB,MAAMf,UAAU,IAAI,EAAE;QAC3Ca;QACAG,OAAO;YAAEC,KAAK;gBAAC;oBAAEV,QAAQ;wBAAEW,QAAQX;oBAAO;gBAAE;gBAAG;oBAAEY,QAAQ;wBAAED,QAAQ;oBAAK;gBAAE;aAAE;QAAC;IAC/E;IAEA,MAAME,KAAKrB;IACX,0EAA0E;IAC1E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAMsB,uBAAuBpB,uBAC3B,IAAI,EACJ;QAAEqB,MAAM;QAAcC,MAAMlB;IAAe,GAC3CO;IAEF,MAAMY,OAAgC;QACpCJ;QACAb;QACAkB,SAASJ;QACTf;QACAK;QACAQ,QAAQ;QACRf;QACA,GAAIM,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBkB,YAAY;YAAElB;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,MAAMN,mBAAmB,IAAI,EAAEW,WAAWW,MAAMT;IAEhD,OAAON,cAAc,QAAS,OAAkBe;AAClD,EAAC"}
+{"version":3,"sources":["../src/createVersion.ts"],"sourcesContent":["import type { CreateVersion } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { backoff, conflictError, MAX_WRITE_ATTEMPTS } from './utilities/optimistic.js'\nimport { projectVersionSnapshot } from './utilities/resolveSchema.js'\nimport { findLatestVersion } from './utilities/versionIndex.js'\nimport { isConditionalCheckFailed, putVersionAsLatest } from './utilities/writeItems.js'\n\n/**\n * Insert a new version for a collection's parent doc, maintaining the\n * `latest=true` invariant per parent.\n *\n * Two steps:\n *  1. Find the previous `latest=true` row — through the parent's pointer\n *     (two key reads), or by reading the versions partition while pointers\n *     aren't complete yet (`findLatestVersion`).\n *  2. `putVersionAsLatest` flips that row's `latest` to false, puts the new\n *     row and moves the pointer in one atomic `TransactWriteItems` call. If\n *     a crash occurs mid-flow none of it lands, so we never end up with two\n *     `latest=true` rows or zero.\n *\n * If another save of the same document got in between the two steps, the\n * transaction's conditions fail and both steps are repeated.\n *\n * `autosave` is persisted on the row even though it isn't surfaced in\n * `TypeWithVersion` — `findVersions` filters by it.\n */\nexport const createVersion: CreateVersion = async function createVersion(\n  this: DynamoAdapter,\n  {\n    autosave,\n    collectionSlug,\n    createdAt,\n    parent,\n    publishedLocale,\n    returning,\n    snapshot,\n    updatedAt,\n    versionData,\n  },\n) {\n  const partition = this.resolveVersionsPartition(collectionSlug)\n\n  const id = randomUUID()\n  // Project the snapshot against the parent collection's schema so that any\n  // unknown keys (e.g. registration-form `confirm-password`) don't ride into\n  // the version row alongside the legitimate doc state.\n  const sanitizedVersionData = projectVersionSnapshot(\n    this,\n    { kind: 'collection', slug: collectionSlug },\n    versionData as Record<string, unknown>,\n  )\n  const item: Record<string, unknown> = {\n    id,\n    parent,\n    version: sanitizedVersionData,\n    createdAt,\n    updatedAt,\n    latest: true,\n    autosave,\n    ...(snapshot ? { snapshot: true } : {}),\n    ...(publishedLocale !== undefined ? { publishedLocale } : {}),\n  }\n\n  for (let attempt = 1; ; attempt++) {\n    const { pointer, previous } = await findLatestVersion(this, partition, parent)\n    try {\n      await putVersionAsLatest(this, partition, item, previous, pointer)\n      break\n    } catch (err) {\n      if (!isConditionalCheckFailed(err)) throw err\n      if (attempt >= MAX_WRITE_ATTEMPTS) throw conflictError()\n      await backoff(attempt)\n    }\n  }\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["randomUUID","backoff","conflictError","MAX_WRITE_ATTEMPTS","projectVersionSnapshot","findLatestVersion","isConditionalCheckFailed","putVersionAsLatest","createVersion","autosave","collectionSlug","createdAt","parent","publishedLocale","returning","snapshot","updatedAt","versionData","partition","resolveVersionsPartition","id","sanitizedVersionData","kind","slug","item","version","latest","undefined","attempt","pointer","previous","err"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,OAAO,EAAEC,aAAa,EAAEC,kBAAkB,QAAQ,4BAA2B;AACtF,SAASC,sBAAsB,QAAQ,+BAA8B;AACrE,SAASC,iBAAiB,QAAQ,8BAA6B;AAC/D,SAASC,wBAAwB,EAAEC,kBAAkB,QAAQ,4BAA2B;AAExF;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EACEC,QAAQ,EACRC,cAAc,EACdC,SAAS,EACTC,MAAM,EACNC,eAAe,EACfC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACZ;IAED,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACT;IAEhD,MAAMU,KAAKpB;IACX,0EAA0E;IAC1E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAMqB,uBAAuBjB,uBAC3B,IAAI,EACJ;QAAEkB,MAAM;QAAcC,MAAMb;IAAe,GAC3CO;IAEF,MAAMO,OAAgC;QACpCJ;QACAR;QACAa,SAASJ;QACTV;QACAK;QACAU,QAAQ;QACRjB;QACA,GAAIM,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBc,YAAY;YAAEd;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,IAAK,IAAIe,UAAU,IAAKA,UAAW;QACjC,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAG,MAAMzB,kBAAkB,IAAI,EAAEa,WAAWN;QACvE,IAAI;YACF,MAAML,mBAAmB,IAAI,EAAEW,WAAWM,MAAMM,UAAUD;YAC1D;QACF,EAAE,OAAOE,KAAK;YACZ,IAAI,CAACzB,yBAAyByB,MAAM,MAAMA;YAC1C,IAAIH,WAAWzB,oBAAoB,MAAMD;YACzC,MAAMD,QAAQ2B;QAChB;IACF;IAEA,OAAOd,cAAc,QAAS,OAAkBU;AAClD,EAAC"}

package/dist/deleteMany.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteMany.d.ts","sourceRoot":"","sources":["../src/deleteMany.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AASzC;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,UAexB,CAAA"}
+{"version":3,"file":"deleteMany.d.ts","sourceRoot":"","sources":["../src/deleteMany.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AASzC;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,UAgBxB,CAAA"}

package/dist/deleteMany.js

@@ -1,6 +1,6 @@
+import { hasCompanionRows } from './utilities/fieldIndexes.js';
 import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
-import { hasUniqueFields } from './utilities/uniqueGuards.js';
 import { deleteItems } from './utilities/writeItems.js';
 /**
  * v1 strategy: query-and-collect matches, then delete each by composite key
@@ -9,8 +9,11 @@ import { deleteItems } from './utilities/writeItems.js';
     const where = await prepareCollectionWhere(this, collection, rawWhere);
     const partition = this.resolvePartition(collection);
     const matched = await queryMatching(this, partition, where);
-    await deleteItems(this, partition, matched, // Unique guards are released together with the documents that hold them.
-    hasUniqueFields(this, collection) ? collection : undefined);
+    await deleteItems(this, partition, matched, // Unique guards and index rows go together with the documents they
+    // point at.
+    hasCompanionRows(this, collection) ? {
+        collection
+    } : {});
 };
 
 //# sourceMappingURL=deleteMany.js.map

package/dist/deleteMany.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteMany.ts"],"sourcesContent":["import type { DeleteMany } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { hasUniqueFields } from './utilities/uniqueGuards.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * v1 strategy: query-and-collect matches, then delete each by composite key\n * in parallel. See `deleteItems` for why this isn't a `BatchWriteItem`.\n */\nexport const deleteMany: DeleteMany = async function deleteMany(\n  this: DynamoAdapter,\n  { collection, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const matched = await queryMatching(this, partition, where)\n\n  await deleteItems(\n    this,\n    partition,\n    matched,\n    // Unique guards are released together with the documents that hold them.\n    hasUniqueFields(this, collection) ? collection : undefined,\n  )\n}\n"],"names":["prepareCollectionWhere","queryMatching","hasUniqueFields","deleteItems","deleteMany","collection","where","rawWhere","partition","resolvePartition","matched","undefined"],"mappings":"AAIA,SAASA,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;CAGC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,OAAOC,QAAQ,EAAE;IAE/B,MAAMD,QAAQ,MAAMN,uBAAuB,IAAI,EAAEK,YAAYE;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACJ;IACxC,MAAMK,UAAU,MAAMT,cAAc,IAAI,EAAEO,WAAWF;IAErD,MAAMH,YACJ,IAAI,EACJK,WACAE,SACA,yEAAyE;IACzER,gBAAgB,IAAI,EAAEG,cAAcA,aAAaM;AAErD,EAAC"}
+{"version":3,"sources":["../src/deleteMany.ts"],"sourcesContent":["import type { DeleteMany } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { hasCompanionRows } from './utilities/fieldIndexes.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * v1 strategy: query-and-collect matches, then delete each by composite key\n * in parallel. See `deleteItems` for why this isn't a `BatchWriteItem`.\n */\nexport const deleteMany: DeleteMany = async function deleteMany(\n  this: DynamoAdapter,\n  { collection, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const matched = await queryMatching(this, partition, where)\n\n  await deleteItems(\n    this,\n    partition,\n    matched,\n    // Unique guards and index rows go together with the documents they\n    // point at.\n    hasCompanionRows(this, collection) ? { collection } : {},\n  )\n}\n"],"names":["hasCompanionRows","prepareCollectionWhere","queryMatching","deleteItems","deleteMany","collection","where","rawWhere","partition","resolvePartition","matched"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,8BAA6B;AAC9D,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;CAGC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,OAAOC,QAAQ,EAAE;IAE/B,MAAMD,QAAQ,MAAML,uBAAuB,IAAI,EAAEI,YAAYE;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACJ;IACxC,MAAMK,UAAU,MAAMR,cAAc,IAAI,EAAEM,WAAWF;IAErD,MAAMH,YACJ,IAAI,EACJK,WACAE,SACA,mEAAmE;IACnE,YAAY;IACZV,iBAAiB,IAAI,EAAEK,cAAc;QAAEA;IAAW,IAAI,CAAC;AAE3D,EAAC"}

package/dist/deleteOne.js

@@ -1,15 +1,15 @@
+import { hasCompanionRows } from './utilities/fieldIndexes.js';
 import { findFirst } from './utilities/findFirst.js';
 import { prepareCollectionWhere } from './utilities/prepareWhere.js';
-import { hasUniqueFields } from './utilities/uniqueGuards.js';
 import { whereToId } from './utilities/whereToId.js';
 import { deleteItem } from './utilities/writeItems.js';
 export const deleteOne = async function deleteOne({ collection, returning, where: rawWhere }) {
     const where = await prepareCollectionWhere(this, collection, rawWhere);
     const partition = this.resolvePartition(collection);
     const idFromWhere = whereToId(where);
-    // Releasing a document's unique guards needs its values, so those
-    // collections always read the document first.
-    const guarded = hasUniqueFields(this, collection);
+    // Removing a document's unique guards and index rows needs its values, so
+    // collections that have either always read the document first.
+    const guarded = hasCompanionRows(this, collection);
     // Fast path — pure id-equality lets us delete and capture the doc in one call.
     if (idFromWhere !== null && !guarded) {
         const deleted = await deleteItem(this, partition, idFromWhere, {
@@ -30,7 +30,7 @@ export const deleteOne = async function deleteOne({ collection, returning, where
         return null;
     }
     await deleteItem(this, partition, found['id'], guarded ? {
-        unique: {
+        companions: {
             collection,
             doc: found
         }

package/dist/deleteOne.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteOne.ts"],"sourcesContent":["import type { DeleteOne } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { hasUniqueFields } from './utilities/uniqueGuards.js'\nimport { whereToId } from './utilities/whereToId.js'\nimport { deleteItem } from './utilities/writeItems.js'\n\nexport const deleteOne: DeleteOne = async function deleteOne(\n  this: DynamoAdapter,\n  { collection, returning, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const idFromWhere = whereToId(where)\n  // Releasing a document's unique guards needs its values, so those\n  // collections always read the document first.\n  const guarded = hasUniqueFields(this, collection)\n\n  // Fast path — pure id-equality lets us delete and capture the doc in one call.\n  if (idFromWhere !== null && !guarded) {\n    const deleted = await deleteItem(this, partition, idFromWhere, { returnOld: true })\n    if (returning === false) {\n      return null as never\n    }\n    return deleted as never\n  }\n\n  // Slow path — locate (a `GetItem` when `where` is an id), then delete by\n  // composite key.\n  const found = await findFirst(this, { partition, where })\n  if (!found) {\n    return null as never\n  }\n\n  await deleteItem(\n    this,\n    partition,\n    found['id'],\n    guarded ? { unique: { collection, doc: found } } : {},\n  )\n\n  if (returning === false) {\n    return null as never\n  }\n  return found as never\n}\n"],"names":["findFirst","prepareCollectionWhere","hasUniqueFields","whereToId","deleteItem","deleteOne","collection","returning","where","rawWhere","partition","resolvePartition","idFromWhere","guarded","deleted","returnOld","found","unique","doc"],"mappings":"AAIA,SAASA,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,YAAuB,eAAeA,UAEjD,EAAEC,UAAU,EAAEC,SAAS,EAAEC,OAAOC,QAAQ,EAAE;IAE1C,MAAMD,QAAQ,MAAMP,uBAAuB,IAAI,EAAEK,YAAYG;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACL;IACxC,MAAMM,cAAcT,UAAUK;IAC9B,kEAAkE;IAClE,8CAA8C;IAC9C,MAAMK,UAAUX,gBAAgB,IAAI,EAAEI;IAEtC,+EAA+E;IAC/E,IAAIM,gBAAgB,QAAQ,CAACC,SAAS;QACpC,MAAMC,UAAU,MAAMV,WAAW,IAAI,EAAEM,WAAWE,aAAa;YAAEG,WAAW;QAAK;QACjF,IAAIR,cAAc,OAAO;YACvB,OAAO;QACT;QACA,OAAOO;IACT;IAEA,yEAAyE;IACzE,iBAAiB;IACjB,MAAME,QAAQ,MAAMhB,UAAU,IAAI,EAAE;QAAEU;QAAWF;IAAM;IACvD,IAAI,CAACQ,OAAO;QACV,OAAO;IACT;IAEA,MAAMZ,WACJ,IAAI,EACJM,WACAM,KAAK,CAAC,KAAK,EACXH,UAAU;QAAEI,QAAQ;YAAEX;YAAYY,KAAKF;QAAM;IAAE,IAAI,CAAC;IAGtD,IAAIT,cAAc,OAAO;QACvB,OAAO;IACT;IACA,OAAOS;AACT,EAAC"}
+{"version":3,"sources":["../src/deleteOne.ts"],"sourcesContent":["import type { DeleteOne } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { hasCompanionRows } from './utilities/fieldIndexes.js'\nimport { findFirst } from './utilities/findFirst.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { whereToId } from './utilities/whereToId.js'\nimport { deleteItem } from './utilities/writeItems.js'\n\nexport const deleteOne: DeleteOne = async function deleteOne(\n  this: DynamoAdapter,\n  { collection, returning, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const idFromWhere = whereToId(where)\n  // Removing a document's unique guards and index rows needs its values, so\n  // collections that have either always read the document first.\n  const guarded = hasCompanionRows(this, collection)\n\n  // Fast path — pure id-equality lets us delete and capture the doc in one call.\n  if (idFromWhere !== null && !guarded) {\n    const deleted = await deleteItem(this, partition, idFromWhere, { returnOld: true })\n    if (returning === false) {\n      return null as never\n    }\n    return deleted as never\n  }\n\n  // Slow path — locate (a `GetItem` when `where` is an id), then delete by\n  // composite key.\n  const found = await findFirst(this, { partition, where })\n  if (!found) {\n    return null as never\n  }\n\n  await deleteItem(\n    this,\n    partition,\n    found['id'],\n    guarded ? { companions: { collection, doc: found } } : {},\n  )\n\n  if (returning === false) {\n    return null as never\n  }\n  return found as never\n}\n"],"names":["hasCompanionRows","findFirst","prepareCollectionWhere","whereToId","deleteItem","deleteOne","collection","returning","where","rawWhere","partition","resolvePartition","idFromWhere","guarded","deleted","returnOld","found","companions","doc"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,8BAA6B;AAC9D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,YAAuB,eAAeA,UAEjD,EAAEC,UAAU,EAAEC,SAAS,EAAEC,OAAOC,QAAQ,EAAE;IAE1C,MAAMD,QAAQ,MAAMN,uBAAuB,IAAI,EAAEI,YAAYG;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACL;IACxC,MAAMM,cAAcT,UAAUK;IAC9B,0EAA0E;IAC1E,+DAA+D;IAC/D,MAAMK,UAAUb,iBAAiB,IAAI,EAAEM;IAEvC,+EAA+E;IAC/E,IAAIM,gBAAgB,QAAQ,CAACC,SAAS;QACpC,MAAMC,UAAU,MAAMV,WAAW,IAAI,EAAEM,WAAWE,aAAa;YAAEG,WAAW;QAAK;QACjF,IAAIR,cAAc,OAAO;YACvB,OAAO;QACT;QACA,OAAOO;IACT;IAEA,yEAAyE;IACzE,iBAAiB;IACjB,MAAME,QAAQ,MAAMf,UAAU,IAAI,EAAE;QAAES;QAAWF;IAAM;IACvD,IAAI,CAACQ,OAAO;QACV,OAAO;IACT;IAEA,MAAMZ,WACJ,IAAI,EACJM,WACAM,KAAK,CAAC,KAAK,EACXH,UAAU;QAAEI,YAAY;YAAEX;YAAYY,KAAKF;QAAM;IAAE,IAAI,CAAC;IAG1D,IAAIT,cAAc,OAAO;QACvB,OAAO;IACT;IACA,OAAOS;AACT,EAAC"}

package/dist/deleteVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteVersions.d.ts","sourceRoot":"","sources":["../src/deleteVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAQ7C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAsB5B,CAAA"}
+{"version":3,"file":"deleteVersions.d.ts","sourceRoot":"","sources":["../src/deleteVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAQ7C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAwB5B,CAAA"}

package/dist/deleteVersions.js

@@ -16,7 +16,11 @@ import { deleteItems } from './utilities/writeItems.js';
         kind: collection ? 'collection' : 'global',
         slug
     }, where, locale));
-    await deleteItems(this, partition, matched);
+    // Each version's index row, and its parent's pointer if it was the latest,
+    // go with it.
+    await deleteItems(this, partition, matched, {
+        versions: true
+    });
 };
 
 //# sourceMappingURL=deleteVersions.js.map

package/dist/deleteVersions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteVersions.ts"],"sourcesContent":["import type { DeleteVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * Same query + parallel delete pattern as `deleteMany`, but routes to the\n * versions partition for either a collection (`collection`) or a global\n * (`globalSlug`). Payload guarantees exactly one of those two slugs is\n * present.\n */\nexport const deleteVersions: DeleteVersions = async function deleteVersions(\n  this: DynamoAdapter,\n  { collection, globalSlug, locale, where },\n) {\n  const slug = collection ?? globalSlug\n  if (!slug) {\n    throw new Error('payload-ddb: deleteVersions requires either `collection` or `globalSlug`.')\n  }\n\n  const partition = this.resolveVersionsPartition(slug)\n  const matched = await queryMatching(\n    this,\n    partition,\n    await prepareVersionsWhere(\n      this,\n      { kind: collection ? 'collection' : 'global', slug },\n      where,\n      locale,\n    ),\n  )\n\n  await deleteItems(this, partition, matched)\n}\n"],"names":["prepareVersionsWhere","queryMatching","deleteItems","deleteVersions","collection","globalSlug","locale","where","slug","Error","partition","resolveVersionsPartition","matched","kind"],"mappings":"AAIA,SAASA,oBAAoB,QAAQ,8BAA6B;AAClE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;;;CAKC,GACD,OAAO,MAAMC,iBAAiC,eAAeA,eAE3D,EAAEC,UAAU,EAAEC,UAAU,EAAEC,MAAM,EAAEC,KAAK,EAAE;IAEzC,MAAMC,OAAOJ,cAAcC;IAC3B,IAAI,CAACG,MAAM;QACT,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACH;IAChD,MAAMI,UAAU,MAAMX,cACpB,IAAI,EACJS,WACA,MAAMV,qBACJ,IAAI,EACJ;QAAEa,MAAMT,aAAa,eAAe;QAAUI;IAAK,GACnDD,OACAD;IAIJ,MAAMJ,YAAY,IAAI,EAAEQ,WAAWE;AACrC,EAAC"}
+{"version":3,"sources":["../src/deleteVersions.ts"],"sourcesContent":["import type { DeleteVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * Same query + parallel delete pattern as `deleteMany`, but routes to the\n * versions partition for either a collection (`collection`) or a global\n * (`globalSlug`). Payload guarantees exactly one of those two slugs is\n * present.\n */\nexport const deleteVersions: DeleteVersions = async function deleteVersions(\n  this: DynamoAdapter,\n  { collection, globalSlug, locale, where },\n) {\n  const slug = collection ?? globalSlug\n  if (!slug) {\n    throw new Error('payload-ddb: deleteVersions requires either `collection` or `globalSlug`.')\n  }\n\n  const partition = this.resolveVersionsPartition(slug)\n  const matched = await queryMatching(\n    this,\n    partition,\n    await prepareVersionsWhere(\n      this,\n      { kind: collection ? 'collection' : 'global', slug },\n      where,\n      locale,\n    ),\n  )\n\n  // Each version's index row, and its parent's pointer if it was the latest,\n  // go with it.\n  await deleteItems(this, partition, matched, { versions: true })\n}\n"],"names":["prepareVersionsWhere","queryMatching","deleteItems","deleteVersions","collection","globalSlug","locale","where","slug","Error","partition","resolveVersionsPartition","matched","kind","versions"],"mappings":"AAIA,SAASA,oBAAoB,QAAQ,8BAA6B;AAClE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;;;CAKC,GACD,OAAO,MAAMC,iBAAiC,eAAeA,eAE3D,EAAEC,UAAU,EAAEC,UAAU,EAAEC,MAAM,EAAEC,KAAK,EAAE;IAEzC,MAAMC,OAAOJ,cAAcC;IAC3B,IAAI,CAACG,MAAM;QACT,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACH;IAChD,MAAMI,UAAU,MAAMX,cACpB,IAAI,EACJS,WACA,MAAMV,qBACJ,IAAI,EACJ;QAAEa,MAAMT,aAAa,eAAe;QAAUI;IAAK,GACnDD,OACAD;IAIJ,2EAA2E;IAC3E,cAAc;IACd,MAAMJ,YAAY,IAAI,EAAEQ,WAAWE,SAAS;QAAEE,UAAU;IAAK;AAC/D,EAAC"}