equipped 5.2.9 → 5.3.0-alpha.0

package/dist/esm/chunk-6SB5M4XH.mjs

@@ -0,0 +1,795 @@
+import {
+  Filter,
+  FilterGroup,
+  IncOp,
+  MaxOp,
+  MinOp,
+  MulOp,
+  OrmAdapter,
+  PatchOp,
+  PullOp,
+  PushOp,
+  SetOp,
+  UnsetOp
+} from "./chunk-TWKHVLLT.mjs";
+import {
+  configurable
+} from "./chunk-2TCFNKRZ.mjs";
+
+// src/orm/adapters/in-memory/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { v, differ } from "valleyed";
+var inMemoryConnectionPipe = () => v.object({});
+function clone(value) {
+  return structuredClone(value);
+}
+var replaceMap = (target, source) => {
+  target.clear();
+  for (const [k, val] of source.entries()) target.set(k, val);
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsSubset(source, needle) {
+  if (Array.isArray(source)) {
+    const wanted = Array.isArray(needle) ? needle : [needle];
+    return wanted.every((item) => source.some((existing) => differ.equal(existing, item)));
+  }
+  if (isPlainObject(source) && isPlainObject(needle)) {
+    return Object.entries(needle).every(([k, v2]) => containsSubset(source[k], v2));
+  }
+  return differ.equal(source, needle);
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === false ? -1 : 1;
+  const sa = JSON.stringify(a);
+  const sb = JSON.stringify(b);
+  if (sa === sb) return 0;
+  return sa < sb ? -1 : 1;
+}
+function resolveConfigName(_, config) {
+  return `${config.prefix ?? ""}${config.table}`;
+}
+function evaluateFilter(doc, filter) {
+  const fieldValue = doc[filter.field];
+  const value = filter.value;
+  switch (filter.op) {
+    case "eq":
+      return differ.equal(fieldValue, value);
+    case "ne":
+      return !differ.equal(fieldValue, value);
+    case "gt":
+      return compareValues(fieldValue, value) > 0;
+    case "gte":
+      return compareValues(fieldValue, value) >= 0;
+    case "lt":
+      return compareValues(fieldValue, value) < 0;
+    case "lte":
+      return compareValues(fieldValue, value) <= 0;
+    case "in": {
+      if (!Array.isArray(value)) return false;
+      return value.some((v2) => differ.equal(fieldValue, v2));
+    }
+    case "notIn": {
+      if (!Array.isArray(value)) return true;
+      return !value.some((v2) => differ.equal(fieldValue, v2));
+    }
+    case "like":
+      return String(fieldValue ?? "").toLowerCase().includes(String(value ?? "").toLowerCase());
+    case "exists":
+      return fieldValue != null;
+    case "notExists":
+      return fieldValue == null;
+    case "contains":
+      return containsSubset(fieldValue, value);
+    case "notContains":
+      return !containsSubset(fieldValue, value);
+    default:
+      return false;
+  }
+}
+function evaluateChild(doc, child) {
+  if (child instanceof Filter) return evaluateFilter(doc, child);
+  if (child instanceof FilterGroup) {
+    if (child.op === "and") return child.children.every((c) => evaluateChild(doc, c));
+    if (child.op === "or") return child.children.some((c) => evaluateChild(doc, c));
+  }
+  return true;
+}
+function matchesFilter(doc, group) {
+  for (const clause of group.children) {
+    if (!evaluateChild(doc, clause)) return false;
+  }
+  return true;
+}
+function applyOptions(rows, options) {
+  let results = rows;
+  if (options?.orderBy?.length) {
+    results = [...results].sort((a, b) => {
+      for (const ord of options.orderBy ?? []) {
+        const cmp = compareValues(a[ord.field], b[ord.field]);
+        if (cmp !== 0) return ord.direction === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  if (options?.offset != null) {
+    results = results.slice(Math.max(0, options.offset));
+  }
+  if (options?.limit != null) {
+    results = results.slice(0, options.limit);
+  }
+  if (options?.select?.length) {
+    const fields = new Set(options.select);
+    results = results.map((row) => {
+      const out = {};
+      for (const key of fields) out[key] = row[key];
+      return out;
+    });
+  }
+  return results;
+}
+function applyUpdateOp(current, key, value) {
+  if (value instanceof IncOp) {
+    const base = Number(current[key] ?? 0);
+    current[key] = base + value.value;
+    return;
+  }
+  if (value instanceof MulOp) {
+    const base = Number(current[key] ?? 0);
+    current[key] = base * value.value;
+    return;
+  }
+  if (value instanceof MinOp) {
+    const base = current[key];
+    current[key] = base == null || compareValues(value.value, base) < 0 ? value.value : base;
+    return;
+  }
+  if (value instanceof MaxOp) {
+    const base = current[key];
+    current[key] = base == null || compareValues(value.value, base) > 0 ? value.value : base;
+    return;
+  }
+  if (value instanceof UnsetOp) {
+    current[key] = null;
+    return;
+  }
+  if (value instanceof PushOp) {
+    const arr = Array.isArray(current[key]) ? [...current[key]] : [];
+    arr.push(clone(value.value));
+    current[key] = arr;
+    return;
+  }
+  if (value instanceof PullOp) {
+    const arr = Array.isArray(current[key]) ? current[key] : [];
+    current[key] = arr.filter((entry) => !differ.equal(entry, value.value));
+    return;
+  }
+  if (value instanceof PatchOp) {
+    const target = isPlainObject(current[key]) ? clone(current[key]) : {};
+    if (isPlainObject(value.value)) {
+      for (const [k, v2] of Object.entries(value.value)) {
+        target[k] = clone(v2);
+      }
+    }
+    current[key] = target;
+    return;
+  }
+  current[key] = clone(value);
+}
+function applyUpdateData(doc, data) {
+  const updated = clone(doc);
+  for (const [key, value] of Object.entries(data)) {
+    applyUpdateOp(updated, key, value);
+  }
+  return updated;
+}
+function applyOps(doc, ops) {
+  const updated = clone(doc);
+  for (const op of ops) {
+    if (op instanceof SetOp) {
+      for (const [key, value] of Object.entries(op.values)) {
+        updated[key] = clone(value);
+      }
+    } else {
+      applyUpdateOp(updated, op.field, op);
+    }
+  }
+  return updated;
+}
+var sessionActiveStore = new AsyncLocalStorage();
+var InMemoryAdapter = class extends configurable(inMemoryConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = v.object({ table: v.string() });
+  supportedFieldTypes = ["string", "number", "boolean", "null", "object", "array", "date"];
+  queryableOps = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "notIn", "like", "exists", "notExists", "contains", "notContains"];
+  updateOps = ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+  aggregateOps = ["count", "countDistinct", "sum", "avg", "min", "max"];
+  stores = /* @__PURE__ */ new Map();
+  migrations = /* @__PURE__ */ new Map();
+  indexes = /* @__PURE__ */ new Map();
+  tables = /* @__PURE__ */ new Map();
+  foreignKeys = /* @__PURE__ */ new Map();
+  #migrationLock = Promise.resolve();
+  constructor(config) {
+    super(config);
+  }
+  #getStore(name) {
+    if (!this.stores.has(name)) this.stores.set(name, /* @__PURE__ */ new Map());
+    return this.stores.get(name);
+  }
+  #resolveStore(schema, config) {
+    return this.#getStore(resolveConfigName(schema, config));
+  }
+  #snapshot() {
+    const stores = /* @__PURE__ */ new Map();
+    for (const [name, store] of this.stores.entries()) {
+      const storeCopy = /* @__PURE__ */ new Map();
+      for (const [id, doc] of store.entries()) {
+        storeCopy.set(id, clone(doc));
+      }
+      stores.set(name, storeCopy);
+    }
+    const migrations = new Map(this.migrations);
+    const indexes = new Map(this.indexes);
+    const tables = /* @__PURE__ */ new Map();
+    for (const [name, meta] of this.tables.entries()) {
+      tables.set(name, { pk: { ...meta.pk }, fields: new Map(meta.fields) });
+    }
+    const foreignKeys = new Map(this.foreignKeys);
+    return { stores, migrations, indexes, tables, foreignKeys };
+  }
+  #restore(snap) {
+    replaceMap(this.stores, snap.stores);
+    replaceMap(this.migrations, snap.migrations);
+    replaceMap(this.indexes, snap.indexes);
+    replaceMap(this.tables, snap.tables);
+    replaceMap(this.foreignKeys, snap.foreignKeys);
+  }
+  async findByPk(schema, config, pk) {
+    const store = this.#resolveStore(schema, config);
+    const doc = store.get(String(pk));
+    return doc ? clone(doc) : null;
+  }
+  async createMany(schema, config, data) {
+    const pk = schema.pkField.name;
+    const store = this.#resolveStore(schema, config);
+    return data.map((d) => {
+      const row = clone(d);
+      store.set(String(row[pk]), row);
+      return clone(row);
+    });
+  }
+  async deleteByPk(schema, config, pk) {
+    const store = this.#resolveStore(schema, config);
+    const pkStr = String(pk);
+    const doc = store.get(pkStr);
+    if (!doc) return null;
+    store.delete(pkStr);
+    return clone(doc);
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const store = this.#resolveStore(schema, config);
+    const pkStr = String(pk);
+    const doc = store.get(pkStr);
+    if (!doc) return null;
+    const updated = applyOps(doc, ops);
+    store.set(pkStr, updated);
+    return clone(updated);
+  }
+  async findMany(schema, config, group, options) {
+    const store = this.#resolveStore(schema, config);
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, group)).map((doc) => clone(doc));
+    return applyOptions(rows, options);
+  }
+  async count(schema, config, group) {
+    const store = this.#resolveStore(schema, config);
+    return [...store.values()].filter((doc) => matchesFilter(doc, group)).length;
+  }
+  async *iterateMany(schema, config, group, options) {
+    const store = this.#resolveStore(schema, config);
+    const rows = applyOptions([...store.values()].filter((doc) => matchesFilter(doc, group)).map((doc) => clone(doc)), options);
+    const batchSize = typeof options?.batchSize === "number" && Number.isSafeInteger(options.batchSize) && options.batchSize > 0 ? options.batchSize : 1;
+    for (let start = 0; start < rows.length; start += batchSize) {
+      for (const row of rows.slice(start, start + batchSize)) {
+        yield row;
+      }
+    }
+  }
+  async updateMany(schema, config, group, data) {
+    const store = this.#resolveStore(schema, config);
+    const ids = [...store.entries()].filter(([, doc]) => matchesFilter(doc, group)).map(([id]) => id);
+    const updated = [];
+    for (const id of ids) {
+      const current = store.get(id);
+      if (!current) continue;
+      const next = applyUpdateData(current, data);
+      store.set(id, next);
+      updated.push(clone(next));
+    }
+    return updated;
+  }
+  async deleteMany(schema, config, filter) {
+    const store = this.#resolveStore(schema, config);
+    const pk = schema.pkField.name;
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, filter)).map((doc) => clone(doc));
+    for (const row of rows) store.delete(String(row[pk]));
+    return rows;
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const store = this.#resolveStore(schema, config);
+    const pk = schema.pkField.name;
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, filter));
+    const current = rows[0];
+    if (current) {
+      const next = ops.length > 0 ? applyOps(current, ops) : clone(current);
+      store.set(String(next[pk]), next);
+      return clone(next);
+    }
+    const base = clone(create);
+    const result = ops.length > 0 ? applyOps(base, ops) : base;
+    store.set(String(result[pk]), result);
+    return clone(result);
+  }
+  async aggregate(schema, config, spec) {
+    const store = this.#resolveStore(schema, config);
+    let rows = [...store.values()];
+    if (spec.where) {
+      const where = spec.where;
+      rows = rows.filter((doc) => matchesFilter(doc, where));
+    }
+    const groups = /* @__PURE__ */ new Map();
+    if (spec.groupBy.length > 0) {
+      for (const row of rows) {
+        const key = JSON.stringify(spec.groupBy.map((f) => row[f]));
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(row);
+      }
+    } else {
+      groups.set("__all__", rows);
+    }
+    const results = [];
+    for (const [, groupRows] of groups) {
+      const result = {};
+      if (spec.groupBy.length > 0) {
+        for (const field of spec.groupBy) {
+          result[field] = groupRows[0][field];
+        }
+      }
+      for (const agg of spec.aggregates) {
+        switch (agg.fn) {
+          case "count":
+            result[agg.alias] = groupRows.length;
+            break;
+          case "countDistinct": {
+            const vals = new Set(groupRows.map((r) => JSON.stringify(r[agg.field])));
+            result[agg.alias] = vals.size;
+            break;
+          }
+          case "sum":
+            result[agg.alias] = groupRows.reduce((acc, r) => acc + Number(r[agg.field] ?? 0), 0);
+            break;
+          case "avg": {
+            const sum = groupRows.reduce((acc, r) => acc + Number(r[agg.field] ?? 0), 0);
+            result[agg.alias] = groupRows.length > 0 ? sum / groupRows.length : 0;
+            break;
+          }
+          case "min": {
+            let minVal = null;
+            for (const r of groupRows) {
+              const val = r[agg.field];
+              if (val != null && (minVal === null || compareValues(val, minVal) < 0)) minVal = val;
+            }
+            result[agg.alias] = minVal;
+            break;
+          }
+          case "max": {
+            let maxVal = null;
+            for (const r of groupRows) {
+              const val = r[agg.field];
+              if (val != null && (maxVal === null || compareValues(val, maxVal) > 0)) maxVal = val;
+            }
+            result[agg.alias] = maxVal;
+            break;
+          }
+        }
+      }
+      results.push(result);
+    }
+    if (spec.having) {
+      const having = spec.having;
+      return results.filter((r) => matchesFilter(r, having));
+    }
+    return results;
+  }
+  async loadMigrations() {
+    return [...this.migrations.values()].map((m) => ({ id: m.id, appliedAt: m.appliedAt }));
+  }
+  async recordMigration(id, appliedAt) {
+    this.migrations.set(id, { id, appliedAt });
+  }
+  async applyCreateTable(change) {
+    const fields = /* @__PURE__ */ new Map();
+    for (const f of change.fields) {
+      fields.set(f.name, { ...f });
+    }
+    this.tables.set(change.name, { pk: { name: change.pk.name, type: change.pk.type }, fields });
+  }
+  async applyDropTable(change) {
+    this.tables.delete(change.name);
+  }
+  async applyAddField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.set(change.field.name, { ...change.field });
+    }
+  }
+  async applyDropField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.delete(change.name);
+    }
+  }
+  async applyModifyField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.delete(change.name);
+      table.fields.set(change.to.name, { ...change.to });
+    }
+  }
+  async applyRenameTable(change) {
+    const table = this.tables.get(change.from);
+    if (table) {
+      this.tables.delete(change.from);
+      this.tables.set(change.to, table);
+    }
+  }
+  async applyRenameField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      const field = table.fields.get(change.from);
+      if (field) {
+        table.fields.delete(change.from);
+        table.fields.set(change.to, { ...field, name: change.to });
+      }
+    }
+  }
+  async applyAddIndex(change) {
+    const indexName = change.name ?? `${change.table}_${change.on.join("_")}_idx`;
+    this.indexes.set(indexName, { table: change.table, on: change.on, unique: change.unique ?? false });
+  }
+  async applyDropIndex(change) {
+    this.indexes.delete(change.name);
+  }
+  async applyAddForeignKey(change) {
+    const fkName = change.name ?? `${change.table}_${change.on}_fk`;
+    this.foreignKeys.set(fkName, {
+      table: change.table,
+      on: change.on,
+      references: { table: change.references.table, column: change.references.column },
+      onDelete: change.onDelete,
+      onUpdate: change.onUpdate
+    });
+  }
+  async applyDropForeignKey(change) {
+    this.foreignKeys.delete(change.name);
+  }
+  async introspect() {
+    const schemas = [];
+    for (const [name, meta] of this.tables.entries()) {
+      const fields = [...meta.fields.values()].map((f) => ({
+        name: f.name,
+        type: f.type,
+        nullable: f.nullable ?? false,
+        ...f.default !== void 0 ? { default: f.default } : {},
+        ...f.unique ? { unique: true } : {}
+      }));
+      const indexes = [...this.indexes.entries()].filter(([, idx]) => idx.table === name).map(([idxName, idx]) => ({ name: idxName, on: idx.on, unique: idx.unique }));
+      const foreignKeys = [...this.foreignKeys.entries()].filter(([, fk]) => fk.table === name).map(([fkName, fk]) => ({
+        name: fkName,
+        on: fk.on,
+        references: { table: fk.references.table, column: fk.references.column },
+        ...fk.onDelete ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate ? { onUpdate: fk.onUpdate } : {}
+      }));
+      schemas.push({
+        name,
+        pk: { name: meta.pk.name, type: meta.pk.type },
+        fields,
+        indexes,
+        foreignKeys
+      });
+    }
+    return schemas;
+  }
+  async acquireMigrationLock(fn) {
+    let release;
+    const next = new Promise((r) => {
+      release = r;
+    });
+    const prev = this.#migrationLock;
+    this.#migrationLock = next;
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  async session(fn) {
+    if (sessionActiveStore.getStore()) return fn();
+    const snap = this.#snapshot();
+    try {
+      return await sessionActiveStore.run(true, fn);
+    } catch (error) {
+      this.#restore(snap);
+      throw error;
+    }
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { FilterGroup: FilterGroup2 } = await null;
+  const { OrderBy } = await null;
+  const { Schema } = await null;
+  const { IncOp: IncOp2, PatchOp: PatchOp2, PullOp: PullOp2, PushOp: PushOp2 } = await null;
+  const { v: v2 } = await null;
+  describe("in-memory adapter", () => {
+    test("InMemoryAdapter.create({}) produces a working adapter", () => {
+      const adapter = InMemoryAdapter.create({});
+      expect(adapter).toBeInstanceOf(InMemoryAdapter);
+      expect(adapter.schemaConfigPipe).toBeDefined();
+      expect(adapter.supportedFieldTypes).toEqual(["string", "number", "boolean", "null", "object", "array", "date"]);
+    });
+    test("supports nested filters, ordering, select, offset and limit", async () => {
+      const schema = Schema.from("users").pk("id", v2.string(), () => "u").field("name", v2.string()).field("age", v2.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 }
+      ]);
+      const builtGroup = FilterGroup2.create().and([
+        (q) => q.gt("age", 19),
+        (q) => q.or([(g) => g.eq("name", "Alice"), (g) => g.eq("name", "Carol")])
+      ]);
+      const options = { orderBy: [new OrderBy("age", "desc")], offset: 1, limit: 1, select: ["id", "name"] };
+      const rows = await use.findMany(builtGroup, options);
+      expect(rows).toEqual([{ id: "u1", name: "Alice" }]);
+    });
+    test("count returns the number of matching rows without query options", async () => {
+      const schema = Schema.from("count_users").pk("id", v2.string(), () => "u").field("name", v2.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "count_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" },
+        { id: "u3", name: "Alice" }
+      ]);
+      await expect(use.count(FilterGroup2.create().eq("name", "Alice"))).resolves.toBe(2);
+    });
+    test("iterateMany with batchSize matches findMany filtering ordering offset limit and selection", async () => {
+      const schema = Schema.from("iter_users").pk("id", v2.string(), () => "u").field("name", v2.string()).field("age", v2.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "iter_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 },
+        { id: "u4", name: "Dan", age: 50 }
+      ]);
+      const filter = FilterGroup2.create().gt("age", 19);
+      const options = {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        select: ["id", "name"]
+      };
+      const expected = await use.findMany(filter, options);
+      const rows = [];
+      for await (const row of use.iterateMany(filter, { ...options, batchSize: 2 })) {
+        rows.push(row);
+      }
+      expect(rows).toEqual(expected);
+      expect(rows).toEqual([
+        { id: "u3", name: "Carol" },
+        { id: "u1", name: "Alice" }
+      ]);
+    });
+    test("supports update operators and rollback on failed session", async () => {
+      const schema = Schema.from("docs").pk("id", v2.string(), () => "d1").field("count", v2.number()).field("tags", v2.array(v2.string())).field("meta", v2.object({ a: v2.number() })).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "docs" });
+      await use.createOne({ id: "d1", count: 1, tags: ["x"], meta: { a: 1 } });
+      await adapter.session(async () => {
+        await use.updateOne(FilterGroup2.create().eq("id", "d1"), {
+          count: new IncOp2("count", 2),
+          tags: new PushOp2("tags", "y"),
+          meta: new PatchOp2("meta", { a: 9 })
+        });
+      });
+      await expect(
+        adapter.session(async () => {
+          await use.updateOne(FilterGroup2.create().eq("id", "d1"), { tags: new PullOp2("tags", "x") });
+          throw new Error("boom");
+        })
+      ).rejects.toThrow("boom");
+      const row = await use.findOne(FilterGroup2.create().eq("id", "d1"));
+      expect(row).toEqual({ id: "d1", count: 3, tags: ["x", "y"], meta: { a: 9 } });
+    });
+    test("notIn filter excludes matching values", async () => {
+      const schema = Schema.from("users").pk("id", v2.string(), () => "u").field("name", v2.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "users" });
+      await use.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" },
+        { id: "u3", name: "Carol" }
+      ]);
+      const rows = await use.findMany(FilterGroup2.create().notIn("name", ["Alice", "Carol"]));
+      expect(rows).toHaveLength(1);
+      expect(rows[0].name).toBe("Bob");
+    });
+    test("exists / notExists filter ops work correctly", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => "i").field("val", v2.optional(v2.string()), { onCreate: () => void 0 }).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", val: "present" },
+        { id: "i2", val: null },
+        { id: "i3", val: void 0 }
+      ]);
+      const existsRows = await use.findMany(FilterGroup2.create().exists("val"));
+      expect(existsRows).toHaveLength(1);
+      expect(existsRows[0].id).toBe("i1");
+      const notExistsRows = await use.findMany(FilterGroup2.create().notExists("val"));
+      expect(notExistsRows).toHaveLength(2);
+    });
+    test("findByPk returns seeded document and null for missing", async () => {
+      const schema = Schema.from("test").pk("id", v2.string(), () => "gen").build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "test" });
+      await use.createOne({ id: "x" });
+      const found = await adapter.findByPk(schema, { table: "test" }, "x");
+      expect(found).toEqual({ id: "x" });
+      const missing = await adapter.findByPk(schema, { table: "test" }, "missing");
+      expect(missing).toBeNull();
+    });
+    test("auto-wired Instance hooks register correctly keyed by class", async () => {
+      const { Instance: Inst } = await null;
+      const onSpy = (await null).vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      InMemoryAdapter.create({});
+      expect(onSpy).not.toHaveBeenCalled();
+      onSpy.mockRestore();
+    });
+    test("declares aggregateOps with all six canonical ops", () => {
+      const adapter = InMemoryAdapter.create({});
+      expect(adapter.aggregateOps).toEqual(["count", "countDistinct", "sum", "avg", "min", "max"]);
+    });
+    test("aggregate count returns correct total", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => `i-${Math.random().toString(36).slice(2, 8)}`).field("category", v2.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 3 }]);
+    });
+    test("aggregate count with where filter", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => `i-${Math.random().toString(36).slice(2, 8)}`).field("category", v2.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: [],
+        where: FilterGroup2.create().eq("category", "A")
+      });
+      expect(result).toEqual([{ total: 2 }]);
+    });
+    test("aggregate count on empty store returns zero", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => "x").build();
+      const adapter = InMemoryAdapter.create({});
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 0 }]);
+    });
+    test("aggregate sum/avg/min/max compute correctly", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => "x").field("price", v2.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", price: 10 },
+        { id: "i2", price: 20 },
+        { id: "i3", price: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [
+          { fn: "sum", field: "price", alias: "total" },
+          { fn: "avg", field: "price", alias: "avg" },
+          { fn: "min", field: "price", alias: "low" },
+          { fn: "max", field: "price", alias: "high" }
+        ],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 60, avg: 20, low: 10, high: 30 }]);
+    });
+    test("aggregate countDistinct counts unique values", async () => {
+      const schema = Schema.from("items").pk("id", v2.string(), () => "x").field("category", v2.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "countDistinct", field: "category", alias: "unique" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ unique: 2 }]);
+    });
+    test("aggregate groupBy produces per-group results", async () => {
+      const schema = Schema.from("orders").pk("id", v2.string(), () => "x").field("region", v2.string()).field("amount", v2.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "orders" });
+      await use.createMany([
+        { id: "o1", region: "US", amount: 10 },
+        { id: "o2", region: "EU", amount: 20 },
+        { id: "o3", region: "US", amount: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "cnt" },
+          { fn: "sum", field: "amount", alias: "total" }
+        ],
+        groupBy: ["region"]
+      });
+      expect(result).toHaveLength(2);
+      const us = result.find((r) => r.region === "US");
+      const eu = result.find((r) => r.region === "EU");
+      expect(us).toEqual({ region: "US", cnt: 2, total: 40 });
+      expect(eu).toEqual({ region: "EU", cnt: 1, total: 20 });
+    });
+    test("aggregate having filters post-aggregation", async () => {
+      const schema = Schema.from("orders").pk("id", v2.string(), () => "x").field("region", v2.string()).field("amount", v2.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "orders" });
+      await use.createMany([
+        { id: "o1", region: "US", amount: 10 },
+        { id: "o2", region: "EU", amount: 20 },
+        { id: "o3", region: "US", amount: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "sum", field: "amount", alias: "total" }],
+        groupBy: ["region"],
+        having: FilterGroup2.create().gt("total", 25)
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ region: "US", total: 40 });
+    });
+  });
+}
+
+export {
+  InMemoryAdapter
+};
+//# sourceMappingURL=chunk-6SB5M4XH.mjs.map