@open-aih/payload-ddb 3.1.0

package/dist/utilities/draftsFallback.d.ts

@@ -0,0 +1,28 @@
+import type { Where } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Returns true when the named collection has `versions.drafts` enabled in
+ * the Payload config. Read methods that union main-partition rows with
+ * latest-version rows gate on this so non-drafts collections stay on the
+ * fast single-partition path.
+ */
+export declare function collectionHasDrafts(adapter: DynamoAdapter, collectionSlug: string): boolean;
+/**
+ * Pull `latest=true` rows from the versions partition for any parent that
+ * isn't already represented in `mainRows`, project each row's `version`
+ * payload up to top-level (so it looks like a doc), filter by `where` in
+ * JS, and return the supplemental docs ready to merge into `mainRows`.
+ *
+ * The intentional asymmetry: when a parent appears in both partitions, the
+ * main-partition row wins. `find`/`findOne` reflect persistent state, and
+ * for a doc that has been published the main row IS that state. The
+ * version-only path is what catches drafts-only docs (created but never
+ * published, so no main-partition row exists).
+ *
+ * `where` was already pushed to DynamoDB for the main-partition Query but
+ * can't be reused here — version-row attributes live nested under
+ * `version.*` until projection. We re-evaluate in JS against the projected
+ * docs to keep semantics consistent.
+ */
+export declare function fetchDraftsOnlySupplements(adapter: DynamoAdapter, collectionSlug: string, mainRows: Record<string, unknown>[], where: undefined | Where): Promise<Record<string, unknown>[]>;
+//# sourceMappingURL=draftsFallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draftsFallback.d.ts","sourceRoot":"","sources":["../../src/utilities/draftsFallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKhD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAI3F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,KAAK,EAAE,SAAS,GAAG,KAAK,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAoBpC"}

package/dist/utilities/draftsFallback.js

@@ -0,0 +1,52 @@
+import { matchesWhere } from './matchesWhere.js';
+import { queryMatching } from './queryMatching.js';
+/**
+ * Returns true when the named collection has `versions.drafts` enabled in
+ * the Payload config. Read methods that union main-partition rows with
+ * latest-version rows gate on this so non-drafts collections stay on the
+ * fast single-partition path.
+ */ export function collectionHasDrafts(adapter, collectionSlug) {
+    const cfg = adapter.payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!cfg?.versions) return false;
+    return cfg.versions.drafts !== false;
+}
+/**
+ * Pull `latest=true` rows from the versions partition for any parent that
+ * isn't already represented in `mainRows`, project each row's `version`
+ * payload up to top-level (so it looks like a doc), filter by `where` in
+ * JS, and return the supplemental docs ready to merge into `mainRows`.
+ *
+ * The intentional asymmetry: when a parent appears in both partitions, the
+ * main-partition row wins. `find`/`findOne` reflect persistent state, and
+ * for a doc that has been published the main row IS that state. The
+ * version-only path is what catches drafts-only docs (created but never
+ * published, so no main-partition row exists).
+ *
+ * `where` was already pushed to DynamoDB for the main-partition Query but
+ * can't be reused here — version-row attributes live nested under
+ * `version.*` until projection. We re-evaluate in JS against the projected
+ * docs to keep semantics consistent.
+ */ export async function fetchDraftsOnlySupplements(adapter, collectionSlug, mainRows, where) {
+    const versionsPartition = adapter.resolveVersionsPartition(collectionSlug);
+    const latestRows = await queryMatching(adapter, versionsPartition, {
+        latest: {
+            equals: true
+        }
+    });
+    const seen = new Set(mainRows.map((row)=>row['id']));
+    const supplements = [];
+    for (const row of latestRows){
+        if (seen.has(row['parent'])) continue;
+        const version = row['version'];
+        if (!version || typeof version !== 'object') continue;
+        const projected = {
+            ...version,
+            id: row['parent']
+        };
+        if (where && !matchesWhere(projected, where)) continue;
+        supplements.push(projected);
+    }
+    return supplements;
+}
+
+//# sourceMappingURL=draftsFallback.js.map

package/dist/utilities/draftsFallback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/draftsFallback.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport type { DynamoAdapter } from '../types.js'\n\nimport { matchesWhere } from './matchesWhere.js'\nimport { queryMatching } from './queryMatching.js'\n\n/**\n * Returns true when the named collection has `versions.drafts` enabled in\n * the Payload config. Read methods that union main-partition rows with\n * latest-version rows gate on this so non-drafts collections stay on the\n * fast single-partition path.\n */\nexport function collectionHasDrafts(adapter: DynamoAdapter, collectionSlug: string): boolean {\n  const cfg = adapter.payload.config.collections.find((c) => c.slug === collectionSlug)\n  if (!cfg?.versions) return false\n  return cfg.versions.drafts !== false\n}\n\n/**\n * Pull `latest=true` rows from the versions partition for any parent that\n * isn't already represented in `mainRows`, project each row's `version`\n * payload up to top-level (so it looks like a doc), filter by `where` in\n * JS, and return the supplemental docs ready to merge into `mainRows`.\n *\n * The intentional asymmetry: when a parent appears in both partitions, the\n * main-partition row wins. `find`/`findOne` reflect persistent state, and\n * for a doc that has been published the main row IS that state. The\n * version-only path is what catches drafts-only docs (created but never\n * published, so no main-partition row exists).\n *\n * `where` was already pushed to DynamoDB for the main-partition Query but\n * can't be reused here — version-row attributes live nested under\n * `version.*` until projection. We re-evaluate in JS against the projected\n * docs to keep semantics consistent.\n */\nexport async function fetchDraftsOnlySupplements(\n  adapter: DynamoAdapter,\n  collectionSlug: string,\n  mainRows: Record<string, unknown>[],\n  where: undefined | Where,\n): Promise<Record<string, unknown>[]> {\n  const versionsPartition = adapter.resolveVersionsPartition(collectionSlug)\n  const latestRows = await queryMatching(adapter, versionsPartition, {\n    latest: { equals: true },\n  })\n\n  const seen = new Set<unknown>(mainRows.map((row) => row['id']))\n  const supplements: Record<string, unknown>[] = []\n  for (const row of latestRows) {\n    if (seen.has(row['parent'])) continue\n    const version = row['version']\n    if (!version || typeof version !== 'object') continue\n    const projected: Record<string, unknown> = {\n      ...(version as Record<string, unknown>),\n      id: row['parent'],\n    }\n    if (where && !matchesWhere(projected, where)) continue\n    supplements.push(projected)\n  }\n  return supplements\n}\n"],"names":["matchesWhere","queryMatching","collectionHasDrafts","adapter","collectionSlug","cfg","payload","config","collections","find","c","slug","versions","drafts","fetchDraftsOnlySupplements","mainRows","where","versionsPartition","resolveVersionsPartition","latestRows","latest","equals","seen","Set","map","row","supplements","has","version","projected","id","push"],"mappings":"AAIA,SAASA,YAAY,QAAQ,oBAAmB;AAChD,SAASC,aAAa,QAAQ,qBAAoB;AAElD;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,OAAsB,EAAEC,cAAsB;IAChF,MAAMC,MAAMF,QAAQG,OAAO,CAACC,MAAM,CAACC,WAAW,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKP;IACtE,IAAI,CAACC,KAAKO,UAAU,OAAO;IAC3B,OAAOP,IAAIO,QAAQ,CAACC,MAAM,KAAK;AACjC;AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,eAAeC,2BACpBX,OAAsB,EACtBC,cAAsB,EACtBW,QAAmC,EACnCC,KAAwB;IAExB,MAAMC,oBAAoBd,QAAQe,wBAAwB,CAACd;IAC3D,MAAMe,aAAa,MAAMlB,cAAcE,SAASc,mBAAmB;QACjEG,QAAQ;YAAEC,QAAQ;QAAK;IACzB;IAEA,MAAMC,OAAO,IAAIC,IAAaR,SAASS,GAAG,CAAC,CAACC,MAAQA,GAAG,CAAC,KAAK;IAC7D,MAAMC,cAAyC,EAAE;IACjD,KAAK,MAAMD,OAAON,WAAY;QAC5B,IAAIG,KAAKK,GAAG,CAACF,GAAG,CAAC,SAAS,GAAG;QAC7B,MAAMG,UAAUH,GAAG,CAAC,UAAU;QAC9B,IAAI,CAACG,WAAW,OAAOA,YAAY,UAAU;QAC7C,MAAMC,YAAqC;YACzC,GAAID,OAAO;YACXE,IAAIL,GAAG,CAAC,SAAS;QACnB;QACA,IAAIT,SAAS,CAAChB,aAAa6B,WAAWb,QAAQ;QAC9CU,YAAYK,IAAI,CAACF;IACnB;IACA,OAAOH;AACT"}

package/dist/utilities/ensureConnected.d.ts

@@ -0,0 +1,12 @@
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Idempotently set up `client` and `docClient` on the adapter. Called by both
+ * `init` and `connect` because Payload's lifecycle invokes them in
+ * `init → connect` order, and `init` (where table provisioning lives) needs a
+ * working client before `connect` runs.
+ *
+ * If the user supplied their own `client`, we honor it and don't take
+ * ownership for `destroy`.
+ */
+export declare function ensureConnected(adapter: DynamoAdapter): void;
+//# sourceMappingURL=ensureConnected.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ensureConnected.d.ts","sourceRoot":"","sources":["../../src/utilities/ensureConnected.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAS5D"}

package/dist/utilities/ensureConnected.js

@@ -0,0 +1,20 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+/**
+ * Idempotently set up `client` and `docClient` on the adapter. Called by both
+ * `init` and `connect` because Payload's lifecycle invokes them in
+ * `init → connect` order, and `init` (where table provisioning lives) needs a
+ * working client before `connect` runs.
+ *
+ * If the user supplied their own `client`, we honor it and don't take
+ * ownership for `destroy`.
+ */ export function ensureConnected(adapter) {
+    if (adapter.docClient) return;
+    if (!adapter.client) {
+        adapter.client = new DynamoDBClient(adapter.clientConfig);
+        adapter.ownsClient = true;
+    }
+    adapter.docClient = DynamoDBDocumentClient.from(adapter.client, adapter.translateConfig);
+}
+
+//# sourceMappingURL=ensureConnected.js.map

package/dist/utilities/ensureConnected.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/ensureConnected.ts"],"sourcesContent":["import { DynamoDBClient } from '@aws-sdk/client-dynamodb'\nimport { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb'\n\nimport type { DynamoAdapter } from '../types.js'\n\n/**\n * Idempotently set up `client` and `docClient` on the adapter. Called by both\n * `init` and `connect` because Payload's lifecycle invokes them in\n * `init → connect` order, and `init` (where table provisioning lives) needs a\n * working client before `connect` runs.\n *\n * If the user supplied their own `client`, we honor it and don't take\n * ownership for `destroy`.\n */\nexport function ensureConnected(adapter: DynamoAdapter): void {\n  if (adapter.docClient) return\n\n  if (!adapter.client) {\n    adapter.client = new DynamoDBClient(adapter.clientConfig)\n    adapter.ownsClient = true\n  }\n\n  adapter.docClient = DynamoDBDocumentClient.from(adapter.client, adapter.translateConfig)\n}\n"],"names":["DynamoDBClient","DynamoDBDocumentClient","ensureConnected","adapter","docClient","client","clientConfig","ownsClient","from","translateConfig"],"mappings":"AAAA,SAASA,cAAc,QAAQ,2BAA0B;AACzD,SAASC,sBAAsB,QAAQ,wBAAuB;AAI9D;;;;;;;;CAQC,GACD,OAAO,SAASC,gBAAgBC,OAAsB;IACpD,IAAIA,QAAQC,SAAS,EAAE;IAEvB,IAAI,CAACD,QAAQE,MAAM,EAAE;QACnBF,QAAQE,MAAM,GAAG,IAAIL,eAAeG,QAAQG,YAAY;QACxDH,QAAQI,UAAU,GAAG;IACvB;IAEAJ,QAAQC,SAAS,GAAGH,uBAAuBO,IAAI,CAACL,QAAQE,MAAM,EAAEF,QAAQM,eAAe;AACzF"}

package/dist/utilities/ensureTable.d.ts

@@ -0,0 +1,16 @@
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Idempotently provision the single backing table with our composite-key
+ * schema: `pk` (String) partition + `sk` (String) sort, on-demand
+ * (`PAY_PER_REQUEST`) billing.
+ *
+ * Behavior:
+ *  - DescribeTable first; return early if the table already exists.
+ *  - Otherwise CreateTable + wait until ACTIVE (up to 60s).
+ *
+ * Sort key is always String. Collections that opt into Number IDs still work
+ * — the adapter coerces ids into strings for `sk` while keeping the original
+ * type on the `id` attribute.
+ */
+export declare function ensureTable(adapter: DynamoAdapter, tableName: string): Promise<void>;
+//# sourceMappingURL=ensureTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ensureTable.d.ts","sourceRoot":"","sources":["../../src/utilities/ensureTable.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiC1F"}

package/dist/utilities/ensureTable.js

@@ -0,0 +1,62 @@
+import { CreateTableCommand, DescribeTableCommand, waitUntilTableExists } from '@aws-sdk/client-dynamodb';
+/**
+ * Idempotently provision the single backing table with our composite-key
+ * schema: `pk` (String) partition + `sk` (String) sort, on-demand
+ * (`PAY_PER_REQUEST`) billing.
+ *
+ * Behavior:
+ *  - DescribeTable first; return early if the table already exists.
+ *  - Otherwise CreateTable + wait until ACTIVE (up to 60s).
+ *
+ * Sort key is always String. Collections that opt into Number IDs still work
+ * — the adapter coerces ids into strings for `sk` while keeping the original
+ * type on the `id` attribute.
+ */ export async function ensureTable(adapter, tableName) {
+    const client = adapter.client;
+    if (!client) {
+        throw new Error('payload-ddb: client is not initialized — call connect() first.');
+    }
+    try {
+        await client.send(new DescribeTableCommand({
+            TableName: tableName
+        }));
+        return;
+    } catch (err) {
+        if (!(err instanceof Error) || err.name !== 'ResourceNotFoundException') {
+            throw err;
+        }
+    }
+    adapter.payload.logger.info(`payload-ddb: creating table \`${tableName}\``);
+    await client.send(new CreateTableCommand({
+        TableName: tableName,
+        AttributeDefinitions: [
+            {
+                AttributeName: 'pk',
+                AttributeType: 'S'
+            },
+            {
+                AttributeName: 'sk',
+                AttributeType: 'S'
+            }
+        ],
+        KeySchema: [
+            {
+                AttributeName: 'pk',
+                KeyType: 'HASH'
+            },
+            {
+                AttributeName: 'sk',
+                KeyType: 'RANGE'
+            }
+        ],
+        BillingMode: 'PAY_PER_REQUEST'
+    }));
+    await waitUntilTableExists({
+        client,
+        maxWaitTime: 60
+    }, {
+        TableName: tableName
+    });
+}
+
+//# sourceMappingURL=ensureTable.js.map

package/dist/utilities/ensureTable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/ensureTable.ts"],"sourcesContent":["import {\n  CreateTableCommand,\n  DescribeTableCommand,\n  waitUntilTableExists,\n} from '@aws-sdk/client-dynamodb'\n\nimport type { DynamoAdapter } from '../types.js'\n\n/**\n * Idempotently provision the single backing table with our composite-key\n * schema: `pk` (String) partition + `sk` (String) sort, on-demand\n * (`PAY_PER_REQUEST`) billing.\n *\n * Behavior:\n *  - DescribeTable first; return early if the table already exists.\n *  - Otherwise CreateTable + wait until ACTIVE (up to 60s).\n *\n * Sort key is always String. Collections that opt into Number IDs still work\n * — the adapter coerces ids into strings for `sk` while keeping the original\n * type on the `id` attribute.\n */\nexport async function ensureTable(adapter: DynamoAdapter, tableName: string): Promise<void> {\n  const client = adapter.client\n  if (!client) {\n    throw new Error('payload-ddb: client is not initialized — call connect() first.')\n  }\n\n  try {\n    await client.send(new DescribeTableCommand({ TableName: tableName }))\n    return\n  } catch (err) {\n    if (!(err instanceof Error) || err.name !== 'ResourceNotFoundException') {\n      throw err\n    }\n  }\n\n  adapter.payload.logger.info(`payload-ddb: creating table \\`${tableName}\\``)\n\n  await client.send(\n    new CreateTableCommand({\n      TableName: tableName,\n      AttributeDefinitions: [\n        { AttributeName: 'pk', AttributeType: 'S' },\n        { AttributeName: 'sk', AttributeType: 'S' },\n      ],\n      KeySchema: [\n        { AttributeName: 'pk', KeyType: 'HASH' },\n        { AttributeName: 'sk', KeyType: 'RANGE' },\n      ],\n      BillingMode: 'PAY_PER_REQUEST',\n    }),\n  )\n\n  await waitUntilTableExists({ client, maxWaitTime: 60 }, { TableName: tableName })\n}\n"],"names":["CreateTableCommand","DescribeTableCommand","waitUntilTableExists","ensureTable","adapter","tableName","client","Error","send","TableName","err","name","payload","logger","info","AttributeDefinitions","AttributeName","AttributeType","KeySchema","KeyType","BillingMode","maxWaitTime"],"mappings":"AAAA,SACEA,kBAAkB,EAClBC,oBAAoB,EACpBC,oBAAoB,QACf,2BAA0B;AAIjC;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeC,YAAYC,OAAsB,EAAEC,SAAiB;IACzE,MAAMC,SAASF,QAAQE,MAAM;IAC7B,IAAI,CAACA,QAAQ;QACX,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI;QACF,MAAMD,OAAOE,IAAI,CAAC,IAAIP,qBAAqB;YAAEQ,WAAWJ;QAAU;QAClE;IACF,EAAE,OAAOK,KAAK;QACZ,IAAI,CAAEA,CAAAA,eAAeH,KAAI,KAAMG,IAAIC,IAAI,KAAK,6BAA6B;YACvE,MAAMD;QACR;IACF;IAEAN,QAAQQ,OAAO,CAACC,MAAM,CAACC,IAAI,CAAC,CAAC,8BAA8B,EAAET,UAAU,EAAE,CAAC;IAE1E,MAAMC,OAAOE,IAAI,CACf,IAAIR,mBAAmB;QACrBS,WAAWJ;QACXU,sBAAsB;YACpB;gBAAEC,eAAe;gBAAMC,eAAe;YAAI;YAC1C;gBAAED,eAAe;gBAAMC,eAAe;YAAI;SAC3C;QACDC,WAAW;YACT;gBAAEF,eAAe;gBAAMG,SAAS;YAAO;YACvC;gBAAEH,eAAe;gBAAMG,SAAS;YAAQ;SACzC;QACDC,aAAa;IACf;IAGF,MAAMlB,qBAAqB;QAAEI;QAAQe,aAAa;IAAG,GAAG;QAAEZ,WAAWJ;IAAU;AACjF"}

package/dist/utilities/findFirst.d.ts

@@ -0,0 +1,16 @@
+import type { Where } from 'payload';
+import type { DynamoAdapter } from '../types.js';
+/**
+ * Locate the first item in a partition matching `where`. Used by `findOne`
+ * directly and by `deleteOne`/`updateOne` to capture the doc before mutating.
+ *
+ * Fast path: if `where` is a pure id-equality, do a single `GetItem` with the
+ * full composite key.
+ * Slow path: paginate `Query` (scoped by `pk = partition`) with
+ * `FilterExpression` pushdown and stop on the first matching row in any page.
+ */
+export declare function findFirst(adapter: DynamoAdapter, args: {
+    partition: string;
+    where: undefined | Where;
+}): Promise<null | Record<string, unknown>>;
+//# sourceMappingURL=findFirst.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findFirst.d.ts","sourceRoot":"","sources":["../../src/utilities/findFirst.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAShD;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,GAAG,KAAK,CAAA;CAAE,GACpD,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA+DzC"}

package/dist/utilities/findFirst.js

@@ -0,0 +1,79 @@
+import { GetCommand, QueryCommand } from '@aws-sdk/lib-dynamodb';
+import { buildFilterExpression } from './buildFilterExpression.js';
+import { matchesWhere } from './matchesWhere.js';
+import { whereHasJsOnlyOperator } from './operators.js';
+import { queryMatching } from './queryMatching.js';
+import { stripInternalKeys } from './stripInternalKeys.js';
+import { whereToId } from './whereToId.js';
+/**
+ * Locate the first item in a partition matching `where`. Used by `findOne`
+ * directly and by `deleteOne`/`updateOne` to capture the doc before mutating.
+ *
+ * Fast path: if `where` is a pure id-equality, do a single `GetItem` with the
+ * full composite key.
+ * Slow path: paginate `Query` (scoped by `pk = partition`) with
+ * `FilterExpression` pushdown and stop on the first matching row in any page.
+ */ export async function findFirst(adapter, args) {
+    const docClient = adapter.docClient;
+    if (!docClient) {
+        throw new Error('payload-ddb: docClient is not initialized — call connect() first.');
+    }
+    const { partition } = args;
+    const id = whereToId(args.where);
+    if (id !== null) {
+        const result = await docClient.send(new GetCommand({
+            TableName: adapter.tableName,
+            Key: {
+                pk: partition,
+                sk: String(id)
+            },
+            // Strong consistency — Payload assumes read-after-write visibility.
+            ConsistentRead: true
+        }));
+        return result.Item ? stripInternalKeys(result.Item) : null;
+    }
+    // JS-only operator (e.g. `like`) somewhere in `where` — fetch the partition
+    // and pick the first JS match. Loses the "stop on first hit per page"
+    // optimization but keeps semantics consistent with `queryMatching`.
+    if (whereHasJsOnlyOperator(args.where)) {
+        const all = await queryMatching(adapter, partition, undefined);
+        for (const row of all){
+            if (matchesWhere(row, args.where)) return row;
+        }
+        return null;
+    }
+    const filter = buildFilterExpression(args.where);
+    // Always-false predicate (e.g. `in: []`) → no document can match.
+    if (filter === null) return null;
+    let exclusiveStartKey;
+    while(true){
+        const result = await docClient.send(new QueryCommand({
+            TableName: adapter.tableName,
+            KeyConditionExpression: '#pk = :pk',
+            ExpressionAttributeNames: {
+                '#pk': 'pk',
+                ...filter?.names ?? {}
+            },
+            ExpressionAttributeValues: {
+                ':pk': partition,
+                ...filter?.values ?? {}
+            },
+            ConsistentRead: true,
+            ...filter ? {
+                FilterExpression: filter.expression
+            } : {},
+            ...exclusiveStartKey ? {
+                ExclusiveStartKey: exclusiveStartKey
+            } : {}
+        }));
+        for (const item of result.Items ?? []){
+            return stripInternalKeys(item);
+        }
+        if (!result.LastEvaluatedKey) {
+            return null;
+        }
+        exclusiveStartKey = result.LastEvaluatedKey;
+    }
+}
+
+//# sourceMappingURL=findFirst.js.map

package/dist/utilities/findFirst.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/findFirst.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { GetCommand, 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 { queryMatching } from './queryMatching.js'\nimport { stripInternalKeys } from './stripInternalKeys.js'\nimport { whereToId } from './whereToId.js'\n\n/**\n * Locate the first item in a partition matching `where`. Used by `findOne`\n * directly and by `deleteOne`/`updateOne` to capture the doc before mutating.\n *\n * Fast path: if `where` is a pure id-equality, do a single `GetItem` with the\n * full composite key.\n * Slow path: paginate `Query` (scoped by `pk = partition`) with\n * `FilterExpression` pushdown and stop on the first matching row in any page.\n */\nexport async function findFirst(\n  adapter: DynamoAdapter,\n  args: { partition: string; where: undefined | Where },\n): Promise<null | 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  const { partition } = args\n  const id = whereToId(args.where)\n\n  if (id !== null) {\n    const result = await docClient.send(\n      new GetCommand({\n        TableName: adapter.tableName,\n        Key: { pk: partition, sk: String(id) },\n        // Strong consistency — Payload assumes read-after-write visibility.\n        ConsistentRead: true,\n      }),\n    )\n    return result.Item ? stripInternalKeys(result.Item) : null\n  }\n\n  // JS-only operator (e.g. `like`) somewhere in `where` — fetch the partition\n  // and pick the first JS match. Loses the \"stop on first hit per page\"\n  // optimization but keeps semantics consistent with `queryMatching`.\n  if (whereHasJsOnlyOperator(args.where)) {\n    const all = await queryMatching(adapter, partition, undefined)\n    for (const row of all) {\n      if (matchesWhere(row, args.where)) return row\n    }\n    return null\n  }\n\n  const filter = buildFilterExpression(args.where)\n  // Always-false predicate (e.g. `in: []`) → no document can match.\n  if (filter === null) return null\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        ConsistentRead: true,\n        ...(filter ? { FilterExpression: filter.expression } : {}),\n        ...(exclusiveStartKey ? { ExclusiveStartKey: exclusiveStartKey } : {}),\n      }),\n    )\n    for (const item of result.Items ?? []) {\n      return stripInternalKeys(item)\n    }\n    if (!result.LastEvaluatedKey) {\n      return null\n    }\n    exclusiveStartKey = result.LastEvaluatedKey\n  }\n}\n"],"names":["GetCommand","QueryCommand","buildFilterExpression","matchesWhere","whereHasJsOnlyOperator","queryMatching","stripInternalKeys","whereToId","findFirst","adapter","args","docClient","Error","partition","id","where","result","send","TableName","tableName","Key","pk","sk","String","ConsistentRead","Item","all","undefined","row","filter","exclusiveStartKey","KeyConditionExpression","ExpressionAttributeNames","names","ExpressionAttributeValues","values","FilterExpression","expression","ExclusiveStartKey","item","Items","LastEvaluatedKey"],"mappings":"AAEA,SAASA,UAAU,EAAEC,YAAY,QAAQ,wBAAuB;AAIhE,SAASC,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,SAAS,QAAQ,iBAAgB;AAE1C;;;;;;;;CAQC,GACD,OAAO,eAAeC,UACpBC,OAAsB,EACtBC,IAAqD;IAErD,MAAMC,YAAYF,QAAQE,SAAS;IACnC,IAAI,CAACA,WAAW;QACd,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAM,EAAEC,SAAS,EAAE,GAAGH;IACtB,MAAMI,KAAKP,UAAUG,KAAKK,KAAK;IAE/B,IAAID,OAAO,MAAM;QACf,MAAME,SAAS,MAAML,UAAUM,IAAI,CACjC,IAAIjB,WAAW;YACbkB,WAAWT,QAAQU,SAAS;YAC5BC,KAAK;gBAAEC,IAAIR;gBAAWS,IAAIC,OAAOT;YAAI;YACrC,oEAAoE;YACpEU,gBAAgB;QAClB;QAEF,OAAOR,OAAOS,IAAI,GAAGnB,kBAAkBU,OAAOS,IAAI,IAAI;IACxD;IAEA,4EAA4E;IAC5E,sEAAsE;IACtE,oEAAoE;IACpE,IAAIrB,uBAAuBM,KAAKK,KAAK,GAAG;QACtC,MAAMW,MAAM,MAAMrB,cAAcI,SAASI,WAAWc;QACpD,KAAK,MAAMC,OAAOF,IAAK;YACrB,IAAIvB,aAAayB,KAAKlB,KAAKK,KAAK,GAAG,OAAOa;QAC5C;QACA,OAAO;IACT;IAEA,MAAMC,SAAS3B,sBAAsBQ,KAAKK,KAAK;IAC/C,kEAAkE;IAClE,IAAIc,WAAW,MAAM,OAAO;IAC5B,IAAIC;IAEJ,MAAO,KAAM;QACX,MAAMd,SAAS,MAAML,UAAUM,IAAI,CACjC,IAAIhB,aAAa;YACfiB,WAAWT,QAAQU,SAAS;YAC5BY,wBAAwB;YACxBC,0BAA0B;gBACxB,OAAO;gBACP,GAAIH,QAAQI,SAAS,CAAC,CAAC;YACzB;YACAC,2BAA2B;gBACzB,OAAOrB;gBACP,GAAIgB,QAAQM,UAAU,CAAC,CAAC;YAC1B;YACAX,gBAAgB;YAChB,GAAIK,SAAS;gBAAEO,kBAAkBP,OAAOQ,UAAU;YAAC,IAAI,CAAC,CAAC;YACzD,GAAIP,oBAAoB;gBAAEQ,mBAAmBR;YAAkB,IAAI,CAAC,CAAC;QACvE;QAEF,KAAK,MAAMS,QAAQvB,OAAOwB,KAAK,IAAI,EAAE,CAAE;YACrC,OAAOlC,kBAAkBiC;QAC3B;QACA,IAAI,CAACvB,OAAOyB,gBAAgB,EAAE;YAC5B,OAAO;QACT;QACAX,oBAAoBd,OAAOyB,gBAAgB;IAC7C;AACF"}

package/dist/utilities/getByPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read a dotted path from a record. Returns `undefined` if any segment along
+ * the way is missing or non-object.
+ *
+ * Intentionally simple — does not support array index syntax, escaped dots,
+ * or symbol keys. Field paths in Payload's `Where` are dotted strings.
+ */
+export declare function getByPath(source: unknown, path: string): unknown;
+//# sourceMappingURL=getByPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getByPath.d.ts","sourceRoot":"","sources":["../../src/utilities/getByPath.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAahE"}

package/dist/utilities/getByPath.js

@@ -0,0 +1,22 @@
+/**
+ * Read a dotted path from a record. Returns `undefined` if any segment along
+ * the way is missing or non-object.
+ *
+ * Intentionally simple — does not support array index syntax, escaped dots,
+ * or symbol keys. Field paths in Payload's `Where` are dotted strings.
+ */ export function getByPath(source, path) {
+    if (source === null || typeof source !== 'object') {
+        return undefined;
+    }
+    const segments = path.split('.');
+    let cursor = source;
+    for (const segment of segments){
+        if (cursor === null || typeof cursor !== 'object') {
+            return undefined;
+        }
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+
+//# sourceMappingURL=getByPath.js.map

package/dist/utilities/getByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getByPath.ts"],"sourcesContent":["/**\n * Read a dotted path from a record. Returns `undefined` if any segment along\n * the way is missing or non-object.\n *\n * Intentionally simple — does not support array index syntax, escaped dots,\n * or symbol keys. Field paths in Payload's `Where` are dotted strings.\n */\nexport function getByPath(source: unknown, path: string): unknown {\n  if (source === null || typeof source !== 'object') {\n    return undefined\n  }\n  const segments = path.split('.')\n  let cursor: unknown = source\n  for (const segment of segments) {\n    if (cursor === null || typeof cursor !== 'object') {\n      return undefined\n    }\n    cursor = (cursor as Record<string, unknown>)[segment]\n  }\n  return cursor\n}\n"],"names":["getByPath","source","path","undefined","segments","split","cursor","segment"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,UAAUC,MAAe,EAAEC,IAAY;IACrD,IAAID,WAAW,QAAQ,OAAOA,WAAW,UAAU;QACjD,OAAOE;IACT;IACA,MAAMC,WAAWF,KAAKG,KAAK,CAAC;IAC5B,IAAIC,SAAkBL;IACtB,KAAK,MAAMM,WAAWH,SAAU;QAC9B,IAAIE,WAAW,QAAQ,OAAOA,WAAW,UAAU;YACjD,OAAOH;QACT;QACAG,SAAS,AAACA,MAAkC,CAACC,QAAQ;IACvD;IACA,OAAOD;AACT"}

package/dist/utilities/matchesWhere.d.ts

@@ -0,0 +1,12 @@
+import type { Where } from 'payload';
+/**
+ * In-memory predicate that evaluates a Payload `Where` against a fetched item.
+ * Used as a fallback when the query cannot be reduced to a `GetItem` and we
+ * have to `Scan` the table.
+ *
+ * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.
+ * Throws on any other operator so we surface coverage gaps instead of
+ * silently returning wrong results.
+ */
+export declare function matchesWhere(item: Record<string, unknown>, where: Where | undefined): boolean;
+//# sourceMappingURL=matchesWhere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesWhere.d.ts","sourceRoot":"","sources":["../../src/utilities/matchesWhere.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CA8C7F"}

package/dist/utilities/matchesWhere.js

@@ -0,0 +1,98 @@
+import { getByPath } from './getByPath.js';
+import { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js';
+/**
+ * In-memory predicate that evaluates a Payload `Where` against a fetched item.
+ * Used as a fallback when the query cannot be reduced to a `GetItem` and we
+ * have to `Scan` the table.
+ *
+ * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.
+ * Throws on any other operator so we surface coverage gaps instead of
+ * silently returning wrong results.
+ */ export function matchesWhere(item, where) {
+    if (!where) {
+        return true;
+    }
+    for (const [key, raw] of Object.entries(where)){
+        if (key === 'and') {
+            if (!Array.isArray(raw)) continue;
+            for (const sub of raw){
+                if (!matchesWhere(item, sub)) return false;
+            }
+            continue;
+        }
+        if (key === 'or') {
+            if (!Array.isArray(raw)) continue;
+            let any = false;
+            for (const sub of raw){
+                if (matchesWhere(item, sub)) {
+                    any = true;
+                    break;
+                }
+            }
+            if (!any) return false;
+            continue;
+        }
+        if (!raw || typeof raw !== 'object') {
+            continue;
+        }
+        const fieldValue = getByPath(item, key);
+        const operators = raw;
+        for (const [operator, expected] of Object.entries(operators)){
+            if (!SUPPORTED_OPERATORS.has(operator)) {
+                throw unsupportedOperatorError(operator, key);
+            }
+            if (!evaluate(fieldValue, operator, expected)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function evaluate(actual, operator, expected) {
+    switch(operator){
+        case 'equals':
+            return actual === expected;
+        case 'not_equals':
+            return actual !== expected;
+        case 'greater_than':
+            return compareLoose(actual, expected) > 0;
+        case 'greater_than_equal':
+            return compareLoose(actual, expected) >= 0;
+        case 'less_than':
+            return compareLoose(actual, expected) < 0;
+        case 'less_than_equal':
+            return compareLoose(actual, expected) <= 0;
+        case 'exists':
+            return expected ? actual !== undefined && actual !== null : actual === undefined || actual === null;
+        case 'in':
+            return Array.isArray(expected) && expected.includes(actual);
+        case 'not_in':
+            return Array.isArray(expected) && !expected.includes(actual);
+        case 'like':
+            {
+                // Empty needle means "no constraint" — mirrors SQL `LIKE '%%'` and what
+                // Payload's admin search produces when the search input is cleared.
+                if (typeof expected !== 'string' || expected === '') return true;
+                if (typeof actual !== 'string') return false;
+                return actual.toLowerCase().includes(expected.toLowerCase());
+            }
+        default:
+            return false;
+    }
+}
+/**
+ * Loose ordered comparison matching DynamoDB's `<`/`>` semantics: numbers and
+ * strings (including ISO date strings) compare naturally; nullish on either
+ * side yields a non-match by returning `NaN`. Lets `greater_than`/`less_than`
+ * mirror the server-side filter evaluator behavior.
+ */ function compareLoose(a, b) {
+    if (a === undefined || a === null || b === undefined || b === null) return NaN;
+    if (typeof a === 'number' && typeof b === 'number') return a - b;
+    const as = String(a);
+    const bs = String(b);
+    if (as < bs) return -1;
+    if (as > bs) return 1;
+    return 0;
+}
+
+//# sourceMappingURL=matchesWhere.js.map

package/dist/utilities/matchesWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/matchesWhere.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { getByPath } from './getByPath.js'\nimport { SUPPORTED_OPERATORS, unsupportedOperatorError } from './operators.js'\n\n/**\n * In-memory predicate that evaluates a Payload `Where` against a fetched item.\n * Used as a fallback when the query cannot be reduced to a `GetItem` and we\n * have to `Scan` the table.\n *\n * Supports: `equals`, `not_equals`, `exists`, `in`, `not_in`, `and`, `or`.\n * Throws on any other operator so we surface coverage gaps instead of\n * silently returning wrong results.\n */\nexport function matchesWhere(item: Record<string, unknown>, where: Where | undefined): boolean {\n  if (!where) {\n    return true\n  }\n\n  for (const [key, raw] of Object.entries(where)) {\n    if (key === 'and') {\n      if (!Array.isArray(raw)) continue\n      for (const sub of raw) {\n        if (!matchesWhere(item, sub)) return false\n      }\n      continue\n    }\n\n    if (key === 'or') {\n      if (!Array.isArray(raw)) continue\n      let any = false\n      for (const sub of raw) {\n        if (matchesWhere(item, sub)) {\n          any = true\n          break\n        }\n      }\n      if (!any) return false\n      continue\n    }\n\n    if (!raw || typeof raw !== 'object') {\n      continue\n    }\n\n    const fieldValue = getByPath(item, key)\n    const operators = raw as Record<string, unknown>\n\n    for (const [operator, expected] of Object.entries(operators)) {\n      if (!SUPPORTED_OPERATORS.has(operator)) {\n        throw unsupportedOperatorError(operator, key)\n      }\n\n      if (!evaluate(fieldValue, operator, expected)) {\n        return false\n      }\n    }\n  }\n\n  return true\n}\n\nfunction evaluate(actual: unknown, operator: string, expected: unknown): boolean {\n  switch (operator) {\n    case 'equals':\n      return actual === expected\n    case 'not_equals':\n      return actual !== expected\n    case 'greater_than':\n      return compareLoose(actual, expected) > 0\n    case 'greater_than_equal':\n      return compareLoose(actual, expected) >= 0\n    case 'less_than':\n      return compareLoose(actual, expected) < 0\n    case 'less_than_equal':\n      return compareLoose(actual, expected) <= 0\n    case 'exists':\n      return expected ? actual !== undefined && actual !== null : actual === undefined || actual === null\n    case 'in':\n      return Array.isArray(expected) && expected.includes(actual)\n    case 'not_in':\n      return Array.isArray(expected) && !expected.includes(actual)\n    case 'like': {\n      // Empty needle means \"no constraint\" — mirrors SQL `LIKE '%%'` and what\n      // Payload's admin search produces when the search input is cleared.\n      if (typeof expected !== 'string' || expected === '') return true\n      if (typeof actual !== 'string') return false\n      return actual.toLowerCase().includes(expected.toLowerCase())\n    }\n    default:\n      return false\n  }\n}\n\n/**\n * Loose ordered comparison matching DynamoDB's `<`/`>` semantics: numbers and\n * strings (including ISO date strings) compare naturally; nullish on either\n * side yields a non-match by returning `NaN`. Lets `greater_than`/`less_than`\n * mirror the server-side filter evaluator behavior.\n */\nfunction compareLoose(a: unknown, b: unknown): number {\n  if (a === undefined || a === null || b === undefined || b === null) return NaN\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  const as = String(a)\n  const bs = String(b)\n  if (as < bs) return -1\n  if (as > bs) return 1\n  return 0\n}\n"],"names":["getByPath","SUPPORTED_OPERATORS","unsupportedOperatorError","matchesWhere","item","where","key","raw","Object","entries","Array","isArray","sub","any","fieldValue","operators","operator","expected","has","evaluate","actual","compareLoose","undefined","includes","toLowerCase","a","b","NaN","as","String","bs"],"mappings":"AAEA,SAASA,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,mBAAmB,EAAEC,wBAAwB,QAAQ,iBAAgB;AAE9E;;;;;;;;CAQC,GACD,OAAO,SAASC,aAAaC,IAA6B,EAAEC,KAAwB;IAClF,IAAI,CAACA,OAAO;QACV,OAAO;IACT;IAEA,KAAK,MAAM,CAACC,KAAKC,IAAI,IAAIC,OAAOC,OAAO,CAACJ,OAAQ;QAC9C,IAAIC,QAAQ,OAAO;YACjB,IAAI,CAACI,MAAMC,OAAO,CAACJ,MAAM;YACzB,KAAK,MAAMK,OAAOL,IAAK;gBACrB,IAAI,CAACJ,aAAaC,MAAMQ,MAAM,OAAO;YACvC;YACA;QACF;QAEA,IAAIN,QAAQ,MAAM;YAChB,IAAI,CAACI,MAAMC,OAAO,CAACJ,MAAM;YACzB,IAAIM,MAAM;YACV,KAAK,MAAMD,OAAOL,IAAK;gBACrB,IAAIJ,aAAaC,MAAMQ,MAAM;oBAC3BC,MAAM;oBACN;gBACF;YACF;YACA,IAAI,CAACA,KAAK,OAAO;YACjB;QACF;QAEA,IAAI,CAACN,OAAO,OAAOA,QAAQ,UAAU;YACnC;QACF;QAEA,MAAMO,aAAad,UAAUI,MAAME;QACnC,MAAMS,YAAYR;QAElB,KAAK,MAAM,CAACS,UAAUC,SAAS,IAAIT,OAAOC,OAAO,CAACM,WAAY;YAC5D,IAAI,CAACd,oBAAoBiB,GAAG,CAACF,WAAW;gBACtC,MAAMd,yBAAyBc,UAAUV;YAC3C;YAEA,IAAI,CAACa,SAASL,YAAYE,UAAUC,WAAW;gBAC7C,OAAO;YACT;QACF;IACF;IAEA,OAAO;AACT;AAEA,SAASE,SAASC,MAAe,EAAEJ,QAAgB,EAAEC,QAAiB;IACpE,OAAQD;QACN,KAAK;YACH,OAAOI,WAAWH;QACpB,KAAK;YACH,OAAOG,WAAWH;QACpB,KAAK;YACH,OAAOI,aAAaD,QAAQH,YAAY;QAC1C,KAAK;YACH,OAAOI,aAAaD,QAAQH,aAAa;QAC3C,KAAK;YACH,OAAOI,aAAaD,QAAQH,YAAY;QAC1C,KAAK;YACH,OAAOI,aAAaD,QAAQH,aAAa;QAC3C,KAAK;YACH,OAAOA,WAAWG,WAAWE,aAAaF,WAAW,OAAOA,WAAWE,aAAaF,WAAW;QACjG,KAAK;YACH,OAAOV,MAAMC,OAAO,CAACM,aAAaA,SAASM,QAAQ,CAACH;QACtD,KAAK;YACH,OAAOV,MAAMC,OAAO,CAACM,aAAa,CAACA,SAASM,QAAQ,CAACH;QACvD,KAAK;YAAQ;gBACX,wEAAwE;gBACxE,oEAAoE;gBACpE,IAAI,OAAOH,aAAa,YAAYA,aAAa,IAAI,OAAO;gBAC5D,IAAI,OAAOG,WAAW,UAAU,OAAO;gBACvC,OAAOA,OAAOI,WAAW,GAAGD,QAAQ,CAACN,SAASO,WAAW;YAC3D;QACA;YACE,OAAO;IACX;AACF;AAEA;;;;;CAKC,GACD,SAASH,aAAaI,CAAU,EAAEC,CAAU;IAC1C,IAAID,MAAMH,aAAaG,MAAM,QAAQC,MAAMJ,aAAaI,MAAM,MAAM,OAAOC;IAC3E,IAAI,OAAOF,MAAM,YAAY,OAAOC,MAAM,UAAU,OAAOD,IAAIC;IAC/D,MAAME,KAAKC,OAAOJ;IAClB,MAAMK,KAAKD,OAAOH;IAClB,IAAIE,KAAKE,IAAI,OAAO,CAAC;IACrB,IAAIF,KAAKE,IAAI,OAAO;IACpB,OAAO;AACT"}

package/dist/utilities/normalizeForDynamo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert values that DynamoDB's marshaller can't represent natively into a
+ * shape it can. Today this is just `Date → ISO string`, but the same hook is
+ * the right place for any future "Payload sends X, Dynamo wants Y" coercions
+ * (e.g. `BigInt`).
+ *
+ * Why this exists: with `convertClassInstanceToMap: true` (our default
+ * translate option), a `Date` instance has no enumerable own properties and
+ * marshals as an empty map `{}`. That stores fine but compares as type `M`,
+ * which `FilterExpression` operators like `>` reject. Stringifying to ISO
+ * keeps Mongo-parity ordering (lex compare on ISO strings = chronological
+ * order) and round-trips cleanly back to a `Date` in user code.
+ */
+export declare function normalizeForDynamo<T>(value: T): T;
+//# sourceMappingURL=normalizeForDynamo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeForDynamo.d.ts","sourceRoot":"","sources":["../../src/utilities/normalizeForDynamo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAYjD"}

package/dist/utilities/normalizeForDynamo.js

@@ -0,0 +1,27 @@
+/**
+ * Convert values that DynamoDB's marshaller can't represent natively into a
+ * shape it can. Today this is just `Date → ISO string`, but the same hook is
+ * the right place for any future "Payload sends X, Dynamo wants Y" coercions
+ * (e.g. `BigInt`).
+ *
+ * Why this exists: with `convertClassInstanceToMap: true` (our default
+ * translate option), a `Date` instance has no enumerable own properties and
+ * marshals as an empty map `{}`. That stores fine but compares as type `M`,
+ * which `FilterExpression` operators like `>` reject. Stringifying to ISO
+ * keeps Mongo-parity ordering (lex compare on ISO strings = chronological
+ * order) and round-trips cleanly back to a `Date` in user code.
+ */ export function normalizeForDynamo(value) {
+    if (value === null || value === undefined) return value;
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) return value.map(normalizeForDynamo);
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)){
+            out[k] = normalizeForDynamo(v);
+        }
+        return out;
+    }
+    return value;
+}
+
+//# sourceMappingURL=normalizeForDynamo.js.map

package/dist/utilities/normalizeForDynamo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/normalizeForDynamo.ts"],"sourcesContent":["/**\n * Convert values that DynamoDB's marshaller can't represent natively into a\n * shape it can. Today this is just `Date → ISO string`, but the same hook is\n * the right place for any future \"Payload sends X, Dynamo wants Y\" coercions\n * (e.g. `BigInt`).\n *\n * Why this exists: with `convertClassInstanceToMap: true` (our default\n * translate option), a `Date` instance has no enumerable own properties and\n * marshals as an empty map `{}`. That stores fine but compares as type `M`,\n * which `FilterExpression` operators like `>` reject. Stringifying to ISO\n * keeps Mongo-parity ordering (lex compare on ISO strings = chronological\n * order) and round-trips cleanly back to a `Date` in user code.\n */\nexport function normalizeForDynamo<T>(value: T): T {\n  if (value === null || value === undefined) return value\n  if (value instanceof Date) return value.toISOString() as T\n  if (Array.isArray(value)) return value.map(normalizeForDynamo) as T\n  if (typeof value === 'object') {\n    const out: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n      out[k] = normalizeForDynamo(v)\n    }\n    return out as T\n  }\n  return value\n}\n"],"names":["normalizeForDynamo","value","undefined","Date","toISOString","Array","isArray","map","out","k","v","Object","entries"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASA,mBAAsBC,KAAQ;IAC5C,IAAIA,UAAU,QAAQA,UAAUC,WAAW,OAAOD;IAClD,IAAIA,iBAAiBE,MAAM,OAAOF,MAAMG,WAAW;IACnD,IAAIC,MAAMC,OAAO,CAACL,QAAQ,OAAOA,MAAMM,GAAG,CAACP;IAC3C,IAAI,OAAOC,UAAU,UAAU;QAC7B,MAAMO,MAA+B,CAAC;QACtC,KAAK,MAAM,CAACC,GAAGC,EAAE,IAAIC,OAAOC,OAAO,CAACX,OAAmC;YACrEO,GAAG,CAACC,EAAE,GAAGT,mBAAmBU;QAC9B;QACA,OAAOF;IACT;IACA,OAAOP;AACT"}

package/dist/utilities/operators.d.ts

@@ -0,0 +1,26 @@
+import type { Where } from 'payload';
+/**
+ * The where-operator coverage shared by `matchesWhere` (in-JS evaluator) and
+ * `buildFilterExpression` (DynamoDB pushdown). Keeping the set in one place
+ * keeps the two paths honest — if an operator is supported in one, it should
+ * be supported in the other, since callers can't know which path runs.
+ */
+export declare const SUPPORTED_OPERATORS: Set<string>;
+/**
+ * Operators we can't faithfully express in a DynamoDB `FilterExpression` and
+ * therefore evaluate in JS after fetching candidate rows. `like` is here
+ * because Payload's contract is case-insensitive substring matching while
+ * DynamoDB's `contains()` is case-sensitive — pushing it down would silently
+ * change semantics. When `where` contains any of these, the read helpers
+ * `Query` the partition without server-side filtering and apply
+ * `matchesWhere` in memory.
+ */
+export declare const JS_ONLY_OPERATORS: Set<string>;
+export declare const SUPPORTED_OPERATORS_DESCRIPTION: string;
+export declare function unsupportedOperatorError(operator: string, field: string): Error;
+/**
+ * Walk a `Where` and return true if any leaf clause uses an operator that
+ * forces JS-side evaluation. Recurses into `and`/`or` groups.
+ */
+export declare function whereHasJsOnlyOperator(where: undefined | Where): boolean;
+//# sourceMappingURL=operators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../src/utilities/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,aAW9B,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,aAAoB,CAAA;AAElD,eAAO,MAAM,+BAA+B,QAAoD,CAAA;AAEhG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAK/E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,GAAG,OAAO,CAkBxE"}