@cyberskill/shared 1.208.0 → 1.209.0

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

@@ -1,564 +1,488 @@
-var I = Object.defineProperty, M = Object.defineProperties;
-var b = Object.getOwnPropertyDescriptors;
-var S = Object.getOwnPropertySymbols;
-var A = Object.prototype.hasOwnProperty, T = Object.prototype.propertyIsEnumerable;
-var p = (c, t, e) => t in c ? I(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e, m = (c, t) => {
-  for (var e in t || (t = {}))
-    A.call(t, e) && p(c, e, t[e]);
-  if (S)
-    for (var e of S(t))
-      T.call(t, e) && p(c, e, t[e]);
-  return c;
-}, h = (c, t) => M(c, b(t));
-var N = (c, t, e) => p(c, typeof t != "symbol" ? t + "" : t, e);
-var a = (c, t, e) => new Promise((r, s) => {
-  var n = (l) => {
-    try {
-      i(e.next(l));
-    } catch (f) {
-      s(f);
-    }
-  }, u = (l) => {
-    try {
-      i(e.throw(l));
-    } catch (f) {
-      s(f);
-    }
-  }, i = (l) => l.done ? r(l.value) : Promise.resolve(l.value).then(n, u);
-  i((e = e.apply(c, t)).next());
-});
-import F from "migrate-mongo";
-import { Document as G } from "mongoose";
-import $ from "mongoose-aggregate-paginate-v2";
-import { default as de } from "mongoose-aggregate-paginate-v2";
-import j from "mongoose-paginate-v2";
-import { default as fe } from "mongoose-paginate-v2";
-import { v4 as w } from "uuid";
-import { RESPONSE_STATUS as d } from "../../constant/response-status.js";
-import { regexSearchMapper as q } from "../../util/common/common.util.js";
-import { deepClone as V, getNestedValue as v, setNestedValue as P, isObject as D } from "../../util/object/object.util.js";
-import { generateShortId as U, generateSlug as E } from "../../util/string/string.util.js";
-import { validate as L } from "../../util/validate/validate.util.js";
-import { writeFileSync as x, pathExistsSync as Q, readFileSync as H, appendFileSync as k } from "../fs/fs.util.js";
-import { catchError as o } from "../log/log.util.js";
-import { F as y, M as C } from "../../../path.constant-CvSr0Rrx.js";
-import "../path/path.util.js";
-const g = {
+import R from "migrate-mongo";
+import { Document as S } from "mongoose";
+import N from "mongoose-aggregate-paginate-v2";
+import { default as X } from "mongoose-aggregate-paginate-v2";
+import w from "mongoose-paginate-v2";
+import { default as Z } from "mongoose-paginate-v2";
+import { v4 as h } from "uuid";
+import { RESPONSE_STATUS as i } from "../../constant/response-status.js";
+import { deepClone as D, getNestedValue as x, setNestedValue as C, isObject as O } from "../../util/object/object.util.js";
+import { regexSearchMapper as _ } from "../../util/common/common.util.js";
+import { writeFileSync as p, pathExistsSync as I, readFileSync as M, appendFileSync as b } from "../fs/fs.util.js";
+import { P as m, M as E } from "../../../index-BG1UznTl.js";
+import { validate as A } from "../../util/validate/validate.util.js";
+import { generateShortId as T, generateSlug as y } from "../../util/string/string.util.js";
+import { catchError as u } from "../log/log.util.js";
+const l = {
   createGenericFields() {
     return {
-      id: w(),
+      id: h(),
       isDel: !1,
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
   },
-  applyPlugins(c, t) {
-    t.filter((e) => typeof e == "function").forEach((e) => c.plugin(e));
+  applyPlugins(n, t) {
+    t.filter((e) => typeof e == "function").forEach((e) => n.plugin(e));
   },
-  applyMiddlewares(c, t) {
+  applyMiddlewares(n, t) {
     t.forEach(({ method: e, pre: r, post: s }) => {
-      e && r && c.pre(e, r), e && s && c.post(e, s);
+      e && r && n.pre(e, r), e && s && n.post(e, s);
     });
   },
-  createGenericSchema(c) {
-    return new c.Schema(
+  createGenericSchema(n) {
+    return new n.Schema(
       {
-        id: { type: String, default: w, unique: !0 },
+        id: { type: String, default: h, unique: !0 },
         isDel: { type: Boolean, default: !1 }
       },
       { timestamps: !0 }
     );
   },
   createSchema({
-    mongoose: c,
+    mongoose: n,
     schema: t,
     virtuals: e = [],
     standalone: r = !1
   }) {
-    const s = new c.Schema(t);
-    return e.forEach(({ name: n, options: u, get: i }) => {
-      const l = s.virtual(n, u);
-      i && l.get(i);
-    }), r || s.add(g.createGenericSchema(c)), s;
+    const s = new n.Schema(t);
+    return e.forEach(({ name: c, options: a, get: o }) => {
+      const d = s.virtual(c, a);
+      o && d.get(o);
+    }), r || s.add(l.createGenericSchema(n)), s;
   },
   createModel({
-    mongoose: c,
+    mongoose: n,
     name: t,
     schema: e,
     pagination: r = !1,
     aggregate: s = !1,
-    virtuals: n = [],
-    middlewares: u = []
+    virtuals: c = [],
+    middlewares: a = []
   }) {
     if (!t)
       throw new Error("Model name is required.");
-    if (c.models[t])
-      return c.models[t];
-    const i = g.createSchema({ mongoose: c, schema: e, virtuals: n });
-    return g.applyPlugins(i, [
-      r && j,
-      s && $
-    ]), g.applyMiddlewares(i, u), c.model(t, i);
+    if (n.models[t])
+      return n.models[t];
+    const o = l.createSchema({ mongoose: n, schema: e, virtuals: c });
+    return l.applyPlugins(o, [
+      r && w,
+      s && N
+    ]), l.applyMiddlewares(o, a), n.model(t, o);
   },
   validator: {
     isRequired() {
-      return function(c) {
-        return a(this, null, function* () {
-          return !L.isEmpty(c);
-        });
+      return async function(n) {
+        return !A.isEmpty(n);
       };
     },
-    isUnique(c) {
-      return function(t) {
-        return a(this, null, function* () {
-          if (!Array.isArray(c) || c.length === 0)
-            throw new Error("Fields must be a non-empty array of strings.");
-          const e = { $or: c.map((s) => ({ [s]: t })) };
-          return !(yield this.constructor.exists(e));
-        });
+    isUnique(n) {
+      return async function(t) {
+        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 })) };
+        return !await this.constructor.exists(e);
       };
     },
-    matchesRegex(c) {
-      return function(t) {
-        return a(this, null, function* () {
-          if (!Array.isArray(c) || c.some((e) => !(e instanceof RegExp)))
-            throw new Error("regexArray must be an array of valid RegExp objects.");
-          return c.every((e) => e.test(t));
-        });
+    matchesRegex(n) {
+      return async function(t) {
+        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));
       };
     }
   },
-  migrate: h(m({}, F), {
-    setConfig: (c) => {
+  migrate: {
+    ...R,
+    setConfig: (n) => {
       const t = `// This file is automatically generated by the Cyberskill CLI.
-module.exports = ${JSON.stringify(c, null, 4)}`;
-      x(y.MIGRATE_MONGO_CONFIG, t);
+module.exports = ${JSON.stringify(n, null, 4)}`;
+      p(m.MIGRATE_MONGO_CONFIG, t);
       const e = `
-${C}
+${E}
 `;
-      Q(y.GIT_IGNORE) ? H(y.GIT_IGNORE, "utf-8").split(`
-`).includes(C) || k(y.GIT_IGNORE, e) : x(y.GIT_IGNORE, e);
+      I(m.GIT_IGNORE) ? M(m.GIT_IGNORE, "utf-8").split(`
+`).includes(E) || b(m.GIT_IGNORE, e) : p(m.GIT_IGNORE, e);
     }
-  }),
-  regexify(c, t) {
-    if (!c)
+  },
+  regexify(n, t) {
+    if (!n)
       return {};
-    let e = V(c);
+    let e = D(n);
     if (!t || t.length === 0)
       return e;
     for (const r of t) {
-      const s = r.toString().split("."), n = v(e, s);
-      if (typeof n == "string" && n.length > 0) {
-        const u = {
-          $regex: `.*${q(n)}.*`,
+      const s = r.toString().split("."), c = x(e, s);
+      if (typeof c == "string" && c.length > 0) {
+        const a = {
+          $regex: `.*${_(c)}.*`,
           $options: "i"
         };
-        e = P(e, s, u);
+        e = C(e, s, a);
       }
     }
     return e;
   }
 };
-class ae {
+class B {
+  collection;
   constructor(t, e) {
-    N(this, "collection");
     this.collection = t.collection(e);
   }
-  createOne(t) {
-    return a(this, null, function* () {
-      try {
-        const e = m(m({}, g.createGenericFields()), t);
-        return (yield this.collection.insertOne(e)).acknowledged ? {
-          success: !0,
-          message: "Document created successfully",
-          result: e
-        } : {
-          success: !1,
-          message: "Document creation failed",
-          code: d.INTERNAL_SERVER_ERROR.CODE
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async createOne(t) {
+    try {
+      const e = {
+        ...l.createGenericFields(),
+        ...t
+      };
+      return (await this.collection.insertOne(e)).acknowledged ? {
+        success: !0,
+        message: "Document created successfully",
+        result: e
+      } : {
+        success: !1,
+        message: "Document creation failed",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
-  createMany(t) {
-    return a(this, null, function* () {
-      try {
-        const e = t.map((s) => m(m({}, g.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
-        } : {
-          success: !0,
-          message: `${r.insertedCount} documents created successfully`,
-          result: e
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async createMany(t) {
+    try {
+      const e = t.map((s) => ({
+        ...l.createGenericFields(),
+        ...s
+      })), r = await this.collection.insertMany(e);
+      return r.insertedCount === 0 ? {
+        success: !1,
+        message: "No documents were inserted",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      } : {
+        success: !0,
+        message: `${r.insertedCount} documents created successfully`,
+        result: e
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
-  findOne(t) {
-    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 };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async findOne(t) {
+    try {
+      const e = await this.collection.findOne(t);
+      return e ? { success: !0, message: "Document found", result: e } : { success: !1, message: "Document not found", code: i.NOT_FOUND.CODE };
+    } catch (e) {
+      return u(e);
+    }
   }
-  findAll() {
-    return a(this, arguments, function* (t = {}) {
-      try {
-        return {
-          success: !0,
-          message: "Documents retrieved successfully",
-          result: yield this.collection.find(t).toArray()
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async findAll(t = {}) {
+    try {
+      return {
+        success: !0,
+        message: "Documents retrieved successfully",
+        result: await this.collection.find(t).toArray()
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
-  count() {
-    return a(this, arguments, function* (t = {}) {
-      try {
-        return {
-          success: !0,
-          message: "Count retrieved successfully",
-          result: yield this.collection.countDocuments(t)
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async count(t = {}) {
+    try {
+      return {
+        success: !0,
+        message: "Count retrieved successfully",
+        result: await this.collection.countDocuments(t)
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
-  updateOne(t, e) {
-    return a(this, null, function* () {
-      try {
-        const r = yield this.collection.updateOne(t, {
-          $set: e
-        });
-        return r.matchedCount === 0 ? {
-          success: !1,
-          message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
-        } : {
-          success: !0,
-          message: "Document updated successfully",
-          result: r
-        };
-      } catch (r) {
-        return o(r);
-      }
-    });
+  async updateOne(t, e) {
+    try {
+      const r = await this.collection.updateOne(t, {
+        $set: e
+      });
+      return r.matchedCount === 0 ? {
+        success: !1,
+        message: "No documents matched the filter",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      } : {
+        success: !0,
+        message: "Document updated successfully",
+        result: r
+      };
+    } catch (r) {
+      return u(r);
+    }
   }
-  updateMany(t, e) {
-    return a(this, null, function* () {
-      try {
-        const r = yield this.collection.updateMany(t, {
-          $set: e
-        });
-        return r.matchedCount === 0 ? {
-          success: !1,
-          message: "No documents matched the filter",
-          code: d.INTERNAL_SERVER_ERROR.CODE
-        } : {
-          success: !0,
-          message: "Documents updated successfully",
-          result: r
-        };
-      } catch (r) {
-        return o(r);
-      }
-    });
+  async updateMany(t, e) {
+    try {
+      const r = await this.collection.updateMany(t, {
+        $set: e
+      });
+      return r.matchedCount === 0 ? {
+        success: !1,
+        message: "No documents matched the filter",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      } : {
+        success: !0,
+        message: "Documents updated successfully",
+        result: r
+      };
+    } catch (r) {
+      return u(r);
+    }
   }
-  deleteOne(t) {
-    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
-        } : {
-          success: !0,
-          message: "Document deleted successfully",
-          result: e
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async deleteOne(t) {
+    try {
+      const e = await this.collection.deleteOne(t);
+      return e.deletedCount === 0 ? {
+        success: !1,
+        message: "No documents matched the filter",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      } : {
+        success: !0,
+        message: "Document deleted successfully",
+        result: e
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
-  deleteMany(t) {
-    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
-        } : {
-          success: !0,
-          message: "Documents deleted successfully",
-          result: e
-        };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async deleteMany(t) {
+    try {
+      const e = await this.collection.deleteMany(t);
+      return e.deletedCount === 0 ? {
+        success: !1,
+        message: "No documents matched the filter",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      } : {
+        success: !0,
+        message: "Documents deleted successfully",
+        result: e
+      };
+    } catch (e) {
+      return u(e);
+    }
   }
 }
-class oe {
+class K {
   constructor(t) {
     this.model = t;
   }
   getModelName() {
     return this.model.modelName;
   }
-  findOne() {
-    return a(this, arguments, function* (t = {}, e = {}, r = {}, s) {
-      try {
-        const n = this.model.findOne(t, e, r);
-        s && n.populate(s);
-        const u = yield n.exec();
-        return u ? { success: !0, result: u } : {
-          success: !1,
-          message: `No ${this.getModelName()} found.`,
-          code: d.NOT_FOUND.CODE
-        };
-      } catch (n) {
-        return o(n);
-      }
-    });
+  async findOne(t = {}, e = {}, r = {}, s) {
+    try {
+      const c = this.model.findOne(t, e, r);
+      s && c.populate(s);
+      const a = await c.exec();
+      return a ? { success: !0, result: a } : {
+        success: !1,
+        message: `No ${this.getModelName()} found.`,
+        code: i.NOT_FOUND.CODE
+      };
+    } catch (c) {
+      return u(c);
+    }
   }
-  findAll() {
-    return a(this, arguments, function* (t = {}, e = {}, r = {}, s) {
-      try {
-        const n = this.model.find(t, e, r);
-        return s && n.populate(s), { success: !0, result: yield n.exec() };
-      } catch (n) {
-        return o(n);
-      }
-    });
+  async findAll(t = {}, e = {}, r = {}, s) {
+    try {
+      const c = this.model.find(t, e, r);
+      return s && c.populate(s), { success: !0, result: await c.exec() };
+    } catch (c) {
+      return u(c);
+    }
   }
-  findPaging() {
-    return a(this, arguments, function* (t = {}, e = {}) {
-      try {
-        return { success: !0, result: yield this.model.paginate(t, e) };
-      } catch (r) {
-        return o(r);
-      }
-    });
+  async findPaging(t = {}, e = {}) {
+    try {
+      return { success: !0, result: await this.model.paginate(t, e) };
+    } catch (r) {
+      return u(r);
+    }
   }
-  findPagingAggregate(r) {
-    return a(this, arguments, function* (t, e = {}) {
-      try {
-        return { success: !0, result: yield this.model.aggregatePaginate(
-          this.model.aggregate(t),
-          e
-        ) };
-      } catch (s) {
-        return o(s);
-      }
-    });
+  async findPagingAggregate(t, e = {}) {
+    try {
+      return { success: !0, result: await this.model.aggregatePaginate(
+        this.model.aggregate(t),
+        e
+      ) };
+    } catch (r) {
+      return u(r);
+    }
   }
-  count() {
-    return a(this, arguments, function* (t = {}) {
-      try {
-        return { success: !0, result: yield this.model.countDocuments(t) };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async count(t = {}) {
+    try {
+      return { success: !0, result: await this.model.countDocuments(t) };
+    } catch (e) {
+      return u(e);
+    }
   }
-  createOne(t) {
-    return a(this, null, function* () {
-      try {
-        return { success: !0, result: yield this.model.create(t) };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async createOne(t) {
+    try {
+      return { success: !0, result: await this.model.create(t) };
+    } catch (e) {
+      return u(e);
+    }
   }
-  createMany(r) {
-    return a(this, arguments, function* (t, e = {}) {
-      try {
-        return { success: !0, result: (yield this.model.insertMany(t, e)).map((u) => u instanceof G ? u.toObject() : null).filter((u) => u !== null) };
-      } catch (s) {
-        return o(s);
-      }
-    });
+  async createMany(t, e = {}) {
+    try {
+      return { success: !0, result: (await this.model.insertMany(t, e)).map((c) => c instanceof S ? c.toObject() : null).filter((c) => c !== null) };
+    } catch (r) {
+      return u(r);
+    }
   }
-  updateOne() {
-    return a(this, arguments, function* (t = {}, e = {}, r = {}) {
-      try {
-        const s = yield this.model.findOneAndUpdate(t, e, m({
-          new: !0
-        }, r)).exec();
-        return s ? { success: !0, result: s } : {
-          success: !1,
-          message: `Failed to update ${this.getModelName()}.`,
-          code: d.NOT_FOUND.CODE
-        };
-      } catch (s) {
-        return o(s);
-      }
-    });
+  async updateOne(t = {}, e = {}, r = {}) {
+    try {
+      const s = await this.model.findOneAndUpdate(t, e, {
+        new: !0,
+        ...r
+      }).exec();
+      return s ? { success: !0, result: s } : {
+        success: !1,
+        message: `Failed to update ${this.getModelName()}.`,
+        code: i.NOT_FOUND.CODE
+      };
+    } catch (s) {
+      return u(s);
+    }
   }
-  updateMany() {
-    return a(this, arguments, function* (t = {}, e = {}, r = {}) {
-      try {
-        return { success: !0, result: yield this.model.updateMany(t, e, r).exec() };
-      } catch (s) {
-        return o(s);
-      }
-    });
+  async updateMany(t = {}, e = {}, r = {}) {
+    try {
+      return { success: !0, result: await this.model.updateMany(t, e, r).exec() };
+    } catch (s) {
+      return u(s);
+    }
   }
-  deleteOne() {
-    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
-        };
-      } catch (r) {
-        return o(r);
-      }
-    });
+  async deleteOne(t = {}, e = {}) {
+    try {
+      const r = await this.model.findOneAndDelete(t, e).exec();
+      return r ? { success: !0, result: r } : {
+        success: !1,
+        message: `No ${this.getModelName()} found to delete.`,
+        code: i.NOT_FOUND.CODE
+      };
+    } catch (r) {
+      return u(r);
+    }
   }
-  deleteMany() {
-    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
-        } : { success: !0, result: r };
-      } catch (r) {
-        return o(r);
-      }
-    });
+  async deleteMany(t = {}, e = {}) {
+    try {
+      const r = await this.model.deleteMany(t, e).exec();
+      return r.deletedCount === 0 ? {
+        success: !1,
+        message: "No documents found to delete.",
+        code: i.NOT_FOUND.CODE
+      } : { success: !0, result: r };
+    } catch (r) {
+      return u(r);
+    }
   }
-  createShortId(t, e = 4) {
-    return a(this, null, function* () {
-      try {
-        const s = /* @__PURE__ */ new Set();
-        for (let n = 0; n < 10; n++) {
-          const u = U(t, n + e);
-          if (!s.has(u) && (s.add(u), !(yield this.model.exists({ shortId: u }))))
-            return { success: !0, result: u };
-        }
-        return {
-          success: !1,
-          message: "Failed to create a unique shortId",
-          code: d.INTERNAL_SERVER_ERROR.CODE
-        };
-      } catch (r) {
-        return o(r);
+  async createShortId(t, e = 4) {
+    try {
+      const s = /* @__PURE__ */ new Set();
+      for (let c = 0; c < 10; c++) {
+        const a = T(t, c + e);
+        if (!s.has(a) && (s.add(a), !await this.model.exists({ shortId: a })))
+          return { success: !0, result: a };
       }
-    });
+      return {
+        success: !1,
+        message: "Failed to create a unique shortId",
+        code: i.INTERNAL_SERVER_ERROR.CODE
+      };
+    } catch (r) {
+      return u(r);
+    }
   }
   createSlugQuery({ slug: t, field: e, isObject: r, filter: s }) {
-    const n = m({}, s != null ? s : {});
-    return r ? h(m({}, n), {
+    const c = { ...s ?? {} };
+    return r ? {
+      ...c,
       $or: [
         { [`slug.${e}`]: t },
         { slugHistory: { $elemMatch: { [`slug.${e}`]: t } } }
       ]
-    }) : h(m({}, n), {
+    } : {
+      ...c,
       $or: [
         { slug: t },
         { slugHistory: t }
       ]
-    });
-  }
-  createUniqueSlug(n) {
-    return a(this, arguments, function* ({ slug: t, field: e, isObject: r, filter: s }) {
-      const u = E(t);
-      let i = u, l = 1;
-      for (; yield this.model.exists(this.createSlugQuery({ slug: i, field: e, isObject: r, filter: s })); )
-        i = `${u}-${l++}`;
-      return i;
-    });
+    };
   }
-  createSlug(s) {
-    return a(this, arguments, function* ({ field: t, from: e, filter: r }) {
-      try {
-        const n = e[t];
-        return D(n) ? { success: !0, result: Object.fromEntries(
-          yield Promise.all(
-            Object.entries(n).map((_) => a(this, [_], function* ([f, O]) {
-              const R = yield this.createUniqueSlug({
-                slug: O,
-                field: f,
-                isObject: !0,
-                filter: r
-              });
-              return [f, R];
-            }))
-          )
-        ) } : { success: !0, result: yield this.createUniqueSlug({
-          slug: n,
-          field: t,
-          isObject: !1,
-          filter: r
-        }) };
-      } catch (n) {
-        return o(n);
-      }
-    });
+  async createUniqueSlug({ slug: t, field: e, isObject: r, filter: s }) {
+    const c = y(t);
+    let a = c, o = 1;
+    for (; await this.model.exists(this.createSlugQuery({ slug: a, field: e, isObject: r, filter: s })); )
+      a = `${c}-${o++}`;
+    return a;
   }
-  checkSlug(n) {
-    return a(this, arguments, function* ({ slug: t, field: e, from: r, filter: s }) {
-      try {
-        const u = r[e];
-        if (D(u)) {
-          for (const O of Object.values(u)) {
-            const _ = E(O);
-            if (yield this.model.exists(this.createSlugQuery({
-              slug: _,
-              field: e,
+  async createSlug({ field: t, from: e, filter: r }) {
+    try {
+      const s = e[t];
+      return O(s) ? { success: !0, result: Object.fromEntries(
+        await Promise.all(
+          Object.entries(s).map(async ([d, f]) => {
+            const g = await this.createUniqueSlug({
+              slug: f,
+              field: d,
               isObject: !0,
-              filter: s
-            })))
-              return { success: !0, result: !0 };
-          }
-          return { success: !0, result: !1 };
+              filter: r
+            });
+            return [d, g];
+          })
+        )
+      ) } : { success: !0, result: await this.createUniqueSlug({
+        slug: s,
+        field: t,
+        isObject: !1,
+        filter: r
+      }) };
+    } catch (s) {
+      return u(s);
+    }
+  }
+  async checkSlug({ slug: t, field: e, from: r, filter: s }) {
+    try {
+      const c = r[e];
+      if (O(c)) {
+        for (const f of Object.values(c)) {
+          const g = y(f);
+          if (await this.model.exists(this.createSlugQuery({
+            slug: g,
+            field: e,
+            isObject: !0,
+            filter: s
+          })))
+            return { success: !0, result: !0 };
         }
-        const l = E(t);
-        return { success: !0, result: (yield this.model.exists(this.createSlugQuery({
-          slug: l,
-          field: e,
-          isObject: !1,
-          filter: s
-        }))) !== null };
-      } catch (u) {
-        return o(u);
+        return { success: !0, result: !1 };
       }
-    });
+      const o = y(t);
+      return { success: !0, result: await this.model.exists(this.createSlugQuery({
+        slug: o,
+        field: e,
+        isObject: !1,
+        filter: s
+      })) !== null };
+    } catch (c) {
+      return u(c);
+    }
   }
-  aggregate(t) {
-    return a(this, null, function* () {
-      try {
-        return { success: !0, result: yield this.model.aggregate(t) };
-      } catch (e) {
-        return o(e);
-      }
-    });
+  async aggregate(t) {
+    try {
+      return { success: !0, result: await this.model.aggregate(t) };
+    } catch (e) {
+      return u(e);
+    }
   }
 }
 export {
-  ae as MongoController,
-  oe as MongooseController,
-  de as aggregatePaginate,
-  g as mongo,
-  fe as mongoosePaginate
+  B as MongoController,
+  K as MongooseController,
+  X as aggregatePaginate,
+  l as mongo,
+  Z as mongoosePaginate
 };