@nxgt/mongo 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,185 +1,5 @@
-// 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 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")
-  };
-}
-// src/definition/fields.ts
-import { ObjectId as ObjectId2 } from "mongodb";
-import { z as z2 } from "zod";
-
-// src/definition/object-id.ts
-import { ObjectId } from "mongodb";
-import { z } from "zod";
-
-// src/errors/data-error.ts
-class DataError extends Error {
-  constructor(message = "Database error", options = {}) {
-    super(message, options.cause === undefined ? undefined : { cause: options.cause });
-    this.name = "DataError";
-    this.code = "DATABASE";
-    this.collection = options.collection;
-    this.id = options.id;
-    this.serverCode = options.serverCode;
-    this.serverCodeName = options.serverCodeName;
-    this.index = options.index;
-    this.keys = options.keys ?? [];
-    this.values = options.values;
-    this.issues = options.issues ?? [];
-    this.expectedVersion = options.expectedVersion;
-    this.actualVersion = options.actualVersion;
-  }
-}
-
-class NotFoundError extends DataError {
-  constructor(message = "Not found", options = {}) {
-    super(message, options);
-    this.name = "NotFoundError";
-    this.code = "NOT_FOUND";
-  }
-}
-
-class ConflictError extends DataError {
-  constructor(message = "Duplicate key", options = {}) {
-    super(message, { serverCode: 11000, ...options });
-    this.name = "ConflictError";
-    this.code = "CONFLICT";
-  }
-}
-
-class ValidationError extends DataError {
-  constructor(message = "Document failed validation", options = {}) {
-    super(message, { serverCode: 121, ...options });
-    this.name = "ValidationError";
-    this.code = "VALIDATION";
-  }
-}
-
-class OptimisticLockError extends DataError {
-  constructor(message = "Version conflict", options = {}) {
-    super(message, options);
-    this.name = "OptimisticLockError";
-    this.code = "OPTIMISTIC_LOCK";
-  }
-}
-
-class InvalidIdError extends DataError {
-  constructor(message = "Invalid id", options = {}) {
-    super(message, options);
-    this.name = "InvalidIdError";
-    this.code = "INVALID_ID";
-  }
-}
-
-class InvalidCursorError extends DataError {
-  constructor(message = "Invalid cursor", options = {}) {
-    super(message, options);
-    this.name = "InvalidCursorError";
-    this.code = "INVALID_CURSOR";
-  }
-}
-
-// src/definition/object-id.ts
-var HEX_24 = /^[0-9a-fA-F]{24}$/;
-function isObjectId(value) {
-  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
-}
-function isObjectIdString(value) {
-  return typeof value === "string" && HEX_24.test(value);
-}
-function isValidObjectId(value) {
-  return isObjectId(value) || isObjectIdString(value);
-}
-function tryObjectId(value) {
-  if (isObjectId(value))
-    return value;
-  if (isObjectIdString(value))
-    return ObjectId.createFromHexString(value);
-  return;
-}
-function describe(value) {
-  if (value === null)
-    return "null";
-  if (value === undefined)
-    return "undefined";
-  if (typeof value === "string")
-    return `the string ${JSON.stringify(value)}`;
-  return `a ${typeof value}`;
-}
-function toObjectId(value, field = "_id") {
-  const made = tryObjectId(value);
-  if (made)
-    return made;
-  throw new InvalidIdError(`${field}: expected an ObjectId or its 24-character hex string, got ${describe(value)}`, { id: value, keys: [field] });
-}
-function toObjectIds(values, field = "_id") {
-  return [...values].map((value) => toObjectId(value, field));
-}
-function objectIdParam() {
-  return z.custom(isValidObjectId, {
-    error: "must be an ObjectId or its 24-character hex string"
-  }).transform((value) => toObjectId(value));
-}
-
-// src/definition/fields.ts
-function objectId() {
-  return z2.custom(isObjectId, { error: "must be an ObjectId" }).meta({ bsonType: "objectId" });
-}
-function id() {
-  return objectId().default(() => new ObjectId2);
-}
-function timestamps() {
-  return {
-    createdAt: z2.date().default(() => new Date),
-    updatedAt: z2.date().default(() => new Date)
-  };
-}
-function softDelete() {
-  return { deletedAt: z2.date().nullable().default(null) };
-}
-function optimisticLock() {
-  return { version: z2.int().nonnegative().default(0) };
-}
-function actors(actor = objectId()) {
-  return {
-    createdBy: actor.nullable().default(null),
-    updatedBy: actor.nullable().default(null),
-    deletedBy: actor.nullable().default(null)
-  };
-}
-var STAMP_FIELDS = {
-  id: "_id",
-  createdAt: "createdAt",
-  updatedAt: "updatedAt",
-  deletedAt: "deletedAt",
-  version: "version",
-  createdBy: "createdBy",
-  updatedBy: "updatedBy",
-  deletedBy: "deletedBy"
-};
 // src/definition/json-schema.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 var MONGO_JSON_SCHEMA_KEYWORDS = new Set([
   "additionalItems",
   "additionalProperties",
@@ -279,7 +99,7 @@ function inline(value, defs, stack) {
   return out;
 }
 function toMongoJsonSchema(schema) {
-  const json = z3.toJSONSchema(schema, {
+  const json = z.toJSONSchema(schema, {
     target: "draft-4",
     io: "output",
     unrepresentable: "any",
@@ -293,6 +113,74 @@ function toMongoJsonSchema(schema) {
   const definitions = isRecord(json.definitions) ? json.definitions : isRecord(json.$defs) ? json.$defs : {};
   return inline(json, definitions, []);
 }
+
+// src/errors/data-error.ts
+class DataError extends Error {
+  constructor(message = "Database error", options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "DataError";
+    this.code = "DATABASE";
+    this.collection = options.collection;
+    this.id = options.id;
+    this.serverCode = options.serverCode;
+    this.serverCodeName = options.serverCodeName;
+    this.index = options.index;
+    this.keys = options.keys ?? [];
+    this.values = options.values;
+    this.issues = options.issues ?? [];
+    this.expectedVersion = options.expectedVersion;
+    this.actualVersion = options.actualVersion;
+  }
+}
+
+class NotFoundError extends DataError {
+  constructor(message = "Not found", options = {}) {
+    super(message, options);
+    this.name = "NotFoundError";
+    this.code = "NOT_FOUND";
+  }
+}
+
+class ConflictError extends DataError {
+  constructor(message = "Duplicate key", options = {}) {
+    super(message, { serverCode: 11000, ...options });
+    this.name = "ConflictError";
+    this.code = "CONFLICT";
+  }
+}
+
+class ValidationError extends DataError {
+  constructor(message = "Document failed validation", options = {}) {
+    super(message, { serverCode: 121, ...options });
+    this.name = "ValidationError";
+    this.code = "VALIDATION";
+  }
+}
+
+class OptimisticLockError extends DataError {
+  constructor(message = "Version conflict", options = {}) {
+    super(message, options);
+    this.name = "OptimisticLockError";
+    this.code = "OPTIMISTIC_LOCK";
+  }
+}
+
+class InvalidIdError extends DataError {
+  constructor(message = "Invalid id", options = {}) {
+    super(message, options);
+    this.name = "InvalidIdError";
+    this.code = "INVALID_ID";
+  }
+}
+
+class InvalidCursorError extends DataError {
+  constructor(message = "Invalid cursor", options = {}) {
+    super(message, options);
+    this.name = "InvalidCursorError";
+    this.code = "INVALID_CURSOR";
+  }
+}
+
 // src/errors/to-data-error.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -397,95 +285,7 @@ function toDataError(error, context = {}) {
   }
   return new DataError(message || `MongoDB error ${code}`, common);
 }
-// src/pagination/cursor.ts
-import { ObjectId as ObjectId3 } from "mongodb";
-function isObjectId2(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 (isObjectId2(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 ObjectId3(tagged.$oid);
-    }
-  }
-  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/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/sync/index-diff.ts
 var COLLATION_DEFAULTS = {
   caseLevel: false,
@@ -709,7 +509,167 @@ async function syncCollections(db, definitions, options = {}) {
   return reports;
 }
 
-// src/repository/create-repository.ts
+// 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 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")
+  };
+}
+
+// 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 shape = definition.schema.shape;
+  const stamps = stampsOf(definition);
+  const session = options.session;
+  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`);
+  }
+  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
+  };
+}
+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);
+    }
+  }
+  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);
 }
@@ -725,343 +685,458 @@ function mergeFilters(a, b) {
     return left;
   return { $and: [left, right] };
 }
-function createRepository(db, definition, options = {}) {
-  return build(db, definition, options);
+function live(ctx, withDeleted) {
+  return ctx.softDeletes && !withDeleted ? { deletedAt: null } : undefined;
 }
-function build(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(`createRepository: softDelete needs a "deletedAt" field, and "${name}" has none`);
-  }
-  if (options.optimisticLock === true && !stamps.version) {
-    throw new TypeError(`createRepository: optimisticLock needs a "version" field, and "${name}" has none`);
+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}".`);
   }
-  const run = async (fn) => {
-    try {
-      return await fn();
-    } catch (error) {
-      throw toDataError(error, { collection: name });
-    }
-  };
-  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;
-    }
-    Object.defineProperty(document, "id", {
-      get: () => String(document._id),
-      enumerable: true,
-      configurable: true
-    });
+}
+
+// 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 repository = {
-    definition,
-    db,
-    collection,
-    session,
-    with: (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);
+  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))
+        return Reflect.get(target, key, receiver);
+      const value = collection[key];
+      return typeof value === "function" ? value.bind(collection) : value;
     },
-    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 }) };
+    has(target, key) {
+      return Reflect.has(target, key) || key in collection;
     }
+  });
+}
+// src/definition/fields.ts
+import { ObjectId as ObjectId3 } from "mongodb";
+import { z as z3 } from "zod";
+
+// src/definition/object-id.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+import { z as z2 } from "zod";
+var HEX_24 = /^[0-9a-fA-F]{24}$/;
+function isObjectId2(value) {
+  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
+}
+function isObjectIdString(value) {
+  return typeof value === "string" && HEX_24.test(value);
+}
+function isValidObjectId(value) {
+  return isObjectId2(value) || isObjectIdString(value);
+}
+function tryObjectId(value) {
+  if (isObjectId2(value))
+    return value;
+  if (isObjectIdString(value))
+    return ObjectId2.createFromHexString(value);
+  return;
+}
+function describe(value) {
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  if (typeof value === "string")
+    return `the string ${JSON.stringify(value)}`;
+  return `a ${typeof value}`;
+}
+function toObjectId(value, field = "_id") {
+  const made = tryObjectId(value);
+  if (made)
+    return made;
+  throw new InvalidIdError(`${field}: expected an ObjectId or its 24-character hex string, got ${describe(value)}`, { id: value, keys: [field] });
+}
+function toObjectIds(values, field = "_id") {
+  return [...values].map((value) => toObjectId(value, field));
+}
+function objectIdParam() {
+  return z2.custom(isValidObjectId, {
+    error: "must be an ObjectId or its 24-character hex string"
+  }).transform((value) => toObjectId(value));
+}
+
+// src/definition/fields.ts
+function objectId() {
+  return z3.custom(isObjectId2, { error: "must be an ObjectId" }).meta({ bsonType: "objectId" });
+}
+function id() {
+  return objectId().default(() => new ObjectId3);
+}
+function timestamps() {
+  return {
+    createdAt: z3.date().default(() => new Date),
+    updatedAt: z3.date().default(() => new Date)
   };
-  return repository;
 }
+function softDelete() {
+  return { deletedAt: z3.date().nullable().default(null) };
+}
+function optimisticLock() {
+  return { version: z3.int().nonnegative().default(0) };
+}
+function actors(actor = objectId()) {
+  return {
+    createdBy: actor.nullable().default(null),
+    updatedBy: actor.nullable().default(null),
+    deletedBy: actor.nullable().default(null)
+  };
+}
+var STAMP_FIELDS = {
+  id: "_id",
+  createdAt: "createdAt",
+  updatedAt: "updatedAt",
+  deletedAt: "deletedAt",
+  version: "version",
+  createdBy: "createdBy",
+  updatedBy: "updatedBy",
+  deletedBy: "deletedBy"
+};
 // src/transaction/with-transaction.ts
 function isSession(host) {
   return typeof host.inTransaction === "function";
@@ -1100,17 +1175,17 @@ export {
   STAMP_FIELDS,
   ValidationError,
   actors,
-  createRepository,
   cursorLimit,
   decodeCursor,
   defineCollection,
   diffIndexes,
   encodeCursor,
+  getCollection,
   hasValidator,
   id,
   indexMatches,
   indexNameOf,
-  isObjectId,
+  isObjectId2 as isObjectId,
   isObjectIdString,
   isValidObjectId,
   normalizeIndex,
@@ -1133,5 +1208,5 @@ export {
   withTransaction
 };
 
-//# debugId=5C569B791BADEA5664756E2164756E21
+//# debugId=AC287DF6F57068F864756E2164756E21
 //# sourceMappingURL=index.js.map