@open-aih/payload-ddb 3.1.0

package/dist/index.js

@@ -0,0 +1,98 @@
+import { createDatabaseAdapter } from 'payload';
+import { connect } from './connect.js';
+import { count } from './count.js';
+import { countGlobalVersions } from './countGlobalVersions.js';
+import { countVersions } from './countVersions.js';
+import { create } from './create.js';
+import { createGlobal } from './createGlobal.js';
+import { createGlobalVersion } from './createGlobalVersion.js';
+import { createVersion } from './createVersion.js';
+import { deleteMany } from './deleteMany.js';
+import { deleteOne } from './deleteOne.js';
+import { deleteVersions } from './deleteVersions.js';
+import { destroy } from './destroy.js';
+import { find } from './find.js';
+import { findDistinct } from './findDistinct.js';
+import { findGlobal } from './findGlobal.js';
+import { findGlobalVersions } from './findGlobalVersions.js';
+import { findOne } from './findOne.js';
+import { findVersions } from './findVersions.js';
+import { init } from './init.js';
+import { queryDrafts } from './queryDrafts.js';
+import { updateGlobal } from './updateGlobal.js';
+import { updateGlobalVersion } from './updateGlobalVersion.js';
+import { updateMany } from './updateMany.js';
+import { updateOne } from './updateOne.js';
+import { updateVersion } from './updateVersion.js';
+import { upsert } from './upsert.js';
+export { scrubUnknownFields } from './utilities/scrubUnknownFields.js';
+const NAME = 'dynamodb';
+const PACKAGE_NAME = '@aih-software/payload-ddb';
+const DEFAULT_TABLE_NAME = 'payload';
+export function dynamoAdapter(args = {}) {
+    function adapterInit({ payload }) {
+        const tableName = args.tableName ?? DEFAULT_TABLE_NAME;
+        const resolvePartition = (slug)=>slug;
+        const resolveVersionsPartition = (slug)=>`${slug}_versions`;
+        return createDatabaseAdapter({
+            name: NAME,
+            packageName: PACKAGE_NAME,
+            defaultIDType: 'text',
+            payload,
+            // ----- adapter-specific state -----
+            clientConfig: args.clientConfig ?? {},
+            translateConfig: args.translateConfig ?? {
+                marshallOptions: {
+                    removeUndefinedValues: true,
+                    convertClassInstanceToMap: true
+                }
+            },
+            client: args.client,
+            docClient: undefined,
+            ownsClient: !args.client,
+            tableName,
+            ensureTables: args.ensureTables ?? false,
+            resolvePartition,
+            resolveVersionsPartition,
+            // ----- lifecycle -----
+            connect,
+            destroy,
+            init,
+            // ----- transactions (no-op until DynamoDB transact-writes are wired) -----
+            beginTransaction: async ()=>null,
+            commitTransaction: async ()=>{},
+            rollbackTransaction: async ()=>{},
+            // ----- methods -----
+            count,
+            countGlobalVersions,
+            countVersions,
+            create,
+            createGlobal,
+            createGlobalVersion,
+            createVersion,
+            deleteMany,
+            deleteOne,
+            deleteVersions,
+            find,
+            findDistinct,
+            findGlobal,
+            findGlobalVersions,
+            findOne,
+            findVersions,
+            queryDrafts,
+            updateGlobal,
+            updateGlobalVersion,
+            updateMany,
+            updateOne,
+            updateVersion,
+            upsert
+        });
+    }
+    return {
+        name: NAME,
+        defaultIDType: 'text',
+        init: adapterInit
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { DatabaseAdapterObj, Payload } from 'payload'\n\nimport { createDatabaseAdapter } from 'payload'\n\nimport type { Args, DynamoAdapter } from './types.js'\n\nimport { connect } from './connect.js'\nimport { count } from './count.js'\nimport { countGlobalVersions } from './countGlobalVersions.js'\nimport { countVersions } from './countVersions.js'\nimport { create } from './create.js'\nimport { createGlobal } from './createGlobal.js'\nimport { createGlobalVersion } from './createGlobalVersion.js'\nimport { createVersion } from './createVersion.js'\nimport { deleteMany } from './deleteMany.js'\nimport { deleteOne } from './deleteOne.js'\nimport { deleteVersions } from './deleteVersions.js'\nimport { destroy } from './destroy.js'\nimport { find } from './find.js'\nimport { findDistinct } from './findDistinct.js'\nimport { findGlobal } from './findGlobal.js'\nimport { findGlobalVersions } from './findGlobalVersions.js'\nimport { findOne } from './findOne.js'\nimport { findVersions } from './findVersions.js'\nimport { init } from './init.js'\nimport { queryDrafts } from './queryDrafts.js'\nimport { updateGlobal } from './updateGlobal.js'\nimport { updateGlobalVersion } from './updateGlobalVersion.js'\nimport { updateMany } from './updateMany.js'\nimport { updateOne } from './updateOne.js'\nimport { updateVersion } from './updateVersion.js'\nimport { upsert } from './upsert.js'\n\nexport type { Args, DynamoAdapter } from './types.js'\nexport { scrubUnknownFields } from './utilities/scrubUnknownFields.js'\nexport type { ScrubReport } from './utilities/scrubUnknownFields.js'\n\nconst NAME = 'dynamodb'\nconst PACKAGE_NAME = '@aih-software/payload-ddb'\nconst DEFAULT_TABLE_NAME = 'payload'\n\nexport function dynamoAdapter(args: Args = {}): DatabaseAdapterObj<DynamoAdapter> {\n  function adapterInit({ payload }: { payload: Payload }): DynamoAdapter {\n    const tableName = args.tableName ?? DEFAULT_TABLE_NAME\n\n    const resolvePartition = (slug: string): string => slug\n    const resolveVersionsPartition = (slug: string): string => `${slug}_versions`\n\n    return createDatabaseAdapter<DynamoAdapter>({\n      name: NAME,\n      packageName: PACKAGE_NAME,\n      defaultIDType: 'text',\n      payload,\n\n      // ----- adapter-specific state -----\n      clientConfig: args.clientConfig ?? {},\n      translateConfig: args.translateConfig ?? {\n        marshallOptions: {\n          removeUndefinedValues: true,\n          convertClassInstanceToMap: true,\n        },\n      },\n      client: args.client,\n      docClient: undefined,\n      ownsClient: !args.client,\n      tableName,\n      ensureTables: args.ensureTables ?? false,\n      resolvePartition,\n      resolveVersionsPartition,\n\n      // ----- lifecycle -----\n      connect,\n      destroy,\n      init,\n\n      // ----- transactions (no-op until DynamoDB transact-writes are wired) -----\n      beginTransaction: async () => null,\n      commitTransaction: async () => {},\n      rollbackTransaction: async () => {},\n\n      // ----- methods -----\n      count,\n      countGlobalVersions,\n      countVersions,\n      create,\n      createGlobal,\n      createGlobalVersion,\n      createVersion,\n      deleteMany,\n      deleteOne,\n      deleteVersions,\n      find,\n      findDistinct,\n      findGlobal,\n      findGlobalVersions,\n      findOne,\n      findVersions,\n      queryDrafts,\n      updateGlobal,\n      updateGlobalVersion,\n      updateMany,\n      updateOne,\n      updateVersion,\n      upsert,\n    })\n  }\n\n  return {\n    name: NAME,\n    defaultIDType: 'text',\n    init: adapterInit,\n  }\n}\n"],"names":["createDatabaseAdapter","connect","count","countGlobalVersions","countVersions","create","createGlobal","createGlobalVersion","createVersion","deleteMany","deleteOne","deleteVersions","destroy","find","findDistinct","findGlobal","findGlobalVersions","findOne","findVersions","init","queryDrafts","updateGlobal","updateGlobalVersion","updateMany","updateOne","updateVersion","upsert","scrubUnknownFields","NAME","PACKAGE_NAME","DEFAULT_TABLE_NAME","dynamoAdapter","args","adapterInit","payload","tableName","resolvePartition","slug","resolveVersionsPartition","name","packageName","defaultIDType","clientConfig","translateConfig","marshallOptions","removeUndefinedValues","convertClassInstanceToMap","client","docClient","undefined","ownsClient","ensureTables","beginTransaction","commitTransaction","rollbackTransaction"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,UAAS;AAI/C,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,KAAK,QAAQ,aAAY;AAClC,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,MAAM,QAAQ,cAAa;AACpC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,cAAc,QAAQ,sBAAqB;AACpD,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,MAAM,QAAQ,cAAa;AAGpC,SAASC,kBAAkB,QAAQ,oCAAmC;AAGtE,MAAMC,OAAO;AACb,MAAMC,eAAe;AACrB,MAAMC,qBAAqB;AAE3B,OAAO,SAASC,cAAcC,OAAa,CAAC,CAAC;IAC3C,SAASC,YAAY,EAAEC,OAAO,EAAwB;QACpD,MAAMC,YAAYH,KAAKG,SAAS,IAAIL;QAEpC,MAAMM,mBAAmB,CAACC,OAAyBA;QACnD,MAAMC,2BAA2B,CAACD,OAAyB,GAAGA,KAAK,SAAS,CAAC;QAE7E,OAAOrC,sBAAqC;YAC1CuC,MAAMX;YACNY,aAAaX;YACbY,eAAe;YACfP;YAEA,qCAAqC;YACrCQ,cAAcV,KAAKU,YAAY,IAAI,CAAC;YACpCC,iBAAiBX,KAAKW,eAAe,IAAI;gBACvCC,iBAAiB;oBACfC,uBAAuB;oBACvBC,2BAA2B;gBAC7B;YACF;YACAC,QAAQf,KAAKe,MAAM;YACnBC,WAAWC;YACXC,YAAY,CAAClB,KAAKe,MAAM;YACxBZ;YACAgB,cAAcnB,KAAKmB,YAAY,IAAI;YACnCf;YACAE;YAEA,wBAAwB;YACxBrC;YACAW;YACAO;YAEA,4EAA4E;YAC5EiC,kBAAkB,UAAY;YAC9BC,mBAAmB,WAAa;YAChCC,qBAAqB,WAAa;YAElC,sBAAsB;YACtBpD;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAE;YACAC;YACAC;YACAC;YACAC;YACAC;YACAE;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;QACF;IACF;IAEA,OAAO;QACLa,MAAMX;QACNa,eAAe;QACftB,MAAMc;IACR;AACF"}

package/dist/init.d.ts

@@ -0,0 +1,16 @@
+import type { Init } from 'payload';
+/**
+ * Lifecycle hook called once after the factory `init` returns the adapter.
+ * Payload's order is `init → connect`, so we call `ensureConnected` here
+ * to populate the client before any DynamoDB operations.
+ *
+ * In single-table mode, every collection, global, and versions stream lives
+ * under a different `pk` value in the same physical table — so provisioning
+ * just means making sure that one table exists.
+ *
+ * Provisioning is opt-in because real deployments typically manage tables
+ * out-of-band (CDK, Terraform, CloudFormation). It's a meaningful dev-loop
+ * convenience for local testing against DynamoDB Local.
+ */
+export declare const init: Init;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAOnC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,EAAE,IAWlB,CAAA"}

package/dist/init.js

@@ -0,0 +1,24 @@
+import { ensureConnected } from './utilities/ensureConnected.js';
+import { ensureTable } from './utilities/ensureTable.js';
+/**
+ * Lifecycle hook called once after the factory `init` returns the adapter.
+ * Payload's order is `init → connect`, so we call `ensureConnected` here
+ * to populate the client before any DynamoDB operations.
+ *
+ * In single-table mode, every collection, global, and versions stream lives
+ * under a different `pk` value in the same physical table — so provisioning
+ * just means making sure that one table exists.
+ *
+ * Provisioning is opt-in because real deployments typically manage tables
+ * out-of-band (CDK, Terraform, CloudFormation). It's a meaningful dev-loop
+ * convenience for local testing against DynamoDB Local.
+ */ export const init = async function() {
+    ensureConnected(this);
+    this.payload.logger.debug(`payload-ddb: init using table \`${this.tableName}\`; ensureTables=${this.ensureTables}`);
+    if (this.ensureTables) {
+        await ensureTable(this, this.tableName);
+        this.payload.logger.debug('payload-ddb: table ready');
+    }
+};
+
+//# sourceMappingURL=init.js.map

package/dist/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/init.ts"],"sourcesContent":["import type { Init } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { ensureConnected } from './utilities/ensureConnected.js'\nimport { ensureTable } from './utilities/ensureTable.js'\n\n/**\n * Lifecycle hook called once after the factory `init` returns the adapter.\n * Payload's order is `init → connect`, so we call `ensureConnected` here\n * to populate the client before any DynamoDB operations.\n *\n * In single-table mode, every collection, global, and versions stream lives\n * under a different `pk` value in the same physical table — so provisioning\n * just means making sure that one table exists.\n *\n * Provisioning is opt-in because real deployments typically manage tables\n * out-of-band (CDK, Terraform, CloudFormation). It's a meaningful dev-loop\n * convenience for local testing against DynamoDB Local.\n */\nexport const init: Init = async function (this: DynamoAdapter) {\n  ensureConnected(this)\n\n  this.payload.logger.debug(\n    `payload-ddb: init using table \\`${this.tableName}\\`; ensureTables=${this.ensureTables}`,\n  )\n\n  if (this.ensureTables) {\n    await ensureTable(this, this.tableName)\n    this.payload.logger.debug('payload-ddb: table ready')\n  }\n}\n"],"names":["ensureConnected","ensureTable","init","payload","logger","debug","tableName","ensureTables"],"mappings":"AAIA,SAASA,eAAe,QAAQ,iCAAgC;AAChE,SAASC,WAAW,QAAQ,6BAA4B;AAExD;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,OAAa;IACxBF,gBAAgB,IAAI;IAEpB,IAAI,CAACG,OAAO,CAACC,MAAM,CAACC,KAAK,CACvB,CAAC,gCAAgC,EAAE,IAAI,CAACC,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAACC,YAAY,EAAE;IAG1F,IAAI,IAAI,CAACA,YAAY,EAAE;QACrB,MAAMN,YAAY,IAAI,EAAE,IAAI,CAACK,SAAS;QACtC,IAAI,CAACH,OAAO,CAACC,MAAM,CAACC,KAAK,CAAC;IAC5B;AACF,EAAC"}

package/dist/queryDrafts.d.ts

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

package/dist/queryDrafts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryDrafts.d.ts","sourceRoot":"","sources":["../src/queryDrafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,WAAW,EAAS,MAAM,SAAS,CAAA;AA6ChE,eAAO,MAAM,WAAW,EAAE,WAsEzB,CAAA"}

package/dist/queryDrafts.js

@@ -0,0 +1,103 @@
+import { applySorts } from './utilities/applySorts.js';
+import { matchesWhere } from './utilities/matchesWhere.js';
+import { queryMatching } from './utilities/queryMatching.js';
+/**
+ * Return the latest version of every doc as a paginated, doc-shaped result.
+ *
+ * Strategy:
+ *  1. Query the versions partition for `latest=true` rows (one per parent).
+ *  2. Project each row's `version` payload up to top-level so the result
+ *     looks like a doc — this lets the user's `where` / `sort` operate in
+ *     doc-field terms instead of `version.x` paths.
+ *  3. Fill in any docs that have a row in the *main* partition but no
+ *     `latest=true` version row. This covers two cases:
+ *     - documents created before versioning was enabled
+ *     - data orphaned by historical adapter bugs that dropped version writes
+ *  4. Apply `where` post-projection, sort, paginate.
+ *
+ * No `_status` filter is applied — `queryDrafts` returns the latest version
+ * regardless of draft/published state. Payload's higher-level code decides
+ * how to use the result.
+ */ // Payload core calls appendVersionToQueryKey before invoking queryDrafts,
+// transforming e.g. `{ slug: { equals: 'x' } }` → `{ 'version.slug': { equals: 'x' } }`.
+// But we project versionData flat to the top level, so those prefixed paths
+// never resolve. Strip the leading `version.` to match the projected shape.
+function stripVersionPrefix(where) {
+    if (!where || typeof where !== 'object') return where;
+    const result = {};
+    for (const [key, value] of Object.entries(where)){
+        if (key === 'and' || key === 'or') {
+            if (Array.isArray(value)) {
+                result[key] = value.map((sub)=>stripVersionPrefix(sub)).filter(Boolean);
+            }
+        } else {
+            result[key.startsWith('version.') ? key.slice(8) : key] = value;
+        }
+    }
+    return result;
+}
+export const queryDrafts = async function queryDrafts({ collection, limit = 10, page = 1, pagination = true, sort, where }) {
+    const versionsPartition = this.resolveVersionsPartition(collection);
+    const docsPartition = this.resolvePartition(collection);
+    const [latestRows, mainRows] = await Promise.all([
+        queryMatching(this, versionsPartition, {
+            latest: {
+                equals: true
+            }
+        }),
+        queryMatching(this, docsPartition, undefined)
+    ]);
+    // Latest-version rows win. We key by parent id so `mainRows` only fills
+    // entries that have no version backing.
+    const docsByParent = new Map();
+    for (const row of latestRows){
+        const version = row['version'];
+        if (!version || typeof version !== 'object') continue;
+        docsByParent.set(row['parent'], {
+            ...version,
+            id: row['parent']
+        });
+    }
+    for (const doc of mainRows){
+        if (!docsByParent.has(doc['id'])) {
+            docsByParent.set(doc['id'], doc);
+        }
+    }
+    const projected = [
+        ...docsByParent.values()
+    ];
+    // Payload core calls appendVersionToQueryKey before invoking queryDrafts,
+    // which transforms e.g. `{ slug: { equals: 'x' } }` into
+    // `{ 'version.slug': { equals: 'x' } }`. But we project versionData flat
+    // to the top level above, so those prefixed paths never resolve via
+    // getByPath. Strip the leading `version.` from every field key so the
+    // in-memory filter matches the projected shape.
+    const normalizedWhere = stripVersionPrefix(where);
+    const matched = normalizedWhere ? projected.filter((doc)=>matchesWhere(doc, normalizedWhere)) : projected;
+    applySorts(matched, sort);
+    const totalDocs = matched.length;
+    const useLimit = limit > 0;
+    const safePage = useLimit ? Math.max(1, page) : 1;
+    const start = useLimit ? (safePage - 1) * limit : 0;
+    const end = useLimit ? start + limit : totalDocs;
+    const docs = matched.slice(start, end);
+    const effectiveLimit = useLimit ? limit : totalDocs;
+    const totalPages = pagination && useLimit ? Math.max(1, Math.ceil(totalDocs / limit)) : 1;
+    const hasNextPage = pagination && useLimit && safePage < totalPages;
+    const hasPrevPage = pagination && useLimit && safePage > 1;
+    const result = {
+        docs,
+        hasNextPage,
+        hasPrevPage,
+        limit: effectiveLimit,
+        nextPage: hasNextPage ? safePage + 1 : null,
+        page: safePage,
+        pagingCounter: useLimit ? (safePage - 1) * limit + 1 : 1,
+        prevPage: hasPrevPage ? safePage - 1 : null,
+        totalDocs,
+        totalPages
+    };
+    return result;
+};
+
+//# sourceMappingURL=queryDrafts.js.map

package/dist/queryDrafts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queryDrafts.ts"],"sourcesContent":["import type { PaginatedDocs, QueryDrafts, Where } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { matchesWhere } from './utilities/matchesWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * Return the latest version of every doc as a paginated, doc-shaped result.\n *\n * Strategy:\n *  1. Query the versions partition for `latest=true` rows (one per parent).\n *  2. Project each row's `version` payload up to top-level so the result\n *     looks like a doc — this lets the user's `where` / `sort` operate in\n *     doc-field terms instead of `version.x` paths.\n *  3. Fill in any docs that have a row in the *main* partition but no\n *     `latest=true` version row. This covers two cases:\n *     - documents created before versioning was enabled\n *     - data orphaned by historical adapter bugs that dropped version writes\n *  4. Apply `where` post-projection, sort, paginate.\n *\n * No `_status` filter is applied — `queryDrafts` returns the latest version\n * regardless of draft/published state. Payload's higher-level code decides\n * how to use the result.\n */\n// Payload core calls appendVersionToQueryKey before invoking queryDrafts,\n// transforming e.g. `{ slug: { equals: 'x' } }` → `{ 'version.slug': { equals: 'x' } }`.\n// But we project versionData flat to the top level, so those prefixed paths\n// never resolve. Strip the leading `version.` to match the projected shape.\nfunction stripVersionPrefix(where: Where | null | undefined): Where | null | undefined {\n  if (!where || typeof where !== 'object') return where\n  const result: Where = {}\n  for (const [key, value] of Object.entries(where)) {\n    if (key === 'and' || key === 'or') {\n      if (Array.isArray(value)) {\n        result[key] = value.map((sub) => stripVersionPrefix(sub as Where)).filter(Boolean) as Where[]\n      }\n    } else {\n      result[key.startsWith('version.') ? key.slice(8) : key] = value as Where[string]\n    }\n  }\n  return result\n}\n\nexport const queryDrafts: QueryDrafts = async function queryDrafts(\n  this: DynamoAdapter,\n  { collection, limit = 10, page = 1, pagination = true, sort, where },\n) {\n  const versionsPartition = this.resolveVersionsPartition(collection)\n  const docsPartition = this.resolvePartition(collection)\n\n  const [latestRows, mainRows] = await Promise.all([\n    queryMatching(this, versionsPartition, { latest: { equals: true } }),\n    queryMatching(this, docsPartition, undefined),\n  ])\n\n  // Latest-version rows win. We key by parent id so `mainRows` only fills\n  // entries that have no version backing.\n  const docsByParent = new Map<unknown, Record<string, unknown>>()\n  for (const row of latestRows) {\n    const version = row['version']\n    if (!version || typeof version !== 'object') continue\n    docsByParent.set(row['parent'], {\n      ...(version as Record<string, unknown>),\n      id: row['parent'],\n    })\n  }\n\n  for (const doc of mainRows) {\n    if (!docsByParent.has(doc['id'])) {\n      docsByParent.set(doc['id'], doc)\n    }\n  }\n\n  const projected = [...docsByParent.values()]\n  // Payload core calls appendVersionToQueryKey before invoking queryDrafts,\n  // which transforms e.g. `{ slug: { equals: 'x' } }` into\n  // `{ 'version.slug': { equals: 'x' } }`. But we project versionData flat\n  // to the top level above, so those prefixed paths never resolve via\n  // getByPath. Strip the leading `version.` from every field key so the\n  // in-memory filter matches the projected shape.\n  const normalizedWhere = stripVersionPrefix(where)\n  const matched = normalizedWhere\n    ? projected.filter((doc) => matchesWhere(doc, normalizedWhere))\n    : projected\n\n  applySorts(matched, sort)\n\n  const totalDocs = matched.length\n  const useLimit = limit > 0\n  const safePage = useLimit ? Math.max(1, page) : 1\n\n  const start = useLimit ? (safePage - 1) * limit : 0\n  const end = useLimit ? start + limit : totalDocs\n  const docs = matched.slice(start, end)\n\n  const effectiveLimit = useLimit ? limit : totalDocs\n  const totalPages = pagination && useLimit ? Math.max(1, Math.ceil(totalDocs / limit)) : 1\n  const hasNextPage = pagination && useLimit && safePage < totalPages\n  const hasPrevPage = pagination && useLimit && safePage > 1\n\n  const result: PaginatedDocs<Record<string, unknown>> = {\n    docs,\n    hasNextPage,\n    hasPrevPage,\n    limit: effectiveLimit,\n    nextPage: hasNextPage ? safePage + 1 : null,\n    page: safePage,\n    pagingCounter: useLimit ? (safePage - 1) * limit + 1 : 1,\n    prevPage: hasPrevPage ? safePage - 1 : null,\n    totalDocs,\n    totalPages,\n  }\n  return result as never\n}\n"],"names":["applySorts","matchesWhere","queryMatching","stripVersionPrefix","where","result","key","value","Object","entries","Array","isArray","map","sub","filter","Boolean","startsWith","slice","queryDrafts","collection","limit","page","pagination","sort","versionsPartition","resolveVersionsPartition","docsPartition","resolvePartition","latestRows","mainRows","Promise","all","latest","equals","undefined","docsByParent","Map","row","version","set","id","doc","has","projected","values","normalizedWhere","matched","totalDocs","length","useLimit","safePage","Math","max","start","end","docs","effectiveLimit","totalPages","ceil","hasNextPage","hasPrevPage","nextPage","pagingCounter","prevPage"],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,119 @@
+import type { DynamoDBClient, DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
+import type { DynamoDBDocumentClient, TranslateConfig } from '@aws-sdk/lib-dynamodb';
+import type { ArrayField, BaseDatabaseAdapter, BlocksField, CheckboxField, CodeField, CollapsibleField, CollectionSlug, DateField, EmailField, Field, GlobalSlug, GroupField, JoinField, JSONField, NumberField, PointField, RadioField, RelationshipField, RichTextField, RowField, SanitizedConfig, SelectField, TabsField, TextareaField, TextField, UploadField } from 'payload';
+/**
+ * User-facing options for the `dynamoAdapter` factory.
+ */
+export type Args = {
+    /**
+     * Configuration passed straight through to `new DynamoDBClient(...)`.
+     * Use this for region, credentials, endpoint (e.g. DynamoDB Local), retry
+     * strategy, etc.
+     */
+    clientConfig?: DynamoDBClientConfig;
+    /**
+     * Optional pre-built DynamoDB client. If supplied, `clientConfig` is ignored
+     * and the adapter will not call `.destroy()` on shutdown — the caller owns
+     * the client lifecycle.
+     */
+    client?: DynamoDBClient;
+    /**
+     * Marshalling/unmarshalling options forwarded to
+     * `DynamoDBDocumentClient.from(client, translateConfig)`.
+     *
+     * Defaults applied when omitted:
+     *  - `removeUndefinedValues: true`
+     *  - `convertClassInstanceToMap: true`
+     */
+    translateConfig?: TranslateConfig;
+    /**
+     * Name of the single DynamoDB table that backs every collection, global,
+     * and version. The adapter expects a composite-key schema (`pk` + `sk`).
+     *
+     * @default 'payload'
+     */
+    tableName?: string;
+    /**
+     * Path to read and write migration files from.
+     * @default 'migrations'
+     */
+    migrationDir?: string;
+    /**
+     * If true, the adapter will provision the table at init time when it
+     * doesn't already exist. Disable in production where infra is managed
+     * out-of-band (CDK, Terraform, CloudFormation).
+     *
+     * @default false
+     */
+    ensureTables?: boolean;
+};
+/**
+ * The fully-resolved adapter instance, accessible as `payload.db` at runtime.
+ *
+ * Method implementations should be defined as `function` declarations (not
+ * arrows) and may use `this: DynamoAdapter` to reach the live client and
+ * resolved partition keys.
+ */
+export interface DynamoAdapter extends BaseDatabaseAdapter {
+    /** Underlying low-level DynamoDB client. Populated by `connect`. */
+    client: DynamoDBClient | undefined;
+    /** Document client wrapper around `client`. Populated by `connect`. */
+    docClient: DynamoDBDocumentClient | undefined;
+    /** Original options passed to the factory. */
+    clientConfig: DynamoDBClientConfig;
+    translateConfig: TranslateConfig;
+    /** True when the adapter constructed `client` itself and owns its lifecycle. */
+    ownsClient: boolean;
+    /** The single table name that backs all collections, globals, and versions. */
+    tableName: string;
+    ensureTables: boolean;
+    /**
+     * Resolve a collection or global slug to its DynamoDB partition key value.
+     * Today this is the slug verbatim — kept as a method so future schemes
+     * (e.g. tenant-scoped prefixes) can land without touching every method.
+     */
+    resolvePartition: (slug: CollectionSlug | GlobalSlug | string) => string;
+    /**
+     * Resolve a slug to the partition key value used for its versions —
+     * `${slug}_versions`. Mirrors the v1 `_versions` sibling-table convention,
+     * just expressed as a partition within the single table.
+     */
+    resolveVersionsPartition: (slug: CollectionSlug | GlobalSlug | string) => string;
+}
+export type BuildSchemaOptions = {
+    allowIDField?: boolean;
+    disableUnique?: boolean;
+    draftsEnabled?: boolean;
+    indexSortableFields?: boolean;
+};
+export type FieldGenerator<TSchema, TField> = {
+    config: SanitizedConfig;
+    field: TField;
+    options: BuildSchemaOptions;
+    schema: TSchema;
+};
+export type FieldGeneratorFunction<TSchema, TField extends Field> = (args: FieldGenerator<TSchema, TField>) => void;
+export type FieldToSchemaMap<TSchema> = {
+    array: FieldGeneratorFunction<TSchema, ArrayField>;
+    blocks: FieldGeneratorFunction<TSchema, BlocksField>;
+    checkbox: FieldGeneratorFunction<TSchema, CheckboxField>;
+    code: FieldGeneratorFunction<TSchema, CodeField>;
+    collapsible: FieldGeneratorFunction<TSchema, CollapsibleField>;
+    date: FieldGeneratorFunction<TSchema, DateField>;
+    email: FieldGeneratorFunction<TSchema, EmailField>;
+    group: FieldGeneratorFunction<TSchema, GroupField>;
+    join: FieldGeneratorFunction<TSchema, JoinField>;
+    json: FieldGeneratorFunction<TSchema, JSONField>;
+    number: FieldGeneratorFunction<TSchema, NumberField>;
+    point: FieldGeneratorFunction<TSchema, PointField>;
+    radio: FieldGeneratorFunction<TSchema, RadioField>;
+    relationship: FieldGeneratorFunction<TSchema, RelationshipField>;
+    richText: FieldGeneratorFunction<TSchema, RichTextField>;
+    row: FieldGeneratorFunction<TSchema, RowField>;
+    select: FieldGeneratorFunction<TSchema, SelectField>;
+    tabs: FieldGeneratorFunction<TSchema, TabsField>;
+    text: FieldGeneratorFunction<TSchema, TextField>;
+    textarea: FieldGeneratorFunction<TSchema, TextareaField>;
+    upload: FieldGeneratorFunction<TSchema, UploadField>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { DynamoDBClient, DynamoDBClientConfig } from '@aws-sdk/client-dynamodb'\nimport type { DynamoDBDocumentClient, TranslateConfig } from '@aws-sdk/lib-dynamodb'\nimport type {\n  ArrayField,\n  BaseDatabaseAdapter,\n  BlocksField,\n  CheckboxField,\n  CodeField,\n  CollapsibleField,\n  CollectionSlug,\n  DateField,\n  EmailField,\n  Field,\n  GlobalSlug,\n  GroupField,\n  JoinField,\n  JSONField,\n  NumberField,\n  PointField,\n  RadioField,\n  RelationshipField,\n  RichTextField,\n  RowField,\n  SanitizedConfig,\n  SelectField,\n  TabsField,\n  TextareaField,\n  TextField,\n  UploadField,\n} from 'payload'\n\n/**\n * User-facing options for the `dynamoAdapter` factory.\n */\nexport type Args = {\n  /**\n   * Configuration passed straight through to `new DynamoDBClient(...)`.\n   * Use this for region, credentials, endpoint (e.g. DynamoDB Local), retry\n   * strategy, etc.\n   */\n  clientConfig?: DynamoDBClientConfig\n  /**\n   * Optional pre-built DynamoDB client. If supplied, `clientConfig` is ignored\n   * and the adapter will not call `.destroy()` on shutdown — the caller owns\n   * the client lifecycle.\n   */\n  client?: DynamoDBClient\n  /**\n   * Marshalling/unmarshalling options forwarded to\n   * `DynamoDBDocumentClient.from(client, translateConfig)`.\n   *\n   * Defaults applied when omitted:\n   *  - `removeUndefinedValues: true`\n   *  - `convertClassInstanceToMap: true`\n   */\n  translateConfig?: TranslateConfig\n  /**\n   * Name of the single DynamoDB table that backs every collection, global,\n   * and version. The adapter expects a composite-key schema (`pk` + `sk`).\n   *\n   * @default 'payload'\n   */\n  tableName?: string\n  /**\n   * Path to read and write migration files from.\n   * @default 'migrations'\n   */\n  migrationDir?: string\n  /**\n   * If true, the adapter will provision the table at init time when it\n   * doesn't already exist. Disable in production where infra is managed\n   * out-of-band (CDK, Terraform, CloudFormation).\n   *\n   * @default false\n   */\n  ensureTables?: boolean\n}\n\n/**\n * The fully-resolved adapter instance, accessible as `payload.db` at runtime.\n *\n * Method implementations should be defined as `function` declarations (not\n * arrows) and may use `this: DynamoAdapter` to reach the live client and\n * resolved partition keys.\n */\nexport interface DynamoAdapter extends BaseDatabaseAdapter {\n  /** Underlying low-level DynamoDB client. Populated by `connect`. */\n  client: DynamoDBClient | undefined\n  /** Document client wrapper around `client`. Populated by `connect`. */\n  docClient: DynamoDBDocumentClient | undefined\n  /** Original options passed to the factory. */\n  clientConfig: DynamoDBClientConfig\n  translateConfig: TranslateConfig\n  /** True when the adapter constructed `client` itself and owns its lifecycle. */\n  ownsClient: boolean\n  /** The single table name that backs all collections, globals, and versions. */\n  tableName: string\n  ensureTables: boolean\n  /**\n   * Resolve a collection or global slug to its DynamoDB partition key value.\n   * Today this is the slug verbatim — kept as a method so future schemes\n   * (e.g. tenant-scoped prefixes) can land without touching every method.\n   */\n  resolvePartition: (slug: CollectionSlug | GlobalSlug | string) => string\n  /**\n   * Resolve a slug to the partition key value used for its versions —\n   * `${slug}_versions`. Mirrors the v1 `_versions` sibling-table convention,\n   * just expressed as a partition within the single table.\n   */\n  resolveVersionsPartition: (slug: CollectionSlug | GlobalSlug | string) => string\n}\n\nexport type BuildSchemaOptions = {\n  allowIDField?: boolean\n  disableUnique?: boolean\n  draftsEnabled?: boolean\n  indexSortableFields?: boolean\n}\n\nexport type FieldGenerator<TSchema, TField> = {\n  config: SanitizedConfig\n  field: TField\n  options: BuildSchemaOptions\n  schema: TSchema\n}\n\nexport type FieldGeneratorFunction<TSchema, TField extends Field> = (\n  args: FieldGenerator<TSchema, TField>,\n) => void\n\nexport type FieldToSchemaMap<TSchema> = {\n  array: FieldGeneratorFunction<TSchema, ArrayField>\n  blocks: FieldGeneratorFunction<TSchema, BlocksField>\n  checkbox: FieldGeneratorFunction<TSchema, CheckboxField>\n  code: FieldGeneratorFunction<TSchema, CodeField>\n  collapsible: FieldGeneratorFunction<TSchema, CollapsibleField>\n  date: FieldGeneratorFunction<TSchema, DateField>\n  email: FieldGeneratorFunction<TSchema, EmailField>\n  group: FieldGeneratorFunction<TSchema, GroupField>\n  join: FieldGeneratorFunction<TSchema, JoinField>\n  json: FieldGeneratorFunction<TSchema, JSONField>\n  number: FieldGeneratorFunction<TSchema, NumberField>\n  point: FieldGeneratorFunction<TSchema, PointField>\n  radio: FieldGeneratorFunction<TSchema, RadioField>\n  relationship: FieldGeneratorFunction<TSchema, RelationshipField>\n  richText: FieldGeneratorFunction<TSchema, RichTextField>\n  row: FieldGeneratorFunction<TSchema, RowField>\n  select: FieldGeneratorFunction<TSchema, SelectField>\n  tabs: FieldGeneratorFunction<TSchema, TabsField>\n  text: FieldGeneratorFunction<TSchema, TextField>\n  textarea: FieldGeneratorFunction<TSchema, TextareaField>\n  upload: FieldGeneratorFunction<TSchema, UploadField>\n}\n"],"names":[],"mappings":"AAkIA,WAsBC"}

package/dist/updateGlobal.d.ts

@@ -0,0 +1,9 @@
+import type { UpdateGlobal } from 'payload';
+/**
+ * Read-merge-write for the global's singleton row. Per Payload's contract,
+ * if the global doesn't exist callers should use `createGlobal` first — we
+ * surface the missing case as `null` cast (matching `updateOne`) rather than
+ * silently upserting, which would mask programmer errors.
+ */
+export declare const updateGlobal: UpdateGlobal;
+//# sourceMappingURL=updateGlobal.d.ts.map

package/dist/updateGlobal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateGlobal.d.ts","sourceRoot":"","sources":["../src/updateGlobal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAU3C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,YAuC1B,CAAA"}

package/dist/updateGlobal.js

@@ -0,0 +1,45 @@
+import { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectForGlobal } from './utilities/resolveSchema.js';
+import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+/**
+ * Read-merge-write for the global's singleton row. Per Payload's contract,
+ * if the global doesn't exist callers should use `createGlobal` first — we
+ * surface the missing case as `null` cast (matching `updateOne`) rather than
+ * silently upserting, which would mask programmer errors.
+ */ export const updateGlobal = async function updateGlobal({ slug, data, returning }) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolvePartition(slug);
+    const result = await docClient.send(new GetCommand({
+        TableName: this.tableName,
+        Key: {
+            pk: partition,
+            sk: slug
+        },
+        ConsistentRead: true
+    }));
+    if (!result.Item) {
+        return null;
+    }
+    const existing = stripInternalKeys(result.Item);
+    const merged = {
+        ...existing,
+        ...data,
+        id: slug
+    };
+    const projected = projectForGlobal(this, slug, merged);
+    await docClient.send(new PutCommand({
+        TableName: this.tableName,
+        Item: normalizeForDynamo({
+            ...projected,
+            pk: partition,
+            sk: slug
+        })
+    }));
+    return returning === false ? null : projected;
+};
+
+//# sourceMappingURL=updateGlobal.js.map

package/dist/updateGlobal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/updateGlobal.ts"],"sourcesContent":["import type { UpdateGlobal } from 'payload'\n\nimport { GetCommand, 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'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * Read-merge-write for the global's singleton row. Per Payload's contract,\n * if the global doesn't exist callers should use `createGlobal` first — we\n * surface the missing case as `null` cast (matching `updateOne`) rather than\n * silently upserting, which would mask programmer errors.\n */\nexport const updateGlobal: UpdateGlobal = async function updateGlobal(\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 partition = this.resolvePartition(slug)\n\n  const result = await docClient.send(\n    new GetCommand({\n      TableName: this.tableName,\n      Key: { pk: partition, sk: slug },\n      ConsistentRead: true,\n    }),\n  )\n\n  if (!result.Item) {\n    return null as never\n  }\n\n  const existing = stripInternalKeys(result.Item)\n  const merged: Record<string, unknown> = { ...existing, ...data, id: slug }\n  const projected = projectForGlobal(this, slug, merged)\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: partition,\n        sk: slug,\n      }),\n    }),\n  )\n\n  return returning === false ? (null as never) : (projected as never)\n}\n"],"names":["GetCommand","PutCommand","normalizeForDynamo","projectForGlobal","stripInternalKeys","updateGlobal","slug","data","returning","docClient","Error","partition","resolvePartition","result","send","TableName","tableName","Key","pk","sk","ConsistentRead","Item","existing","merged","id","projected"],"mappings":"AAEA,SAASA,UAAU,EAAEC,UAAU,QAAQ,wBAAuB;AAI9D,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,gBAAgB,QAAQ,+BAA8B;AAC/D,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;;CAKC,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,YAAY,IAAI,CAACC,gBAAgB,CAACN;IAExC,MAAMO,SAAS,MAAMJ,UAAUK,IAAI,CACjC,IAAId,WAAW;QACbe,WAAW,IAAI,CAACC,SAAS;QACzBC,KAAK;YAAEC,IAAIP;YAAWQ,IAAIb;QAAK;QAC/Bc,gBAAgB;IAClB;IAGF,IAAI,CAACP,OAAOQ,IAAI,EAAE;QAChB,OAAO;IACT;IAEA,MAAMC,WAAWlB,kBAAkBS,OAAOQ,IAAI;IAC9C,MAAME,SAAkC;QAAE,GAAGD,QAAQ;QAAE,GAAGf,IAAI;QAAEiB,IAAIlB;IAAK;IACzE,MAAMmB,YAAYtB,iBAAiB,IAAI,EAAEG,MAAMiB;IAE/C,MAAMd,UAAUK,IAAI,CAClB,IAAIb,WAAW;QACbc,WAAW,IAAI,CAACC,SAAS;QACzBK,MAAMnB,mBAAmB;YACvB,GAAGuB,SAAS;YACZP,IAAIP;YACJQ,IAAIb;QACN;IACF;IAGF,OAAOE,cAAc,QAAS,OAAkBiB;AAClD,EAAC"}

package/dist/updateGlobalVersion.d.ts

@@ -0,0 +1,8 @@
+import type { UpdateGlobalVersion } from 'payload';
+/**
+ * Same read-merge-write semantics as `updateVersion`. Doesn't cascade
+ * `latest` flips for the same reason: Payload owns that contract by issuing
+ * paired updates.
+ */
+export declare const updateGlobalVersion: UpdateGlobalVersion;
+//# sourceMappingURL=updateGlobalVersion.d.ts.map

package/dist/updateGlobalVersion.d.ts.map

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

package/dist/updateGlobalVersion.js

@@ -0,0 +1,59 @@
+import { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
+import { findFirst } from './utilities/findFirst.js';
+import { normalizeForDynamo } from './utilities/normalizeForDynamo.js';
+import { projectVersionRow } from './utilities/resolveSchema.js';
+import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+/**
+ * Same read-merge-write semantics as `updateVersion`. Doesn't cascade
+ * `latest` flips for the same reason: Payload owns that contract by issuing
+ * paired updates.
+ */ export const updateGlobalVersion = async function updateGlobalVersion(args) {
+    const docClient = this.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const partition = this.resolveVersionsPartition(args.global);
+    let target = null;
+    if (args.id !== undefined && args.id !== null) {
+        const result = await docClient.send(new GetCommand({
+            TableName: this.tableName,
+            Key: {
+                pk: partition,
+                sk: String(args.id)
+            },
+            ConsistentRead: true
+        }));
+        target = result.Item ? stripInternalKeys(result.Item) : null;
+    } else if (args.where) {
+        target = await findFirst(this, {
+            partition,
+            where: args.where
+        });
+    }
+    if (!target) {
+        return null;
+    }
+    const merged = {
+        ...target,
+        ...args.versionData,
+        id: target['id']
+    };
+    const projected = projectVersionRow(this, {
+        kind: 'global',
+        slug: args.global
+    }, merged);
+    await docClient.send(new PutCommand({
+        TableName: this.tableName,
+        Item: normalizeForDynamo({
+            ...projected,
+            pk: partition,
+            sk: String(projected['id'])
+        })
+    }));
+    if (args.returning === false) {
+        return null;
+    }
+    return projected;
+};
+
+//# sourceMappingURL=updateGlobalVersion.js.map

package/dist/updateGlobalVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/updateGlobalVersion.ts"],"sourcesContent":["import type { UpdateGlobalVersion } from 'payload'\n\nimport { GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { normalizeForDynamo } from './utilities/normalizeForDynamo.js'\nimport { projectVersionRow } from './utilities/resolveSchema.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * Same read-merge-write semantics as `updateVersion`. Doesn't cascade\n * `latest` flips for the same reason: Payload owns that contract by issuing\n * paired updates.\n */\nexport const updateGlobalVersion: UpdateGlobalVersion = async function updateGlobalVersion(\n  this: DynamoAdapter,\n  args,\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(args.global)\n\n  let target: null | Record<string, unknown> = null\n\n  if (args.id !== undefined && args.id !== null) {\n    const result = await docClient.send(\n      new GetCommand({\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(args.id) },\n        ConsistentRead: true,\n      }),\n    )\n    target = result.Item ? stripInternalKeys(result.Item) : null\n  } else if (args.where) {\n    target = await findFirst(this, { partition, where: args.where })\n  }\n\n  if (!target) {\n    return null as never\n  }\n\n  const merged: Record<string, unknown> = {\n    ...target,\n    ...args.versionData,\n    id: target['id'],\n  }\n  const projected = projectVersionRow(\n    this,\n    { kind: 'global', slug: args.global },\n    merged,\n  )\n\n  await docClient.send(\n    new PutCommand({\n      TableName: this.tableName,\n      Item: normalizeForDynamo({\n        ...projected,\n        pk: partition,\n        sk: String(projected['id']),\n      }),\n    }),\n  )\n\n  if (args.returning === false) {\n    return null as never\n  }\n  return projected as never\n}\n"],"names":["GetCommand","PutCommand","findFirst","normalizeForDynamo","projectVersionRow","stripInternalKeys","updateGlobalVersion","args","docClient","Error","partition","resolveVersionsPartition","global","target","id","undefined","result","send","TableName","tableName","Key","pk","sk","String","ConsistentRead","Item","where","merged","versionData","projected","kind","slug","returning"],"mappings":"AAEA,SAASA,UAAU,EAAEC,UAAU,QAAQ,wBAAuB;AAI9D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,kBAAkB,QAAQ,oCAAmC;AACtE,SAASC,iBAAiB,QAAQ,+BAA8B;AAChE,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;CAIC,GACD,OAAO,MAAMC,sBAA2C,eAAeA,oBAErEC,IAAI;IAEJ,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACJ,KAAKK,MAAM;IAE3D,IAAIC,SAAyC;IAE7C,IAAIN,KAAKO,EAAE,KAAKC,aAAaR,KAAKO,EAAE,KAAK,MAAM;QAC7C,MAAME,SAAS,MAAMR,UAAUS,IAAI,CACjC,IAAIjB,WAAW;YACbkB,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIX;gBAAWY,IAAIC,OAAOhB,KAAKO,EAAE;YAAE;YAC1CU,gBAAgB;QAClB;QAEFX,SAASG,OAAOS,IAAI,GAAGpB,kBAAkBW,OAAOS,IAAI,IAAI;IAC1D,OAAO,IAAIlB,KAAKmB,KAAK,EAAE;QACrBb,SAAS,MAAMX,UAAU,IAAI,EAAE;YAAEQ;YAAWgB,OAAOnB,KAAKmB,KAAK;QAAC;IAChE;IAEA,IAAI,CAACb,QAAQ;QACX,OAAO;IACT;IAEA,MAAMc,SAAkC;QACtC,GAAGd,MAAM;QACT,GAAGN,KAAKqB,WAAW;QACnBd,IAAID,MAAM,CAAC,KAAK;IAClB;IACA,MAAMgB,YAAYzB,kBAChB,IAAI,EACJ;QAAE0B,MAAM;QAAUC,MAAMxB,KAAKK,MAAM;IAAC,GACpCe;IAGF,MAAMnB,UAAUS,IAAI,CAClB,IAAIhB,WAAW;QACbiB,WAAW,IAAI,CAACC,SAAS;QACzBM,MAAMtB,mBAAmB;YACvB,GAAG0B,SAAS;YACZR,IAAIX;YACJY,IAAIC,OAAOM,SAAS,CAAC,KAAK;QAC5B;IACF;IAGF,IAAItB,KAAKyB,SAAS,KAAK,OAAO;QAC5B,OAAO;IACT;IACA,OAAOH;AACT,EAAC"}

package/dist/updateMany.d.ts

@@ -0,0 +1,13 @@
+import type { UpdateMany } from 'payload';
+/**
+ * v1 strategy: query-and-collect matches, sort, slice to `limit`, then
+ * read-merge-write each in parallel. Same merge semantics as `updateOne`:
+ * `data` is overlaid on the target and `id` is preserved from the target.
+ *
+ * `Promise.all` is order-preserving, so the returned array matches the
+ * sorted target order. Bulk DynamoDB transact-writes (`TransactWriteItems`,
+ * 100-item / 4 MB cap) are the natural next optimization but require the
+ * transaction wiring we deliberately stubbed out for now.
+ */
+export declare const updateMany: UpdateMany;
+//# sourceMappingURL=updateMany.d.ts.map

package/dist/updateMany.d.ts.map

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