@alexify/migronaut 2.1.0 → 2.3.0

package/src/versioning/document.js

@@ -0,0 +1,326 @@
+const { ConfigInvalidError, ShapeVersionError } = require('../errors/index.js');
+const { VERSIONING_DEFAULTS, fieldNameIssue, versioningOf } = require('./config.js');
+const {
+  cloneDocument,
+  isPlainObject,
+  sameValue,
+  setOwn,
+  toCount,
+  touchedFields,
+} = require('./internal.js');
+
+/**
+ * The document-level contract shared by everything that writes a versioned
+ * collection — the repository helpers, the Mongoose plugin and the
+ * background-migration engine. They must agree on one model, or a background
+ * update would silently overwrite an application write:
+ *
+ * - a missing (or `null`) version or revision field reads as **0**, so legacy
+ *   documents need no backfill before the first guarded write;
+ * - every write to a collection with revisions bumps the revision by one
+ *   (`$inc`), so an optimistic-concurrency filter `{ _id, rev }` notices any
+ *   write that happened in between;
+ * - the version is set to an exact number, never incremented — two releases
+ *   writing the same shape agree on it.
+ *
+ * `names` below is `{ field, revisionField }` from `resolveFieldNames` (or a
+ * resolved `versioning`); `revisionField` is `null` when revisions are off.
+ */
+
+/**
+ * The system field names, validated: `{ field, revisionField }` with the
+ * defaults filled in and `revisionField: null` under `revision: false`.
+ *
+ * @throws {ConfigInvalidError} on an invalid name, or both naming one field
+ */
+function resolveFieldNames({ field, revisionField, revision } = {}) {
+  const versionName = field ?? VERSIONING_DEFAULTS.field;
+  const revisionName =
+    revision === false ? null : (revisionField ?? VERSIONING_DEFAULTS.revisionField);
+  for (const [key, name] of [
+    ['field', versionName],
+    ['revisionField', revisionName],
+  ]) {
+    if (name === null) continue;
+    const issue = fieldNameIssue(name);
+    if (issue) throw new ConfigInvalidError(`${key} ${issue}`, { key });
+  }
+  if (versionName === revisionName) {
+    throw new ConfigInvalidError('field and revisionField must differ', { key: 'revisionField' });
+  }
+  return { field: versionName, revisionField: revisionName };
+}
+
+/** A document's count field: 0 when missing or `null`, `null` when not a non-negative integer */
+function countOf(doc, field) {
+  if (!isPlainObject(doc)) return null;
+  const value = doc[field];
+  return value === undefined || value === null ? 0 : toCount(value);
+}
+
+/** The shape version of `doc` — 0 when the field is missing, `null` when it is not a count */
+const versionOf = (doc, field = VERSIONING_DEFAULTS.field) => countOf(doc, field);
+
+/** The revision of `doc` — 0 when the field is missing, `null` when it is not a count */
+const revisionOf = (doc, revisionField = VERSIONING_DEFAULTS.revisionField) =>
+  countOf(doc, revisionField);
+
+/**
+ * Whether `doc` is at exactly `version` — a missing or `null` field is
+ * version 0. A document that is not a plain object (a hydrated Mongoose
+ * document) is refused: its fields are not its own properties, and a silent
+ * `false` would read as "an old shape".
+ */
+function isVersion(doc, version, { field = VERSIONING_DEFAULTS.field } = {}) {
+  if (doc === null || doc === undefined) return false;
+  assertPlainDocument(doc);
+  return versionOf(doc, field) === version;
+}
+
+/** A plain document, or a ConfigInvalidError that says how to get one */
+function assertPlainDocument(doc) {
+  if (!isPlainObject(doc)) {
+    throw new ConfigInvalidError(
+      'A plain document is expected — read it with .lean(), or call .toObject() on a Mongoose ' +
+        'document',
+    );
+  }
+}
+
+/**
+ * The revision field alone, validated (`__rev` by default) — for a write
+ * that never sets the version, whose field name it then has no use for: a
+ * caller naming only its revision field (`__v`, as a Mongoose app may keep
+ * it) is not refused over a version field it never touches.
+ */
+function resolveRevisionField(revisionField) {
+  const name = revisionField ?? VERSIONING_DEFAULTS.revisionField;
+  const issue = fieldNameIssue(name);
+  if (issue) throw new ConfigInvalidError(`revisionField ${issue}`, { key: 'revisionField' });
+  return name;
+}
+
+/** The revision after one more write */
+const nextRevision = (revision) => (toCount(revision) ?? 0) + 1;
+
+function assertCount(value, what) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new ConfigInvalidError(`${what} must be an integer ≥ 0`, { [what]: value });
+  }
+}
+
+/** `{ [field]: n }`, or — for 0 — a match on the field being 0, `null` or missing */
+function countFilter(field, value) {
+  return value === 0 ? { [field]: { $in: [null, 0] } } : { [field]: value };
+}
+
+/** Documents at exactly `version` (0 = no version field) */
+function versionFilter(names, version) {
+  assertCount(version, 'version');
+  return countFilter(names.field, version);
+}
+
+/** Documents at exactly `revision` (0 = no revision field) */
+function revisionFilter(names, revision) {
+  assertCount(revision, 'revision');
+  return countFilter(names.revisionField, revision);
+}
+
+/**
+ * Documents below `version`: missing or `null` fields, smaller numbers, and
+ * anything that is not a number at all (which no validator would accept
+ * either). One `$not` range — two intervals of one index scan — rather than
+ * an `$or`. `null` for version 0: nothing is below it.
+ */
+function belowVersionFilter(names, version) {
+  assertCount(version, 'version');
+  return version === 0 ? null : { [names.field]: { $not: { $gte: version } } };
+}
+
+/** The key of the index every version-filtered scan uses */
+const versionIndexKey = (names) => ({ [names.field]: 1, _id: 1 });
+
+/**
+ * The optimistic-concurrency filter for rewriting `prev`: its `_id`, the
+ * exact version it was read at (`from`, by default its own) and — with
+ * revisions — the exact revision. A concurrent write moves the revision (or
+ * the version), so the rewrite then matches nothing instead of losing it.
+ */
+function occFilter(prev, names, { from } = {}) {
+  const version = from ?? versionOf(prev, names.field);
+  const filter = { _id: prev._id };
+  // A value that is not a count is matched as it is stored — `$eq`, so a
+  // stored object with `$`-keys is never read as an operator.
+  if (version === null) filter[names.field] = { $eq: prev[names.field] };
+  else Object.assign(filter, countFilter(names.field, version));
+  if (names.revisionField !== null) {
+    const revision = revisionOf(prev, names.revisionField);
+    if (revision === null) filter[names.revisionField] = { $eq: prev[names.revisionField] };
+    else Object.assign(filter, countFilter(names.revisionField, revision));
+  }
+  return filter;
+}
+
+/** Why `key` cannot be written as a top-level field with `$set`, or `null` */
+function topLevelKeyIssue(key) {
+  if (key.length === 0) return 'an empty field name';
+  if (key.startsWith('$')) return `a field name starting with '$' ("${key}")`;
+  if (key.includes('.')) return `a field name with a dot ("${key}")`;
+  if (key.includes('\0')) return 'a field name with NUL';
+  return null;
+}
+
+function invalidShape(detail, extra) {
+  return new ShapeVersionError(`The transformation returned ${detail}`, {
+    reason: 'invalid',
+    ...extra,
+  });
+}
+
+const hasKeys = (object) => {
+  for (const key in object) if (Object.hasOwn(object, key)) return true;
+  return false;
+};
+
+/**
+ * The operator update that turns `prev` into `next` and stamps it: `$set`
+ * for every top-level field whose BSON value changed, `$unset` for every one
+ * that disappeared (or became `undefined`), the version set to `to` (unset
+ * for `to: 0`), and the revision bumped.
+ *
+ * Fields that did not change are left out — so the stored BSON type of
+ * everything a transformation did not touch survives (a document read with
+ * promoted values and written back whole would turn a `Double 1.0` into an
+ * `Int32`, a `Long` into a number). A changed nested field rewrites its
+ * whole top-level subdocument. `next`'s own version and revision fields are
+ * ignored: the engine owns them.
+ *
+ * @throws {ShapeVersionError} (`reason: 'invalid'`) when `next` is not a
+ *   document, changes `_id`, or names a field `$set` cannot write
+ */
+function stampedDiff(prev, next, names, { to }) {
+  if (!isPlainObject(next)) throw invalidShape('something that is not a document');
+  assertCount(to, 'to');
+  const { field, revisionField } = names;
+  const $set = {};
+  const $unset = {};
+  for (const key of Object.keys(next)) {
+    if (key === '_id') {
+      if (!sameValue(prev._id, next._id)) throw invalidShape('a document with a different _id');
+      continue;
+    }
+    if (key === field || key === revisionField) continue;
+    const issue = topLevelKeyIssue(key);
+    if (issue) throw invalidShape(issue, { field: key });
+    const value = next[key];
+    if (value === undefined) {
+      if (Object.hasOwn(prev, key)) setOwn($unset, key, '');
+    } else if (!Object.hasOwn(prev, key) || !sameValue(prev[key], value)) {
+      setOwn($set, key, value);
+    }
+  }
+  for (const key of Object.keys(prev)) {
+    if (key === '_id' || key === field || key === revisionField) continue;
+    if (!Object.hasOwn(next, key)) setOwn($unset, key, '');
+  }
+  if (to === 0) $unset[field] = '';
+  else $set[field] = to;
+  const update = {};
+  if (hasKeys($set)) update.$set = $set;
+  if (hasKeys($unset)) update.$unset = $unset;
+  if (revisionField !== null) update.$inc = { [revisionField]: 1 };
+  return update;
+}
+
+function refuseTouch(fields, name, role) {
+  if (name !== null && fields.has(name)) {
+    throw new ConfigInvalidError(
+      `The update must not write the ${role} field "${name}" — migronaut sets it`,
+      { field: name },
+    );
+  }
+}
+
+/**
+ * Stamp an update the caller wrote: the version set to `to` (left alone when
+ * `to` is `undefined`; unset for 0) and the revision bumped. Works on an
+ * operator update (merged into its `$set`/`$unset`/`$inc`) and on a pipeline
+ * (one stage appended). A replacement document — or a pipeline that projects
+ * or replaces the root — is refused: it would drop the revision.
+ *
+ * @throws {ConfigInvalidError} on a replacement, or an update that writes a
+ *   system field itself
+ */
+function stampedUpdate(names, { to, update }) {
+  const { field, revisionField } = names;
+  if (to !== undefined) assertCount(to, 'to');
+  if (!Array.isArray(update) && !isPlainObject(update)) {
+    throw new ConfigInvalidError('The update must be an update document or a pipeline');
+  }
+  const touched = touchedFields(update);
+  if (touched.whole) {
+    throw new ConfigInvalidError(
+      Array.isArray(update)
+        ? 'A pipeline that projects or replaces the document cannot keep its revision'
+        : 'A replacement document is not an update — use replaceWithRevision',
+    );
+  }
+  refuseTouch(touched.fields, revisionField, 'revision');
+  if (to !== undefined) refuseTouch(touched.fields, field, 'version');
+
+  if (Array.isArray(update)) {
+    const stage = {};
+    if (to !== undefined && to !== 0) stage[field] = { $literal: to };
+    if (revisionField !== null) {
+      stage[revisionField] = { $add: [{ $ifNull: [`$${revisionField}`, 0] }, 1] };
+    }
+    const out = [...update];
+    if (hasKeys(stage)) out.push({ $set: stage });
+    if (to === 0) out.push({ $unset: field });
+    return out;
+  }
+  const out = { ...update };
+  if (to === 0) out.$unset = { ...update.$unset, [field]: '' };
+  else if (to !== undefined) out.$set = { ...update.$set, [field]: to };
+  if (revisionField !== null) out.$inc = { ...update.$inc, [revisionField]: 1 };
+  return out;
+}
+
+/**
+ * `doc` with its version set to `version` and its revision to 0 — each only
+ * when the document does not carry it yet, so stamping is idempotent and a
+ * document someone already stamped keeps its fields.
+ */
+function stampDocument(doc, names, version) {
+  if (!isPlainObject(doc)) throw new ConfigInvalidError('Only a plain document can be stamped');
+  assertCount(version, 'version');
+  const out = { ...doc };
+  if (out[names.field] === undefined) out[names.field] = version;
+  if (names.revisionField !== null && out[names.revisionField] === undefined) {
+    out[names.revisionField] = 0;
+  }
+  return out;
+}
+
+module.exports = {
+  assertPlainDocument,
+  belowVersionFilter,
+  cloneDocument,
+  fieldNameIssue,
+  isVersion,
+  nextRevision,
+  occFilter,
+  refuseTouch,
+  resolveFieldNames,
+  resolveRevisionField,
+  revisionFilter,
+  revisionOf,
+  sameValue,
+  stampDocument,
+  stampedDiff,
+  stampedUpdate,
+  versionFilter,
+  versionIndexKey,
+  versionOf,
+  versioningOf,
+};

package/src/versioning/index.js

@@ -0,0 +1,50 @@
+const {
+  ConfigInvalidError,
+  MigronautError,
+  RevisionConflictError,
+  ShapeVersionError,
+} = require('../errors/index.js');
+const {
+  bumpRevision,
+  findOneAndUpdateWithRevision,
+  replaceWithRevision,
+  retryOnConflict,
+  updateWithRevision,
+} = require('./occ.js');
+const { isVersion } = require('./document.js');
+const { versioningPlugin } = require('./mongoose.js');
+const { defineShapes } = require('./registry.js');
+const { upcaster } = require('./upcaster.js');
+
+/**
+ * `@alexify/migronaut/versioning` — document versioning and optimistic
+ * concurrency for an application's repository layer.
+ *
+ * Deliberately small: it requires nothing but its own modules and the error
+ * classes — not the migration engine, not the driver, not mongoose — so a
+ * service that only reads and writes documents pays for nothing else. The
+ * error classes are the package root's own, so `instanceof` agrees whichever
+ * entry point a caller imports them from.
+ */
+module.exports = {
+  // The application's view of its versioned collections
+  defineShapes,
+  upcaster,
+  isVersion,
+
+  // Optimistic concurrency
+  updateWithRevision,
+  replaceWithRevision,
+  findOneAndUpdateWithRevision,
+  retryOnConflict,
+  bumpRevision,
+
+  // Mongoose
+  versioningPlugin,
+
+  // Errors — the same classes the package root exports
+  MigronautError,
+  ConfigInvalidError,
+  RevisionConflictError,
+  ShapeVersionError,
+};

package/src/versioning/internal.js

@@ -0,0 +1,279 @@
+/**
+ * Small value helpers shared by the versioning runtime. This directory is the
+ * `@alexify/migronaut/versioning` subpath: it may require its siblings and
+ * `../errors/index.js` only — never the engine, the driver or mongoose — so an
+ * application's repository layer pays for nothing else (pinned by a test).
+ */
+
+const isPlainObject = (value) => {
+  if (value === null || typeof value !== 'object') return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+
+/** A BSON value class from the driver (`Int32`, `Long`, `ObjectId`, …) */
+const bsonType = (value) =>
+  value !== null && typeof value === 'object' && typeof value._bsontype === 'string'
+    ? value._bsontype
+    : undefined;
+
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+
+/**
+ * A non-negative safe integer from whatever the driver handed back — a plain
+ * number, a `bigint` (`useBigInt64`), an `Int32`, a `Double` or a `Long`
+ * (`promoteValues: false`) — or `null` when the value is not one.
+ */
+function toCount(value) {
+  if (typeof value === 'number') {
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+  }
+  if (typeof value === 'bigint') {
+    return value >= 0n && value <= MAX_SAFE ? Number(value) : null;
+  }
+  const type = bsonType(value);
+  if (type === 'Int32' || type === 'Double') return toCount(Number(value.valueOf()));
+  if (type === 'Long') {
+    if (value.isNegative()) return null;
+    const number = value.toNumber();
+    return Number.isSafeInteger(number) ? number : null;
+  }
+  return null;
+}
+
+const bytesEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+};
+
+const binaryBytes = (value) =>
+  value.buffer.subarray(0, typeof value.position === 'number' ? value.position : undefined);
+
+/**
+ * Two BSON values of the same class. `undefined` means "cannot tell" — the
+ * caller then treats them as different, which costs one rewritten field and
+ * never loses a change.
+ */
+function sameBsonValue(type, a, b) {
+  switch (type) {
+    case 'ObjectId':
+    case 'ObjectID':
+      return a.toHexString() === b.toHexString();
+    case 'Long':
+    case 'Timestamp':
+      return a.equals(b) && a.unsigned === b.unsigned;
+    case 'Int32':
+    case 'Double':
+      return Object.is(Number(a.valueOf()), Number(b.valueOf()));
+    case 'Decimal128':
+      return bytesEqual(a.bytes, b.bytes);
+    case 'Binary':
+    case 'UUID':
+      return a.sub_type === b.sub_type && bytesEqual(binaryBytes(a), binaryBytes(b));
+    case 'BSONRegExp':
+      return a.pattern === b.pattern && a.options === b.options;
+    case 'BSONSymbol':
+      return String(a.valueOf()) === String(b.valueOf());
+    case 'MinKey':
+    case 'MaxKey':
+      return true;
+    case 'Code':
+      return a.code === b.code && sameValue(a.scope ?? null, b.scope ?? null);
+    case 'DBRef':
+      return (
+        a.collection === b.collection &&
+        a.db === b.db &&
+        sameValue(a.oid, b.oid) &&
+        sameValue(a.fields ?? {}, b.fields ?? {})
+      );
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Whether two document values would serialize to the same BSON. Key order
+ * counts (`{a, b}` and `{b, a}` are different documents to the server), a
+ * `Date` compares by time, a RegExp by source and flags, and a BSON class by
+ * its own contents — `Double 1` and `Int32 1` are *different*, because
+ * keeping the stored type is the point. Anything this cannot judge is
+ * "different": a spurious difference rewrites one field, a spurious sameness
+ * would drop a change.
+ */
+function sameValue(a, b) {
+  if (a === b) return a !== 0 || Object.is(a, b);
+  if (typeof a !== typeof b) return false;
+  if (typeof a === 'number') return Number.isNaN(a) && Number.isNaN(b);
+  if (a === null || b === null || typeof a !== 'object') return false;
+  const typeA = bsonType(a);
+  const typeB = bsonType(b);
+  if (typeA !== undefined || typeB !== undefined) {
+    return typeA === typeB && sameBsonValue(typeA, a, b) === true;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!sameValue(a[i], b[i])) return false;
+    return true;
+  }
+  if (Array.isArray(b)) return false;
+  if (a instanceof Date) return b instanceof Date && Object.is(a.getTime(), b.getTime());
+  if (a instanceof RegExp) {
+    return b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+  }
+  if (ArrayBuffer.isView(a)) {
+    return ArrayBuffer.isView(b) && a.constructor === b.constructor && bytesEqual(a, b);
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (key !== keysB[i] || !sameValue(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+/**
+ * A copy a transformation may mutate freely: plain objects and arrays are
+ * copied all the way down, a `Date` is cloned, and every other value — BSON
+ * classes included, which a structured clone would strip of their prototype
+ * — is shared.
+ */
+function cloneDocument(value) {
+  if (Array.isArray(value)) {
+    const out = new Array(value.length);
+    for (let i = 0; i < value.length; i++) out[i] = cloneDocument(value[i]);
+    return out;
+  }
+  if (value instanceof Date) return new Date(value.getTime());
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value)) setOwn(out, key, cloneDocument(value[key]));
+  return out;
+}
+
+/**
+ * `target[key] = value` as an own, enumerable property — `__proto__` too,
+ * which a plain assignment would turn into the object's prototype (a stored
+ * field of that name is data, as the BSON parser reads it).
+ */
+function setOwn(target, key, value) {
+  if (key === '__proto__') {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    target[key] = value;
+  }
+}
+
+/**
+ * A collection definition as a module may hand it over: an ES-module
+ * namespace (`import * as orders`, or `require` of an ES module) carries it
+ * as its `default`.
+ */
+function unwrapDefinition(value) {
+  return isPlainObject(value?.default) ? value.default : value;
+}
+
+/** `a.b.c` → `a`; `$[]`-style paths keep their first segment too */
+const topField = (path) => {
+  const dot = path.indexOf('.');
+  return dot === -1 ? path : path.slice(0, dot);
+};
+
+const PIPELINE_FIELD_STAGES = new Set(['$set', '$addFields']);
+const PIPELINE_WHOLE_STAGES = new Set(['$project', '$replaceRoot', '$replaceWith']);
+
+/**
+ * The top-level fields an update writes: `{ fields, whole }`, where `whole`
+ * means it may rewrite the entire document (a replacement, or a pipeline that
+ * projects or replaces the root) and `fields` lists the ones it names.
+ */
+function touchedFields(update) {
+  const fields = new Set();
+  if (Array.isArray(update)) {
+    let whole = false;
+    for (const stage of update) {
+      if (!isPlainObject(stage)) continue;
+      for (const [operator, spec] of Object.entries(stage)) {
+        if (PIPELINE_FIELD_STAGES.has(operator) && isPlainObject(spec)) {
+          for (const key of Object.keys(spec)) fields.add(topField(key));
+        } else if (operator === '$unset') {
+          for (const key of Array.isArray(spec) ? spec : [spec]) {
+            if (typeof key === 'string') fields.add(topField(key));
+          }
+        } else if (PIPELINE_WHOLE_STAGES.has(operator)) {
+          whole = true;
+          if (operator === '$project' && isPlainObject(spec)) {
+            for (const key of Object.keys(spec)) fields.add(topField(key));
+          }
+        }
+      }
+    }
+    return { fields, whole };
+  }
+  if (!isPlainObject(update)) return { fields, whole: false };
+  // One walk: a key without `$` makes it a replacement document, whose own
+  // keys are then the fields; operator specs name theirs.
+  const plain = new Set();
+  for (const [key, spec] of Object.entries(update)) {
+    if (!key.startsWith('$')) {
+      plain.add(key);
+      continue;
+    }
+    if (!isPlainObject(spec)) continue;
+    for (const [path, value] of Object.entries(spec)) {
+      fields.add(topField(path));
+      if (key === '$rename' && typeof value === 'string') fields.add(topField(value));
+    }
+  }
+  return plain.size > 0 ? { fields: plain, whole: true } : { fields, whole: false };
+}
+
+const LOGICAL = new Set(['$and', '$or', '$nor']);
+
+/** `"$__rev"` or `"$__rev.x"` inside a serialized `$expr` — not `"$__revision"` */
+const references = new Map();
+function fieldReference(field) {
+  // Built once per field: every guarded write asks.
+  let pattern = references.get(field);
+  if (pattern === undefined) {
+    pattern = new RegExp(`"\\$${field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:"|\\.)`);
+    references.set(field, pattern);
+  }
+  return pattern;
+}
+
+/** Whether a query filter constrains `field` (at the top level, or through `$and`/`$or`/`$nor`) */
+function filterTouches(filter, field) {
+  if (!isPlainObject(filter)) return false;
+  for (const [key, value] of Object.entries(filter)) {
+    if (LOGICAL.has(key) && Array.isArray(value)) {
+      for (const branch of value) if (filterTouches(branch, field)) return true;
+    } else if (key === '$expr') {
+      if (fieldReference(field).test(JSON.stringify(value ?? null))) return true;
+    } else if (!key.startsWith('$') && topField(key) === field) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = {
+  bsonType,
+  cloneDocument,
+  filterTouches,
+  isPlainObject,
+  sameValue,
+  setOwn,
+  toCount,
+  topField,
+  touchedFields,
+  unwrapDefinition,
+};