equipped 5.2.9 → 5.3.0-alpha.0

package/dist/esm/orm/adapters/mongodb/index.mjs

@@ -0,0 +1,1539 @@
+import {
+  Filter,
+  FilterGroup,
+  IncOp,
+  MaxOp,
+  MinOp,
+  MulOp,
+  OrmAdapter,
+  PatchOp,
+  PullOp,
+  PushOp,
+  UnsetOp,
+  flattenOps
+} from "../../../chunk-TWKHVLLT.mjs";
+import {
+  EquippedError,
+  configurable
+} from "../../../chunk-2TCFNKRZ.mjs";
+import "../../../chunk-VCCS7CAI.mjs";
+import "../../../chunk-J5LGTIGS.mjs";
+
+// src/orm/adapters/mongodb/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { MongoClient } from "mongodb";
+import { v } from "valleyed";
+
+// src/orm/adapters/mongodb/query.ts
+function compileMongoFilter(group, primaryKey) {
+  const clauses = [];
+  for (const child of group.children) {
+    const compiled = compileChild(child, primaryKey);
+    if (compiled) clauses.push(compiled);
+  }
+  if (clauses.length === 0) return {};
+  if (clauses.length === 1) return clauses[0];
+  return { $and: clauses };
+}
+function compileMongoQuery(group, options, primaryKey) {
+  const mongoFilter = compileMongoFilter(group, primaryKey);
+  const orderBys = options?.orderBy ?? [];
+  const sort = orderBys.length > 0 ? Object.fromEntries(orderBys.map((o) => [mapField(o.field, primaryKey), o.direction === "desc" ? -1 : 1])) : void 0;
+  const selects = options?.select ?? [];
+  const projection = selects.length > 0 ? Object.fromEntries(selects.map((f) => [mapField(f, primaryKey), 1])) : void 0;
+  return {
+    filter: mongoFilter,
+    sort,
+    limit: options?.limit,
+    skip: options?.offset,
+    projection
+  };
+}
+function mapField(field, primaryKey) {
+  if (field === "id" && primaryKey === "_id") return "_id";
+  return field;
+}
+function compileFilter(f, primaryKey) {
+  const field = mapField(f.field, primaryKey);
+  switch (f.op) {
+    case "eq":
+      return { [field]: { $eq: f.value } };
+    case "ne":
+      return { [field]: { $ne: f.value } };
+    case "gt":
+      return { [field]: { $gt: f.value } };
+    case "gte":
+      return { [field]: { $gte: f.value } };
+    case "lt":
+      return { [field]: { $lt: f.value } };
+    case "lte":
+      return { [field]: { $lte: f.value } };
+    case "in":
+      return { [field]: { $in: f.value } };
+    case "notIn":
+      return { [field]: { $nin: f.value } };
+    case "like":
+      return { [field]: { $regex: new RegExp(String(f.value), "i") } };
+    case "exists":
+      return { [field]: { $exists: true, $ne: null } };
+    case "notExists":
+      return { [field]: { $eq: null } };
+    case "contains":
+      return { [field]: { $all: Array.isArray(f.value) ? f.value : [f.value] } };
+    case "notContains":
+      return { [field]: { $not: { $all: Array.isArray(f.value) ? f.value : [f.value] } } };
+    default:
+      return { [field]: { $eq: f.value } };
+  }
+}
+function compileChild(child, primaryKey) {
+  if (child instanceof Filter) return compileFilter(child, primaryKey);
+  if (child instanceof FilterGroup) return compileGroup(child, primaryKey);
+  return null;
+}
+function compileGroup(group, primaryKey) {
+  const clauses = group.children.map((c) => compileChild(c, primaryKey)).filter((c) => c !== null);
+  if (clauses.length === 0) return null;
+  if (clauses.length === 1) return clauses[0];
+  return { [group.op === "or" ? "$or" : "$and"]: clauses };
+}
+function compileMongoUpdate(data) {
+  const $set = {};
+  const $inc = {};
+  const $mul = {};
+  const $min = {};
+  const $max = {};
+  const $unset = {};
+  const $push = {};
+  const $pull = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value instanceof IncOp) $inc[key] = value.value;
+    else if (value instanceof MulOp) $mul[key] = value.value;
+    else if (value instanceof MinOp) $min[key] = value.value;
+    else if (value instanceof MaxOp) $max[key] = value.value;
+    else if (value instanceof UnsetOp) $unset[key] = "";
+    else if (value instanceof PushOp) $push[key] = value.value;
+    else if (value instanceof PullOp) $pull[key] = value.value;
+    else if (value instanceof PatchOp) {
+      const patchVal = value.value;
+      for (const [subKey, subVal] of Object.entries(patchVal)) {
+        $set[`${key}.${subKey}`] = subVal;
+      }
+    } else $set[key] = value;
+  }
+  const result = {};
+  if (Object.keys($set).length) result.$set = $set;
+  if (Object.keys($inc).length) result.$inc = $inc;
+  if (Object.keys($mul).length) result.$mul = $mul;
+  if (Object.keys($min).length) result.$min = $min;
+  if (Object.keys($max).length) result.$max = $max;
+  if (Object.keys($unset).length) result.$unset = $unset;
+  if (Object.keys($push).length) result.$push = $push;
+  if (Object.keys($pull).length) result.$pull = $pull;
+  return result;
+}
+function compileMongoOps(ops) {
+  return compileMongoUpdate(flattenOps(ops));
+}
+function compileMongoAggregate(spec, primaryKey) {
+  const pipeline = [];
+  if (spec.where) {
+    const match = compileMongoFilter(spec.where, primaryKey);
+    if (Object.keys(match).length > 0) pipeline.push({ $match: match });
+  }
+  const groupId = spec.groupBy.length > 0 ? Object.fromEntries(spec.groupBy.map((f) => [f, `$${mapField(f, primaryKey)}`])) : null;
+  const accumulators = {};
+  for (const agg of spec.aggregates) {
+    const fieldRef = agg.field ? `$${mapField(agg.field, primaryKey)}` : void 0;
+    switch (agg.fn) {
+      case "count":
+        accumulators[agg.alias] = { $sum: 1 };
+        break;
+      case "countDistinct":
+        accumulators[agg.alias] = { $addToSet: fieldRef };
+        break;
+      case "sum":
+      case "avg":
+      case "min":
+      case "max":
+        accumulators[agg.alias] = { [`$${agg.fn}`]: fieldRef };
+        break;
+    }
+  }
+  pipeline.push({ $group: { _id: groupId, ...accumulators } });
+  const project = { _id: 0 };
+  for (const f of spec.groupBy) {
+    project[f] = `$_id.${f}`;
+  }
+  for (const agg of spec.aggregates) {
+    if (agg.fn === "countDistinct") {
+      project[agg.alias] = { $size: `$${agg.alias}` };
+    } else {
+      project[agg.alias] = 1;
+    }
+  }
+  pipeline.push({ $project: project });
+  if (spec.having) {
+    const havingMatch = compileMongoFilter(spec.having, "");
+    if (Object.keys(havingMatch).length > 0) pipeline.push({ $match: havingMatch });
+  }
+  return pipeline;
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { FilterGroup: FilterGroup2 } = await null;
+  const { OrderBy } = await null;
+  describe("compileMongoFilter", () => {
+    test("empty filter group compiles to empty object", () => {
+      const group = FilterGroup2.create();
+      expect(compileMongoFilter(group, "id")).toEqual({});
+    });
+    test("single eq filter compiles to $eq", () => {
+      const group = FilterGroup2.create().eq("name", "Alice");
+      expect(compileMongoFilter(group, "id")).toEqual({ name: { $eq: "Alice" } });
+    });
+    test("ne, gt, gte, lt, lte compile to corresponding Mongo ops", () => {
+      expect(compileMongoFilter(FilterGroup2.create().ne("age", 5), "id")).toEqual({ age: { $ne: 5 } });
+      expect(compileMongoFilter(FilterGroup2.create().gt("age", 10), "id")).toEqual({ age: { $gt: 10 } });
+      expect(compileMongoFilter(FilterGroup2.create().gte("age", 20), "id")).toEqual({ age: { $gte: 20 } });
+      expect(compileMongoFilter(FilterGroup2.create().lt("age", 30), "id")).toEqual({ age: { $lt: 30 } });
+      expect(compileMongoFilter(FilterGroup2.create().lte("age", 40), "id")).toEqual({ age: { $lte: 40 } });
+    });
+    test("in compiles to $in", () => {
+      const group = FilterGroup2.create().in("status", ["a", "b"]);
+      expect(compileMongoFilter(group, "id")).toEqual({ status: { $in: ["a", "b"] } });
+    });
+    test("notIn compiles to $nin (canonical name notIn, Mongo op $nin)", () => {
+      const group = FilterGroup2.create().notIn("status", ["x", "y"]);
+      expect(compileMongoFilter(group, "id")).toEqual({ status: { $nin: ["x", "y"] } });
+    });
+    test("like compiles to $regex with case-insensitive flag", () => {
+      const group = FilterGroup2.create().like("name", "ali");
+      const result = compileMongoFilter(group, "id");
+      expect(result.name).toEqual({ $regex: expect.any(RegExp) });
+      const regex = result.name.$regex;
+      expect(regex.flags).toBe("i");
+      expect(regex.test("Alice")).toBe(true);
+    });
+    test("exists compiles to $exists: true, $ne: null", () => {
+      const group = FilterGroup2.create().exists("val");
+      expect(compileMongoFilter(group, "id")).toEqual({ val: { $exists: true, $ne: null } });
+    });
+    test("notExists is its own op \u2014 compiles to $eq: null", () => {
+      const group = FilterGroup2.create().notExists("val");
+      expect(compileMongoFilter(group, "id")).toEqual({ val: { $eq: null } });
+    });
+    test("contains compiles to $all", () => {
+      const group = FilterGroup2.create().contains("tags", ["a", "b"]);
+      expect(compileMongoFilter(group, "id")).toEqual({ tags: { $all: ["a", "b"] } });
+    });
+    test("notContains compiles to $not: { $all }", () => {
+      const group = FilterGroup2.create().notContains("tags", ["x"]);
+      expect(compileMongoFilter(group, "id")).toEqual({ tags: { $not: { $all: ["x"] } } });
+    });
+    test("multiple clauses produce $and", () => {
+      const group = FilterGroup2.create().eq("a", 1).gt("b", 2);
+      const result = compileMongoFilter(group, "id");
+      expect(result).toEqual({ $and: [{ a: { $eq: 1 } }, { b: { $gt: 2 } }] });
+    });
+    test("nested and/or groups compile correctly", () => {
+      const group = FilterGroup2.create().and([
+        (q) => q.eq("a", 1),
+        (q) => q.or([(g) => g.eq("b", 2), (g) => g.eq("c", 3)])
+      ]);
+      const result = compileMongoFilter(group, "id");
+      expect(result).toEqual({
+        $and: [{ a: { $eq: 1 } }, { $or: [{ b: { $eq: 2 } }, { c: { $eq: 3 } }] }]
+      });
+    });
+    test("maps id field to _id when primaryKey is _id", () => {
+      const group = FilterGroup2.create().eq("id", "abc");
+      expect(compileMongoFilter(group, "_id")).toEqual({ _id: { $eq: "abc" } });
+    });
+  });
+  describe("compileMongoQuery", () => {
+    test("options: sort, limit, skip, projection", () => {
+      const group = FilterGroup2.create().eq("active", true);
+      const options = {
+        orderBy: [new OrderBy("name", "asc"), new OrderBy("age", "desc")],
+        limit: 10,
+        offset: 5,
+        select: ["name", "age"]
+      };
+      const result = compileMongoQuery(group, options, "id");
+      expect(result.filter).toEqual({ active: { $eq: true } });
+      expect(result.sort).toEqual({ name: 1, age: -1 });
+      expect(result.limit).toBe(10);
+      expect(result.skip).toBe(5);
+      expect(result.projection).toEqual({ name: 1, age: 1 });
+    });
+    test("undefined options returns undefined for sort/limit/skip/projection", () => {
+      const group = FilterGroup2.create().eq("x", 1);
+      const result = compileMongoQuery(group, void 0, "id");
+      expect(result.sort).toBeUndefined();
+      expect(result.limit).toBeUndefined();
+      expect(result.skip).toBeUndefined();
+      expect(result.projection).toBeUndefined();
+    });
+  });
+  describe("compileMongoUpdate", () => {
+    test("plain values go into $set", () => {
+      const result = compileMongoUpdate({ name: "Alice", age: 30 });
+      expect(result).toEqual({ $set: { name: "Alice", age: 30 } });
+    });
+    test("IncOp goes into $inc", () => {
+      const result = compileMongoUpdate({ count: new IncOp("count", 5) });
+      expect(result).toEqual({ $inc: { count: 5 } });
+    });
+    test("MulOp goes into $mul", () => {
+      const result = compileMongoUpdate({ score: new MulOp("score", 2) });
+      expect(result).toEqual({ $mul: { score: 2 } });
+    });
+    test("MinOp/MaxOp go into $min/$max", () => {
+      const result = compileMongoUpdate({
+        lo: new MinOp("lo", 1),
+        hi: new MaxOp("hi", 99)
+      });
+      expect(result).toEqual({ $min: { lo: 1 }, $max: { hi: 99 } });
+    });
+    test("UnsetOp goes into $unset", () => {
+      const result = compileMongoUpdate({ old: new UnsetOp("old") });
+      expect(result).toEqual({ $unset: { old: "" } });
+    });
+    test("PushOp/PullOp go into $push/$pull", () => {
+      const result = compileMongoUpdate({
+        tags: new PushOp("tags", "new"),
+        removed: new PullOp("removed", "old")
+      });
+      expect(result).toEqual({ $push: { tags: "new" }, $pull: { removed: "old" } });
+    });
+    test("PatchOp produces dot-notation $set entries", () => {
+      const result = compileMongoUpdate({ meta: new PatchOp("meta", { a: 1, b: 2 }) });
+      expect(result).toEqual({ $set: { "meta.a": 1, "meta.b": 2 } });
+    });
+    test("empty data produces empty result", () => {
+      const result = compileMongoUpdate({});
+      expect(result).toEqual({});
+    });
+  });
+  describe("compileMongoOps", () => {
+    test("SetOp values go into $set", () => {
+      const result = compileMongoOps([new SetOp({ name: "Bob", age: 25 })]);
+      expect(result).toEqual({ $set: { name: "Bob", age: 25 } });
+    });
+    test("mixed ops compile to separate Mongo update operators", () => {
+      const result = compileMongoOps([
+        new SetOp({ name: "Alice" }),
+        new IncOp("count", 1),
+        new PushOp("tags", "x")
+      ]);
+      expect(result).toEqual({
+        $set: { name: "Alice" },
+        $inc: { count: 1 },
+        $push: { tags: "x" }
+      });
+    });
+    test("empty ops produces empty result", () => {
+      expect(compileMongoOps([])).toEqual({});
+    });
+  });
+  describe("compileMongoAggregate", () => {
+    test("bare count produces $group with $sum:1 and $project", () => {
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $group: { _id: null, total: { $sum: 1 } } },
+        { $project: { _id: 0, total: 1 } }
+      ]);
+    });
+    test("multi-aggregator produces all accumulators in $group", () => {
+      const spec = {
+        aggregates: [
+          { fn: "count", alias: "total" },
+          { fn: "sum", field: "amount", alias: "revenue" },
+          { fn: "avg", field: "price", alias: "avgPrice" }
+        ],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        {
+          $group: {
+            _id: null,
+            total: { $sum: 1 },
+            revenue: { $sum: "$amount" },
+            avgPrice: { $avg: "$price" }
+          }
+        },
+        { $project: { _id: 0, total: 1, revenue: 1, avgPrice: 1 } }
+      ]);
+    });
+    test("single-column groupBy produces composite _id and $project lift", () => {
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["region"]
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $group: { _id: { region: "$region" }, total: { $sum: 1 } } },
+        { $project: { _id: 0, region: "$_id.region", total: 1 } }
+      ]);
+    });
+    test("multi-column groupBy via composite _id", () => {
+      const spec = {
+        aggregates: [{ fn: "sum", field: "amount", alias: "revenue" }],
+        groupBy: ["region", "year"]
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        {
+          $group: {
+            _id: { region: "$region", year: "$year" },
+            revenue: { $sum: "$amount" }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            region: "$_id.region",
+            year: "$_id.year",
+            revenue: 1
+          }
+        }
+      ]);
+    });
+    test("where-only emits $match before $group", () => {
+      const spec = {
+        where: FilterGroup2.create().eq("active", true),
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $match: { active: { $eq: true } } },
+        { $group: { _id: null, total: { $sum: 1 } } },
+        { $project: { _id: 0, total: 1 } }
+      ]);
+    });
+    test("having-only emits $match after $project", () => {
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["region"],
+        having: FilterGroup2.create().gt("total", 5)
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $group: { _id: { region: "$region" }, total: { $sum: 1 } } },
+        { $project: { _id: 0, region: "$_id.region", total: 1 } },
+        { $match: { total: { $gt: 5 } } }
+      ]);
+    });
+    test("where + having produces both $match stages", () => {
+      const spec = {
+        where: FilterGroup2.create().eq("active", true),
+        aggregates: [{ fn: "sum", field: "amount", alias: "revenue" }],
+        groupBy: ["region"],
+        having: FilterGroup2.create().gte("revenue", 1e3)
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $match: { active: { $eq: true } } },
+        {
+          $group: {
+            _id: { region: "$region" },
+            revenue: { $sum: "$amount" }
+          }
+        },
+        { $project: { _id: 0, region: "$_id.region", revenue: 1 } },
+        { $match: { revenue: { $gte: 1e3 } } }
+      ]);
+    });
+    test("countDistinct uses $addToSet in $group and $size in $project", () => {
+      const spec = {
+        aggregates: [{ fn: "countDistinct", field: "userId", alias: "uniqueUsers" }],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $group: { _id: null, uniqueUsers: { $addToSet: "$userId" } } },
+        { $project: { _id: 0, uniqueUsers: { $size: "$uniqueUsers" } } }
+      ]);
+    });
+    test("min/max produce $min/$max accumulators", () => {
+      const spec = {
+        aggregates: [
+          { fn: "min", field: "price", alias: "lowest" },
+          { fn: "max", field: "price", alias: "highest" }
+        ],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        {
+          $group: {
+            _id: null,
+            lowest: { $min: "$price" },
+            highest: { $max: "$price" }
+          }
+        },
+        { $project: { _id: 0, lowest: 1, highest: 1 } }
+      ]);
+    });
+    test("field-name mapping: id field maps to _id when primaryKey is _id", () => {
+      const spec = {
+        where: FilterGroup2.create().eq("id", "abc"),
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["id"]
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $match: { _id: { $eq: "abc" } } },
+        { $group: { _id: { id: "$_id" }, total: { $sum: 1 } } },
+        { $project: { _id: 0, id: "$_id.id", total: 1 } }
+      ]);
+    });
+    test("countDistinct with groupBy combines $addToSet, groupBy lift, and $size", () => {
+      const spec = {
+        aggregates: [{ fn: "countDistinct", field: "category", alias: "uniqueCats" }],
+        groupBy: ["region"]
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        {
+          $group: {
+            _id: { region: "$region" },
+            uniqueCats: { $addToSet: "$category" }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            region: "$_id.region",
+            uniqueCats: { $size: "$uniqueCats" }
+          }
+        }
+      ]);
+    });
+    test("all six aggregators in a single pipeline", () => {
+      const spec = {
+        aggregates: [
+          { fn: "count", alias: "total" },
+          { fn: "countDistinct", field: "status", alias: "uniqueStatuses" },
+          { fn: "sum", field: "amount", alias: "totalAmount" },
+          { fn: "avg", field: "amount", alias: "avgAmount" },
+          { fn: "min", field: "amount", alias: "minAmount" },
+          { fn: "max", field: "amount", alias: "maxAmount" }
+        ],
+        groupBy: ["region"]
+      };
+      const pipeline = compileMongoAggregate(spec, "_id");
+      expect(pipeline).toEqual([
+        {
+          $group: {
+            _id: { region: "$region" },
+            total: { $sum: 1 },
+            uniqueStatuses: { $addToSet: "$status" },
+            totalAmount: { $sum: "$amount" },
+            avgAmount: { $avg: "$amount" },
+            minAmount: { $min: "$amount" },
+            maxAmount: { $max: "$amount" }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            region: "$_id.region",
+            total: 1,
+            uniqueStatuses: { $size: "$uniqueStatuses" },
+            totalAmount: 1,
+            avgAmount: 1,
+            minAmount: 1,
+            maxAmount: 1
+          }
+        }
+      ]);
+    });
+    test("empty where filter is omitted from pipeline", () => {
+      const spec = {
+        where: FilterGroup2.create(),
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      };
+      expect(compileMongoAggregate(spec, "_id")).toEqual([
+        { $group: { _id: null, total: { $sum: 1 } } },
+        { $project: { _id: 0, total: 1 } }
+      ]);
+    });
+  });
+}
+
+// src/orm/adapters/mongodb/index.ts
+var mongoSchemaConfigPipe = () => v.object({ db: v.string(), col: v.string() });
+var mongoConnectionPipe = () => v.object({
+  uri: v.string()
+});
+var MIGRATION_TRACKER_COLLECTION = "equipped_migrations";
+var MongoDbAdapter = class extends configurable(mongoConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = mongoSchemaConfigPipe();
+  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"];
+  supportedFieldTypes = ["string", "number", "boolean", "null", "object", "array", "date"];
+  client;
+  #sessionStore = new AsyncLocalStorage();
+  constructor(config, options) {
+    super(config);
+    this.client = new MongoClient(config.uri, {
+      ...options,
+      ignoreUndefined: true
+    });
+  }
+  #getCollection(schemaCfg) {
+    return this.client.db(schemaCfg.db).collection(schemaCfg.col);
+  }
+  async connect() {
+    try {
+      await this.client.connect();
+    } catch (error) {
+      throw new EquippedError("Failed to connect MongoDB client", { adapter: "mongodb" }, error);
+    }
+  }
+  async disconnect() {
+    try {
+      await this.client.close();
+    } catch (error) {
+      throw new EquippedError("Failed to disconnect MongoDB client", { adapter: "mongodb" }, error);
+    }
+  }
+  async findByPk(schema, config, pk) {
+    const schemaCfg = config;
+    try {
+      const pkName = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const doc = await collection.findOne(
+        { [pkName]: pk },
+        { session: this.#sessionStore.getStore() }
+      );
+      return doc;
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB findByPk failed",
+        { adapter: "mongodb", operation: "findByPk", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async createMany(_schema, config, data) {
+    const schemaCfg = config;
+    try {
+      const collection = this.#getCollection(schemaCfg);
+      const docs = data.map((d) => d);
+      await collection.insertMany(docs, { session: this.#sessionStore.getStore() });
+      return data;
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB createMany failed",
+        { adapter: "mongodb", operation: "createMany", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const schemaCfg = config;
+    try {
+      const pkName = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const update = compileMongoOps(ops);
+      if (Object.keys(update).length === 0) {
+        return await collection.findOne({ [pkName]: pk }, { session: this.#sessionStore.getStore() });
+      }
+      return await collection.findOneAndUpdate(
+        { [pkName]: pk },
+        update,
+        { returnDocument: "after", session: this.#sessionStore.getStore() }
+      );
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB updateByPk failed",
+        { adapter: "mongodb", operation: "updateByPk", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async deleteByPk(schema, config, pk) {
+    const schemaCfg = config;
+    try {
+      const pkName = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      return await collection.findOneAndDelete(
+        { [pkName]: pk },
+        { session: this.#sessionStore.getStore() }
+      );
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB deleteByPk failed",
+        { adapter: "mongodb", operation: "deleteByPk", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async raw(_schema, config, pipeline) {
+    const schemaCfg = config;
+    try {
+      const collection = this.#getCollection(schemaCfg);
+      const result = await collection.aggregate(pipeline, { session: this.#sessionStore.getStore() }).toArray();
+      return result;
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError(
+        "MongoDB raw failed",
+        { adapter: "mongodb", operation: "raw", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async aggregate(schema, config, spec) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const pipeline = compileMongoAggregate(spec, pk);
+      const result = await collection.aggregate(pipeline, { session: this.#sessionStore.getStore() }).toArray();
+      return result;
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError(
+        "MongoDB aggregate failed",
+        { adapter: "mongodb", operation: "aggregate", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async findMany(schema, config, filter, options) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const { filter: mongoFilter, sort, limit, skip, projection } = compileMongoQuery(filter, options, pk);
+      const collection = this.#getCollection(schemaCfg);
+      let cursor = collection.find(mongoFilter, {
+        session: this.#sessionStore.getStore(),
+        projection
+      });
+      if (sort) cursor = cursor.sort(sort);
+      if (limit) cursor = cursor.limit(limit);
+      if (skip) cursor = cursor.skip(skip);
+      return await cursor.toArray();
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB findMany failed",
+        { adapter: "mongodb", operation: "findMany", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async count(schema, config, filter) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      return await collection.countDocuments(compileMongoFilter(filter, pk), { session: this.#sessionStore.getStore() });
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB count failed",
+        { adapter: "mongodb", operation: "count", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async *iterateMany(schema, config, filter, options) {
+    const schemaCfg = config;
+    let cursor;
+    try {
+      const pk = schema.pkField.name;
+      const { filter: mongoFilter, sort, limit, skip, projection } = compileMongoQuery(filter, options, pk);
+      const collection = this.#getCollection(schemaCfg);
+      cursor = collection.find(mongoFilter, {
+        session: this.#sessionStore.getStore(),
+        projection
+      });
+      if (sort) cursor = cursor.sort(sort);
+      if (limit) cursor = cursor.limit(limit);
+      if (skip) cursor = cursor.skip(skip);
+      if (options?.batchSize !== void 0) cursor = cursor.batchSize(options.batchSize);
+      for await (const row of cursor) {
+        yield row;
+      }
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB iterateMany failed",
+        { adapter: "mongodb", operation: "iterateMany", collection: schemaCfg.col },
+        error
+      );
+    } finally {
+      await cursor?.close();
+    }
+  }
+  async updateMany(schema, config, filter, data) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const session = this.#sessionStore.getStore();
+      const mongoFilter = compileMongoFilter(filter, pk);
+      const matchingDocs = await collection.find(mongoFilter, { session, projection: { [pk]: 1 } }).toArray();
+      const ids = matchingDocs.map((d) => d[pk]);
+      const idFilter = { [pk]: { $in: ids } };
+      const update = compileMongoUpdate(data);
+      if (Object.keys(update).length > 0) {
+        await collection.updateMany(idFilter, update, { session });
+      }
+      return await collection.find({ [pk]: { $in: ids } }, { session }).toArray();
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB updateMany failed",
+        { adapter: "mongodb", operation: "updateMany", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async deleteMany(schema, config, filter) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const session = this.#sessionStore.getStore();
+      const mongoFilter = compileMongoFilter(filter, pk);
+      const docs = await collection.find(mongoFilter, { session }).toArray();
+      if (docs.length > 0) {
+        await collection.deleteMany(mongoFilter, { session });
+      }
+      return docs;
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB deleteMany failed",
+        { adapter: "mongodb", operation: "deleteMany", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const schemaCfg = config;
+    try {
+      const pk = schema.pkField.name;
+      const collection = this.#getCollection(schemaCfg);
+      const mongoFilter = compileMongoFilter(filter, pk);
+      const updateDoc = compileMongoOps(ops);
+      const doc = await collection.findOneAndUpdate(
+        mongoFilter,
+        {
+          ...updateDoc,
+          $setOnInsert: create
+        },
+        {
+          returnDocument: "after",
+          session: this.#sessionStore.getStore(),
+          upsert: true
+        }
+      );
+      return doc;
+    } catch (error) {
+      throw new EquippedError(
+        "MongoDB upsertOne failed",
+        { adapter: "mongodb", operation: "upsertOne", collection: schemaCfg.col },
+        error
+      );
+    }
+  }
+  async session(fn) {
+    if (this.#sessionStore.getStore()) return fn();
+    try {
+      const session = await this.client.startSession();
+      try {
+        return await session.withTransaction(async () => this.#sessionStore.run(session, fn));
+      } finally {
+        await session.endSession();
+      }
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("MongoDB session failed", { adapter: "mongodb", operation: "session" }, error);
+    }
+  }
+  async loadMigrations() {
+    const db = this.client.db();
+    const docs = await db.collection(MIGRATION_TRACKER_COLLECTION).find({}).toArray();
+    return docs.map((d) => ({ id: String(d._id), appliedAt: d.appliedAt }));
+  }
+  async recordMigration(id, appliedAt) {
+    const db = this.client.db();
+    await db.collection(MIGRATION_TRACKER_COLLECTION).insertOne({ _id: id, appliedAt });
+  }
+  async applyAddIndex(change) {
+    const db = this.client.db();
+    const fields = {};
+    for (const f of change.on) {
+      fields[f] = 1;
+    }
+    const name = change.name ?? `${change.table}_${change.on.join("_")}_idx`;
+    await db.collection(change.table).createIndex(fields, { unique: change.unique ?? false, name });
+  }
+  async applyDropIndex(change) {
+    const db = this.client.db();
+    const collections = await db.listCollections().toArray();
+    for (const col of collections) {
+      const indexes = await db.collection(col.name).listIndexes().toArray();
+      if (indexes.some((idx) => idx.name === change.name)) {
+        await db.collection(col.name).dropIndex(change.name);
+        return;
+      }
+    }
+  }
+  async introspect() {
+    const db = this.client.db();
+    const collections = await db.listCollections().toArray();
+    const schemas = [];
+    for (const col of collections) {
+      if (col.name === MIGRATION_TRACKER_COLLECTION) continue;
+      const rawIndexes = await db.collection(col.name).listIndexes().toArray();
+      const indexes = rawIndexes.filter((idx) => idx.name !== "_id_").map((idx) => ({
+        name: idx.name,
+        on: Object.keys(idx.key),
+        unique: !!idx.unique
+      }));
+      schemas.push({
+        name: col.name,
+        pk: void 0,
+        fields: [],
+        indexes,
+        foreignKeys: []
+      });
+    }
+    return schemas;
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  describe("MongoDbAdapter: class-via-configurable shape", () => {
+    test("MongoDbAdapter.create validates connection config via pipe", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(adapter).toBeInstanceOf(MongoDbAdapter);
+      expect(adapter.client).toBeInstanceOf(MongoClient);
+    });
+    test("MongoDbAdapter.create rejects invalid config", () => {
+      expect(() => MongoDbAdapter.create({})).toThrow();
+      expect(() => MongoDbAdapter.create({ uri: 123 })).toThrow();
+    });
+    test("readonly schemaConfigPipe declared with { db, col } shape", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(adapter.schemaConfigPipe).toBeDefined();
+    });
+    test("capability declarations use as const", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(adapter.supportedFieldTypes).toEqual([
+        "string",
+        "number",
+        "boolean",
+        "null",
+        "object",
+        "array",
+        "date"
+      ]);
+      expect(adapter.queryableOps).toEqual([
+        "eq",
+        "ne",
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "in",
+        "notIn",
+        "like",
+        "exists",
+        "notExists",
+        "contains",
+        "notContains"
+      ]);
+      expect(adapter.updateOps).toEqual([
+        "set",
+        "inc",
+        "mul",
+        "min",
+        "max",
+        "unset",
+        "push",
+        "pull",
+        "patch"
+      ]);
+      expect(adapter.aggregateOps).toEqual([
+        "count",
+        "countDistinct",
+        "sum",
+        "avg",
+        "min",
+        "max"
+      ]);
+    });
+    test("underlying MongoClient exposed as readonly instance field", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(adapter.client).toBeInstanceOf(MongoClient);
+    });
+    test("adapter.use returns OrmUse-shaped object", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const schema = Schema.from("test").pk("id", v2.string(), () => "x").build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      const use = adapter.use(schema, { db: "testdb", col: "testcol" });
+      expect(use.findMany).toBeTypeOf("function");
+      expect(use.iterateMany).toBeTypeOf("function");
+      expect(use.findOne).toBeTypeOf("function");
+      expect(use.count).toBeTypeOf("function");
+      expect(use.createOne).toBeTypeOf("function");
+      expect(use.createMany).toBeTypeOf("function");
+      expect(use.updateMany).toBeTypeOf("function");
+      expect(use.updateOne).toBeTypeOf("function");
+      expect(use.upsertOne).toBeTypeOf("function");
+      expect(use.deleteOne).toBeTypeOf("function");
+      expect(use.deleteMany).toBeTypeOf("function");
+      expect(use.raw).toBeTypeOf("function");
+    });
+    test("type-level: adapter declares all 9 canonical update ops", () => {
+      const _adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: adapter declares all 7 field types", () => {
+      const _adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: adapter declares all 13 queryable ops", () => {
+      const _adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: Repo.from with MongoDbAdapter enables all builder methods", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v2.string(), () => "x").build();
+      const _one = repo.on(_TestSchema).one();
+      const _all = repo.on(_TestSchema).all();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_one.create).toBeFunction();
+      expectTypeOf(_one.find).toBeFunction();
+      expectTypeOf(_one.update).toBeFunction();
+      expectTypeOf(_one.delete).toBeFunction();
+      expectTypeOf(_one.upsert).toBeFunction();
+      expectTypeOf(_all.create).toBeFunction();
+      expectTypeOf(_all.find).toBeFunction();
+      expectTypeOf(_all.count).toBeFunction();
+      expectTypeOf(_all.update).toBeFunction();
+      expectTypeOf(_all.delete).toBeFunction();
+      expectTypeOf(_ref.raw).toBeFunction();
+      expectTypeOf(repo.session).toBeFunction();
+    });
+    test("type-level: raw arg-tuple infers (pipeline: Record<string, unknown>[]) from MongoDbAdapter", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v2.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).parameters.toEqualTypeOf();
+    });
+    test("type-level: per-call <T> override narrows MongoDbAdapter raw return type", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v2.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).returns.toEqualTypeOf();
+    });
+    test("count forwards compiled filter to collection.countDocuments", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("mongo_count").pk("_id", v2.string(), () => "x").field("name", v2.string()).build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let capturedFilter;
+      adapter.client.db = () => ({
+        collection: () => ({
+          countDocuments: async (filter, _opts) => {
+            capturedFilter = filter;
+            return 7;
+          }
+        })
+      });
+      const result = await adapter.count(schema, { db: "testdb", col: "things" }, FilterGroup2.create().eq("name", "Alice"));
+      expect(capturedFilter).toEqual({ name: { $eq: "Alice" } });
+      expect(result).toBe(7);
+    });
+    test("raw forwards pipeline to collection.aggregate at runtime", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const schema = Schema.from("mongo_raw").pk("id", v2.string(), () => "x").build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let capturedPipeline;
+      const mockResults = [{ total: 42 }];
+      adapter.client.db = () => ({
+        collection: () => ({
+          aggregate: (pipeline, _opts) => {
+            capturedPipeline = pipeline;
+            return { toArray: async () => mockResults };
+          }
+        })
+      });
+      const result = await adapter.use(schema, { db: "testdb", col: "things" }).raw([{ $count: "total" }]);
+      expect(capturedPipeline).toEqual([{ $count: "total" }]);
+      expect(result).toEqual(mockResults);
+    });
+    test("iterateMany forwards batchSize and closes cursor on early return", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const { OrderBy } = await null;
+      const schema = Schema.from("mongo_iter").pk("_id", v2.string(), () => "x").field("age", v2.number()).build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let capturedFindFilter;
+      let capturedFindOptions;
+      let capturedSort;
+      let capturedLimit;
+      let capturedSkip;
+      let capturedBatchSize;
+      let closeCalls = 0;
+      const cursor = {
+        sort(sort) {
+          capturedSort = sort;
+          return this;
+        },
+        limit(limit) {
+          capturedLimit = limit;
+          return this;
+        },
+        skip(skip) {
+          capturedSkip = skip;
+          return this;
+        },
+        batchSize(batchSize) {
+          capturedBatchSize = batchSize;
+          return this;
+        },
+        async close() {
+          closeCalls += 1;
+        },
+        async *[Symbol.asyncIterator]() {
+          yield { _id: "u4", age: 50 };
+          yield { _id: "u3", age: 40 };
+        }
+      };
+      adapter.client.db = () => ({
+        collection: () => ({
+          find: (filter, options) => {
+            capturedFindFilter = filter;
+            capturedFindOptions = options;
+            return cursor;
+          }
+        })
+      });
+      const rows = [];
+      for await (const row of adapter.use(schema, { db: "testdb", col: "people" }).iterateMany(FilterGroup2.create().gt("age", 19), {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        batchSize: 25
+      })) {
+        rows.push(row);
+        break;
+      }
+      expect(capturedFindFilter).toEqual({ age: { $gt: 19 } });
+      expect(capturedFindOptions).toEqual({ session: void 0, projection: void 0 });
+      expect(capturedSort).toEqual({ age: -1 });
+      expect(capturedLimit).toBe(2);
+      expect(capturedSkip).toBe(1);
+      expect(capturedBatchSize).toBe(25);
+      expect(rows).toEqual([{ _id: "u4", age: 50 }]);
+      expect(closeCalls).toBe(1);
+    });
+    test("iterateMany closes cursor on normal completion", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("mongo_iter_complete").pk("_id", v2.string(), () => "x").field("age", v2.number()).build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let closeCalls = 0;
+      const cursor = {
+        async close() {
+          closeCalls += 1;
+        },
+        async *[Symbol.asyncIterator]() {
+          yield { _id: "u1", age: 30 };
+          yield { _id: "u2", age: 40 };
+        }
+      };
+      adapter.client.db = () => ({
+        collection: () => ({
+          find: () => cursor
+        })
+      });
+      const rows = [];
+      for await (const row of adapter.use(schema, { db: "testdb", col: "people" }).iterateMany(FilterGroup2.create())) {
+        rows.push(row);
+      }
+      expect(rows).toEqual([{ _id: "u1", age: 30 }, { _id: "u2", age: 40 }]);
+      expect(closeCalls).toBe(1);
+    });
+    test("nested session returns callback without starting new transaction", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(adapter.session).toBeTypeOf("function");
+    });
+    test("type-level: adapter declares all 6 canonical aggregate ops", () => {
+      const _adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: Repo.from with MongoDbAdapter enables aggregate method", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", v2.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.aggregate).toBeFunction();
+    });
+    test("aggregate forwards compiled pipeline to collection.aggregate", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const schema = Schema.from("mongo_agg").pk("_id", v2.string(), () => "x").field("amount", v2.number()).build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let capturedPipeline;
+      const mockResults = [{ total: 3, revenue: 150 }];
+      adapter.client.db = () => ({
+        collection: () => ({
+          aggregate: (pipeline, _opts) => {
+            capturedPipeline = pipeline;
+            return { toArray: async () => mockResults };
+          }
+        })
+      });
+      const result = await adapter.aggregate(schema, { db: "testdb", col: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "total" },
+          { fn: "sum", field: "amount", alias: "revenue" }
+        ],
+        groupBy: []
+      });
+      expect(capturedPipeline).toEqual([
+        { $group: { _id: null, total: { $sum: 1 }, revenue: { $sum: "$amount" } } },
+        { $project: { _id: 0, total: 1, revenue: 1 } }
+      ]);
+      expect(result).toEqual(mockResults);
+    });
+    test("aggregate with where and groupBy produces correct pipeline", async () => {
+      const { Schema } = await null;
+      const { v: v2 } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("mongo_agg2").pk("_id", v2.string(), () => "x").field("region", v2.string()).field("amount", v2.number()).build();
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      let capturedPipeline;
+      adapter.client.db = () => ({
+        collection: () => ({
+          aggregate: (pipeline, _opts) => {
+            capturedPipeline = pipeline;
+            return { toArray: async () => [{ region: "US", total: 2 }] };
+          }
+        })
+      });
+      await adapter.aggregate(schema, { db: "testdb", col: "orders" }, {
+        where: FilterGroup2.create().gt("amount", 10),
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["region"]
+      });
+      expect(capturedPipeline).toEqual([
+        { $match: { amount: { $gt: 10 } } },
+        { $group: { _id: { region: "$region" }, total: { $sum: 1 } } },
+        { $project: { _id: 0, region: "$_id.region", total: 1 } }
+      ]);
+    });
+    test("auto-wires Instance hooks for connect/disconnect", async () => {
+      const { Instance: Inst } = await null;
+      const { vi } = await null;
+      const onSpy = vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      MongoDbAdapter.create({ uri: "mongodb://localhost:27017" });
+      expect(onSpy).toHaveBeenCalledWith("start", expect.any(Function), expect.objectContaining({ class: MongoDbAdapter }));
+      expect(onSpy).toHaveBeenCalledWith("close", expect.any(Function), expect.objectContaining({ class: MongoDbAdapter }));
+      onSpy.mockRestore();
+    });
+  });
+  describe("MongoDbAdapter: migrations", () => {
+    function mockMongoDb(adapter) {
+      const state = {
+        migrations: /* @__PURE__ */ new Map(),
+        collections: /* @__PURE__ */ new Map()
+      };
+      const getCol = (name) => {
+        if (!state.collections.has(name)) {
+          state.collections.set(name, { indexes: [] });
+        }
+        return state.collections.get(name);
+      };
+      adapter.client.db = () => ({
+        collection: (name) => {
+          if (name === MIGRATION_TRACKER_COLLECTION) {
+            return {
+              find: () => ({ toArray: async () => [...state.migrations.values()] }),
+              insertOne: async (doc) => {
+                state.migrations.set(doc._id, doc);
+              }
+            };
+          }
+          const col = getCol(name);
+          return {
+            createIndex: async (fields, opts) => {
+              col.indexes.push({ name: opts.name, key: fields, unique: opts.unique });
+            },
+            dropIndex: async (indexName) => {
+              col.indexes = col.indexes.filter((i) => i.name !== indexName);
+            },
+            listIndexes: () => ({
+              toArray: async () => [
+                { name: "_id_", key: { _id: 1 } },
+                ...col.indexes
+              ]
+            })
+          };
+        },
+        listCollections: () => ({
+          toArray: async () => [...state.collections.keys()].map((name) => ({ name }))
+        })
+      });
+      return state;
+    }
+    test("loadMigrations reads from equipped_migrations collection", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.migrations.set("0001", { _id: "0001", appliedAt: 1e3 });
+      state.migrations.set("0002", { _id: "0002", appliedAt: 2e3 });
+      const result = await adapter.loadMigrations();
+      expect(result).toEqual([
+        { id: "0001", appliedAt: 1e3 },
+        { id: "0002", appliedAt: 2e3 }
+      ]);
+    });
+    test("loadMigrations returns empty array when no migrations exist", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      mockMongoDb(adapter);
+      const result = await adapter.loadMigrations();
+      expect(result).toEqual([]);
+    });
+    test("recordMigration inserts into equipped_migrations with _id", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      await adapter.recordMigration("0001", 1234);
+      expect(state.migrations.has("0001")).toBe(true);
+      expect(state.migrations.get("0001")).toEqual({ _id: "0001", appliedAt: 1234 });
+    });
+    test("applyAddIndex creates index with specified name and fields", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"], unique: true, name: "users_email_unique" });
+      const col = state.collections.get("users");
+      expect(col.indexes).toHaveLength(1);
+      expect(col.indexes[0]).toEqual({ name: "users_email_unique", key: { email: 1 }, unique: true });
+    });
+    test("applyAddIndex auto-derives name when absent", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"] });
+      const col = state.collections.get("users");
+      expect(col.indexes[0].name).toBe("users_email_idx");
+    });
+    test("applyAddIndex auto-derived compound index name", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      await adapter.applyAddIndex({ kind: "addIndex", table: "orders", on: ["userId", "createdAt"] });
+      const col = state.collections.get("orders");
+      expect(col.indexes[0].name).toBe("orders_userId_createdAt_idx");
+      expect(col.indexes[0].key).toEqual({ userId: 1, createdAt: 1 });
+    });
+    test("applyDropIndex finds and drops index by scanning collections", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("users", { indexes: [{ name: "users_email_idx", key: { email: 1 }, unique: true }] });
+      await adapter.applyDropIndex({ kind: "dropIndex", name: "users_email_idx" });
+      expect(state.collections.get("users").indexes).toHaveLength(0);
+    });
+    test("applyDropIndex is a no-op when index not found", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      mockMongoDb(adapter);
+      await adapter.applyDropIndex({ kind: "dropIndex", name: "nonexistent_idx" });
+    });
+    test("introspect returns DiscoveredSchema with empty fields, pk, and foreignKeys", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("users", { indexes: [] });
+      state.collections.set("posts", { indexes: [] });
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(2);
+      for (const s of schemas) {
+        expect(s.pk).toBeUndefined();
+        expect(s.fields).toEqual([]);
+        expect(s.foreignKeys).toEqual([]);
+      }
+    });
+    test("introspect skips _id_ index", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("users", { indexes: [{ name: "users_email_idx", key: { email: 1 }, unique: false }] });
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(1);
+      expect(schemas[0].indexes).toHaveLength(1);
+      expect(schemas[0].indexes[0].name).toBe("users_email_idx");
+    });
+    test("introspect skips tracker collection", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("users", { indexes: [] });
+      state.collections.set(MIGRATION_TRACKER_COLLECTION, { indexes: [] });
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(1);
+      expect(schemas[0].name).toBe("users");
+    });
+    test("introspect maps index keys to on array and unique flag", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("orders", {
+        indexes: [
+          { name: "orders_userId_createdAt_idx", key: { userId: 1, createdAt: 1 }, unique: false },
+          { name: "orders_email_unique", key: { email: 1 }, unique: true }
+        ]
+      });
+      const schemas = await adapter.introspect();
+      expect(schemas[0].indexes).toEqual([
+        { name: "orders_userId_createdAt_idx", on: ["userId", "createdAt"], unique: false },
+        { name: "orders_email_unique", on: ["email"], unique: true }
+      ]);
+    });
+    test("adapter does not implement acquireMigrationLock", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      expect(adapter.acquireMigrationLock).toBeUndefined();
+    });
+    test("adapter does not implement DDL apply methods", () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      expect(adapter.applyCreateTable).toBeUndefined();
+      expect(adapter.applyDropTable).toBeUndefined();
+      expect(adapter.applyAddField).toBeUndefined();
+      expect(adapter.applyDropField).toBeUndefined();
+      expect(adapter.applyModifyField).toBeUndefined();
+      expect(adapter.applyRenameTable).toBeUndefined();
+      expect(adapter.applyRenameField).toBeUndefined();
+      expect(adapter.applyAddForeignKey).toBeUndefined();
+      expect(adapter.applyDropForeignKey).toBeUndefined();
+    });
+    test("type-level: ChangeFor<MongoDbAdapter> excludes DDL variants", () => {
+      expectTypeOf().not.toBeNever();
+      expectTypeOf().not.toBeNever();
+      expectTypeOf().not.toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+      expectTypeOf().toBeNever();
+    });
+    test("type-level: Migrator.from(repo, adapter).build() works without withoutLock", async () => {
+      const { Migrator } = await null;
+      const { Repo } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const step = Migrator.from(repo, adapter).migrations([]);
+      expectTypeOf(step).toHaveProperty("build");
+      expectTypeOf(step).toHaveProperty("withoutLock");
+    });
+    test("type-level: Migrator.from(repo, adapter).withoutLock().build() also works", async () => {
+      const { Migrator } = await null;
+      const { Repo } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const migrator = Migrator.from(repo, adapter).migrations([]).withoutLock().build();
+      expect(migrator).toBeDefined();
+    });
+    test("end-to-end: Migrator runs addIndex + dropIndex + execute changes", async () => {
+      const { Migrator } = await null;
+      const { Repo } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      let executeRan = false;
+      const migrations = [
+        {
+          id: "0001-add-idx",
+          tx: false,
+          changes: [
+            { kind: "addIndex", table: "users", on: ["email"], unique: true }
+          ]
+        },
+        {
+          id: "0002-backfill",
+          tx: false,
+          changes: [
+            { kind: "execute", up: async () => {
+              executeRan = true;
+            } }
+          ]
+        },
+        {
+          id: "0003-drop-idx",
+          tx: false,
+          changes: [
+            { kind: "dropIndex", name: "users_email_idx" }
+          ]
+        }
+      ];
+      const migrator = Migrator.from(repo, adapter).migrations(migrations).build();
+      const result = await migrator.up();
+      expect(result.ran).toEqual(["0001-add-idx", "0002-backfill", "0003-drop-idx"]);
+      expect(executeRan).toBe(true);
+      expect(state.migrations.size).toBe(3);
+      expect(state.collections.get("users").indexes).toHaveLength(0);
+    });
+    test("introspect round-trip: addIndex then introspect sees the index", async () => {
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      const state = mockMongoDb(adapter);
+      state.collections.set("users", {
+        indexes: [{ name: "users_email_idx", key: { email: 1 }, unique: true }]
+      });
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(1);
+      expect(schemas[0].name).toBe("users");
+      expect(schemas[0].pk).toBeUndefined();
+      expect(schemas[0].fields).toEqual([]);
+      expect(schemas[0].foreignKeys).toEqual([]);
+      expect(schemas[0].indexes).toEqual([
+        { name: "users_email_idx", on: ["email"], unique: true }
+      ]);
+    });
+    test("data backfill via execute change", async () => {
+      const { Migrator } = await null;
+      const { Repo } = await null;
+      const adapter = MongoDbAdapter.create({ uri: "mongodb://localhost:27017/testdb" });
+      mockMongoDb(adapter);
+      const repo = Repo.from(adapter).resolve(() => ({ db: "test", col: "test" })).build();
+      const backfilledData = [];
+      const m = {
+        id: "0001-backfill",
+        tx: false,
+        changes: [{
+          kind: "execute",
+          up: async () => {
+            backfilledData.push("user-1-normalized");
+            backfilledData.push("user-2-normalized");
+          }
+        }]
+      };
+      const migrator = Migrator.from(repo, adapter).migrations([m]).build();
+      await migrator.up();
+      expect(backfilledData).toEqual(["user-1-normalized", "user-2-normalized"]);
+    });
+  });
+}
+export {
+  MongoDbAdapter
+};
+//# sourceMappingURL=index.mjs.map