@cyberskill/shared 1.217.0 → 2.1.0

package/dist/node/mongo/mongo.util.js

@@ -1,68 +1,111 @@
-import { cloneDeep as v, isObject as S } from "lodash-es";
-import w from "migrate-mongo";
-import { Document as I } from "mongoose";
-import C from "mongoose-aggregate-paginate-v2";
-import { default as ae } from "mongoose-aggregate-paginate-v2";
-import P from "mongoose-paginate-v2";
-import { default as fe } from "mongoose-paginate-v2";
-import { v4 as N } from "uuid";
-import { getNestedValue as M, setNestedValue as A } from "../../util/object/object.util.js";
-import { regexSearchMapper as T } from "../../util/common/common.util.js";
-import { writeFileSync as D, pathExistsSync as j, readFileSync as F, appendFileSync as G } from "../fs/fs.util.js";
-import { PATH as g, MIGRATE_MONGO_CONFIG as x } from "../path/path.constant.js";
-import { validate as $ } from "../../util/validate/validate.util.js";
-import { generateShortId as q, generateSlug as O } from "../../util/string/string.util.js";
-import { RESPONSE_STATUS as d } from "../../constant/response-status.js";
-import { catchError as i } from "../log/log.util.js";
-var V = Object.defineProperty, U = Object.defineProperties, L = Object.getOwnPropertyDescriptors, b = Object.getOwnPropertySymbols, Q = Object.prototype.hasOwnProperty, H = Object.prototype.propertyIsEnumerable, E = (n, t, e) => t in n ? V(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, f = (n, t) => {
+import { cloneDeep as U, isObject as $ } from "lodash-es";
+import k from "migrate-mongo";
+import { Document as K } from "mongoose";
+import W from "mongoose-aggregate-paginate-v2";
+import Q from "mongoose-paginate-v2";
+import { v4 as F } from "uuid";
+import { getNestedValue as H, setNestedValue as z } from "../../util/object/object.util.js";
+import { regexSearchMapper as J } from "../../util/common/common.util.js";
+import { writeFileSync as G, pathExistsSync as X, readFileSync as Y, appendFileSync as Z } from "../fs/fs.util.js";
+import { PATH as x, MIGRATE_MONGO_CONFIG as q } from "../path/path.constant.js";
+import { validate as ee } from "../../util/validate/validate.util.js";
+import { generateShortId as te, generateSlug as j } from "../../util/string/string.util.js";
+import { RESPONSE_STATUS as R } from "../../constant/response-status.js";
+import { catchError as f } from "../log/log.util.js";
+var re = Object.defineProperty, se = Object.defineProperties, ne = Object.getOwnPropertyDescriptors, L = Object.getOwnPropertySymbols, ce = Object.prototype.hasOwnProperty, ue = Object.prototype.propertyIsEnumerable, T = (n, t, e) => t in n ? re(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, E = (n, t) => {
   for (var e in t || (t = {}))
-    Q.call(t, e) && E(n, e, t[e]);
-  if (b)
-    for (var e of b(t))
-      H.call(t, e) && E(n, e, t[e]);
+    ce.call(t, e) && T(n, e, t[e]);
+  if (L)
+    for (var e of L(t))
+      ue.call(t, e) && T(n, e, t[e]);
   return n;
-}, R = (n, t) => U(n, L(t)), J = (n, t, e) => E(n, typeof t != "symbol" ? t + "" : t, e), o = (n, t, e) => new Promise((r, s) => {
-  var u = (a) => {
+}, w = (n, t) => se(n, ne(t)), oe = (n, t, e) => T(n, typeof t != "symbol" ? t + "" : t, e), a = (n, t, e) => new Promise((r, s) => {
+  var c = (i) => {
     try {
-      l(e.next(a));
-    } catch (m) {
-      s(m);
+      o(e.next(i));
+    } catch (l) {
+      s(l);
     }
-  }, c = (a) => {
+  }, u = (i) => {
     try {
-      l(e.throw(a));
-    } catch (m) {
-      s(m);
+      o(e.throw(i));
+    } catch (l) {
+      s(l);
     }
-  }, l = (a) => a.done ? r(a.value) : Promise.resolve(a.value).then(u, c);
-  l((e = e.apply(n, t)).next());
+  }, o = (i) => i.done ? r(i.value) : Promise.resolve(i.value).then(c, u);
+  o((e = e.apply(n, t)).next());
 });
-const h = {
+function ie(n) {
+  return n === n.toUpperCase() ? n.charAt(0).toUpperCase() + n.slice(1).toLowerCase() : n;
+}
+const b = {
+  /**
+   * Creates generic fields that are commonly used across MongoDB documents.
+   * This function generates standard fields including a UUID, deletion flag, and timestamps
+   * that can be applied to any document schema.
+   *
+   * @returns An object containing generic document fields (id, isDel, createdAt, updatedAt).
+   */
   createGenericFields() {
     return {
-      id: N(),
+      id: F(),
       isDel: !1,
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
   },
+  /**
+   * Applies plugins to a Mongoose schema.
+   * This function filters out falsy plugins and applies the remaining valid plugins
+   * to the provided schema.
+   *
+   * @param schema - The Mongoose schema to apply plugins to.
+   * @param plugins - An array of plugin functions or false values to filter and apply.
+   */
   applyPlugins(n, t) {
     t.filter((e) => typeof e == "function").forEach((e) => n.plugin(e));
   },
+  /**
+   * Applies middleware functions to a Mongoose schema.
+   * This function configures pre and post middleware for specified methods on the schema.
+   *
+   * @param schema - The Mongoose schema to apply middleware to.
+   * @param middlewares - An array of middleware configurations with method, pre, and post functions.
+   */
   applyMiddlewares(n, t) {
     t.forEach(({ method: e, pre: r, post: s }) => {
       e && r && n.pre(e, r), e && s && n.post(e, s);
     });
   },
+  /**
+   * Creates a generic Mongoose schema with common fields.
+   * This function creates a base schema with UUID field and deletion flag,
+   * configured with automatic timestamps.
+   *
+   * @param mongoose - The Mongoose instance to create the schema with.
+   * @returns A Mongoose schema with generic document fields.
+   */
   createGenericSchema(n) {
     return new n.Schema(
       {
-        id: { type: String, default: N, unique: !0 },
+        id: { type: String, default: F, unique: !0 },
         isDel: { type: Boolean, default: !1 }
       },
       { timestamps: !0 }
     );
   },
+  /**
+   * Creates a Mongoose schema with optional virtual fields and generic fields.
+   * This function creates a new Mongoose schema from the provided schema definition,
+   * optionally adds virtual fields, and includes generic fields (unless standalone is true).
+   *
+   * @param options - Configuration options including mongoose instance, schema definition, virtuals, and standalone flag.
+   * @param options.mongoose - The Mongoose instance to use for schema creation.
+   * @param options.schema - The schema definition object.
+   * @param options.virtuals - Optional array of virtual field configurations.
+   * @param options.standalone - Whether to exclude generic fields (default: false).
+   * @returns A configured Mongoose schema.
+   */
   createSchema({
     mongoose: n,
     schema: t,
@@ -70,41 +113,90 @@ const h = {
     standalone: r = !1
   }) {
     const s = new n.Schema(t);
-    return e.forEach(({ name: u, options: c, get: l }) => {
-      const a = s.virtual(u, c);
-      l && a.get(l);
-    }), r || s.add(h.createGenericSchema(n)), s;
+    return e.forEach(({ name: c, options: u, get: o }) => {
+      if (b.isDynamicVirtual(u)) {
+        const i = s.statics;
+        i._dynamicVirtuals || (i._dynamicVirtuals = []), i._dynamicVirtuals.push({
+          name: c,
+          options: u
+        });
+        const l = s.virtual(c);
+        o ? l.get(o) : l.get(function() {
+          var d;
+          return ((d = this._populated) == null ? void 0 : d[c]) || (u != null && u.count ? 0 : u != null && u.justOne ? null : []);
+        });
+      } else {
+        const i = s.virtual(c, u);
+        o && i.get(o);
+      }
+    }), r || s.add(b.createGenericSchema(n)), s;
   },
+  /**
+   * Creates a Mongoose model with plugins, middleware, and pagination support.
+   * This function creates a model from a schema with optional pagination and aggregation plugins,
+   * and applies any specified middleware. If a model with the same name already exists, it returns the existing model.
+   *
+   * @param options - Configuration options including mongoose instance, model name, schema, and feature flags.
+   * @param options.mongoose - The Mongoose instance to use for model creation.
+   * @param options.name - The name of the model to create.
+   * @param options.schema - The schema definition for the model.
+   * @param options.pagination - Whether to enable pagination plugin (default: false).
+   * @param options.aggregate - Whether to enable aggregation pagination plugin (default: false).
+   * @param options.virtuals - Optional array of virtual field configurations.
+   * @param options.middlewares - Optional array of middleware configurations.
+   * @returns A configured Mongoose model with extended functionality.
+   * @throws {Error} When the model name is not provided.
+   */
   createModel({
     mongoose: n,
     name: t,
     schema: e,
     pagination: r = !1,
     aggregate: s = !1,
-    virtuals: u = [],
-    middlewares: c = []
+    virtuals: c = [],
+    middlewares: u = []
   }) {
     if (!t)
       throw new Error("Model name is required.");
     if (n.models[t])
       return n.models[t];
-    const l = h.createSchema({ mongoose: n, schema: e, virtuals: u });
-    return h.applyPlugins(l, [
-      r && P,
-      s && C
-    ]), h.applyMiddlewares(l, c), n.model(t, l);
+    const o = b.createSchema({ mongoose: n, schema: e, virtuals: c });
+    return b.applyPlugins(o, [
+      r && Q,
+      s && W
+    ]), b.applyMiddlewares(o, u), n.model(t, o);
   },
+  /**
+   * Validation utilities for Mongoose schemas.
+   * This object provides common validation functions that can be used in Mongoose schema definitions.
+   */
   validator: {
+    /**
+     * Creates a required field validator.
+     * This function returns a validator that checks if a field value is not empty
+     * using the validate.isEmpty utility.
+     *
+     * @returns A validation function that returns true if the field is not empty.
+     */
     isRequired() {
       return function(n) {
-        return o(this, null, function* () {
-          return !$.isEmpty(n);
+        return a(this, null, function* () {
+          return !ee.isEmpty(n);
         });
       };
     },
+    /**
+     * Creates a unique field validator.
+     * This function returns a validator that checks if a field value is unique
+     * across the specified fields in the collection.
+     *
+     * @param fields - An array of field names to check for uniqueness.
+     * @returns A validation function that returns true if the value is unique across the specified fields.
+     * @throws {Error} When fields is not a non-empty array of strings.
+     */
     isUnique(n) {
       return function(t) {
-        return o(this, null, function* () {
+        return a(this, null, function* () {
           if (!Array.isArray(n) || n.length === 0)
             throw new Error("Fields must be a non-empty array of strings.");
           const e = { $or: n.map((s) => ({ [s]: t })) };
@@ -112,9 +204,18 @@ const h = {
         });
       };
     },
+    /**
+     * Creates a regex pattern validator.
+     * This function returns a validator that checks if a string value matches
+     * all provided regular expressions.
+     *
+     * @param regexArray - An array of regular expressions to test against the value.
+     * @returns A validation function that returns true if the value matches all regex patterns.
+     * @throws {Error} When regexArray is not an array of valid RegExp objects.
+     */
     matchesRegex(n) {
       return function(t) {
-        return o(this, null, function* () {
+        return a(this, null, function* () {
           if (!Array.isArray(n) || n.some((e) => !(e instanceof RegExp)))
             throw new Error("regexArray must be an array of valid RegExp objects.");
           return n.every((e) => e.test(t));
@@ -122,45 +223,213 @@ const h = {
       };
     }
   },
-  migrate: R(f({}, w), {
+  /**
+   * Migration utilities for MongoDB.
+   * This object extends the migrate-mongo library with additional configuration utilities.
+   */
+  migrate: w(E({}, k), {
+    /**
+     * Sets the migration configuration and updates .gitignore.
+     * This function creates a migration configuration file and ensures it's properly
+     * excluded from version control.
+     *
+     * @param options - Migration configuration options to write to the config file.
+     */
     setConfig: (n) => {
       const t = `// This file is automatically generated by the Cyberskill CLI.
 module.exports = ${JSON.stringify(n, null, 4)}`;
-      D(g.MIGRATE_MONGO_CONFIG, t);
+      G(x.MIGRATE_MONGO_CONFIG, t);
       const e = `
-${x}
+${q}
 `;
-      j(g.GIT_IGNORE) ? F(g.GIT_IGNORE, "utf-8").split(`
-`).includes(x) || G(g.GIT_IGNORE, e) : D(g.GIT_IGNORE, e);
+      X(x.GIT_IGNORE) ? Y(x.GIT_IGNORE, "utf-8").split(`
+`).includes(q) || Z(x.GIT_IGNORE, e) : G(x.GIT_IGNORE, e);
     }
   }),
+  /**
+   * Converts string values in a filter to regex patterns for case-insensitive search.
+   * This function recursively processes a filter object and converts string values in specified fields
+   * to MongoDB regex patterns that support accented character matching.
+   *
+   * @param filter - The filter object to process.
+   * @param fields - An array of field names to convert to regex patterns.
+   * @returns A new filter object with string values converted to regex patterns.
+   */
   regexify(n, t) {
     if (!n)
       return {};
-    let e = v(n);
+    let e = U(n);
     if (!t || t.length === 0)
       return e;
     for (const r of t) {
-      const s = r.toString().split("."), u = M(e, s);
-      if (typeof u == "string" && u.length > 0) {
-        const c = {
-          $regex: `.*${T(u)}.*`,
+      const s = r.toString().split("."), c = H(e, s);
+      if (typeof c == "string" && c.length > 0) {
+        const u = {
+          $regex: `.*${J(c)}.*`,
           $options: "i"
         };
-        e = A(e, s, c);
+        e = z(e, s, u);
       }
     }
     return e;
+  },
+  /**
+   * Checks if a virtual options object has a dynamic ref function.
+   *
+   * @param options - The virtual options to check.
+   * @returns True if the options contain a dynamic ref function.
+   */
+  isDynamicVirtual(n) {
+    return !!(n && typeof n.ref == "function");
   }
 };
-class ce {
+function le(n) {
+  return n !== null && typeof n == "object" && "toObject" in n && typeof n.toObject == "function";
+}
+function ae(n, t, e) {
+  if (!n.length || !t || !(e != null && e.ref))
+    return [];
+  const r = /* @__PURE__ */ new Map();
+  return n.forEach((s) => {
+    try {
+      const c = e.ref(s);
+      if (c == null)
+        return;
+      const u = typeof c == "string" ? c : String(c);
+      if (u && u.trim() !== "") {
+        const o = ie(u);
+        r.has(o) || r.set(o, []), r.get(o).push(s);
+      }
+    } catch (c) {
+      f(new Error(`Dynamic ref function failed for virtual "${t}": ${c instanceof Error ? c.message : String(c)}`));
+    }
+  }), Array.from(r.entries()).map(([s, c]) => ({ model: s, docs: c }));
+}
+function P(n, t, e, r, s) {
+  return a(this, null, function* () {
+    if (!t.length || !e.length || !r)
+      return t;
+    const c = e.filter((i) => {
+      if (Array.isArray(r))
+        return r.length > 0 && r.some((l) => typeof l == "string" ? l === i.name : l.path === i.name);
+      if (typeof r == "string")
+        return r === i.name;
+      if (typeof r == "object" && r !== null) {
+        const l = r;
+        return l.path && l.path === i.name || l.populate && l.populate === i.name;
+      }
+      return !1;
+    });
+    if (c.length === 0)
+      return t;
+    const u = U(t.map(
+      (i) => le(i) ? i.toObject() : i
+    ));
+    u.forEach((i) => {
+      c.forEach(({ name: l, options: d }) => {
+        if (!(l in i)) {
+          const m = i;
+          m[l] = d.count ? 0 : d.justOne ? null : [];
+        }
+      });
+    });
+    const o = /* @__PURE__ */ new Map();
+    for (const i of c) {
+      const { name: l, options: d } = i, m = ae(u, l, d);
+      for (const p of m) {
+        o.has(p.model) || o.set(p.model, {
+          virtuals: [],
+          localValueSets: /* @__PURE__ */ new Map(),
+          docsByLocalValue: /* @__PURE__ */ new Map()
+        });
+        const h = o.get(p.model);
+        h.virtuals.find((N) => N.name === l) || (h.virtuals.push(i), h.localValueSets.set(l, /* @__PURE__ */ new Set()));
+        const M = h.localValueSets.get(l);
+        p.docs.forEach((N) => {
+          const C = N[d.localField];
+          if (C != null) {
+            const _ = String(C);
+            M.add(_);
+            let v = -1;
+            const D = N;
+            D.id !== void 0 ? v = u.findIndex((V) => V.id === D.id) : D._id !== void 0 && (v = u.findIndex((V) => {
+              var O, g, S, y;
+              return ((g = (O = V._id) == null ? void 0 : O.toString) == null ? void 0 : g.call(O)) === ((y = (S = D._id) == null ? void 0 : S.toString) == null ? void 0 : y.call(S));
+            })), v !== -1 && (h.docsByLocalValue.has(_) || h.docsByLocalValue.set(_, []), h.docsByLocalValue.get(_).push(v));
+          }
+        });
+      }
+    }
+    return yield Promise.all(Array.from(o.entries()).map((i) => a(null, [i], function* ([l, d]) {
+      const m = n.models[l];
+      if (!m)
+        return;
+      const p = /* @__PURE__ */ new Set();
+      if (d.localValueSets.forEach((_) => {
+        _.forEach((v) => p.add(v));
+      }), p.size === 0)
+        return;
+      const h = [...new Set(d.virtuals.map((_) => _.options.foreignField))], M = Array.from(p);
+      let N;
+      h.length === 1 ? N = { [String(h[0])]: { $in: M } } : N = { $or: h.map((_) => ({ [_]: { $in: M } })) };
+      const C = yield m.find(N, s).lean();
+      for (const _ of d.virtuals) {
+        const { name: v, options: D } = _, V = C.filter((O) => {
+          const g = O[D.foreignField];
+          return g != null && p.has(String(g));
+        });
+        if (D.count) {
+          const O = /* @__PURE__ */ new Map();
+          V.forEach((g) => {
+            var S;
+            const y = (S = g[D.foreignField]) == null ? void 0 : S.toString();
+            y && O.set(y, (O.get(y) || 0) + 1);
+          }), d.localValueSets.get(v).forEach((g) => {
+            const S = d.docsByLocalValue.get(g) || [], y = O.get(g) || 0;
+            S.forEach((A) => {
+              const I = u[A];
+              I[v] === void 0 && (I[v] = y);
+            });
+          });
+        } else {
+          const O = /* @__PURE__ */ new Map();
+          V.forEach((g) => {
+            var S;
+            const y = (S = g[D.foreignField]) == null ? void 0 : S.toString();
+            y && (O.has(y) || O.set(y, []), O.get(y).push(g));
+          }), d.localValueSets.get(v).forEach((g) => {
+            const S = d.docsByLocalValue.get(g) || [], y = O.get(g) || [], A = D.justOne ? y[0] || null : y;
+            S.forEach((I) => {
+              const B = u[I];
+              B[v] = A;
+            });
+          });
+        }
+      }
+    }))), u;
+  });
+}
+class Ne {
+  /**
+   * Creates a new MongoDB controller instance.
+   *
+   * @param db - The MongoDB database instance.
+   * @param collectionName - The name of the collection to operate on.
+   */
   constructor(t, e) {
-    J(this, "collection"), this.collection = t.collection(e);
+    oe(this, "collection"), this.collection = t.collection(e);
   }
+  /**
+   * Creates a single document in the collection.
+   * This method adds generic fields (id, isDel, timestamps) to the document before insertion.
+   *
+   * @param document - The document to create, with or without generic fields.
+   * @returns A promise that resolves to a standardized response with the created document.
+   */
   createOne(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
-        const e = f(f({}, h.createGenericFields()), t);
+        const e = E(E({}, b.createGenericFields()), t);
         return (yield this.collection.insertOne(e)).acknowledged ? {
           success: !0,
           message: "Document created successfully",
@@ -168,43 +437,62 @@ class ce {
         } : {
           success: !1,
           message: "Document creation failed",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Creates multiple documents in the collection.
+   * This method adds generic fields to each document before bulk insertion.
+   *
+   * @param documents - An array of documents to create.
+   * @returns A promise that resolves to a standardized response with the created documents.
+   */
   createMany(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
-        const e = t.map((s) => f(f({}, h.createGenericFields()), s)), r = yield this.collection.insertMany(e);
+        const e = t.map((s) => E(E({}, b.createGenericFields()), s)), r = yield this.collection.insertMany(e);
         return r.insertedCount === 0 ? {
           success: !1,
           message: "No documents were inserted",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         } : {
           success: !0,
           message: `${r.insertedCount} documents created successfully`,
           result: e
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Finds a single document by filter criteria.
+   *
+   * @param filter - The filter criteria to find the document.
+   * @returns A promise that resolves to a standardized response with the found document.
+   */
   findOne(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         const e = yield this.collection.findOne(t);
-        return e ? { success: !0, message: "Document found", result: e } : { success: !1, message: "Document not found", code: d.NOT_FOUND.CODE };
+        return e ? { success: !0, message: "Document found", result: e } : { success: !1, message: "Document not found", code: R.NOT_FOUND.CODE };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Finds all documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find documents (defaults to empty object for all documents).
+   * @returns A promise that resolves to a standardized response with the found documents.
+   */
   findAll() {
-    return o(this, arguments, function* (t = {}) {
+    return a(this, arguments, function* (t = {}) {
       try {
         return {
           success: !0,
@@ -212,25 +500,39 @@ class ce {
           result: yield this.collection.find(t).toArray()
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Counts documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to count documents (defaults to empty object for all documents).
+   * @returns A promise that resolves to a standardized response with the document count.
+   */
   count() {
-    return o(this, arguments, function* (t = {}) {
+    return a(this, arguments, function* (t = {}) {
       try {
+        const e = yield this.collection.countDocuments(t);
         return {
           success: !0,
-          message: "Count retrieved successfully",
-          result: yield this.collection.countDocuments(t)
+          message: `${e} documents counted successfully`,
+          result: e
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Updates a single document matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find the document to update.
+   * @param update - The update data to apply to the document.
+   * @returns A promise that resolves to a standardized response with the update result.
+   */
   updateOne(t, e) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         const r = yield this.collection.updateOne(t, {
           $set: e
@@ -238,19 +540,26 @@ class ce {
         return r.matchedCount === 0 ? {
           success: !1,
           message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         } : {
           success: !0,
           message: "Document updated successfully",
           result: r
         };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Updates multiple documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find documents to update.
+   * @param update - The update data to apply to the documents.
+   * @returns A promise that resolves to a standardized response with the update result.
+   */
   updateMany(t, e) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         const r = yield this.collection.updateMany(t, {
           $set: e
@@ -258,300 +567,487 @@ class ce {
         return r.matchedCount === 0 ? {
           success: !1,
           message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         } : {
           success: !0,
           message: "Documents updated successfully",
           result: r
         };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Deletes a single document matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find the document to delete.
+   * @returns A promise that resolves to a standardized response with the delete result.
+   */
   deleteOne(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         const e = yield this.collection.deleteOne(t);
         return e.deletedCount === 0 ? {
           success: !1,
           message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         } : {
           success: !0,
           message: "Document deleted successfully",
           result: e
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Deletes multiple documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find documents to delete.
+   * @returns A promise that resolves to a standardized response with the delete result.
+   */
   deleteMany(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         const e = yield this.collection.deleteMany(t);
         return e.deletedCount === 0 ? {
           success: !1,
           message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         } : {
           success: !0,
           message: "Documents deleted successfully",
           result: e
         };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
 }
-class oe {
+class be {
+  /**
+   * Creates a new Mongoose controller instance.
+   *
+   * @param model - The Mongoose model to operate on.
+   */
   constructor(t) {
     this.model = t;
   }
+  /**
+   * Gets the model name for logging and error messages.
+   *
+   * @returns The name of the model.
+   */
   getModelName() {
     return this.model.modelName;
   }
+  /**
+   * Finds a single document with optional population and projection.
+   * Automatically handles dynamic virtual population if configured.
+   *
+   * @param filter - The filter criteria to find the document.
+   * @param projection - The fields to include/exclude in the result.
+   * @param options - Query options for the operation.
+   * @param populate - Population configuration for related documents.
+   * @returns A promise that resolves to a standardized response with the found document.
+   */
   findOne() {
-    return o(this, arguments, function* (t = {}, e = {}, r = {}, s) {
+    return a(this, arguments, function* (t = {}, e = {}, r = {}, s) {
       try {
-        const u = this.model.findOne(t, e, r);
-        s && u.populate(s);
-        const c = yield u.exec();
-        return c ? { success: !0, result: c } : {
-          success: !1,
-          message: `No ${this.getModelName()} found.`,
-          code: d.NOT_FOUND.CODE
-        };
-      } catch (u) {
-        return i(u);
+        const c = this.model.findOne(t, e, r), o = this.model.schema.statics._dynamicVirtuals;
+        s && (!o || o.length === 0) && c.populate(s);
+        const i = yield c.exec();
+        if (!i)
+          return {
+            success: !1,
+            message: `No ${this.getModelName()} found.`,
+            code: R.NOT_FOUND.CODE
+          };
+        let l = i;
+        if (o && o.length > 0) {
+          const d = yield P(this.model.base, [i], o, s);
+          l = d && d[0] ? d[0] : i;
+        }
+        return { success: !0, result: l };
+      } catch (c) {
+        return f(c);
       }
     });
   }
+  /**
+   * Finds all documents with optional population and projection.
+   * Automatically handles dynamic virtual population if configured.
+   *
+   * @param filter - The filter criteria to find documents.
+   * @param projection - The fields to include/exclude in the result.
+   * @param options - Query options for the operation.
+   * @param populate - Population configuration for related documents.
+   * @returns A promise that resolves to a standardized response with the found documents.
+   */
   findAll() {
-    return o(this, arguments, function* (t = {}, e = {}, r = {}, s) {
+    return a(this, arguments, function* (t = {}, e = {}, r = {}, s) {
       try {
-        const u = this.model.find(t, e, r);
-        return s && u.populate(s), { success: !0, result: yield u.exec() };
-      } catch (u) {
-        return i(u);
+        const c = this.model.find(t, e, r), o = this.model.schema.statics._dynamicVirtuals;
+        s && (!o || o.length === 0) && c.populate(s);
+        const i = yield c.exec();
+        let l = i;
+        return o && o.length > 0 && i.length > 0 && (l = yield P(this.model.base, i, o, s)), { success: !0, result: l };
+      } catch (c) {
+        return f(c);
       }
     });
   }
+  /**
+   * Finds documents with pagination support.
+   * Automatically handles dynamic virtual population if configured.
+   *
+   * @param filter - The filter criteria to find documents.
+   * @param options - Pagination options including page, limit, and population.
+   * @returns A promise that resolves to a standardized response with paginated results.
+   */
   findPaging() {
-    return o(this, arguments, function* (t = {}, e = {}) {
+    return a(this, arguments, function* (t = {}, e = {}) {
       try {
-        return { success: !0, result: yield this.model.paginate(t, e) };
+        const s = this.model.schema.statics._dynamicVirtuals, c = E({}, e);
+        s && s.length > 0 && (c.populate = void 0);
+        const u = yield this.model.paginate(t, c);
+        let o = u.docs;
+        return s && s.length > 0 && u.docs.length > 0 && (o = yield P(this.model.base, u.docs, s, e.populate)), { success: !0, result: w(E({}, u), { docs: o }) };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Performs aggregation with pagination support.
+   *
+   * @param pipeline - The aggregation pipeline stages.
+   * @param options - Pagination options for the aggregation result.
+   * @returns A promise that resolves to a standardized response with paginated aggregation results.
+   */
   findPagingAggregate(t) {
-    return o(this, arguments, function* (e, r = {}) {
+    return a(this, arguments, function* (e, r = {}) {
       try {
-        return { success: !0, result: yield this.model.aggregatePaginate(
+        const c = this.model.schema.statics._dynamicVirtuals, u = E({}, r);
+        c && c.length > 0 && (u.populate = void 0);
+        const o = yield this.model.aggregatePaginate(
           this.model.aggregate(e),
-          r
-        ) };
+          u
+        );
+        let i = o.docs;
+        return c && c.length > 0 && o.docs.length > 0 && (i = yield P(this.model.base, o.docs, c, r.populate)), { success: !0, result: w(E({}, o), { docs: i }) };
       } catch (s) {
-        return i(s);
+        return f(s);
       }
     });
   }
+  /**
+   * Counts documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to count documents.
+   * @returns A promise that resolves to a standardized response with the document count.
+   */
   count() {
-    return o(this, arguments, function* (t = {}) {
+    return a(this, arguments, function* (t = {}) {
       try {
         return { success: !0, result: yield this.model.countDocuments(t) };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Creates a single document.
+   *
+   * @param doc - The document to create.
+   * @returns A promise that resolves to a standardized response with the created document.
+   */
   createOne(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         return { success: !0, result: yield this.model.create(t) };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
+  /**
+   * Creates multiple documents with bulk insertion.
+   *
+   * @param docs - An array of documents to create.
+   * @param options - Options for the bulk insertion operation.
+   * @returns A promise that resolves to a standardized response with the created documents.
+   */
   createMany(t) {
-    return o(this, arguments, function* (e, r = {}) {
+    return a(this, arguments, function* (e, r = {}) {
       try {
-        return { success: !0, result: (yield this.model.insertMany(e, r)).map((c) => c instanceof I ? c.toObject() : null).filter((c) => c !== null) };
+        return { success: !0, result: (yield this.model.insertMany(e, r)).map((u) => u instanceof K ? u.toObject() : null).filter((u) => u !== null) };
       } catch (s) {
-        return i(s);
+        return f(s);
       }
     });
   }
+  /**
+   * Updates a single document and returns the updated version.
+   *
+   * @param filter - The filter criteria to find the document to update.
+   * @param update - The update data to apply.
+   * @param options - Options for the update operation.
+   * @returns A promise that resolves to a standardized response with the updated document.
+   */
   updateOne() {
-    return o(this, arguments, function* (t = {}, e = {}, r = {}) {
+    return a(this, arguments, function* (t = {}, e = {}, r = {}) {
       try {
-        const s = yield this.model.findOneAndUpdate(t, e, f({
+        const s = yield this.model.findOneAndUpdate(t, e, E({
           new: !0
         }, r)).exec();
         return s ? { success: !0, result: s } : {
           success: !1,
           message: `Failed to update ${this.getModelName()}.`,
-          code: d.NOT_FOUND.CODE
+          code: R.NOT_FOUND.CODE
         };
       } catch (s) {
-        return i(s);
+        return f(s);
       }
     });
   }
+  /**
+   * Updates multiple documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find documents to update.
+   * @param update - The update data to apply.
+   * @param options - Options for the update operation.
+   * @returns A promise that resolves to a standardized response with the update result.
+   */
   updateMany() {
-    return o(this, arguments, function* (t = {}, e = {}, r = {}) {
+    return a(this, arguments, function* (t = {}, e = {}, r = {}) {
       try {
         return { success: !0, result: yield this.model.updateMany(t, e, r).exec() };
       } catch (s) {
-        return i(s);
+        return f(s);
       }
     });
   }
+  /**
+   * Deletes a single document and returns the deleted version.
+   *
+   * @param filter - The filter criteria to find the document to delete.
+   * @param options - Options for the delete operation.
+   * @returns A promise that resolves to a standardized response with the deleted document.
+   */
   deleteOne() {
-    return o(this, arguments, function* (t = {}, e = {}) {
+    return a(this, arguments, function* (t = {}, e = {}) {
       try {
         const r = yield this.model.findOneAndDelete(t, e).exec();
         return r ? { success: !0, result: r } : {
           success: !1,
           message: `No ${this.getModelName()} found to delete.`,
-          code: d.NOT_FOUND.CODE
+          code: R.NOT_FOUND.CODE
         };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Deletes multiple documents matching the filter criteria.
+   *
+   * @param filter - The filter criteria to find documents to delete.
+   * @param options - Options for the delete operation.
+   * @returns A promise that resolves to a standardized response with the delete result.
+   */
   deleteMany() {
-    return o(this, arguments, function* (t = {}, e = {}) {
+    return a(this, arguments, function* (t = {}, e = {}) {
       try {
         const r = yield this.model.deleteMany(t, e).exec();
         return r.deletedCount === 0 ? {
           success: !1,
           message: "No documents found to delete.",
-          code: d.NOT_FOUND.CODE
+          code: R.NOT_FOUND.CODE
         } : { success: !0, result: r };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Creates a unique short ID based on a given ID.
+   * This method generates multiple short IDs with increasing lengths and finds the first available one.
+   *
+   * @param id - The base ID to generate short IDs from.
+   * @param length - The initial length for short ID generation (default: 4).
+   * @returns A promise that resolves to a standardized response with the unique short ID.
+   */
   createShortId(t, e = 4) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
-        const s = /* @__PURE__ */ new Set();
-        for (let u = 0; u < 10; u++) {
-          const c = q(t, u + e);
-          if (!s.has(c) && (s.add(c), !(yield this.model.exists({ shortId: c }))))
-            return { success: !0, result: c };
+        const s = Array.from({ length: 10 }, (o, i) => te(t, i + e)), u = (yield Promise.all(
+          s.map((o) => this.model.exists({ shortId: o }))
+        )).findIndex((o) => !o);
+        if (u !== -1) {
+          const o = s[u];
+          if (o)
+            return { success: !0, result: o };
         }
         return {
           success: !1,
           message: "Failed to create a unique shortId",
-          code: d.INTERNAL_SERVER_ERROR.CODE
+          code: R.INTERNAL_SERVER_ERROR.CODE
         };
       } catch (r) {
-        return i(r);
+        return f(r);
       }
     });
   }
+  /**
+   * Creates a query for slug existence checking.
+   * This method generates a query that checks for slug existence in both current and historical slug fields.
+   *
+   * @param options - Configuration for slug query generation including slug, field, and filter.
+   * @param options.slug - The slug string to check for existence.
+   * @param options.field - The field name for object-based slug checking.
+   * @param options.isObject - Whether the slug is stored as an object with nested fields.
+   * @param options.filter - Additional filter conditions to apply to the query.
+   * @returns A MongoDB query object for checking slug existence.
+   */
   createSlugQuery({ slug: t, field: e, isObject: r, filter: s }) {
-    const u = f({}, s != null ? s : {});
-    return r ? R(f({}, u), {
+    const c = E({}, s != null ? s : {});
+    return r ? w(E({}, c), {
       $or: [
         { [`slug.${e}`]: t },
         { slugHistory: { $elemMatch: { [`slug.${e}`]: t } } }
       ]
-    }) : R(f({}, u), {
+    }) : w(E({}, c), {
       $or: [
         { slug: t },
         { slugHistory: t }
       ]
     });
   }
+  /**
+   * Creates a unique slug based on a given string.
+   * This method generates multiple slug variations and finds the first available one.
+   *
+   * @param options - Configuration for slug generation including slug, field, and filter.
+   * @param options.slug - The base slug string to make unique.
+   * @param options.field - The field name for object-based slug checking.
+   * @param options.isObject - Whether the slug is stored as an object with nested fields.
+   * @param options.filter - Additional filter conditions to apply when checking slug existence.
+   * @returns A promise that resolves to a unique slug string.
+   */
   createUniqueSlug(t) {
-    return o(this, arguments, function* ({ slug: e, field: r, isObject: s, filter: u }) {
-      const c = O(e);
-      let l = c, a = 1;
-      for (; yield this.model.exists(this.createSlugQuery({ slug: l, field: r, isObject: s, filter: u })); )
-        l = `${c}-${a++}`;
-      return l;
+    return a(this, arguments, function* ({ slug: e, field: r, isObject: s, filter: c }) {
+      const u = j(e), i = Array.from({ length: 100 }, (m, p) => p === 0 ? u : `${u}-${p}`), d = (yield Promise.all(
+        i.map(
+          (m) => this.model.exists(this.createSlugQuery({ slug: m, field: r, isObject: s, filter: c }))
+        )
+      )).findIndex((m) => !m);
+      if (d !== -1) {
+        const m = i[d];
+        if (m)
+          return m;
+      }
+      return `${u}-${Date.now()}`;
     });
   }
+  /**
+   * Creates a slug for a document field.
+   * This method handles both simple string fields and object fields with nested slug generation.
+   *
+   * @param options - Configuration for slug creation including field, source document, and filter.
+   * @param options.field - The field name to create a slug for.
+   * @param options.from - The source document containing the field value.
+   * @param options.filter - Additional filter conditions to apply when checking slug existence.
+   * @returns A promise that resolves to a standardized response with the created slug(s).
+   */
   createSlug(t) {
-    return o(this, arguments, function* ({ field: e, from: r, filter: s }) {
+    return a(this, arguments, function* ({ field: e, from: r, filter: s }) {
       try {
-        const u = r[e];
-        return S(u) ? { success: !0, result: Object.fromEntries(
+        const c = r[e];
+        return $(c) ? { success: !0, result: Object.fromEntries(
           yield Promise.all(
-            Object.entries(u).map((m) => o(this, [m], function* ([y, p]) {
-              const _ = yield this.createUniqueSlug({
-                slug: p,
-                field: y,
+            Object.entries(c).map((l) => a(this, [l], function* ([d, m]) {
+              const p = yield this.createUniqueSlug({
+                slug: m,
+                field: d,
                 isObject: !0,
                 filter: s
               });
-              return [y, _];
+              return [d, p];
             }))
           )
         ) } : { success: !0, result: yield this.createUniqueSlug({
-          slug: u,
+          slug: c,
           field: e,
           isObject: !1,
           filter: s
         }) };
-      } catch (u) {
-        return i(u);
+      } catch (c) {
+        return f(c);
       }
     });
   }
+  /**
+   * Checks if a slug already exists in the collection.
+   * This method verifies slug existence in both current and historical slug fields.
+   *
+   * @param options - Configuration for slug checking including slug, field, source document, and filter.
+   * @param options.slug - The slug string to check for existence.
+   * @param options.field - The field name for object-based slug checking.
+   * @param options.from - The source document containing the field value.
+   * @param options.filter - Additional filter conditions to apply to the query.
+   * @returns A promise that resolves to a standardized response indicating whether the slug exists.
+   */
   checkSlug(t) {
-    return o(this, arguments, function* ({ slug: e, field: r, from: s, filter: u }) {
+    return a(this, arguments, function* ({ slug: e, field: r, from: s, filter: c }) {
       try {
-        const c = s[r];
-        if (S(c)) {
-          for (const y of Object.values(c)) {
-            const p = O(y);
-            if (yield this.model.exists(this.createSlugQuery({
-              slug: p,
-              field: r,
-              isObject: !0,
-              filter: u
-            })))
-              return { success: !0, result: !0 };
-          }
-          return { success: !0, result: !1 };
+        const u = s[r];
+        if ($(u)) {
+          const m = Object.values(u).map((h) => j(h));
+          return (yield Promise.all(
+            m.map(
+              (h) => this.model.exists(this.createSlugQuery({
+                slug: h,
+                field: r,
+                isObject: !0,
+                filter: c
+              }))
+            )
+          )).some((h) => h) ? { success: !0, result: !0 } : { success: !0, result: !1 };
         }
-        const a = O(e);
+        const i = j(e);
         return { success: !0, result: (yield this.model.exists(this.createSlugQuery({
-          slug: a,
+          slug: i,
           field: r,
           isObject: !1,
-          filter: u
+          filter: c
         }))) !== null };
-      } catch (c) {
-        return i(c);
+      } catch (u) {
+        return f(u);
       }
     });
   }
+  /**
+   * Performs aggregation operations on the collection.
+   *
+   * @param pipeline - The aggregation pipeline stages to execute.
+   * @returns A promise that resolves to a standardized response with the aggregation results.
+   */
   aggregate(t) {
-    return o(this, null, function* () {
+    return a(this, null, function* () {
       try {
         return { success: !0, result: yield this.model.aggregate(t) };
       } catch (e) {
-        return i(e);
+        return f(e);
       }
     });
   }
 }
 export {
-  ce as MongoController,
-  oe as MongooseController,
-  ae as aggregatePaginate,
-  h as mongo,
-  fe as mongoosePaginate
+  Ne as MongoController,
+  be as MongooseController,
+  b as mongo
 };