@cyberskill/shared 2.20.0 → 2.25.0

package/dist/node/mongo/mongo.controller.js

@@ -0,0 +1,956 @@
+import { MONGO_SLUG_MAX_ATTEMPTS as U } from "./mongo.constant.js";
+import { mongo as T, applyNestedPopulate as W, convertEnumToModelName as B } from "./mongo.util.js";
+import { normalizeMongoFilter as M, deepClone as G } from "../../util/object/object.util.js";
+import { generateShortId as K, generateSlug as C } from "../../util/string/string.util.js";
+import { RESPONSE_STATUS as j } from "../../constant/response-status.js";
+import { catchError as m } from "../log/log.util.js";
+var Q = Object.defineProperty, k = Object.defineProperties, X = Object.getOwnPropertyDescriptors, I = Object.getOwnPropertySymbols, J = Object.prototype.hasOwnProperty, Y = Object.prototype.propertyIsEnumerable, w = (l, r, e) => r in l ? Q(l, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : l[r] = e, R = (l, r) => {
+  for (var e in r || (r = {}))
+    J.call(r, e) && w(l, e, r[e]);
+  if (I)
+    for (var e of I(r))
+      Y.call(r, e) && w(l, e, r[e]);
+  return l;
+}, A = (l, r) => k(l, X(r)), Z = (l, r, e) => w(l, typeof r != "symbol" ? r + "" : r, e), f = (l, r, e) => new Promise((t, s) => {
+  var n = (a) => {
+    try {
+      o(e.next(a));
+    } catch (c) {
+      s(c);
+    }
+  }, u = (a) => {
+    try {
+      o(e.throw(a));
+    } catch (c) {
+      s(c);
+    }
+  }, o = (a) => a.done ? t(a.value) : Promise.resolve(a.value).then(n, u);
+  o((e = e.apply(l, r)).next());
+});
+function L(l) {
+  return l != null && typeof l == "object";
+}
+function $(l, r) {
+  if (!l || !r || r.length === 0)
+    return l;
+  const e = new Set(r.map((t) => t.name));
+  if (Array.isArray(l)) {
+    const t = l.filter((s) => {
+      if (typeof s == "string")
+        return !Array.from(e).some(
+          (n) => s === n || s.startsWith(`${n}.`)
+        );
+      if (typeof s == "object" && s !== null) {
+        const n = s, u = n.path || n.populate || "";
+        return !Array.from(e).some(
+          (o) => u === o || u.startsWith(`${o}.`)
+        );
+      }
+      return !0;
+    });
+    return t.length > 0 ? t : void 0;
+  }
+  if (typeof l == "string")
+    return Array.from(e).some(
+      (t) => l === t || l.startsWith(`${t}.`)
+    ) ? void 0 : l;
+  if (typeof l == "object" && l !== null) {
+    const t = l, s = t.path || t.populate || "";
+    return Array.from(e).some(
+      (n) => s === n || s.startsWith(`${n}.`)
+    ) ? void 0 : l;
+  }
+  return l;
+}
+function H(l, r, e) {
+  if (!l.length || !r || !(e != null && e.ref))
+    return [];
+  const t = /* @__PURE__ */ new Map();
+  return l.forEach((s) => {
+    try {
+      const n = e.ref(s);
+      if (n == null)
+        return;
+      const u = typeof n == "string" ? n : String(n);
+      if (u && u.trim() !== "") {
+        const o = B(u);
+        t.has(o) || t.set(o, []), t.get(o).push(s);
+      }
+    } catch (n) {
+      m(new Error(`Dynamic ref function failed for virtual "${r}": ${n instanceof Error ? n.message : String(n)}`));
+    }
+  }), Array.from(t.entries()).map(([s, n]) => ({ model: s, docs: n }));
+}
+function ee(l) {
+  return l !== null && typeof l == "object" && "toObject" in l && typeof l.toObject == "function";
+}
+function z(l, r, e, t, s, n) {
+  return f(this, null, function* () {
+    if (!r.length || !e.length || !t)
+      return r;
+    const u = e.filter((c) => {
+      if (Array.isArray(t))
+        return t.length > 0 && t.some((d) => {
+          if (typeof d == "string")
+            return d === c.name || d.startsWith(`${c.name}.`);
+          if (d && typeof d == "object") {
+            const i = d, p = i.path || i.populate || "";
+            return p === c.name || p.startsWith(`${c.name}.`);
+          }
+          return !1;
+        });
+      if (typeof t == "string")
+        return t === c.name || t.startsWith(`${c.name}.`);
+      if (typeof t == "object" && t !== null) {
+        const d = t, i = d.path || d.populate || "";
+        return i === c.name || i.startsWith(`${c.name}.`);
+      }
+      return !1;
+    });
+    if (u.length === 0)
+      return r;
+    const o = G(r.map((c) => ee(c) ? c.toObject() : c));
+    o.forEach((c) => {
+      u.forEach(({ name: d, options: i }) => {
+        d in c || (c[d] = i.count ? 0 : i.justOne ? null : []);
+      });
+    });
+    const a = /* @__PURE__ */ new Map();
+    for (const c of u) {
+      const { name: d, options: i } = c, p = H(o, d, i);
+      for (const y of p) {
+        a.has(y.model) || a.set(y.model, {
+          virtuals: [],
+          localValueSets: /* @__PURE__ */ new Map(),
+          docsByLocalValue: /* @__PURE__ */ new Map()
+        });
+        const O = a.get(y.model);
+        O.virtuals.find((_) => _.name === d) || (O.virtuals.push(c), O.localValueSets.set(d, /* @__PURE__ */ new Set()));
+        const N = O.localValueSets.get(d);
+        y.docs.forEach((_) => {
+          const v = _[i.localField];
+          if (v != null) {
+            const g = String(v);
+            N.add(g);
+            let h = -1;
+            const S = _;
+            S.id !== void 0 ? h = o.findIndex((F) => F.id === S.id) : S._id !== void 0 && (h = o.findIndex((F) => {
+              var b, E, V, D;
+              return ((E = (b = F._id) == null ? void 0 : b.toString) == null ? void 0 : E.call(b)) === ((D = (V = S._id) == null ? void 0 : V.toString) == null ? void 0 : D.call(V));
+            })), h !== -1 && (O.docsByLocalValue.has(g) || O.docsByLocalValue.set(g, []), O.docsByLocalValue.get(g).push(h));
+          }
+        });
+      }
+    }
+    if (yield Promise.all(Array.from(a.entries()).map((c) => f(null, [c], function* ([d, i]) {
+      const p = l.models[d];
+      if (!p)
+        return;
+      const y = /* @__PURE__ */ new Set();
+      if (i.localValueSets.forEach((g) => {
+        g.forEach((h) => y.add(h));
+      }), y.size === 0)
+        return;
+      const O = [...new Set(i.virtuals.map((g) => g.options.foreignField))], N = Array.from(y);
+      let _;
+      O.length === 1 ? _ = { [String(O[0])]: { $in: N } } : _ = { $or: O.map((g) => ({ [g]: { $in: N } })) };
+      const v = yield p.find(_, s).lean();
+      for (const g of i.virtuals) {
+        const { name: h, options: S } = g, F = v.filter((b) => {
+          const E = b[S.foreignField];
+          return E != null && y.has(String(E));
+        });
+        if (S.count) {
+          const b = /* @__PURE__ */ new Map();
+          F.forEach((E) => {
+            var V;
+            const D = (V = E[S.foreignField]) == null ? void 0 : V.toString();
+            D && b.set(D, (b.get(D) || 0) + 1);
+          }), i.localValueSets.get(h).forEach((E) => {
+            const V = i.docsByLocalValue.get(E) || [], D = b.get(E) || 0;
+            V.forEach((P) => {
+              const x = o[P];
+              x[h] === void 0 && (x[h] = D);
+            });
+          });
+        } else {
+          const b = /* @__PURE__ */ new Map();
+          F.forEach((E) => {
+            var V;
+            const D = (V = E[S.foreignField]) == null ? void 0 : V.toString();
+            D && (b.has(D) || b.set(D, []), b.get(D).push(E));
+          }), i.localValueSets.get(h).forEach((E) => {
+            const V = i.docsByLocalValue.get(E) || [], D = b.get(E) || [], P = S.justOne ? D[0] || null : D;
+            V.forEach((x) => {
+              const q = o[x];
+              q[h] = P;
+            });
+          });
+        }
+      }
+    }))), t) {
+      const d = ((i) => {
+        const p = Array.isArray(i) ? i : [i], y = /* @__PURE__ */ new Map(), O = [];
+        for (const _ of p)
+          if (typeof _ == "string")
+            if (_.includes(".")) {
+              const v = _.split("."), g = v[0] || "", h = v.slice(1).join(".");
+              g && (y.has(g) || y.set(g, []), h && y.get(g).push(h));
+            } else
+              O.push(_);
+          else if (_ && typeof _ == "object") {
+            const v = _;
+            if (v.path && v.path.includes(".")) {
+              const g = v.path.split("."), h = g[0] || "", S = g.slice(1).join(".");
+              h && (y.has(h) || y.set(h, []), S && y.get(h).push(S), v.populate && y.get(h).push(v.populate));
+            } else
+              O.push(_);
+          }
+        const N = [...O];
+        return y.forEach((_, v) => {
+          const g = [];
+          for (const h of _)
+            (typeof h == "string" || h && typeof h == "object") && g.push(h);
+          g.length > 0 ? N.push({ path: v, populate: g }) : N.push(v);
+        }), N;
+      })(t);
+      yield W(l, o, d, e, n);
+    }
+    return o;
+  });
+}
+class le {
+  /**
+   * Creates a new MongoDB controller instance.
+   *
+   * @param db - The MongoDB database instance.
+   * @param collectionName - The name of the collection to operate on.
+   */
+  constructor(r, e) {
+    Z(this, "collection"), this.collection = r.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(r) {
+    return f(this, null, function* () {
+      try {
+        const e = R(R({}, T.createGenericFields()), r);
+        return (yield this.collection.insertOne(e)).acknowledged ? {
+          success: !0,
+          message: "Document created successfully",
+          result: e
+        } : {
+          success: !1,
+          message: "Document creation failed",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        };
+      } catch (e) {
+        return m(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(r) {
+    return f(this, null, function* () {
+      try {
+        const e = r.map((s) => R(R({}, T.createGenericFields()), s)), t = yield this.collection.insertMany(e);
+        return t.insertedCount === 0 ? {
+          success: !1,
+          message: "No documents were inserted",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        } : {
+          success: !0,
+          message: `${t.insertedCount} documents created successfully`,
+          result: e
+        };
+      } catch (e) {
+        return m(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(r) {
+    return f(this, null, function* () {
+      try {
+        const e = yield this.collection.findOne(r);
+        return e ? { success: !0, message: "Document found", result: e } : { success: !1, message: "Document not found", code: j.NOT_FOUND.CODE };
+      } catch (e) {
+        return m(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 f(this, arguments, function* (r = {}) {
+      try {
+        return {
+          success: !0,
+          message: "Documents retrieved successfully",
+          result: yield this.collection.find(r).toArray()
+        };
+      } catch (e) {
+        return m(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 f(this, arguments, function* (r = {}) {
+      try {
+        const e = yield this.collection.countDocuments(r);
+        return {
+          success: !0,
+          message: `${e} documents counted successfully`,
+          result: e
+        };
+      } catch (e) {
+        return m(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(r, e) {
+    return f(this, null, function* () {
+      try {
+        const t = yield this.collection.updateOne(r, {
+          $set: e
+        });
+        return t.matchedCount === 0 ? {
+          success: !1,
+          message: "No documents matched the filter",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        } : {
+          success: !0,
+          message: "Document updated successfully",
+          result: t
+        };
+      } catch (t) {
+        return m(t);
+      }
+    });
+  }
+  /**
+   * 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(r, e) {
+    return f(this, null, function* () {
+      try {
+        const t = yield this.collection.updateMany(r, {
+          $set: e
+        });
+        return t.matchedCount === 0 ? {
+          success: !1,
+          message: "No documents matched the filter",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        } : {
+          success: !0,
+          message: "Documents updated successfully",
+          result: t
+        };
+      } catch (t) {
+        return m(t);
+      }
+    });
+  }
+  /**
+   * 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(r) {
+    return f(this, null, function* () {
+      try {
+        const e = yield this.collection.deleteOne(r);
+        return e.deletedCount === 0 ? {
+          success: !1,
+          message: "No documents matched the filter",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        } : {
+          success: !0,
+          message: "Document deleted successfully",
+          result: e
+        };
+      } catch (e) {
+        return m(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(r) {
+    return f(this, null, function* () {
+      try {
+        const e = yield this.collection.deleteMany(r);
+        return e.deletedCount === 0 ? {
+          success: !1,
+          message: "No documents matched the filter",
+          code: j.INTERNAL_SERVER_ERROR.CODE
+        } : {
+          success: !0,
+          message: "Documents deleted successfully",
+          result: e
+        };
+      } catch (e) {
+        return m(e);
+      }
+    });
+  }
+}
+class ce {
+  /**
+   * Creates a new Mongoose controller instance.
+   *
+   * @param model - The Mongoose model to operate on.
+   */
+  constructor(r) {
+    this.model = r;
+  }
+  /**
+   * Gets the model name for logging and error messages.
+   *
+   * @returns The name of the model.
+   */
+  getModelName() {
+    return this.model.modelName;
+  }
+  /**
+   * Gets the dynamic virtuals configuration from the model instance.
+   *
+   * @returns Array of dynamic virtual configurations or undefined if none exist.
+   */
+  getDynamicVirtuals() {
+    if (this.model._virtualConfigs) {
+      const t = this.model._virtualConfigs.filter((s) => {
+        var n;
+        return typeof ((n = s.options) == null ? void 0 : n.ref) == "function";
+      });
+      if (t.length > 0)
+        return t;
+    }
+    return this.model.schema.statics._dynamicVirtuals;
+  }
+  /**
+   * Populates dynamic virtuals for a single document.
+   *
+   * @param result - The document to populate dynamic virtuals for.
+   * @param populate - The populate options to determine which virtuals to populate.
+   * @returns The document with dynamic virtuals populated.
+   */
+  populateDynamicVirtualsForDocument(r, e) {
+    return f(this, null, function* () {
+      const t = this.getDynamicVirtuals();
+      if (t && t.length > 0) {
+        const s = yield z(this.model.base, [r], t, e, void 0, this.model);
+        return s && s[0] ? s[0] : r;
+      }
+      return r;
+    });
+  }
+  /**
+   * Populates dynamic virtuals for an array of documents.
+   *
+   * @param results - The documents to populate dynamic virtuals for.
+   * @param populate - The populate options to determine which virtuals to populate.
+   * @returns The documents with dynamic virtuals populated.
+   */
+  populateDynamicVirtualsForDocuments(r, e) {
+    return f(this, null, function* () {
+      const t = this.getDynamicVirtuals();
+      return t && t.length > 0 && r.length > 0 ? yield z(this.model.base, r, t, e, void 0, this.model) : r;
+    });
+  }
+  /**
+   * 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 f(this, arguments, function* (r = {}, e = {}, t = {}, s) {
+      var n, u;
+      try {
+        const o = M(r), a = this.model.findOne(o, e, t), c = this.getDynamicVirtuals(), d = $(s, c);
+        d && a.populate(d);
+        const i = yield a.exec();
+        if (!i)
+          return {
+            success: !1,
+            message: `No ${this.getModelName()} found.`,
+            code: j.NOT_FOUND.CODE
+          };
+        const p = yield this.populateDynamicVirtualsForDocument(i, s);
+        return { success: !0, result: (u = (n = p == null ? void 0 : p.toObject) == null ? void 0 : n.call(p)) != null ? u : p };
+      } catch (o) {
+        return m(o);
+      }
+    });
+  }
+  /**
+   * 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 f(this, arguments, function* (r = {}, e = {}, t = {}, s) {
+      try {
+        const n = M(r), u = this.model.find(n, e, t), o = this.getDynamicVirtuals(), a = $(s, o);
+        a && u.populate(a);
+        const c = yield u.exec();
+        return { success: !0, result: (yield this.populateDynamicVirtualsForDocuments(c, s)).map((i) => {
+          var p, y;
+          return (y = (p = i == null ? void 0 : i.toObject) == null ? void 0 : p.call(i)) != null ? y : i;
+        }) };
+      } catch (n) {
+        return m(n);
+      }
+    });
+  }
+  /**
+   * 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 f(this, arguments, function* (r = {}, e = {}) {
+      try {
+        const t = M(r), s = this.getDynamicVirtuals(), n = R({}, e);
+        e.populate && (n.populate = $(e.populate, s));
+        const u = yield this.model.paginate(t, n);
+        if (s && s.length > 0) {
+          const o = yield this.populateDynamicVirtualsForDocuments(u.docs, e.populate);
+          return { success: !0, result: A(R({}, u), { docs: o.map((a) => {
+            var c, d;
+            return (d = (c = a == null ? void 0 : a.toObject) == null ? void 0 : c.call(a)) != null ? d : a;
+          }) }) };
+        }
+        return { success: !0, result: A(R({}, u), { docs: u.docs.map((o) => {
+          var a, c;
+          return (c = (a = o == null ? void 0 : o.toObject) == null ? void 0 : a.call(o)) != null ? c : o;
+        }) }) };
+      } catch (t) {
+        return m(t);
+      }
+    });
+  }
+  /**
+   * 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(r) {
+    return f(this, arguments, function* (e, t = {}) {
+      try {
+        const s = this.getDynamicVirtuals(), n = R({}, t);
+        t.populate && (n.populate = $(t.populate, s));
+        const u = yield this.model.aggregatePaginate(
+          this.model.aggregate(e),
+          n
+        ), o = yield this.populateDynamicVirtualsForDocuments(u.docs, t.populate);
+        return { success: !0, result: A(R({}, u), { docs: o.map((a) => {
+          var c, d;
+          return (d = (c = a == null ? void 0 : a.toObject) == null ? void 0 : c.call(a)) != null ? d : a;
+        }) }) };
+      } catch (s) {
+        return m(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 f(this, arguments, function* (r = {}) {
+      try {
+        const e = M(r);
+        return { success: !0, result: yield this.model.countDocuments(e) };
+      } catch (e) {
+        return m(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(r) {
+    return f(this, null, function* () {
+      var e, t;
+      try {
+        const s = yield this.model.create(r);
+        return { success: !0, result: (t = (e = s == null ? void 0 : s.toObject) == null ? void 0 : e.call(s)) != null ? t : s };
+      } catch (s) {
+        return m(s);
+      }
+    });
+  }
+  /**
+   * 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(r) {
+    return f(this, arguments, function* (e, t = {}) {
+      try {
+        return { success: !0, result: (yield this.model.insertMany(e, t)).map((n) => {
+          var u, o;
+          return (o = (u = n == null ? void 0 : n.toObject) == null ? void 0 : u.call(n)) != null ? o : n;
+        }) };
+      } catch (s) {
+        return m(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 f(this, arguments, function* (r = {}, e = {}, t = {}) {
+      var s, n;
+      try {
+        const u = M(r), o = yield this.model.findOneAndUpdate(u, e, R({
+          new: !0
+        }, t)).exec();
+        return o ? { success: !0, result: (n = (s = o == null ? void 0 : o.toObject) == null ? void 0 : s.call(o)) != null ? n : o } : {
+          success: !1,
+          message: `Failed to update ${this.getModelName()}.`,
+          code: j.NOT_FOUND.CODE
+        };
+      } catch (u) {
+        return m(u);
+      }
+    });
+  }
+  /**
+   * 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 f(this, arguments, function* (r = {}, e = {}, t = {}) {
+      try {
+        const s = M(r);
+        return { success: !0, result: yield this.model.updateMany(s, e, t).exec() };
+      } catch (s) {
+        return m(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 f(this, arguments, function* (r = {}, e = {}) {
+      var t, s;
+      try {
+        const n = M(r), u = yield this.model.findOneAndDelete(n, e).exec();
+        return u ? { success: !0, result: (s = (t = u == null ? void 0 : u.toObject) == null ? void 0 : t.call(u)) != null ? s : u } : {
+          success: !1,
+          message: `No ${this.getModelName()} found to delete.`,
+          code: j.NOT_FOUND.CODE
+        };
+      } catch (n) {
+        return m(n);
+      }
+    });
+  }
+  /**
+   * 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 f(this, arguments, function* (r = {}, e = {}) {
+      try {
+        const t = M(r), s = yield this.model.deleteMany(t, e).exec();
+        return s.deletedCount === 0 ? {
+          success: !1,
+          message: "No documents found to delete.",
+          code: j.NOT_FOUND.CODE
+        } : { success: !0, result: s };
+      } catch (t) {
+        return m(t);
+      }
+    });
+  }
+  /**
+   * 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(r, e = 4) {
+    return f(this, null, function* () {
+      try {
+        const s = Array.from({ length: 10 }, (o, a) => K(r, a + 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: j.INTERNAL_SERVER_ERROR.CODE
+        };
+      } catch (t) {
+        return m(t);
+      }
+    });
+  }
+  /**
+   * 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.haveHistory - Whether to check historical slug fields for existence.
+   * @param options.filter - Additional filter conditions to apply to the query.
+   * @returns A MongoDB query object for checking slug existence.
+   */
+  createSlugQuery({ slug: r, field: e, isObject: t, haveHistory: s = !1, filter: n }) {
+    const u = R({}, n != null ? n : {});
+    return t ? A(R({}, u), {
+      $or: [
+        { [`slug.${e}`]: r },
+        ...s ? [{ slugHistory: { $elemMatch: { [`slug.${e}`]: r } } }] : []
+      ]
+    }) : A(R({}, u), {
+      $or: [
+        { slug: r },
+        ...s ? [{ slugHistory: r }] : []
+      ]
+    });
+  }
+  /**
+   * 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.haveHistory - Whether to check historical slug fields for uniqueness.
+   * @param options.filter - Additional filter conditions to apply when checking slug existence.
+   * @returns A promise that resolves to a unique slug string.
+   */
+  createUniqueSlug(r) {
+    return f(this, arguments, function* ({ slug: e, field: t, isObject: s, haveHistory: n, filter: u }) {
+      if (!e || typeof e != "string")
+        throw new Error("Invalid slug provided: must be a non-empty string");
+      const o = C(e);
+      if (!(yield this.model.exists(
+        this.createSlugQuery({ slug: o, field: t, isObject: s, haveHistory: n, filter: u })
+      )))
+        return o;
+      for (let i = 1; i <= U; i++) {
+        const p = `${o}-${i}`;
+        if (!(yield this.model.exists(
+          this.createSlugQuery({ slug: p, field: t, isObject: s, haveHistory: n, filter: u })
+        )))
+          return p;
+      }
+      const c = Date.now(), d = Math.random().toString(36).substring(2, 8);
+      return `${o}-${c}-${d}`;
+    });
+  }
+  /**
+   * 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.haveHistory - Whether to check historical slug fields for uniqueness.
+   * @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(r) {
+    return f(this, arguments, function* ({ field: e, from: t, filter: s, haveHistory: n }) {
+      try {
+        const u = t[e];
+        return L(u) ? { success: !0, result: Object.fromEntries(
+          yield Promise.all(
+            Object.entries(u).map((d) => f(this, [d], function* ([i, p]) {
+              const y = yield this.createUniqueSlug({
+                slug: p,
+                field: i,
+                isObject: !0,
+                haveHistory: n,
+                filter: s
+              });
+              return [i, y];
+            }))
+          )
+        ) } : { success: !0, result: yield this.createUniqueSlug({
+          slug: u,
+          field: e,
+          isObject: !1,
+          haveHistory: n,
+          filter: s
+        }) };
+      } catch (u) {
+        return m(u);
+      }
+    });
+  }
+  /**
+   * 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.haveHistory - Whether to check historical slug fields for existence.
+   * @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(r) {
+    return f(this, arguments, function* ({ slug: e, field: t, from: s, filter: n, haveHistory: u }) {
+      try {
+        const o = s[t];
+        if (L(o)) {
+          const p = Object.values(o).map((O) => C(O));
+          return (yield Promise.all(
+            p.map(
+              (O) => this.model.exists(this.createSlugQuery({
+                slug: O,
+                field: t,
+                isObject: !0,
+                haveHistory: u,
+                filter: n
+              }))
+            )
+          )).some((O) => O) ? { success: !0, result: !0 } : { success: !0, result: !1 };
+        }
+        const c = C(e);
+        return { success: !0, result: (yield this.model.exists(this.createSlugQuery({
+          slug: c,
+          field: t,
+          isObject: !1,
+          filter: n
+        }))) !== null };
+      } catch (o) {
+        return m(o);
+      }
+    });
+  }
+  /**
+   * 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(r) {
+    return f(this, null, function* () {
+      try {
+        return { success: !0, result: yield this.model.aggregate(r) };
+      } catch (e) {
+        return m(e);
+      }
+    });
+  }
+  /**
+   * Retrieves distinct values for the specified key from the collection.
+   *
+   * @param key - The field for which to return distinct values.
+   * @param filter - The filter query to apply (optional).
+   * @param options - Additional options for the distinct operation (optional).
+   * @returns A promise that resolves to a standardized response with the array of distinct values.
+   */
+  distinct(r) {
+    return f(this, arguments, function* (e, t = {}, s = {}) {
+      try {
+        return { success: !0, result: yield this.model.distinct(e, t, s) };
+      } catch (n) {
+        return m(n);
+      }
+    });
+  }
+}
+export {
+  le as MongoController,
+  ce as MongooseController
+};