@open-aih/payload-ddb 3.1.0 → 4.1.0

package/dist/utilities/queryMatching.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/queryMatching.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { QueryCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { buildFilterExpression } from './buildFilterExpression.js'\nimport { matchesWhere } from './matchesWhere.js'\nimport { whereHasJsOnlyOperator } from './operators.js'\nimport { stripInternalKeys } from './stripInternalKeys.js'\n\n/**\n * Walk a partition via paginated `Query` (`pk = :partition`), pushing the\n * caller's `where` into `FilterExpression` so non-matching rows are skipped\n * server-side. Returns every matching item materialized in memory — suitable\n * for callers that need the full set (sort, paginate, bulk-mutate).\n *\n * Use `findFirst` instead when you only need the first match: that helper\n * stops on the first hit.\n *\n * Cost note: `FilterExpression` reduces network bytes but not RCU\n * consumption. DynamoDB still reads every row in the partition before\n * filtering. The next meaningful optimization is GSIs that mirror specific\n * access patterns (e.g. `email` for auth, `slug` for public collections).\n */\nexport async function queryMatching(\n  adapter: DynamoAdapter,\n  partition: string,\n  where: undefined | Where,\n): Promise<Record<string, unknown>[]> {\n  const docClient = adapter.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  // When `where` uses an operator we can't faithfully push down (today: `like`,\n  // because Payload's contract is case-insensitive while DynamoDB's\n  // `contains()` isn't), we fetch the whole partition and evaluate in JS.\n  // Recurse with `where = undefined` to reuse the standard pagination loop.\n  if (whereHasJsOnlyOperator(where)) {\n    const all = await queryMatching(adapter, partition, undefined)\n    return all.filter((row) => matchesWhere(row, where))\n  }\n\n  const filter = buildFilterExpression(where)\n  // `null` signals an always-false predicate (e.g. `id: { in: [] }` from\n  // access control). Short-circuit so we don't pay for a Query just to\n  // return nothing.\n  if (filter === null) return []\n  const matched: Record<string, unknown>[] = []\n  let exclusiveStartKey: Record<string, unknown> | undefined\n\n  while (true) {\n    const result = await docClient.send(\n      new QueryCommand({\n        TableName: adapter.tableName,\n        KeyConditionExpression: '#pk = :pk',\n        ExpressionAttributeNames: {\n          '#pk': 'pk',\n          ...(filter?.names ?? {}),\n        },\n        ExpressionAttributeValues: {\n          ':pk': partition,\n          ...(filter?.values ?? {}),\n        },\n        // Strong consistency by default — Payload assumes read-after-write\n        // visibility (Mongo/Postgres do), and DynamoDB's default eventual\n        // consistency breaks \"create-then-list\" flows. 2x RCU but correct.\n        ConsistentRead: true,\n        ...(filter ? { FilterExpression: filter.expression } : {}),\n        ...(exclusiveStartKey ? { ExclusiveStartKey: exclusiveStartKey } : {}),\n      }),\n    )\n    for (const item of result.Items ?? []) {\n      matched.push(stripInternalKeys(item))\n    }\n    if (!result.LastEvaluatedKey) break\n    exclusiveStartKey = result.LastEvaluatedKey\n  }\n\n  return matched\n}\n"],"names":["QueryCommand","buildFilterExpression","matchesWhere","whereHasJsOnlyOperator","stripInternalKeys","queryMatching","adapter","partition","where","docClient","Error","all","undefined","filter","row","matched","exclusiveStartKey","result","send","TableName","tableName","KeyConditionExpression","ExpressionAttributeNames","names","ExpressionAttributeValues","values","ConsistentRead","FilterExpression","expression","ExclusiveStartKey","item","Items","push","LastEvaluatedKey"],"mappings":"AAEA,SAASA,YAAY,QAAQ,wBAAuB;AAIpD,SAASC,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,iBAAiB,QAAQ,yBAAwB;AAE1D;;;;;;;;;;;;;CAaC,GACD,OAAO,eAAeC,cACpBC,OAAsB,EACtBC,SAAiB,EACjBC,KAAwB;IAExB,MAAMC,YAAYH,QAAQG,SAAS;IACnC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,8EAA8E;IAC9E,kEAAkE;IAClE,wEAAwE;IACxE,0EAA0E;IAC1E,IAAIP,uBAAuBK,QAAQ;QACjC,MAAMG,MAAM,MAAMN,cAAcC,SAASC,WAAWK;QACpD,OAAOD,IAAIE,MAAM,CAAC,CAACC,MAAQZ,aAAaY,KAAKN;IAC/C;IAEA,MAAMK,SAASZ,sBAAsBO;IACrC,uEAAuE;IACvE,qEAAqE;IACrE,kBAAkB;IAClB,IAAIK,WAAW,MAAM,OAAO,EAAE;IAC9B,MAAME,UAAqC,EAAE;IAC7C,IAAIC;IAEJ,MAAO,KAAM;QACX,MAAMC,SAAS,MAAMR,UAAUS,IAAI,CACjC,IAAIlB,aAAa;YACfmB,WAAWb,QAAQc,SAAS;YAC5BC,wBAAwB;YACxBC,0BAA0B;gBACxB,OAAO;gBACP,GAAIT,QAAQU,SAAS,CAAC,CAAC;YACzB;YACAC,2BAA2B;gBACzB,OAAOjB;gBACP,GAAIM,QAAQY,UAAU,CAAC,CAAC;YAC1B;YACA,mEAAmE;YACnE,kEAAkE;YAClE,mEAAmE;YACnEC,gBAAgB;YAChB,GAAIb,SAAS;gBAAEc,kBAAkBd,OAAOe,UAAU;YAAC,IAAI,CAAC,CAAC;YACzD,GAAIZ,oBAAoB;gBAAEa,mBAAmBb;YAAkB,IAAI,CAAC,CAAC;QACvE;QAEF,KAAK,MAAMc,QAAQb,OAAOc,KAAK,IAAI,EAAE,CAAE;YACrChB,QAAQiB,IAAI,CAAC5B,kBAAkB0B;QACjC;QACA,IAAI,CAACb,OAAOgB,gBAAgB,EAAE;QAC9BjB,oBAAoBC,OAAOgB,gBAAgB;IAC7C;IAEA,OAAOlB;AACT"}
+{"version":3,"sources":["../../src/utilities/queryMatching.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { buildFilterExpression } from './buildFilterExpression.js'\nimport { matchesWhere } from './matchesWhere.js'\nimport { partitionPages } from './queryPartition.js'\nimport { stripInternalKeys } from './stripInternalKeys.js'\n\n/**\n * Walk a partition, pushing as much of the caller's `where` into\n * `FilterExpression` as DynamoDB can express so non-matching rows are skipped\n * server-side. Returns every matching item materialized in memory — suitable\n * for callers that need the full set (sort, paginate, bulk-mutate).\n *\n * When the pushed-down filter isn't the whole `where` (a JS-only operator\n * such as `like`, or a path through an array), each returned row is\n * re-checked with `matchesWhere`. The expressible clauses still narrow the\n * read, so a `where` that mixes both kinds no longer pulls the entire\n * partition over the wire.\n *\n * Use `findFirst` instead when you only need the first match: that helper\n * stops on the first hit.\n */\nexport async function queryMatching(\n  adapter: DynamoAdapter,\n  partition: string,\n  where: undefined | Where,\n): Promise<Record<string, unknown>[]> {\n  const compiled = buildFilterExpression(where)\n  // Always-false predicate (e.g. `id: { in: [] }` from access control).\n  // Short-circuit so we don't pay for a Query just to return nothing.\n  if (compiled.never) return []\n\n  const matched: Record<string, unknown>[] = []\n  for await (const page of partitionPages(adapter, partition, compiled.filter)) {\n    for (const item of page.items) {\n      const row = stripInternalKeys(item)\n      if (compiled.exact || matchesWhere(row, where)) matched.push(row)\n    }\n  }\n  return matched\n}\n"],"names":["buildFilterExpression","matchesWhere","partitionPages","stripInternalKeys","queryMatching","adapter","partition","where","compiled","never","matched","page","filter","item","items","row","exact","push"],"mappings":"AAIA,SAASA,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,cAAc,QAAQ,sBAAqB;AACpD,SAASC,iBAAiB,QAAQ,yBAAwB;AAE1D;;;;;;;;;;;;;;CAcC,GACD,OAAO,eAAeC,cACpBC,OAAsB,EACtBC,SAAiB,EACjBC,KAAwB;IAExB,MAAMC,WAAWR,sBAAsBO;IACvC,sEAAsE;IACtE,oEAAoE;IACpE,IAAIC,SAASC,KAAK,EAAE,OAAO,EAAE;IAE7B,MAAMC,UAAqC,EAAE;IAC7C,WAAW,MAAMC,QAAQT,eAAeG,SAASC,WAAWE,SAASI,MAAM,EAAG;QAC5E,KAAK,MAAMC,QAAQF,KAAKG,KAAK,CAAE;YAC7B,MAAMC,MAAMZ,kBAAkBU;YAC9B,IAAIL,SAASQ,KAAK,IAAIf,aAAac,KAAKR,QAAQG,QAAQO,IAAI,CAACF;QAC/D;IACF;IACA,OAAOL;AACT"}

package/dist/utilities/queryPartition.d.ts

@@ -0,0 +1,26 @@
+import type { DynamoAdapter } from '../types.js';
+import type { FilterExpression } from './buildFilterExpression.js';
+export type PartitionPage = {
+    /** Rows on this page that passed the filter (`Count`). */
+    count: number;
+    /** The rows themselves; empty when `countOnly` is set. */
+    items: Record<string, unknown>[];
+};
+/**
+ * Walk one partition (`pk = :partition`) page by page with an optional
+ * `FilterExpression`. The single place the adapter issues a `Query`, shared
+ * by `queryMatching`, `queryCount` and `findFirst` — each decides what to do
+ * with the pages (collect, count, stop at the first hit).
+ *
+ * Cost note: `FilterExpression` reduces network bytes but not RCU
+ * consumption. DynamoDB still reads every row in the partition before
+ * filtering. The next meaningful optimization is GSIs that mirror specific
+ * access patterns (e.g. `email` for auth, `slug` for public collections).
+ *
+ * With `countOnly`, `Select: 'COUNT'` keeps DynamoDB from shipping item
+ * bytes — only the post-filter `Count` per page comes back over the wire.
+ */
+export declare function partitionPages(adapter: DynamoAdapter, partition: string, filter: FilterExpression | undefined, options?: {
+    countOnly?: boolean;
+}): AsyncGenerator<PartitionPage>;
+//# sourceMappingURL=queryPartition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryPartition.d.ts","sourceRoot":"","sources":["../../src/utilities/queryPartition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,cAAc,CACnC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACpC,cAAc,CAAC,aAAa,CAAC,CAkC/B"}

package/dist/utilities/queryPartition.js

@@ -0,0 +1,55 @@
+import { QueryCommand } from '@aws-sdk/lib-dynamodb';
+/**
+ * Walk one partition (`pk = :partition`) page by page with an optional
+ * `FilterExpression`. The single place the adapter issues a `Query`, shared
+ * by `queryMatching`, `queryCount` and `findFirst` — each decides what to do
+ * with the pages (collect, count, stop at the first hit).
+ *
+ * Cost note: `FilterExpression` reduces network bytes but not RCU
+ * consumption. DynamoDB still reads every row in the partition before
+ * filtering. The next meaningful optimization is GSIs that mirror specific
+ * access patterns (e.g. `email` for auth, `slug` for public collections).
+ *
+ * With `countOnly`, `Select: 'COUNT'` keeps DynamoDB from shipping item
+ * bytes — only the post-filter `Count` per page comes back over the wire.
+ */ export async function* partitionPages(adapter, partition, filter, options = {}) {
+    const docClient = adapter.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    let exclusiveStartKey;
+    do {
+        const result = await docClient.send(new QueryCommand({
+            TableName: adapter.tableName,
+            KeyConditionExpression: '#pk = :pk',
+            ExpressionAttributeNames: {
+                '#pk': 'pk',
+                ...filter?.names ?? {}
+            },
+            ExpressionAttributeValues: {
+                ':pk': partition,
+                ...filter?.values ?? {}
+            },
+            // Strong consistency by default — Payload assumes read-after-write
+            // visibility (Mongo/Postgres do), and DynamoDB's default eventual
+            // consistency breaks "create-then-list" flows. 2x RCU but correct.
+            ConsistentRead: true,
+            ...options.countOnly ? {
+                Select: 'COUNT'
+            } : {},
+            ...filter ? {
+                FilterExpression: filter.expression
+            } : {},
+            ...exclusiveStartKey ? {
+                ExclusiveStartKey: exclusiveStartKey
+            } : {}
+        }));
+        yield {
+            count: result.Count ?? 0,
+            items: result.Items ?? []
+        };
+        exclusiveStartKey = result.LastEvaluatedKey;
+    }while (exclusiveStartKey)
+}
+
+//# sourceMappingURL=queryPartition.js.map

package/dist/utilities/queryPartition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/queryPartition.ts"],"sourcesContent":["import { QueryCommand } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from '../types.js'\nimport type { FilterExpression } from './buildFilterExpression.js'\n\nexport type PartitionPage = {\n  /** Rows on this page that passed the filter (`Count`). */\n  count: number\n  /** The rows themselves; empty when `countOnly` is set. */\n  items: Record<string, unknown>[]\n}\n\n/**\n * Walk one partition (`pk = :partition`) page by page with an optional\n * `FilterExpression`. The single place the adapter issues a `Query`, shared\n * by `queryMatching`, `queryCount` and `findFirst` — each decides what to do\n * with the pages (collect, count, stop at the first hit).\n *\n * Cost note: `FilterExpression` reduces network bytes but not RCU\n * consumption. DynamoDB still reads every row in the partition before\n * filtering. The next meaningful optimization is GSIs that mirror specific\n * access patterns (e.g. `email` for auth, `slug` for public collections).\n *\n * With `countOnly`, `Select: 'COUNT'` keeps DynamoDB from shipping item\n * bytes — only the post-filter `Count` per page comes back over the wire.\n */\nexport async function* partitionPages(\n  adapter: DynamoAdapter,\n  partition: string,\n  filter: FilterExpression | undefined,\n  options: { countOnly?: boolean } = {},\n): AsyncGenerator<PartitionPage> {\n  const docClient = adapter.docClient\n  if (!docClient) {\n    throw new Error('payload-ddb: docClient is not initialized — call connect() first.')\n  }\n\n  let exclusiveStartKey: Record<string, unknown> | undefined\n\n  do {\n    const result = await docClient.send(\n      new QueryCommand({\n        TableName: adapter.tableName,\n        KeyConditionExpression: '#pk = :pk',\n        ExpressionAttributeNames: {\n          '#pk': 'pk',\n          ...(filter?.names ?? {}),\n        },\n        ExpressionAttributeValues: {\n          ':pk': partition,\n          ...(filter?.values ?? {}),\n        },\n        // Strong consistency by default — Payload assumes read-after-write\n        // visibility (Mongo/Postgres do), and DynamoDB's default eventual\n        // consistency breaks \"create-then-list\" flows. 2x RCU but correct.\n        ConsistentRead: true,\n        ...(options.countOnly ? { Select: 'COUNT' as const } : {}),\n        ...(filter ? { FilterExpression: filter.expression } : {}),\n        ...(exclusiveStartKey ? { ExclusiveStartKey: exclusiveStartKey } : {}),\n      }),\n    )\n\n    yield { count: result.Count ?? 0, items: result.Items ?? [] }\n    exclusiveStartKey = result.LastEvaluatedKey\n  } while (exclusiveStartKey)\n}\n"],"names":["QueryCommand","partitionPages","adapter","partition","filter","options","docClient","Error","exclusiveStartKey","result","send","TableName","tableName","KeyConditionExpression","ExpressionAttributeNames","names","ExpressionAttributeValues","values","ConsistentRead","countOnly","Select","FilterExpression","expression","ExclusiveStartKey","count","Count","items","Items","LastEvaluatedKey"],"mappings":"AAAA,SAASA,YAAY,QAAQ,wBAAuB;AAYpD;;;;;;;;;;;;;CAaC,GACD,OAAO,gBAAgBC,eACrBC,OAAsB,EACtBC,SAAiB,EACjBC,MAAoC,EACpCC,UAAmC,CAAC,CAAC;IAErC,MAAMC,YAAYJ,QAAQI,SAAS;IACnC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIC;IAEJ,GAAG;QACD,MAAMC,SAAS,MAAMH,UAAUI,IAAI,CACjC,IAAIV,aAAa;YACfW,WAAWT,QAAQU,SAAS;YAC5BC,wBAAwB;YACxBC,0BAA0B;gBACxB,OAAO;gBACP,GAAIV,QAAQW,SAAS,CAAC,CAAC;YACzB;YACAC,2BAA2B;gBACzB,OAAOb;gBACP,GAAIC,QAAQa,UAAU,CAAC,CAAC;YAC1B;YACA,mEAAmE;YACnE,kEAAkE;YAClE,mEAAmE;YACnEC,gBAAgB;YAChB,GAAIb,QAAQc,SAAS,GAAG;gBAAEC,QAAQ;YAAiB,IAAI,CAAC,CAAC;YACzD,GAAIhB,SAAS;gBAAEiB,kBAAkBjB,OAAOkB,UAAU;YAAC,IAAI,CAAC,CAAC;YACzD,GAAId,oBAAoB;gBAAEe,mBAAmBf;YAAkB,IAAI,CAAC,CAAC;QACvE;QAGF,MAAM;YAAEgB,OAAOf,OAAOgB,KAAK,IAAI;YAAGC,OAAOjB,OAAOkB,KAAK,IAAI,EAAE;QAAC;QAC5DnB,oBAAoBC,OAAOmB,gBAAgB;IAC7C,QAASpB,kBAAkB;AAC7B"}

package/dist/utilities/resolveJoins.d.ts

@@ -0,0 +1,37 @@
+import type { JoinQuery } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Fill in `join` fields on documents that have just been read.
+ *
+ * A join field stores nothing on its own document: `category.posts` is
+ * "every post whose `category` points at this category". Payload hands the
+ * adapter the joins it wants (`joins`, keyed by join path) and expects each
+ * document to come back with
+ *
+ *     { docs: [...ids], hasNextPage: boolean, totalDocs?: number }
+ *
+ * at that path — ids only; core populates them to the requested depth. For a
+ * polymorphic join (`collection: [...]`) each entry is
+ * `{ relationTo, value }` instead.
+ *
+ * Strategy, following the JS join resolution in Payload's Mongo adapter: one
+ * query per target collection for *all* parents at once (`on in [parent
+ * ids]`, AND-ed with the join's own `where`), then group the results by
+ * parent in memory. Sorting, paging and counting are done per parent, so
+ * `limit` means "this many per document", as it does with the other
+ * adapters' native joins.
+ *
+ * Only joins named in `joins` with a truthy value run; `joins: false` and
+ * `joins[path]: false` leave documents untouched. Joined documents are read
+ * from the target's main partition — drafts that were never published are
+ * not included.
+ *
+ * Mutates `docs` in place.
+ */
+export declare function resolveJoins(adapter: DynamoAdapter, args: {
+    collectionSlug: string;
+    docs: Record<string, unknown>[];
+    joins: JoinQuery | undefined;
+    locale?: string | undefined;
+}): Promise<void>;
+//# sourceMappingURL=resolveJoins.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveJoins.d.ts","sourceRoot":"","sources":["../../src/utilities/resolveJoins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,SAAS,CAAA;AAI/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAchD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE;IACJ,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;IAC/B,KAAK,EAAE,SAAS,GAAG,SAAS,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B,GACA,OAAO,CAAC,IAAI,CAAC,CAiHf"}

package/dist/utilities/resolveJoins.js

@@ -0,0 +1,195 @@
+import { fieldShouldBeLocalized } from 'payload/shared';
+import { applySorts } from './applySorts.js';
+import { candidatesAt } from './matchesWhere.js';
+import { effectiveLocale, prepareCollectionWhere, prepareSort, resolveStoredPath } from './prepareWhere.js';
+import { queryMatching } from './queryMatching.js';
+/**
+ * Fill in `join` fields on documents that have just been read.
+ *
+ * A join field stores nothing on its own document: `category.posts` is
+ * "every post whose `category` points at this category". Payload hands the
+ * adapter the joins it wants (`joins`, keyed by join path) and expects each
+ * document to come back with
+ *
+ *     { docs: [...ids], hasNextPage: boolean, totalDocs?: number }
+ *
+ * at that path — ids only; core populates them to the requested depth. For a
+ * polymorphic join (`collection: [...]`) each entry is
+ * `{ relationTo, value }` instead.
+ *
+ * Strategy, following the JS join resolution in Payload's Mongo adapter: one
+ * query per target collection for *all* parents at once (`on in [parent
+ * ids]`, AND-ed with the join's own `where`), then group the results by
+ * parent in memory. Sorting, paging and counting are done per parent, so
+ * `limit` means "this many per document", as it does with the other
+ * adapters' native joins.
+ *
+ * Only joins named in `joins` with a truthy value run; `joins: false` and
+ * `joins[path]: false` leave documents untouched. Joined documents are read
+ * from the target's main partition — drafts that were never published are
+ * not included.
+ *
+ * Mutates `docs` in place.
+ */ export async function resolveJoins(adapter, args) {
+    const { collectionSlug, docs, joins, locale } = args;
+    if (!joins || docs.length === 0) return;
+    const collectionConfig = adapter.payload?.collections?.[collectionSlug]?.config;
+    if (!collectionConfig) return;
+    const definitions = new Map();
+    for (const [target, list] of Object.entries(collectionConfig.joins ?? {})){
+        for (const join of list)definitions.set(join.joinPath, {
+            join,
+            targets: [
+                target
+            ]
+        });
+    }
+    for (const join of collectionConfig.polymorphicJoins ?? []){
+        const { collection } = join.field;
+        definitions.set(join.joinPath, {
+            join,
+            targets: Array.isArray(collection) ? collection : [
+                collection
+            ]
+        });
+    }
+    const parentIds = docs.map((doc)=>doc['id']);
+    const parentKeys = new Set(parentIds.map(String));
+    for (const [joinPath, joinQuery] of Object.entries(joins)){
+        if (!joinQuery || typeof joinQuery !== 'object') continue;
+        const definition = definitions.get(joinPath);
+        if (!definition) continue;
+        const { join } = definition;
+        const query = joinQuery;
+        const polymorphicJoin = Array.isArray(join.field.collection);
+        const limit = query.limit ?? join.field.defaultLimit ?? 10;
+        const skip = (Math.max(1, query.page ?? 1) - 1) * limit;
+        const { targets, where: joinWhere } = polymorphicJoin ? narrowTargets(definition.targets, query.where) : {
+            targets: definition.targets,
+            where: query.where
+        };
+        // parent key → joined rows, in the order the targets were read.
+        const grouped = new Map();
+        for (const target of targets){
+            const targetConfig = adapter.payload.collections?.[target]?.config;
+            if (!targetConfig) continue;
+            const on = join.field.on;
+            // Look the `on` field up on each target: a polymorphic join has no
+            // single target field, and the path may need a locale key.
+            const stored = resolveStoredPath(adapter, {
+                kind: 'collection',
+                slug: target
+            }, on, locale);
+            const polymorphicTarget = stored.field !== null && 'relationTo' in stored.field && Array.isArray(stored.field.relationTo);
+            const pointsAtParents = polymorphicTarget ? {
+                [`${on}.relationTo`]: {
+                    equals: collectionSlug
+                },
+                [`${on}.value`]: {
+                    in: parentIds
+                }
+            } : {
+                [on]: {
+                    in: parentIds
+                }
+            };
+            const rows = await queryMatching(adapter, adapter.resolvePartition(target), await prepareCollectionWhere(adapter, target, joinWhere ? {
+                and: [
+                    joinWhere,
+                    pointsAtParents
+                ]
+            } : pointsAtParents, locale));
+            const sort = query.sort || join.field.defaultSort || targetConfig.defaultSort || '-createdAt';
+            applySorts(rows, prepareSort(adapter, {
+                kind: 'collection',
+                slug: target
+            }, sort, locale));
+            for (const row of rows){
+                // A hasMany `on` field can name several parents; a row joins each of
+                // them once.
+                const owners = new Set();
+                for (const candidate of candidatesAt(row, stored.path)){
+                    const key = ownerKey(candidate, collectionSlug);
+                    if (key !== null && parentKeys.has(key)) owners.add(key);
+                }
+                for (const key of owners){
+                    const list = grouped.get(key) ?? [];
+                    list.push({
+                        relationTo: target,
+                        row
+                    });
+                    grouped.set(key, list);
+                }
+            }
+        }
+        const joinLocale = fieldShouldBeLocalized({
+            field: join.field,
+            parentIsLocalized: join.parentIsLocalized
+        }) && effectiveLocale(adapter, locale);
+        const writePath = joinLocale ? `${joinPath}.${joinLocale}` : joinPath;
+        for (const doc of docs){
+            const all = grouped.get(String(doc['id'])) ?? [];
+            const page = limit === 0 ? all : all.slice(skip, skip + limit);
+            setByPath(doc, writePath, {
+                docs: page.map(({ relationTo, row })=>polymorphicJoin ? {
+                        relationTo,
+                        value: row['id']
+                    } : row['id']),
+                hasNextPage: limit !== 0 && all.length > skip + page.length,
+                ...query.count ? {
+                    totalDocs: all.length
+                } : {}
+            });
+        }
+    }
+}
+/**
+ * The parent a stored `on` value points at, as a string key: a bare id, or
+ * the `value` of a polymorphic `{ relationTo, value }` aimed at this
+ * collection. `null` for anything else.
+ */ function ownerKey(candidate, collectionSlug) {
+    if (typeof candidate === 'string' || typeof candidate === 'number') return String(candidate);
+    if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+        const { relationTo, value } = candidate;
+        if (relationTo === collectionSlug && (typeof value === 'string' || typeof value === 'number')) {
+            return String(value);
+        }
+    }
+    return null;
+}
+/**
+ * A polymorphic join's `where` may carry a top-level `relationTo` clause to
+ * pick which target collections to read. It isn't a field on the targets, so
+ * lift it out and return the rest.
+ */ function narrowTargets(targets, where) {
+    const clause = where?.['relationTo'];
+    if (!where || !clause || typeof clause !== 'object' || Array.isArray(clause)) {
+        return {
+            targets,
+            where
+        };
+    }
+    const { equals, in: within } = clause;
+    const wanted = Array.isArray(within) ? within : equals !== undefined ? [
+        equals
+    ] : null;
+    const { relationTo: _relationTo, ...rest } = where;
+    return {
+        targets: wanted ? targets.filter((target)=>wanted.includes(target)) : targets,
+        where: Object.keys(rest).length > 0 ? rest : undefined
+    };
+}
+function setByPath(target, path, value) {
+    const segments = path.split('.');
+    let cursor = target;
+    for (const segment of segments.slice(0, -1)){
+        const next = cursor[segment];
+        if (!next || typeof next !== 'object' || Array.isArray(next)) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+    cursor[segments[segments.length - 1]] = value;
+}
+
+//# sourceMappingURL=resolveJoins.js.map

package/dist/utilities/resolveJoins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/resolveJoins.ts"],"sourcesContent":["import type { JoinQuery, SanitizedJoins, Where } from 'payload'\n\nimport { fieldShouldBeLocalized } from 'payload/shared'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { applySorts } from './applySorts.js'\nimport { candidatesAt } from './matchesWhere.js'\nimport {\n  effectiveLocale,\n  prepareCollectionWhere,\n  prepareSort,\n  resolveStoredPath,\n} from './prepareWhere.js'\nimport { queryMatching } from './queryMatching.js'\n\ntype SanitizedJoin = SanitizedJoins[string][number]\n\n/**\n * Fill in `join` fields on documents that have just been read.\n *\n * A join field stores nothing on its own document: `category.posts` is\n * \"every post whose `category` points at this category\". Payload hands the\n * adapter the joins it wants (`joins`, keyed by join path) and expects each\n * document to come back with\n *\n *     { docs: [...ids], hasNextPage: boolean, totalDocs?: number }\n *\n * at that path — ids only; core populates them to the requested depth. For a\n * polymorphic join (`collection: [...]`) each entry is\n * `{ relationTo, value }` instead.\n *\n * Strategy, following the JS join resolution in Payload's Mongo adapter: one\n * query per target collection for *all* parents at once (`on in [parent\n * ids]`, AND-ed with the join's own `where`), then group the results by\n * parent in memory. Sorting, paging and counting are done per parent, so\n * `limit` means \"this many per document\", as it does with the other\n * adapters' native joins.\n *\n * Only joins named in `joins` with a truthy value run; `joins: false` and\n * `joins[path]: false` leave documents untouched. Joined documents are read\n * from the target's main partition — drafts that were never published are\n * not included.\n *\n * Mutates `docs` in place.\n */\nexport async function resolveJoins(\n  adapter: DynamoAdapter,\n  args: {\n    collectionSlug: string\n    docs: Record<string, unknown>[]\n    joins: JoinQuery | undefined\n    locale?: string | undefined\n  },\n): Promise<void> {\n  const { collectionSlug, docs, joins, locale } = args\n  if (!joins || docs.length === 0) return\n\n  const collectionConfig = adapter.payload?.collections?.[collectionSlug]?.config\n  if (!collectionConfig) return\n\n  const definitions = new Map<string, { join: SanitizedJoin; targets: string[] }>()\n  for (const [target, list] of Object.entries(collectionConfig.joins ?? {})) {\n    for (const join of list) definitions.set(join.joinPath, { join, targets: [target] })\n  }\n  for (const join of collectionConfig.polymorphicJoins ?? []) {\n    const { collection } = join.field\n    definitions.set(join.joinPath, {\n      join,\n      targets: Array.isArray(collection) ? collection : [collection],\n    })\n  }\n\n  const parentIds = docs.map((doc) => doc['id'])\n  const parentKeys = new Set(parentIds.map(String))\n\n  for (const [joinPath, joinQuery] of Object.entries(joins as Record<string, unknown>)) {\n    if (!joinQuery || typeof joinQuery !== 'object') continue\n    const definition = definitions.get(joinPath)\n    if (!definition) continue\n\n    const { join } = definition\n    const query = joinQuery as {\n      count?: boolean\n      limit?: number\n      page?: number\n      sort?: string\n      where?: Where\n    }\n    const polymorphicJoin = Array.isArray(join.field.collection)\n    const limit = query.limit ?? join.field.defaultLimit ?? 10\n    const skip = (Math.max(1, query.page ?? 1) - 1) * limit\n\n    const { targets, where: joinWhere } = polymorphicJoin\n      ? narrowTargets(definition.targets, query.where)\n      : { targets: definition.targets, where: query.where }\n\n    // parent key → joined rows, in the order the targets were read.\n    const grouped = new Map<string, { relationTo: string; row: Record<string, unknown> }[]>()\n\n    for (const target of targets) {\n      const targetConfig = adapter.payload.collections?.[target]?.config\n      if (!targetConfig) continue\n\n      const on = join.field.on\n      // Look the `on` field up on each target: a polymorphic join has no\n      // single target field, and the path may need a locale key.\n      const stored = resolveStoredPath(adapter, { kind: 'collection', slug: target }, on, locale)\n      const polymorphicTarget =\n        stored.field !== null &&\n        'relationTo' in stored.field &&\n        Array.isArray(stored.field.relationTo)\n      const pointsAtParents: Where = polymorphicTarget\n        ? {\n            [`${on}.relationTo`]: { equals: collectionSlug },\n            [`${on}.value`]: { in: parentIds as never },\n          }\n        : { [on]: { in: parentIds as never } }\n\n      const rows = await queryMatching(\n        adapter,\n        adapter.resolvePartition(target),\n        await prepareCollectionWhere(\n          adapter,\n          target,\n          joinWhere ? { and: [joinWhere, pointsAtParents] } : pointsAtParents,\n          locale,\n        ),\n      )\n\n      const sort =\n        query.sort || join.field.defaultSort || targetConfig.defaultSort || '-createdAt'\n      applySorts(rows, prepareSort(adapter, { kind: 'collection', slug: target }, sort, locale))\n\n      for (const row of rows) {\n        // A hasMany `on` field can name several parents; a row joins each of\n        // them once.\n        const owners = new Set<string>()\n        for (const candidate of candidatesAt(row, stored.path)) {\n          const key = ownerKey(candidate, collectionSlug)\n          if (key !== null && parentKeys.has(key)) owners.add(key)\n        }\n        for (const key of owners) {\n          const list = grouped.get(key) ?? []\n          list.push({ relationTo: target, row })\n          grouped.set(key, list)\n        }\n      }\n    }\n\n    const joinLocale =\n      fieldShouldBeLocalized({ field: join.field, parentIsLocalized: join.parentIsLocalized }) &&\n      effectiveLocale(adapter, locale)\n    const writePath = joinLocale ? `${joinPath}.${joinLocale}` : joinPath\n\n    for (const doc of docs) {\n      const all = grouped.get(String(doc['id'])) ?? []\n      const page = limit === 0 ? all : all.slice(skip, skip + limit)\n      setByPath(doc, writePath, {\n        docs: page.map(({ relationTo, row }) =>\n          polymorphicJoin ? { relationTo, value: row['id'] } : row['id'],\n        ),\n        hasNextPage: limit !== 0 && all.length > skip + page.length,\n        ...(query.count ? { totalDocs: all.length } : {}),\n      })\n    }\n  }\n}\n\n/**\n * The parent a stored `on` value points at, as a string key: a bare id, or\n * the `value` of a polymorphic `{ relationTo, value }` aimed at this\n * collection. `null` for anything else.\n */\nfunction ownerKey(candidate: unknown, collectionSlug: string): null | string {\n  if (typeof candidate === 'string' || typeof candidate === 'number') return String(candidate)\n  if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {\n    const { relationTo, value } = candidate as { relationTo?: unknown; value?: unknown }\n    if (relationTo === collectionSlug && (typeof value === 'string' || typeof value === 'number')) {\n      return String(value)\n    }\n  }\n  return null\n}\n\n/**\n * A polymorphic join's `where` may carry a top-level `relationTo` clause to\n * pick which target collections to read. It isn't a field on the targets, so\n * lift it out and return the rest.\n */\nfunction narrowTargets(\n  targets: string[],\n  where: undefined | Where,\n): { targets: string[]; where: undefined | Where } {\n  const clause = where?.['relationTo']\n  if (!where || !clause || typeof clause !== 'object' || Array.isArray(clause)) {\n    return { targets, where }\n  }\n  const { equals, in: within } = clause as { equals?: unknown; in?: unknown }\n  const wanted = Array.isArray(within) ? within : equals !== undefined ? [equals] : null\n  const { relationTo: _relationTo, ...rest } = where\n  return {\n    targets: wanted ? targets.filter((target) => wanted.includes(target)) : targets,\n    where: Object.keys(rest).length > 0 ? (rest as Where) : undefined,\n  }\n}\n\nfunction setByPath(target: Record<string, unknown>, path: string, value: unknown): void {\n  const segments = path.split('.')\n  let cursor = target\n  for (const segment of segments.slice(0, -1)) {\n    const next = cursor[segment]\n    if (!next || typeof next !== 'object' || Array.isArray(next)) {\n      cursor[segment] = {}\n    }\n    cursor = cursor[segment] as Record<string, unknown>\n  }\n  cursor[segments[segments.length - 1]!] = value\n}\n"],"names":["fieldShouldBeLocalized","applySorts","candidatesAt","effectiveLocale","prepareCollectionWhere","prepareSort","resolveStoredPath","queryMatching","resolveJoins","adapter","args","collectionSlug","docs","joins","locale","length","collectionConfig","payload","collections","config","definitions","Map","target","list","Object","entries","join","set","joinPath","targets","polymorphicJoins","collection","field","Array","isArray","parentIds","map","doc","parentKeys","Set","String","joinQuery","definition","get","query","polymorphicJoin","limit","defaultLimit","skip","Math","max","page","where","joinWhere","narrowTargets","grouped","targetConfig","on","stored","kind","slug","polymorphicTarget","relationTo","pointsAtParents","equals","in","rows","resolvePartition","and","sort","defaultSort","row","owners","candidate","path","key","ownerKey","has","add","push","joinLocale","parentIsLocalized","writePath","all","slice","setByPath","value","hasNextPage","count","totalDocs","clause","within","wanted","undefined","_relationTo","rest","filter","includes","keys","segments","split","cursor","segment","next"],"mappings":"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"}

package/dist/utilities/stripInternalKeys.d.ts

@@ -1,7 +1,21 @@
 /**
- * Drop the adapter's internal `pk`/`sk` attributes from a row before it
- * crosses the boundary back into Payload land. Callers see clean documents
- * keyed by the user-facing `id`; the composite-key plumbing stays internal.
+ * Drop the adapter's internal attributes (`pk`, `sk`, `_rev`) from a row
+ * before it crosses the boundary back into Payload land. Callers see clean
+ * documents keyed by the user-facing `id`; the composite-key plumbing stays
+ * internal.
+ *
+ * The row's revision is remembered against the returned object — see
+ * `revisionOf`.
  */
 export declare function stripInternalKeys(item: Record<string, unknown>): Record<string, unknown>;
+/**
+ * The revision a row had when it was read, or `undefined` for a row written
+ * before revisions existed (or for an object that didn't come from a read).
+ *
+ * Every write the adapter makes bumps `_rev`. A read-merge-write passes the
+ * row it read as `replaces`, and the write only lands if the stored revision
+ * is still this one — otherwise someone else wrote in between and the merge
+ * has to be redone on the fresh row.
+ */
+export declare function revisionOf(row: object): number | undefined;
 //# sourceMappingURL=stripInternalKeys.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stripInternalKeys.d.ts","sourceRoot":"","sources":["../../src/utilities/stripInternalKeys.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGxF"}
+{"version":3,"file":"stripInternalKeys.d.ts","sourceRoot":"","sources":["../../src/utilities/stripInternalKeys.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D"}

package/dist/utilities/stripInternalKeys.js

@@ -1,10 +1,31 @@
 /**
- * Drop the adapter's internal `pk`/`sk` attributes from a row before it
- * crosses the boundary back into Payload land. Callers see clean documents
- * keyed by the user-facing `id`; the composite-key plumbing stays internal.
+ * The revision each row object was read at, kept beside the object rather
+ * than on it so documents handed back to Payload carry no adapter fields.
+ * Entries vanish with the row object.
+ */ const revisions = new WeakMap();
+/**
+ * Drop the adapter's internal attributes (`pk`, `sk`, `_rev`) from a row
+ * before it crosses the boundary back into Payload land. Callers see clean
+ * documents keyed by the user-facing `id`; the composite-key plumbing stays
+ * internal.
+ *
+ * The row's revision is remembered against the returned object — see
+ * `revisionOf`.
  */ export function stripInternalKeys(item) {
-    const { pk: _pk, sk: _sk, ...rest } = item;
+    const { _rev, pk: _pk, sk: _sk, ...rest } = item;
+    if (typeof _rev === 'number') revisions.set(rest, _rev);
     return rest;
 }
+/**
+ * The revision a row had when it was read, or `undefined` for a row written
+ * before revisions existed (or for an object that didn't come from a read).
+ *
+ * Every write the adapter makes bumps `_rev`. A read-merge-write passes the
+ * row it read as `replaces`, and the write only lands if the stored revision
+ * is still this one — otherwise someone else wrote in between and the merge
+ * has to be redone on the fresh row.
+ */ export function revisionOf(row) {
+    return revisions.get(row);
+}
 
 //# sourceMappingURL=stripInternalKeys.js.map

package/dist/utilities/stripInternalKeys.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/stripInternalKeys.ts"],"sourcesContent":["/**\n * Drop the adapter's internal `pk`/`sk` attributes from a row before it\n * crosses the boundary back into Payload land. Callers see clean documents\n * keyed by the user-facing `id`; the composite-key plumbing stays internal.\n */\nexport function stripInternalKeys(item: Record<string, unknown>): Record<string, unknown> {\n  const { pk: _pk, sk: _sk, ...rest } = item\n  return rest\n}\n"],"names":["stripInternalKeys","item","pk","_pk","sk","_sk","rest"],"mappings":"AAAA;;;;CAIC,GACD,OAAO,SAASA,kBAAkBC,IAA6B;IAC7D,MAAM,EAAEC,IAAIC,GAAG,EAAEC,IAAIC,GAAG,EAAE,GAAGC,MAAM,GAAGL;IACtC,OAAOK;AACT"}
+{"version":3,"sources":["../../src/utilities/stripInternalKeys.ts"],"sourcesContent":["/**\n * The revision each row object was read at, kept beside the object rather\n * than on it so documents handed back to Payload carry no adapter fields.\n * Entries vanish with the row object.\n */\nconst revisions = new WeakMap<object, number>()\n\n/**\n * Drop the adapter's internal attributes (`pk`, `sk`, `_rev`) from a row\n * before it crosses the boundary back into Payload land. Callers see clean\n * documents keyed by the user-facing `id`; the composite-key plumbing stays\n * internal.\n *\n * The row's revision is remembered against the returned object — see\n * `revisionOf`.\n */\nexport function stripInternalKeys(item: Record<string, unknown>): Record<string, unknown> {\n  const { _rev, pk: _pk, sk: _sk, ...rest } = item\n  if (typeof _rev === 'number') revisions.set(rest, _rev)\n  return rest\n}\n\n/**\n * The revision a row had when it was read, or `undefined` for a row written\n * before revisions existed (or for an object that didn't come from a read).\n *\n * Every write the adapter makes bumps `_rev`. A read-merge-write passes the\n * row it read as `replaces`, and the write only lands if the stored revision\n * is still this one — otherwise someone else wrote in between and the merge\n * has to be redone on the fresh row.\n */\nexport function revisionOf(row: object): number | undefined {\n  return revisions.get(row)\n}\n"],"names":["revisions","WeakMap","stripInternalKeys","item","_rev","pk","_pk","sk","_sk","rest","set","revisionOf","row","get"],"mappings":"AAAA;;;;CAIC,GACD,MAAMA,YAAY,IAAIC;AAEtB;;;;;;;;CAQC,GACD,OAAO,SAASC,kBAAkBC,IAA6B;IAC7D,MAAM,EAAEC,IAAI,EAAEC,IAAIC,GAAG,EAAEC,IAAIC,GAAG,EAAE,GAAGC,MAAM,GAAGN;IAC5C,IAAI,OAAOC,SAAS,UAAUJ,UAAUU,GAAG,CAACD,MAAML;IAClD,OAAOK;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASE,WAAWC,GAAW;IACpC,OAAOZ,UAAUa,GAAG,CAACD;AACvB"}

package/dist/utilities/uniqueGuards.d.ts

@@ -0,0 +1,39 @@
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Uniqueness for fields declared `unique: true`.
+ *
+ * DynamoDB can only enforce uniqueness on a primary key, so each unique
+ * value gets a small *guard row* whose key *is* the value:
+ *
+ *     pk = "<collection partition>#unique#<stored field path>"
+ *     sk = "<type tag>:<value>"
+ *     owner = "<id of the document holding the value>"
+ *
+ * A document and its guards are written in one `TransactWriteItems`, each
+ * guard conditioned on "no such row, or it's already mine". A second
+ * document claiming the same value fails that condition and the whole write
+ * is cancelled. Guards live in their own partitions, so they never show up
+ * in a collection's reads.
+ *
+ * Covered: scalar unique fields at the top level or inside groups / named
+ * tabs, including localized ones (one guard per locale). Not covered:
+ * unique fields inside arrays or blocks, and `hasMany` fields — a list has
+ * no single value to key on.
+ *
+ * Empty values (`null`, `undefined`, `''`) are not guarded: any number of
+ * documents may leave a unique field blank.
+ */
+export type UniqueGuard = {
+    key: {
+        pk: string;
+        sk: string;
+    };
+    /** Schema path of the field, without locale — what a validation error names. */
+    path: string;
+};
+/** Whether a collection declares any unique field the adapter guards. */
+export declare function hasUniqueFields(adapter: DynamoAdapter, collectionSlug: string): boolean;
+/** Every guard a document's current values call for. */
+export declare function uniqueGuardsFor(adapter: DynamoAdapter, collectionSlug: string, partition: string, doc: Record<string, unknown>): UniqueGuard[];
+export declare function sameGuard(a: UniqueGuard, b: UniqueGuard): boolean;
+//# sourceMappingURL=uniqueGuards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueGuards.d.ts","sourceRoot":"","sources":["../../src/utilities/uniqueGuards.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAMD,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAavF;AAmBD,wDAAwD;AACxD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,WAAW,EAAE,CAuDf;AAuBD,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAEjE"}

package/dist/utilities/uniqueGuards.js

@@ -0,0 +1,106 @@
+import { createHash } from 'node:crypto';
+import { fieldShouldBeLocalized } from 'payload/shared';
+const cache = new WeakMap();
+/** Whether a collection declares any unique field the adapter guards. */ export function hasUniqueFields(adapter, collectionSlug) {
+    let known = cache.get(adapter);
+    if (!known) {
+        known = new Map();
+        cache.set(adapter, known);
+    }
+    const cached = known.get(collectionSlug);
+    if (cached !== undefined) return cached;
+    const fields = adapter.payload?.collections?.[collectionSlug]?.config.flattenedFields;
+    const result = fields ? containsUnique(fields) : false;
+    known.set(collectionSlug, result);
+    return result;
+}
+function isGuardable(field) {
+    return 'unique' in field && Boolean(field.unique) && field.name !== 'id' && !('hasMany' in field && field.hasMany);
+}
+function containsUnique(fields) {
+    return fields.some((field)=>{
+        if (field.type === 'array' || field.type === 'blocks') return false;
+        if ('flattenedFields' in field) return containsUnique(field.flattenedFields);
+        return isGuardable(field);
+    });
+}
+/** Every guard a document's current values call for. */ export function uniqueGuardsFor(adapter, collectionSlug, partition, doc) {
+    if (!hasUniqueFields(adapter, collectionSlug)) return [];
+    const fields = adapter.payload.collections[collectionSlug].config.flattenedFields;
+    const localeCodes = adapter.payload.config.localization ? adapter.payload.config.localization.localeCodes : null;
+    const guards = [];
+    collect(doc, fields, [], [], false);
+    return guards;
+    function collect(source, level, schemaPath, storedPath, parentIsLocalized) {
+        if (!source || typeof source !== 'object' || Array.isArray(source)) return;
+        const record = source;
+        for (const field of level){
+            if (field.type === 'array' || field.type === 'blocks') continue;
+            const isContainer = 'flattenedFields' in field;
+            if (!isContainer && !isGuardable(field)) continue;
+            const value = record[field.name];
+            const schema = [
+                ...schemaPath,
+                field.name
+            ];
+            const stored = [
+                ...storedPath,
+                field.name
+            ];
+            const localized = Boolean(localeCodes) && fieldShouldBeLocalized({
+                field,
+                parentIsLocalized
+            });
+            // A localized field holds one value per locale; visit each.
+            const variants = localized && value && typeof value === 'object' && !Array.isArray(value) ? Object.entries(value).filter(([locale])=>localeCodes.includes(locale)).map(([locale, inner])=>[
+                    inner,
+                    [
+                        ...stored,
+                        locale
+                    ]
+                ]) : localized ? [] : [
+                [
+                    value,
+                    stored
+                ]
+            ];
+            for (const [inner, innerStored] of variants){
+                if (isContainer) {
+                    collect(inner, field.flattenedFields, schema, innerStored, parentIsLocalized || localized);
+                    continue;
+                }
+                const sk = encodeValue(inner);
+                if (sk === null) continue;
+                guards.push({
+                    key: {
+                        pk: `${partition}#unique#${innerStored.join('.')}`,
+                        sk
+                    },
+                    path: schema.join('.')
+                });
+            }
+        }
+    }
+}
+/**
+ * Turn a value into a sort key. The type tag keeps `1` and `'1'` apart;
+ * long strings are hashed because a sort key is capped at 1024 bytes.
+ * Returns `null` for values that aren't guarded.
+ */ function encodeValue(value) {
+    switch(typeof value){
+        case 'boolean':
+            return `b:${value}`;
+        case 'number':
+            return Number.isFinite(value) ? `n:${value}` : null;
+        case 'string':
+            if (value === '') return null;
+            return value.length > 256 ? `h:${createHash('sha256').update(value).digest('hex')}` : `s:${value}`;
+        default:
+            return null;
+    }
+}
+export function sameGuard(a, b) {
+    return a.key.pk === b.key.pk && a.key.sk === b.key.sk;
+}
+
+//# sourceMappingURL=uniqueGuards.js.map