@cyberskill/shared 3.2.0 → 3.3.0

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

@@ -1,468 +1,334 @@
-import { MONGO_SLUG_MAX_ATTEMPTS as S } from "./mongo.constant.js";
-import { populateDynamicVirtuals as f, filterDynamicVirtualsFromPopulate as y, isObject as O } from "./mongo.dynamic-populate.js";
-import { normalizeMongoFilter as d } from "../../util/object/object.util.js";
-import { generateShortId as b, generateSlug as p, generateRandomString as V } from "../../util/string/string.util.js";
-import { RESPONSE_STATUS as g } from "../../constant/response-status.js";
-import { catchError as u } from "../log/log.util.js";
-class R {
-  /**
-   * 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 s = this.model._virtualConfigs.filter((t) => typeof t.options?.ref == "function");
-      if (s.length > 0)
-        return s;
-    }
-    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.
-   */
-  async populateDynamicVirtualsForDocument(r, e) {
-    const s = this.getDynamicVirtuals();
-    if (s && s.length > 0) {
-      const t = await f(this.model.base, [r], s, e, void 0, this.model);
-      return t && t[0] ? t[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.
-   */
-  async populateDynamicVirtualsForDocuments(r, e) {
-    const s = this.getDynamicVirtuals();
-    return s && s.length > 0 && r.length > 0 ? await f(this.model.base, r, s, 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.
-   */
-  async findOne(r = {}, e = {}, s = {}, t) {
-    try {
-      const a = d(r), c = this.model.findOne(a, e, s).maxTimeMS(3e4).lean(), n = this.getDynamicVirtuals(), i = y(t, n);
-      i && c.populate(i);
-      const o = await c.exec();
-      if (!o)
-        return {
-          success: !1,
-          message: `No ${this.getModelName()} found.`,
-          code: g.NOT_FOUND.CODE
-        };
-      const l = await this.populateDynamicVirtualsForDocument(o, t);
-      return { success: !0, result: l?.toObject?.() ?? l };
-    } catch (a) {
-      return u(a);
-    }
-  }
-  /**
-   * 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.
-   */
-  async findAll(r = {}, e = {}, s = {}, t) {
-    try {
-      const a = d(r), c = this.model.find(a, e, s).maxTimeMS(3e4).lean();
-      s.limit || c.limit(1e4);
-      const n = this.getDynamicVirtuals(), i = y(t, n);
-      i && c.populate(i);
-      const o = await c.exec();
-      return { success: !0, result: (await this.populateDynamicVirtualsForDocuments(o, t)).map((m) => m?.toObject?.() ?? m) };
-    } catch (a) {
-      return u(a);
-    }
-  }
-  /**
-   * 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.
-   */
-  async findPaging(r = {}, e = {}) {
-    try {
-      const s = d(r), t = this.getDynamicVirtuals(), a = { ...e };
-      e.populate && (a.populate = y(e.populate, t));
-      const c = await this.model.paginate(s, a);
-      if (t && t.length > 0) {
-        const n = await this.populateDynamicVirtualsForDocuments(c.docs, e.populate);
-        return { success: !0, result: { ...c, docs: n.map((i) => i?.toObject?.() ?? i) } };
-      }
-      return { success: !0, result: { ...c, docs: c.docs.map((n) => n?.toObject?.() ?? n) } };
-    } catch (s) {
-      return u(s);
-    }
-  }
-  /**
-   * 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.
-   */
-  async findPagingAggregate(r, e = {}) {
-    try {
-      const s = this.getDynamicVirtuals(), t = { ...e };
-      e.populate && (t.populate = y(e.populate, s));
-      const a = await this.model.aggregatePaginate(
-        this.model.aggregate(r),
-        t
-      ), c = await this.populateDynamicVirtualsForDocuments(a.docs, e.populate);
-      return { success: !0, result: { ...a, docs: c.map((n) => n?.toObject?.() ?? n) } };
-    } catch (s) {
-      return u(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.
-   */
-  async count(r = {}) {
-    try {
-      const e = d(r);
-      return { success: !0, result: await this.model.countDocuments(e) };
-    } catch (e) {
-      return u(e);
-    }
-  }
-  /**
-   * Creates a single document.
-   *
-   * @param doc - The document to create.
-   * @returns A promise that resolves to a standardized response with the created document.
-   */
-  async createOne(r) {
-    try {
-      const e = await this.model.create(r);
-      return { success: !0, result: e?.toObject?.() ?? e };
-    } catch (e) {
-      return u(e);
-    }
-  }
-  /**
-   * Creates multiple documents with bulk insertion.
-   *
-   * @param docs - An array of documents to create.
-   * @param options - Options for the bulk insertion operation.
-   * @returns A promise that resolves to a standardized response with the created documents.
-   */
-  async createMany(r, e = {}) {
-    try {
-      return { success: !0, result: (await this.model.insertMany(r, e)).map((t) => t?.toObject?.() ?? t) };
-    } catch (s) {
-      return u(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.
-   */
-  async updateOne(r = {}, e = {}, s = {}) {
-    try {
-      const t = d(r), a = await this.model.findOneAndUpdate(t, e, {
-        new: !0,
-        ...s
-      }).exec();
-      return a ? { success: !0, result: a?.toObject?.() ?? a } : {
-        success: !1,
-        message: `Failed to update ${this.getModelName()}.`,
-        code: g.NOT_FOUND.CODE
-      };
-    } catch (t) {
-      return u(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.
-   * @param options - Options for the update operation.
-   * @returns A promise that resolves to a standardized response with the update result.
-   */
-  async updateMany(r = {}, e = {}, s = {}) {
-    try {
-      const t = d(r);
-      return { success: !0, result: await this.model.updateMany(t, e, s).exec() };
-    } catch (t) {
-      return u(t);
-    }
-  }
-  /**
-   * 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.
-   */
-  async deleteOne(r = {}, e = {}) {
-    try {
-      const s = d(r), t = await this.model.findOneAndDelete(s, e).exec();
-      return t ? { success: !0, result: t?.toObject?.() ?? t } : {
-        success: !1,
-        message: `No ${this.getModelName()} found to delete.`,
-        code: g.NOT_FOUND.CODE
-      };
-    } catch (s) {
-      return u(s);
-    }
-  }
-  /**
-   * 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.
-   */
-  async deleteMany(r = {}, e = {}) {
-    try {
-      const s = d(r), t = await this.model.deleteMany(s, e).exec();
-      return t.deletedCount === 0 ? {
-        success: !1,
-        message: "No documents found to delete.",
-        code: g.NOT_FOUND.CODE
-      } : { success: !0, result: t };
-    } catch (s) {
-      return u(s);
-    }
-  }
-  /**
-   * 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.
-   */
-  async createShortId(r, e = 4) {
-    try {
-      const t = Array.from({ length: 10 }, (n, i) => b(r, i + e)), c = (await Promise.all(
-        t.map((n) => this.model.exists({ shortId: n }))
-      )).findIndex((n) => !n);
-      if (c !== -1) {
-        const n = t[c];
-        if (n)
-          return { success: !0, result: n };
-      }
-      return {
-        success: !1,
-        message: "Failed to create a unique shortId",
-        code: g.INTERNAL_SERVER_ERROR.CODE
-      };
-    } catch (s) {
-      return u(s);
-    }
-  }
-  /**
-   * 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: s, haveHistory: t = !1, filter: a }) {
-    const c = { ...a ?? {} };
-    return s ? {
-      ...c,
-      $or: [
-        { [`slug.${e}`]: r },
-        ...t ? [{ slugHistory: { $elemMatch: { [`slug.${e}`]: r } } }] : []
-      ]
-    } : {
-      ...c,
-      $or: [
-        { slug: r },
-        ...t ? [{ 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.
-   */
-  async createUniqueSlug({ slug: r, field: e, isObject: s, haveHistory: t, filter: a }) {
-    if (!r || typeof r != "string")
-      throw new Error("Invalid slug provided: must be a non-empty string");
-    const c = p(r);
-    if (!await this.model.exists(
-      this.createSlugQuery({ slug: c, field: e, isObject: s, haveHistory: t, filter: a })
-    ))
-      return c;
-    for (let l = 1; l <= S; l++) {
-      const m = `${c}-${l}`;
-      if (!await this.model.exists(
-        this.createSlugQuery({ slug: m, field: e, isObject: s, haveHistory: t, filter: a })
-      ))
-        return m;
-    }
-    const i = Date.now(), o = V(6);
-    return `${c}-${i}-${o}`;
-  }
-  /**
-   * 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).
-   */
-  async createSlug({ field: r, from: e, filter: s, haveHistory: t }) {
-    try {
-      const a = e[r];
-      return O(a) ? { success: !0, result: Object.fromEntries(
-        await Promise.all(
-          Object.entries(a).map(async ([o, l]) => {
-            const m = await this.createUniqueSlug({
-              slug: l,
-              field: o,
-              isObject: !0,
-              haveHistory: t,
-              filter: s
-            });
-            return [o, m];
-          })
-        )
-      ) } : { success: !0, result: await this.createUniqueSlug({
-        slug: a,
-        field: r,
-        isObject: !1,
-        haveHistory: t,
-        filter: s
-      }) };
-    } catch (a) {
-      return u(a);
-    }
-  }
-  /**
-   * 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.
-   */
-  async checkSlug({ slug: r, field: e, from: s, filter: t, haveHistory: a }) {
-    try {
-      const c = s[e];
-      if (O(c)) {
-        const m = Object.values(c).map((h) => p(h));
-        return (await Promise.all(
-          m.map(
-            (h) => this.model.exists(this.createSlugQuery({
-              slug: h,
-              field: e,
-              isObject: !0,
-              haveHistory: a,
-              filter: t
-            }))
-          )
-        )).some((h) => h) ? { success: !0, result: !0 } : { success: !0, result: !1 };
-      }
-      const i = p(r);
-      return { success: !0, result: await this.model.exists(this.createSlugQuery({
-        slug: i,
-        field: e,
-        isObject: !1,
-        filter: t
-      })) !== null };
-    } catch (c) {
-      return u(c);
-    }
-  }
-  /**
-   * 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.
-   */
-  async aggregate(r) {
-    try {
-      return { success: !0, result: await this.model.aggregate(r) };
-    } catch (e) {
-      return u(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.
-   */
-  async distinct(r, e = {}, s = {}) {
-    try {
-      return { success: !0, result: await this.model.distinct(r, e, s) };
-    } catch (t) {
-      return u(t);
-    }
-  }
-}
-export {
-  R as MongooseController
+import { normalizeMongoFilter as e } from "../../util/object/object.util.js";
+import { generateRandomString as t, generateShortId as n, generateSlug as r } from "../../util/string/string.util.js";
+import { RESPONSE_STATUS as i } from "../../constant/response-status.js";
+import { catchError as a } from "../log/log.util.js";
+import "./mongo.constant.js";
+import { filterDynamicVirtualsFromPopulate as o, isObject as s, populateDynamicVirtuals as c } from "./mongo.dynamic-populate.js";
+//#region src/node/mongo/mongo.controller.mongoose.ts
+var l = class {
+	defaultLimit;
+	constructor(e, t) {
+		this.model = e, this.defaultLimit = t?.defaultLimit ?? 1e4;
+	}
+	getModelName() {
+		return this.model.modelName;
+	}
+	getDynamicVirtuals() {
+		let e = this.model;
+		if (e._virtualConfigs) {
+			let t = e._virtualConfigs.filter((e) => typeof e.options?.ref == "function");
+			if (t.length > 0) return t;
+		}
+		return this.model.schema.statics._dynamicVirtuals;
+	}
+	async populateDynamicVirtualsForDocument(e, t) {
+		let n = this.getDynamicVirtuals();
+		if (n && n.length > 0) {
+			let r = await c(this.model.base, [e], n, t, void 0, this.model);
+			return r && r[0] ? r[0] : e;
+		}
+		return e;
+	}
+	async populateDynamicVirtualsForDocuments(e, t) {
+		let n = this.getDynamicVirtuals();
+		return n && n.length > 0 && e.length > 0 ? await c(this.model.base, e, n, t, void 0, this.model) : e;
+	}
+	async findOne(t = {}, n = {}, r = {}, s) {
+		try {
+			let a = e(t), c = this.model.findOne(a, n, r).maxTimeMS(3e4).lean(), l = o(s, this.getDynamicVirtuals());
+			l && c.populate(l);
+			let u = await c.exec();
+			if (!u) return {
+				success: !1,
+				message: `No ${this.getModelName()} found.`,
+				code: i.NOT_FOUND.CODE
+			};
+			let d = await this.populateDynamicVirtualsForDocument(u, s);
+			return {
+				success: !0,
+				result: d?.toObject?.() ?? d
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async findAll(t = {}, n = {}, r = {}, i) {
+		try {
+			let a = e(t), s = this.model.find(a, n, r).maxTimeMS(3e4).lean();
+			r.limit || s.limit(this.defaultLimit);
+			let c = o(i, this.getDynamicVirtuals());
+			c && s.populate(c);
+			let l = await s.exec();
+			return {
+				success: !0,
+				result: (await this.populateDynamicVirtualsForDocuments(l, i)).map((e) => e?.toObject?.() ?? e)
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async findPaging(t = {}, n = {}) {
+		try {
+			let r = e(t), i = this.getDynamicVirtuals(), a = { ...n };
+			n.populate && (a.populate = o(n.populate, i));
+			let s = await this.model.paginate(r, a);
+			if (i && i.length > 0) {
+				let e = await this.populateDynamicVirtualsForDocuments(s.docs, n.populate);
+				return {
+					success: !0,
+					result: {
+						...s,
+						docs: e.map((e) => e?.toObject?.() ?? e)
+					}
+				};
+			}
+			return {
+				success: !0,
+				result: {
+					...s,
+					docs: s.docs.map((e) => e?.toObject?.() ?? e)
+				}
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async findPagingAggregate(e, t = {}) {
+		try {
+			let n = this.getDynamicVirtuals(), r = { ...t };
+			t.populate && (r.populate = o(t.populate, n));
+			let i = await this.model.aggregatePaginate(this.model.aggregate(e), r), a = await this.populateDynamicVirtualsForDocuments(i.docs, t.populate);
+			return {
+				success: !0,
+				result: {
+					...i,
+					docs: a.map((e) => e?.toObject?.() ?? e)
+				}
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async count(t = {}) {
+		try {
+			let n = e(t);
+			return {
+				success: !0,
+				result: await this.model.countDocuments(n)
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async createOne(e) {
+		try {
+			let t = await this.model.create(e);
+			return {
+				success: !0,
+				result: t?.toObject?.() ?? t
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async createMany(e, t = {}) {
+		try {
+			return {
+				success: !0,
+				result: (await this.model.insertMany(e, t)).map((e) => e?.toObject?.() ?? e)
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async updateOne(t = {}, n = {}, r = {}) {
+		try {
+			let a = e(t), o = await this.model.findOneAndUpdate(a, n, {
+				new: !0,
+				...r
+			}).exec();
+			return o ? {
+				success: !0,
+				result: o?.toObject?.() ?? o
+			} : {
+				success: !1,
+				message: `Failed to update ${this.getModelName()}.`,
+				code: i.NOT_FOUND.CODE
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async updateMany(t = {}, n = {}, r = {}) {
+		try {
+			let i = e(t);
+			return {
+				success: !0,
+				result: await this.model.updateMany(i, n, r).exec()
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async deleteOne(t = {}, n = {}) {
+		try {
+			let r = e(t), a = await this.model.findOneAndDelete(r, n).exec();
+			return a ? {
+				success: !0,
+				result: a?.toObject?.() ?? a
+			} : {
+				success: !1,
+				message: `No ${this.getModelName()} found to delete.`,
+				code: i.NOT_FOUND.CODE
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async deleteMany(t = {}, n = {}) {
+		try {
+			let r = e(t), a = await this.model.deleteMany(r, n).exec();
+			return a.deletedCount === 0 ? {
+				success: !1,
+				message: "No documents found to delete.",
+				code: i.NOT_FOUND.CODE
+			} : {
+				success: !0,
+				result: a
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async createShortId(e, t = 4) {
+		try {
+			let r = Array.from({ length: 10 }, (r, i) => n(e, i + t)), a = (await Promise.all(r.map((e) => this.model.exists({ shortId: e })))).findIndex((e) => !e);
+			if (a !== -1) {
+				let e = r[a];
+				if (e) return {
+					success: !0,
+					result: e
+				};
+			}
+			return {
+				success: !1,
+				message: "Failed to create a unique shortId",
+				code: i.INTERNAL_SERVER_ERROR.CODE
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	createSlugQuery({ slug: e, field: t, isObject: n, haveHistory: r = !1, filter: i }) {
+		let a = { ...i ?? {} };
+		return n ? {
+			...a,
+			$or: [{ [`slug.${t}`]: e }, ...r ? [{ slugHistory: { $elemMatch: { [`slug.${t}`]: e } } }] : []]
+		} : {
+			...a,
+			$or: [{ slug: e }, ...r ? [{ slugHistory: e }] : []]
+		};
+	}
+	async createUniqueSlug({ slug: e, field: n, isObject: i, haveHistory: a, filter: o }) {
+		if (!e || typeof e != "string") throw Error("Invalid slug provided: must be a non-empty string");
+		let s = r(e);
+		if (!await this.model.exists(this.createSlugQuery({
+			slug: s,
+			field: n,
+			isObject: i,
+			haveHistory: a,
+			filter: o
+		}))) return s;
+		let c = Array.from({ length: 100 }, (e, t) => `${s}-${t + 1}`), l = c.map((e) => this.createSlugQuery({
+			slug: e,
+			field: n,
+			isObject: i,
+			haveHistory: a,
+			filter: o
+		})), u = i ? `slug.${n}` : "slug", d = await this.model.find({ $or: l.map((e) => e.$or).flat() }).select(u).lean(), f = new Set(d.map((e) => i ? e?.slug?.[n] : e?.slug));
+		return c.find((e) => !f.has(e)) || `${s}-${Date.now()}-${t(6)}`;
+	}
+	async createSlug({ field: e, from: t, filter: n, haveHistory: r }) {
+		try {
+			let i = t[e];
+			return s(i) ? {
+				success: !0,
+				result: Object.fromEntries(await Promise.all(Object.entries(i).map(async ([e, t]) => [e, await this.createUniqueSlug({
+					slug: t,
+					field: e,
+					isObject: !0,
+					haveHistory: r,
+					filter: n
+				})])))
+			} : {
+				success: !0,
+				result: await this.createUniqueSlug({
+					slug: i,
+					field: e,
+					isObject: !1,
+					haveHistory: r,
+					filter: n
+				})
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async checkSlug({ slug: e, field: t, from: n, filter: i, haveHistory: o }) {
+		try {
+			let a = n[t];
+			if (s(a)) {
+				let e = Object.values(a).map((e) => r(e));
+				return (await Promise.all(e.map((e) => this.model.exists(this.createSlugQuery({
+					slug: e,
+					field: t,
+					isObject: !0,
+					haveHistory: o,
+					filter: i
+				}))))).some((e) => e) ? {
+					success: !0,
+					result: !0
+				} : {
+					success: !0,
+					result: !1
+				};
+			}
+			let c = r(e);
+			return {
+				success: !0,
+				result: await this.model.exists(this.createSlugQuery({
+					slug: c,
+					field: t,
+					isObject: !1,
+					filter: i
+				})) !== null
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async aggregate(e) {
+		try {
+			return {
+				success: !0,
+				result: await this.model.aggregate(e)
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
+	async distinct(e, t = {}, n = {}) {
+		try {
+			return {
+				success: !0,
+				result: await this.model.distinct(e, t, n)
+			};
+		} catch (e) {
+			return a(e);
+		}
+	}
 };
-//# sourceMappingURL=mongo.controller.mongoose.js.map
+//#endregion
+export { l as MongooseController };
+
+//# sourceMappingURL=mongo.controller.mongoose.js.map