@crvouga/mockingbird-service-dynamodb 3.10.2 → 3.10.3

package/CHANGELOG.md

@@ -1,14 +1,16 @@
 # Changelog — @crvouga/mockingbird-service-dynamodb
 
-## 3.10.2 (2026-11-02)
+## 3.10.3 (2026-11-02)
 
 ### Fixes and improvements
 
-- reopen IndexedDB durability connection after the browser force-closes it ([d0b45aa](https://github.com/crvouga/mockingbird/commit/d0b45aa1d12a55967e72b8ddc6573f5998c377ce))
+- parse condition, filter and key-condition expressions by DynamoDB's grammar ([e6085d3](https://github.com/crvouga/mockingbird/commit/e6085d35866b318c7e2b9ee99b5d738352150a99))
+
+## 3.10.2 (2026-11-02)
 
-### Dependencies
+### Fixes and improvements
 
-- `@crvouga/mockingbird-service-sqlite`
+- reopen IndexedDB durability connection after the browser force-closes it ([d0b45aa](https://github.com/crvouga/mockingbird/commit/d0b45aa1d12a55967e72b8ddc6573f5998c377ce))
 
 ## 3.10.1 (2026-11-02)
 

package/README.md

@@ -46,7 +46,7 @@ const { Item } = await db.send(new GetCommand({ TableName: "records", Key: { pk:
 await emulator.close() // after the test
 ```
 
-Supported operations are CreateTable, DescribeTable, GetItem, PutItem, UpdateItem, DeleteItem, Query, Scan, BatchGetItem, BatchWriteItem, TransactGetItems, and TransactWriteItems. The expression subset includes expression name/value aliases, SET/ADD/REMOVE/DELETE, `if_not_exists`, `attribute_exists`, `attribute_not_exists`, `begins_with`, comparisons, BETWEEN, AND/OR, projection, conditions, limits, cursors, index ordering, and return values.
+Supported operations are CreateTable, DescribeTable, GetItem, PutItem, UpdateItem, DeleteItem, Query, Scan, BatchGetItem, BatchWriteItem, TransactGetItems, and TransactWriteItems. The expression subset includes expression name/value aliases, SET/ADD/REMOVE/DELETE, `if_not_exists`; condition, filter and key-condition expressions parsed by DynamoDB's grammar (comparisons between values or paths, BETWEEN, IN, AND/OR/NOT with parentheses, `attribute_exists`, `attribute_not_exists`, `attribute_type`, `begins_with`, `contains`, `size`); projection, conditions, limits, cursors, index ordering, and return values.
 
 ### Admin and deterministic controls
 

package/dist/{chunk-CMCJXLNA.js → chunk-KVPS4PKK.js}

@@ -9,7 +9,7 @@ import {
   parseFaultHeader,
   resolveAdminPrefix,
   restoreClock
-} from "./chunk-JAVDTXSC.js";
+} from "./chunk-WWR6WDQX.js";
 
 // ../../adapters/node/dist/cli.js
 import { readFile as readFile5 } from "node:fs/promises";
@@ -3057,7 +3057,7 @@ async function preflightFleet(config, options) {
             break;
         }
       }
-      targets.set(name, { ...target, packageVersion: packageVersion ?? "3.10.2" });
+      targets.set(name, { ...target, packageVersion: packageVersion ?? "3.10.3" });
     } catch (error) {
       throw new Error(`service ${name}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -5012,4 +5012,4 @@ export {
   createServer2 as createServer,
   serveTarget
 };
-//# sourceMappingURL=chunk-CMCJXLNA.js.map
+//# sourceMappingURL=chunk-KVPS4PKK.js.map

package/dist/{chunk-JAVDTXSC.js → chunk-WWR6WDQX.js}

@@ -1037,14 +1037,14 @@ var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
   const capacity = Math.max(0, Math.floor(size));
   const rings = /* @__PURE__ */ new Map();
   let sequence = 0;
-  const order = /* @__PURE__ */ new WeakMap();
+  const order2 = /* @__PURE__ */ new WeakMap();
   const inOrder = (ring) => ring.entries.length < capacity ? ring.entries : [...ring.entries.slice(ring.next), ...ring.entries.slice(0, ring.next)];
   return {
     size: capacity,
     record(entry) {
       if (capacity === 0)
         return;
-      order.set(entry, sequence++);
+      order2.set(entry, sequence++);
       let ring = rings.get(entry.namespace);
       if (!ring) {
         ring = { entries: [], next: 0 };
@@ -1058,7 +1058,7 @@ var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
       }
     },
     list(query = {}) {
-      const source = query.namespace !== void 0 ? inOrder(rings.get(query.namespace) ?? { entries: [], next: 0 }) : [...rings.values()].flatMap(inOrder).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+      const source = query.namespace !== void 0 ? inOrder(rings.get(query.namespace) ?? { entries: [], next: 0 }) : [...rings.values()].flatMap(inOrder).sort((a, b) => (order2.get(a) ?? 0) - (order2.get(b) ?? 0));
       const matched = source.filter((entry) => (query.operationId === void 0 || entry.operationId === query.operationId) && (query.method === void 0 || entry.method.toUpperCase() === query.method.toUpperCase()) && (query.path === void 0 || entry.path === query.path) && (query.faultId === void 0 || entry.faultId === query.faultId) && (query.status === void 0 || entry.status === query.status) && (query.since === void 0 || Date.parse(entry.at) >= query.since));
       if (query.limit === void 0)
         return matched;
@@ -1991,7 +1991,7 @@ var listing = (entry) => ({
   hits: entry.hits,
   seen: entry.seen
 });
-var createFaultRegistry = (random = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
+var createFaultRegistry = (random = createRng(0), sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))) => {
   const entries = [];
   const counters = /* @__PURE__ */ new Map();
   const own = /* @__PURE__ */ new Map();
@@ -2287,7 +2287,7 @@ var createNamespaceControls = (options) => {
     if (change.autoAdvanceMs !== void 0)
       settingsOf(namespace).autoAdvanceMs = change.autoAdvanceMs;
   };
-  const resolve = (namespace, input, now) => {
+  const resolve2 = (namespace, input, now) => {
     if (!isRecord2(input))
       throw new ControlError("fault: expected an object");
     if (typeof input.preset !== "string") {
@@ -2339,7 +2339,7 @@ var createNamespaceControls = (options) => {
     for (const each of plan.faults ?? []) {
       if (isRecord2(each) && each.namespace === "*")
         throw new ControlError('faults: a control document cannot hold a "*" rule; add it with POST /faults');
-      resolve("default", each, 0);
+      resolve2("default", each, 0);
     }
   };
   const commit = (namespace, plan, replace) => {
@@ -2356,7 +2356,7 @@ var createNamespaceControls = (options) => {
         faults.clear(namespace);
       const now = options.clock(namespace).now();
       for (const each of plan.faults)
-        store(namespace, resolve(namespace, { ...each, namespace }, now));
+        store(namespace, resolve2(namespace, { ...each, namespace }, now));
     }
   };
   const bootPlan = (namespace) => ({
@@ -2433,7 +2433,7 @@ var createNamespaceControls = (options) => {
     },
     addFault(namespace, input) {
       ensure(namespace);
-      return store(namespace, resolve(namespace, input, options.clock(namespace).now()));
+      return store(namespace, resolve2(namespace, input, options.clock(namespace).now()));
     },
     scriptFaults(namespace, request) {
       const rules = [];
@@ -2443,7 +2443,7 @@ var createNamespaceControls = (options) => {
           if (chooses)
             throw new ControlError(`fault: ${chooses} has no meaning here; a fault in a header is for its own request`);
         }
-        for (const { rule } of resolve(namespace, request.fault, 0).rules) {
+        for (const { rule } of resolve2(namespace, request.fault, 0).rules) {
           const action = { id: "request" };
           for (const key of ACTION)
             if (rule[key] !== void 0)
@@ -3646,12 +3646,12 @@ var inspectState = (scope) => {
       ...declaration?.meta !== void 0 ? { meta: declaration.meta } : {}
     });
   }
-  const order = /* @__PURE__ */ new Map();
+  const order2 = /* @__PURE__ */ new Map();
   for (const [index, item] of (scope.declarations ?? []).entries())
-    order.set(item.name, index);
+    order2.set(item.name, index);
   collections.sort((a, b) => {
-    const left = order.get(a.name);
-    const right = order.get(b.name);
+    const left = order2.get(a.name);
+    const right = order2.get(b.name);
     if (left !== void 0 && right !== void 0)
       return left - right;
     if (left !== void 0)
@@ -3673,14 +3673,14 @@ var pageOf = (sqlite, storageNamespace, name2, query) => {
   if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
     return fail(400, "limit must be an integer from 1 to 200");
   }
-  const order = query.order ?? "newest";
-  if (order !== "newest" && order !== "oldest")
+  const order2 = query.order ?? "newest";
+  if (order2 !== "newest" && order2 !== "oldest")
     return fail(400, 'order must be "newest" or "oldest"');
   const collection = collectionOf(sqlite, storageNamespace, name2);
-  const rows = collection.list({ order }).filter((row) => {
+  const rows = collection.list({ order: order2 }).filter((row) => {
     if (query.after === void 0)
       return true;
-    return order === "newest" ? row.seq < query.after : row.seq > query.after;
+    return order2 === "newest" ? row.seq < query.after : row.seq > query.after;
   });
   const slice = rows.slice(0, limit);
   const last = slice.at(-1);
@@ -3795,11 +3795,11 @@ var stateAdminRoutes = (routes) => {
         return adminError2(400, "limit: expected an integer");
       if (after === "bad")
         return adminError2(400, "after: expected a sequence number");
-      const order = url.searchParams.get("order");
+      const order2 = url.searchParams.get("order");
       return fromResult(readStatePage(scope.value, params.collection ?? "", {
         ...limit !== void 0 ? { limit } : {},
         ...after !== void 0 ? { after } : {},
-        ...order === "newest" || order === "oldest" ? { order } : {}
+        ...order2 === "newest" || order2 === "oldest" ? { order: order2 } : {}
       }), 200);
     },
     "GET /state/:collection/:id": ({ namespace, params }) => {
@@ -3861,7 +3861,7 @@ var stateAdminRoutes = (routes) => {
 };
 
 // ../core/dist/version.js
-var PACKAGE_VERSION = true ? "3.10.2" : UNRELEASED_VERSION;
+var PACKAGE_VERSION = true ? "3.10.3" : UNRELEASED_VERSION;
 
 // ../core/dist/webhooks.js
 var json4 = (status, body) => new Response(JSON.stringify(body), {
@@ -4016,7 +4016,7 @@ var DroppedConnectionError = class extends TypeError {
     this.reason = reason;
   }
 };
-var realSleep = (ms, signal) => new Promise((resolve, reject) => {
+var realSleep = (ms, signal) => new Promise((resolve2, reject) => {
   if (signal?.aborted) {
     reject(signal.reason);
     return;
@@ -4027,26 +4027,26 @@ var realSleep = (ms, signal) => new Promise((resolve, reject) => {
   };
   const timer = setTimeout(() => {
     signal?.removeEventListener("abort", abort);
-    resolve();
+    resolve2();
   }, ms);
   signal?.addEventListener("abort", abort, { once: true });
 });
 var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 204, 205, 304]);
-var truncateResponse = (response, bytes) => {
+var truncateResponse = (response, bytes2) => {
   if (NULL_BODY_STATUS.has(response.status))
     return response;
   const reader = response.body?.getReader();
   let sent = 0;
   const body = new ReadableStream({
     async pull(controller) {
-      const chunk = sent < bytes && reader ? await reader.read() : void 0;
+      const chunk = sent < bytes2 && reader ? await reader.read() : void 0;
       if (!chunk || chunk.done) {
         await reader?.cancel().catch(() => {
         });
         controller.error(new DroppedConnectionError("truncate"));
         return;
       }
-      const part = chunk.value.subarray(0, bytes - sent);
+      const part = chunk.value.subarray(0, bytes2 - sent);
       sent += part.length;
       controller.enqueue(part);
     },
@@ -5141,6 +5141,291 @@ var credentialRoutes = (registry) => ({
   }
 });
 
+// src/expression.ts
+var COMPARATORS = /* @__PURE__ */ new Set(["=", "<>", "<", "<=", ">", ">="]);
+var FUNCTIONS = /* @__PURE__ */ new Set([
+  "attribute_exists",
+  "attribute_not_exists",
+  "attribute_type",
+  "begins_with",
+  "contains"
+]);
+var TYPES = /* @__PURE__ */ new Set(["S", "SS", "N", "NS", "B", "BS", "BOOL", "NULL", "L", "M"]);
+var tokenize = (source) => {
+  const tokens = [];
+  const pattern = /\s+|(<>|<=|>=|[=<>(),.[\]])|(#[A-Za-z0-9_]+)|(:[A-Za-z0-9_]+)|([0-9]+)(?![A-Za-z_])|([A-Za-z_][A-Za-z0-9_-]*)/y;
+  let index = 0;
+  while (index < source.length) {
+    pattern.lastIndex = index;
+    const match2 = pattern.exec(source);
+    if (!match2)
+      throw new SyntaxError(`Invalid ConditionExpression: Syntax error; token: "${source[index]}"`);
+    index = pattern.lastIndex;
+    if (match2[1]) tokens.push({ type: "punct", text: match2[1] });
+    else if (match2[2]) tokens.push({ type: "name", text: match2[2] });
+    else if (match2[3]) tokens.push({ type: "value", text: match2[3] });
+    else if (match2[4]) tokens.push({ type: "number", text: match2[4] });
+    else if (match2[5]) tokens.push({ type: "word", text: match2[5] });
+  }
+  return tokens;
+};
+var Parser = class {
+  constructor(tokens, names, values) {
+    this.tokens = tokens;
+    this.names = names;
+    this.values = values;
+  }
+  tokens;
+  names;
+  values;
+  index = 0;
+  parse() {
+    const node = this.or();
+    if (this.peek()) this.fail();
+    return node;
+  }
+  peek(offset = 0) {
+    return this.tokens[this.index + offset];
+  }
+  fail() {
+    const token = this.peek();
+    throw new SyntaxError(
+      `Invalid ConditionExpression: Syntax error; token: "${token?.text ?? "<EOF>"}"`
+    );
+  }
+  keyword(word) {
+    const token = this.peek();
+    if (token?.type === "word" && token.text.toUpperCase() === word) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+  punct(text) {
+    if (this.peek()?.type === "punct" && this.peek()?.text === text) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+  expect(text) {
+    if (!this.punct(text)) this.fail();
+  }
+  or() {
+    let node = this.and();
+    while (this.keyword("OR")) node = { kind: "or", left: node, right: this.and() };
+    return node;
+  }
+  and() {
+    let node = this.not();
+    while (this.keyword("AND")) node = { kind: "and", left: node, right: this.not() };
+    return node;
+  }
+  not() {
+    if (this.keyword("NOT")) return { kind: "not", operand: this.not() };
+    return this.primary();
+  }
+  primary() {
+    if (this.punct("(")) {
+      const node = this.or();
+      this.expect(")");
+      return node;
+    }
+    const token = this.peek();
+    if (token?.type === "word" && FUNCTIONS.has(token.text) && this.peek(1)?.type === "punct" && this.peek(1)?.text === "(") {
+      this.index += 2;
+      const args = [this.operand()];
+      while (this.punct(",")) args.push(this.operand());
+      this.expect(")");
+      const arity = token.text === "attribute_exists" || token.text === "attribute_not_exists" ? 1 : 2;
+      if (args.length !== arity || args[0]?.kind !== "path")
+        throw new SyntaxError(`Invalid ConditionExpression: Incorrect operands for ${token.text}`);
+      return { kind: "call", name: token.text, args };
+    }
+    const left = this.operand();
+    if (this.keyword("BETWEEN")) {
+      const low = this.operand();
+      if (!this.keyword("AND")) this.fail();
+      return { kind: "between", subject: left, low, high: this.operand() };
+    }
+    if (this.keyword("IN")) {
+      this.expect("(");
+      const candidates = [this.operand()];
+      while (this.punct(",")) candidates.push(this.operand());
+      this.expect(")");
+      return { kind: "in", subject: left, candidates };
+    }
+    const op = this.peek();
+    if (op?.type !== "punct" || !COMPARATORS.has(op.text)) this.fail();
+    this.index++;
+    return { kind: "compare", op: op.text, left, right: this.operand() };
+  }
+  operand() {
+    const token = this.peek();
+    if (token?.type === "value") {
+      this.index++;
+      const value = this.values[token.text];
+      if (!value)
+        throw new SyntaxError(
+          `Invalid ConditionExpression: An expression attribute value used in expression is not defined; attribute value: ${token.text}`
+        );
+      return { kind: "value", value };
+    }
+    if (token?.type === "word" && token.text === "size" && this.peek(1)?.type === "punct" && this.peek(1)?.text === "(") {
+      this.index += 2;
+      const path = this.path();
+      this.expect(")");
+      return { kind: "size", path };
+    }
+    return { kind: "path", path: this.path() };
+  }
+  segment() {
+    const token = this.peek();
+    if (token?.type === "name") {
+      this.index++;
+      const name2 = this.names[token.text];
+      if (name2 === void 0)
+        throw new SyntaxError(
+          `Invalid ConditionExpression: An expression attribute name used in the document path is not defined; attribute name: ${token.text}`
+        );
+      return name2;
+    }
+    if (token?.type === "word") {
+      this.index++;
+      return token.text;
+    }
+    return this.fail();
+  }
+  path() {
+    const path = [this.segment()];
+    for (; ; ) {
+      if (this.punct(".")) path.push(this.segment());
+      else if (this.punct("[")) {
+        const token = this.peek();
+        if (token?.type !== "number") this.fail();
+        this.index++;
+        path.push(Number(token.text));
+        this.expect("]");
+      } else return path;
+    }
+  }
+};
+var resolve = (item, path) => {
+  let value = item[path[0]];
+  for (const segment of path.slice(1))
+    value = typeof segment === "number" ? value?.L?.[segment] : value?.M?.[segment];
+  return value;
+};
+var typeOf = (value) => Object.keys(value)[0];
+var bytes = (base64) => Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
+var order = (left, right) => {
+  if (left?.N !== void 0 && right?.N !== void 0) return Number(left.N) - Number(right.N);
+  if (left?.S !== void 0 && right?.S !== void 0)
+    return left.S < right.S ? -1 : left.S > right.S ? 1 : 0;
+  if (left?.B !== void 0 && right?.B !== void 0) {
+    const a = bytes(String(left.B));
+    const b = bytes(String(right.B));
+    for (let i = 0; i < Math.min(a.length, b.length); i++)
+      if (a[i] !== b[i]) return a[i] - b[i];
+    return a.length - b.length;
+  }
+  return void 0;
+};
+var sameSet = (left, right) => left.length === right.length && left.every((entry) => right.includes(entry));
+var equal = (left, right) => {
+  if (left === void 0 || right === void 0) return false;
+  if (left.N !== void 0 && right.N !== void 0) return Number(left.N) === Number(right.N);
+  for (const set2 of ["SS", "NS", "BS"]) {
+    const a = left[set2];
+    const b = right[set2];
+    if (a && b) return sameSet(a, b);
+  }
+  return JSON.stringify(left) === JSON.stringify(right);
+};
+var operandValue = (item, operand) => {
+  if (operand.kind === "value") return operand.value;
+  const value = resolve(item, operand.path);
+  if (operand.kind === "path" || value === void 0) return value;
+  if (value.S !== void 0) return { N: String([...value.S].length) };
+  if (value.B !== void 0) return { N: String(bytes(String(value.B)).length) };
+  const collection = value.SS ?? value.NS ?? value.BS ?? value.L;
+  if (collection) return { N: String(collection.length) };
+  if (value.M) return { N: String(Object.keys(value.M).length) };
+  return void 0;
+};
+var call = (item, name2, args) => {
+  const subject = operandValue(item, args[0]);
+  const argument = args[1] ? operandValue(item, args[1]) : void 0;
+  switch (name2) {
+    case "attribute_exists":
+      return subject !== void 0;
+    case "attribute_not_exists":
+      return subject === void 0;
+    case "attribute_type":
+      if (argument?.S === void 0 || !TYPES.has(argument.S))
+        throw new SyntaxError(
+          `Invalid ConditionExpression: Invalid attribute type name found in type`
+        );
+      return subject !== void 0 && typeOf(subject) === argument.S;
+    case "begins_with":
+      if (subject?.S !== void 0 && argument?.S !== void 0)
+        return subject.S.startsWith(argument.S);
+      if (subject?.B !== void 0 && argument?.B !== void 0) {
+        const whole = bytes(String(subject.B));
+        const prefix = bytes(String(argument.B));
+        return prefix.every((byte, i) => whole[i] === byte);
+      }
+      return false;
+    case "contains":
+      if (subject === void 0 || argument === void 0) return false;
+      if (subject.S !== void 0 && argument.S !== void 0) return subject.S.includes(argument.S);
+      if (subject.SS && argument.S !== void 0) return subject.SS.includes(argument.S);
+      if (subject.NS && argument.N !== void 0)
+        return subject.NS.some((entry) => Number(entry) === Number(argument.N));
+      if (subject.BS && argument.B !== void 0) return subject.BS.includes(argument.B);
+      if (subject.L) return subject.L.some((entry) => equal(entry, argument));
+      return false;
+  }
+  return false;
+};
+var evaluate = (node, item) => {
+  switch (node.kind) {
+    case "or":
+      return evaluate(node.left, item) || evaluate(node.right, item);
+    case "and":
+      return evaluate(node.left, item) && evaluate(node.right, item);
+    case "not":
+      return !evaluate(node.operand, item);
+    case "call":
+      return call(item, node.name, node.args);
+    case "in": {
+      const subject = operandValue(item, node.subject);
+      return node.candidates.some((candidate) => equal(subject, operandValue(item, candidate)));
+    }
+    case "between": {
+      const subject = operandValue(item, node.subject);
+      const low = order(subject, operandValue(item, node.low));
+      const high = order(subject, operandValue(item, node.high));
+      return low !== void 0 && high !== void 0 && low >= 0 && high <= 0;
+    }
+    case "compare": {
+      const left = operandValue(item, node.left);
+      const right = operandValue(item, node.right);
+      if (node.op === "=") return equal(left, right);
+      if (node.op === "<>") return !equal(left, right);
+      const sign = order(left, right);
+      if (sign === void 0) return false;
+      return node.op === "<" ? sign < 0 : node.op === "<=" ? sign <= 0 : node.op === ">" ? sign > 0 : sign >= 0;
+    }
+  }
+};
+var compileCondition = (expression, names, values) => {
+  if (typeof expression !== "string" || !expression.trim()) return () => true;
+  const tree = new Parser(tokenize(expression), names, values).parse();
+  return (item) => evaluate(tree, item ?? {});
+};
+var condition = (expression, item, names, values) => compileCondition(expression, names, values)(item);
+
 // src/generated/openapi.ts
 var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"Amazon DynamoDB (Mockingbird subset)","version":"2012-08-10","description":"AWS JSON DynamoDB contract used by AWS SDK v3."},"servers":[{"url":"https://dynamodb.us-east-1.amazonaws.com"}],"paths":{"/":{"post":{"operationId":"DynamoDbRpc","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"parameters":[{"name":"X-Amz-Target","in":"header","required":true,"schema":{"type":"string","pattern":"^DynamoDB_20120810\\\\\\\\.[A-Za-z]+$"}}],"requestBody":{"required":true,"content":{"application/x-amz-json-1.0":{"schema":{"type":"object","additionalProperties":true}},"application/json":{"schema":{"type":"object","additionalProperties":true}}}},"responses":{"200":{"description":"Operation response","content":{"application/x-amz-json-1.0":{"schema":{"type":"object","additionalProperties":true}}}},"400":{"description":"DynamoDB exception","content":{"application/x-amz-json-1.0":{"schema":{"type":"object","additionalProperties":true}}}}}}}}}`);
 var operationIds = ["DynamoDbRpc"];
@@ -5231,7 +5516,6 @@ var DYNAMODB_NAMESPACE = "dynamodb";
 var accessKeyCredential = sigV4AccessKeyId;
 var clone = (value) => structuredClone(value);
 var scalar = (value) => value?.S ?? (value?.N !== void 0 ? Number(value.N) : value?.BOOL ?? value?.B);
-var equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
 var resolveName = (name2, names) => name2.split(".").map((part) => names[part] ?? part).join(".");
 var get = (item, path, names) => {
   const parts = resolveName(path.trim(), names).split(".");
@@ -5277,52 +5561,6 @@ var splitTop = (value, separator = ",") => {
   out.push(value.slice(start).trim());
   return out.filter(Boolean);
 };
-var condition = (expression, item, names, values) => {
-  if (typeof expression !== "string" || !expression.trim()) return true;
-  const source = expression.trim().replace(/^\((.*)\)$/, "$1");
-  const ors = source.split(/\s+OR\s+/i);
-  if (ors.length > 1) return ors.some((part) => condition(part, item, names, values));
-  const ands = source.split(/\s+AND\s+/i);
-  if (ands.length > 1 && !/\s+BETWEEN\s+/i.test(source))
-    return ands.every((part) => condition(part, item, names, values));
-  const exists = /^attribute_(not_)?exists\s*\(([^)]+)\)$/i.exec(source);
-  if (exists)
-    return exists[1] ? get(item ?? {}, exists[2], names) === void 0 : get(item ?? {}, exists[2], names) !== void 0;
-  const begins = /^begins_with\s*\(([^,]+),\s*(:\w+)\)$/i.exec(source);
-  if (begins)
-    return String(scalar(get(item ?? {}, begins[1], names)) ?? "").startsWith(
-      String(scalar(values[begins[2]]) ?? "")
-    );
-  const between = /^(.+?)\s+BETWEEN\s+(:\w+)\s+AND\s+(:\w+)$/i.exec(source);
-  if (between) {
-    const actual = scalar(get(item ?? {}, between[1], names));
-    const low = scalar(values[between[2]]);
-    const high = scalar(values[between[3]]);
-    return actual !== void 0 && low !== void 0 && high !== void 0 && actual >= low && actual <= high;
-  }
-  const comparison = /^(.+?)\s*(=|<>|<=|>=|<|>)\s*(:\w+)$/.exec(source);
-  if (comparison) {
-    const leftValue = get(item ?? {}, comparison[1], names);
-    const rightValue = values[comparison[3]];
-    const left = scalar(leftValue);
-    const right = scalar(rightValue);
-    switch (comparison[2]) {
-      case "=":
-        return equal(leftValue, rightValue);
-      case "<>":
-        return !equal(leftValue, rightValue);
-      case "<":
-        return left !== void 0 && right !== void 0 && left < right;
-      case "<=":
-        return left !== void 0 && right !== void 0 && left <= right;
-      case ">":
-        return left !== void 0 && right !== void 0 && left > right;
-      case ">=":
-        return left !== void 0 && right !== void 0 && left >= right;
-    }
-  }
-  throw new SyntaxError(`Unsupported expression: ${expression}`);
-};
 var project = (item, expression, names) => typeof expression !== "string" ? clone(item) : Object.fromEntries(
   splitTop(expression).map((path) => [resolveName(path, names), get(item, path, names)]).filter((entry) => entry[1] !== void 0)
 );
@@ -5548,14 +5786,12 @@ var DynamoAPI = class {
       const found = rows.findIndex((row) => row.key === start);
       if (found >= 0) rows = rows.slice(found + 1);
     }
-    const matching = rows.filter(
-      (row) => !query || condition(input.KeyConditionExpression, row.value, names, values)
-    );
+    const keyCondition = compileCondition(query ? input.KeyConditionExpression : "", names, values);
+    const filter = compileCondition(input.FilterExpression, names, values);
+    const matching = rows.filter((row) => keyCondition(row.value));
     const limit = input.Limit === void 0 ? matching.length : Math.max(0, Number(input.Limit));
     const evaluated = matching.slice(0, limit);
-    const filtered = evaluated.filter(
-      (row) => condition(input.FilterExpression, row.value, names, values)
-    );
+    const filtered = evaluated.filter((row) => filter(row.value));
     const last = matching.length > evaluated.length ? evaluated.at(-1) : void 0;
     return {
       Items: filtered.map((row) => project(row.value, input.ProjectionExpression, names)),
@@ -5763,4 +5999,4 @@ export {
   accessKeyCredential,
   DynamoAPI
 };
-//# sourceMappingURL=chunk-JAVDTXSC.js.map
+//# sourceMappingURL=chunk-WWR6WDQX.js.map