@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/createVersion.js

@@ -1,27 +1,23 @@
-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';
+import { putVersionAsLatest } from './utilities/writeItems.js';
 /**
  * Insert a new version for a collection's parent doc, maintaining the
  * `latest=true` invariant per parent.
  *
  * Two round trips:
  *  1. `Query` the versions partition for the previous `latest=true` row.
- *  2. `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).
+ *  2. `putVersionAsLatest` flips that row's `latest` to false and puts the
+ *     new row in one atomic `TransactWriteItems` call. If a crash occurs
+ *     mid-flow neither mutation lands, so we never end up with two
+ *     `latest=true` rows or zero. The flip carries `attribute_exists(pk)` so
+ *     the transaction fails cleanly if the previous row was deleted between
+ *     (1) and (2).
  *
  * `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,
@@ -63,43 +59,7 @@ import { projectVersionSnapshot } from './utilities/resolveSchema.js';
             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
-    }));
+    await putVersionAsLatest(this, partition, item, previousLatest);
     return returning === false ? null : item;
 };
 

package/dist/createVersion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/createVersion.ts"],"sourcesContent":["import type { CreateVersion } from 'payload'\n\nimport { 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"}
+{"version":3,"sources":["../src/createVersion.ts"],"sourcesContent":["import type { CreateVersion } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { projectVersionSnapshot } from './utilities/resolveSchema.js'\nimport { putVersionAsLatest } from './utilities/writeItems.js'\n\n/**\n * Insert a new version for a collection's parent doc, maintaining the\n * `latest=true` invariant per parent.\n *\n * Two round trips:\n *  1. `Query` the versions partition for the previous `latest=true` row.\n *  2. `putVersionAsLatest` flips that row's `latest` to false and puts the\n *     new row in one atomic `TransactWriteItems` call. If a crash occurs\n *     mid-flow neither mutation lands, so we never end up with two\n *     `latest=true` rows or zero. The flip carries `attribute_exists(pk)` so\n *     the transaction fails cleanly if the previous row was deleted between\n *     (1) and (2).\n *\n * `autosave` is persisted on the row even though it isn't surfaced in\n * `TypeWithVersion` — `findVersions` filters by it.\n */\nexport const createVersion: CreateVersion = async function createVersion(\n  this: DynamoAdapter,\n  {\n    autosave,\n    collectionSlug,\n    createdAt,\n    parent,\n    publishedLocale,\n    returning,\n    snapshot,\n    updatedAt,\n    versionData,\n  },\n) {\n  const partition = this.resolveVersionsPartition(collectionSlug)\n\n  const previousLatest = await findFirst(this, {\n    partition,\n    where: { and: [{ parent: { equals: parent } }, { latest: { equals: true } }] },\n  })\n\n  const id = randomUUID()\n  // Project the snapshot against the parent collection's schema so that any\n  // unknown keys (e.g. registration-form `confirm-password`) don't ride into\n  // the version row alongside the legitimate doc state.\n  const sanitizedVersionData = projectVersionSnapshot(\n    this,\n    { kind: 'collection', slug: collectionSlug },\n    versionData as Record<string, unknown>,\n  )\n  const item: Record<string, unknown> = {\n    id,\n    parent,\n    version: sanitizedVersionData,\n    createdAt,\n    updatedAt,\n    latest: true,\n    autosave,\n    ...(snapshot ? { snapshot: true } : {}),\n    ...(publishedLocale !== undefined ? { publishedLocale } : {}),\n  }\n\n  await putVersionAsLatest(this, partition, item, previousLatest)\n\n  return returning === false ? (null as never) : (item as never)\n}\n"],"names":["randomUUID","findFirst","projectVersionSnapshot","putVersionAsLatest","createVersion","autosave","collectionSlug","createdAt","parent","publishedLocale","returning","snapshot","updatedAt","versionData","partition","resolveVersionsPartition","previousLatest","where","and","equals","latest","id","sanitizedVersionData","kind","slug","item","version","undefined"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,+BAA8B;AACrE,SAASC,kBAAkB,QAAQ,4BAA2B;AAE9D;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EACEC,QAAQ,EACRC,cAAc,EACdC,SAAS,EACTC,MAAM,EACNC,eAAe,EACfC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACZ;IAED,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACT;IAEhD,MAAMU,iBAAiB,MAAMf,UAAU,IAAI,EAAE;QAC3Ca;QACAG,OAAO;YAAEC,KAAK;gBAAC;oBAAEV,QAAQ;wBAAEW,QAAQX;oBAAO;gBAAE;gBAAG;oBAAEY,QAAQ;wBAAED,QAAQ;oBAAK;gBAAE;aAAE;QAAC;IAC/E;IAEA,MAAME,KAAKrB;IACX,0EAA0E;IAC1E,2EAA2E;IAC3E,sDAAsD;IACtD,MAAMsB,uBAAuBpB,uBAC3B,IAAI,EACJ;QAAEqB,MAAM;QAAcC,MAAMlB;IAAe,GAC3CO;IAEF,MAAMY,OAAgC;QACpCJ;QACAb;QACAkB,SAASJ;QACTf;QACAK;QACAQ,QAAQ;QACRf;QACA,GAAIM,WAAW;YAAEA,UAAU;QAAK,IAAI,CAAC,CAAC;QACtC,GAAIF,oBAAoBkB,YAAY;YAAElB;QAAgB,IAAI,CAAC,CAAC;IAC9D;IAEA,MAAMN,mBAAmB,IAAI,EAAEW,WAAWW,MAAMT;IAEhD,OAAON,cAAc,QAAS,OAAkBe;AAClD,EAAC"}

package/dist/deleteMany.d.ts

@@ -1,12 +1,7 @@
 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.
+ * in parallel. See `deleteItems` for why this isn't a `BatchWriteItem`.
  */
 export declare const deleteMany: DeleteMany;
 //# sourceMappingURL=deleteMany.d.ts.map

package/dist/deleteMany.d.ts.map

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

package/dist/deleteMany.js

@@ -1,27 +1,16 @@
-import { DeleteCommand } from '@aws-sdk/lib-dynamodb';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
+import { hasUniqueFields } from './utilities/uniqueGuards.js';
+import { deleteItems } from './utilities/writeItems.js';
 /**
  * v1 strategy: query-and-collect matches, then delete each by composite key
- * 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 const deleteMany = async function deleteMany({ collection, where }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
+ * in parallel. See `deleteItems` for why this isn't a `BatchWriteItem`.
+ */ export const deleteMany = async function deleteMany({ collection, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere);
     const partition = this.resolvePartition(collection);
     const matched = await queryMatching(this, partition, where);
-    await Promise.all(matched.map((target)=>docClient.send(new DeleteCommand({
-            TableName: this.tableName,
-            Key: {
-                pk: partition,
-                sk: String(target['id'])
-            }
-        }))));
+    await deleteItems(this, partition, matched, // Unique guards are released together with the documents that hold them.
+    hasUniqueFields(this, collection) ? collection : undefined);
 };
 
 //# sourceMappingURL=deleteMany.js.map

package/dist/deleteMany.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteMany.ts"],"sourcesContent":["import type { DeleteMany } from 'payload'\n\nimport { DeleteCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * v1 strategy: query-and-collect matches, then delete each by composite key\n * in parallel.\n *\n * `BatchWriteItem` could halve the request count (25 deletes per call) but\n * has partial-failure semantics that need retry logic — out of scope until\n * we wire up retries. Sequential parallel `DeleteCommand`s are simple and\n * correct.\n */\nexport const deleteMany: DeleteMany = async function deleteMany(\n  this: DynamoAdapter,\n  { collection, where },\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(collection)\n  const matched = await queryMatching(this, partition, where)\n\n  await Promise.all(\n    matched.map((target) =>\n      docClient.send(\n        new DeleteCommand({\n          TableName: this.tableName,\n          Key: { pk: partition, sk: String(target['id']) },\n        }),\n      ),\n    ),\n  )\n}\n"],"names":["DeleteCommand","queryMatching","deleteMany","collection","where","docClient","Error","partition","resolvePartition","matched","Promise","all","map","target","send","TableName","tableName","Key","pk","sk","String"],"mappings":"AAEA,SAASA,aAAa,QAAQ,wBAAuB;AAIrD,SAASC,aAAa,QAAQ,+BAA8B;AAE5D;;;;;;;;CAQC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,KAAK,EAAE;IAErB,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACL;IACxC,MAAMM,UAAU,MAAMR,cAAc,IAAI,EAAEM,WAAWH;IAErD,MAAMM,QAAQC,GAAG,CACfF,QAAQG,GAAG,CAAC,CAACC,SACXR,UAAUS,IAAI,CACZ,IAAId,cAAc;YAChBe,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIX;gBAAWY,IAAIC,OAAOP,MAAM,CAAC,KAAK;YAAE;QACjD;AAIR,EAAC"}
+{"version":3,"sources":["../src/deleteMany.ts"],"sourcesContent":["import type { DeleteMany } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { hasUniqueFields } from './utilities/uniqueGuards.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * v1 strategy: query-and-collect matches, then delete each by composite key\n * in parallel. See `deleteItems` for why this isn't a `BatchWriteItem`.\n */\nexport const deleteMany: DeleteMany = async function deleteMany(\n  this: DynamoAdapter,\n  { collection, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const matched = await queryMatching(this, partition, where)\n\n  await deleteItems(\n    this,\n    partition,\n    matched,\n    // Unique guards are released together with the documents that hold them.\n    hasUniqueFields(this, collection) ? collection : undefined,\n  )\n}\n"],"names":["prepareCollectionWhere","queryMatching","hasUniqueFields","deleteItems","deleteMany","collection","where","rawWhere","partition","resolvePartition","matched","undefined"],"mappings":"AAIA,SAASA,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;CAGC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,UAAU,EAAEC,OAAOC,QAAQ,EAAE;IAE/B,MAAMD,QAAQ,MAAMN,uBAAuB,IAAI,EAAEK,YAAYE;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACJ;IACxC,MAAMK,UAAU,MAAMT,cAAc,IAAI,EAAEO,WAAWF;IAErD,MAAMH,YACJ,IAAI,EACJK,WACAE,SACA,yEAAyE;IACzER,gBAAgB,IAAI,EAAEG,cAAcA,aAAaM;AAErD,EAAC"}

package/dist/deleteOne.d.ts.map

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

package/dist/deleteOne.js

@@ -1,30 +1,27 @@
-import { DeleteCommand } from '@aws-sdk/lib-dynamodb';
 import { findFirst } from './utilities/findFirst.js';
-import { stripInternalKeys } from './utilities/stripInternalKeys.js';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
+import { hasUniqueFields } from './utilities/uniqueGuards.js';
 import { whereToId } from './utilities/whereToId.js';
-export const deleteOne = async function deleteOne({ collection, returning, where }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
+import { deleteItem } from './utilities/writeItems.js';
+export const deleteOne = async function deleteOne({ collection, returning, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere);
     const partition = this.resolvePartition(collection);
     const idFromWhere = whereToId(where);
+    // Releasing a document's unique guards needs its values, so those
+    // collections always read the document first.
+    const guarded = hasUniqueFields(this, collection);
     // Fast path — pure id-equality lets us delete and capture the doc in one call.
-    if (idFromWhere !== null) {
-        const result = await docClient.send(new DeleteCommand({
-            TableName: this.tableName,
-            Key: {
-                pk: partition,
-                sk: String(idFromWhere)
-            },
-            ReturnValues: 'ALL_OLD'
-        }));
+    if (idFromWhere !== null && !guarded) {
+        const deleted = await deleteItem(this, partition, idFromWhere, {
+            returnOld: true
+        });
         if (returning === false) {
             return null;
         }
-        return result.Attributes ? stripInternalKeys(result.Attributes) : null;
+        return deleted;
     }
-    // Slow path — locate by query, then delete by composite key.
+    // Slow path — locate (a `GetItem` when `where` is an id), then delete by
+    // composite key.
     const found = await findFirst(this, {
         partition,
         where
@@ -32,13 +29,12 @@ export const deleteOne = async function deleteOne({ collection, returning, where
     if (!found) {
         return null;
     }
-    await docClient.send(new DeleteCommand({
-        TableName: this.tableName,
-        Key: {
-            pk: partition,
-            sk: String(found['id'])
+    await deleteItem(this, partition, found['id'], guarded ? {
+        unique: {
+            collection,
+            doc: found
         }
-    }));
+    } : {});
     if (returning === false) {
         return null;
     }

package/dist/deleteOne.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteOne.ts"],"sourcesContent":["import type { DeleteOne } from 'payload'\n\nimport { DeleteCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\nimport { whereToId } from './utilities/whereToId.js'\n\nexport const deleteOne: DeleteOne = async function deleteOne(\n  this: DynamoAdapter,\n  { collection, returning, where },\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(collection)\n  const idFromWhere = whereToId(where)\n\n  // Fast path — pure id-equality lets us delete and capture the doc in one call.\n  if (idFromWhere !== null) {\n    const result = await docClient.send(\n      new DeleteCommand({\n        TableName: this.tableName,\n        Key: { pk: partition, sk: String(idFromWhere) },\n        ReturnValues: 'ALL_OLD',\n      }),\n    )\n    if (returning === false) {\n      return null as never\n    }\n    return (result.Attributes ? stripInternalKeys(result.Attributes) : null) as never\n  }\n\n  // Slow path — locate by query, then delete by composite key.\n  const found = await findFirst(this, { partition, where })\n  if (!found) {\n    return null as never\n  }\n\n  await docClient.send(\n    new DeleteCommand({\n      TableName: this.tableName,\n      Key: { pk: partition, sk: String(found['id']) },\n    }),\n  )\n\n  if (returning === false) {\n    return null as never\n  }\n  return found as never\n}\n"],"names":["DeleteCommand","findFirst","stripInternalKeys","whereToId","deleteOne","collection","returning","where","docClient","Error","partition","resolvePartition","idFromWhere","result","send","TableName","tableName","Key","pk","sk","String","ReturnValues","Attributes","found"],"mappings":"AAEA,SAASA,aAAa,QAAQ,wBAAuB;AAIrD,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,SAAS,QAAQ,2BAA0B;AAEpD,OAAO,MAAMC,YAAuB,eAAeA,UAEjD,EAAEC,UAAU,EAAEC,SAAS,EAAEC,KAAK,EAAE;IAEhC,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACN;IACxC,MAAMO,cAAcT,UAAUI;IAE9B,+EAA+E;IAC/E,IAAIK,gBAAgB,MAAM;QACxB,MAAMC,SAAS,MAAML,UAAUM,IAAI,CACjC,IAAId,cAAc;YAChBe,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIR;gBAAWS,IAAIC,OAAOR;YAAa;YAC9CS,cAAc;QAChB;QAEF,IAAIf,cAAc,OAAO;YACvB,OAAO;QACT;QACA,OAAQO,OAAOS,UAAU,GAAGpB,kBAAkBW,OAAOS,UAAU,IAAI;IACrE;IAEA,6DAA6D;IAC7D,MAAMC,QAAQ,MAAMtB,UAAU,IAAI,EAAE;QAAES;QAAWH;IAAM;IACvD,IAAI,CAACgB,OAAO;QACV,OAAO;IACT;IAEA,MAAMf,UAAUM,IAAI,CAClB,IAAId,cAAc;QAChBe,WAAW,IAAI,CAACC,SAAS;QACzBC,KAAK;YAAEC,IAAIR;YAAWS,IAAIC,OAAOG,KAAK,CAAC,KAAK;QAAE;IAChD;IAGF,IAAIjB,cAAc,OAAO;QACvB,OAAO;IACT;IACA,OAAOiB;AACT,EAAC"}
+{"version":3,"sources":["../src/deleteOne.ts"],"sourcesContent":["import type { DeleteOne } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { findFirst } from './utilities/findFirst.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { hasUniqueFields } from './utilities/uniqueGuards.js'\nimport { whereToId } from './utilities/whereToId.js'\nimport { deleteItem } from './utilities/writeItems.js'\n\nexport const deleteOne: DeleteOne = async function deleteOne(\n  this: DynamoAdapter,\n  { collection, returning, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere)\n  const partition = this.resolvePartition(collection)\n  const idFromWhere = whereToId(where)\n  // Releasing a document's unique guards needs its values, so those\n  // collections always read the document first.\n  const guarded = hasUniqueFields(this, collection)\n\n  // Fast path — pure id-equality lets us delete and capture the doc in one call.\n  if (idFromWhere !== null && !guarded) {\n    const deleted = await deleteItem(this, partition, idFromWhere, { returnOld: true })\n    if (returning === false) {\n      return null as never\n    }\n    return deleted as never\n  }\n\n  // Slow path — locate (a `GetItem` when `where` is an id), then delete by\n  // composite key.\n  const found = await findFirst(this, { partition, where })\n  if (!found) {\n    return null as never\n  }\n\n  await deleteItem(\n    this,\n    partition,\n    found['id'],\n    guarded ? { unique: { collection, doc: found } } : {},\n  )\n\n  if (returning === false) {\n    return null as never\n  }\n  return found as never\n}\n"],"names":["findFirst","prepareCollectionWhere","hasUniqueFields","whereToId","deleteItem","deleteOne","collection","returning","where","rawWhere","partition","resolvePartition","idFromWhere","guarded","deleted","returnOld","found","unique","doc"],"mappings":"AAIA,SAASA,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,YAAuB,eAAeA,UAEjD,EAAEC,UAAU,EAAEC,SAAS,EAAEC,OAAOC,QAAQ,EAAE;IAE1C,MAAMD,QAAQ,MAAMP,uBAAuB,IAAI,EAAEK,YAAYG;IAC7D,MAAMC,YAAY,IAAI,CAACC,gBAAgB,CAACL;IACxC,MAAMM,cAAcT,UAAUK;IAC9B,kEAAkE;IAClE,8CAA8C;IAC9C,MAAMK,UAAUX,gBAAgB,IAAI,EAAEI;IAEtC,+EAA+E;IAC/E,IAAIM,gBAAgB,QAAQ,CAACC,SAAS;QACpC,MAAMC,UAAU,MAAMV,WAAW,IAAI,EAAEM,WAAWE,aAAa;YAAEG,WAAW;QAAK;QACjF,IAAIR,cAAc,OAAO;YACvB,OAAO;QACT;QACA,OAAOO;IACT;IAEA,yEAAyE;IACzE,iBAAiB;IACjB,MAAME,QAAQ,MAAMhB,UAAU,IAAI,EAAE;QAAEU;QAAWF;IAAM;IACvD,IAAI,CAACQ,OAAO;QACV,OAAO;IACT;IAEA,MAAMZ,WACJ,IAAI,EACJM,WACAM,KAAK,CAAC,KAAK,EACXH,UAAU;QAAEI,QAAQ;YAAEX;YAAYY,KAAKF;QAAM;IAAE,IAAI,CAAC;IAGtD,IAAIT,cAAc,OAAO;QACvB,OAAO;IACT;IACA,OAAOS;AACT,EAAC"}

package/dist/deleteVersions.d.ts.map

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

package/dist/deleteVersions.js

@@ -1,28 +1,22 @@
-import { DeleteCommand } from '@aws-sdk/lib-dynamodb';
+import { prepareVersionsWhere } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
+import { deleteItems } from './utilities/writeItems.js';
 /**
  * Same query + parallel delete pattern as `deleteMany`, but routes to the
  * versions partition for either a collection (`collection`) or a global
  * (`globalSlug`). Payload guarantees exactly one of those two slugs is
  * present.
- */ export const deleteVersions = async function deleteVersions({ collection, globalSlug, where }) {
-    const docClient = this.docClient;
-    if (!docClient) {
-        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
-    }
+ */ export const deleteVersions = async function deleteVersions({ collection, globalSlug, locale, where }) {
     const slug = collection ?? globalSlug;
     if (!slug) {
         throw new Error('payload-ddb: deleteVersions requires either `collection` or `globalSlug`.');
     }
     const partition = this.resolveVersionsPartition(slug);
-    const matched = await queryMatching(this, partition, where);
-    await Promise.all(matched.map((target)=>docClient.send(new DeleteCommand({
-            TableName: this.tableName,
-            Key: {
-                pk: partition,
-                sk: String(target['id'])
-            }
-        }))));
+    const matched = await queryMatching(this, partition, await prepareVersionsWhere(this, {
+        kind: collection ? 'collection' : 'global',
+        slug
+    }, where, locale));
+    await deleteItems(this, partition, matched);
 };
 
 //# sourceMappingURL=deleteVersions.js.map

package/dist/deleteVersions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/deleteVersions.ts"],"sourcesContent":["import type { DeleteVersions } from 'payload'\n\nimport { DeleteCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * Same query + parallel delete pattern as `deleteMany`, but routes to the\n * versions partition for either a collection (`collection`) or a global\n * (`globalSlug`). Payload guarantees exactly one of those two slugs is\n * present.\n */\nexport const deleteVersions: DeleteVersions = async function deleteVersions(\n  this: DynamoAdapter,\n  { collection, globalSlug, where },\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 slug = collection ?? globalSlug\n  if (!slug) {\n    throw new Error('payload-ddb: deleteVersions requires either `collection` or `globalSlug`.')\n  }\n\n  const partition = this.resolveVersionsPartition(slug)\n  const matched = await queryMatching(this, partition, where)\n\n  await Promise.all(\n    matched.map((target) =>\n      docClient.send(\n        new DeleteCommand({\n          TableName: this.tableName,\n          Key: { pk: partition, sk: String(target['id']) },\n        }),\n      ),\n    ),\n  )\n}\n"],"names":["DeleteCommand","queryMatching","deleteVersions","collection","globalSlug","where","docClient","Error","slug","partition","resolveVersionsPartition","matched","Promise","all","map","target","send","TableName","tableName","Key","pk","sk","String"],"mappings":"AAEA,SAASA,aAAa,QAAQ,wBAAuB;AAIrD,SAASC,aAAa,QAAQ,+BAA8B;AAE5D;;;;;CAKC,GACD,OAAO,MAAMC,iBAAiC,eAAeA,eAE3D,EAAEC,UAAU,EAAEC,UAAU,EAAEC,KAAK,EAAE;IAEjC,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,OAAOL,cAAcC;IAC3B,IAAI,CAACI,MAAM;QACT,MAAM,IAAID,MAAM;IAClB;IAEA,MAAME,YAAY,IAAI,CAACC,wBAAwB,CAACF;IAChD,MAAMG,UAAU,MAAMV,cAAc,IAAI,EAAEQ,WAAWJ;IAErD,MAAMO,QAAQC,GAAG,CACfF,QAAQG,GAAG,CAAC,CAACC,SACXT,UAAUU,IAAI,CACZ,IAAIhB,cAAc;YAChBiB,WAAW,IAAI,CAACC,SAAS;YACzBC,KAAK;gBAAEC,IAAIX;gBAAWY,IAAIC,OAAOP,MAAM,CAAC,KAAK;YAAE;QACjD;AAIR,EAAC"}
+{"version":3,"sources":["../src/deleteVersions.ts"],"sourcesContent":["import type { DeleteVersions } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { deleteItems } from './utilities/writeItems.js'\n\n/**\n * Same query + parallel delete pattern as `deleteMany`, but routes to the\n * versions partition for either a collection (`collection`) or a global\n * (`globalSlug`). Payload guarantees exactly one of those two slugs is\n * present.\n */\nexport const deleteVersions: DeleteVersions = async function deleteVersions(\n  this: DynamoAdapter,\n  { collection, globalSlug, locale, where },\n) {\n  const slug = collection ?? globalSlug\n  if (!slug) {\n    throw new Error('payload-ddb: deleteVersions requires either `collection` or `globalSlug`.')\n  }\n\n  const partition = this.resolveVersionsPartition(slug)\n  const matched = await queryMatching(\n    this,\n    partition,\n    await prepareVersionsWhere(\n      this,\n      { kind: collection ? 'collection' : 'global', slug },\n      where,\n      locale,\n    ),\n  )\n\n  await deleteItems(this, partition, matched)\n}\n"],"names":["prepareVersionsWhere","queryMatching","deleteItems","deleteVersions","collection","globalSlug","locale","where","slug","Error","partition","resolveVersionsPartition","matched","kind"],"mappings":"AAIA,SAASA,oBAAoB,QAAQ,8BAA6B;AAClE,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,WAAW,QAAQ,4BAA2B;AAEvD;;;;;CAKC,GACD,OAAO,MAAMC,iBAAiC,eAAeA,eAE3D,EAAEC,UAAU,EAAEC,UAAU,EAAEC,MAAM,EAAEC,KAAK,EAAE;IAEzC,MAAMC,OAAOJ,cAAcC;IAC3B,IAAI,CAACG,MAAM;QACT,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACH;IAChD,MAAMI,UAAU,MAAMX,cACpB,IAAI,EACJS,WACA,MAAMV,qBACJ,IAAI,EACJ;QAAEa,MAAMT,aAAa,eAAe;QAAUI;IAAK,GACnDD,OACAD;IAIJ,MAAMJ,YAAY,IAAI,EAAEQ,WAAWE;AACrC,EAAC"}

package/dist/find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../src/find.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAiB,MAAM,SAAS,CAAA;AAQlD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,EAAE,IAyClB,CAAA"}
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../src/find.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAiB,MAAM,SAAS,CAAA;AAUlD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,EAAE,IA4ClB,CAAA"}

package/dist/find.js

@@ -1,6 +1,8 @@
 import { applySorts } from './utilities/applySorts.js';
 import { collectionHasDrafts, fetchDraftsOnlySupplements } from './utilities/draftsFallback.js';
+import { prepareCollectionWhere, prepareSort } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
+import { resolveJoins } from './utilities/resolveJoins.js';
 /**
  * v2 strategy: paginated `Query` over the collection's partition (`pk = slug`)
  * with `where` translated to `FilterExpression`, then in-memory sort and page
@@ -17,13 +19,17 @@ import { queryMatching } from './utilities/queryMatching.js';
  *    (e.g. `email` for auth, `slug` for public-facing collections).
  *  - Stream pages instead of materializing all matches when `pagination=false`
  *    and `limit` is small.
- */ export const find = async function find({ collection, limit = 10, page = 1, pagination = true, sort, where }) {
+ */ export const find = async function find({ collection, joins, limit = 10, locale, page = 1, pagination = true, sort, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere, locale);
     const matched = await queryMatching(this, this.resolvePartition(collection), where);
     if (collectionHasDrafts(this, collection)) {
         const supplements = await fetchDraftsOnlySupplements(this, collection, matched, where);
         matched.push(...supplements);
     }
-    applySorts(matched, sort);
+    applySorts(matched, prepareSort(this, {
+        kind: 'collection',
+        slug: collection
+    }, sort, locale));
     const totalDocs = matched.length;
     // `limit: 0` disables the cap. When pagination is false, limit/page still
     // control the slice; the flag only gates total-count metadata.
@@ -32,6 +38,13 @@ import { queryMatching } from './utilities/queryMatching.js';
     const start = useLimit ? (safePage - 1) * limit : 0;
     const end = useLimit ? start + limit : totalDocs;
     const docs = matched.slice(start, end);
+    // Only the page being returned — joins cost a query per target collection.
+    await resolveJoins(this, {
+        collectionSlug: collection,
+        docs,
+        joins,
+        locale
+    });
     const effectiveLimit = useLimit ? limit : totalDocs;
     const totalPages = pagination && useLimit ? Math.max(1, Math.ceil(totalDocs / limit)) : 1;
     const hasNextPage = pagination && useLimit && safePage < totalPages;

package/dist/find.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/find.ts"],"sourcesContent":["import type { Find, PaginatedDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { collectionHasDrafts, fetchDraftsOnlySupplements } from './utilities/draftsFallback.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * v2 strategy: paginated `Query` over the collection's partition (`pk = slug`)\n * with `where` translated to `FilterExpression`, then in-memory sort and page\n * slice. `Query` reads only the rows in this collection's partition, so we no\n * longer pay to walk the whole table.\n *\n * For collections with `versions.drafts: true`, also pull `latest=true` rows\n * from the versions partition and union in any whose parent isn't already\n * represented in the main partition. This catches drafts-only docs (created\n * but never published) that would otherwise be invisible to `find`.\n *\n * Optimizations to land later:\n *  - Use `Query` against a GSI when the predicate matches an indexed key\n *    (e.g. `email` for auth, `slug` for public-facing collections).\n *  - Stream pages instead of materializing all matches when `pagination=false`\n *    and `limit` is small.\n */\nexport const find: Find = async function find(\n  this: DynamoAdapter,\n  { collection, limit = 10, page = 1, pagination = true, sort, where },\n) {\n  const matched = await queryMatching(this, this.resolvePartition(collection), where)\n\n  if (collectionHasDrafts(this, collection)) {\n    const supplements = await fetchDraftsOnlySupplements(this, collection, matched, where)\n    matched.push(...supplements)\n  }\n\n  applySorts(matched, sort)\n\n  const totalDocs = matched.length\n  // `limit: 0` disables the cap. When pagination is false, limit/page still\n  // control the slice; the flag only gates total-count metadata.\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","collectionHasDrafts","fetchDraftsOnlySupplements","queryMatching","find","collection","limit","page","pagination","sort","where","matched","resolvePartition","supplements","push","totalDocs","length","useLimit","safePage","Math","max","start","end","docs","slice","effectiveLimit","totalPages","ceil","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,mBAAmB,EAAEC,0BAA0B,QAAQ,gCAA+B;AAC/F,SAASC,aAAa,QAAQ,+BAA8B;AAE5D;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,OAAa,eAAeA,KAEvC,EAAEC,UAAU,EAAEC,QAAQ,EAAE,EAAEC,OAAO,CAAC,EAAEC,aAAa,IAAI,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAEpE,MAAMC,UAAU,MAAMR,cAAc,IAAI,EAAE,IAAI,CAACS,gBAAgB,CAACP,aAAaK;IAE7E,IAAIT,oBAAoB,IAAI,EAAEI,aAAa;QACzC,MAAMQ,cAAc,MAAMX,2BAA2B,IAAI,EAAEG,YAAYM,SAASD;QAChFC,QAAQG,IAAI,IAAID;IAClB;IAEAb,WAAWW,SAASF;IAEpB,MAAMM,YAAYJ,QAAQK,MAAM;IAChC,0EAA0E;IAC1E,+DAA+D;IAC/D,MAAMC,WAAWX,QAAQ;IACzB,MAAMY,WAAWD,WAAWE,KAAKC,GAAG,CAAC,GAAGb,QAAQ;IAEhD,MAAMc,QAAQJ,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKZ,QAAQ;IAClD,MAAMgB,MAAML,WAAWI,QAAQf,QAAQS;IACvC,MAAMQ,OAAOZ,QAAQa,KAAK,CAACH,OAAOC;IAElC,MAAMG,iBAAiBR,WAAWX,QAAQS;IAC1C,MAAMW,aAAalB,cAAcS,WAAWE,KAAKC,GAAG,CAAC,GAAGD,KAAKQ,IAAI,CAACZ,YAAYT,UAAU;IACxF,MAAMsB,cAAcpB,cAAcS,YAAYC,WAAWQ;IACzD,MAAMG,cAAcrB,cAAcS,YAAYC,WAAW;IAEzD,MAAMY,SAAiD;QACrDP;QACAK;QACAC;QACAvB,OAAOmB;QACPM,UAAUH,cAAcV,WAAW,IAAI;QACvCX,MAAMW;QACNc,eAAef,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKZ,QAAQ,IAAI;QACvD2B,UAAUJ,cAAcX,WAAW,IAAI;QACvCH;QACAW;IACF;IACA,OAAOI;AACT,EAAC"}
+{"version":3,"sources":["../src/find.ts"],"sourcesContent":["import type { Find, PaginatedDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { collectionHasDrafts, fetchDraftsOnlySupplements } from './utilities/draftsFallback.js'\nimport { prepareCollectionWhere, prepareSort } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\nimport { resolveJoins } from './utilities/resolveJoins.js'\n\n/**\n * v2 strategy: paginated `Query` over the collection's partition (`pk = slug`)\n * with `where` translated to `FilterExpression`, then in-memory sort and page\n * slice. `Query` reads only the rows in this collection's partition, so we no\n * longer pay to walk the whole table.\n *\n * For collections with `versions.drafts: true`, also pull `latest=true` rows\n * from the versions partition and union in any whose parent isn't already\n * represented in the main partition. This catches drafts-only docs (created\n * but never published) that would otherwise be invisible to `find`.\n *\n * Optimizations to land later:\n *  - Use `Query` against a GSI when the predicate matches an indexed key\n *    (e.g. `email` for auth, `slug` for public-facing collections).\n *  - Stream pages instead of materializing all matches when `pagination=false`\n *    and `limit` is small.\n */\nexport const find: Find = async function find(\n  this: DynamoAdapter,\n  { collection, joins, limit = 10, locale, page = 1, pagination = true, sort, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere, locale)\n  const matched = await queryMatching(this, this.resolvePartition(collection), where)\n\n  if (collectionHasDrafts(this, collection)) {\n    const supplements = await fetchDraftsOnlySupplements(this, collection, matched, where)\n    matched.push(...supplements)\n  }\n\n  applySorts(matched, prepareSort(this, { kind: 'collection', slug: collection }, sort, locale))\n\n  const totalDocs = matched.length\n  // `limit: 0` disables the cap. When pagination is false, limit/page still\n  // control the slice; the flag only gates total-count metadata.\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  // Only the page being returned — joins cost a query per target collection.\n  await resolveJoins(this, { collectionSlug: collection, docs, joins, locale })\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","collectionHasDrafts","fetchDraftsOnlySupplements","prepareCollectionWhere","prepareSort","queryMatching","resolveJoins","find","collection","joins","limit","locale","page","pagination","sort","where","rawWhere","matched","resolvePartition","supplements","push","kind","slug","totalDocs","length","useLimit","safePage","Math","max","start","end","docs","slice","collectionSlug","effectiveLimit","totalPages","ceil","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,mBAAmB,EAAEC,0BAA0B,QAAQ,gCAA+B;AAC/F,SAASC,sBAAsB,EAAEC,WAAW,QAAQ,8BAA6B;AACjF,SAASC,aAAa,QAAQ,+BAA8B;AAC5D,SAASC,YAAY,QAAQ,8BAA6B;AAE1D;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,OAAa,eAAeA,KAEvC,EAAEC,UAAU,EAAEC,KAAK,EAAEC,QAAQ,EAAE,EAAEC,MAAM,EAAEC,OAAO,CAAC,EAAEC,aAAa,IAAI,EAAEC,IAAI,EAAEC,OAAOC,QAAQ,EAAE;IAE7F,MAAMD,QAAQ,MAAMZ,uBAAuB,IAAI,EAAEK,YAAYQ,UAAUL;IACvE,MAAMM,UAAU,MAAMZ,cAAc,IAAI,EAAE,IAAI,CAACa,gBAAgB,CAACV,aAAaO;IAE7E,IAAId,oBAAoB,IAAI,EAAEO,aAAa;QACzC,MAAMW,cAAc,MAAMjB,2BAA2B,IAAI,EAAEM,YAAYS,SAASF;QAChFE,QAAQG,IAAI,IAAID;IAClB;IAEAnB,WAAWiB,SAASb,YAAY,IAAI,EAAE;QAAEiB,MAAM;QAAcC,MAAMd;IAAW,GAAGM,MAAMH;IAEtF,MAAMY,YAAYN,QAAQO,MAAM;IAChC,0EAA0E;IAC1E,+DAA+D;IAC/D,MAAMC,WAAWf,QAAQ;IACzB,MAAMgB,WAAWD,WAAWE,KAAKC,GAAG,CAAC,GAAGhB,QAAQ;IAEhD,MAAMiB,QAAQJ,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKhB,QAAQ;IAClD,MAAMoB,MAAML,WAAWI,QAAQnB,QAAQa;IACvC,MAAMQ,OAAOd,QAAQe,KAAK,CAACH,OAAOC;IAClC,2EAA2E;IAC3E,MAAMxB,aAAa,IAAI,EAAE;QAAE2B,gBAAgBzB;QAAYuB;QAAMtB;QAAOE;IAAO;IAE3E,MAAMuB,iBAAiBT,WAAWf,QAAQa;IAC1C,MAAMY,aAAatB,cAAcY,WAAWE,KAAKC,GAAG,CAAC,GAAGD,KAAKS,IAAI,CAACb,YAAYb,UAAU;IACxF,MAAM2B,cAAcxB,cAAcY,YAAYC,WAAWS;IACzD,MAAMG,cAAczB,cAAcY,YAAYC,WAAW;IAEzD,MAAMa,SAAiD;QACrDR;QACAM;QACAC;QACA5B,OAAOwB;QACPM,UAAUH,cAAcX,WAAW,IAAI;QACvCd,MAAMc;QACNe,eAAehB,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKhB,QAAQ,IAAI;QACvDgC,UAAUJ,cAAcZ,WAAW,IAAI;QACvCH;QACAY;IACF;IACA,OAAOI;AACT,EAAC"}

package/dist/findDistinct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findDistinct.d.ts","sourceRoot":"","sources":["../src/findDistinct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,SAAS,CAAA;AAQlE;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,YA4C1B,CAAA"}
+{"version":3,"file":"findDistinct.d.ts","sourceRoot":"","sources":["../src/findDistinct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,SAAS,CAAA;AASlE;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,YA6C1B,CAAA"}

package/dist/findDistinct.js

@@ -1,5 +1,6 @@
 import { applySorts } from './utilities/applySorts.js';
 import { getByPath } from './utilities/getByPath.js';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
 /**
  * v2 strategy: paginated `Query` over the collection's partition, JS `where`
@@ -10,7 +11,8 @@ import { queryMatching } from './utilities/queryMatching.js';
  * by reference, so if you `findDistinct` over a non-primitive field you'll
  * get one entry per item (no real dedup). Stringification-based dedup can
  * land if it turns out to matter.
- */ export const findDistinct = async function findDistinct({ collection, field, limit = 10, page = 1, sort, where }) {
+ */ export const findDistinct = async function findDistinct({ collection, field, limit = 10, locale, page = 1, sort, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere, locale);
     const matched = await queryMatching(this, this.resolvePartition(collection), where);
     const seen = new Set();
     const values = [];

package/dist/findDistinct.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/findDistinct.ts"],"sourcesContent":["import type { FindDistinct, PaginatedDistinctDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { getByPath } from './utilities/getByPath.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * v2 strategy: paginated `Query` over the collection's partition, JS `where`\n * filter has already been pushed down via `FilterExpression`, then dedup via\n * `Set` and sort + paginate the resulting value list.\n *\n * Dedup uses primitive equality. Object- or array-valued fields would compare\n * by reference, so if you `findDistinct` over a non-primitive field you'll\n * get one entry per item (no real dedup). Stringification-based dedup can\n * land if it turns out to matter.\n */\nexport const findDistinct: FindDistinct = async function findDistinct(\n  this: DynamoAdapter,\n  { collection, field, limit = 10, page = 1, sort, where },\n) {\n  const matched = await queryMatching(this, this.resolvePartition(collection), where)\n\n  const seen = new Set<unknown>()\n  const values: Record<string, unknown>[] = []\n  for (const item of matched) {\n    const value = getByPath(item, field)\n    if (value === undefined) continue\n    if (seen.has(value)) continue\n    seen.add(value)\n    values.push({ [field]: value })\n  }\n\n  applySorts(values, sort)\n\n  const totalDocs = values.length\n  const useLimit = limit > 0\n  const effectiveLimit = useLimit ? limit : totalDocs\n  const totalPages = useLimit ? Math.max(1, Math.ceil(totalDocs / limit)) : 1\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 paged = values.slice(start, end)\n\n  const hasNextPage = useLimit && safePage < totalPages\n  const hasPrevPage = useLimit && safePage > 1\n\n  const result: PaginatedDistinctDocs<Record<string, unknown>> = {\n    values: paged,\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\n}\n"],"names":["applySorts","getByPath","queryMatching","findDistinct","collection","field","limit","page","sort","where","matched","resolvePartition","seen","Set","values","item","value","undefined","has","add","push","totalDocs","length","useLimit","effectiveLimit","totalPages","Math","max","ceil","safePage","start","end","paged","slice","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,aAAa,QAAQ,+BAA8B;AAE5D;;;;;;;;;CASC,GACD,OAAO,MAAMC,eAA6B,eAAeA,aAEvD,EAAEC,UAAU,EAAEC,KAAK,EAAEC,QAAQ,EAAE,EAAEC,OAAO,CAAC,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAExD,MAAMC,UAAU,MAAMR,cAAc,IAAI,EAAE,IAAI,CAACS,gBAAgB,CAACP,aAAaK;IAE7E,MAAMG,OAAO,IAAIC;IACjB,MAAMC,SAAoC,EAAE;IAC5C,KAAK,MAAMC,QAAQL,QAAS;QAC1B,MAAMM,QAAQf,UAAUc,MAAMV;QAC9B,IAAIW,UAAUC,WAAW;QACzB,IAAIL,KAAKM,GAAG,CAACF,QAAQ;QACrBJ,KAAKO,GAAG,CAACH;QACTF,OAAOM,IAAI,CAAC;YAAE,CAACf,MAAM,EAAEW;QAAM;IAC/B;IAEAhB,WAAWc,QAAQN;IAEnB,MAAMa,YAAYP,OAAOQ,MAAM;IAC/B,MAAMC,WAAWjB,QAAQ;IACzB,MAAMkB,iBAAiBD,WAAWjB,QAAQe;IAC1C,MAAMI,aAAaF,WAAWG,KAAKC,GAAG,CAAC,GAAGD,KAAKE,IAAI,CAACP,YAAYf,UAAU;IAC1E,MAAMuB,WAAWN,WAAWG,KAAKC,GAAG,CAAC,GAAGpB,QAAQ;IAEhD,MAAMuB,QAAQP,WAAW,AAACM,CAAAA,WAAW,CAAA,IAAKvB,QAAQ;IAClD,MAAMyB,MAAMR,WAAWO,QAAQxB,QAAQe;IACvC,MAAMW,QAAQlB,OAAOmB,KAAK,CAACH,OAAOC;IAElC,MAAMG,cAAcX,YAAYM,WAAWJ;IAC3C,MAAMU,cAAcZ,YAAYM,WAAW;IAE3C,MAAMO,SAAyD;QAC7DtB,QAAQkB;QACRE;QACAC;QACA7B,OAAOkB;QACPa,UAAUH,cAAcL,WAAW,IAAI;QACvCtB,MAAMsB;QACNS,eAAef,WAAW,AAACM,CAAAA,WAAW,CAAA,IAAKvB,QAAQ,IAAI;QACvDiC,UAAUJ,cAAcN,WAAW,IAAI;QACvCR;QACAI;IACF;IACA,OAAOW;AACT,EAAC"}
+{"version":3,"sources":["../src/findDistinct.ts"],"sourcesContent":["import type { FindDistinct, PaginatedDistinctDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { getByPath } from './utilities/getByPath.js'\nimport { prepareCollectionWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\n/**\n * v2 strategy: paginated `Query` over the collection's partition, JS `where`\n * filter has already been pushed down via `FilterExpression`, then dedup via\n * `Set` and sort + paginate the resulting value list.\n *\n * Dedup uses primitive equality. Object- or array-valued fields would compare\n * by reference, so if you `findDistinct` over a non-primitive field you'll\n * get one entry per item (no real dedup). Stringification-based dedup can\n * land if it turns out to matter.\n */\nexport const findDistinct: FindDistinct = async function findDistinct(\n  this: DynamoAdapter,\n  { collection, field, limit = 10, locale, page = 1, sort, where: rawWhere },\n) {\n  const where = await prepareCollectionWhere(this, collection, rawWhere, locale)\n  const matched = await queryMatching(this, this.resolvePartition(collection), where)\n\n  const seen = new Set<unknown>()\n  const values: Record<string, unknown>[] = []\n  for (const item of matched) {\n    const value = getByPath(item, field)\n    if (value === undefined) continue\n    if (seen.has(value)) continue\n    seen.add(value)\n    values.push({ [field]: value })\n  }\n\n  applySorts(values, sort)\n\n  const totalDocs = values.length\n  const useLimit = limit > 0\n  const effectiveLimit = useLimit ? limit : totalDocs\n  const totalPages = useLimit ? Math.max(1, Math.ceil(totalDocs / limit)) : 1\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 paged = values.slice(start, end)\n\n  const hasNextPage = useLimit && safePage < totalPages\n  const hasPrevPage = useLimit && safePage > 1\n\n  const result: PaginatedDistinctDocs<Record<string, unknown>> = {\n    values: paged,\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\n}\n"],"names":["applySorts","getByPath","prepareCollectionWhere","queryMatching","findDistinct","collection","field","limit","locale","page","sort","where","rawWhere","matched","resolvePartition","seen","Set","values","item","value","undefined","has","add","push","totalDocs","length","useLimit","effectiveLimit","totalPages","Math","max","ceil","safePage","start","end","paged","slice","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,SAAS,QAAQ,2BAA0B;AACpD,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,aAAa,QAAQ,+BAA8B;AAE5D;;;;;;;;;CASC,GACD,OAAO,MAAMC,eAA6B,eAAeA,aAEvD,EAAEC,UAAU,EAAEC,KAAK,EAAEC,QAAQ,EAAE,EAAEC,MAAM,EAAEC,OAAO,CAAC,EAAEC,IAAI,EAAEC,OAAOC,QAAQ,EAAE;IAE1E,MAAMD,QAAQ,MAAMT,uBAAuB,IAAI,EAAEG,YAAYO,UAAUJ;IACvE,MAAMK,UAAU,MAAMV,cAAc,IAAI,EAAE,IAAI,CAACW,gBAAgB,CAACT,aAAaM;IAE7E,MAAMI,OAAO,IAAIC;IACjB,MAAMC,SAAoC,EAAE;IAC5C,KAAK,MAAMC,QAAQL,QAAS;QAC1B,MAAMM,QAAQlB,UAAUiB,MAAMZ;QAC9B,IAAIa,UAAUC,WAAW;QACzB,IAAIL,KAAKM,GAAG,CAACF,QAAQ;QACrBJ,KAAKO,GAAG,CAACH;QACTF,OAAOM,IAAI,CAAC;YAAE,CAACjB,MAAM,EAAEa;QAAM;IAC/B;IAEAnB,WAAWiB,QAAQP;IAEnB,MAAMc,YAAYP,OAAOQ,MAAM;IAC/B,MAAMC,WAAWnB,QAAQ;IACzB,MAAMoB,iBAAiBD,WAAWnB,QAAQiB;IAC1C,MAAMI,aAAaF,WAAWG,KAAKC,GAAG,CAAC,GAAGD,KAAKE,IAAI,CAACP,YAAYjB,UAAU;IAC1E,MAAMyB,WAAWN,WAAWG,KAAKC,GAAG,CAAC,GAAGrB,QAAQ;IAEhD,MAAMwB,QAAQP,WAAW,AAACM,CAAAA,WAAW,CAAA,IAAKzB,QAAQ;IAClD,MAAM2B,MAAMR,WAAWO,QAAQ1B,QAAQiB;IACvC,MAAMW,QAAQlB,OAAOmB,KAAK,CAACH,OAAOC;IAElC,MAAMG,cAAcX,YAAYM,WAAWJ;IAC3C,MAAMU,cAAcZ,YAAYM,WAAW;IAE3C,MAAMO,SAAyD;QAC7DtB,QAAQkB;QACRE;QACAC;QACA/B,OAAOoB;QACPa,UAAUH,cAAcL,WAAW,IAAI;QACvCvB,MAAMuB;QACNS,eAAef,WAAW,AAACM,CAAAA,WAAW,CAAA,IAAKzB,QAAQ,IAAI;QACvDmC,UAAUJ,cAAcN,WAAW,IAAI;QACvCR;QACAI;IACF;IACA,OAAOW;AACT,EAAC"}

package/dist/findGlobal.d.ts.map

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

package/dist/findGlobal.js

@@ -1,5 +1,6 @@
 import { GetCommand } from '@aws-sdk/lib-dynamodb';
 import { matchesWhere } from './utilities/matchesWhere.js';
+import { prepareGlobalWhere } from './utilities/prepareWhere.js';
 import { stripInternalKeys } from './utilities/stripInternalKeys.js';
 /**
  * Globals are singleton documents. Each lives at `pk = slug, sk = slug`, so
@@ -8,7 +9,7 @@ import { stripInternalKeys } from './utilities/stripInternalKeys.js';
  * The optional `where` is applied as a post-filter via `matchesWhere` —
  * Payload uses it sparingly (mostly for guards) and the row is already
  * in-memory, so a JS check is fine.
- */ export const findGlobal = async function findGlobal({ slug, where }) {
+ */ export const findGlobal = async function findGlobal({ slug, locale, where }) {
     const docClient = this.docClient;
     if (!docClient) {
         throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
@@ -25,7 +26,7 @@ import { stripInternalKeys } from './utilities/stripInternalKeys.js';
         return null;
     }
     const item = stripInternalKeys(result.Item);
-    if (where && !matchesWhere(item, where)) {
+    if (where && !matchesWhere(item, await prepareGlobalWhere(this, slug, where, locale))) {
         return null;
     }
     return item;

package/dist/findGlobal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/findGlobal.ts"],"sourcesContent":["import type { FindGlobal } from 'payload'\n\nimport { GetCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { matchesWhere } from './utilities/matchesWhere.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * Globals are singleton documents. Each lives at `pk = slug, sk = slug`, so\n * reads are a single `GetItem`.\n *\n * The optional `where` is applied as a post-filter via `matchesWhere` —\n * Payload uses it sparingly (mostly for guards) and the row is already\n * in-memory, so a JS check is fine.\n */\nexport const findGlobal: FindGlobal = async function findGlobal(\n  this: DynamoAdapter,\n  { slug, where },\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 result = await docClient.send(\n    new GetCommand({\n      TableName: this.tableName,\n      Key: { pk: this.resolvePartition(slug), sk: slug },\n      ConsistentRead: true,\n    }),\n  )\n\n  if (!result.Item) {\n    return null as never\n  }\n  const item = stripInternalKeys(result.Item)\n  if (where && !matchesWhere(item, where)) {\n    return null as never\n  }\n  return item as never\n}\n"],"names":["GetCommand","matchesWhere","stripInternalKeys","findGlobal","slug","where","docClient","Error","result","send","TableName","tableName","Key","pk","resolvePartition","sk","ConsistentRead","Item","item"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAIlD,SAASC,YAAY,QAAQ,8BAA6B;AAC1D,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;;;;CAOC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAEf,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,SAAS,MAAMF,UAAUG,IAAI,CACjC,IAAIT,WAAW;QACbU,WAAW,IAAI,CAACC,SAAS;QACzBC,KAAK;YAAEC,IAAI,IAAI,CAACC,gBAAgB,CAACV;YAAOW,IAAIX;QAAK;QACjDY,gBAAgB;IAClB;IAGF,IAAI,CAACR,OAAOS,IAAI,EAAE;QAChB,OAAO;IACT;IACA,MAAMC,OAAOhB,kBAAkBM,OAAOS,IAAI;IAC1C,IAAIZ,SAAS,CAACJ,aAAaiB,MAAMb,QAAQ;QACvC,OAAO;IACT;IACA,OAAOa;AACT,EAAC"}
+{"version":3,"sources":["../src/findGlobal.ts"],"sourcesContent":["import type { FindGlobal } from 'payload'\n\nimport { GetCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { matchesWhere } from './utilities/matchesWhere.js'\nimport { prepareGlobalWhere } from './utilities/prepareWhere.js'\nimport { stripInternalKeys } from './utilities/stripInternalKeys.js'\n\n/**\n * Globals are singleton documents. Each lives at `pk = slug, sk = slug`, so\n * reads are a single `GetItem`.\n *\n * The optional `where` is applied as a post-filter via `matchesWhere` —\n * Payload uses it sparingly (mostly for guards) and the row is already\n * in-memory, so a JS check is fine.\n */\nexport const findGlobal: FindGlobal = async function findGlobal(\n  this: DynamoAdapter,\n  { slug, locale, where },\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 result = await docClient.send(\n    new GetCommand({\n      TableName: this.tableName,\n      Key: { pk: this.resolvePartition(slug), sk: slug },\n      ConsistentRead: true,\n    }),\n  )\n\n  if (!result.Item) {\n    return null as never\n  }\n  const item = stripInternalKeys(result.Item)\n  if (where && !matchesWhere(item, await prepareGlobalWhere(this, slug, where, locale))) {\n    return null as never\n  }\n  return item as never\n}\n"],"names":["GetCommand","matchesWhere","prepareGlobalWhere","stripInternalKeys","findGlobal","slug","locale","where","docClient","Error","result","send","TableName","tableName","Key","pk","resolvePartition","sk","ConsistentRead","Item","item"],"mappings":"AAEA,SAASA,UAAU,QAAQ,wBAAuB;AAIlD,SAASC,YAAY,QAAQ,8BAA6B;AAC1D,SAASC,kBAAkB,QAAQ,8BAA6B;AAChE,SAASC,iBAAiB,QAAQ,mCAAkC;AAEpE;;;;;;;CAOC,GACD,OAAO,MAAMC,aAAyB,eAAeA,WAEnD,EAAEC,IAAI,EAAEC,MAAM,EAAEC,KAAK,EAAE;IAEvB,MAAMC,YAAY,IAAI,CAACA,SAAS;IAChC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,SAAS,MAAMF,UAAUG,IAAI,CACjC,IAAIX,WAAW;QACbY,WAAW,IAAI,CAACC,SAAS;QACzBC,KAAK;YAAEC,IAAI,IAAI,CAACC,gBAAgB,CAACX;YAAOY,IAAIZ;QAAK;QACjDa,gBAAgB;IAClB;IAGF,IAAI,CAACR,OAAOS,IAAI,EAAE;QAChB,OAAO;IACT;IACA,MAAMC,OAAOjB,kBAAkBO,OAAOS,IAAI;IAC1C,IAAIZ,SAAS,CAACN,aAAamB,MAAM,MAAMlB,mBAAmB,IAAI,EAAEG,MAAME,OAAOD,UAAU;QACrF,OAAO;IACT;IACA,OAAOc;AACT,EAAC"}

package/dist/findGlobalVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findGlobalVersions.d.ts","sourceRoot":"","sources":["../src/findGlobalVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAiB,MAAM,SAAS,CAAA;AAOhE,eAAO,MAAM,kBAAkB,EAAE,kBAkChC,CAAA"}
+{"version":3,"file":"findGlobalVersions.d.ts","sourceRoot":"","sources":["../src/findGlobalVersions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAiB,MAAM,SAAS,CAAA;AAQhE,eAAO,MAAM,kBAAkB,EAAE,kBAmChC,CAAA"}

package/dist/findGlobalVersions.js

@@ -1,9 +1,17 @@
 import { applySorts } from './utilities/applySorts.js';
+import { prepareSort, prepareVersionsWhere } from './utilities/prepareWhere.js';
 import { queryMatching } from './utilities/queryMatching.js';
-export const findGlobalVersions = async function findGlobalVersions({ global, limit = 10, page = 1, pagination = true, sort, where }) {
+export const findGlobalVersions = async function findGlobalVersions({ global, limit = 10, locale, page = 1, pagination = true, sort, where: rawWhere }) {
+    const where = await prepareVersionsWhere(this, {
+        kind: 'global',
+        slug: global
+    }, rawWhere, locale);
     const partition = this.resolveVersionsPartition(global);
     const matched = await queryMatching(this, partition, where);
-    applySorts(matched, sort);
+    applySorts(matched, prepareSort(this, {
+        kind: 'globalVersions',
+        slug: global
+    }, sort, locale));
     const totalDocs = matched.length;
     const useLimit = limit > 0;
     const safePage = useLimit ? Math.max(1, page) : 1;

package/dist/findGlobalVersions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/findGlobalVersions.ts"],"sourcesContent":["import type { FindGlobalVersions, PaginatedDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\nexport const findGlobalVersions: FindGlobalVersions = async function findGlobalVersions(\n  this: DynamoAdapter,\n  { global, limit = 10, page = 1, pagination = true, sort, where },\n) {\n  const partition = this.resolveVersionsPartition(global)\n  const matched = await queryMatching(this, partition, where)\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","queryMatching","findGlobalVersions","global","limit","page","pagination","sort","where","partition","resolveVersionsPartition","matched","totalDocs","length","useLimit","safePage","Math","max","start","end","docs","slice","effectiveLimit","totalPages","ceil","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,aAAa,QAAQ,+BAA8B;AAE5D,OAAO,MAAMC,qBAAyC,eAAeA,mBAEnE,EAAEC,MAAM,EAAEC,QAAQ,EAAE,EAAEC,OAAO,CAAC,EAAEC,aAAa,IAAI,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAEhE,MAAMC,YAAY,IAAI,CAACC,wBAAwB,CAACP;IAChD,MAAMQ,UAAU,MAAMV,cAAc,IAAI,EAAEQ,WAAWD;IACrDR,WAAWW,SAASJ;IAEpB,MAAMK,YAAYD,QAAQE,MAAM;IAChC,MAAMC,WAAWV,QAAQ;IACzB,MAAMW,WAAWD,WAAWE,KAAKC,GAAG,CAAC,GAAGZ,QAAQ;IAEhD,MAAMa,QAAQJ,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKX,QAAQ;IAClD,MAAMe,MAAML,WAAWI,QAAQd,QAAQQ;IACvC,MAAMQ,OAAOT,QAAQU,KAAK,CAACH,OAAOC;IAElC,MAAMG,iBAAiBR,WAAWV,QAAQQ;IAC1C,MAAMW,aAAajB,cAAcQ,WAAWE,KAAKC,GAAG,CAAC,GAAGD,KAAKQ,IAAI,CAACZ,YAAYR,UAAU;IACxF,MAAMqB,cAAcnB,cAAcQ,YAAYC,WAAWQ;IACzD,MAAMG,cAAcpB,cAAcQ,YAAYC,WAAW;IAEzD,MAAMY,SAAiD;QACrDP;QACAK;QACAC;QACAtB,OAAOkB;QACPM,UAAUH,cAAcV,WAAW,IAAI;QACvCV,MAAMU;QACNc,eAAef,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKX,QAAQ,IAAI;QACvD0B,UAAUJ,cAAcX,WAAW,IAAI;QACvCH;QACAW;IACF;IACA,OAAOI;AACT,EAAC"}
+{"version":3,"sources":["../src/findGlobalVersions.ts"],"sourcesContent":["import type { FindGlobalVersions, PaginatedDocs } from 'payload'\n\nimport type { DynamoAdapter } from './types.js'\n\nimport { applySorts } from './utilities/applySorts.js'\nimport { prepareSort, prepareVersionsWhere } from './utilities/prepareWhere.js'\nimport { queryMatching } from './utilities/queryMatching.js'\n\nexport const findGlobalVersions: FindGlobalVersions = async function findGlobalVersions(\n  this: DynamoAdapter,\n  { global, limit = 10, locale, page = 1, pagination = true, sort, where: rawWhere },\n) {\n  const where = await prepareVersionsWhere(this, { kind: 'global', slug: global }, rawWhere, locale)\n  const partition = this.resolveVersionsPartition(global)\n  const matched = await queryMatching(this, partition, where)\n  applySorts(matched, prepareSort(this, { kind: 'globalVersions', slug: global }, sort, locale))\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","prepareSort","prepareVersionsWhere","queryMatching","findGlobalVersions","global","limit","locale","page","pagination","sort","where","rawWhere","kind","slug","partition","resolveVersionsPartition","matched","totalDocs","length","useLimit","safePage","Math","max","start","end","docs","slice","effectiveLimit","totalPages","ceil","hasNextPage","hasPrevPage","result","nextPage","pagingCounter","prevPage"],"mappings":"AAIA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAASC,WAAW,EAAEC,oBAAoB,QAAQ,8BAA6B;AAC/E,SAASC,aAAa,QAAQ,+BAA8B;AAE5D,OAAO,MAAMC,qBAAyC,eAAeA,mBAEnE,EAAEC,MAAM,EAAEC,QAAQ,EAAE,EAAEC,MAAM,EAAEC,OAAO,CAAC,EAAEC,aAAa,IAAI,EAAEC,IAAI,EAAEC,OAAOC,QAAQ,EAAE;IAElF,MAAMD,QAAQ,MAAMT,qBAAqB,IAAI,EAAE;QAAEW,MAAM;QAAUC,MAAMT;IAAO,GAAGO,UAAUL;IAC3F,MAAMQ,YAAY,IAAI,CAACC,wBAAwB,CAACX;IAChD,MAAMY,UAAU,MAAMd,cAAc,IAAI,EAAEY,WAAWJ;IACrDX,WAAWiB,SAAShB,YAAY,IAAI,EAAE;QAAEY,MAAM;QAAkBC,MAAMT;IAAO,GAAGK,MAAMH;IAEtF,MAAMW,YAAYD,QAAQE,MAAM;IAChC,MAAMC,WAAWd,QAAQ;IACzB,MAAMe,WAAWD,WAAWE,KAAKC,GAAG,CAAC,GAAGf,QAAQ;IAEhD,MAAMgB,QAAQJ,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKf,QAAQ;IAClD,MAAMmB,MAAML,WAAWI,QAAQlB,QAAQY;IACvC,MAAMQ,OAAOT,QAAQU,KAAK,CAACH,OAAOC;IAElC,MAAMG,iBAAiBR,WAAWd,QAAQY;IAC1C,MAAMW,aAAapB,cAAcW,WAAWE,KAAKC,GAAG,CAAC,GAAGD,KAAKQ,IAAI,CAACZ,YAAYZ,UAAU;IACxF,MAAMyB,cAActB,cAAcW,YAAYC,WAAWQ;IACzD,MAAMG,cAAcvB,cAAcW,YAAYC,WAAW;IAEzD,MAAMY,SAAiD;QACrDP;QACAK;QACAC;QACA1B,OAAOsB;QACPM,UAAUH,cAAcV,WAAW,IAAI;QACvCb,MAAMa;QACNc,eAAef,WAAW,AAACC,CAAAA,WAAW,CAAA,IAAKf,QAAQ,IAAI;QACvD8B,UAAUJ,cAAcX,WAAW,IAAI;QACvCH;QACAW;IACF;IACA,OAAOI;AACT,EAAC"}

package/dist/findOne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findOne.d.ts","sourceRoot":"","sources":["../src/findOne.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAOtC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,OAcrB,CAAA"}
+{"version":3,"file":"findOne.d.ts","sourceRoot":"","sources":["../src/findOne.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAStC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,OAgBrB,CAAA"}

package/dist/findOne.js

@@ -1,22 +1,33 @@
 import { collectionHasDrafts, fetchDraftsOnlySupplements } from './utilities/draftsFallback.js';
 import { findFirst } from './utilities/findFirst.js';
+import { prepareCollectionWhere } from './utilities/prepareWhere.js';
+import { resolveJoins } from './utilities/resolveJoins.js';
 /**
  * Locate one doc in `collection` matching `where`. For drafts-enabled
  * collections, fall back to the `latest=true` version row when no main
  * partition row matches — that's how drafts-only docs (saved but never
  * published) become findable.
- */ export const findOne = async function findOne({ collection, where }) {
+ */ export const findOne = async function findOne({ collection, joins, locale, where: rawWhere }) {
+    const where = await prepareCollectionWhere(this, collection, rawWhere, locale);
     const partition = this.resolvePartition(collection);
-    const found = await findFirst(this, {
+    let doc = await findFirst(this, {
         partition,
         where
     });
-    if (found) return found;
-    if (collectionHasDrafts(this, collection)) {
+    if (!doc && collectionHasDrafts(this, collection)) {
         const supplements = await fetchDraftsOnlySupplements(this, collection, [], where);
-        if (supplements.length > 0) return supplements[0];
+        doc = supplements[0] ?? null;
     }
-    return null;
+    if (!doc) return null;
+    await resolveJoins(this, {
+        collectionSlug: collection,
+        docs: [
+            doc
+        ],
+        joins,
+        locale
+    });
+    return doc;
 };
 
 //# sourceMappingURL=findOne.js.map