graphddb 0.1.0

package/dist/testing/index.js

@@ -0,0 +1,898 @@
+import {
+  createCdcEmulator
+} from "../chunk-UNRQ5YJT.js";
+import {
+  ClientManager,
+  MetadataRegistry,
+  TableMapping,
+  resolveModelClass
+} from "../chunk-347U24SB.js";
+
+// src/memory/memory-store.ts
+function deepClone(value) {
+  return structuredClone(value);
+}
+function compareSortKey(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+var MemoryStore = class {
+  /** table → PK → SK → item. */
+  tables = /* @__PURE__ */ new Map();
+  partition(table, pk) {
+    return this.tables.get(table)?.get(pk);
+  }
+  /** Insert/overwrite one physical item. Returns the prior item if present. */
+  putItem(table, item) {
+    const pk = String(item.PK);
+    const sk = String(item.SK ?? "");
+    let tbl = this.tables.get(table);
+    if (!tbl) {
+      tbl = /* @__PURE__ */ new Map();
+      this.tables.set(table, tbl);
+    }
+    let part = tbl.get(pk);
+    if (!part) {
+      part = /* @__PURE__ */ new Map();
+      tbl.set(pk, part);
+    }
+    const prior = part.get(sk);
+    part.set(sk, deepClone(item));
+    return prior ? deepClone(prior) : void 0;
+  }
+  /** Fetch one physical item by base-table key. */
+  getItem(table, pk, sk) {
+    const item = this.partition(table, pk)?.get(sk);
+    return item ? deepClone(item) : void 0;
+  }
+  /** Delete one item by base-table key. Returns the removed item if present. */
+  deleteItem(table, pk, sk) {
+    const part = this.partition(table, pk);
+    if (!part) return void 0;
+    const prior = part.get(sk);
+    part.delete(sk);
+    if (part.size === 0) {
+      this.tables.get(table)?.delete(pk);
+    }
+    return prior ? deepClone(prior) : void 0;
+  }
+  /**
+   * All items in one base-table partition, sorted ascending by SK (byte order).
+   * Used by the Query path (PK eq + optional SK range).
+   */
+  partitionItems(table, pk) {
+    const part = this.partition(table, pk);
+    if (!part) return [];
+    return [...part.values()].map((it) => deepClone(it)).sort((a, b) => compareSortKey(String(a.SK ?? ""), String(b.SK ?? "")));
+  }
+  /**
+   * All items in one GSI partition (rows whose `{index}PK` equals `pk`), sorted
+   * ascending by the GSI sort key (`{index}SK`, byte order). Filtering the base
+   * rows is equivalent to a maintained ALL-projection secondary index.
+   */
+  gsiPartitionItems(table, indexName, pk) {
+    const pkAttr = `${indexName}PK`;
+    const skAttr = `${indexName}SK`;
+    const tbl = this.tables.get(table);
+    if (!tbl) return [];
+    const matched = [];
+    for (const part of tbl.values()) {
+      for (const item of part.values()) {
+        if (String(item[pkAttr] ?? "") === pk) {
+          matched.push(deepClone(item));
+        }
+      }
+    }
+    return matched.sort(
+      (a, b) => compareSortKey(String(a[skAttr] ?? ""), String(b[skAttr] ?? ""))
+    );
+  }
+  /** Every physical item in one table (unsorted; inspection only). */
+  allItems(table) {
+    const tbl = this.tables.get(table);
+    if (!tbl) return [];
+    const out = [];
+    for (const part of tbl.values()) {
+      for (const item of part.values()) {
+        out.push(deepClone(item));
+      }
+    }
+    return out;
+  }
+  /** Names of every table that currently holds at least one partition. */
+  tableNames() {
+    return [...this.tables.keys()];
+  }
+  /** Item count for one table. */
+  count(table) {
+    const tbl = this.tables.get(table);
+    if (!tbl) return 0;
+    let n = 0;
+    for (const part of tbl.values()) n += part.size;
+    return n;
+  }
+  /** Clear all tables. */
+  reset() {
+    this.tables.clear();
+  }
+  /** Structured-clone the whole store (save). */
+  snapshot() {
+    const out = {};
+    for (const table of this.tables.keys()) {
+      out[table] = this.allItems(table);
+    }
+    return out;
+  }
+  /** Replace all store contents from a snapshot (load). */
+  restore(snapshot) {
+    this.tables.clear();
+    for (const [table, items] of Object.entries(snapshot)) {
+      for (const item of items) {
+        this.putItem(table, item);
+      }
+    }
+  }
+};
+
+// src/memory/filter-eval.ts
+var FUNCTIONS = /* @__PURE__ */ new Set([
+  "begins_with",
+  "contains",
+  "attribute_exists",
+  "attribute_not_exists",
+  "attribute_type",
+  "size"
+]);
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  const n = expr.length;
+  while (i < n) {
+    const c = expr[i];
+    if (c === " ") {
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      tokens.push({ kind: "lparen" });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      tokens.push({ kind: "rparen" });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      tokens.push({ kind: "comma" });
+      i++;
+      continue;
+    }
+    if (c === "#" || c === ":") {
+      let j2 = i + 1;
+      while (j2 < n && /[A-Za-z0-9_]/.test(expr[j2])) j2++;
+      const ident = expr.slice(i, j2);
+      tokens.push({ kind: c === "#" ? "name" : "value", value: ident });
+      i = j2;
+      continue;
+    }
+    if (c === "<") {
+      if (expr[i + 1] === ">") {
+        tokens.push({ kind: "op", value: "<>" });
+        i += 2;
+      } else if (expr[i + 1] === "=") {
+        tokens.push({ kind: "op", value: "<=" });
+        i += 2;
+      } else {
+        tokens.push({ kind: "op", value: "<" });
+        i++;
+      }
+      continue;
+    }
+    if (c === ">") {
+      if (expr[i + 1] === "=") {
+        tokens.push({ kind: "op", value: ">=" });
+        i += 2;
+      } else {
+        tokens.push({ kind: "op", value: ">" });
+        i++;
+      }
+      continue;
+    }
+    if (c === "=") {
+      tokens.push({ kind: "op", value: "=" });
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < n && /[A-Za-z_]/.test(expr[j])) j++;
+    const word = expr.slice(i, j);
+    i = j;
+    const upper = word.toUpperCase();
+    if (upper === "AND") tokens.push({ kind: "and" });
+    else if (upper === "OR") tokens.push({ kind: "or" });
+    else if (upper === "NOT") tokens.push({ kind: "not" });
+    else if (upper === "BETWEEN") tokens.push({ kind: "op", value: "BETWEEN" });
+    else if (upper === "IN") tokens.push({ kind: "op", value: "IN" });
+    else if (FUNCTIONS.has(word)) tokens.push({ kind: "func", value: word });
+    else throw new Error(`memory filter: unexpected token '${word}'`);
+  }
+  return tokens;
+}
+var FilterEvaluator = class {
+  constructor(tokens, ctx) {
+    this.tokens = tokens;
+    this.ctx = ctx;
+  }
+  tokens;
+  ctx;
+  pos = 0;
+  evaluate() {
+    const result = this.parseOr();
+    if (this.pos !== this.tokens.length) {
+      throw new Error("memory filter: trailing tokens after expression");
+    }
+    return result;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    const t = this.tokens[this.pos];
+    if (!t) throw new Error("memory filter: unexpected end of expression");
+    this.pos++;
+    return t;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.peek()?.kind === "or") {
+      this.next();
+      const right = this.parseAnd();
+      left = left || right;
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.peek()?.kind === "and") {
+      this.next();
+      const right = this.parseNot();
+      left = left && right;
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.peek()?.kind === "not") {
+      this.next();
+      return !this.parseNot();
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    if (!t) throw new Error("memory filter: unexpected end of expression");
+    if (t.kind === "lparen") {
+      this.next();
+      const inner = this.parseOr();
+      const close = this.next();
+      if (close.kind !== "rparen") {
+        throw new Error('memory filter: expected ")"');
+      }
+      return inner;
+    }
+    if (t.kind === "func") {
+      return this.parseFunction();
+    }
+    if (t.kind === "name") {
+      return this.parseComparison();
+    }
+    throw new Error(`memory filter: unexpected token kind '${t.kind}'`);
+  }
+  parseFunction() {
+    const fn = this.next();
+    if (fn.kind !== "func") throw new Error("memory filter: expected function");
+    this.expect("lparen");
+    if (fn.value === "attribute_exists" || fn.value === "attribute_not_exists") {
+      const column2 = this.readName();
+      this.expect("rparen");
+      const present = this.attrPresent(column2);
+      return fn.value === "attribute_exists" ? present : !present;
+    }
+    if (fn.value === "size") {
+      const column2 = this.readName();
+      this.expect("rparen");
+      const op = this.next();
+      if (op.kind !== "op" || op.value !== "=") {
+        throw new Error('memory filter: expected "=" after size()');
+      }
+      const expected = this.readValue();
+      const len = this.sizeOf(this.attr(column2));
+      return len === expected;
+    }
+    const column = this.readName();
+    this.expect("comma");
+    const value = this.readValue();
+    this.expect("rparen");
+    const actual = this.attr(column);
+    if (fn.value === "begins_with") {
+      return typeof actual === "string" && actual.startsWith(String(value));
+    }
+    if (fn.value === "contains") {
+      if (typeof actual === "string") return actual.includes(String(value));
+      if (Array.isArray(actual)) return actual.includes(value);
+      if (actual instanceof Set) return actual.has(value);
+      return false;
+    }
+    return this.attrType(actual) === value;
+  }
+  parseComparison() {
+    const column = this.readName();
+    const op = this.next();
+    if (op.kind !== "op") {
+      throw new Error("memory filter: expected an operator after a name");
+    }
+    const actual = this.attr(column);
+    if (op.value === "BETWEEN") {
+      const lo = this.readValue();
+      const and = this.next();
+      if (and.kind !== "and") {
+        throw new Error("memory filter: expected AND in BETWEEN");
+      }
+      const hi = this.readValue();
+      return compare(actual, lo) >= 0 && compare(actual, hi) <= 0;
+    }
+    if (op.value === "IN") {
+      this.expect("lparen");
+      const candidates = [this.readValue()];
+      while (this.peek()?.kind === "comma") {
+        this.next();
+        candidates.push(this.readValue());
+      }
+      this.expect("rparen");
+      return candidates.some((v) => looseEq(actual, v));
+    }
+    const expected = this.readValue();
+    switch (op.value) {
+      case "=":
+        return looseEq(actual, expected);
+      case "<>":
+        return !looseEq(actual, expected);
+      case ">":
+        return compare(actual, expected) > 0;
+      case ">=":
+        return compare(actual, expected) >= 0;
+      case "<":
+        return compare(actual, expected) < 0;
+      case "<=":
+        return compare(actual, expected) <= 0;
+      default:
+        throw new Error(`memory filter: unknown operator '${op.value}'`);
+    }
+  }
+  expect(kind) {
+    const t = this.next();
+    if (t.kind !== kind) {
+      throw new Error(`memory filter: expected '${kind}', got '${t.kind}'`);
+    }
+  }
+  readName() {
+    const t = this.next();
+    if (t.kind !== "name") throw new Error("memory filter: expected a name alias");
+    const column = this.ctx.names[t.value];
+    if (column === void 0) {
+      throw new Error(`memory filter: unbound name alias '${t.value}'`);
+    }
+    return column;
+  }
+  readValue() {
+    const t = this.next();
+    if (t.kind !== "value") throw new Error("memory filter: expected a value alias");
+    if (!(t.value in this.ctx.values)) {
+      throw new Error(`memory filter: unbound value alias '${t.value}'`);
+    }
+    return this.ctx.values[t.value];
+  }
+  attr(column) {
+    return this.ctx.item[column];
+  }
+  attrPresent(column) {
+    return column in this.ctx.item;
+  }
+  sizeOf(value) {
+    if (typeof value === "string" || Array.isArray(value)) return value.length;
+    if (value instanceof Set) return value.size;
+    if (value && typeof value === "object") return Object.keys(value).length;
+    return void 0;
+  }
+  attrType(value) {
+    if (typeof value === "string") return "S";
+    if (typeof value === "number") return "N";
+    if (typeof value === "boolean") return "BOOL";
+    if (value === null) return "NULL";
+    if (Array.isArray(value)) return "L";
+    if (value instanceof Set) return "SS";
+    return "M";
+  }
+};
+function looseEq(a, b) {
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  return a === b;
+}
+function compare(a, b) {
+  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function evaluateCompiledFilter(filterExpression, names, values, item) {
+  const tokens = tokenize(filterExpression);
+  return new FilterEvaluator(tokens, { item, names, values }).evaluate();
+}
+
+// src/memory/apply-update.ts
+function resolvePath(pathExpr, names) {
+  return pathExpr.split(".").map((alias) => {
+    const trimmed = alias.trim();
+    const column = names[trimmed];
+    if (column === void 0) {
+      throw new Error(`memory update: unbound name alias '${trimmed}'`);
+    }
+    return column;
+  });
+}
+function setPath(target, segments, value) {
+  let cursor = target;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const existing = cursor[seg];
+    if (existing === null || typeof existing !== "object" || Array.isArray(existing)) {
+      cursor[seg] = {};
+    }
+    cursor = cursor[seg];
+  }
+  cursor[segments[segments.length - 1]] = value;
+}
+function removePath(target, segments) {
+  let cursor = target;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const existing = cursor[seg];
+    if (existing === null || typeof existing !== "object") return;
+    cursor = existing;
+  }
+  delete cursor[segments[segments.length - 1]];
+}
+function applyUpdateExpression(item, expression, clauses) {
+  const setMatch = /SET\s+(.*?)(?:\s+REMOVE\s+|$)/.exec(expression);
+  const removeMatch = /REMOVE\s+(.*)$/.exec(expression);
+  if (setMatch && setMatch[1].trim().length > 0) {
+    const assignments = splitTopLevel(setMatch[1]);
+    for (const assignment of assignments) {
+      const eq = assignment.indexOf("=");
+      if (eq < 0) {
+        throw new Error(`memory update: malformed SET clause '${assignment}'`);
+      }
+      const pathExpr = assignment.slice(0, eq).trim();
+      const valueAlias = assignment.slice(eq + 1).trim();
+      if (!(valueAlias in clauses.values)) {
+        throw new Error(`memory update: unbound value alias '${valueAlias}'`);
+      }
+      const segments = resolvePath(pathExpr, clauses.names);
+      setPath(item, segments, clauses.values[valueAlias]);
+    }
+  }
+  if (removeMatch) {
+    const paths = splitTopLevel(removeMatch[1]);
+    for (const pathExpr of paths) {
+      const trimmed = pathExpr.trim();
+      if (trimmed.length === 0) continue;
+      removePath(item, resolvePath(trimmed, clauses.names));
+    }
+  }
+}
+function splitTopLevel(clause) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of clause) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim().length > 0) parts.push(current);
+  return parts;
+}
+
+// src/memory/apply-condition.ts
+var ConditionalCheckFailed = class extends Error {
+  // Mirror the AWS SDK error name so existing catch/`name`-based handling and
+  // tests that assert on a conditional failure recognize it.
+  name = "ConditionalCheckFailedException";
+  constructor(message = "The conditional request failed") {
+    super(message);
+  }
+};
+function evaluateCondition(expression, names, values, item) {
+  const effectiveItem = item ?? {};
+  const effectiveNames = { ...names ?? {} };
+  let expr = expression;
+  expr = expr.replace(
+    /(attribute_exists|attribute_not_exists)\((PK|SK)\)/g,
+    (_m, fn, col) => {
+      const alias = `#__cond_${col}`;
+      effectiveNames[alias] = col;
+      return `${fn}(${alias})`;
+    }
+  );
+  return evaluateCompiledFilter(expr, effectiveNames, values ?? {}, effectiveItem);
+}
+
+// src/memory/memory-executor.ts
+var MemoryExecutor = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  // ── reads ────────────────────────────────────────────────────────────────
+  async execute(operation) {
+    if (operation.type === "GetItem") {
+      return this.getItem(operation);
+    }
+    if (operation.type === "BatchGetItem") {
+      return this.batchGet(operation);
+    }
+    return this.query(operation);
+  }
+  async batchGet(input) {
+    const items = [];
+    for (const key of input.keys) {
+      const found = this.store.getItem(
+        input.tableName,
+        String(key.PK),
+        String(key.SK ?? "")
+      );
+      if (found) {
+        items.push(projectItem(found, input.projectionExpression, input.expressionAttributeNames));
+      }
+    }
+    return { items };
+  }
+  getItem(operation) {
+    const key = operation.keyCondition;
+    const found = this.store.getItem(
+      operation.tableName,
+      String(key.PK),
+      String(key.SK ?? "")
+    );
+    if (!found) return { items: [] };
+    return {
+      items: [
+        projectItem(
+          found,
+          operation.projectionExpression,
+          operation.expressionAttributeNames
+        )
+      ]
+    };
+  }
+  query(operation) {
+    const { keyCondition, indexName } = operation;
+    const pkAttr = indexName ? `${indexName}PK` : "PK";
+    const skAttr = indexName ? `${indexName}SK` : "SK";
+    const pkValue = String(keyCondition[pkAttr]);
+    let rows = indexName ? this.store.gsiPartitionItems(operation.tableName, indexName, pkValue) : this.store.partitionItems(operation.tableName, pkValue);
+    const skEq = keyCondition[skAttr];
+    if (skEq !== void 0) {
+      rows = rows.filter((it) => String(it[skAttr] ?? "") === String(skEq));
+    } else if (operation.rangeCondition) {
+      const prefix = String(operation.rangeCondition.value);
+      rows = rows.filter(
+        (it) => String(it[operation.rangeCondition.key] ?? "").startsWith(prefix)
+      );
+    }
+    if (operation.scanIndexForward === false) {
+      rows = rows.slice().reverse();
+    }
+    if (operation.exclusiveStartKey) {
+      const startSk = String(operation.exclusiveStartKey[skAttr] ?? "");
+      const startPk = String(operation.exclusiveStartKey[pkAttr] ?? pkValue);
+      const idx = rows.findIndex(
+        (it) => String(it[pkAttr] ?? "") === startPk && String(it[skAttr] ?? "") === startSk
+      );
+      if (idx >= 0) {
+        rows = rows.slice(idx + 1);
+      }
+    }
+    if (operation.filterExpression) {
+      rows = rows.filter(
+        (it) => evaluateCompiledFilter(
+          operation.filterExpression,
+          operation.filterExpressionAttributeNames ?? {},
+          operation.filterExpressionAttributeValues ?? {},
+          it
+        )
+      );
+    }
+    let lastEvaluatedKey;
+    if (operation.limit != null && rows.length > operation.limit) {
+      const lastRow = rows[operation.limit - 1];
+      rows = rows.slice(0, operation.limit);
+      lastEvaluatedKey = { PK: lastRow.PK, SK: lastRow.SK ?? "" };
+      if (indexName) {
+        lastEvaluatedKey[pkAttr] = lastRow[pkAttr];
+        lastEvaluatedKey[skAttr] = lastRow[skAttr];
+      }
+    }
+    const projected = rows.map(
+      (it) => projectItem(
+        it,
+        operation.projectionExpression,
+        operation.expressionAttributeNames
+      )
+    );
+    return lastEvaluatedKey ? { items: projected, lastEvaluatedKey } : { items: projected };
+  }
+  // ── writes ─────────────────────────────────────────────────────────────────
+  async put(input, options) {
+    const prior = this.store.getItem(
+      input.TableName,
+      String(input.Item.PK),
+      String(input.Item.SK ?? "")
+    );
+    this.assertCondition(input.ConditionExpression, input, prior);
+    this.store.putItem(input.TableName, input.Item);
+    return options?.returnOldImage && prior ? { oldItem: prior } : {};
+  }
+  async update(input, options) {
+    const pk = String(input.Key.PK);
+    const sk = String(input.Key.SK ?? "");
+    const prior = this.store.getItem(input.TableName, pk, sk);
+    this.assertCondition(input.ConditionExpression, input, prior);
+    const next = prior ? { ...prior } : { PK: pk, SK: sk };
+    applyUpdateExpression(next, input.UpdateExpression, {
+      names: input.ExpressionAttributeNames,
+      values: input.ExpressionAttributeValues ?? {}
+    });
+    this.store.putItem(input.TableName, next);
+    return options?.returnOldImage && prior ? { oldItem: prior } : {};
+  }
+  async delete(input, options) {
+    const pk = String(input.Key.PK);
+    const sk = String(input.Key.SK ?? "");
+    const prior = this.store.getItem(input.TableName, pk, sk);
+    this.assertCondition(input.ConditionExpression, input, prior);
+    this.store.deleteItem(input.TableName, pk, sk);
+    return options?.returnOldImage && prior ? { oldItem: prior } : {};
+  }
+  async batchWrite(tableName, items) {
+    for (const item of items) {
+      if (item.type === "put") {
+        this.store.putItem(tableName, item.item);
+      } else {
+        this.store.deleteItem(
+          tableName,
+          String(item.key.PK),
+          String(item.key.SK ?? "")
+        );
+      }
+    }
+  }
+  async transactWrite(items) {
+    if (items.length === 0) return;
+    const touchedTables = /* @__PURE__ */ new Set();
+    for (const it of items) {
+      if ("Put" in it) touchedTables.add(it.Put.TableName);
+      else if ("Update" in it) touchedTables.add(it.Update.TableName);
+      else if ("Delete" in it) touchedTables.add(it.Delete.TableName);
+      else touchedTables.add(it.ConditionCheck.TableName);
+    }
+    const backup = /* @__PURE__ */ new Map();
+    for (const table of touchedTables) {
+      backup.set(table, this.store.allItems(table));
+    }
+    try {
+      for (const it of items) {
+        if ("Put" in it) {
+          await this.put(it.Put);
+        } else if ("Update" in it) {
+          await this.update(it.Update);
+        } else if ("Delete" in it) {
+          await this.delete(it.Delete);
+        } else {
+          this.conditionCheck(it.ConditionCheck);
+        }
+      }
+    } catch (err) {
+      for (const [table, snapshot] of backup) {
+        this.restoreTable(table, snapshot);
+      }
+      if (err instanceof ConditionalCheckFailed) {
+        throw new ConditionalCheckFailed(
+          "Transaction cancelled, please refer cancellation reasons for specific reasons"
+        );
+      }
+      throw err;
+    }
+  }
+  restoreTable(table, items) {
+    for (const existing of this.store.allItems(table)) {
+      this.store.deleteItem(
+        table,
+        String(existing.PK),
+        String(existing.SK ?? "")
+      );
+    }
+    for (const item of items) {
+      this.store.putItem(table, item);
+    }
+  }
+  /**
+   * Evaluate a transaction `ConditionCheck` (issue #81): read the keyed item and
+   * assert its `ConditionExpression` holds. Mutates nothing; a failed assertion
+   * throws {@link ConditionalCheckFailed}, which {@link transactWrite} catches to
+   * roll the whole transaction back — mirroring DynamoDB's atomic cancellation.
+   */
+  conditionCheck(input) {
+    const prior = this.store.getItem(
+      input.TableName,
+      String(input.Key.PK),
+      String(input.Key.SK ?? "")
+    );
+    this.assertCondition(input.ConditionExpression, input, prior);
+  }
+  assertCondition(expression, input, item) {
+    if (!expression) return;
+    const ok = evaluateCondition(
+      expression,
+      input.ExpressionAttributeNames,
+      input.ExpressionAttributeValues,
+      item
+    );
+    if (!ok) {
+      throw new ConditionalCheckFailed();
+    }
+  }
+};
+function projectItem(item, projectionExpression, names) {
+  if (!projectionExpression) return item;
+  const paths = projectionExpression.split(",").map((p) => p.trim());
+  const out = {};
+  for (const pathExpr of paths) {
+    const segments = pathExpr.split(".").map((alias) => {
+      const trimmed = alias.trim();
+      return names?.[trimmed] ?? trimmed;
+    });
+    copyPath(item, out, segments);
+  }
+  return out;
+}
+function copyPath(src, dest, segments) {
+  let s = src;
+  for (const seg of segments) {
+    if (s === null || typeof s !== "object") return;
+    s = s[seg];
+    if (s === void 0) return;
+  }
+  let cursor = dest;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (cursor[seg] === void 0 || cursor[seg] === null || typeof cursor[seg] !== "object") {
+      cursor[seg] = {};
+    }
+    cursor = cursor[seg];
+  }
+  cursor[segments[segments.length - 1]] = s;
+}
+
+// src/testing/index.ts
+function physicalTableName(model) {
+  const modelClass = toClass(model);
+  const meta = MetadataRegistry.get(modelClass);
+  return TableMapping.resolve(meta.tableName);
+}
+function toClass(model) {
+  try {
+    return resolveModelClass(model);
+  } catch {
+    return model;
+  }
+}
+function createTestDB(options = {}) {
+  const store = new MemoryStore();
+  const executor = new MemoryExecutor(store);
+  ClientManager.setExecutor(executor);
+  const logicalToPhysical = /* @__PURE__ */ new Map();
+  for (const model of options.models ?? []) {
+    const modelClass = toClass(model);
+    const meta = MetadataRegistry.get(modelClass);
+    logicalToPhysical.set(meta.tableName, physicalTableName(model));
+  }
+  function resolveTable(table) {
+    return logicalToPhysical.get(table) ?? TableMapping.resolve(table);
+  }
+  let emulator = null;
+  if (options.cdc) {
+    emulator = createCdcEmulator({
+      mode: "record",
+      models: (options.models ?? []).map(toClass)
+    });
+  }
+  const inspector = {
+    dump() {
+      const out = {};
+      for (const table of store.tableNames()) {
+        out[table] = store.allItems(table);
+      }
+      return out;
+    },
+    dumpTable(table) {
+      return store.allItems(resolveTable(table));
+    },
+    scan(table, filter) {
+      const physical = resolveTable(table);
+      const index = filter?.index;
+      const pkAttr = index ? `${index}PK` : "PK";
+      const skAttr = index ? `${index}SK` : "SK";
+      let rows = store.allItems(physical);
+      if (filter?.pk !== void 0) {
+        rows = rows.filter((it) => String(it[pkAttr] ?? "") === filter.pk);
+      }
+      if (filter?.skPrefix !== void 0) {
+        rows = rows.filter(
+          (it) => String(it[skAttr] ?? "").startsWith(filter.skPrefix)
+        );
+      }
+      return rows;
+    },
+    count(table) {
+      return store.count(resolveTable(table));
+    },
+    getRaw(table, key) {
+      return store.getItem(resolveTable(table), key.PK, key.SK) ?? null;
+    },
+    seed(table, items) {
+      const physical = resolveTable(table);
+      for (const item of items) {
+        store.putItem(physical, item);
+      }
+    },
+    reset() {
+      store.reset();
+      emulator?.reset();
+    },
+    snapshot() {
+      return store.snapshot();
+    },
+    restore(snapshot) {
+      store.restore(snapshot);
+    },
+    changes() {
+      if (!emulator) {
+        throw new Error(
+          "createTestDB: changes() requires { cdc: true }. Pass it to createTestDB."
+        );
+      }
+      return emulator.record().events;
+    },
+    close() {
+      emulator?.close();
+      emulator = null;
+      ClientManager.resetExecutor();
+    }
+  };
+  return { testing: inspector, store };
+}
+export {
+  MemoryExecutor,
+  MemoryStore,
+  createTestDB
+};