@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/utilities/uniqueGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/uniqueGuards.ts"],"sourcesContent":["import type { FlattenedField } from 'payload'\n\nimport { createHash } from 'node:crypto'\nimport { fieldShouldBeLocalized } from 'payload/shared'\n\nimport type { DynamoAdapter } from '../types.js'\n\n/**\n * Uniqueness for fields declared `unique: true`.\n *\n * DynamoDB can only enforce uniqueness on a primary key, so each unique\n * value gets a small *guard row* whose key *is* the value:\n *\n *     pk = \"<collection partition>#unique#<stored field path>\"\n *     sk = \"<type tag>:<value>\"\n *     owner = \"<id of the document holding the value>\"\n *\n * A document and its guards are written in one `TransactWriteItems`, each\n * guard conditioned on \"no such row, or it's already mine\". A second\n * document claiming the same value fails that condition and the whole write\n * is cancelled. Guards live in their own partitions, so they never show up\n * in a collection's reads.\n *\n * Covered: scalar unique fields at the top level or inside groups / named\n * tabs, including localized ones (one guard per locale). Not covered:\n * unique fields inside arrays or blocks, and `hasMany` fields — a list has\n * no single value to key on.\n *\n * Empty values (`null`, `undefined`, `''`) are not guarded: any number of\n * documents may leave a unique field blank.\n */\n\nexport type UniqueGuard = {\n  key: { pk: string; sk: string }\n  /** Schema path of the field, without locale — what a validation error names. */\n  path: string\n}\n\ntype UniqueField = { field: FlattenedField; path: string[] }\n\nconst cache = new WeakMap<DynamoAdapter, Map<string, boolean>>()\n\n/** Whether a collection declares any unique field the adapter guards. */\nexport function hasUniqueFields(adapter: DynamoAdapter, collectionSlug: string): boolean {\n  let known = cache.get(adapter)\n  if (!known) {\n    known = new Map()\n    cache.set(adapter, known)\n  }\n  const cached = known.get(collectionSlug)\n  if (cached !== undefined) return cached\n\n  const fields = adapter.payload?.collections?.[collectionSlug]?.config.flattenedFields\n  const result = fields ? containsUnique(fields) : false\n  known.set(collectionSlug, result)\n  return result\n}\n\nfunction isGuardable(field: FlattenedField): boolean {\n  return (\n    'unique' in field &&\n    Boolean(field.unique) &&\n    field.name !== 'id' &&\n    !('hasMany' in field && field.hasMany)\n  )\n}\n\nfunction containsUnique(fields: FlattenedField[]): boolean {\n  return fields.some((field) => {\n    if (field.type === 'array' || field.type === 'blocks') return false\n    if ('flattenedFields' in field) return containsUnique(field.flattenedFields)\n    return isGuardable(field)\n  })\n}\n\n/** Every guard a document's current values call for. */\nexport function uniqueGuardsFor(\n  adapter: DynamoAdapter,\n  collectionSlug: string,\n  partition: string,\n  doc: Record<string, unknown>,\n): UniqueGuard[] {\n  if (!hasUniqueFields(adapter, collectionSlug)) return []\n  const fields = adapter.payload.collections[collectionSlug]!.config.flattenedFields\n  const localeCodes = adapter.payload.config.localization\n    ? adapter.payload.config.localization.localeCodes\n    : null\n\n  const guards: UniqueGuard[] = []\n  collect(doc, fields, [], [], false)\n  return guards\n\n  function collect(\n    source: unknown,\n    level: FlattenedField[],\n    schemaPath: string[],\n    storedPath: string[],\n    parentIsLocalized: boolean,\n  ): void {\n    if (!source || typeof source !== 'object' || Array.isArray(source)) return\n    const record = source as Record<string, unknown>\n\n    for (const field of level) {\n      if (field.type === 'array' || field.type === 'blocks') continue\n      const isContainer = 'flattenedFields' in field\n      if (!isContainer && !isGuardable(field)) continue\n\n      const value = record[field.name]\n      const schema = [...schemaPath, field.name]\n      const stored = [...storedPath, field.name]\n      const localized = Boolean(localeCodes) && fieldShouldBeLocalized({ field, parentIsLocalized })\n\n      // A localized field holds one value per locale; visit each.\n      const variants: [unknown, string[]][] =\n        localized && value && typeof value === 'object' && !Array.isArray(value)\n          ? Object.entries(value as Record<string, unknown>)\n              .filter(([locale]) => localeCodes!.includes(locale))\n              .map(([locale, inner]) => [inner, [...stored, locale]])\n          : localized\n            ? []\n            : [[value, stored]]\n\n      for (const [inner, innerStored] of variants) {\n        if (isContainer) {\n          collect(inner, field.flattenedFields, schema, innerStored, parentIsLocalized || localized)\n          continue\n        }\n        const sk = encodeValue(inner)\n        if (sk === null) continue\n        guards.push({\n          key: { pk: `${partition}#unique#${innerStored.join('.')}`, sk },\n          path: schema.join('.'),\n        })\n      }\n    }\n  }\n}\n\n/**\n * Turn a value into a sort key. The type tag keeps `1` and `'1'` apart;\n * long strings are hashed because a sort key is capped at 1024 bytes.\n * Returns `null` for values that aren't guarded.\n */\nfunction encodeValue(value: unknown): null | string {\n  switch (typeof value) {\n    case 'boolean':\n      return `b:${value}`\n    case 'number':\n      return Number.isFinite(value) ? `n:${value}` : null\n    case 'string':\n      if (value === '') return null\n      return value.length > 256\n        ? `h:${createHash('sha256').update(value).digest('hex')}`\n        : `s:${value}`\n    default:\n      return null\n  }\n}\n\nexport function sameGuard(a: UniqueGuard, b: UniqueGuard): boolean {\n  return a.key.pk === b.key.pk && a.key.sk === b.key.sk\n}\n"],"names":["createHash","fieldShouldBeLocalized","cache","WeakMap","hasUniqueFields","adapter","collectionSlug","known","get","Map","set","cached","undefined","fields","payload","collections","config","flattenedFields","result","containsUnique","isGuardable","field","Boolean","unique","name","hasMany","some","type","uniqueGuardsFor","partition","doc","localeCodes","localization","guards","collect","source","level","schemaPath","storedPath","parentIsLocalized","Array","isArray","record","isContainer","value","schema","stored","localized","variants","Object","entries","filter","locale","includes","map","inner","innerStored","sk","encodeValue","push","key","pk","join","path","Number","isFinite","length","update","digest","sameGuard","a","b"],"mappings":"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"}

package/dist/utilities/updateVersionRow.d.ts

@@ -0,0 +1,19 @@
+import type { Where } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+/**
+ * The shared body of `updateVersion` and `updateGlobalVersion`: locate one
+ * version row (by id, else by `where`), overlay `versionData`, and write it
+ * back — conditional on the row being unchanged since it was read, and
+ * retried on the fresh row when it wasn't.
+ */
+export declare function updateVersionRow(adapter: DynamoAdapter, parent: {
+    kind: 'collection' | 'global';
+    slug: string;
+}, args: {
+    id?: number | string;
+    locale?: string;
+    returning?: boolean;
+    versionData: Record<string, unknown>;
+    where?: Where;
+}): Promise<null | Record<string, unknown>>;
+//# sourceMappingURL=updateVersionRow.d.ts.map

package/dist/utilities/updateVersionRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateVersionRow.d.ts","sourceRoot":"","sources":["../../src/utilities/updateVersionRow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAQhD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE;IAAE,IAAI,EAAE,YAAY,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACvD,IAAI,EAAE;IACJ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,GACA,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA2BzC"}

package/dist/utilities/updateVersionRow.js

@@ -0,0 +1,40 @@
+import { findFirst } from './findFirst.js';
+import { getById, writeWithRetry } from './optimistic.js';
+import { prepareVersionsWhere } from './prepareWhere.js';
+import { projectVersionRow } from './resolveSchema.js';
+import { putItem } from './writeItems.js';
+/**
+ * The shared body of `updateVersion` and `updateGlobalVersion`: locate one
+ * version row (by id, else by `where`), overlay `versionData`, and write it
+ * back — conditional on the row being unchanged since it was read, and
+ * retried on the fresh row when it wasn't.
+ */ export async function updateVersionRow(adapter, parent, args) {
+    const partition = adapter.resolveVersionsPartition(parent.slug);
+    const byId = args.id !== undefined && args.id !== null;
+    const where = byId ? undefined : await prepareVersionsWhere(adapter, parent, args.where, args.locale);
+    const read = ()=>{
+        if (byId) return getById(adapter, partition, args.id);
+        return where ? findFirst(adapter, {
+            partition,
+            where
+        }) : Promise.resolve(null);
+    };
+    const updated = await writeWithRetry(await read(), read, async (target)=>{
+        const merged = {
+            ...target,
+            ...args.versionData,
+            id: target['id']
+        };
+        // Project both the version-row metadata layer and the inner `version`
+        // snapshot. Catches stray keys at either layer plus stale leaks already
+        // persisted on the target.
+        const projected = projectVersionRow(adapter, parent, merged);
+        await putItem(adapter, partition, projected, {
+            replaces: target
+        });
+        return projected;
+    });
+    return args.returning === false ? null : updated;
+}
+
+//# sourceMappingURL=updateVersionRow.js.map

package/dist/utilities/updateVersionRow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/updateVersionRow.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { findFirst } from './findFirst.js'\nimport { getById, writeWithRetry } from './optimistic.js'\nimport { prepareVersionsWhere } from './prepareWhere.js'\nimport { projectVersionRow } from './resolveSchema.js'\nimport { putItem } from './writeItems.js'\n\n/**\n * The shared body of `updateVersion` and `updateGlobalVersion`: locate one\n * version row (by id, else by `where`), overlay `versionData`, and write it\n * back — conditional on the row being unchanged since it was read, and\n * retried on the fresh row when it wasn't.\n */\nexport async function updateVersionRow(\n  adapter: DynamoAdapter,\n  parent: { kind: 'collection' | 'global'; slug: string },\n  args: {\n    id?: number | string\n    locale?: string\n    returning?: boolean\n    versionData: Record<string, unknown>\n    where?: Where\n  },\n): Promise<null | Record<string, unknown>> {\n  const partition = adapter.resolveVersionsPartition(parent.slug)\n\n  const byId = args.id !== undefined && args.id !== null\n  const where = byId\n    ? undefined\n    : await prepareVersionsWhere(adapter, parent, args.where, args.locale)\n  const read = () => {\n    if (byId) return getById(adapter, partition, args.id)\n    return where ? findFirst(adapter, { partition, where }) : Promise.resolve(null)\n  }\n\n  const updated = await writeWithRetry(await read(), read, async (target) => {\n    const merged: Record<string, unknown> = {\n      ...target,\n      ...args.versionData,\n      id: target['id'],\n    }\n    // Project both the version-row metadata layer and the inner `version`\n    // snapshot. Catches stray keys at either layer plus stale leaks already\n    // persisted on the target.\n    const projected = projectVersionRow(adapter, parent, merged)\n    await putItem(adapter, partition, projected, { replaces: target })\n    return projected\n  })\n\n  return args.returning === false ? null : updated\n}\n"],"names":["findFirst","getById","writeWithRetry","prepareVersionsWhere","projectVersionRow","putItem","updateVersionRow","adapter","parent","args","partition","resolveVersionsPartition","slug","byId","id","undefined","where","locale","read","Promise","resolve","updated","target","merged","versionData","projected","replaces","returning"],"mappings":"AAIA,SAASA,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,OAAO,EAAEC,cAAc,QAAQ,kBAAiB;AACzD,SAASC,oBAAoB,QAAQ,oBAAmB;AACxD,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,OAAO,QAAQ,kBAAiB;AAEzC;;;;;CAKC,GACD,OAAO,eAAeC,iBACpBC,OAAsB,EACtBC,MAAuD,EACvDC,IAMC;IAED,MAAMC,YAAYH,QAAQI,wBAAwB,CAACH,OAAOI,IAAI;IAE9D,MAAMC,OAAOJ,KAAKK,EAAE,KAAKC,aAAaN,KAAKK,EAAE,KAAK;IAClD,MAAME,QAAQH,OACVE,YACA,MAAMZ,qBAAqBI,SAASC,QAAQC,KAAKO,KAAK,EAAEP,KAAKQ,MAAM;IACvE,MAAMC,OAAO;QACX,IAAIL,MAAM,OAAOZ,QAAQM,SAASG,WAAWD,KAAKK,EAAE;QACpD,OAAOE,QAAQhB,UAAUO,SAAS;YAAEG;YAAWM;QAAM,KAAKG,QAAQC,OAAO,CAAC;IAC5E;IAEA,MAAMC,UAAU,MAAMnB,eAAe,MAAMgB,QAAQA,MAAM,OAAOI;QAC9D,MAAMC,SAAkC;YACtC,GAAGD,MAAM;YACT,GAAGb,KAAKe,WAAW;YACnBV,IAAIQ,MAAM,CAAC,KAAK;QAClB;QACA,sEAAsE;QACtE,wEAAwE;QACxE,2BAA2B;QAC3B,MAAMG,YAAYrB,kBAAkBG,SAASC,QAAQe;QACrD,MAAMlB,QAAQE,SAASG,WAAWe,WAAW;YAAEC,UAAUJ;QAAO;QAChE,OAAOG;IACT;IAEA,OAAOhB,KAAKkB,SAAS,KAAK,QAAQ,OAAON;AAC3C"}

package/dist/utilities/writeErrors.d.ts

@@ -0,0 +1,11 @@
+import type { PayloadRequest } from 'payload';
+import { ValidationError } from 'payload';
+/**
+ * The error Payload's other adapters raise for a duplicate key: a
+ * `ValidationError` naming the field, which core turns into a 400 with a
+ * field-level "Value must be unique" message.
+ */
+export declare function mustBeUniqueError(path: string, collection: string, req: Partial<PayloadRequest> | undefined): ValidationError;
+/** Re-throw a unique-field violation in Payload's terms; pass anything else through. */
+export declare function rethrowUniqueViolation(err: unknown, collection: string, req: Partial<PayloadRequest> | undefined): void;
+//# sourceMappingURL=writeErrors.d.ts.map

package/dist/utilities/writeErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeErrors.d.ts","sourceRoot":"","sources":["../../src/utilities/writeErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAIzC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,GACvC,eAAe,CAcjB;AAED,wFAAwF;AACxF,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,GACvC,IAAI,CAIN"}

package/dist/utilities/writeErrors.js

@@ -0,0 +1,27 @@
+import { ValidationError } from 'payload';
+import { UniqueViolationError } from './writeItems.js';
+/**
+ * The error Payload's other adapters raise for a duplicate key: a
+ * `ValidationError` naming the field, which core turns into a 400 with a
+ * field-level "Value must be unique" message.
+ */ export function mustBeUniqueError(path, collection, req) {
+    return new ValidationError({
+        collection,
+        errors: [
+            {
+                message: req?.t ? req.t('error:valueMustBeUnique') : 'Value must be unique',
+                path
+            }
+        ],
+        ...req ? {
+            req
+        } : {}
+    }, req?.t);
+}
+/** Re-throw a unique-field violation in Payload's terms; pass anything else through. */ export function rethrowUniqueViolation(err, collection, req) {
+    if (err instanceof UniqueViolationError) {
+        throw mustBeUniqueError(err.path, collection, req);
+    }
+}
+
+//# sourceMappingURL=writeErrors.js.map

package/dist/utilities/writeErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/writeErrors.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { ValidationError } from 'payload'\n\nimport { UniqueViolationError } from './writeItems.js'\n\n/**\n * The error Payload's other adapters raise for a duplicate key: a\n * `ValidationError` naming the field, which core turns into a 400 with a\n * field-level \"Value must be unique\" message.\n */\nexport function mustBeUniqueError(\n  path: string,\n  collection: string,\n  req: Partial<PayloadRequest> | undefined,\n): ValidationError {\n  return new ValidationError(\n    {\n      collection,\n      errors: [\n        {\n          message: req?.t ? req.t('error:valueMustBeUnique') : 'Value must be unique',\n          path,\n        },\n      ],\n      ...(req ? { req } : {}),\n    },\n    req?.t,\n  )\n}\n\n/** Re-throw a unique-field violation in Payload's terms; pass anything else through. */\nexport function rethrowUniqueViolation(\n  err: unknown,\n  collection: string,\n  req: Partial<PayloadRequest> | undefined,\n): void {\n  if (err instanceof UniqueViolationError) {\n    throw mustBeUniqueError(err.path, collection, req)\n  }\n}\n"],"names":["ValidationError","UniqueViolationError","mustBeUniqueError","path","collection","req","errors","message","t","rethrowUniqueViolation","err"],"mappings":"AAEA,SAASA,eAAe,QAAQ,UAAS;AAEzC,SAASC,oBAAoB,QAAQ,kBAAiB;AAEtD;;;;CAIC,GACD,OAAO,SAASC,kBACdC,IAAY,EACZC,UAAkB,EAClBC,GAAwC;IAExC,OAAO,IAAIL,gBACT;QACEI;QACAE,QAAQ;YACN;gBACEC,SAASF,KAAKG,IAAIH,IAAIG,CAAC,CAAC,6BAA6B;gBACrDL;YACF;SACD;QACD,GAAIE,MAAM;YAAEA;QAAI,IAAI,CAAC,CAAC;IACxB,GACAA,KAAKG;AAET;AAEA,sFAAsF,GACtF,OAAO,SAASC,uBACdC,GAAY,EACZN,UAAkB,EAClBC,GAAwC;IAExC,IAAIK,eAAeT,sBAAsB;QACvC,MAAMC,kBAAkBQ,IAAIP,IAAI,EAAEC,YAAYC;IAChD;AACF"}

package/dist/utilities/writeItems.d.ts

@@ -0,0 +1,124 @@
+import type { DynamoAdapter } from '../types.js';
+import { type UniqueGuard } from './uniqueGuards.js';
+/**
+ * The single place the adapter's methods mutate the table. Every `create*`,
+ * `update*`, `upsert` and `delete*` method hands its finished document (or
+ * the id to remove) to one of the helpers below instead of building its own
+ * DynamoDB command.
+ *
+ * Keeping writes behind one module means the row's physical shape — the
+ * `pk`/`sk` composite key, the `_rev` revision counter, value normalization,
+ * and any future index attributes — is derived in exactly one spot
+ * (`toItem`), and anything that needs to see every mutation (e.g. buffering
+ * writes for a Payload-level transaction) has one seam to hook into.
+ *
+ * Three guarantees are enforced here, each by a condition DynamoDB checks
+ * atomically with the write:
+ *
+ *  - **Insert-only** (`mustNotExist`): a new document can't replace one that
+ *    already has its id.
+ *  - **No lost updates** (`replaces`): a read-merge-write only lands if the
+ *    row is still at the revision that was read. See `stripInternalKeys`.
+ *  - **Unique fields** (`unique`): the document and a guard row per unique
+ *    value are written in one transaction. See `uniqueGuards`.
+ *
+ * Callers stay responsible for everything Payload-shaped: locating the
+ * target, merging the patch, defaulting timestamps, and projecting against
+ * the collection/global schema. These helpers only persist what they're
+ * given.
+ *
+ * Not routed through here: `scrubUnknownFields`, a one-shot maintenance pass
+ * that re-puts raw rows at their original keys without normalizing them.
+ */
+/**
+ * How many single-row writes a bulk operation keeps in flight at once.
+ * Matches `BatchWriteItem`'s page size and stays well under the SDK's default
+ * socket pool (50), so a large `deleteMany` / `updateMany` doesn't starve
+ * every other request the process is making.
+ */
+export declare const WRITE_CONCURRENCY = 25;
+/**
+ * The write's own precondition didn't hold: the id was already taken
+ * (`mustNotExist`), or the row changed since it was read (`replaces`).
+ */
+export declare class ConditionFailedError extends Error {
+    constructor();
+}
+/** Another document already holds this value of a unique field. */
+export declare class UniqueViolationError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/**
+ * True when `err` means "this write's precondition didn't hold" — the signal
+ * a read-merge-write loop retries on, and that `create` reports as a
+ * duplicate id.
+ */
+export declare function isConditionalCheckFailed(err: unknown): boolean;
+/**
+ * Claim one unique guard for `owner` outside of a document write (used by
+ * `backfillUniqueGuards`). Returns `null` when the guard is now the owner's,
+ * or the id of the document that already holds it.
+ */
+export declare function claimGuard(adapter: DynamoAdapter, guard: UniqueGuard, owner: string): Promise<null | string>;
+export type PutOptions = {
+    /** Insert-only: fail if a row already occupies this id. */
+    mustNotExist?: boolean;
+    /**
+     * The row, as read, that this write was merged onto. The write lands only
+     * if the stored row is still at that revision.
+     */
+    replaces?: Record<string, unknown>;
+    /** Enforce the unique fields of this collection for `doc`. */
+    unique?: {
+        collection: string;
+    };
+};
+/**
+ * Write `doc` as the full row at (`partition`, `doc.id`). The adapter's
+ * update paths are read-merge-write, so this is the write half of both
+ * inserts and updates.
+ *
+ * Throws `ConditionFailedError` when `mustNotExist` / `replaces` doesn't
+ * hold, and `UniqueViolationError` when a unique value is taken.
+ */
+export declare function putItem(adapter: DynamoAdapter, partition: string, doc: Record<string, unknown>, options?: PutOptions): Promise<void>;
+export type DeleteOptions = {
+    returnOld?: boolean;
+    /**
+     * The document being deleted, in a collection with unique fields: its
+     * guards are released in the same transaction.
+     */
+    unique?: {
+        collection: string;
+        doc: Record<string, unknown>;
+    };
+};
+/**
+ * Delete the row at (`partition`, `id`). With `returnOld`, the deleted row
+ * comes back (internal keys stripped) so callers can delete and capture the
+ * document in one round trip; `null` if no row existed. Without it the
+ * result is always `null`.
+ */
+export declare function deleteItem(adapter: DynamoAdapter, partition: string, id: unknown, options?: DeleteOptions): Promise<null | Record<string, unknown>>;
+/**
+ * Delete several rows from one partition, one request each, at most
+ * `WRITE_CONCURRENCY` in flight at a time. Pass `uniqueCollection` when the
+ * rows belong to a collection whose unique guards must be released with them.
+ *
+ * `BatchWriteItem` could cut the request count (25 deletes per call) but has
+ * partial-failure semantics that need retry logic — out of scope until we
+ * wire up retries. Bounded single deletes are simple and correct.
+ */
+export declare function deleteItems(adapter: DynamoAdapter, partition: string, rows: Record<string, unknown>[], uniqueCollection?: string): Promise<void>;
+/**
+ * Insert `doc` as a version row and, in the same `TransactWriteItems` call,
+ * clear `latest` on the row that held it before. If a crash occurs mid-flow
+ * neither mutation lands, so a parent never ends up with two `latest=true`
+ * rows or zero.
+ *
+ * `previousLatest` is the row the caller found holding `latest=true`, or
+ * `null` when this is the first version.
+ */
+export declare function putVersionAsLatest(adapter: DynamoAdapter, partition: string, doc: Record<string, unknown>, previousLatest: null | Record<string, unknown>): Promise<void>;
+//# sourceMappingURL=writeItems.d.ts.map

package/dist/utilities/writeItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeItems.d.ts","sourceRoot":"","sources":["../../src/utilities/writeItems.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKhD,OAAO,EAAa,KAAK,WAAW,EAAmB,MAAM,mBAAmB,CAAA;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAA;AAEnC;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;;CAK9C;AAED,mEAAmE;AACnE,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;gBAET,IAAI,EAAE,MAAM;CAKzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAK9D;AA+ED;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,CAkBxB;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,2DAA2D;IAC3D,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,8DAA8D;IAC9D,MAAM,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CAChC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CA8Ff;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAA;CAC9D,CAAA;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,OAAO,EACX,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAwCzC;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC/B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CASf;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,cAAc,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAqCf"}

package/dist/utilities/writeItems.js

@@ -0,0 +1,383 @@
+import { DeleteCommand, GetCommand, PutCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { APIError } from 'payload';
+import { mapWithConcurrency } from './mapWithConcurrency.js';
+import { normalizeForDynamo } from './normalizeForDynamo.js';
+import { revisionOf, stripInternalKeys } from './stripInternalKeys.js';
+import { sameGuard, uniqueGuardsFor } from './uniqueGuards.js';
+/**
+ * The single place the adapter's methods mutate the table. Every `create*`,
+ * `update*`, `upsert` and `delete*` method hands its finished document (or
+ * the id to remove) to one of the helpers below instead of building its own
+ * DynamoDB command.
+ *
+ * Keeping writes behind one module means the row's physical shape — the
+ * `pk`/`sk` composite key, the `_rev` revision counter, value normalization,
+ * and any future index attributes — is derived in exactly one spot
+ * (`toItem`), and anything that needs to see every mutation (e.g. buffering
+ * writes for a Payload-level transaction) has one seam to hook into.
+ *
+ * Three guarantees are enforced here, each by a condition DynamoDB checks
+ * atomically with the write:
+ *
+ *  - **Insert-only** (`mustNotExist`): a new document can't replace one that
+ *    already has its id.
+ *  - **No lost updates** (`replaces`): a read-merge-write only lands if the
+ *    row is still at the revision that was read. See `stripInternalKeys`.
+ *  - **Unique fields** (`unique`): the document and a guard row per unique
+ *    value are written in one transaction. See `uniqueGuards`.
+ *
+ * Callers stay responsible for everything Payload-shaped: locating the
+ * target, merging the patch, defaulting timestamps, and projecting against
+ * the collection/global schema. These helpers only persist what they're
+ * given.
+ *
+ * Not routed through here: `scrubUnknownFields`, a one-shot maintenance pass
+ * that re-puts raw rows at their original keys without normalizing them.
+ */ /**
+ * How many single-row writes a bulk operation keeps in flight at once.
+ * Matches `BatchWriteItem`'s page size and stays well under the SDK's default
+ * socket pool (50), so a large `deleteMany` / `updateMany` doesn't starve
+ * every other request the process is making.
+ */ export const WRITE_CONCURRENCY = 25;
+/**
+ * The write's own precondition didn't hold: the id was already taken
+ * (`mustNotExist`), or the row changed since it was read (`replaces`).
+ */ export class ConditionFailedError extends Error {
+    constructor(){
+        super('payload-ddb: write condition failed');
+        this.name = 'ConditionFailedError';
+    }
+}
+/** Another document already holds this value of a unique field. */ export class UniqueViolationError extends Error {
+    path;
+    constructor(path){
+        super(`payload-ddb: value of unique field "${path}" is already in use`);
+        this.name = 'UniqueViolationError';
+        this.path = path;
+    }
+}
+/**
+ * True when `err` means "this write's precondition didn't hold" — the signal
+ * a read-merge-write loop retries on, and that `create` reports as a
+ * duplicate id.
+ */ export function isConditionalCheckFailed(err) {
+    return err instanceof ConditionFailedError || err instanceof Error && err.name === 'ConditionalCheckFailedException';
+}
+const ITEM_TOO_LARGE = /item size.*exceeded/i;
+function cancellationReasons(err) {
+    if (!(err instanceof Error) || err.name !== 'TransactionCanceledException') return null;
+    const reasons = err.CancellationReasons;
+    return Array.isArray(reasons) ? reasons : [];
+}
+/**
+ * DynamoDB caps a single item at 400 KB and reports a breach as a bare
+ * `ValidationException` (or, inside a transaction, as one of the
+ * cancellation reasons). Re-throw it as an error that says which document
+ * was too big and why, and that Payload will show to the API caller.
+ */ function rethrowIfItemTooLarge(err, partition, id) {
+    if (!(err instanceof Error)) return;
+    const tooLarge = ITEM_TOO_LARGE.test(err.message) || (cancellationReasons(err) ?? []).some((reason)=>ITEM_TOO_LARGE.test(reason?.Message ?? ''));
+    if (!tooLarge) return;
+    throw new APIError(`payload-ddb: document "${String(id)}" in "${partition}" is too large to store. ` + 'DynamoDB limits a single item to 400 KB, including every field and (for versions) the full snapshot.', 413, null, true);
+}
+function requireDocClient(adapter) {
+    const docClient = adapter.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    return docClient;
+}
+/**
+ * Composite key for a row. `sk` is always the stringified `id` — collections
+ * with Number ids keep the original type on the `id` attribute while the
+ * sort key stays String (see `ensureTable`).
+ */ function keyFor(partition, id) {
+    return {
+        pk: partition,
+        sk: String(id)
+    };
+}
+/**
+ * Turn a Payload-facing document into the row we store: normalized values
+ * plus the internal attributes, keyed by the document's own `id`.
+ * The inverse of `stripInternalKeys`.
+ */ function toItem(partition, doc, revision) {
+    return normalizeForDynamo({
+        ...doc,
+        ...keyFor(partition, doc['id']),
+        _rev: revision
+    });
+}
+/** "This guard row is free, or it is already mine." */ function ownedBy(owner) {
+    return {
+        ConditionExpression: 'attribute_not_exists(pk) OR #owner = :owner',
+        ExpressionAttributeNames: {
+            '#owner': 'owner'
+        },
+        ExpressionAttributeValues: {
+            ':owner': owner
+        }
+    };
+}
+/**
+ * Claim one unique guard for `owner` outside of a document write (used by
+ * `backfillUniqueGuards`). Returns `null` when the guard is now the owner's,
+ * or the id of the document that already holds it.
+ */ export async function claimGuard(adapter, guard, owner) {
+    const docClient = requireDocClient(adapter);
+    try {
+        await docClient.send(new PutCommand({
+            TableName: adapter.tableName,
+            Item: {
+                ...guard.key,
+                owner
+            },
+            ...ownedBy(owner)
+        }));
+        return null;
+    } catch (err) {
+        if (!(err instanceof Error) || err.name !== 'ConditionalCheckFailedException') throw err;
+        const held = await docClient.send(new GetCommand({
+            TableName: adapter.tableName,
+            Key: guard.key,
+            ConsistentRead: true
+        }));
+        return String(held.Item?.['owner'] ?? 'unknown');
+    }
+}
+/**
+ * Write `doc` as the full row at (`partition`, `doc.id`). The adapter's
+ * update paths are read-merge-write, so this is the write half of both
+ * inserts and updates.
+ *
+ * Throws `ConditionFailedError` when `mustNotExist` / `replaces` doesn't
+ * hold, and `UniqueViolationError` when a unique value is taken.
+ */ export async function putItem(adapter, partition, doc, options = {}) {
+    const docClient = requireDocClient(adapter);
+    const { mustNotExist, replaces, unique } = options;
+    const previousRevision = replaces ? revisionOf(replaces) : undefined;
+    const item = toItem(partition, doc, (previousRevision ?? 0) + 1);
+    let condition = {};
+    if (mustNotExist) {
+        // Every row carries `pk`, so "no `pk` attribute" means "no row here".
+        condition = {
+            ConditionExpression: 'attribute_not_exists(pk)'
+        };
+    } else if (replaces && previousRevision === undefined) {
+        // Read from a row written before revisions existed: it must still be
+        // there, and nobody may have given it a revision in the meantime.
+        condition = {
+            ConditionExpression: 'attribute_exists(pk) AND attribute_not_exists(#rev)',
+            ExpressionAttributeNames: {
+                '#rev': '_rev'
+            }
+        };
+    } else if (replaces) {
+        condition = {
+            ConditionExpression: '#rev = :rev',
+            ExpressionAttributeNames: {
+                '#rev': '_rev'
+            },
+            ExpressionAttributeValues: {
+                ':rev': previousRevision
+            }
+        };
+    }
+    const guards = unique ? uniqueGuardsFor(adapter, unique.collection, partition, doc) : [];
+    // Guards for values this document no longer has. Those are released, but
+    // only if they're ours: a row written before guards existed may share a
+    // value with the document that later claimed it.
+    let released = unique && replaces ? uniqueGuardsFor(adapter, unique.collection, partition, replaces).filter((old)=>!guards.some((current)=>sameGuard(current, old))) : [];
+    try {
+        if (guards.length === 0 && released.length === 0) {
+            await docClient.send(new PutCommand({
+                TableName: adapter.tableName,
+                Item: item,
+                ...condition
+            }));
+            return;
+        }
+        const owner = String(doc['id']);
+        const mine = ownedBy(owner);
+        // At most two passes: if a released guard turns out to belong to someone
+        // else, leave it alone and write the rest.
+        for(;;){
+            const transactItems = [
+                {
+                    Put: {
+                        TableName: adapter.tableName,
+                        Item: item,
+                        ...condition
+                    }
+                },
+                // Re-asserted on every write, not only when a value changes, so
+                // documents that predate guards pick theirs up as they're edited.
+                ...guards.map((guard)=>({
+                        Put: {
+                            TableName: adapter.tableName,
+                            Item: {
+                                ...guard.key,
+                                owner
+                            },
+                            ...mine
+                        }
+                    })),
+                ...released.map((guard)=>({
+                        Delete: {
+                            TableName: adapter.tableName,
+                            Key: guard.key,
+                            ...mine
+                        }
+                    }))
+            ];
+            try {
+                await docClient.send(new TransactWriteCommand({
+                    TransactItems: transactItems
+                }));
+                return;
+            } catch (err) {
+                const reasons = cancellationReasons(err);
+                if (!reasons) throw err;
+                const failed = (index)=>{
+                    const code = reasons[index]?.Code;
+                    return code !== undefined && code !== 'None';
+                };
+                if (failed(0)) throw new ConditionFailedError();
+                const taken = guards.findIndex((_, index)=>failed(1 + index));
+                if (taken !== -1) {
+                    // A clash with a concurrent transaction on the same guard isn't
+                    // proof the value is taken — let the caller retry and find out.
+                    if (reasons[1 + taken]?.Code === 'TransactionConflict') throw new ConditionFailedError();
+                    throw new UniqueViolationError(guards[taken].path);
+                }
+                const kept = released.filter((_, index)=>!failed(1 + guards.length + index));
+                if (kept.length === released.length) throw err;
+                released = kept;
+            }
+        }
+    } catch (err) {
+        if (err instanceof Error && err.name === 'ConditionalCheckFailedException') {
+            throw new ConditionFailedError();
+        }
+        rethrowIfItemTooLarge(err, partition, doc['id']);
+        throw err;
+    }
+}
+/**
+ * Delete the row at (`partition`, `id`). With `returnOld`, the deleted row
+ * comes back (internal keys stripped) so callers can delete and capture the
+ * document in one round trip; `null` if no row existed. Without it the
+ * result is always `null`.
+ */ export async function deleteItem(adapter, partition, id, options = {}) {
+    const docClient = requireDocClient(adapter);
+    const key = keyFor(partition, id);
+    const guards = options.unique ? uniqueGuardsFor(adapter, options.unique.collection, partition, options.unique.doc) : [];
+    if (guards.length > 0) {
+        const mine = ownedBy(String(id));
+        try {
+            await docClient.send(new TransactWriteCommand({
+                TransactItems: [
+                    {
+                        Delete: {
+                            TableName: adapter.tableName,
+                            Key: key
+                        }
+                    },
+                    ...guards.map((guard)=>({
+                            Delete: {
+                                TableName: adapter.tableName,
+                                Key: guard.key,
+                                ...mine
+                            }
+                        }))
+                ]
+            }));
+        } catch (err) {
+            // A guard that belongs to another document (possible for rows that
+            // predate guards) cancels the transaction. The document must still go,
+            // so delete it alone and leave that guard with its owner.
+            if (!cancellationReasons(err)) throw err;
+            await docClient.send(new DeleteCommand({
+                TableName: adapter.tableName,
+                Key: key
+            }));
+        }
+        return options.returnOld ? options.unique.doc : null;
+    }
+    const result = await docClient.send(new DeleteCommand({
+        TableName: adapter.tableName,
+        Key: key,
+        ...options.returnOld ? {
+            ReturnValues: 'ALL_OLD'
+        } : {}
+    }));
+    return options.returnOld && result.Attributes ? stripInternalKeys(result.Attributes) : null;
+}
+/**
+ * Delete several rows from one partition, one request each, at most
+ * `WRITE_CONCURRENCY` in flight at a time. Pass `uniqueCollection` when the
+ * rows belong to a collection whose unique guards must be released with them.
+ *
+ * `BatchWriteItem` could cut the request count (25 deletes per call) but has
+ * partial-failure semantics that need retry logic — out of scope until we
+ * wire up retries. Bounded single deletes are simple and correct.
+ */ export async function deleteItems(adapter, partition, rows, uniqueCollection) {
+    await mapWithConcurrency(rows, WRITE_CONCURRENCY, (row)=>deleteItem(adapter, partition, row['id'], uniqueCollection ? {
+            unique: {
+                collection: uniqueCollection,
+                doc: row
+            }
+        } : {}));
+}
+/**
+ * Insert `doc` as a version row and, in the same `TransactWriteItems` call,
+ * clear `latest` on the row that held it before. If a crash occurs mid-flow
+ * neither mutation lands, so a parent never ends up with two `latest=true`
+ * rows or zero.
+ *
+ * `previousLatest` is the row the caller found holding `latest=true`, or
+ * `null` when this is the first version.
+ */ export async function putVersionAsLatest(adapter, partition, doc, previousLatest) {
+    const docClient = requireDocClient(adapter);
+    const transactItems = [];
+    if (previousLatest) {
+        transactItems.push({
+            Update: {
+                TableName: adapter.tableName,
+                Key: keyFor(partition, previousLatest['id']),
+                // Bumping `_rev` along with the flip means a read-merge-write that
+                // read this row while it was still latest can't write `latest` back.
+                UpdateExpression: 'SET #latest = :false ADD #rev :one',
+                ExpressionAttributeNames: {
+                    '#latest': 'latest',
+                    '#rev': '_rev'
+                },
+                ExpressionAttributeValues: {
+                    ':false': false,
+                    ':one': 1
+                },
+                // Fail the whole transaction if the previous row was deleted between
+                // the caller's 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: adapter.tableName,
+            Item: toItem(partition, doc, 1)
+        }
+    });
+    try {
+        await docClient.send(new TransactWriteCommand({
+            TransactItems: transactItems
+        }));
+    } catch (err) {
+        rethrowIfItemTooLarge(err, partition, doc['id']);
+        throw err;
+    }
+}
+
+//# sourceMappingURL=writeItems.js.map