@cyberskill/shared 1.217.0 → 2.0.0

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

@@ -1,68 +1,110 @@
-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 { cloneDeep as C, isObject as N } from "lodash-es";
+import I from "migrate-mongo";
+import { Document as P } from "mongoose";
+import w from "mongoose-aggregate-paginate-v2";
+import { default as de } from "mongoose-aggregate-paginate-v2";
+import A 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 { v4 as D } from "uuid";
+import { getNestedValue as M, setNestedValue as T } from "../../util/object/object.util.js";
+import { regexSearchMapper as j } from "../../util/common/common.util.js";
+import { writeFileSync as x, pathExistsSync as $, readFileSync as F, appendFileSync as G } from "../fs/fs.util.js";
+import { PATH as E, MIGRATE_MONGO_CONFIG as v } from "../path/path.constant.js";
+import { validate as V } from "../../util/validate/validate.util.js";
+import { generateShortId as q, generateSlug as _ } 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) => {
+var U = Object.defineProperty, L = Object.defineProperties, k = Object.getOwnPropertyDescriptors, b = Object.getOwnPropertySymbols, Q = Object.prototype.hasOwnProperty, H = Object.prototype.propertyIsEnumerable, R = (n, t, e) => t in n ? U(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, f = (n, t) => {
   for (var e in t || (t = {}))
-    Q.call(t, e) && E(n, e, t[e]);
+    Q.call(t, e) && R(n, e, t[e]);
   if (b)
     for (var e of b(t))
-      H.call(t, e) && E(n, e, t[e]);
+      H.call(t, e) && R(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) => {
+}, S = (n, t) => L(n, k(t)), J = (n, t, e) => R(n, typeof t != "symbol" ? t + "" : t, e), o = (n, t, e) => new Promise((r, s) => {
   var u = (a) => {
     try {
       l(e.next(a));
-    } catch (m) {
-      s(m);
+    } catch (h) {
+      s(h);
     }
   }, c = (a) => {
     try {
       l(e.throw(a));
-    } catch (m) {
-      s(m);
+    } catch (h) {
+      s(h);
     }
   }, l = (a) => a.done ? r(a.value) : Promise.resolve(a.value).then(u, c);
   l((e = e.apply(n, t)).next());
 });
-const h = {
+const y = {
+  /**
+   * 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: D(),
       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: D, 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,
@@ -73,8 +115,24 @@ const h = {
     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;
+    }), r || s.add(y.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,
@@ -88,20 +146,40 @@ const h = {
       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 l = y.createSchema({ mongoose: n, schema: e, virtuals: u });
+    return y.applyPlugins(l, [
+      r && A,
+      s && w
+    ]), y.applyMiddlewares(l, c), n.model(t, l);
   },
+  /**
+   * 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 !V.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* () {
@@ -112,6 +190,15 @@ 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* () {
@@ -122,45 +209,78 @@ const h = {
       };
     }
   },
-  migrate: R(f({}, w), {
+  /**
+   * Migration utilities for MongoDB.
+   * This object extends the migrate-mongo library with additional configuration utilities.
+   */
+  migrate: S(f({}, I), {
+    /**
+     * 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);
+      x(E.MIGRATE_MONGO_CONFIG, t);
       const e = `
-${x}
+${v}
 `;
-      j(g.GIT_IGNORE) ? F(g.GIT_IGNORE, "utf-8").split(`
-`).includes(x) || G(g.GIT_IGNORE, e) : D(g.GIT_IGNORE, e);
+      $(E.GIT_IGNORE) ? F(E.GIT_IGNORE, "utf-8").split(`
+`).includes(v) || G(E.GIT_IGNORE, e) : x(E.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 = C(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)}.*`,
+          $regex: `.*${j(u)}.*`,
           $options: "i"
         };
-        e = A(e, s, c);
+        e = T(e, s, c);
       }
     }
     return e;
   }
 };
-class ce {
+class oe {
+  /**
+   * 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);
   }
+  /**
+   * 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* () {
       try {
-        const e = f(f({}, h.createGenericFields()), t);
+        const e = f(f({}, y.createGenericFields()), t);
         return (yield this.collection.insertOne(e)).acknowledged ? {
           success: !0,
           message: "Document created successfully",
@@ -175,10 +295,17 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
-        const e = t.map((s) => f(f({}, h.createGenericFields()), s)), r = yield this.collection.insertMany(e);
+        const e = t.map((s) => f(f({}, y.createGenericFields()), s)), r = yield this.collection.insertMany(e);
         return r.insertedCount === 0 ? {
           success: !1,
           message: "No documents were inserted",
@@ -193,6 +320,12 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -203,6 +336,12 @@ class ce {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -216,6 +355,12 @@ class ce {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -229,6 +374,13 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -249,6 +401,13 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -269,6 +428,12 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -287,6 +452,12 @@ class ce {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -306,13 +477,32 @@ class ce {
     });
   }
 }
-class oe {
+class ie {
+  /**
+   * 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.
+   *
+   * @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) {
       try {
@@ -329,6 +519,15 @@ class oe {
       }
     });
   }
+  /**
+   * Finds all documents with optional population and projection.
+   *
+   * @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) {
       try {
@@ -339,6 +538,13 @@ class oe {
       }
     });
   }
+  /**
+   * Finds documents with pagination support.
+   *
+   * @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 = {}) {
       try {
@@ -348,6 +554,13 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -360,6 +573,12 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -369,6 +588,12 @@ class oe {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -378,15 +603,30 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       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((c) => c instanceof P ? c.toObject() : null).filter((c) => c !== null) };
       } catch (s) {
         return i(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 = {}) {
       try {
@@ -403,6 +643,14 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -412,6 +660,13 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -426,6 +681,13 @@ class oe {
       }
     });
   }
+  /**
+   * 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 = {}) {
       try {
@@ -440,14 +702,24 @@ class oe {
       }
     });
   }
+  /**
+   * 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* () {
       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 }, (l, a) => q(t, a + e)), c = (yield Promise.all(
+          s.map((l) => this.model.exists({ shortId: l }))
+        )).findIndex((l) => !l);
+        if (c !== -1) {
+          const l = s[c];
+          if (l)
+            return { success: !0, result: l };
         }
         return {
           success: !1,
@@ -459,43 +731,81 @@ class oe {
       }
     });
   }
+  /**
+   * 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), {
+    return r ? S(f({}, u), {
       $or: [
         { [`slug.${e}`]: t },
         { slugHistory: { $elemMatch: { [`slug.${e}`]: t } } }
       ]
-    }) : R(f({}, u), {
+    }) : S(f({}, u), {
       $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;
+      const c = _(e), a = Array.from({ length: 100 }, (m, p) => p === 0 ? c : `${c}-${p}`), g = (yield Promise.all(
+        a.map(
+          (m) => this.model.exists(this.createSlugQuery({ slug: m, field: r, isObject: s, filter: u }))
+        )
+      )).findIndex((m) => !m);
+      if (g !== -1) {
+        const m = a[g];
+        if (m)
+          return m;
+      }
+      return `${c}-${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 }) {
       try {
         const u = r[e];
-        return S(u) ? { success: !0, result: Object.fromEntries(
+        return N(u) ? { 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(u).map((h) => o(this, [h], function* ([g, m]) {
+              const p = yield this.createUniqueSlug({
+                slug: m,
+                field: g,
                 isObject: !0,
                 filter: s
               });
-              return [y, _];
+              return [g, p];
             }))
           )
         ) } : { success: !0, result: yield this.createUniqueSlug({
@@ -509,24 +819,35 @@ class oe {
       }
     });
   }
+  /**
+   * 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 }) {
       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 };
+        if (N(c)) {
+          const m = Object.values(c).map((O) => _(O));
+          return (yield Promise.all(
+            m.map(
+              (O) => this.model.exists(this.createSlugQuery({
+                slug: O,
+                field: r,
+                isObject: !0,
+                filter: u
+              }))
+            )
+          )).some((O) => O) ? { success: !0, result: !0 } : { success: !0, result: !1 };
         }
-        const a = O(e);
+        const a = _(e);
         return { success: !0, result: (yield this.model.exists(this.createSlugQuery({
           slug: a,
           field: r,
@@ -538,6 +859,12 @@ class oe {
       }
     });
   }
+  /**
+   * 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* () {
       try {
@@ -549,9 +876,9 @@ class oe {
   }
 }
 export {
-  ce as MongoController,
-  oe as MongooseController,
-  ae as aggregatePaginate,
-  h as mongo,
+  oe as MongoController,
+  ie as MongooseController,
+  de as aggregatePaginate,
+  y as mongo,
   fe as mongoosePaginate
 };