@open-aih/payload-ddb 3.1.0 → 4.2.0-beta.20261113193102

package/README.md

@@ -3,22 +3,37 @@
 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 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
+
+- **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 +90,8 @@ 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. |
+| `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
 
@@ -88,42 +105,232 @@ 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`;
-  predicates beyond `pk` get pushed to `FilterExpression` (DynamoDB still
-  reads every row in the partition before filtering).
+- **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*.
+- **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
 
 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.
+
+### 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`,
+not on one side of an `or`. The rest of the `where` is then evaluated on the
+documents it selects. This covers login by `email`, pages by `slug`,
+relationship population (`id in [...]`), filters on a relationship, join
+fields, and date or number ranges.
+
+- **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
+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
+
+- **`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.
+- **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`
+  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`.
+
+### 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.
 
-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).
+Documents written before this was enforced have no guards until they are next
+saved. `backfillIndexes` (see *Indexes*) covers them in the same pass:
+
+```ts
+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.
+- **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
+  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 +348,29 @@ 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`.
+
+**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/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,31 @@ 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. `collection` adds the
+            // document's unique guards and index rows to the same transaction.
+            await putItem(this, partition, projected, {
+                collection,
+                mustNotExist: true
+            });
+            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. `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/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;AAWlD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBA8CjC,CAAA"}