@nxgt/mongo 0.3.0 → 0.3.1

package/dist/index.js

@@ -1,29 +1,117 @@
-// src/definition/define-collection.ts
-function defineCollection(config) {
-  if (!("_id" in config.schema.shape)) {
-    throw new TypeError(`defineCollection: "${config.name}"'s schema has no _id. Add ` + "`_id: id()`, which fills a new ObjectId on create, or declare the " + "key your documents use.");
+// src/definition/json-schema.ts
+import { z } from "zod";
+var MONGO_JSON_SCHEMA_KEYWORDS = new Set([
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "bsonType",
+  "dependencies",
+  "description",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "items",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "properties",
+  "required",
+  "title",
+  "type",
+  "uniqueItems"
+]);
+var SCHEMA_MAPS = new Set([
+  "properties",
+  "patternProperties",
+  "dependencies"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var INTEGER_BSON_TYPES = ["int", "long", "double"];
+function convertIntegerType(node) {
+  const type = node.type;
+  if (type === "integer") {
+    delete node.type;
+    node.bsonType = [...INTEGER_BSON_TYPES];
+    node.multipleOf ??= 1;
+    return;
+  }
+  if (Array.isArray(type) && type.includes("integer")) {
+    delete node.type;
+    node.bsonType = [
+      ...type.filter((one) => one !== "integer"),
+      ...INTEGER_BSON_TYPES
+    ];
+    node.multipleOf ??= 1;
   }
-  return Object.freeze({
-    ...config,
-    indexes: Object.freeze([...config.indexes ?? []]),
-    validation: Object.freeze({
-      level: config.validation?.level ?? "strict",
-      action: config.validation?.action ?? "error"
-    })
-  });
 }
-function stampsOf(definition) {
-  const shape = definition.schema.shape;
-  const has = (name) => (name in shape);
-  return {
-    createdAt: has("createdAt"),
-    updatedAt: has("updatedAt"),
-    deletedAt: has("deletedAt"),
-    version: has("version"),
-    createdBy: has("createdBy"),
-    updatedBy: has("updatedBy"),
-    deletedBy: has("deletedBy")
-  };
+function refName(ref) {
+  return ref.replace(/^#\/(definitions|\$defs)\//, "");
+}
+function inline(value, defs, stack) {
+  if (Array.isArray(value)) {
+    return value.map((one) => inline(one, defs, stack));
+  }
+  if (!isRecord(value))
+    return value;
+  if (typeof value.$ref === "string") {
+    const name = refName(value.$ref);
+    if (stack.includes(name)) {
+      throw new TypeError(`toMongoJsonSchema: "${name}" refers to itself. MongoDB's $jsonSchema ` + "has no $ref, so a recursive schema cannot be a validator. Give the " + "collection no validator, or model the field as an object with no " + "schema of its own.");
+    }
+    const target = defs[name];
+    if (!isRecord(target)) {
+      throw new TypeError(`toMongoJsonSchema: cannot resolve ${value.$ref}, which zod emitted`);
+    }
+    const { $ref: _ref, ...siblings } = value;
+    return {
+      ...inline(target, defs, [...stack, name]),
+      ...inline(siblings, defs, stack)
+    };
+  }
+  const out = {};
+  for (const [key, inner] of Object.entries(value)) {
+    if (!MONGO_JSON_SCHEMA_KEYWORDS.has(key))
+      continue;
+    if (SCHEMA_MAPS.has(key) && isRecord(inner)) {
+      const mapped = {};
+      for (const [name, schema] of Object.entries(inner)) {
+        mapped[name] = inline(schema, defs, stack);
+      }
+      out[key] = mapped;
+      continue;
+    }
+    out[key] = inline(inner, defs, stack);
+  }
+  convertIntegerType(out);
+  return out;
+}
+function toMongoJsonSchema(schema) {
+  const json = z.toJSONSchema(schema, {
+    target: "draft-4",
+    io: "output",
+    unrepresentable: "any",
+    override: (ctx) => {
+      const type = ctx.zodSchema._zod.def.type;
+      if (type === "date" && ctx.jsonSchema.bsonType === undefined) {
+        ctx.jsonSchema.bsonType = "date";
+      }
+    }
+  });
+  const definitions = isRecord(json.definitions) ? json.definitions : isRecord(json.$defs) ? json.$defs : {};
+  return inline(json, definitions, []);
 }
 
 // src/errors/data-error.ts
@@ -94,7 +182,7 @@ class InvalidCursorError extends DataError {
 }
 
 // src/errors/to-data-error.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asArray(value) {
@@ -110,8 +198,8 @@ function indexFromMessage(message) {
 }
 function keysOfDuplicate(error) {
   const pattern = error.keyPattern;
-  if (isRecord(pattern)) {
-    const values = isRecord(error.keyValue) ? error.keyValue : undefined;
+  if (isRecord2(pattern)) {
+    const values = isRecord2(error.keyValue) ? error.keyValue : undefined;
     return { keys: Object.keys(pattern), values };
   }
   const inMessage = text(error.errmsg)?.match(/dup key:\s*\{([^}]*)\}/)?.[1];
@@ -122,8 +210,8 @@ function keysOfDuplicate(error) {
 }
 function firstWriteError(error) {
   for (const write of asArray(error.writeErrors)) {
-    const inner = isRecord(write) && isRecord(write.err) ? write.err : write;
-    if (isRecord(inner))
+    const inner = isRecord2(write) && isRecord2(write.err) ? write.err : write;
+    if (isRecord2(inner))
       return inner;
   }
   return;
@@ -131,11 +219,11 @@ function firstWriteError(error) {
 function issuesOf(details, path = []) {
   const issues = [];
   for (const rule of asArray(details)) {
-    if (!isRecord(rule))
+    if (!isRecord2(rule))
       continue;
     if (rule.propertiesNotSatisfied !== undefined) {
       for (const property of asArray(rule.propertiesNotSatisfied)) {
-        if (!isRecord(property))
+        if (!isRecord2(property))
           continue;
         const name = text(property.propertyName) ?? "";
         const nested = issuesOf(property.details, [...path, name]);
@@ -171,7 +259,7 @@ function issuesOf(details, path = []) {
 function toDataError(error, context = {}) {
   if (error instanceof DataError)
     return error;
-  if (!isRecord(error))
+  if (!isRecord2(error))
     return error;
   const source = firstWriteError(error) ?? error;
   const code = typeof source.code === "number" ? source.code : typeof error.code === "number" ? error.code : undefined;
@@ -191,303 +279,96 @@ function toDataError(error, context = {}) {
     return new ConflictError(`Duplicate key on ${named}${context.collection ? ` in "${context.collection}"` : ""}`, { ...common, index, keys, values });
   }
   if (code === 121) {
-    const errInfo = isRecord(source.errInfo) ? source.errInfo : undefined;
+    const errInfo = isRecord2(source.errInfo) ? source.errInfo : undefined;
     const issues = issuesOf(errInfo?.details);
     return new ValidationError(`Document failed validation${context.collection ? ` in "${context.collection}"` : ""}${issues.length > 0 ? `: ${issues.map((i) => `${i.path} ${i.reason}`).join(", ")}` : ""}`, { ...common, issues, keys: issues.map((issue) => issue.path) });
   }
   return new DataError(message || `MongoDB error ${code}`, common);
 }
 
-// src/pagination/cursor.ts
-import { ObjectId } from "mongodb";
-function isObjectId(value) {
-  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
+// src/sync/index-diff.ts
+var COLLATION_DEFAULTS = {
+  caseLevel: false,
+  caseFirst: "off",
+  strength: 3,
+  numericOrdering: false,
+  alternate: "non-ignorable",
+  maxVariable: "punct",
+  normalization: false,
+  backwards: false
+};
+var OPTION_DEFAULTS = {
+  unique: false,
+  sparse: false,
+  hidden: false,
+  background: false
+};
+var IGNORED = new Set(["v", "ns", "key", "name"]);
+function keyOf(index) {
+  const key = index.key;
+  return key instanceof Map ? Object.fromEntries(key) : { ...key };
 }
-function replacer(key, value) {
-  const raw = this[key];
-  if (raw instanceof Date)
-    return { $date: raw.toISOString() };
-  if (typeof raw === "bigint")
-    return { $bigint: raw.toString() };
-  if (isObjectId(raw))
-    return { $oid: raw.toHexString() };
-  return value;
+function indexNameOf(key) {
+  return Object.entries(key).map(([field, direction]) => `${field}_${String(direction)}`).join("_");
 }
-function reviver(_key, value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const keys = Object.keys(value);
-    if (keys.length === 1) {
-      const tagged = value;
-      if (typeof tagged.$date === "string")
-        return new Date(tagged.$date);
-      if (typeof tagged.$bigint === "string")
-        return BigInt(tagged.$bigint);
-      if (typeof tagged.$oid === "string")
-        return new ObjectId(tagged.$oid);
-    }
+function canonicalCollation(value) {
+  if (typeof value !== "object" || value === null)
+    return value;
+  const collation = value;
+  const out = {};
+  for (const [field, fallback] of Object.entries(COLLATION_DEFAULTS)) {
+    out[field] = collation[field] ?? fallback;
   }
-  return value;
+  out.locale = collation.locale;
+  return out;
 }
-function toBase64Url(text) {
-  let binary = "";
-  for (const byte of new TextEncoder().encode(text)) {
-    binary += String.fromCharCode(byte);
+function normalizeIndex(index) {
+  const key = keyOf(index);
+  const options = {};
+  for (const [name, value] of Object.entries(index)) {
+    if (IGNORED.has(name) || value === undefined)
+      continue;
+    if (name === "collation") {
+      options.collation = canonicalCollation(value);
+      continue;
+    }
+    if (OPTION_DEFAULTS[name] === value)
+      continue;
+    options[name] = value;
   }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return { name: index.name ?? indexNameOf(key), key, options };
 }
-function fromBase64Url(text) {
-  const base64 = text.replace(/-/g, "+").replace(/_/g, "/");
-  const binary = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
-  return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+function canonical(value) {
+  return JSON.stringify(value, (_name, inner) => inner && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a < b ? -1 : 1)) : inner);
 }
-function encodeCursor(payload) {
-  return toBase64Url(JSON.stringify([payload.key, payload.values], replacer));
+function indexMatches(wanted, live) {
+  const a = normalizeIndex(wanted);
+  const b = normalizeIndex(live);
+  return JSON.stringify(Object.entries(a.key)) === JSON.stringify(Object.entries(b.key)) && canonical(a.options) === canonical(b.options);
 }
-function decodeCursor(cursor, expectedKey) {
-  let parsed;
-  try {
-    parsed = JSON.parse(fromBase64Url(cursor), reviver);
-  } catch (cause) {
-    throw new InvalidCursorError("Invalid cursor: it cannot be decoded", {
-      cause
-    });
+function diffIndexes(wanted, live) {
+  const byName = new Map(live.map((index) => [normalizeIndex(index).name, index]));
+  const diff = {
+    create: [],
+    recreate: [],
+    unchanged: [],
+    extra: []
+  };
+  const named = new Set;
+  for (const index of wanted) {
+    const name = normalizeIndex(index).name;
+    named.add(name);
+    const existing = byName.get(name);
+    if (!existing)
+      diff.create.push({ ...index, name });
+    else if (indexMatches(index, existing))
+      diff.unchanged.push(name);
+    else
+      diff.recreate.push({ ...index, name });
   }
-  if (!Array.isArray(parsed) || parsed.length !== 2 || typeof parsed[0] !== "string" || !Array.isArray(parsed[1])) {
-    throw new InvalidCursorError("Invalid cursor: unexpected shape");
-  }
-  const [key, values] = parsed;
-  if (expectedKey !== undefined && key !== expectedKey) {
-    throw new InvalidCursorError(`Invalid cursor: it was written for the ordering ${key}, not ${expectedKey}`);
-  }
-  return { key, values };
-}
-
-// src/pagination/page.ts
-var DEFAULT_PAGE_SIZE = 20;
-var DEFAULT_MAX_PAGE_SIZE = 100;
-function positiveInteger(name, value) {
-  if (!Number.isInteger(value) || value < 1) {
-    throw new RangeError(`${name} must be an integer of at least 1, not ${value}`);
-  }
-  return value;
-}
-function pageWindow(options = {}, maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
-  const page = positiveInteger("page", options.page ?? 1);
-  const pageSize = Math.min(positiveInteger("pageSize", options.pageSize ?? DEFAULT_PAGE_SIZE), maxPageSize);
-  return { page, pageSize, limit: pageSize, skip: (page - 1) * pageSize };
-}
-function toPage(items, total, window) {
-  return {
-    items,
-    total,
-    page: window.page,
-    pageSize: window.pageSize,
-    pageCount: Math.ceil(total / window.pageSize)
-  };
-}
-function cursorLimit(limit, maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
-  return Math.min(positiveInteger("limit", limit ?? DEFAULT_PAGE_SIZE), maxPageSize);
-}
-
-// src/definition/json-schema.ts
-import { z } from "zod";
-var MONGO_JSON_SCHEMA_KEYWORDS = new Set([
-  "additionalItems",
-  "additionalProperties",
-  "allOf",
-  "anyOf",
-  "bsonType",
-  "dependencies",
-  "description",
-  "enum",
-  "exclusiveMaximum",
-  "exclusiveMinimum",
-  "items",
-  "maxItems",
-  "maxLength",
-  "maxProperties",
-  "maximum",
-  "minItems",
-  "minLength",
-  "minProperties",
-  "minimum",
-  "multipleOf",
-  "not",
-  "oneOf",
-  "pattern",
-  "patternProperties",
-  "properties",
-  "required",
-  "title",
-  "type",
-  "uniqueItems"
-]);
-var SCHEMA_MAPS = new Set([
-  "properties",
-  "patternProperties",
-  "dependencies"
-]);
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var INTEGER_BSON_TYPES = ["int", "long", "double"];
-function convertIntegerType(node) {
-  const type = node.type;
-  if (type === "integer") {
-    delete node.type;
-    node.bsonType = [...INTEGER_BSON_TYPES];
-    node.multipleOf ??= 1;
-    return;
-  }
-  if (Array.isArray(type) && type.includes("integer")) {
-    delete node.type;
-    node.bsonType = [
-      ...type.filter((one) => one !== "integer"),
-      ...INTEGER_BSON_TYPES
-    ];
-    node.multipleOf ??= 1;
-  }
-}
-function refName(ref) {
-  return ref.replace(/^#\/(definitions|\$defs)\//, "");
-}
-function inline(value, defs, stack) {
-  if (Array.isArray(value)) {
-    return value.map((one) => inline(one, defs, stack));
-  }
-  if (!isRecord2(value))
-    return value;
-  if (typeof value.$ref === "string") {
-    const name = refName(value.$ref);
-    if (stack.includes(name)) {
-      throw new TypeError(`toMongoJsonSchema: "${name}" refers to itself. MongoDB's $jsonSchema ` + "has no $ref, so a recursive schema cannot be a validator. Give the " + "collection no validator, or model the field as an object with no " + "schema of its own.");
-    }
-    const target = defs[name];
-    if (!isRecord2(target)) {
-      throw new TypeError(`toMongoJsonSchema: cannot resolve ${value.$ref}, which zod emitted`);
-    }
-    const { $ref: _ref, ...siblings } = value;
-    return {
-      ...inline(target, defs, [...stack, name]),
-      ...inline(siblings, defs, stack)
-    };
-  }
-  const out = {};
-  for (const [key, inner] of Object.entries(value)) {
-    if (!MONGO_JSON_SCHEMA_KEYWORDS.has(key))
-      continue;
-    if (SCHEMA_MAPS.has(key) && isRecord2(inner)) {
-      const mapped = {};
-      for (const [name, schema] of Object.entries(inner)) {
-        mapped[name] = inline(schema, defs, stack);
-      }
-      out[key] = mapped;
-      continue;
-    }
-    out[key] = inline(inner, defs, stack);
-  }
-  convertIntegerType(out);
-  return out;
-}
-function toMongoJsonSchema(schema) {
-  const json = z.toJSONSchema(schema, {
-    target: "draft-4",
-    io: "output",
-    unrepresentable: "any",
-    override: (ctx) => {
-      const type = ctx.zodSchema._zod.def.type;
-      if (type === "date" && ctx.jsonSchema.bsonType === undefined) {
-        ctx.jsonSchema.bsonType = "date";
-      }
-    }
-  });
-  const definitions = isRecord2(json.definitions) ? json.definitions : isRecord2(json.$defs) ? json.$defs : {};
-  return inline(json, definitions, []);
-}
-
-// src/sync/index-diff.ts
-var COLLATION_DEFAULTS = {
-  caseLevel: false,
-  caseFirst: "off",
-  strength: 3,
-  numericOrdering: false,
-  alternate: "non-ignorable",
-  maxVariable: "punct",
-  normalization: false,
-  backwards: false
-};
-var OPTION_DEFAULTS = {
-  unique: false,
-  sparse: false,
-  hidden: false,
-  background: false
-};
-var IGNORED = new Set(["v", "ns", "key", "name"]);
-function keyOf(index) {
-  const key = index.key;
-  return key instanceof Map ? Object.fromEntries(key) : { ...key };
-}
-function indexNameOf(key) {
-  return Object.entries(key).map(([field, direction]) => `${field}_${String(direction)}`).join("_");
-}
-function canonicalCollation(value) {
-  if (typeof value !== "object" || value === null)
-    return value;
-  const collation = value;
-  const out = {};
-  for (const [field, fallback] of Object.entries(COLLATION_DEFAULTS)) {
-    out[field] = collation[field] ?? fallback;
-  }
-  out.locale = collation.locale;
-  return out;
-}
-function normalizeIndex(index) {
-  const key = keyOf(index);
-  const options = {};
-  for (const [name, value] of Object.entries(index)) {
-    if (IGNORED.has(name) || value === undefined)
-      continue;
-    if (name === "collation") {
-      options.collation = canonicalCollation(value);
-      continue;
-    }
-    if (OPTION_DEFAULTS[name] === value)
-      continue;
-    options[name] = value;
-  }
-  return { name: index.name ?? indexNameOf(key), key, options };
-}
-function canonical(value) {
-  return JSON.stringify(value, (_name, inner) => inner && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a < b ? -1 : 1)) : inner);
-}
-function indexMatches(wanted, live) {
-  const a = normalizeIndex(wanted);
-  const b = normalizeIndex(live);
-  return JSON.stringify(Object.entries(a.key)) === JSON.stringify(Object.entries(b.key)) && canonical(a.options) === canonical(b.options);
-}
-function diffIndexes(wanted, live) {
-  const byName = new Map(live.map((index) => [normalizeIndex(index).name, index]));
-  const diff = {
-    create: [],
-    recreate: [],
-    unchanged: [],
-    extra: []
-  };
-  const named = new Set;
-  for (const index of wanted) {
-    const name = normalizeIndex(index).name;
-    named.add(name);
-    const existing = byName.get(name);
-    if (!existing)
-      diff.create.push({ ...index, name });
-    else if (indexMatches(index, existing))
-      diff.unchanged.push(name);
-    else
-      diff.recreate.push({ ...index, name });
-  }
-  for (const name of byName.keys()) {
-    if (name !== "_id_" && !named.has(name))
-      diff.extra.push(name);
+  for (const name of byName.keys()) {
+    if (name !== "_id_" && !named.has(name))
+      diff.extra.push(name);
   }
   return diff;
 }
@@ -628,368 +509,538 @@ async function syncCollections(db, definitions, options = {}) {
   return reports;
 }
 
-// src/collection/get-collection.ts
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isUpdateFilter(patch) {
-  return Object.keys(patch).some((key) => key.startsWith("$"));
-}
-function mergeFilters(a, b) {
-  const left = a && Object.keys(a).length > 0 ? a : undefined;
-  const right = b && Object.keys(b).length > 0 ? b : undefined;
-  if (!left)
-    return right ?? {};
-  if (!right)
-    return left;
-  return { $and: [left, right] };
-}
-function databaseOf(source, name) {
-  const client = source;
-  if (typeof client.db === "function")
-    return client.db(name);
-  const db = source;
-  if (name !== undefined && db.databaseName !== name) {
-    throw new TypeError(`getCollection: given a Db for "${db.databaseName}", and a db option of ` + `"${name}". Pass the client, or the database you mean.`);
+// src/definition/define-collection.ts
+function defineCollection(config) {
+  if (!("_id" in config.schema.shape)) {
+    throw new TypeError(`defineCollection: "${config.name}"'s schema has no _id. Add ` + "`_id: id()`, which fills a new ObjectId on create, or declare the " + "key your documents use.");
   }
-  return db;
+  return Object.freeze({
+    ...config,
+    indexes: Object.freeze([...config.indexes ?? []]),
+    validation: Object.freeze({
+      level: config.validation?.level ?? "strict",
+      action: config.validation?.action ?? "error"
+    })
+  });
 }
-function getCollection(source, definition, options = {}) {
-  const db = databaseOf(source, options.db);
-  return build(db, definition, options);
+function stampsOf(definition) {
+  const shape = definition.schema.shape;
+  const has = (name) => (name in shape);
+  return {
+    createdAt: has("createdAt"),
+    updatedAt: has("updatedAt"),
+    deletedAt: has("deletedAt"),
+    version: has("version"),
+    createdBy: has("createdBy"),
+    updatedBy: has("updatedBy"),
+    deletedBy: has("deletedBy")
+  };
 }
-function build(db, definition, options) {
+
+// src/pagination/page.ts
+var DEFAULT_PAGE_SIZE = 20;
+var DEFAULT_MAX_PAGE_SIZE = 100;
+function positiveInteger(name, value) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new RangeError(`${name} must be an integer of at least 1, not ${value}`);
+  }
+  return value;
+}
+function pageWindow(options = {}, maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
+  const page = positiveInteger("page", options.page ?? 1);
+  const pageSize = Math.min(positiveInteger("pageSize", options.pageSize ?? DEFAULT_PAGE_SIZE), maxPageSize);
+  return { page, pageSize, limit: pageSize, skip: (page - 1) * pageSize };
+}
+function toPage(items, total, window) {
+  return {
+    items,
+    total,
+    page: window.page,
+    pageSize: window.pageSize,
+    pageCount: Math.ceil(total / window.pageSize)
+  };
+}
+function cursorLimit(limit, maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
+  return Math.min(positiveInteger("limit", limit ?? DEFAULT_PAGE_SIZE), maxPageSize);
+}
+
+// src/collection/context.ts
+function createContext(db, definition, options) {
   const name = definition.name;
-  const collection = db.collection(name);
   const shape = definition.schema.shape;
-  const hasOwnId = "id" in shape;
   const stamps = stampsOf(definition);
   const session = options.session;
-  const actor = options.actor;
-  const maxPageSize = options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE;
-  const parses = (options.validate ?? "parse") === "parse";
-  const softDeletes = options.softDelete ?? stamps.deletedAt;
-  const touches = options.touchUpdatedAt ?? stamps.updatedAt;
-  const locks = options.optimisticLock ?? stamps.version;
   if (options.softDelete === true && !stamps.deletedAt) {
     throw new TypeError(`getCollection: softDelete needs a "deletedAt" field, and "${name}" has none`);
   }
   if (options.optimisticLock === true && !stamps.version) {
     throw new TypeError(`getCollection: optimisticLock needs a "version" field, and "${name}" has none`);
   }
-  const run = async (fn) => {
-    try {
-      return await fn();
-    } catch (error) {
-      throw toDataError(error, { collection: name });
-    }
+  return {
+    definition,
+    db,
+    collection: db.collection(name),
+    name,
+    shape,
+    stamps,
+    actor: options.actor,
+    session,
+    sessionOption: session ? { session } : {},
+    maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
+    hasOwnId: "id" in shape,
+    parses: (options.validate ?? "parse") === "parse",
+    softDeletes: options.softDelete ?? stamps.deletedAt,
+    touches: options.touchUpdatedAt ?? stamps.updatedAt,
+    locks: options.optimisticLock ?? stamps.version
   };
-  const sessionOption = session ? { session } : {};
-  const live = (withDeleted) => softDeletes && !withDeleted ? { deletedAt: null } : undefined;
-  const scoped = (filter, withDeleted) => mergeFilters(isRecord3(filter) ? filter : undefined, live(withDeleted));
-  const withId = (document) => {
-    if (hasOwnId || !isRecord3(document) || document._id === undefined || Object.hasOwn(document, "id")) {
-      return document;
+}
+async function run(ctx, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw toDataError(error, { collection: ctx.name });
+  }
+}
+function notFound(ctx, id) {
+  return new NotFoundError(`No document in "${ctx.name}" with _id ${String(id)}`, { collection: ctx.name, id });
+}
+
+// src/pagination/cursor.ts
+import { ObjectId } from "mongodb";
+function isObjectId(value) {
+  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
+}
+function replacer(key, value) {
+  const raw = this[key];
+  if (raw instanceof Date)
+    return { $date: raw.toISOString() };
+  if (typeof raw === "bigint")
+    return { $bigint: raw.toString() };
+  if (isObjectId(raw))
+    return { $oid: raw.toHexString() };
+  return value;
+}
+function reviver(_key, value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const keys = Object.keys(value);
+    if (keys.length === 1) {
+      const tagged = value;
+      if (typeof tagged.$date === "string")
+        return new Date(tagged.$date);
+      if (typeof tagged.$bigint === "string")
+        return BigInt(tagged.$bigint);
+      if (typeof tagged.$oid === "string")
+        return new ObjectId(tagged.$oid);
     }
-    Object.defineProperty(document, "id", {
-      get: () => String(document._id),
-      enumerable: true,
-      configurable: true
+  }
+  return value;
+}
+function toBase64Url(text) {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(text)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(text) {
+  const base64 = text.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
+  return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+}
+function encodeCursor(payload) {
+  return toBase64Url(JSON.stringify([payload.key, payload.values], replacer));
+}
+function decodeCursor(cursor, expectedKey) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fromBase64Url(cursor), reviver);
+  } catch (cause) {
+    throw new InvalidCursorError("Invalid cursor: it cannot be decoded", {
+      cause
     });
+  }
+  if (!Array.isArray(parsed) || parsed.length !== 2 || typeof parsed[0] !== "string" || !Array.isArray(parsed[1])) {
+    throw new InvalidCursorError("Invalid cursor: unexpected shape");
+  }
+  const [key, values] = parsed;
+  if (expectedKey !== undefined && key !== expectedKey) {
+    throw new InvalidCursorError(`Invalid cursor: it was written for the ordering ${key}, not ${expectedKey}`);
+  }
+  return { key, values };
+}
+
+// src/collection/filters.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUpdateFilter(patch) {
+  return Object.keys(patch).some((key) => key.startsWith("$"));
+}
+function mergeFilters(a, b) {
+  const left = a && Object.keys(a).length > 0 ? a : undefined;
+  const right = b && Object.keys(b).length > 0 ? b : undefined;
+  if (!left)
+    return right ?? {};
+  if (!right)
+    return left;
+  return { $and: [left, right] };
+}
+function live(ctx, withDeleted) {
+  return ctx.softDeletes && !withDeleted ? { deletedAt: null } : undefined;
+}
+function scoped(ctx, filter, withDeleted) {
+  return mergeFilters(isRecord3(filter) ? filter : undefined, live(ctx, withDeleted));
+}
+function requireFilter(ctx, method, filter) {
+  if (!isRecord3(filter) || Object.keys(filter).length === 0) {
+    throw new TypeError(`${method} needs a filter. Pass \`{ _id: { $exists: true } }\` to target every document of "${ctx.name}".`);
+  }
+}
+
+// src/collection/documents.ts
+function withId(ctx, document) {
+  if (ctx.hasOwnId || !isRecord3(document) || document._id === undefined || Object.hasOwn(document, "id")) {
     return document;
-  };
-  const notFound = (id) => new NotFoundError(`No document in "${name}" with _id ${String(id)}`, {
-    collection: name,
-    id
+  }
+  Object.defineProperty(document, "id", {
+    get: () => String(document._id),
+    enumerable: true,
+    configurable: true
   });
-  const requireFilter = (method, filter) => {
-    if (!isRecord3(filter) || Object.keys(filter).length === 0) {
-      throw new TypeError(`${method} needs a filter. Pass \`{ _id: { $exists: true } }\` to target every document of "${name}".`);
-    }
-  };
-  const toDocument = (values) => {
-    const stamped = { ...values };
-    if (!hasOwnId)
-      delete stamped.id;
-    if (actor !== undefined) {
-      if (stamps.createdBy && stamped.createdBy === undefined) {
-        stamped.createdBy = actor;
-      }
-      if (stamps.updatedBy && stamped.updatedBy === undefined) {
-        stamped.updatedBy = actor;
-      }
-    }
-    return parses ? definition.schema.parse(stamped) : stamped;
-  };
-  const toUpdate = (patch) => {
-    if (!isRecord3(patch)) {
-      throw new TypeError(`update: expected the document's fields or MongoDB's operators, not ${String(patch)}`);
-    }
-    const update = isUpdateFilter(patch) ? { ...patch } : {};
-    const set = isRecord3(update.$set) ? { ...update.$set } : {};
-    if (!isUpdateFilter(patch)) {
-      for (const [field, value] of Object.entries(patch)) {
-        if (value === undefined)
-          continue;
-        const schema = shape[field];
-        if (!schema) {
-          throw new TypeError(`update: "${name}" has no field "${field}" in its schema`);
-        }
-        set[field] = parses ? schema.parse(value) : value;
-      }
+  return document;
+}
+function toDocument(ctx, values) {
+  const stamped = { ...values };
+  if (!ctx.hasOwnId)
+    delete stamped.id;
+  if (ctx.actor !== undefined) {
+    if (ctx.stamps.createdBy && stamped.createdBy === undefined) {
+      stamped.createdBy = ctx.actor;
     }
-    if (touches && set.updatedAt === undefined)
-      set.updatedAt = new Date;
-    if (actor !== undefined && stamps.updatedBy && set.updatedBy === undefined) {
-      set.updatedBy = actor;
+    if (ctx.stamps.updatedBy && stamped.updatedBy === undefined) {
+      stamped.updatedBy = ctx.actor;
     }
-    if (Object.keys(set).length > 0)
-      update.$set = set;
-    if (locks) {
-      const inc = isRecord3(update.$inc) ? { ...update.$inc } : {};
-      inc.version = inc.version ?? 1;
-      update.$inc = inc;
+  }
+  return ctx.parses ? ctx.definition.schema.parse(stamped) : stamped;
+}
+function setFromFields(ctx, patch) {
+  const set = {};
+  for (const [field, value] of Object.entries(patch)) {
+    if (value === undefined)
+      continue;
+    const schema = ctx.shape[field];
+    if (!schema) {
+      throw new TypeError(`update: "${ctx.name}" has no field "${field}" in its schema`);
     }
-    return update;
+    set[field] = ctx.parses ? schema.parse(value) : value;
+  }
+  return set;
+}
+function toUpdate(ctx, patch) {
+  if (!isRecord3(patch)) {
+    throw new TypeError(`update: expected the document's fields or MongoDB's operators, not ${String(patch)}`);
+  }
+  const operators = isUpdateFilter(patch);
+  const update = operators ? { ...patch } : {};
+  const set = {
+    ...isRecord3(update.$set) ? update.$set : {},
+    ...operators ? {} : setFromFields(ctx, patch)
   };
-  const findOne = async (filter, projection) => run(async () => {
-    const found = await collection.findOne(filter, {
-      ...sessionOption,
+  if (ctx.touches && set.updatedAt === undefined)
+    set.updatedAt = new Date;
+  if (ctx.actor !== undefined && ctx.stamps.updatedBy && set.updatedBy === undefined) {
+    set.updatedBy = ctx.actor;
+  }
+  if (Object.keys(set).length > 0)
+    update.$set = set;
+  if (ctx.locks) {
+    const inc = isRecord3(update.$inc) ? { ...update.$inc } : {};
+    inc.version = inc.version ?? 1;
+    update.$inc = inc;
+  }
+  return update;
+}
+
+// src/collection/reads.ts
+function findOne(ctx, filter, projection) {
+  return run(ctx, async () => {
+    const found = await ctx.collection.findOne(filter, {
+      ...ctx.sessionOption,
       ...projection ? { projection } : {}
     });
-    return found === null ? null : withId(found);
+    return found === null ? null : withId(ctx, found);
   });
-  async function findById(id, opts = {}) {
-    const found = await findOne(scoped({ _id: id }, opts.withDeleted));
-    return found ?? undefined;
-  }
-  async function getById(id, opts = {}) {
-    const found = await findById(id, opts);
-    if (!found)
-      throw notFound(id);
-    return found;
-  }
-  async function findMany(opts = {}) {
-    return run(async () => {
-      let cursor = collection.find(scoped(opts.filter, opts.withDeleted), {
-        ...sessionOption,
-        ...opts.projection ? { projection: opts.projection } : {}
-      });
-      if (opts.sort !== undefined)
-        cursor = cursor.sort(opts.sort);
-      if (opts.skip !== undefined)
-        cursor = cursor.skip(opts.skip);
-      if (opts.limit !== undefined)
-        cursor = cursor.limit(opts.limit);
-      const found = await cursor.toArray();
-      return found.map((document) => withId(document));
+}
+async function findById(ctx, id, opts = {}) {
+  const found = await findOne(ctx, scoped(ctx, { _id: id }, opts.withDeleted));
+  return found ?? undefined;
+}
+async function getById(ctx, id, opts = {}) {
+  const found = await findById(ctx, id, opts);
+  if (!found)
+    throw notFound(ctx, id);
+  return found;
+}
+async function findMany(ctx, opts = {}) {
+  return run(ctx, async () => {
+    let cursor = ctx.collection.find(scoped(ctx, opts.filter, opts.withDeleted), {
+      ...ctx.sessionOption,
+      ...opts.projection ? { projection: opts.projection } : {}
     });
+    if (opts.sort !== undefined)
+      cursor = cursor.sort(opts.sort);
+    if (opts.skip !== undefined)
+      cursor = cursor.skip(opts.skip);
+    if (opts.limit !== undefined)
+      cursor = cursor.limit(opts.limit);
+    const found = await cursor.toArray();
+    return found.map((document) => withId(ctx, document));
+  });
+}
+async function findFirst(ctx, filter, opts = {}) {
+  const [first] = await findMany(ctx, { ...opts, filter, limit: 1 });
+  return first;
+}
+async function countDocuments(ctx, filter, opts = {}) {
+  return run(ctx, async () => ctx.collection.countDocuments(scoped(ctx, filter, opts.withDeleted), {
+    ...ctx.sessionOption
+  }));
+}
+async function exists(ctx, filter, opts = {}) {
+  const found = await findOne(ctx, scoped(ctx, filter, opts.withDeleted), {
+    _id: 1
+  });
+  return found !== null && found !== undefined;
+}
+
+// src/collection/paginate.ts
+async function paginate(ctx, opts = {}) {
+  const window = pageWindow(opts, ctx.maxPageSize);
+  const [items, total] = await Promise.all([
+    findMany(ctx, {
+      filter: opts.filter,
+      sort: opts.sort ?? { _id: 1 },
+      limit: window.limit,
+      skip: window.skip,
+      withDeleted: opts.withDeleted
+    }),
+    countDocuments(ctx, opts.filter, {
+      withDeleted: opts.withDeleted
+    })
+  ]);
+  return toPage(items, total, window);
+}
+async function paginateByCursor(ctx, opts = {}) {
+  const sortField = opts.orderBy ?? "_id";
+  if (!ctx.shape[sortField] && sortField !== "_id") {
+    throw new TypeError(`paginateByCursor: "${ctx.name}" has no field "${sortField}" in its schema`);
   }
-  async function countDocuments(filter, opts = {}) {
-    return run(async () => collection.countDocuments(scoped(filter, opts.withDeleted), {
-      ...sessionOption
-    }));
-  }
-  async function updatedOrThrow(id, filter, update, expectedVersion) {
-    const updated = await run(async () => collection.findOneAndUpdate(filter, update, {
-      ...sessionOption,
-      returnDocument: "after"
-    }));
-    if (updated)
-      return withId(updated);
-    if (expectedVersion !== undefined) {
-      const current = await findOne({ _id: id });
-      if (current) {
-        throw new OptimisticLockError(`Document ${String(id)} of "${name}" is at version ${String(current.version)}, not ${expectedVersion}: it changed since it was read`, {
-          collection: name,
-          id,
-          expectedVersion,
-          actualVersion: typeof current.version === "number" ? current.version : undefined
-        });
-      }
+  const direction = opts.direction ?? "asc";
+  const fields = sortField === "_id" ? ["_id"] : [sortField, "_id"];
+  const cursorKey = `${sortField}:${direction}`;
+  const limit = cursorLimit(opts.limit, ctx.maxPageSize);
+  const past = direction === "asc" ? "$gt" : "$lt";
+  let after;
+  if (opts.after) {
+    const { values } = decodeCursor(opts.after, cursorKey);
+    if (values.length !== fields.length) {
+      throw new DataError(`Invalid cursor: expected ${fields.length} value(s), got ${values.length}`, { collection: ctx.name });
     }
-    throw notFound(id);
+    after = {
+      $or: fields.map((field, index) => ({
+        ...Object.fromEntries(fields.slice(0, index).map((previous, i) => [previous, values[i]])),
+        [field]: { [past]: values[index] }
+      }))
+    };
   }
-  async function hardDelete(id) {
-    const deleted = await run(async () => collection.findOneAndDelete({ _id: id }, { ...sessionOption }));
-    if (!deleted)
-      throw notFound(id);
-    return withId(deleted);
+  const sort = Object.fromEntries(fields.map((field) => [field, direction === "asc" ? 1 : -1]));
+  const documents = await findMany(ctx, {
+    filter: mergeFilters(isRecord3(opts.filter) ? opts.filter : undefined, after),
+    sort,
+    limit: limit + 1,
+    withDeleted: opts.withDeleted
+  });
+  const items = documents.slice(0, limit);
+  const last = items.at(-1);
+  if (documents.length <= limit || !last) {
+    return { items, nextCursor: null };
   }
-  async function hardDeleteMany(filter) {
-    requireFilter("hardDeleteMany", filter);
-    return run(async () => {
-      const result = await collection.deleteMany(filter, {
-        ...sessionOption
+  const values = fields.map((field) => {
+    const value = last[field];
+    if (value === null || value === undefined) {
+      throw new TypeError(`paginateByCursor: "${field}" is null in a document of "${ctx.name}". ` + "Page along a field every document has.");
+    }
+    return value;
+  });
+  return { items, nextCursor: encodeCursor({ key: cursorKey, values }) };
+}
+
+// src/collection/writes.ts
+async function updatedOrThrow(ctx, id, filter, update, expectedVersion) {
+  const updated = await run(ctx, async () => ctx.collection.findOneAndUpdate(filter, update, {
+    ...ctx.sessionOption,
+    returnDocument: "after"
+  }));
+  if (updated)
+    return withId(ctx, updated);
+  if (expectedVersion !== undefined) {
+    const current = await findOne(ctx, { _id: id });
+    if (current) {
+      throw new OptimisticLockError(`Document ${String(id)} of "${ctx.name}" is at version ${String(current.version)}, not ${expectedVersion}: it changed since it was read`, {
+        collection: ctx.name,
+        id,
+        expectedVersion,
+        actualVersion: typeof current.version === "number" ? current.version : undefined
       });
-      return result.deletedCount;
+    }
+  }
+  throw notFound(ctx, id);
+}
+function softDeleteUpdate(ctx) {
+  const set = { deletedAt: new Date };
+  if (ctx.actor !== undefined && ctx.stamps.deletedBy) {
+    set.deletedBy = ctx.actor;
+  }
+  const update = { $set: set };
+  if (ctx.locks)
+    update.$inc = { version: 1 };
+  return update;
+}
+async function create(ctx, values) {
+  const document = toDocument(ctx, values);
+  return run(ctx, async () => {
+    await ctx.collection.insertOne(document, {
+      ...ctx.sessionOption
+    });
+    return withId(ctx, document);
+  });
+}
+async function createMany(ctx, values) {
+  if (values.length === 0)
+    return [];
+  const documents = values.map((value) => toDocument(ctx, value));
+  return run(ctx, async () => {
+    await ctx.collection.insertMany(documents, {
+      ...ctx.sessionOption
     });
+    return documents.map((document) => withId(ctx, document));
+  });
+}
+async function update(ctx, id, patch, opts = {}) {
+  const expectedVersion = opts.expectedVersion;
+  if (expectedVersion !== undefined && !ctx.locks) {
+    throw new TypeError(`update: expectedVersion needs a "version" field, and "${ctx.name}" has none`);
   }
-  const api = {
-    definition,
-    db,
-    raw: collection,
-    session,
-    withSession: (other) => build(db, definition, { ...options, session: other }),
-    as: (who) => build(db, definition, { ...options, actor: who }),
-    sync: (syncOptions = {}) => syncCollection(db, definition, { ...sessionOption, ...syncOptions }),
-    findById,
-    getById,
-    async findFirst(filter, opts = {}) {
-      const [first] = await findMany({ ...opts, filter, limit: 1 });
-      return first;
-    },
-    findMany,
-    async create(values) {
-      const document = toDocument(values);
-      return run(async () => {
-        await collection.insertOne(document, { ...sessionOption });
-        return withId(document);
-      });
-    },
-    async createMany(values) {
-      if (values.length === 0)
-        return [];
-      const documents = values.map(toDocument);
-      return run(async () => {
-        await collection.insertMany(documents, {
-          ...sessionOption
-        });
-        return documents.map((document) => withId(document));
-      });
-    },
-    async update(id, patch, opts = {}) {
-      const expectedVersion = opts.expectedVersion;
-      if (expectedVersion !== undefined && !locks) {
-        throw new TypeError(`update: expectedVersion needs a "version" field, and "${name}" has none`);
-      }
-      const update = toUpdate(patch);
-      const filter = mergeFilters({
-        _id: id,
-        ...expectedVersion === undefined ? {} : { version: expectedVersion }
-      }, live());
-      return updatedOrThrow(id, filter, update, expectedVersion);
-    },
-    async updateMany(filter, patch) {
-      requireFilter("updateMany", filter);
-      const update = toUpdate(patch);
-      return run(async () => {
-        const result = await collection.updateMany(scoped(filter), update, {
-          ...sessionOption
-        });
-        return result.modifiedCount;
-      });
-    },
-    async delete(id) {
-      if (!softDeletes)
-        return hardDelete(id);
-      const set = { deletedAt: new Date };
-      if (actor !== undefined && stamps.deletedBy)
-        set.deletedBy = actor;
-      const update = { $set: set };
-      if (locks)
-        update.$inc = { version: 1 };
-      return updatedOrThrow(id, mergeFilters({ _id: id }, live()), update, undefined);
-    },
-    async deleteMany(filter) {
-      requireFilter("deleteMany", filter);
-      if (!softDeletes)
-        return hardDeleteMany(filter);
-      const set = { deletedAt: new Date };
-      if (actor !== undefined && stamps.deletedBy)
-        set.deletedBy = actor;
-      const update = { $set: set };
-      if (locks)
-        update.$inc = { version: 1 };
-      return run(async () => {
-        const result = await collection.updateMany(scoped(filter), update, {
-          ...sessionOption
-        });
-        return result.modifiedCount;
-      });
-    },
-    hardDelete,
-    hardDeleteMany,
-    async restore(id) {
-      if (!stamps.deletedAt) {
-        throw new TypeError(`restore: "${name}" has no soft delete`);
-      }
-      const set = { deletedAt: null };
-      if (stamps.deletedBy)
-        set.deletedBy = null;
-      if (touches)
-        set.updatedAt = new Date;
-      const update = { $set: set };
-      if (locks)
-        update.$inc = { version: 1 };
-      return updatedOrThrow(id, { _id: id }, update, undefined);
-    },
-    count: countDocuments,
-    async exists(filter, opts = {}) {
-      const found = await findOne(scoped(filter, opts.withDeleted), { _id: 1 });
-      return found !== null && found !== undefined;
-    },
-    async paginate(opts = {}) {
-      const window = pageWindow(opts, maxPageSize);
-      const [items, total] = await Promise.all([
-        findMany({
-          filter: opts.filter,
-          sort: opts.sort ?? { _id: 1 },
-          limit: window.limit,
-          skip: window.skip,
-          withDeleted: opts.withDeleted
-        }),
-        countDocuments(opts.filter, {
-          withDeleted: opts.withDeleted
-        })
-      ]);
-      return toPage(items, total, window);
-    },
-    async paginateByCursor(opts = {}) {
-      const sortField = opts.orderBy ?? "_id";
-      if (!shape[sortField] && sortField !== "_id") {
-        throw new TypeError(`paginateByCursor: "${name}" has no field "${sortField}" in its schema`);
-      }
-      const direction = opts.direction ?? "asc";
-      const fields = sortField === "_id" ? ["_id"] : [sortField, "_id"];
-      const cursorKey = `${sortField}:${direction}`;
-      const limit = cursorLimit(opts.limit, maxPageSize);
-      const past = direction === "asc" ? "$gt" : "$lt";
-      let after;
-      if (opts.after) {
-        const { values } = decodeCursor(opts.after, cursorKey);
-        if (values.length !== fields.length) {
-          throw new DataError(`Invalid cursor: expected ${fields.length} value(s), got ${values.length}`, { collection: name });
-        }
-        after = {
-          $or: fields.map((field, index) => ({
-            ...Object.fromEntries(fields.slice(0, index).map((previous, i) => [previous, values[i]])),
-            [field]: { [past]: values[index] }
-          }))
-        };
-      }
-      const sort = Object.fromEntries(fields.map((field) => [field, direction === "asc" ? 1 : -1]));
-      const documents = await findMany({
-        filter: mergeFilters(isRecord3(opts.filter) ? opts.filter : undefined, after),
-        sort,
-        limit: limit + 1,
-        withDeleted: opts.withDeleted
-      });
-      const items = documents.slice(0, limit);
-      const last = items.at(-1);
-      if (documents.length <= limit || !last) {
-        return { items, nextCursor: null };
-      }
-      const values = fields.map((field) => {
-        const value = last[field];
-        if (value === null || value === undefined) {
-          throw new TypeError(`paginateByCursor: "${field}" is null in a document of "${name}". ` + "Page along a field every document has.");
-        }
-        return value;
-      });
-      return { items, nextCursor: encodeCursor({ key: cursorKey, values }) };
-    }
+  const patched = toUpdate(ctx, patch);
+  const filter = mergeFilters({
+    _id: id,
+    ...expectedVersion === undefined ? {} : { version: expectedVersion }
+  }, live(ctx));
+  return updatedOrThrow(ctx, id, filter, patched, expectedVersion);
+}
+async function updateMany(ctx, filter, patch) {
+  requireFilter(ctx, "updateMany", filter);
+  const patched = toUpdate(ctx, patch);
+  return run(ctx, async () => {
+    const result = await ctx.collection.updateMany(scoped(ctx, filter), patched, { ...ctx.sessionOption });
+    return result.modifiedCount;
+  });
+}
+async function hardDelete(ctx, id) {
+  const deleted = await run(ctx, async () => ctx.collection.findOneAndDelete({ _id: id }, { ...ctx.sessionOption }));
+  if (!deleted)
+    throw notFound(ctx, id);
+  return withId(ctx, deleted);
+}
+async function hardDeleteMany(ctx, filter) {
+  requireFilter(ctx, "hardDeleteMany", filter);
+  return run(ctx, async () => {
+    const result = await ctx.collection.deleteMany(filter, {
+      ...ctx.sessionOption
+    });
+    return result.deletedCount;
+  });
+}
+async function deleteOne(ctx, id) {
+  if (!ctx.softDeletes)
+    return hardDelete(ctx, id);
+  return updatedOrThrow(ctx, id, mergeFilters({ _id: id }, live(ctx)), softDeleteUpdate(ctx), undefined);
+}
+async function deleteMany(ctx, filter) {
+  requireFilter(ctx, "deleteMany", filter);
+  if (!ctx.softDeletes)
+    return hardDeleteMany(ctx, filter);
+  return run(ctx, async () => {
+    const result = await ctx.collection.updateMany(scoped(ctx, filter), softDeleteUpdate(ctx), { ...ctx.sessionOption });
+    return result.modifiedCount;
+  });
+}
+async function restore(ctx, id) {
+  if (!ctx.stamps.deletedAt) {
+    throw new TypeError(`restore: "${ctx.name}" has no soft delete`);
+  }
+  const set = { deletedAt: null };
+  if (ctx.stamps.deletedBy)
+    set.deletedBy = null;
+  if (ctx.touches)
+    set.updatedAt = new Date;
+  const update = { $set: set };
+  if (ctx.locks)
+    update.$inc = { version: 1 };
+  return updatedOrThrow(ctx, id, { _id: id }, update, undefined);
+}
+
+// src/collection/get-collection.ts
+function databaseOf(source, name) {
+  const client = source;
+  if (typeof client.db === "function")
+    return client.db(name);
+  const db = source;
+  if (name !== undefined && db.databaseName !== name) {
+    throw new TypeError(`getCollection: given a Db for "${db.databaseName}", and a db option of ` + `"${name}". Pass the client, or the database you mean.`);
+  }
+  return db;
+}
+function getCollection(source, definition, options = {}) {
+  const db = databaseOf(source, options.db);
+  return build(db, definition, options);
+}
+function apiOf(ctx, rebuild) {
+  return {
+    definition: ctx.definition,
+    db: ctx.db,
+    raw: ctx.collection,
+    session: ctx.session,
+    withSession: (other) => rebuild({ session: other }),
+    as: (who) => rebuild({ actor: who }),
+    sync: (syncOptions = {}) => syncCollection(ctx.db, ctx.definition, {
+      ...ctx.sessionOption,
+      ...syncOptions
+    }),
+    findById: (id, opts) => findById(ctx, id, opts),
+    getById: (id, opts) => getById(ctx, id, opts),
+    findFirst: (filter, opts) => findFirst(ctx, filter, opts),
+    findMany: (opts) => findMany(ctx, opts),
+    create: (values) => create(ctx, values),
+    createMany: (values) => createMany(ctx, values),
+    update: (id, patch, opts) => update(ctx, id, patch, opts),
+    updateMany: (filter, patch) => updateMany(ctx, filter, patch),
+    delete: (id) => deleteOne(ctx, id),
+    deleteMany: (filter) => deleteMany(ctx, filter),
+    hardDelete: (id) => hardDelete(ctx, id),
+    hardDeleteMany: (filter) => hardDeleteMany(ctx, filter),
+    restore: (id) => restore(ctx, id),
+    count: (filter, opts) => countDocuments(ctx, filter, opts),
+    exists: (filter, opts) => exists(ctx, filter, opts),
+    paginate: (opts) => paginate(ctx, opts),
+    paginateByCursor: (opts) => paginateByCursor(ctx, opts)
   };
+}
+function build(db, definition, options) {
+  const ctx = createContext(db, definition, options);
+  const rebuild = (changed) => build(db, definition, { ...options, ...changed });
+  const api = apiOf(ctx, rebuild);
+  const collection = ctx.collection;
   return new Proxy(api, {
     get(target, key, receiver) {
       if (Reflect.has(target, key))
@@ -1157,5 +1208,5 @@ export {
   withTransaction
 };
 
-//# debugId=3B847E76D4AAF66F64756E2164756E21
+//# debugId=AC287DF6F57068F864756E2164756E21
 //# sourceMappingURL=index.js.map