@nxgt/shared-mongo 1.0.0

package/dist/index.js

@@ -0,0 +1,1847 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/types/pagination.d.ts
+import"mongoose";
+
+// src/index.ts
+export * from "async-mutex";
+export * from "mongoose";
+
+// src/audit/audit.model.ts
+import { logger as logger3 } from "@nxgt/shared-logging";
+import { redis } from "bun";
+import { model, Schema } from "mongoose";
+
+// src/plugins/pagination/utils.ts
+import { CustomException } from "@nxgt/shared-exceptions";
+var MAX_SIZE = 100;
+function applyPagination(schema) {
+  schema.static("paginate", async function() {
+    const options = arguments?.[0] ?? {};
+    const { first, last, before, after, extraFilter } = options;
+    let filter = options.filter ?? {};
+    const deleted = options.deleted ?? "";
+    const countDocuments = (f) => this[`countDocuments${deleted}`]?.(f) ?? this.countDocuments(f);
+    if (extraFilter) {
+      filter = filter ? { $and: [filter, extraFilter] } : extraFilter;
+    }
+    if (first && last) {
+      throw CustomException.badRequest({
+        message: "errors.could-not-use-first-and-last-together"
+      });
+    }
+    if (after) {
+      filter = filter ? { $and: [filter, { _id: { $gt: after } }] } : { _id: { $gt: after } };
+    }
+    if (before) {
+      filter = filter ? { $and: [filter, { _id: { $lt: before } }] } : { _id: { $lt: before } };
+    }
+    const limit = Math.min(first ?? last ?? MAX_SIZE, MAX_SIZE);
+    const sort = { _id: last || before ? -1 : 1 };
+    let query = (this[`find${deleted}`]?.(filter, arguments?.[1], arguments?.[2]) ?? this.find(filter, arguments?.[1], arguments?.[2])).sort(sort);
+    query = query.limit(limit + 1);
+    const result = await query.exec();
+    const hasExtraDoc = result.length > limit;
+    const actualResults = hasExtraDoc ? result.slice(0, limit) : result;
+    const total = await countDocuments(filter);
+    const edges = actualResults.map((item) => ({
+      node: item,
+      cursor: item.id
+    }));
+    const pageInfo = {
+      hasNextPage: hasExtraDoc,
+      startCursor: edges?.[0]?.cursor,
+      endCursor: edges?.[edges.length - 1]?.cursor
+    };
+    return { edges, pageInfo, totalCount: total };
+  });
+  schema.static("paginateList", function() {
+    const docs = arguments?.[0] ?? [];
+    const options = arguments?.[1] ?? {};
+    return paginateListData(docs, options);
+  });
+  schema.static("paginateOffset", async function() {
+    const options = arguments?.[0] ?? {};
+    const filter = options.filter ?? {};
+    const sort = options.sort ?? {};
+    const populate = options.populate ?? [];
+    const deleted = options.deleted ?? "";
+    const count = await (this[`countDocuments${deleted}`]?.(filter) ?? this.countDocuments(filter));
+    const { size, page, totalPages, skip } = offsetWindow(options, count);
+    const docs = await (this[`find${deleted}`]?.(filter, arguments?.[1], arguments?.[2]) ?? this.find(filter, arguments?.[1], arguments?.[2])).populate(populate).sort(sort).skip(skip).limit(size).exec();
+    return {
+      data: docs,
+      metadata: {
+        page,
+        size,
+        totalElements: count,
+        totalPages,
+        nbOfElements: docs.length,
+        hasPreviousPage: page > 1,
+        hasNextPage: page < totalPages
+      }
+    };
+  });
+  schema.static("paginateListOffset", async function() {
+    const docs = arguments?.[0] ?? [];
+    const options = arguments?.[1] ?? {};
+    const count = docs.length;
+    const { size, page, totalPages, skip } = offsetWindow(options, count);
+    return {
+      data: docs.slice(skip, skip + size),
+      metadata: {
+        page,
+        size,
+        totalElements: count,
+        totalPages,
+        nbOfElements: docs.length,
+        hasPreviousPage: page > 1,
+        hasNextPage: page < totalPages
+      }
+    };
+  });
+  schema.static("cursorPaginate", async function() {
+    const options = arguments?.[0] ?? {};
+    const filter = options.filter ?? {};
+    const populate = options.populate ?? [];
+    const deleted = options.deleted ?? "";
+    const { after, before } = options;
+    const first = options.first && options.first > 0 ? options.first : undefined;
+    const last = options.last && options.last > 0 ? options.last : undefined;
+    if (first && last) {
+      throw CustomException.badRequest({
+        message: "errors.could-not-use-first-and-last-together"
+      });
+    }
+    const cursorFilter = filter;
+    if (after)
+      cursorFilter._id = { $gt: after };
+    if (before)
+      cursorFilter._id = { $lt: before };
+    const limit = Math.min(first ?? last ?? MAX_SIZE, MAX_SIZE);
+    const querySort = { _id: last || before ? -1 : 1 };
+    const query = (this[`find${deleted}`]?.(cursorFilter, arguments?.[1], arguments?.[2]) ?? this.find(cursorFilter, arguments?.[1], arguments?.[2])).populate(populate).sort(querySort);
+    query.limit(Math.max(limit ?? 0, 1) + 1);
+    const docs = await query.exec();
+    const hasExtraDoc = docs.length > limit;
+    const resultDocs = hasExtraDoc ? docs.slice(0, limit) : docs;
+    if (last) {
+      resultDocs.reverse();
+    }
+    const totalElements = await (this[`countDocuments${deleted}`]?.(filter) ?? this.countDocuments(filter));
+    return {
+      data: resultDocs,
+      metadata: {
+        startCursor: resultDocs.length > 0 ? resultDocs[0]._id.toString() : null,
+        endCursor: resultDocs.length > 0 ? resultDocs[resultDocs.length - 1]._id.toString() : null,
+        hasNextPage: hasExtraDoc,
+        totalElements
+      }
+    };
+  });
+}
+function offsetWindow(options, count) {
+  const size = Math.min(Math.max(options.size ?? 20, 1), MAX_SIZE);
+  const page = Math.max(options.page ?? 1, 1);
+  return {
+    size,
+    page,
+    totalPages: Math.floor((count - 1) / size) + 1,
+    skip: (page - 1) * size
+  };
+}
+function paginateListData(list, options) {
+  const { first, last, before, after } = options;
+  if (first && last) {
+    throw CustomException.badRequest({
+      message: "errors.could-not-use-first-and-last-together"
+    });
+  }
+  const isBackward = last || before;
+  const sortedData = list.sort((a, b) => {
+    if (a._id.toString() < b._id.toString())
+      return isBackward ? 1 : -1;
+    if (a._id.toString() > b._id.toString())
+      return isBackward ? -1 : 1;
+    return 0;
+  });
+  const total = sortedData.length;
+  let filteredData = sortedData;
+  if (after || before) {
+    const index = sortedData.findIndex((item) => item.id === (after ?? before));
+    filteredData = index !== -1 ? sortedData.slice(index + 1) : sortedData;
+  }
+  const limit = Math.min(first ?? last ?? MAX_SIZE, MAX_SIZE);
+  const hasExtraDoc = filteredData.length > limit;
+  const resultData = filteredData.slice(0, limit);
+  const edges = resultData.map((item) => ({
+    node: item,
+    cursor: item.id
+  }));
+  const pageInfo = {
+    hasNextPage: hasExtraDoc,
+    startCursor: edges?.[0]?.cursor,
+    endCursor: edges?.[edges.length - 1]?.cursor
+  };
+  return { edges, pageInfo, totalCount: total };
+}
+
+// src/plugins/pagination/types.ts
+class OffsetPaginationOptions {
+  constructor() {}
+}
+
+class NestedOffsetPaginationOptions {
+  constructor() {}
+}
+
+class CursorPaginationOptions {
+  constructor() {}
+}
+
+// src/plugins/pagination/index.ts
+var pagination = (schema) => {
+  applyPagination(schema);
+};
+
+// src/audit/audit.types.ts
+var ChangeOperationType;
+((ChangeOperationType2) => {
+  ChangeOperationType2["ADD"] = "add";
+  ChangeOperationType2["REPLACE"] = "replace";
+  ChangeOperationType2["REMOVE"] = "remove";
+})(ChangeOperationType ||= {});
+var CommitType;
+((CommitType2) => {
+  CommitType2["INITIAL"] = "INITIAL";
+  CommitType2["UPDATE"] = "UPDATE";
+  CommitType2["TERMINAL"] = "TERMINAL";
+})(CommitType ||= {});
+
+// src/audit/audit.utils.ts
+import { delay } from "@nxgt/shared/helpers";
+import { createLogger } from "@nxgt/shared-logging";
+import { Mutex } from "async-mutex";
+import { diff } from "just-diff";
+import { omit as omit2 } from "lodash";
+
+// src/mongoose.ts
+import mongoose from "mongoose";
+
+// src/utils/clear-database.ts
+async function clearDatabase(connection = mongoose.connection) {
+  const database = connection.name;
+  if (Bun.env.NODE_ENV !== "test" || !database.endsWith("-test")) {
+    throw new Error(`clearDatabase refused to run: NODE_ENV="${Bun.env.NODE_ENV}", database="${database}". ` + 'It only runs with NODE_ENV=test against a database whose name ends in "-test". ' + "A test run reaching a non-test database usually means MONGODB_URI is set in the " + "shell, or the test env file was not passed.");
+  }
+  const collections = await connection.listCollections();
+  await Promise.all(collections.filter((collection) => collection.type !== "view" && !collection.name.includes("system")).map((collection) => connection.collection(collection.name).deleteMany({})));
+}
+// src/utils/error.utils.ts
+import { CustomException as CustomException2 } from "@nxgt/shared-exceptions";
+import mongoose2 from "mongoose";
+function castError(error) {
+  let props = {};
+  if (error instanceof CustomException2) {
+    return error;
+  }
+  switch (true) {
+    case error instanceof mongoose2.Error.CastError:
+      props = {
+        message: "errors.cast-failed",
+        options: { field: error.path }
+      };
+      break;
+    case error instanceof mongoose2.Error.VersionError:
+      props = {
+        message: "errors.optimistic-lock-failed",
+        debugMessage: error.message
+      };
+      break;
+    case error instanceof mongoose2.Error.DocumentNotFoundError:
+      props = {
+        message: "errors.not-found"
+      };
+      break;
+    case error instanceof mongoose2.Error.MongooseServerSelectionError:
+      props = {
+        message: "errors.server-connection-failed"
+      };
+      break;
+    case error instanceof mongoose2.Error.ValidationError:
+      props = {
+        message: Object.values(error.errors).map((e) => e.message).join(" ")
+      };
+      break;
+    default:
+      props = {
+        message: "errors.something-went-wrong"
+      };
+  }
+  return CustomException2.badRequest({
+    message: props.message || "",
+    options: props.options,
+    debugMessage: error.message
+  });
+}
+// src/utils/filter.utils.ts
+function buildDateRangeFilter(dateRange) {
+  if (!dateRange) {
+    return;
+  }
+  const filter = {};
+  if (dateRange.from) {
+    filter.$gte = new Date(dateRange.from);
+  }
+  if (dateRange.to) {
+    filter.$lte = new Date(dateRange.to);
+  }
+  return Object.keys(filter).length > 0 ? filter : undefined;
+}
+function buildArrayFilter(arrayFilter) {
+  if (!arrayFilter?.values) {
+    return;
+  }
+  return arrayFilter.operator === "and" ? { $all: arrayFilter.values } : arrayFilter.values;
+}
+function addFilterCondition(query, field, condition) {
+  if (condition) {
+    query[field] = condition;
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildRegexFilter(value) {
+  if (value) {
+    return { $regex: escapeRegex(value), $options: "i" };
+  }
+  return;
+}
+// src/utils/helpers.ts
+var exports_helpers = {};
+__export(exports_helpers, {
+  buildListStringPatch: () => buildListStringPatch,
+  buildListStringPatchUpdate: () => buildListStringPatchUpdate,
+  checkVersion: () => checkVersion,
+  patchListObjectId: () => patchListObjectId,
+  patchListString: () => patchListString,
+  resolveListStringPatch: () => resolveListStringPatch,
+  safeCreateView: () => safeCreateView
+});
+import { CustomException as CustomException3 } from "@nxgt/shared-exceptions";
+import { logger } from "@nxgt/shared-logging";
+import { isNil } from "lodash";
+import mongoose4 from "mongoose";
+
+// src/utils/object-id.utils.ts
+import mongoose3, { Types } from "mongoose";
+function objectIdString() {
+  return new mongoose3.mongo.ObjectId().toHexString();
+}
+function toObjectId(id) {
+  return new Types.ObjectId(id);
+}
+function toObjectIds(ids) {
+  return ids.map(toObjectId);
+}
+function isValidObjectID(id) {
+  return Types.ObjectId.isValid(id);
+}
+function validObjectIds(ids) {
+  return ids?.filter(isValidObjectID);
+}
+function objectIdFromString(id) {
+  return toObjectId(id);
+}
+
+// src/utils/helpers.ts
+async function isView(name) {
+  const db = mongoose4.connection.db;
+  if (!db)
+    return false;
+  const [existing] = await db.listCollections({ name }).toArray();
+  return existing?.type === "view";
+}
+async function safeCreateView(model, viewModel, pipeline = [], attempts = 3) {
+  try {
+    await model.createCollection();
+  } catch (error) {
+    logger.error(`Error creating collection for model ${model.modelName}:`, error);
+  }
+  const viewName = viewModel.collection.name;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    try {
+      await mongoose4.connection.dropCollection(viewName);
+      logger.info(`Dropped existing view for model ${viewModel.modelName}`);
+    } catch (error) {
+      logger.debug(`No existing namespace to drop for model ${viewModel.modelName}: ${error}`);
+    }
+    try {
+      await viewModel.createCollection({
+        viewOn: model.collection.name,
+        pipeline
+      });
+    } catch (error) {
+      logger.error(`Error creating view for model ${viewModel.modelName}:`, error);
+    }
+    if (await isView(viewName))
+      return;
+    logger.warn(`${viewName} is not a view after attempt ${attempt}/${attempts} — retrying`);
+    if (attempt < attempts) {
+      await new Promise((resolve) => setTimeout(resolve, attempt * 50));
+    }
+  }
+  logger.error(`Failed to create view ${viewName} for model ${viewModel.modelName}: it exists as a plain collection, so every query through it will come back empty.`);
+}
+function patchListString(list = [], patch) {
+  if (!patch) {
+    return list;
+  }
+  const add = patch.add ?? [];
+  const remove = patch.remove ?? [];
+  const replace = patch.replace ?? [];
+  let result = [...list, ...add];
+  result = result.filter((item) => !remove.includes(item));
+  if (replace.length) {
+    result = replace;
+  }
+  return Array.from(new Set(result));
+}
+function patchListObjectId(list = [], patch) {
+  const values = list.map((item) => item instanceof mongoose4.Types.ObjectId ? item.toHexString() : item._id.toHexString());
+  return patchListString(values, patch).filter(isValidObjectID).map((id) => new mongoose4.Types.ObjectId(id));
+}
+async function resolveListStringPatch(current, model, value, filter = {}) {
+  if (!value?.replace?.length && !value?.add?.length && !value?.remove?.length) {
+    return;
+  }
+  const idsOf = async (ids) => ids?.length ? (await model.find({ _id: ids, ...filter }).exec()).map((item) => String(item._id)) : [];
+  if (value.replace?.length) {
+    return idsOf(value.replace);
+  }
+  const held = (Array.isArray(current) ? current : []).map((item) => String(item?._id ?? item));
+  const removed = new Set(value.remove ?? []);
+  return [
+    ...new Set([
+      ...held.filter((id) => !removed.has(id)),
+      ...await idsOf(value.add)
+    ])
+  ];
+}
+async function buildListStringPatch(_source, path, model, value, filter = {}) {
+  const add = value?.add?.length ? (await model.find({
+    _id: value.add,
+    ...filter
+  }).exec()).map((item) => item._id) : [];
+  const remove = value?.remove?.length ? (await model.find({
+    _id: value.remove,
+    ...filter
+  }).exec()).map((item) => item._id) : [];
+  const replace = value?.replace?.length ? (await model.find({
+    _id: value.replace,
+    ...filter
+  }).exec()).map((item) => item._id) : [];
+  return {
+    ...value?.add?.length && {
+      $addToSet: {
+        [path]: {
+          $each: add
+        }
+      }
+    },
+    ...value?.remove?.length && {
+      $pullAll: {
+        [path]: remove
+      }
+    },
+    ...value?.replace?.length && {
+      [path]: replace
+    }
+  };
+}
+async function buildListStringPatchUpdate(path, value) {
+  const add = value?.add ?? [];
+  const remove = value?.remove ?? [];
+  const replace = value?.replace ?? [];
+  return {
+    ...add.length && {
+      $addToSet: {
+        [path]: {
+          $each: add
+        }
+      }
+    },
+    ...remove.length && {
+      $pullAll: {
+        [path]: remove
+      }
+    },
+    ...replace.length && {
+      [path]: replace
+    }
+  };
+}
+function checkVersion(modelVersion, version) {
+  if (isNil(version)) {
+    return;
+  }
+  if (modelVersion !== version) {
+    throw CustomException3.badRequest({
+      message: "errors.optimistic-lock-failed"
+    });
+  }
+}
+// src/utils/mappers.ts
+var exports_mappers = {};
+__export(exports_mappers, {
+  toObject: () => toObject,
+  toObjects: () => toObjects
+});
+import { omit } from "lodash";
+var toObject = (doc, ...omitFields) => {
+  if (!doc)
+    return null;
+  return {
+    ...omit(doc.toObject({ getters: true, virtuals: true, versionKey: true }), [
+      "_id",
+      ...omitFields
+    ])
+  };
+};
+var toObjects = (docs, ...omitFields) => docs.map((doc) => toObject(doc, ...omitFields));
+// src/plugins/index.ts
+import autopopulate from "mongoose-autopopulate";
+import leanVirtuals from "mongoose-lean-virtuals";
+
+// src/plugins/errors.ts
+import { CustomException as CustomException4 } from "@nxgt/shared-exceptions";
+var errors = (schema) => {
+  schema.post([
+    "save",
+    "deleteOne",
+    "findOneAndDelete",
+    "updateOne",
+    "findOneAndUpdate",
+    "replaceOne",
+    "findOneAndReplace",
+    "findOne",
+    "countDocuments"
+  ], (error, _, next) => {
+    if (error) {
+      if (error.name === "MongoServerError" && error.code === 11000) {
+        next(CustomException4.badRequest({
+          message: "errors.duplicate-key",
+          debugMessage: error.message
+        }));
+      } else {
+        next(castError(error));
+      }
+    } else {
+      next();
+    }
+  });
+};
+
+// src/plugins/shared/shared.ts
+import { translate } from "@nxgt/i18n";
+import { CustomException as CustomException5, ErrorCode } from "@nxgt/shared-exceptions";
+import { has } from "lodash";
+import mongoose5 from "mongoose";
+function applySharedOperations(schema) {
+  schema.static("ensureExists", async function() {
+    const result = await mongoose5.Model.exists.apply(this, [arguments?.[0] ?? {}]).exec();
+    if (!result) {
+      const localeKey = `${this.collection.collectionName}.errors.not-found`;
+      throw CustomException5.notFound({
+        message: arguments?.[1]?.message ?? (translate(localeKey) === localeKey ? "errors.not-found" : localeKey),
+        options: arguments?.[1]?.options
+      });
+    }
+  });
+  schema.static("requireById", async function() {
+    try {
+      const doc = await mongoose5.Model.findById.apply(this, [arguments?.[0] ?? {}]).exec();
+      if (!doc) {
+        const localeKey = `${this.collection.collectionName}.errors.not-found`;
+        throw CustomException5.notFound({
+          message: arguments?.[1]?.message ?? (translate(localeKey) === localeKey ? "errors.not-found" : localeKey),
+          options: arguments?.[1]?.options
+        });
+      }
+      return doc;
+    } catch (error) {
+      if (error instanceof CustomException5) {
+        throw error;
+      }
+      throw CustomException5.from({
+        message: arguments?.[1]?.message ?? error?.message,
+        code: arguments?.[1]?.code ?? ErrorCode.BadRequest,
+        debugMessage: translate(error.message)
+      });
+    }
+  });
+  if (schema.options.versionKey) {
+    schema.pre(["findOneAndUpdate"], async function() {
+      const update = this.getUpdate();
+      if (!update) {
+        return;
+      }
+      if (has(update, "version")) {
+        delete update.version;
+      }
+      const keys = ["$set", "$setOnInsert"];
+      for (const key of keys) {
+        if (update[key] != null && update[key].version != null) {
+          delete update[key].version;
+          if (Object.keys(update[key]).length === 0) {
+            delete update[key];
+          }
+        }
+      }
+      update.$inc = update.$inc || {};
+      update.$inc.version = 1;
+    });
+  }
+}
+
+// src/plugins/shared/index.ts
+function shared(schema) {
+  applySharedOperations(schema);
+}
+
+// src/plugins/consts.ts
+var PLUGIN_OPTIONS = {
+  autopopulate: { maxDepth: 1 }
+};
+
+// src/plugins/index.ts
+var MONGOOSE_PLUGINS = {
+  shared,
+  errors,
+  pagination,
+  leanVirtuals,
+  autopopulate
+};
+function applyPlugins(schema, plugins) {
+  plugins.forEach((plugin) => {
+    schema.plugin(plugin);
+  });
+}
+
+// src/utils/mongo-utils.ts
+var MONGO_UTILS = {
+  applyPlugins,
+  castError,
+  auditChanges,
+  ...exports_mappers,
+  ...exports_helpers,
+  timestamps: { createdAt: "createdDate", updatedAt: "lastModifiedDate" },
+  coreOptions: {
+    toObject: { virtuals: true, versionKey: true },
+    toJSON: { virtuals: true, versionKey: true },
+    timestamps: { createdAt: "createdDate", updatedAt: "lastModifiedDate" },
+    versionKey: "version",
+    optimisticConcurrency: true
+  },
+  auditPipeline: [
+    {
+      $match: {
+        operationType: { $in: ["insert", "update", "replace", "delete"] }
+      }
+    }
+  ]
+};
+// src/utils/pagination.utils.ts
+function paginateList(docs, options) {
+  return paginateListData(docs, options);
+}
+// src/utils/sort.utils.ts
+import { buildSort, SortDirection } from "@nxgt/shared/helpers";
+// src/audit/audit.utils.ts
+var mutex = new Mutex;
+var logger2 = createLogger({ name: "audit" });
+function auditChanges(changeStream, options) {
+  options.omitFields = options.omitFields ?? [
+    "_id",
+    "id",
+    "version",
+    "createdDate",
+    "lastModifiedDate",
+    "createdBy",
+    "lastModifiedBy",
+    "__v"
+  ];
+  changeStream.on("change", async (data) => {
+    const globalId = `${data.ns.coll}/${data.documentKey._id.toHexString()}`;
+    const previousSnapshot = await AuditModel.findOne({
+      globalId
+    }).sort({ version: -1 }).exec();
+    const stateBeforeChange = previousSnapshot?.state;
+    if (["delete", "update", "replace"].includes(data.operationType)) {
+      const doc = await mongoose.connection.db?.collection(data.ns.coll).findOne({ _id: { $eq: data.documentKey._id } });
+      const state = doc ? { ...doc, id: doc._id.toHexString() } : undefined;
+      const changes = data.operationType === "delete" ? [] : diff(omit2(stateBeforeChange, options.omitFields ?? []), omit2(state, options.omitFields ?? []));
+      await AuditModel.create({
+        type: data.operationType === "delete" ? "TERMINAL" : "UPDATE",
+        author: options.author,
+        changes,
+        properties: changes.flatMap((change) => change.path.toString()),
+        state: state ?? previousSnapshot?.state ?? {
+          _id: data.documentKey._id,
+          id: data.documentKey._id.toHexString()
+        },
+        version: (previousSnapshot?.version ?? 0) + 1,
+        globalId
+      });
+    } else {
+      const state = data.fullDocument ? {
+        ...data.fullDocument,
+        id: data.fullDocument._id.toHexString()
+      } : undefined;
+      const changes = diff({}, omit2(state, options.omitFields ?? []));
+      await AuditModel.create({
+        type: "INITIAL",
+        author: options.author,
+        changes,
+        version: 0,
+        properties: changes.flatMap((change) => change.path.toString()),
+        state,
+        globalId
+      });
+    }
+  });
+}
+function runWithChangesListening(bloc, options) {
+  return (options.mutex ?? mutex).runExclusive(async () => {
+    const changeStreams = options.models.map((model) => model.watch(MONGO_UTILS.auditPipeline));
+    changeStreams.forEach((changeStream) => {
+      auditChanges(changeStream, omit2(options, "models"));
+    });
+    try {
+      return await mongoose.connection.transaction(async () => {
+        return await bloc();
+      }, { readPreference: "primary" });
+    } finally {
+      await delay(1);
+      for (const changeStream of changeStreams) {
+        await changeStream.close();
+      }
+    }
+  });
+}
+var AUDIT_EVENT = "event:audit";
+function registerAuditSubscription({ pubsub }) {
+  const AUDIT_CHANGE_STREAM = AuditModel.watch([
+    {
+      $match: {
+        operationType: "insert"
+      }
+    }
+  ]);
+  AUDIT_CHANGE_STREAM.on("change", async (data) => {
+    try {
+      pubsub.publish(AUDIT_EVENT, await AuditModel.findById(data.documentKey._id));
+    } catch (error2) {
+      logger2.error(error2);
+    }
+  });
+}
+
+// src/audit/audit.model.ts
+var schema2 = new Schema({
+  type: {
+    type: String,
+    enum: ["INITIAL" /* INITIAL */, "UPDATE" /* UPDATE */, "TERMINAL" /* TERMINAL */]
+  },
+  author: String,
+  globalId: { type: String, required: true },
+  state: { type: Schema.Types.Mixed, required: true },
+  properties: [{ type: String, required: true }],
+  changes: [{ type: Schema.Types.Mixed, required: true }],
+  version: { type: Number, required: true, default: 0 }
+}, {
+  timestamps: { createdAt: "date", updatedAt: false },
+  versionKey: false
+});
+(() => {
+  pagination(schema2);
+})();
+var AuditModel = model("Audit", schema2);
+var AUDIT_CHANGE_STREAM = AuditModel.watch([
+  {
+    $match: {
+      operationType: "insert"
+    }
+  }
+]);
+(() => {
+  AUDIT_CHANGE_STREAM.on("change", async (data) => {
+    try {
+      await redis.publish(AUDIT_EVENT, JSON.stringify(await AuditModel.findById(data.documentKey._id)));
+    } catch (error2) {
+      logger3.error(error2);
+    }
+  });
+})();
+// src/audit/audit.service.ts
+import { castAsync } from "@nxgt/shared/helpers";
+class AuditService {
+  constructor() {
+    this.model = AuditModel;
+  }
+  async findChangesPaginated(options) {
+    return castAsync(this.model.paginate(options));
+  }
+  findChangesPaginatedByCollectionAndOid(oid, collection, options) {
+    const collectionFilter = {
+      globalId: { $regex: `^${collection}/${oid}$` }
+    };
+    const filter2 = options.filter ? {
+      $and: [collectionFilter, options.filter]
+    } : collectionFilter;
+    return this.findChangesPaginated({ ...options, filter: filter2 });
+  }
+  findChangesPaginatedByCollection(collection, options) {
+    const collectionFilter = {
+      globalId: { $regex: `^${collection}/` }
+    };
+    const filter2 = options.filter ? {
+      $and: [collectionFilter, options.filter]
+    } : collectionFilter;
+    return this.findChangesPaginated({ ...options, filter: filter2 });
+  }
+  async findChanges(filter2 = {}) {
+    return this.model.find(filter2 ?? {});
+  }
+  matches(audit, filter2) {
+    return audit.globalId.startsWith(`${filter2.collection}/`) && (filter2.type ? filter2.type === audit.type : true);
+  }
+  extractId(audit) {
+    return audit.globalId.split("/")[1];
+  }
+}
+// src/integrity/integrity.registry.ts
+import { CustomException as CustomException6 } from "@nxgt/shared-exceptions";
+
+class IntegrityRegistry {
+  constructor() {
+    this.blockers = new Map;
+    this.cascades = new Map;
+  }
+  registerBlocker(options) {
+    const { id, model: model2, errorCode, blocker } = options;
+    const current = this.blockers.get(model2) ?? [];
+    if (current.some((it) => it.id === id))
+      return;
+    current.push({ id, fn: blocker, errorCode });
+    this.blockers.set(model2, current);
+  }
+  registerCascade(options) {
+    const { id, model: model2, cascade } = options;
+    const current = this.cascades.get(model2) ?? [];
+    if (current.some((it) => it.id === id))
+      return;
+    current.push({ id, fn: cascade });
+    this.cascades.set(model2, current);
+  }
+  async validateDeletion(model2, ids) {
+    const collectionBlockers = this.blockers.get(model2) ?? [];
+    const results = await Promise.all(collectionBlockers.map(async ({ fn, errorCode }) => {
+      const count = await fn(ids);
+      return count > 0 ? errorCode : null;
+    }));
+    const failures = results.filter(Boolean);
+    if (failures.length > 0) {
+      throw CustomException6.conflict({
+        message: failures[0],
+        options: { ids, blockedBy: failures }
+      });
+    }
+  }
+  async runCascades(model2, ids) {
+    const handlers = this.cascades.get(model2) ?? [];
+    await Promise.all(handlers.map(({ fn }) => fn(ids)));
+  }
+}
+var integrityRegistry = new IntegrityRegistry;
+// src/migrations/disconnect.ts
+function isTeardownError(err) {
+  const name = typeof err === "object" && err !== null && "name" in err ? String(err.name) : "";
+  const message = err instanceof Error ? err.message : String(err);
+  return name === "MongoClientClosedError" || name === "MongoPoolClosedError" || message.includes("client was closed") || message.includes("closed connection pool");
+}
+function ignoreTeardownError(err) {
+  if (!isTeardownError(err)) {
+    throw err;
+  }
+}
+async function disconnectQuietly() {
+  process.on("uncaughtException", ignoreTeardownError);
+  process.on("unhandledRejection", ignoreTeardownError);
+  try {
+    await mongoose.disconnect().catch(ignoreTeardownError);
+    await new Promise((resolve) => setImmediate(resolve));
+  } finally {
+    process.off("uncaughtException", ignoreTeardownError);
+    process.off("unhandledRejection", ignoreTeardownError);
+  }
+}
+
+// src/migrations/migration.runner.ts
+import { Mutex as Mutex2 } from "async-mutex";
+
+// src/migrations/migration.model.ts
+import { model as model2, Schema as Schema2 } from "mongoose";
+var migrationSchema = new Schema2({
+  name: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  batch: {
+    type: Number,
+    required: true
+  },
+  status: {
+    type: String,
+    enum: ["up", "failed"],
+    required: true
+  },
+  executedAt: {
+    type: Date,
+    required: true
+  },
+  duration: {
+    type: Number,
+    required: true
+  },
+  error: {
+    type: String
+  }
+}, {
+  collection: "migrations",
+  versionKey: false
+});
+var MigrationModel = model2("Migration", migrationSchema);
+
+// src/migrations/migration.utils.ts
+import { readdir, writeFile } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { createLogger as createLogger2 } from "@nxgt/shared-logging";
+var logger4 = createLogger2({ name: "migrations" });
+var MIGRATION_FILE_PATTERN = /^\d{1,16}-[a-zA-Z0-9_-]+\.ts$/;
+function isMigrationFile(filename) {
+  return MIGRATION_FILE_PATTERN.test(filename);
+}
+function migrationName(filename) {
+  return filename.slice(0, -extname(filename).length);
+}
+function migrationTimestamp(name) {
+  return name.split("-")[0] || "";
+}
+function sortMigrationsAsc(migrations) {
+  return [...migrations].sort((a, b) => {
+    const tsA = BigInt(migrationTimestamp(a.name));
+    const tsB = BigInt(migrationTimestamp(b.name));
+    if (tsA < tsB)
+      return -1;
+    if (tsA > tsB)
+      return 1;
+    return 0;
+  });
+}
+function sortMigrationsDesc(migrations) {
+  return [...migrations].sort((a, b) => {
+    const tsA = BigInt(migrationTimestamp(a.name));
+    const tsB = BigInt(migrationTimestamp(b.name));
+    if (tsA < tsB)
+      return 1;
+    if (tsA > tsB)
+      return -1;
+    return 0;
+  });
+}
+async function createMigrationFile(migrationsDir, description) {
+  const timestamp = new Date().toISOString().replace(/[-T:Z]/g, "").slice(0, 14);
+  const sanitized = description.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "");
+  const filename = `${timestamp}-${sanitized}.ts`;
+  const filePath = join(resolve(migrationsDir), filename);
+  const content = `import type { ClientSession, Connection } from 'mongoose';
+
+export async function up(db: Connection, session?: ClientSession): Promise<void> {
+	// TODO: Implement migration
+}
+
+export async function down(db: Connection, session?: ClientSession): Promise<void> {
+	// TODO: Implement rollback
+}
+`;
+  await writeFile(filePath, content, "utf8");
+  try {
+    const { spawnSync } = __require("node:child_process");
+    spawnSync("bunx", ["@biomejs/biome", "format", "--write", filePath]);
+  } catch {}
+  return filePath;
+}
+async function loadMigrationFiles(migrationsDir) {
+  const absoluteDir = resolve(migrationsDir);
+  let filenames;
+  try {
+    filenames = await readdir(absoluteDir);
+  } catch {
+    throw new Error(`migrations.errors.directory-not-found: ${absoluteDir}`);
+  }
+  const migrationFiles = filenames.filter(isMigrationFile);
+  const definitions = await Promise.all(migrationFiles.map(async (filename) => {
+    const filePath = join(absoluteDir, filename);
+    const name = migrationName(filename);
+    const module = await import(filePath);
+    if (typeof module.up !== "function") {
+      throw new Error(`migrations.errors.missing-up-export: ${filename}`);
+    }
+    return {
+      name,
+      filePath,
+      up: module.up,
+      down: typeof module.down === "function" ? module.down : undefined
+    };
+  }));
+  return sortMigrationsAsc(definitions);
+}
+
+// src/migrations/migration.runner.ts
+var mutex2 = new Mutex2;
+
+class MigrationRunner {
+  constructor(options) {
+    this.migrationsDir = options.migrationsDir;
+    this.connection = options.connection;
+  }
+  async up(options) {
+    await mutex2.runExclusive(async () => {
+      const allMigrations = await loadMigrationFiles(this.migrationsDir);
+      if (options?.name) {
+        await this.runSpecificUp(allMigrations, options.name, options.dryRun);
+      } else {
+        await this.runPendingUp(allMigrations, options?.dryRun);
+      }
+    });
+  }
+  async down(options) {
+    await mutex2.runExclusive(async () => {
+      const allMigrations = await loadMigrationFiles(this.migrationsDir);
+      if (options?.name) {
+        await this.runSpecificDown(allMigrations, options.name, options.dryRun);
+      } else {
+        await this.runLastBatchDown(allMigrations, options?.dryRun);
+      }
+    });
+  }
+  async create(options) {
+    const filePath = await createMigrationFile(this.migrationsDir, options.name);
+    logger4.info(`created migration: ${filePath}`);
+    return filePath;
+  }
+  async list() {
+    const [allMigrations, records] = await Promise.all([
+      loadMigrationFiles(this.migrationsDir),
+      MigrationModel.find({}).sort({ name: 1 }).lean().exec()
+    ]);
+    const recordByName = new Map(records.map((r) => [r.name, r]));
+    return sortMigrationsAsc(allMigrations).map((migration) => {
+      const record = recordByName.get(migration.name);
+      if (!record) {
+        return {
+          name: migration.name,
+          status: "pending"
+        };
+      }
+      return {
+        name: record.name,
+        status: record.status,
+        batch: record.batch,
+        executedAt: record.executedAt
+      };
+    });
+  }
+  async runPendingUp(allMigrations, dryRun) {
+    const executedNames = await this.fetchExecutedNames();
+    const pending = sortMigrationsAsc(allMigrations).filter((m) => !executedNames.has(m.name));
+    if (pending.length === 0) {
+      logger4.info("no pending migrations");
+      return;
+    }
+    if (dryRun) {
+      logger4.info(`[DRY RUN] pending migrations to run: ${pending.length}`);
+      for (const m of pending)
+        logger4.info(`[DRY RUN]   → ${m.name}`);
+      return;
+    }
+    const batch = await this.nextBatchNumber();
+    for (const migration of pending) {
+      await this.executeMigrationUp(migration, batch);
+    }
+  }
+  async runSpecificUp(allMigrations, name, dryRun) {
+    const migration = allMigrations.find((m) => m.name === name);
+    if (!migration) {
+      throw new Error(`migrations.errors.not-found: ${name}`);
+    }
+    if (dryRun) {
+      logger4.info(`[DRY RUN] specific migration to run: ${migration.name}`);
+      return;
+    }
+    const batch = await this.nextBatchNumber();
+    await this.executeMigrationUp(migration, batch);
+  }
+  async executeMigrationUp(migration, batch) {
+    logger4.info(`running up → ${migration.name}`);
+    const start = Date.now();
+    const session = await this.connection.startSession();
+    try {
+      await session.withTransaction(async () => {
+        await migration.up(this.connection, session);
+        const duration2 = Date.now() - start;
+        await MigrationModel.findOneAndUpdate({ name: migration.name }, {
+          name: migration.name,
+          batch,
+          status: "up",
+          executedAt: new Date,
+          duration: duration2,
+          error: undefined
+        }, { upsert: true, returnDocument: "after", session }).exec();
+      });
+      const duration = Date.now() - start;
+      logger4.info(`✓ ${migration.name} (${duration}ms)`);
+    } catch (err) {
+      const duration = Date.now() - start;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      await MigrationModel.findOneAndUpdate({ name: migration.name }, {
+        name: migration.name,
+        batch,
+        status: "failed",
+        executedAt: new Date,
+        duration,
+        error: errorMessage
+      }, { upsert: true, returnDocument: "after" }).exec();
+      logger4.error(`✗ ${migration.name} — ${errorMessage}`);
+      throw err;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async runLastBatchDown(allMigrations, dryRun) {
+    const lastBatch = await this.fetchLastBatch();
+    if (lastBatch === null) {
+      logger4.info("nothing to roll back");
+      return;
+    }
+    const lastBatchRecords = await MigrationModel.find({ batch: lastBatch }).sort({ name: -1 }).lean().exec();
+    const migrationByName = new Map(allMigrations.map((m) => [m.name, m]));
+    const toRollback = lastBatchRecords.map((r) => migrationByName.get(r.name)).filter((m) => m !== undefined);
+    if (dryRun) {
+      logger4.info(`[DRY RUN] migrations to roll back (batch ${lastBatch}):`);
+      for (const m of sortMigrationsDesc(toRollback))
+        logger4.info(`[DRY RUN]   → ${m.name}`);
+      return;
+    }
+    for (const record of sortMigrationsDesc(toRollback)) {
+      await this.executeMigrationDown(record);
+    }
+  }
+  async runSpecificDown(allMigrations, name, dryRun) {
+    const migration = allMigrations.find((m) => m.name === name);
+    if (!migration) {
+      throw new Error(`migrations.errors.not-found: ${name}`);
+    }
+    if (dryRun) {
+      logger4.info(`[DRY RUN] specific migration to roll back: ${migration.name}`);
+      return;
+    }
+    await this.executeMigrationDown(migration);
+  }
+  async executeMigrationDown(migration) {
+    if (!migration.down) {
+      throw new Error(`migrations.errors.missing-down-export: ${migration.name}`);
+    }
+    logger4.info(`running down → ${migration.name}`);
+    const start = Date.now();
+    const session = await this.connection.startSession();
+    try {
+      await session.withTransaction(async () => {
+        await migration.down?.(this.connection, session);
+        await MigrationModel.deleteOne({ name: migration.name }).session(session).exec();
+      });
+      const duration = Date.now() - start;
+      logger4.info(`✓ rolled back ${migration.name} (${duration}ms)`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger4.error(`✗ rollback failed ${migration.name} — ${errorMessage}`);
+      throw err;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async fetchExecutedNames() {
+    const records = await MigrationModel.find({ status: "up" }, { name: 1 }).lean().exec();
+    return new Set(records.map((r) => r.name));
+  }
+  async fetchLastBatch() {
+    const record = await MigrationModel.findOne({ status: "up" }).sort({ batch: -1 }).select("batch").lean().exec();
+    return record?.batch ?? null;
+  }
+  async nextBatchNumber() {
+    const last = await this.fetchLastBatch();
+    return (last ?? 0) + 1;
+  }
+}
+
+// src/migrations/migrate.ts
+function resolveUri(options) {
+  const uri = options.uri ?? Bun.env.MONGODB_URI;
+  if (!uri) {
+    throw new Error("migrations.errors.missing-uri: provide `uri` in options or set MONGODB_URI");
+  }
+  return uri;
+}
+async function migrate(operation = "list", options) {
+  if (operation === "create") {
+    const runner2 = new MigrationRunner({
+      migrationsDir: options.migrationsDir,
+      connection: null
+    });
+    await runner2.create(options.create ?? { name: "unnamed-migration" });
+    return;
+  }
+  const uri = resolveUri(options);
+  await mongoose.connect(uri);
+  const runner = new MigrationRunner({
+    migrationsDir: options.migrationsDir,
+    connection: mongoose.connection
+  });
+  try {
+    if (operation === "list") {
+      await runner.list();
+    } else {
+      await runner[operation](options[operation]);
+    }
+  } finally {
+    await disconnectQuietly();
+  }
+}
+async function withMigrationRunner(options, fn) {
+  const uri = resolveUri(options);
+  await mongoose.connect(uri);
+  const runner = new MigrationRunner({
+    migrationsDir: options.migrationsDir,
+    connection: mongoose.connection
+  });
+  try {
+    return await fn(runner);
+  } finally {
+    await disconnectQuietly();
+  }
+}
+// src/models/postal-address.model.ts
+import { Schema as Schema3 } from "mongoose";
+
+// src/validation/validators/index.ts
+var exports_validators = {};
+__export(exports_validators, {
+  email: () => email,
+  future: () => future,
+  guid: () => guid,
+  ip: () => ip,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  mac: () => mac,
+  max: () => max,
+  maxLength: () => maxLength,
+  min: () => min,
+  minLength: () => minLength,
+  negative: () => negative,
+  notBlank: () => notBlank,
+  notEmpty: () => notEmpty,
+  objectId: () => objectId,
+  past: () => past,
+  pattern: () => pattern,
+  phone: () => phone,
+  positive: () => positive,
+  range: () => range,
+  required: () => required,
+  size: () => size,
+  ssn: () => ssn,
+  street: () => street,
+  time: () => time,
+  url: () => url,
+  uuid: () => uuid,
+  zipCode: () => zipCode
+});
+
+// src/validation/validators/email.validator.ts
+import { REGEX } from "@nxgt/shared/helpers";
+import { isNil as isNil3 } from "lodash";
+
+// src/validation/validation.utils.ts
+import { translate as translate2 } from "@nxgt/i18n";
+import { cast } from "@nxgt/shared/helpers";
+import { isArray, isNil as isNil2 } from "lodash";
+function parseValidatorOptions(args) {
+  function parseField(field2) {
+    return isArray(field2) && field2.length === 2 && typeof field2[1] === "string" ? { value: field2[0], message: field2[1] } : { value: cast(field2) };
+  }
+  const field = parseField(args);
+  return {
+    ...field,
+    message: (options, defaultMessage) => (props) => {
+      return translate2(isNil2(props.value) ? "validation.errors.required" : field.message ?? defaultMessage ?? "", {
+        ...props,
+        ...options
+      });
+    }
+  };
+}
+
+// src/validation/validators/email.validator.ts
+function email(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({
+      domains: options.value.domains?.join(", "),
+      numberOfDomains: options.value.domains?.length ?? 0
+    }, "validation.errors.email"),
+    validator(value) {
+      return isNil3(value) || typeof value === "string" && REGEX.email.test(value) && (options.value.domains?.length ? options.value.domains.filter((domain) => value.includes(domain)).length === options.value.domains.length : true);
+    }
+  };
+}
+
+// src/validation/validators/future.validator.ts
+import i18next from "i18next";
+import { isNil as isNil4, omit as omit3 } from "lodash";
+import { DateTime } from "luxon";
+function future(args) {
+  const options = parseValidatorOptions(args);
+  const limit = DateTime.now().minus(omit3(options.value, "datetime"));
+  return {
+    message: options.message?.({
+      limit: limit.setLocale(i18next.language).toLocaleString(options.value.datetime ?? true ? DateTime.DATETIME_FULL : DateTime.DATE_FULL)
+    }, "validation.errors.future"),
+    validator(value) {
+      return isNil4(value) || value instanceof Date && DateTime.fromJSDate(value).isValid && DateTime.fromJSDate(value) >= limit;
+    }
+  };
+}
+
+// src/validation/validators/guid.validator.ts
+import { REGEX as REGEX2 } from "@nxgt/shared/helpers";
+import { isNil as isNil5 } from "lodash";
+function guid(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.guid"),
+    validator(value) {
+      return isNil5(value) || typeof value === "string" && REGEX2.guid.test(value);
+    }
+  };
+}
+
+// src/validation/validators/ip.validator.ts
+import { REGEX as REGEX3 } from "@nxgt/shared/helpers";
+import { isNil as isNil6 } from "lodash";
+function ip(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.ip"),
+    validator(value) {
+      return isNil6(value) || typeof value === "string" && REGEX3.ip.test(value);
+    }
+  };
+}
+
+// src/validation/validators/ipv4.validator.ts
+import { REGEX as REGEX4 } from "@nxgt/shared/helpers";
+import { isNil as isNil7 } from "lodash";
+function ipv4(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.ipv4"),
+    validator(value) {
+      return isNil7(value) || typeof value === "string" && REGEX4.ipv4.test(value);
+    }
+  };
+}
+
+// src/validation/validators/ipv6.validator.ts
+import { REGEX as REGEX5 } from "@nxgt/shared/helpers";
+import { isNil as isNil8 } from "lodash";
+function ipv6(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.ipv6"),
+    validator(value) {
+      return isNil8(value) || typeof value === "string" && REGEX5.ipv6.test(value);
+    }
+  };
+}
+
+// src/validation/validators/mac.validator.ts
+import { REGEX as REGEX6 } from "@nxgt/shared/helpers";
+import { isNil as isNil9 } from "lodash";
+function mac(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.mac"),
+    validator(value) {
+      return isNil9(value) || typeof value === "string" && REGEX6.mac.test(value);
+    }
+  };
+}
+
+// src/validation/validators/max.validator.ts
+import { isNil as isNil10 } from "lodash";
+function max(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({ max: options.value }, "validation.errors.max"),
+    validator(value) {
+      return isNil10(value) || typeof value === "number" && value <= options.value;
+    }
+  };
+}
+
+// src/validation/validators/max-length.validator.ts
+import { isArray as isArray2, isNil as isNil11 } from "lodash";
+function maxLength(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({ maxLength: options.value }, "validation.errors.max-length"),
+    validator(value) {
+      return isNil11(value) || typeof value === "string" && value.length <= options.value || isArray2(value) && value.length <= options.value;
+    }
+  };
+}
+
+// src/validation/validators/min.validator.ts
+import { isNil as isNil12 } from "lodash";
+function min(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({ min: options.value }, "validation.errors.min"),
+    validator(value) {
+      return isNil12(value) || typeof value === "number" && value >= options.value;
+    }
+  };
+}
+
+// src/validation/validators/min-length.validator.ts
+import { isArray as isArray3, isNil as isNil13 } from "lodash";
+function minLength(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({ minLength: options.value }, "validation.errors.min-length"),
+    validator(value) {
+      return isNil13(value) || typeof value === "string" && value.length >= options.value || isArray3(value) && value.length >= options.value;
+    }
+  };
+}
+
+// src/validation/validators/negative.validator.ts
+import { isNil as isNil14 } from "lodash";
+function negative(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.negative"),
+    validator(value) {
+      return isNil14(value) || typeof value === "number" && value <= 0;
+    }
+  };
+}
+
+// src/validation/validators/not-blank.validator.ts
+import { isEmpty, isNil as isNil15 } from "lodash";
+function notBlank(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.not-blank"),
+    validator(value) {
+      return isNil15(value) || typeof value === "string" && !isEmpty(value.trim());
+    }
+  };
+}
+
+// src/validation/validators/not-empty.validator.ts
+import { isArray as isArray4, isEmpty as isEmpty2, isNil as isNil16 } from "lodash";
+function notEmpty(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.not-empty"),
+    validator(value) {
+      return isNil16(value) || (typeof value === "string" || isArray4(value)) && !isEmpty2(value);
+    }
+  };
+}
+
+// src/validation/validators/object-id.validator.ts
+import { REGEX as REGEX7 } from "@nxgt/shared/helpers";
+import { isNil as isNil17 } from "lodash";
+function objectId(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.object-id"),
+    validator(value) {
+      return isNil17(value) || typeof value === "string" && REGEX7.objectId.test(value);
+    }
+  };
+}
+
+// src/validation/validators/past.validator.ts
+import i18next2 from "i18next";
+import { isNil as isNil18, omit as omit4 } from "lodash";
+import { DateTime as DateTime2 } from "luxon";
+function past(args) {
+  const options = parseValidatorOptions(args);
+  const limit = DateTime2.now().minus(omit4(options.value, "datetime"));
+  return {
+    message: options.message?.({
+      limit: limit.setLocale(i18next2.language).toLocaleString(options.value.datetime ?? true ? DateTime2.DATETIME_FULL : DateTime2.DATE_FULL)
+    }, "validation.errors.past"),
+    validator(value) {
+      return isNil18(value) || value instanceof Date && DateTime2.fromJSDate(value).isValid && DateTime2.fromJSDate(value) <= limit;
+    }
+  };
+}
+
+// src/validation/validators/pattern.validator.ts
+import { REGEX as REGEX8 } from "@nxgt/shared/helpers";
+import { isNil as isNil19 } from "lodash";
+function pattern(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({ pattern: options.value }, "validation.errors.pattern"),
+    validator(value) {
+      return isNil19(value) || REGEX8.regex(options.value).test(value.toString());
+    }
+  };
+}
+
+// src/validation/validators/phone.validator.ts
+import { REGEX as REGEX9 } from "@nxgt/shared/helpers";
+import { isNil as isNil20 } from "lodash";
+function phone(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.phone"),
+    validator(value) {
+      return isNil20(value) || typeof value === "string" && REGEX9.phone.test(value);
+    }
+  };
+}
+
+// src/validation/validators/positive.validator.ts
+import { isNil as isNil21 } from "lodash";
+function positive(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.positive"),
+    validator(value) {
+      return isNil21(value) || typeof value === "number" && value >= 0;
+    }
+  };
+}
+
+// src/validation/validators/range.validator.ts
+import { isNil as isNil22 } from "lodash";
+function range(args) {
+  const options = parseValidatorOptions(args);
+  if (options.value[0] > options.value[1]) {
+    throw new Error("First argument  must ne less than or equal to the second argument");
+  }
+  return {
+    message: options.message?.({ min: options.value[0], max: options.value[1] }, "validation.errors.range"),
+    validator(value) {
+      return isNil22(value) || typeof value === "number" && value >= options.value[0] && value <= options.value[1];
+    }
+  };
+}
+
+// src/validation/validators/required.validator.ts
+import { isEmpty as isEmpty3, isNil as isNil23 } from "lodash";
+function required(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.required"),
+    validator(value) {
+      return typeof value === "number" ? !isNil23(value) : !isNil23(value) && !isEmpty3(value);
+    }
+  };
+}
+
+// src/validation/validators/size.validator.ts
+import { isArray as isArray5, isNil as isNil24 } from "lodash";
+function size(args) {
+  const options = parseValidatorOptions(args);
+  if (options.value[0] > options.value[1]) {
+    throw new Error("First argument  must ne less than or equal to the second argument");
+  }
+  return {
+    message: options.message?.({ min: options.value[0], max: options.value[1] }, "validation.errors.size"),
+    validator(value) {
+      return isNil24(value) || (typeof value === "string" || isArray5(value)) && value.length >= options.value[0] && value.length <= options.value[1];
+    }
+  };
+}
+
+// src/validation/validators/ssn.validator.ts
+import { REGEX as REGEX10 } from "@nxgt/shared/helpers";
+import { isNil as isNil25 } from "lodash";
+function ssn(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.ssn"),
+    validator(value) {
+      return isNil25(value) || typeof value === "string" && REGEX10.ssn.test(value);
+    }
+  };
+}
+
+// src/validation/validators/street.validator.ts
+import { REGEX as REGEX11 } from "@nxgt/shared/helpers";
+import { isNil as isNil26 } from "lodash";
+function street(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.street"),
+    validator(value) {
+      return isNil26(value) || typeof value === "string" && REGEX11.street.test(value);
+    }
+  };
+}
+
+// src/validation/validators/time.validator.ts
+import { REGEX as REGEX12 } from "@nxgt/shared/helpers";
+import { isNil as isNil27 } from "lodash";
+function time(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.time"),
+    validator(value) {
+      return isNil27(value) || typeof value === "string" && REGEX12.time.test(value);
+    }
+  };
+}
+
+// src/validation/validators/url.validator.ts
+import { REGEX as REGEX13 } from "@nxgt/shared/helpers";
+import { isNil as isNil28 } from "lodash";
+function url(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({
+      domains: options.value.domains?.join(", "),
+      numberOfDomains: options.value.domains?.length ?? 0
+    }, "validation.errors.url"),
+    validator(value) {
+      return isNil28(value) || typeof value === "string" && REGEX13.url.test(value) && (options.value.domains?.length ? options.value.domains.filter((domain) => value.includes(domain)).length === options.value.domains.length : true);
+    }
+  };
+}
+
+// src/validation/validators/uuid.validator.ts
+import { REGEX as REGEX14 } from "@nxgt/shared/helpers";
+import { isNil as isNil29 } from "lodash";
+function uuid(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.uuid"),
+    validator(value) {
+      return isNil29(value) || typeof value === "string" && REGEX14.uuid.test(value);
+    }
+  };
+}
+
+// src/validation/validators/zip-code.validator.ts
+import { REGEX as REGEX15 } from "@nxgt/shared/helpers";
+import { isNil as isNil30 } from "lodash";
+function zipCode(args) {
+  const options = parseValidatorOptions(args);
+  return {
+    message: options.message?.({}, "validation.errors.zip-code"),
+    validator(value) {
+      return isNil30(value) || typeof value === "string" && REGEX15.zipCode.test(value);
+    }
+  };
+}
+// src/models/postal-address.model.ts
+var PostalAddressSchema = new Schema3({
+  street: { type: String, validate: exports_validators.maxLength(200) },
+  locality: { type: String, validate: exports_validators.maxLength(100) },
+  region: { type: String, validate: exports_validators.maxLength(100) },
+  postalCode: { type: String, validate: exports_validators.maxLength(20) },
+  country: { type: String, validate: exports_validators.size([2, 2]) }
+}, { _id: false });
+// src/services/crud.service.ts
+import { cleanObject } from "@nxgt/shared/helpers";
+import { CustomException as CustomException7 } from "@nxgt/shared-exceptions";
+class MongoCrudService {
+  constructor(principal) {
+    this.principal = principal;
+    this.extraModels = [];
+  }
+  get changesOptions() {
+    return {
+      models: [this.model, ...this.extraModels],
+      author: this.principal?.name || "system",
+      mutex: this.mutex
+    };
+  }
+  async find(filter2 = {}) {
+    return this.model.find(filter2).exec();
+  }
+  async findById(id) {
+    const entity = await this.model.findById(id).exec();
+    if (!entity) {
+      throw CustomException7.notFound({
+        message: `${this.model.collection.name}.errors.not-found`
+      });
+    }
+    return entity;
+  }
+  async create(input) {
+    const entity = await runWithChangesListening(async () => {
+      await this.beforeCreate(input);
+      const data = await this.buildCreateData(input);
+      return this.model.create({
+        ...data,
+        createdBy: this.principal?.name,
+        lastModifiedBy: this.principal?.name
+      });
+    }, this.changesOptions);
+    return this.findById(entity.id);
+  }
+  async findWritableById(id) {
+    const entity = await this.model.findById(id).exec();
+    if (!entity) {
+      throw CustomException7.notFound({
+        message: `${this.model.collection.name}.errors.not-found`
+      });
+    }
+    return entity;
+  }
+  async update(id, input) {
+    return runWithChangesListening(async () => {
+      const doc = await this.findWritableById(id);
+      await this.beforeUpdate(doc, input);
+      const data = await this.buildUpdateData(doc, input);
+      Object.assign(doc, cleanObject({
+        ...data,
+        lastModifiedBy: this.principal?.name
+      }));
+      await doc.save();
+      return this.findById(id);
+    }, this.changesOptions);
+  }
+  async deleteMany(ids) {
+    await runWithChangesListening(async () => {
+      await this.beforeDeleteMany(ids);
+      await integrityRegistry.validateDeletion(this.model.modelName, ids);
+      await integrityRegistry.runCascades(this.model.modelName, ids);
+      return this.model.deleteMany({ _id: { $in: ids } }).exec();
+    }, this.changesOptions);
+  }
+  async delete(id) {
+    await this.model.ensureExists({ _id: id }, {
+      message: `${this.model.collection.name}.errors.not-found`
+    });
+    await this.deleteMany([id]);
+  }
+  buildCreateData(input) {
+    return input;
+  }
+  buildUpdateData(_doc, input) {
+    return input;
+  }
+  async beforeDeleteMany(_ids) {}
+  async beforeCreate(_input) {}
+  async beforeUpdate(_doc, _input) {}
+}
+export {
+  AUDIT_CHANGE_STREAM,
+  AUDIT_EVENT,
+  AuditModel,
+  AuditService,
+  ChangeOperationType,
+  CommitType,
+  CursorPaginationOptions,
+  IntegrityRegistry,
+  MONGOOSE_PLUGINS,
+  MONGO_UTILS,
+  MigrationModel,
+  MigrationRunner,
+  MongoCrudService,
+  NestedOffsetPaginationOptions,
+  OffsetPaginationOptions,
+  PLUGIN_OPTIONS,
+  PostalAddressSchema,
+  SortDirection,
+  exports_validators as VALIDATORS,
+  addFilterCondition,
+  applyPlugins,
+  auditChanges,
+  buildArrayFilter,
+  buildDateRangeFilter,
+  buildListStringPatch,
+  buildListStringPatchUpdate,
+  buildRegexFilter,
+  buildSort,
+  castError,
+  checkVersion,
+  clearDatabase,
+  createMigrationFile,
+  integrityRegistry,
+  isMigrationFile,
+  isValidObjectID,
+  loadMigrationFiles,
+  logger4 as logger,
+  migrate,
+  migrationName,
+  migrationTimestamp,
+  mongoose,
+  objectIdFromString,
+  objectIdString,
+  paginateList,
+  patchListObjectId,
+  patchListString,
+  registerAuditSubscription,
+  resolveListStringPatch,
+  runWithChangesListening,
+  safeCreateView,
+  sortMigrationsAsc,
+  sortMigrationsDesc,
+  toObject,
+  toObjectId,
+  toObjectIds,
+  toObjects,
+  validObjectIds,
+  withMigrationRunner
+};
+
+//# debugId=91BF3312614B3B9464756E2164756E21
+//# sourceMappingURL=index.js.map