@nxgt/mongo 0.1.0

package/dist/index.js

@@ -0,0 +1,1057 @@
+// 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 } from "mongodb";
+import { z } from "zod";
+function isObjectId(value) {
+  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
+}
+function objectId() {
+  return z.custom(isObjectId, { error: "must be an ObjectId" }).meta({ bsonType: "objectId" });
+}
+function id() {
+  return objectId().default(() => new ObjectId);
+}
+function timestamps() {
+  return {
+    createdAt: z.date().default(() => new Date),
+    updatedAt: z.date().default(() => new Date)
+  };
+}
+function softDelete() {
+  return { deletedAt: z.date().nullable().default(null) };
+}
+function optimisticLock() {
+  return { version: z.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 z2 } 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;
+  }
+}
+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 = z2.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
+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 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);
+}
+function asArray(value) {
+  if (Array.isArray(value))
+    return value;
+  return value === undefined || value === null ? [] : [value];
+}
+function text(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function indexFromMessage(message) {
+  return message?.match(/index:\s*(\S+)\s+dup key/)?.[1];
+}
+function keysOfDuplicate(error) {
+  const pattern = error.keyPattern;
+  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];
+  if (!inMessage)
+    return { keys: [], values: undefined };
+  const keys = [...inMessage.matchAll(/([\w.$]+)\s*:/g)].map((match) => match[1]);
+  return { keys, values: undefined };
+}
+function firstWriteError(error) {
+  for (const write of asArray(error.writeErrors)) {
+    const inner = isRecord2(write) && isRecord2(write.err) ? write.err : write;
+    if (isRecord2(inner))
+      return inner;
+  }
+  return;
+}
+function issuesOf(details, path = []) {
+  const issues = [];
+  for (const rule of asArray(details)) {
+    if (!isRecord2(rule))
+      continue;
+    if (rule.propertiesNotSatisfied !== undefined) {
+      for (const property of asArray(rule.propertiesNotSatisfied)) {
+        if (!isRecord2(property))
+          continue;
+        const name = text(property.propertyName) ?? "";
+        const nested = issuesOf(property.details, [...path, name]);
+        const description = text(property.description);
+        issues.push(...description === undefined ? nested : nested.map((issue) => ({ description, ...issue })));
+      }
+      continue;
+    }
+    if (rule.missingProperties !== undefined) {
+      for (const missing of asArray(rule.missingProperties)) {
+        issues.push({
+          path: [...path, String(missing)].join("."),
+          reason: "required",
+          specifiedAs: rule.specifiedAs
+        });
+      }
+      continue;
+    }
+    if (rule.schemaRulesNotSatisfied !== undefined) {
+      issues.push(...issuesOf(rule.schemaRulesNotSatisfied, path));
+      continue;
+    }
+    issues.push({
+      path: path.join("."),
+      reason: text(rule.reason) ?? text(rule.operatorName) ?? "invalid",
+      ...rule.specifiedAs === undefined ? {} : { specifiedAs: rule.specifiedAs },
+      ...rule.consideredValue === undefined ? {} : { consideredValue: rule.consideredValue },
+      ...text(rule.consideredType) === undefined ? {} : { consideredType: text(rule.consideredType) }
+    });
+  }
+  return issues;
+}
+function toDataError(error, context = {}) {
+  if (error instanceof DataError)
+    return 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;
+  if (typeof code !== "number")
+    return error;
+  const message = text(source.errmsg) ?? text(source.message) ?? text(error.message) ?? "";
+  const common = {
+    collection: context.collection,
+    serverCode: code,
+    serverCodeName: text(error.codeName) ?? text(source.codeName),
+    cause: error
+  };
+  if (code === 11000) {
+    const { keys, values } = keysOfDuplicate(source);
+    const index = indexFromMessage(message);
+    const named = keys.length > 0 ? keys.join(", ") : index ?? "a unique index";
+    return new ConflictError(`Duplicate key on ${named}${context.collection ? ` in "${context.collection}"` : ""}`, { ...common, index, keys, values });
+  }
+  if (code === 121) {
+    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 as ObjectId2 } 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 ObjectId2(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,
+  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);
+  }
+  return diff;
+}
+
+// src/sync/validator-diff.ts
+function canonical2(value) {
+  return JSON.stringify(value ?? null, (_name, inner) => inner && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a < b ? -1 : 1)) : inner);
+}
+function hasValidator(live) {
+  return live.validator !== undefined && Object.keys(live.validator).length > 0;
+}
+function validationMatches(wanted, live) {
+  if (wanted.validator === undefined)
+    return !hasValidator(live);
+  if (!hasValidator(live))
+    return false;
+  return canonical2(live.validator) === canonical2(wanted.validator) && (live.validationLevel ?? "strict") === wanted.level && (live.validationAction ?? "error") === wanted.action;
+}
+
+// src/sync/sync-collection.ts
+function serverCode(error) {
+  const code = error?.code;
+  return typeof code === "number" ? code : undefined;
+}
+async function collectionOptions(db, name, session) {
+  const [info] = await db.listCollections({ name }, { ...session ? { session } : {}, nameOnly: false }).toArray();
+  return info ? info.options ?? {} : undefined;
+}
+async function liveIndexes(db, name, session) {
+  try {
+    return await db.collection(name).indexes({ session });
+  } catch (error) {
+    if (serverCode(error) === 26)
+      return [];
+    throw error;
+  }
+}
+function validationFor(definition) {
+  const { level, action } = definition.validation;
+  return {
+    validator: level === "off" ? undefined : { $jsonSchema: toMongoJsonSchema(definition.schema) },
+    level,
+    action
+  };
+}
+function creationOptions(wanted) {
+  return wanted.validator === undefined ? {} : {
+    validator: wanted.validator,
+    validationLevel: wanted.level,
+    validationAction: wanted.action
+  };
+}
+async function writeValidation(db, name, wanted, session) {
+  try {
+    await db.command({
+      collMod: name,
+      validator: wanted.validator ?? {},
+      ...wanted.validator === undefined ? {} : { validationLevel: wanted.level, validationAction: wanted.action }
+    }, session ? { session } : undefined);
+  } catch (error) {
+    if (serverCode(error) === 13) {
+      throw new DataError(`sync: not allowed to run collMod on "${name}". Writing a validator ` + "needs the `collMod` action, which `readWrite` does not grant and " + "`dbAdmin` does: sync with a role that has it, not with the " + "application’s own user.", { collection: name, serverCode: 13, cause: error });
+    }
+    throw toDataError(error, { collection: name });
+  }
+}
+async function syncCollection(db, definition, options = {}) {
+  const { name } = definition;
+  const dryRun = options.dryRun ?? false;
+  const session = options.session;
+  const wanted = validationFor(definition);
+  let live = await collectionOptions(db, name, session);
+  let created = false;
+  let validator = "unchanged";
+  if (!live) {
+    created = true;
+    if (wanted.validator !== undefined)
+      validator = "created";
+    if (!dryRun) {
+      try {
+        await db.createCollection(name, {
+          ...creationOptions(wanted),
+          ...session ? { session } : {}
+        });
+      } catch (error) {
+        if (serverCode(error) !== 48) {
+          throw toDataError(error, { collection: name });
+        }
+        created = false;
+        validator = "unchanged";
+        live = await collectionOptions(db, name, session);
+      }
+    }
+  }
+  if (live && !validationMatches(wanted, live)) {
+    validator = wanted.validator === undefined ? "removed" : hasValidator(live) ? "updated" : "created";
+    if (!dryRun)
+      await writeValidation(db, name, wanted, session);
+  }
+  const existing = dryRun && created ? [] : await liveIndexes(db, name, session);
+  const diff = diffIndexes(definition.indexes, existing);
+  const dropped = options.dropUnknownIndexes ? diff.extra : [];
+  const build = [...diff.create, ...diff.recreate];
+  if (!dryRun) {
+    const collection = db.collection(name);
+    for (const index of [
+      ...diff.recreate.map((i) => normalizeIndex(i).name),
+      ...dropped
+    ]) {
+      await collection.dropIndex(index, session ? { session } : undefined);
+    }
+    if (build.length > 0) {
+      try {
+        await collection.createIndexes(build, session ? { session } : undefined);
+      } catch (error) {
+        throw toDataError(error, { collection: name });
+      }
+    }
+  }
+  return {
+    name,
+    created,
+    validator,
+    indexes: {
+      created: diff.create.map((index) => normalizeIndex(index).name),
+      recreated: diff.recreate.map((index) => normalizeIndex(index).name),
+      dropped,
+      unchanged: diff.unchanged
+    },
+    dryRun
+  };
+}
+async function syncCollections(db, definitions, options = {}) {
+  const reports = [];
+  for (const definition of definitions) {
+    reports.push(await syncCollection(db, definition, options));
+  }
+  return reports;
+}
+
+// src/repository/create-repository.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 createRepository(db, definition, options = {}) {
+  return build(db, definition, options);
+}
+function build(db, definition, options) {
+  const name = definition.name;
+  const collection = db.collection(name);
+  const shape = definition.schema.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`);
+  }
+  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 notFound = (id) => new NotFoundError(`No document in "${name}" with _id ${String(id)}`, {
+    collection: name,
+    id
+  });
+  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 (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;
+      }
+    }
+    if (touches && set.updatedAt === undefined)
+      set.updatedAt = new Date;
+    if (actor !== undefined && stamps.updatedBy && set.updatedBy === undefined) {
+      set.updatedBy = 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 update;
+  };
+  const findOne = async (filter, projection) => run(async () => collection.findOne(filter, {
+    ...sessionOption,
+    ...projection ? { projection } : {}
+  }));
+  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);
+      return cursor.toArray();
+    });
+  }
+  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 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
+        });
+      }
+    }
+    throw notFound(id);
+  }
+  async function hardDelete(id) {
+    const deleted = await run(async () => collection.findOneAndDelete({ _id: id }, { ...sessionOption }));
+    if (!deleted)
+      throw notFound(id);
+    return deleted;
+  }
+  async function hardDeleteMany(filter) {
+    requireFilter("hardDeleteMany", filter);
+    return run(async () => {
+      const result = await collection.deleteMany(filter, {
+        ...sessionOption
+      });
+      return result.deletedCount;
+    });
+  }
+  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 document;
+      });
+    },
+    async createMany(values) {
+      if (values.length === 0)
+        return [];
+      const documents = values.map(toDocument);
+      return run(async () => {
+        await collection.insertMany(documents, {
+          ...sessionOption
+        });
+        return documents;
+      });
+    },
+    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 }) };
+    }
+  };
+  return repository;
+}
+// src/transaction/with-transaction.ts
+function isSession(host) {
+  return typeof host.inTransaction === "function";
+}
+async function withTransaction(host, fn, options) {
+  try {
+    if (isSession(host)) {
+      if (host.inTransaction()) {
+        if (options) {
+          throw new TypeError("withTransaction: this session is already in a transaction, which " + "this call joins. MongoDB has no savepoints, so the read " + "concern, the write concern and the read preference are the " + "outer transaction’s.");
+        }
+        return await fn(host);
+      }
+      return await host.withTransaction(fn, options);
+    }
+    const session = host.startSession();
+    try {
+      return await session.withTransaction(fn, options);
+    } finally {
+      await session.endSession();
+    }
+  } catch (error) {
+    throw toDataError(error);
+  }
+}
+export {
+  ConflictError,
+  DEFAULT_MAX_PAGE_SIZE,
+  DEFAULT_PAGE_SIZE,
+  DataError,
+  InvalidCursorError,
+  MONGO_JSON_SCHEMA_KEYWORDS,
+  NotFoundError,
+  OptimisticLockError,
+  STAMP_FIELDS,
+  ValidationError,
+  actors,
+  createRepository,
+  cursorLimit,
+  decodeCursor,
+  defineCollection,
+  diffIndexes,
+  encodeCursor,
+  hasValidator,
+  id,
+  indexMatches,
+  indexNameOf,
+  normalizeIndex,
+  objectId,
+  optimisticLock,
+  pageWindow,
+  softDelete,
+  stampsOf,
+  syncCollection,
+  syncCollections,
+  timestamps,
+  toDataError,
+  toMongoJsonSchema,
+  toPage,
+  validationMatches,
+  withTransaction
+};
+
+//# debugId=44372BBBC1BF50A464756E2164756E21
+//# sourceMappingURL=index.js.map