@open-aih/payload-ddb 3.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dbyron10
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# payload-ddb
+
+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.
+
+## Installation
+
+```bash
+pnpm add @aih-software/payload-ddb
+# or
+npm install @aih-software/payload-ddb
+```
+
+## Quick start (DynamoDB Local)
+
+```ts
+import { buildConfig } from 'payload'
+import { dynamoAdapter } from '@aih-software/payload-ddb'
+
+export default buildConfig({
+  db: dynamoAdapter({
+    ensureTables: true, // auto-create the table on startup; turn off in prod
+    clientConfig: {
+      endpoint: 'http://localhost:8000',
+      region: 'us-east-1',
+      credentials: {
+        accessKeyId: 'fake',
+        secretAccessKey: 'fake',
+      },
+    },
+  }),
+  // ...rest of config
+})
+```
+
+## Production setup
+
+The single backing table should be provisioned out-of-band (CDK, Terraform,
+CloudFormation) so the adapter doesn't need IAM permissions to create or
+describe tables.
+
+```ts
+db: dynamoAdapter({
+  // ensureTables defaults to false — leave it off
+  tableName: 'payload',
+  clientConfig: {
+    region: 'us-east-1',
+    // credentials resolved from the default chain (IAM role, env, etc.)
+  },
+})
+```
+
+Provision the table with a composite key:
+- Partition key: `pk` (String)
+- Sort key: `sk` (String)
+- Billing: on-demand (`PAY_PER_REQUEST`) or provisioned, your call
+
+Every collection, global, and versions stream lives under a different `pk`
+value in the same physical table.
+
+## Configuration
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `clientConfig` | `DynamoDBClientConfig` | `{}` | Passed straight to `new DynamoDBClient(...)`. Region, endpoint, credentials, retry strategy, etc. |
+| `client` | `DynamoDBClient` | — | Pre-built client. If supplied, `clientConfig` is ignored and the adapter does **not** call `.destroy()` on shutdown. |
+| `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. |
+
+## Data layout
+
+- **One DynamoDB table for everything.** Every row carries a synthetic
+  `pk`/`sk` pair that the adapter strips on read so callers never see them.
+- **Collection documents:** `pk = "<slug>"`, `sk = "<id>"`.
+- **Globals:** `pk = "<slug>"`, `sk = "<slug>"` — single-row partition since
+  globals are singletons.
+- **Versions:** `pk = "<slug>_versions"`, `sk = "<versionId>"` for both
+  collections and globals.
+- **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).
+
+## 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`.
+
+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).
+
+## 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.
+- **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.
+
+## 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.
+
+```bash
+pnpm install
+pnpm docker:start   # boots amazon/dynamodb-local on :8001
+pnpm test           # runs every test/**/*.int.spec.ts once
+pnpm test:watch     # vitest in watch mode
+pnpm typecheck:test # tsc -p test/tsconfig.json
+pnpm docker:stop    # tears the container down
+```
+
+`pnpm test` fails fast with a friendly message if the container isn't
+reachable. Override the host/port with `PAYLOAD_DDB_TEST_HOST` /
+`PAYLOAD_DDB_TEST_PORT` if 8001 conflicts on your machine.
+
+See [`test/README.md`](./test/README.md) for the harness layout and how to
+add a new spec.
+
+## License
+
+MIT

package/dist/connect.d.ts

@@ -0,0 +1,3 @@
+import type { Connect } from 'payload';
+export declare const connect: Connect;
+//# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

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

package/dist/connect.js

@@ -0,0 +1,6 @@
+import { ensureConnected } from './utilities/ensureConnected.js';
+export const connect = async function() {
+    ensureConnected(this);
+};
+
+//# sourceMappingURL=connect.js.map

package/dist/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/connect.ts"],"sourcesContent":["import type { Connect } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { ensureConnected } from './utilities/ensureConnected.js'\n\nexport const connect: Connect = async function (this: DynamoAdapter) {\n  ensureConnected(this)\n}\n"],"names":["ensureConnected","connect"],"mappings":"AAIA,SAASA,eAAe,QAAQ,iCAAgC;AAEhE,OAAO,MAAMC,UAAmB;IAC9BD,gBAAgB,IAAI;AACtB,EAAC"}

package/dist/count.d.ts

@@ -0,0 +1,3 @@
+import type { Count } from 'payload';
+export declare const count: Count;
+//# sourceMappingURL=count.d.ts.map

package/dist/count.d.ts.map

@@ -0,0 +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"}

package/dist/count.js

@@ -0,0 +1,9 @@
+import { queryCount } from './utilities/queryCount.js';
+export const count = async function count({ collection, where }) {
+    const totalDocs = await queryCount(this, this.resolvePartition(collection), where);
+    return {
+        totalDocs
+    };
+};
+
+//# sourceMappingURL=count.js.map

package/dist/count.js.map

@@ -0,0 +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"}

package/dist/countGlobalVersions.d.ts

@@ -0,0 +1,3 @@
+import type { CountGlobalVersions } from 'payload';
+export declare const countGlobalVersions: CountGlobalVersions;
+//# sourceMappingURL=countGlobalVersions.d.ts.map

package/dist/countGlobalVersions.d.ts.map

@@ -0,0 +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"}

package/dist/countGlobalVersions.js

@@ -0,0 +1,9 @@
+import { queryCount } from './utilities/queryCount.js';
+export const countGlobalVersions = async function countGlobalVersions({ global, where }) {
+    const totalDocs = await queryCount(this, this.resolveVersionsPartition(global), where);
+    return {
+        totalDocs
+    };
+};
+
+//# sourceMappingURL=countGlobalVersions.js.map

package/dist/countGlobalVersions.js.map

@@ -0,0 +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"}

package/dist/countVersions.d.ts

@@ -0,0 +1,3 @@
+import type { CountVersions } from 'payload';
+export declare const countVersions: CountVersions;
+//# sourceMappingURL=countVersions.d.ts.map

package/dist/countVersions.d.ts.map

@@ -0,0 +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"}

package/dist/countVersions.js

@@ -0,0 +1,9 @@
+import { queryCount } from './utilities/queryCount.js';
+export const countVersions = async function countVersions({ collection, where }) {
+    const totalDocs = await queryCount(this, this.resolveVersionsPartition(collection), where);
+    return {
+        totalDocs
+    };
+};
+
+//# sourceMappingURL=countVersions.js.map

package/dist/countVersions.js.map

@@ -0,0 +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"}

package/dist/create.d.ts

@@ -0,0 +1,3 @@
+import type { Create } from 'payload';
+export declare const create: Create;
+//# sourceMappingURL=create.d.ts.map

package/dist/create.d.ts.map

@@ -0,0 +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"}

package/dist/create.js

@@ -0,0 +1,38 @@
+import { PutCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'node:crypto';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.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.');
+    }
+    const id = customID ?? data['id'] ?? randomUUID();
+    const now = new Date().toISOString();
+    // Spread `data` first, then nullish-coalesce timestamps. Explicit values
+    // in `data` (versions/restore, migrations backdating) still win, but a
+    // payload-passed `data.createdAt = undefined` no longer wipes the default
+    // back to undefined — which the marshaller would then drop with
+    // `removeUndefinedValues: true`, leaving the row without timestamps.
+    const item = {
+        ...data,
+        id,
+        createdAt: data['createdAt'] ?? now,
+        updatedAt: data['updatedAt'] ?? now
+    };
+    // Project against the collection's declared fields. DDB has no schema
+    // 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)
+        })
+    }));
+    return returning === false ? null : projected;
+};
+
+//# sourceMappingURL=create.js.map

package/dist/create.js.map

@@ -0,0 +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"}

package/dist/createGlobal.d.ts

@@ -0,0 +1,8 @@
+import type { CreateGlobal } from 'payload';
+/**
+ * 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 declare const createGlobal: CreateGlobal;
+//# sourceMappingURL=createGlobal.d.ts.map

package/dist/createGlobal.d.ts.map

@@ -0,0 +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"}

package/dist/createGlobal.js

@@ -0,0 +1,29 @@
+import { PutCommand } from '@aws-sdk/lib-dynamodb';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectForGlobal } from './utilities/resolveSchema.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
+        })
+    }));
+    return returning === false ? null : projected;
+};
+
+//# sourceMappingURL=createGlobal.js.map

package/dist/createGlobal.js.map

@@ -0,0 +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"}

package/dist/createGlobalVersion.d.ts

@@ -0,0 +1,8 @@
+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.
+ */
+export declare const createGlobalVersion: CreateGlobalVersion;
+//# sourceMappingURL=createGlobalVersion.d.ts.map

package/dist/createGlobalVersion.d.ts.map

@@ -0,0 +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"}

package/dist/createGlobalVersion.js

@@ -0,0 +1,80 @@
+import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'node:crypto';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectVersionSnapshot } from './utilities/resolveSchema.js';
+/**
+ * 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.
+ */ export const createGlobalVersion = async function createGlobalVersion({ autosave, createdAt, globalSlug, publishedLocale, returning, snapshot, updatedAt, versionData }) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolveVersionsPartition(globalSlug);
+    const previousLatest = await findFirst(this, {
+        partition,
+        where: {
+            latest: {
+                equals: true
+            }
+        }
+    });
+    const id = randomUUID();
+    const sanitizedVersionData = projectVersionSnapshot(this, {
+        kind: 'global',
+        slug: globalSlug
+    }, versionData);
+    const item = {
+        id,
+        version: sanitizedVersionData,
+        createdAt,
+        updatedAt,
+        latest: true,
+        autosave,
+        ...snapshot ? {
+            snapshot: true
+        } : {},
+        ...publishedLocale !== undefined ? {
+            publishedLocale
+        } : {}
+    };
+    const putItem = normalizeForDynamo({
+        ...item,
+        pk: partition,
+        sk: id
+    });
+    const transactItems = [];
+    if (previousLatest) {
+        transactItems.push({
+            Update: {
+                TableName: this.tableName,
+                Key: {
+                    pk: partition,
+                    sk: String(previousLatest['id'])
+                },
+                UpdateExpression: 'SET #latest = :false',
+                ExpressionAttributeNames: {
+                    '#latest': 'latest'
+                },
+                ExpressionAttributeValues: {
+                    ':false': false
+                },
+                ConditionExpression: 'attribute_exists(pk)'
+            }
+        });
+    }
+    transactItems.push({
+        Put: {
+            TableName: this.tableName,
+            Item: putItem
+        }
+    });
+    await docClient.send(new TransactWriteCommand({
+        TransactItems: transactItems
+    }));
+    return returning === false ? null : item;
+};
+
+//# sourceMappingURL=createGlobalVersion.js.map

package/dist/createGlobalVersion.js.map

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

package/dist/createVersion.d.ts

@@ -0,0 +1,18 @@
+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. `TransactWriteItems` to flip that row's `latest` to false and put the
+ *     new row in one atomic call. If a crash occurs mid-flow neither
+ *     mutation lands, so we never end up with two `latest=true` rows or
+ *     zero. The Update carries `attribute_exists(pk)` so the transaction
+ *     fails cleanly if the previous row was deleted between (1) and (2).
+ *
+ * `autosave` is persisted on the row even though it isn't surfaced in
+ * `TypeWithVersion` — `findVersions` filters by it.
+ */
+export declare const createVersion: CreateVersion;
+//# sourceMappingURL=createVersion.d.ts.map

package/dist/createVersion.d.ts.map

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

package/dist/createVersion.js

@@ -0,0 +1,106 @@
+import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'node:crypto';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectVersionSnapshot } from './utilities/resolveSchema.js';
+/**
+ * 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. `TransactWriteItems` to flip that row's `latest` to false and put the
+ *     new row in one atomic call. If a crash occurs mid-flow neither
+ *     mutation lands, so we never end up with two `latest=true` rows or
+ *     zero. The Update carries `attribute_exists(pk)` so the transaction
+ *     fails cleanly if the previous row was deleted between (1) and (2).
+ *
+ * `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 docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    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
+    // the version row alongside the legitimate doc state.
+    const sanitizedVersionData = projectVersionSnapshot(this, {
+        kind: 'collection',
+        slug: collectionSlug
+    }, versionData);
+    const item = {
+        id,
+        parent,
+        version: sanitizedVersionData,
+        createdAt,
+        updatedAt,
+        latest: true,
+        autosave,
+        ...snapshot ? {
+            snapshot: true
+        } : {},
+        ...publishedLocale !== undefined ? {
+            publishedLocale
+        } : {}
+    };
+    const putItem = normalizeForDynamo({
+        ...item,
+        pk: partition,
+        sk: id
+    });
+    const transactItems = [];
+    if (previousLatest) {
+        transactItems.push({
+            Update: {
+                TableName: this.tableName,
+                Key: {
+                    pk: partition,
+                    sk: String(previousLatest['id'])
+                },
+                UpdateExpression: 'SET #latest = :false',
+                ExpressionAttributeNames: {
+                    '#latest': 'latest'
+                },
+                ExpressionAttributeValues: {
+                    ':false': false
+                },
+                // Fail the whole transaction if the previous row was deleted between
+                // our read and this transaction. Better to error and let the caller
+                // retry than to silently leave the new version with a phantom flip.
+                ConditionExpression: 'attribute_exists(pk)'
+            }
+        });
+    }
+    transactItems.push({
+        Put: {
+            TableName: this.tableName,
+            Item: putItem
+        }
+    });
+    await docClient.send(new TransactWriteCommand({
+        TransactItems: transactItems
+    }));
+    return returning === false ? null : item;
+};
+
+//# sourceMappingURL=createVersion.js.map

package/dist/createVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createVersion.ts"],"sourcesContent":["import type { CreateVersion } from 'payload'\n\nimport { TransactWriteCommand } from '@aws-sdk/lib-dynamodb'\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectVersionSnapshot } from './utilities/resolveSchema.js'\n\n/**\n * 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. `TransactWriteItems` to flip that row's `latest` to false and put the\n *     new row in one atomic call. If a crash occurs mid-flow neither\n *     mutation lands, so we never end up with two `latest=true` rows or\n *     zero. The Update carries `attribute_exists(pk)` so the transaction\n *     fails cleanly if the previous row was deleted between (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 docClient = this.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  const partition = this.resolveVersionsPartition(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  const putItem = normalizeForDynamo({\n    ...item,\n    pk: partition,\n    sk: id,\n  })\n\n  const transactItems: NonNullable<\n    ConstructorParameters<typeof TransactWriteCommand>[0]['TransactItems']\n  > = []\n\n  if (previousLatest) {\n    transactItems.push({\n      Update: {\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(previousLatest['id']) },\n        UpdateExpression: 'SET #latest = :false',\n        ExpressionAttributeNames: { '#latest': 'latest' },\n        ExpressionAttributeValues: { ':false': false },\n        // Fail the whole transaction if the previous row was deleted between\n        // our read and this transaction. Better to error and let the caller\n        // retry than to silently leave the new version with a phantom flip.\n        ConditionExpression: 'attribute_exists(pk)',\n      },\n    })\n  }\n\n  transactItems.push({\n    Put: {\n      TableName: this.tableName,\n      Item: putItem,\n    },\n  })\n\n  await docClient.send(new TransactWriteCommand({ TransactItems: transactItems }))\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["TransactWriteCommand","randomUUID","findFirst","normalizeForDynamo","projectVersionSnapshot","createVersion","autosave","collectionSlug","createdAt","parent","publishedLocale","returning","snapshot","updatedAt","versionData","docClient","Error","partition","resolveVersionsPartition","previousLatest","where","and","equals","latest","id","sanitizedVersionData","kind","slug","item","version","undefined","putItem","pk","sk","transactItems","push","Update","TableName","tableName","Key","String","UpdateExpression","ExpressionAttributeNames","ExpressionAttributeValues","ConditionExpression","Put","Item","send","TransactItems"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,wBAAuB;AAC5D,SAASC,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,sBAAsB,QAAQ,+BAA8B;AAErE;;;;;;;;;;;;;;CAcC,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,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACX;IAEhD,MAAMY,iBAAiB,MAAMjB,UAAU,IAAI,EAAE;QAC3Ce;QACAG,OAAO;YAAEC,KAAK;gBAAC;oBAAEZ,QAAQ;wBAAEa,QAAQb;oBAAO;gBAAE;gBAAG;oBAAEc,QAAQ;wBAAED,QAAQ;oBAAK;gBAAE;aAAE;QAAC;IAC/E;IAEA,MAAME,KAAKvB;IACX,0EAA0E;IAC1E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAMwB,uBAAuBrB,uBAC3B,IAAI,EACJ;QAAEsB,MAAM;QAAcC,MAAMpB;IAAe,GAC3CO;IAEF,MAAMc,OAAgC;QACpCJ;QACAf;QACAoB,SAASJ;QACTjB;QACAK;QACAU,QAAQ;QACRjB;QACA,GAAIM,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBoB,YAAY;YAAEpB;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,MAAMqB,UAAU5B,mBAAmB;QACjC,GAAGyB,IAAI;QACPI,IAAIf;QACJgB,IAAIT;IACN;IAEA,MAAMU,gBAEF,EAAE;IAEN,IAAIf,gBAAgB;QAClBe,cAAcC,IAAI,CAAC;YACjBC,QAAQ;gBACNC,WAAW,IAAI,CAACC,SAAS;gBACzBC,KAAK;oBAAEP,IAAIf;oBAAWgB,IAAIO,OAAOrB,cAAc,CAAC,KAAK;gBAAE;gBACvDsB,kBAAkB;gBAClBC,0BAA0B;oBAAE,WAAW;gBAAS;gBAChDC,2BAA2B;oBAAE,UAAU;gBAAM;gBAC7C,qEAAqE;gBACrE,oEAAoE;gBACpE,oEAAoE;gBACpEC,qBAAqB;YACvB;QACF;IACF;IAEAV,cAAcC,IAAI,CAAC;QACjBU,KAAK;YACHR,WAAW,IAAI,CAACC,SAAS;YACzBQ,MAAMf;QACR;IACF;IAEA,MAAMhB,UAAUgC,IAAI,CAAC,IAAI/C,qBAAqB;QAAEgD,eAAed;IAAc;IAE7E,OAAOvB,cAAc,QAAS,OAAkBiB;AAClD,EAAC"}

package/dist/deleteMany.d.ts

@@ -0,0 +1,12 @@
+import type { DeleteMany } from 'payload';
+/**
+ * v1 strategy: query-and-collect matches, then delete each by composite key
+ * in parallel.
+ *
+ * `BatchWriteItem` could halve the request count (25 deletes per call) but
+ * has partial-failure semantics that need retry logic — out of scope until
+ * we wire up retries. Sequential parallel `DeleteCommand`s are simple and
+ * correct.
+ */
+export declare const deleteMany: DeleteMany;
+//# sourceMappingURL=deleteMany.d.ts.map

package/dist/deleteMany.d.ts.map

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