@cyberskill/shared 3.2.0 → 3.3.0

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

@@ -1,295 +1,136 @@
-import m from "mongoose-aggregate-paginate-v2";
-import p from "mongoose-paginate-v2";
-import { randomUUID as f } from "node:crypto";
-import { deepClone as y, getNestedValue as g, setNestedValue as h } from "../../util/object/object.util.js";
-import { regexSearchMapper as w } from "../../util/common/common.util.js";
-import { writeFileSync as S, addGitIgnoreEntry as E } from "../fs/fs.util.js";
-import { PATH as d, MIGRATE_MONGO_CONFIG as R } from "../path/path.constant.js";
-import { validate as x } from "../../util/validate/validate.util.js";
-function I(e) {
-  return e === e.toUpperCase() ? e.charAt(0).toUpperCase() + e.slice(1).toLowerCase() : e;
+import { regexSearchMapper as e } from "../../util/common/common.util.js";
+import { deepClone as t, getNestedValue as n, setNestedValue as r } from "../../util/object/object.util.js";
+import { validate as i } from "../../util/validate/validate.util.js";
+import { addGitIgnoreEntry as a, writeFileSync as o } from "../fs/fs.util.js";
+import { MIGRATE_MONGO_CONFIG as s, PATH as c } from "../path/path.constant.js";
+import "./mongo.populate.js";
+import l from "mongoose-aggregate-paginate-v2";
+import u from "mongoose-paginate-v2";
+import { randomUUID as d } from "node:crypto";
+//#region src/node/mongo/mongo.util.ts
+function f(e) {
+	return e === e.toUpperCase() ? e.charAt(0).toUpperCase() + e.slice(1).toLowerCase() : e;
 }
-const l = {
-  /**
-   * 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: f(),
-      isDel: !1,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-  },
-  /**
-   * Applies plugins to a Mongoose schema.
-   * This function filters out falsy plugins and applies the remaining valid plugins
-   * to the provided schema.
-   *
-   * @param schema - The Mongoose schema to apply plugins to.
-   * @param plugins - An array of plugin functions or false values to filter and apply.
-   */
-  applyPlugins(e, r) {
-    r.filter((t) => typeof t == "function").forEach((t) => e.plugin(t));
-  },
-  /**
-   * 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(e, r) {
-    r.forEach(({ method: t, pre: n, post: i }) => {
-      t && n && e.pre(t, n), t && i && e.post(t, i);
-    });
-  },
-  /**
-   * 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(e) {
-    return new e.Schema(
-      {
-        id: { type: String, default: () => f(), unique: !0 },
-        isDel: { type: Boolean, default: !1 }
-      },
-      { timestamps: !0 }
-    );
-  },
-  /**
-   * Creates a Mongoose schema with optional virtual fields and generic fields.
-   * This function creates a new Mongoose schema from the provided schema definition,
-   * optionally adds virtual fields, and includes generic fields (unless standalone is true).
-   *
-   * @param options - Configuration options including mongoose instance, schema definition, virtuals, and standalone flag.
-   * @param options.mongoose - The Mongoose instance to use for schema creation.
-   * @param options.schema - The schema definition object.
-   * @param options.virtuals - Optional array of virtual field configurations.
-   * @param options.standalone - Whether to exclude generic fields (default: false).
-   * @returns A configured Mongoose schema.
-   */
-  createSchema({
-    mongoose: e,
-    schema: r,
-    virtuals: t = [],
-    standalone: n = !1
-  }) {
-    const i = new e.Schema(r, {
-      toJSON: { virtuals: !0 },
-      // So `res.json()` and other `JSON.stringify()` functions include virtuals
-      toObject: { virtuals: !0 }
-      // So `console.log()` and other functions that use `toObject()` include virtuals
-    });
-    return t.forEach(({ name: s, options: a, get: o }) => {
-      if (l.isDynamicVirtual(a)) {
-        const c = i.statics;
-        c._dynamicVirtuals || (c._dynamicVirtuals = []), c._dynamicVirtuals.push({
-          name: s,
-          options: a
-        });
-        const u = i.virtual(s);
-        o ? u.get(o) : u.get(function() {
-          return this._populated?.[s] || (a?.count ? 0 : a?.justOne ? null : []);
-        });
-      } else {
-        const c = i.virtual(s, a);
-        o && c.get(o);
-      }
-    }), n || i.add(l.createGenericSchema(e)), i;
-  },
-  /**
-   * 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: e,
-    name: r,
-    schema: t,
-    virtuals: n = [],
-    pagination: i = !0,
-    aggregate: s = !0,
-    middlewares: a = []
-  }) {
-    if (!r)
-      throw new Error("Model name is required.");
-    if (e.models[r])
-      return e.models[r];
-    const o = l.createSchema({ mongoose: e, schema: t, virtuals: n });
-    (i || s) && l.applyPlugins(o, [
-      i && p,
-      s && m
-    ]), l.applyMiddlewares(o, a);
-    const c = e.model(r, o);
-    return n.length > 0 && (c._virtualConfigs = n), c;
-  },
-  /**
-   * 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 async function(e) {
-        return !x.isEmpty(e);
-      };
-    },
-    /**
-     * 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(e) {
-      return async function(r) {
-        if (!Array.isArray(e) || e.length === 0)
-          throw new Error("Fields must be a non-empty array of strings.");
-        const t = { $or: e.map((i) => ({ [i]: r })) };
-        return !await this.constructor.exists(t);
-      };
-    },
-    /**
-     * 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(e) {
-      return async (r) => {
-        if (!Array.isArray(e) || e.some((t) => !(t instanceof RegExp)))
-          throw new Error("regexArray must be an array of valid RegExp objects.");
-        return e.every((t) => t.test(r));
-      };
-    }
-  },
-  /**
-   * Migration utilities for MongoDB.
-   * This object extends the migrate-mongo library with additional configuration utilities.
-   */
-  migrate: {
-    /**
-     * Lazily loads the migrate-mongo module to avoid eager import overhead.
-     * Use this to access migrate-mongo methods (up, down, status, create) programmatically.
-     *
-     * @returns A promise resolving to the migrate-mongo module.
-     */
-    async getModule() {
-      return (await import("migrate-mongo")).default;
-    },
-    /**
-     * 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: (e) => {
-      const r = `// This file is automatically generated by the Cyberskill CLI.
-module.exports = ${JSON.stringify(e, null, 4)}`;
-      S(d.MIGRATE_MONGO_CONFIG, r), E(d.GIT_IGNORE, R);
-    }
-  },
-  /**
-   * 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(e, r) {
-    if (!e)
-      return {};
-    let t = y(e);
-    if (!r || r.length === 0)
-      return t;
-    for (const n of r) {
-      const i = n.toString().split("."), s = g(t, i);
-      if (typeof s == "string" && s.length > 0) {
-        const a = {
-          $regex: `.*${w(s)}.*`,
-          $options: "i"
-        };
-        t = h(t, i, a);
-      }
-    }
-    return t;
-  },
-  /**
-   * Checks if a virtual options object has a dynamic ref function.
-   *
-   * @param options - The virtual options to check.
-   * @returns True if the options contain a dynamic ref function.
-   */
-  isDynamicVirtual(e) {
-    return !!(e && typeof e.ref == "function");
-  },
-  /**
-   * Generic utility function to get new records from the database
-   * @param controller - MongoController instance
-   * @param recordsToCheck - Array of records to check
-   * @param filterFn - Function to determine if a record already exists
-   * @returns Array of records that don't exist in the database
-   */
-  async getNewRecords(e, r, t) {
-    const n = await e.findAll({});
-    return n.success ? r.filter(
-      (s) => !n.result.some(
-        (a) => t(a, s)
-      )
-    ) : r;
-  },
-  /**
-   * Generic utility function to get existing records that match the filter criteria
-   * @param controller - MongoController instance
-   * @param recordsToCheck - Array of records to check
-   * @param filterFn - Function to determine if a record exists
-   * @returns Array of existing records that match the filter criteria
-   */
-  async getExistingRecords(e, r, t) {
-    const n = await e.findAll({});
-    return n.success ? n.result.filter(
-      (s) => r.some(
-        (a) => t(s, a)
-      )
-    ) : [];
-  }
+var p = {
+	createGenericFields() {
+		return {
+			id: d(),
+			isDel: !1,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	},
+	applyPlugins(e, t) {
+		t.filter((e) => typeof e == "function").forEach((t) => e.plugin(t));
+	},
+	applyMiddlewares(e, t) {
+		t.forEach(({ method: t, pre: n, post: r }) => {
+			t && n && e.pre(t, n), t && r && e.post(t, r);
+		});
+	},
+	createGenericSchema(e) {
+		return new e.Schema({
+			id: {
+				type: String,
+				default: () => d(),
+				unique: !0
+			},
+			isDel: {
+				type: Boolean,
+				default: !1
+			}
+		}, { timestamps: !0 });
+	},
+	createSchema({ mongoose: e, schema: t, virtuals: n = [], standalone: r = !1 }) {
+		let i = new e.Schema(t, {
+			toJSON: { virtuals: !0 },
+			toObject: { virtuals: !0 }
+		});
+		return n.forEach(({ name: e, options: t, get: n }) => {
+			if (p.isDynamicVirtual(t)) {
+				let r = i.statics;
+				r._dynamicVirtuals ||= [], r._dynamicVirtuals.push({
+					name: e,
+					options: t
+				}), i.virtual(e).get(n || function() {
+					return this._populated?.[e] || (t?.count ? 0 : t?.justOne ? null : []);
+				});
+			} else {
+				let r = i.virtual(e, t);
+				n && r.get(n);
+			}
+		}), r || i.add(p.createGenericSchema(e)), i;
+	},
+	createModel({ mongoose: e, name: t, schema: n, virtuals: r = [], pagination: i = !0, aggregate: a = !0, middlewares: o = [] }) {
+		if (!t) throw Error("Model name is required.");
+		if (e.models[t]) return e.models[t];
+		let s = p.createSchema({
+			mongoose: e,
+			schema: n,
+			virtuals: r
+		});
+		(i || a) && p.applyPlugins(s, [i && u, a && l]), p.applyMiddlewares(s, o);
+		let c = e.model(t, s);
+		return r.length > 0 && (c._virtualConfigs = r), c;
+	},
+	validator: {
+		isRequired() {
+			return async function(e) {
+				return !i.isEmpty(e);
+			};
+		},
+		isUnique(e) {
+			return async function(t) {
+				if (!Array.isArray(e) || e.length === 0) throw Error("Fields must be a non-empty array of strings.");
+				let n = { $or: e.map((e) => ({ [e]: t })) };
+				return !await this.constructor.exists(n);
+			};
+		},
+		matchesRegex(e) {
+			return async (t) => {
+				if (!Array.isArray(e) || e.some((e) => !(e instanceof RegExp))) throw Error("regexArray must be an array of valid RegExp objects.");
+				return e.every((e) => e.test(t));
+			};
+		}
+	},
+	migrate: {
+		async getModule() {
+			return (await import("migrate-mongo")).default;
+		},
+		setConfig: (e) => {
+			let t = `// This file is automatically generated by the Cyberskill CLI.\nmodule.exports = ${JSON.stringify(e, null, 4)}`;
+			o(c.MIGRATE_MONGO_CONFIG, t), a(c.GIT_IGNORE, s);
+		}
+	},
+	regexify(i, a) {
+		if (!i) return {};
+		let o = t(i);
+		if (!a || a.length === 0) return o;
+		for (let t of a) {
+			let i = t.toString().split("."), a = n(o, i);
+			if (typeof a == "string" && a.length > 0) {
+				let t = {
+					$regex: `.*${e(a)}.*`,
+					$options: "i"
+				};
+				o = r(o, i, t);
+			}
+		}
+		return o;
+	},
+	isDynamicVirtual(e) {
+		return !!(e && typeof e.ref == "function");
+	},
+	async getNewRecords(e, t, n, r = {}) {
+		let i = await e.findAll(r);
+		return i.success ? t.filter((e) => !i.result.some((t) => n(t, e))) : t;
+	},
+	async getExistingRecords(e, t, n, r = {}) {
+		let i = await e.findAll(r);
+		return i.success ? i.result.filter((e) => t.some((t) => n(e, t))) : [];
+	}
 };
-export {
-  I as convertEnumToModelName,
-  l as mongo
-};
-//# sourceMappingURL=mongo.util.js.map
+//#endregion
+export { f as convertEnumToModelName, p as mongo };
+
+//# sourceMappingURL=mongo.util.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"mongo.util.js","sources":["../../../src/node/mongo/mongo.util.ts"],"sourcesContent":["import type migrate from 'migrate-mongo';\nimport type mongooseRaw from 'mongoose';\n\nimport aggregatePaginate from 'mongoose-aggregate-paginate-v2';\nimport mongoosePaginate from 'mongoose-paginate-v2';\nimport { randomUUID } from 'node:crypto';\n\nimport { deepClone, getNestedValue, regexSearchMapper, setNestedValue } from '#util/index.js';\nimport { validate } from '#util/validate/index.js';\n\nimport type { MongoController } from './mongo.controller.js';\nimport type { C_Document, I_CreateModelOptions, I_CreateSchemaOptions, I_DynamicVirtualConfig, I_DynamicVirtualOptions, I_ExtendedModel, I_GenericDocument, I_MongooseModelMiddleware, T_MongoosePlugin, T_MongooseShema, T_QueryFilter, T_VirtualOptions, T_WithId } from './mongo.type.js';\n\nimport { addGitIgnoreEntry, writeFileSync } from '../fs/index.js';\nimport { MIGRATE_MONGO_CONFIG, PATH } from '../path/index.js';\n\n/**\n * Converts enum values to proper model names.\n * Handles common naming conventions like converting 'USER' to 'User'.\n *\n * @param enumValue - The enum value to convert\n * @returns The converted model name\n */\nexport function convertEnumToModelName(enumValue: string): string {\n    if (enumValue === enumValue.toUpperCase()) {\n        return enumValue.charAt(0).toUpperCase() + enumValue.slice(1).toLowerCase();\n    }\n\n    return enumValue;\n}\n\n/**\n * Interface for the MongoDB utility object to enable explicit type annotation.\n * Required to avoid TS7056 (inferred type exceeds maximum serialization length).\n */\ninterface I_MongoUtils {\n    createGenericFields: () => I_GenericDocument;\n    applyPlugins: <T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>) => void;\n    applyMiddlewares: <T extends Partial<C_Document>>(schema: T_MongooseShema<T>, middlewares: I_MongooseModelMiddleware<T>[]) => void;\n    createGenericSchema: (mongoose: typeof mongooseRaw) => T_MongooseShema<I_GenericDocument>;\n    createSchema: <T, R extends string>(options: I_CreateSchemaOptions<T, R>) => T_MongooseShema<T>;\n    createModel: <T extends Partial<C_Document>, R extends string>(options: I_CreateModelOptions<T, R>) => I_ExtendedModel<T>;\n    validator: {\n        isRequired: <T>() => (this: T, value: unknown) => Promise<boolean>;\n        isUnique: <T extends { constructor: { exists: (query: { [key: string]: unknown }) => Promise<unknown> } }>(fields: string[]) => (this: T, value: unknown) => Promise<boolean>;\n        matchesRegex: (regexArray: RegExp[]) => (value: string) => Promise<boolean>;\n    };\n    migrate: {\n        getModule: () => Promise<typeof migrate>;\n        setConfig: (options: Partial<migrate.config.Config> & { moduleSystem?: 'commonjs' | 'esm' }) => void;\n    };\n    regexify: <T>(filter?: T_QueryFilter<T>, fields?: (keyof T | string)[]) => T_QueryFilter<T>;\n    isDynamicVirtual: <T, R extends string>(options?: T_VirtualOptions<T, R>) => options is I_DynamicVirtualOptions<T, R>;\n    getNewRecords: <T extends I_GenericDocument>(controller: MongoController<T>, recordsToCheck: T[], filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean) => Promise<T[]>;\n    getExistingRecords: <T extends I_GenericDocument>(controller: MongoController<T>, recordsToCheck: T[], filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean) => Promise<T_WithId<T>[]>;\n}\n\n/**\n * MongoDB utility object providing comprehensive database operations and utilities.\n * This object contains methods for creating generic fields, applying plugins and middlewares,\n * creating schemas and models, validation functions, migration utilities, and regex filtering.\n */\nexport const mongo: I_MongoUtils = {\n    /**\n     * Creates generic fields that are commonly used across MongoDB documents.\n     * This function generates standard fields including a UUID, deletion flag, and timestamps\n     * that can be applied to any document schema.\n     *\n     * @returns An object containing generic document fields (id, isDel, createdAt, updatedAt).\n     */\n    createGenericFields(): I_GenericDocument {\n        return {\n            id: randomUUID(),\n            isDel: false,\n            createdAt: new Date(),\n            updatedAt: new Date(),\n        };\n    },\n    /**\n     * Applies plugins to a Mongoose schema.\n     * This function filters out falsy plugins and applies the remaining valid plugins\n     * to the provided schema.\n     *\n     * @param schema - The Mongoose schema to apply plugins to.\n     * @param plugins - An array of plugin functions or false values to filter and apply.\n     */\n    applyPlugins<T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>) {\n        plugins\n            .filter((plugin): plugin is T_MongoosePlugin => typeof plugin === 'function')\n            .forEach(plugin => schema.plugin(plugin));\n    },\n    /**\n     * Applies middleware functions to a Mongoose schema.\n     * This function configures pre and post middleware for specified methods on the schema.\n     *\n     * @param schema - The Mongoose schema to apply middleware to.\n     * @param middlewares - An array of middleware configurations with method, pre, and post functions.\n     */\n    applyMiddlewares<T extends Partial<C_Document>>(\n        schema: T_MongooseShema<T>,\n        middlewares: I_MongooseModelMiddleware<T>[],\n    ) {\n        middlewares.forEach(({ method, pre, post }) => {\n            if (method && pre) {\n                schema.pre(method as RegExp, pre);\n            }\n\n            if (method && post) {\n                schema.post(method as RegExp, post);\n            }\n        });\n    },\n    /**\n     * Creates a generic Mongoose schema with common fields.\n     * This function creates a base schema with UUID field and deletion flag,\n     * configured with automatic timestamps.\n     *\n     * @param mongoose - The Mongoose instance to create the schema with.\n     * @returns A Mongoose schema with generic document fields.\n     */\n    createGenericSchema(mongoose: typeof mongooseRaw) {\n        return new mongoose.Schema<I_GenericDocument>(\n            {\n                id: { type: String, default: () => randomUUID(), unique: true },\n                isDel: { type: Boolean, default: false },\n            },\n            { timestamps: true },\n        );\n    },\n    /**\n     * Creates a Mongoose schema with optional virtual fields and generic fields.\n     * This function creates a new Mongoose schema from the provided schema definition,\n     * optionally adds virtual fields, and includes generic fields (unless standalone is true).\n     *\n     * @param options - Configuration options including mongoose instance, schema definition, virtuals, and standalone flag.\n     * @param options.mongoose - The Mongoose instance to use for schema creation.\n     * @param options.schema - The schema definition object.\n     * @param options.virtuals - Optional array of virtual field configurations.\n     * @param options.standalone - Whether to exclude generic fields (default: false).\n     * @returns A configured Mongoose schema.\n     */\n    createSchema<T, R extends string = string>({\n        mongoose,\n        schema,\n        virtuals = [],\n        standalone = false,\n    }: I_CreateSchemaOptions<T, R>): T_MongooseShema<T> {\n        const createdSchema = new mongoose.Schema<T>(schema, {\n            toJSON: { virtuals: true }, // So `res.json()` and other `JSON.stringify()` functions include virtuals\n            toObject: { virtuals: true }, // So `console.log()` and other functions that use `toObject()` include virtuals\n        });\n\n        virtuals.forEach(({ name, options, get }) => {\n            if (mongo.isDynamicVirtual<T, R>(options)) {\n                const schemaStatics = createdSchema.statics as Record<string, unknown>;\n\n                if (!schemaStatics['_dynamicVirtuals']) {\n                    schemaStatics['_dynamicVirtuals'] = [];\n                }\n\n                (schemaStatics['_dynamicVirtuals'] as I_DynamicVirtualConfig<T>[]).push({\n                    name: name as string,\n                    options,\n                });\n\n                const virtualInstance = createdSchema.virtual(name as string);\n\n                if (get) {\n                    virtualInstance.get(get);\n                }\n                else {\n                    virtualInstance.get(function (this: T & { _populated?: { [key: string]: unknown } }) {\n                        return this._populated?.[name as string] || (options?.count ? 0 : (options?.justOne ? null : []));\n                    });\n                }\n            }\n            else {\n                const virtualInstance = createdSchema.virtual(name as string, options);\n\n                if (get) {\n                    virtualInstance.get(get);\n                }\n            }\n        });\n\n        if (!standalone) {\n            createdSchema.add(mongo.createGenericSchema(mongoose));\n        }\n\n        return createdSchema;\n    },\n    /**\n     * Creates a Mongoose model with plugins, middleware, and pagination support.\n     * This function creates a model from a schema with optional pagination and aggregation plugins,\n     * and applies any specified middleware. If a model with the same name already exists, it returns the existing model.\n     *\n     * @param options - Configuration options including mongoose instance, model name, schema, and feature flags.\n     * @param options.mongoose - The Mongoose instance to use for model creation.\n     * @param options.name - The name of the model to create.\n     * @param options.schema - The schema definition for the model.\n     * @param options.pagination - Whether to enable pagination plugin (default: false).\n     * @param options.aggregate - Whether to enable aggregation pagination plugin (default: false).\n     * @param options.virtuals - Optional array of virtual field configurations.\n     * @param options.middlewares - Optional array of middleware configurations.\n     * @returns A configured Mongoose model with extended functionality.\n     * @throws {Error} When the model name is not provided.\n     */\n    createModel<T extends Partial<C_Document>, R extends string = string>({\n        mongoose: currentMongooseInstance,\n        name,\n        schema,\n        virtuals = [],\n        pagination = true,\n        aggregate = true,\n        middlewares = [],\n    }: I_CreateModelOptions<T, R>): I_ExtendedModel<T> {\n        if (!name) {\n            throw new Error('Model name is required.');\n        }\n\n        if (currentMongooseInstance.models[name]) {\n            return currentMongooseInstance.models[name] as I_ExtendedModel<T>;\n        }\n\n        const createdSchema = mongo.createSchema({ mongoose: currentMongooseInstance, schema, virtuals });\n\n        if (pagination || aggregate) {\n            mongo.applyPlugins<T>(createdSchema, [\n                pagination && mongoosePaginate,\n                aggregate && aggregatePaginate,\n            ]);\n        }\n\n        mongo.applyMiddlewares<T>(createdSchema, middlewares);\n\n        const model = currentMongooseInstance.model<T>(name, createdSchema) as I_ExtendedModel<T>;\n\n        if (virtuals.length > 0) {\n            (model as any)._virtualConfigs = virtuals;\n        }\n\n        return model;\n    },\n    /**\n     * Validation utilities for Mongoose schemas.\n     * This object provides common validation functions that can be used in Mongoose schema definitions.\n     */\n    validator: {\n        /**\n         * Creates a required field validator.\n         * This function returns a validator that checks if a field value is not empty\n         * using the validate.isEmpty utility.\n         *\n         * @returns A validation function that returns true if the field is not empty.\n         */\n        isRequired<T>(): (this: T, value: unknown) => Promise<boolean> {\n            return async function (this: T, value: unknown): Promise<boolean> {\n                return !validate.isEmpty(value);\n            };\n        },\n        /**\n         * Creates a unique field validator.\n         * This function returns a validator that checks if a field value is unique\n         * across the specified fields in the collection.\n         *\n         * @param fields - An array of field names to check for uniqueness.\n         * @returns A validation function that returns true if the value is unique across the specified fields.\n         * @throws {Error} When fields is not a non-empty array of strings.\n         */\n        isUnique<T extends { constructor: { exists: (query: { [key: string]: unknown }) => Promise<unknown> } }>(fields: string[]) {\n            return async function (this: T, value: unknown): Promise<boolean> {\n                if (!Array.isArray(fields) || fields.length === 0) {\n                    throw new Error('Fields must be a non-empty array of strings.');\n                }\n\n                const query = { $or: fields.map(field => ({ [field]: value })) };\n                const existingDocument = await this.constructor.exists(query);\n\n                return !existingDocument;\n            };\n        },\n        /**\n         * Creates a regex pattern validator.\n         * This function returns a validator that checks if a string value matches\n         * all provided regular expressions.\n         *\n         * @param regexArray - An array of regular expressions to test against the value.\n         * @returns A validation function that returns true if the value matches all regex patterns.\n         * @throws {Error} When regexArray is not an array of valid RegExp objects.\n         */\n        matchesRegex(regexArray: RegExp[]): (value: string) => Promise<boolean> {\n            return async (value: string): Promise<boolean> => {\n                if (!Array.isArray(regexArray) || regexArray.some(r => !(r instanceof RegExp))) {\n                    throw new Error('regexArray must be an array of valid RegExp objects.');\n                }\n\n                return regexArray.every(regex => regex.test(value));\n            };\n        },\n    },\n    /**\n     * Migration utilities for MongoDB.\n     * This object extends the migrate-mongo library with additional configuration utilities.\n     */\n    migrate: {\n        /**\n         * Lazily loads the migrate-mongo module to avoid eager import overhead.\n         * Use this to access migrate-mongo methods (up, down, status, create) programmatically.\n         *\n         * @returns A promise resolving to the migrate-mongo module.\n         */\n        async getModule(): Promise<typeof migrate> {\n            return (await import('migrate-mongo')).default;\n        },\n        /**\n         * Sets the migration configuration and updates .gitignore.\n         * This function creates a migration configuration file and ensures it's properly\n         * excluded from version control.\n         *\n         * @param options - Migration configuration options to write to the config file.\n         */\n        setConfig: (options: Partial<migrate.config.Config> & { moduleSystem?: 'commonjs' | 'esm' }) => {\n            const optionsJS = `// This file is automatically generated by the Cyberskill CLI.\\nmodule.exports = ${JSON.stringify(options, null, 4)}`;\n\n            writeFileSync(PATH.MIGRATE_MONGO_CONFIG, optionsJS);\n\n            addGitIgnoreEntry(PATH.GIT_IGNORE, MIGRATE_MONGO_CONFIG);\n        },\n    },\n    /**\n     * Converts string values in a filter to regex patterns for case-insensitive search.\n     * This function recursively processes a filter object and converts string values in specified fields\n     * to MongoDB regex patterns that support accented character matching.\n     *\n     * @param filter - The filter object to process.\n     * @param fields - An array of field names to convert to regex patterns.\n     * @returns A new filter object with string values converted to regex patterns.\n     */\n    regexify<T>(filter?: T_QueryFilter<T>, fields?: (keyof T | string)[]): T_QueryFilter<T> {\n        if (!filter) {\n            return {} as T_QueryFilter<T>;\n        }\n\n        let newFilter = deepClone(filter);\n\n        if (!fields || fields.length === 0) {\n            return newFilter;\n        }\n\n        for (const field of fields) {\n            const path = field.toString().split('.');\n            const value = getNestedValue(newFilter, path);\n\n            if (typeof value === 'string' && value.length > 0) {\n                const regexValue = {\n                    $regex: `.*${regexSearchMapper(value)}.*`,\n                    $options: 'i',\n                };\n\n                newFilter = setNestedValue(newFilter, path, regexValue);\n            }\n        }\n\n        return newFilter;\n    },\n    /**\n     * Checks if a virtual options object has a dynamic ref function.\n     *\n     * @param options - The virtual options to check.\n     * @returns True if the options contain a dynamic ref function.\n     */\n    isDynamicVirtual<T, R extends string = string>(options?: T_VirtualOptions<T, R>): options is I_DynamicVirtualOptions<T, R> {\n        return Boolean(options && typeof options.ref === 'function');\n    },\n\n    /**\n     * Generic utility function to get new records from the database\n     * @param controller - MongoController instance\n     * @param recordsToCheck - Array of records to check\n     * @param filterFn - Function to determine if a record already exists\n     * @returns Array of records that don't exist in the database\n     */\n    async getNewRecords<T extends I_GenericDocument>(\n        controller: MongoController<T>,\n        recordsToCheck: T[],\n        filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean,\n    ): Promise<T[]> {\n        const existingRecords = await controller.findAll({});\n\n        if (!existingRecords.success) {\n            return recordsToCheck;\n        }\n\n        const filteredRecords = recordsToCheck.filter(newRecord =>\n            !existingRecords.result.some((existingRecord: T_WithId<T>) =>\n                filterFn(existingRecord, newRecord),\n            ),\n        );\n\n        return filteredRecords;\n    },\n\n    /**\n     * Generic utility function to get existing records that match the filter criteria\n     * @param controller - MongoController instance\n     * @param recordsToCheck - Array of records to check\n     * @param filterFn - Function to determine if a record exists\n     * @returns Array of existing records that match the filter criteria\n     */\n    async getExistingRecords<T extends I_GenericDocument>(\n        controller: MongoController<T>,\n        recordsToCheck: T[],\n        filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean,\n    ): Promise<T_WithId<T>[]> {\n        const existingRecords = await controller.findAll({});\n\n        if (!existingRecords.success) {\n            return [];\n        }\n\n        const foundRecords = existingRecords.result.filter((existingRecord: T_WithId<T>) =>\n            recordsToCheck.some((newRecord: T) =>\n                filterFn(existingRecord, newRecord),\n            ),\n        );\n\n        return foundRecords;\n    },\n};\n\nexport { applyNestedPopulate } from './mongo.populate.js';\n"],"names":["convertEnumToModelName","enumValue","mongo","randomUUID","schema","plugins","plugin","middlewares","method","pre","post","mongoose","virtuals","standalone","createdSchema","name","options","get","schemaStatics","virtualInstance","currentMongooseInstance","pagination","aggregate","mongoosePaginate","aggregatePaginate","model","value","validate","fields","query","field","regexArray","r","regex","optionsJS","writeFileSync","PATH","addGitIgnoreEntry","MIGRATE_MONGO_CONFIG","filter","newFilter","deepClone","path","getNestedValue","regexValue","regexSearchMapper","setNestedValue","controller","recordsToCheck","filterFn","existingRecords","newRecord","existingRecord"],"mappings":"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"}
+{"version":3,"file":"mongo.util.js","names":[],"sources":["../../../src/node/mongo/mongo.util.ts"],"sourcesContent":["import type migrate from 'migrate-mongo';\nimport type mongooseRaw from 'mongoose';\n\nimport aggregatePaginate from 'mongoose-aggregate-paginate-v2';\nimport mongoosePaginate from 'mongoose-paginate-v2';\nimport { randomUUID } from 'node:crypto';\n\nimport { deepClone, getNestedValue, regexSearchMapper, setNestedValue } from '#util/index.js';\nimport { validate } from '#util/validate/index.js';\n\nimport type { MongoController } from './mongo.controller.js';\nimport type { C_Document, I_CreateModelOptions, I_CreateSchemaOptions, I_DynamicVirtualConfig, I_DynamicVirtualOptions, I_ExtendedModel, I_GenericDocument, I_MongooseModelMiddleware, T_MongoosePlugin, T_MongooseShema, T_QueryFilter, T_VirtualOptions, T_WithId } from './mongo.type.js';\n\nimport { addGitIgnoreEntry, writeFileSync } from '../fs/index.js';\nimport { MIGRATE_MONGO_CONFIG, PATH } from '../path/index.js';\n\n/**\n * Converts enum values to proper model names.\n * Handles common naming conventions like converting 'USER' to 'User'.\n *\n * @param enumValue - The enum value to convert\n * @returns The converted model name\n */\nexport function convertEnumToModelName(enumValue: string): string {\n    if (enumValue === enumValue.toUpperCase()) {\n        return enumValue.charAt(0).toUpperCase() + enumValue.slice(1).toLowerCase();\n    }\n\n    return enumValue;\n}\n\n/**\n * Interface for the MongoDB utility object to enable explicit type annotation.\n * Required to avoid TS7056 (inferred type exceeds maximum serialization length).\n */\ninterface I_MongoUtils {\n    createGenericFields: () => I_GenericDocument;\n    applyPlugins: <T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>) => void;\n    applyMiddlewares: <T extends Partial<C_Document>>(schema: T_MongooseShema<T>, middlewares: I_MongooseModelMiddleware<T>[]) => void;\n    createGenericSchema: (mongoose: typeof mongooseRaw) => T_MongooseShema<I_GenericDocument>;\n    createSchema: <T, R extends string>(options: I_CreateSchemaOptions<T, R>) => T_MongooseShema<T>;\n    createModel: <T extends Partial<C_Document>, R extends string>(options: I_CreateModelOptions<T, R>) => I_ExtendedModel<T>;\n    validator: {\n        isRequired: <T>() => (this: T, value: unknown) => Promise<boolean>;\n        isUnique: <T extends { constructor: { exists: (query: { [key: string]: unknown }) => Promise<unknown> } }>(fields: string[]) => (this: T, value: unknown) => Promise<boolean>;\n        matchesRegex: (regexArray: RegExp[]) => (value: string) => Promise<boolean>;\n    };\n    migrate: {\n        getModule: () => Promise<typeof migrate>;\n        setConfig: (options: Partial<migrate.config.Config> & { moduleSystem?: 'commonjs' | 'esm' }) => void;\n    };\n    regexify: <T>(filter?: T_QueryFilter<T>, fields?: (keyof T | string)[]) => T_QueryFilter<T>;\n    isDynamicVirtual: <T, R extends string>(options?: T_VirtualOptions<T, R>) => options is I_DynamicVirtualOptions<T, R>;\n    getNewRecords: <T extends I_GenericDocument>(controller: MongoController<T>, recordsToCheck: T[], filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean) => Promise<T[]>;\n    getExistingRecords: <T extends I_GenericDocument>(controller: MongoController<T>, recordsToCheck: T[], filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean) => Promise<T_WithId<T>[]>;\n}\n\n/**\n * MongoDB utility object providing comprehensive database operations and utilities.\n * This object contains methods for creating generic fields, applying plugins and middlewares,\n * creating schemas and models, validation functions, migration utilities, and regex filtering.\n */\nexport const mongo: I_MongoUtils = {\n    /**\n     * Creates generic fields that are commonly used across MongoDB documents.\n     * This function generates standard fields including a UUID, deletion flag, and timestamps\n     * that can be applied to any document schema.\n     *\n     * @returns An object containing generic document fields (id, isDel, createdAt, updatedAt).\n     */\n    createGenericFields(): I_GenericDocument {\n        return {\n            id: randomUUID(),\n            isDel: false,\n            createdAt: new Date(),\n            updatedAt: new Date(),\n        };\n    },\n    /**\n     * Applies plugins to a Mongoose schema.\n     * This function filters out falsy plugins and applies the remaining valid plugins\n     * to the provided schema.\n     *\n     * @param schema - The Mongoose schema to apply plugins to.\n     * @param plugins - An array of plugin functions or false values to filter and apply.\n     */\n    applyPlugins<T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>) {\n        plugins\n            .filter((plugin): plugin is T_MongoosePlugin => typeof plugin === 'function')\n            .forEach(plugin => schema.plugin(plugin));\n    },\n    /**\n     * Applies middleware functions to a Mongoose schema.\n     * This function configures pre and post middleware for specified methods on the schema.\n     *\n     * @param schema - The Mongoose schema to apply middleware to.\n     * @param middlewares - An array of middleware configurations with method, pre, and post functions.\n     */\n    applyMiddlewares<T extends Partial<C_Document>>(\n        schema: T_MongooseShema<T>,\n        middlewares: I_MongooseModelMiddleware<T>[],\n    ) {\n        middlewares.forEach(({ method, pre, post }) => {\n            if (method && pre) {\n                schema.pre(method as RegExp, pre);\n            }\n\n            if (method && post) {\n                schema.post(method as RegExp, post);\n            }\n        });\n    },\n    /**\n     * Creates a generic Mongoose schema with common fields.\n     * This function creates a base schema with UUID field and deletion flag,\n     * configured with automatic timestamps.\n     *\n     * @param mongoose - The Mongoose instance to create the schema with.\n     * @returns A Mongoose schema with generic document fields.\n     */\n    createGenericSchema(mongoose: typeof mongooseRaw) {\n        return new mongoose.Schema<I_GenericDocument>(\n            {\n                id: { type: String, default: () => randomUUID(), unique: true },\n                isDel: { type: Boolean, default: false },\n            },\n            { timestamps: true },\n        );\n    },\n    /**\n     * Creates a Mongoose schema with optional virtual fields and generic fields.\n     * This function creates a new Mongoose schema from the provided schema definition,\n     * optionally adds virtual fields, and includes generic fields (unless standalone is true).\n     *\n     * @param options - Configuration options including mongoose instance, schema definition, virtuals, and standalone flag.\n     * @param options.mongoose - The Mongoose instance to use for schema creation.\n     * @param options.schema - The schema definition object.\n     * @param options.virtuals - Optional array of virtual field configurations.\n     * @param options.standalone - Whether to exclude generic fields (default: false).\n     * @returns A configured Mongoose schema.\n     */\n    createSchema<T, R extends string = string>({\n        mongoose,\n        schema,\n        virtuals = [],\n        standalone = false,\n    }: I_CreateSchemaOptions<T, R>): T_MongooseShema<T> {\n        const createdSchema = new mongoose.Schema<T>(schema, {\n            toJSON: { virtuals: true }, // So `res.json()` and other `JSON.stringify()` functions include virtuals\n            toObject: { virtuals: true }, // So `console.log()` and other functions that use `toObject()` include virtuals\n        });\n\n        virtuals.forEach(({ name, options, get }) => {\n            if (mongo.isDynamicVirtual<T, R>(options)) {\n                const schemaStatics = createdSchema.statics as Record<string, unknown>;\n\n                if (!schemaStatics['_dynamicVirtuals']) {\n                    schemaStatics['_dynamicVirtuals'] = [];\n                }\n\n                (schemaStatics['_dynamicVirtuals'] as I_DynamicVirtualConfig<T>[]).push({\n                    name: name as string,\n                    options,\n                });\n\n                const virtualInstance = createdSchema.virtual(name as string);\n\n                if (get) {\n                    virtualInstance.get(get);\n                }\n                else {\n                    virtualInstance.get(function (this: T & { _populated?: { [key: string]: unknown } }) {\n                        return this._populated?.[name as string] || (options?.count ? 0 : (options?.justOne ? null : []));\n                    });\n                }\n            }\n            else {\n                const virtualInstance = createdSchema.virtual(name as string, options);\n\n                if (get) {\n                    virtualInstance.get(get);\n                }\n            }\n        });\n\n        if (!standalone) {\n            createdSchema.add(mongo.createGenericSchema(mongoose));\n        }\n\n        return createdSchema;\n    },\n    /**\n     * Creates a Mongoose model with plugins, middleware, and pagination support.\n     * This function creates a model from a schema with optional pagination and aggregation plugins,\n     * and applies any specified middleware. If a model with the same name already exists, it returns the existing model.\n     *\n     * @param options - Configuration options including mongoose instance, model name, schema, and feature flags.\n     * @param options.mongoose - The Mongoose instance to use for model creation.\n     * @param options.name - The name of the model to create.\n     * @param options.schema - The schema definition for the model.\n     * @param options.pagination - Whether to enable pagination plugin (default: false).\n     * @param options.aggregate - Whether to enable aggregation pagination plugin (default: false).\n     * @param options.virtuals - Optional array of virtual field configurations.\n     * @param options.middlewares - Optional array of middleware configurations.\n     * @returns A configured Mongoose model with extended functionality.\n     * @throws {Error} When the model name is not provided.\n     */\n    createModel<T extends Partial<C_Document>, R extends string = string>({\n        mongoose: currentMongooseInstance,\n        name,\n        schema,\n        virtuals = [],\n        pagination = true,\n        aggregate = true,\n        middlewares = [],\n    }: I_CreateModelOptions<T, R>): I_ExtendedModel<T> {\n        if (!name) {\n            throw new Error('Model name is required.');\n        }\n\n        if (currentMongooseInstance.models[name]) {\n            return currentMongooseInstance.models[name] as I_ExtendedModel<T>;\n        }\n\n        const createdSchema = mongo.createSchema({ mongoose: currentMongooseInstance, schema, virtuals });\n\n        if (pagination || aggregate) {\n            mongo.applyPlugins<T>(createdSchema, [\n                pagination && mongoosePaginate,\n                aggregate && aggregatePaginate,\n            ]);\n        }\n\n        mongo.applyMiddlewares<T>(createdSchema, middlewares);\n\n        const model = currentMongooseInstance.model<T>(name, createdSchema) as I_ExtendedModel<T>;\n\n        if (virtuals.length > 0) {\n            (model as any)._virtualConfigs = virtuals;\n        }\n\n        return model;\n    },\n    /**\n     * Validation utilities for Mongoose schemas.\n     * This object provides common validation functions that can be used in Mongoose schema definitions.\n     */\n    validator: {\n        /**\n         * Creates a required field validator.\n         * This function returns a validator that checks if a field value is not empty\n         * using the validate.isEmpty utility.\n         *\n         * @returns A validation function that returns true if the field is not empty.\n         */\n        isRequired<T>(): (this: T, value: unknown) => Promise<boolean> {\n            return async function (this: T, value: unknown): Promise<boolean> {\n                return !validate.isEmpty(value);\n            };\n        },\n        /**\n         * Creates a unique field validator.\n         * This function returns a validator that checks if a field value is unique\n         * across the specified fields in the collection.\n         *\n         * @param fields - An array of field names to check for uniqueness.\n         * @returns A validation function that returns true if the value is unique across the specified fields.\n         * @throws {Error} When fields is not a non-empty array of strings.\n         */\n        isUnique<T extends { constructor: { exists: (query: { [key: string]: unknown }) => Promise<unknown> } }>(fields: string[]) {\n            return async function (this: T, value: unknown): Promise<boolean> {\n                if (!Array.isArray(fields) || fields.length === 0) {\n                    throw new Error('Fields must be a non-empty array of strings.');\n                }\n\n                const query = { $or: fields.map(field => ({ [field]: value })) };\n                const existingDocument = await this.constructor.exists(query);\n\n                return !existingDocument;\n            };\n        },\n        /**\n         * Creates a regex pattern validator.\n         * This function returns a validator that checks if a string value matches\n         * all provided regular expressions.\n         *\n         * @param regexArray - An array of regular expressions to test against the value.\n         * @returns A validation function that returns true if the value matches all regex patterns.\n         * @throws {Error} When regexArray is not an array of valid RegExp objects.\n         */\n        matchesRegex(regexArray: RegExp[]): (value: string) => Promise<boolean> {\n            return async (value: string): Promise<boolean> => {\n                if (!Array.isArray(regexArray) || regexArray.some(r => !(r instanceof RegExp))) {\n                    throw new Error('regexArray must be an array of valid RegExp objects.');\n                }\n\n                return regexArray.every(regex => regex.test(value));\n            };\n        },\n    },\n    /**\n     * Migration utilities for MongoDB.\n     * This object extends the migrate-mongo library with additional configuration utilities.\n     */\n    migrate: {\n        /**\n         * Lazily loads the migrate-mongo module to avoid eager import overhead.\n         * Use this to access migrate-mongo methods (up, down, status, create) programmatically.\n         *\n         * @returns A promise resolving to the migrate-mongo module.\n         */\n        async getModule(): Promise<typeof migrate> {\n            return (await import('migrate-mongo')).default;\n        },\n        /**\n         * Sets the migration configuration and updates .gitignore.\n         * This function creates a migration configuration file and ensures it's properly\n         * excluded from version control.\n         *\n         * @param options - Migration configuration options to write to the config file.\n         */\n        setConfig: (options: Partial<migrate.config.Config> & { moduleSystem?: 'commonjs' | 'esm' }) => {\n            const optionsJS = `// This file is automatically generated by the Cyberskill CLI.\\nmodule.exports = ${JSON.stringify(options, null, 4)}`;\n\n            writeFileSync(PATH.MIGRATE_MONGO_CONFIG, optionsJS);\n\n            addGitIgnoreEntry(PATH.GIT_IGNORE, MIGRATE_MONGO_CONFIG);\n        },\n    },\n    /**\n     * Converts string values in a filter to regex patterns for case-insensitive search.\n     * This function recursively processes a filter object and converts string values in specified fields\n     * to MongoDB regex patterns that support accented character matching.\n     *\n     * @param filter - The filter object to process.\n     * @param fields - An array of field names to convert to regex patterns.\n     * @returns A new filter object with string values converted to regex patterns.\n     */\n    regexify<T>(filter?: T_QueryFilter<T>, fields?: (keyof T | string)[]): T_QueryFilter<T> {\n        if (!filter) {\n            return {} as T_QueryFilter<T>;\n        }\n\n        let newFilter = deepClone(filter);\n\n        if (!fields || fields.length === 0) {\n            return newFilter;\n        }\n\n        for (const field of fields) {\n            const path = field.toString().split('.');\n            const value = getNestedValue(newFilter, path);\n\n            if (typeof value === 'string' && value.length > 0) {\n                const regexValue = {\n                    $regex: `.*${regexSearchMapper(value)}.*`,\n                    $options: 'i',\n                };\n\n                newFilter = setNestedValue(newFilter, path, regexValue);\n            }\n        }\n\n        return newFilter;\n    },\n    /**\n     * Checks if a virtual options object has a dynamic ref function.\n     *\n     * @param options - The virtual options to check.\n     * @returns True if the options contain a dynamic ref function.\n     */\n    isDynamicVirtual<T, R extends string = string>(options?: T_VirtualOptions<T, R>): options is I_DynamicVirtualOptions<T, R> {\n        return Boolean(options && typeof options.ref === 'function');\n    },\n\n    /**\n     * Generic utility function to get new records from the database\n     * @param controller - MongoController instance\n     * @param recordsToCheck - Array of records to check\n     * @param filterFn - Function to determine if a record already exists\n     * @returns Array of records that don't exist in the database\n     */\n    async getNewRecords<T extends I_GenericDocument>(\n        controller: MongoController<T>,\n        recordsToCheck: T[],\n        filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean,\n        filter: Record<string, unknown> = {},\n    ): Promise<T[]> {\n        const existingRecords = await controller.findAll(filter as any);\n\n        if (!existingRecords.success) {\n            return recordsToCheck;\n        }\n\n        const filteredRecords = recordsToCheck.filter(newRecord =>\n            !existingRecords.result.some((existingRecord: T_WithId<T>) =>\n                filterFn(existingRecord, newRecord),\n            ),\n        );\n\n        return filteredRecords;\n    },\n\n    /**\n     * Generic utility function to get existing records that match the filter criteria\n     * @param controller - MongoController instance\n     * @param recordsToCheck - Array of records to check\n     * @param filterFn - Function to determine if a record exists\n     * @returns Array of existing records that match the filter criteria\n     */\n    async getExistingRecords<T extends I_GenericDocument>(\n        controller: MongoController<T>,\n        recordsToCheck: T[],\n        filterFn: (existingRecord: T_WithId<T>, newRecord: T) => boolean,\n        filter: Record<string, unknown> = {},\n    ): Promise<T_WithId<T>[]> {\n        const existingRecords = await controller.findAll(filter as any);\n\n        if (!existingRecords.success) {\n            return [];\n        }\n\n        const foundRecords = existingRecords.result.filter((existingRecord: T_WithId<T>) =>\n            recordsToCheck.some((newRecord: T) =>\n                filterFn(existingRecord, newRecord),\n            ),\n        );\n\n        return foundRecords;\n    },\n};\n\nexport { applyNestedPopulate } from './mongo.populate.js';\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,EAAuB,GAA2B;AAK9D,QAJI,MAAc,EAAU,aAAa,GAC9B,EAAU,OAAO,EAAE,CAAC,aAAa,GAAG,EAAU,MAAM,EAAE,CAAC,aAAa,GAGxE;;AAkCX,IAAa,IAAsB;CAQ/B,sBAAyC;AACrC,SAAO;GACH,IAAI,GAAY;GAChB,OAAO;GACP,2BAAW,IAAI,MAAM;GACrB,2BAAW,IAAI,MAAM;GACxB;;CAUL,aAAgB,GAA4B,GAA0C;AAClF,IACK,QAAQ,MAAuC,OAAO,KAAW,WAAW,CAC5E,SAAQ,MAAU,EAAO,OAAO,EAAO,CAAC;;CASjD,iBACI,GACA,GACF;AACE,IAAY,SAAS,EAAE,WAAQ,QAAK,cAAW;AAK3C,GAJI,KAAU,KACV,EAAO,IAAI,GAAkB,EAAI,EAGjC,KAAU,KACV,EAAO,KAAK,GAAkB,EAAK;IAEzC;;CAUN,oBAAoB,GAA8B;AAC9C,SAAO,IAAI,EAAS,OAChB;GACI,IAAI;IAAE,MAAM;IAAQ,eAAe,GAAY;IAAE,QAAQ;IAAM;GAC/D,OAAO;IAAE,MAAM;IAAS,SAAS;IAAO;GAC3C,EACD,EAAE,YAAY,IAAM,CACvB;;CAcL,aAA2C,EACvC,aACA,WACA,cAAW,EAAE,EACb,gBAAa,MACmC;EAChD,IAAM,IAAgB,IAAI,EAAS,OAAU,GAAQ;GACjD,QAAQ,EAAE,UAAU,IAAM;GAC1B,UAAU,EAAE,UAAU,IAAM;GAC/B,CAAC;AAuCF,SArCA,EAAS,SAAS,EAAE,SAAM,YAAS,aAAU;AACzC,OAAI,EAAM,iBAAuB,EAAQ,EAAE;IACvC,IAAM,IAAgB,EAAc;AAapC,IAXA,AACI,EAAc,qBAAsB,EAAE,EAGzC,EAAc,iBAAoD,KAAK;KAC9D;KACN;KACH,CAAC,EAEsB,EAAc,QAAQ,EAAe,CAGzC,IADhB,KAIoB,WAAiE;AACjF,YAAO,KAAK,aAAa,OAAoB,GAAS,QAAQ,IAAK,GAAS,UAAU,OAAO,EAAE;MACjG;UAGL;IACD,IAAM,IAAkB,EAAc,QAAQ,GAAgB,EAAQ;AAEtE,IAAI,KACA,EAAgB,IAAI,EAAI;;IAGlC,EAEG,KACD,EAAc,IAAI,EAAM,oBAAoB,EAAS,CAAC,EAGnD;;CAkBX,YAAsE,EAClE,UAAU,GACV,SACA,WACA,cAAW,EAAE,EACb,gBAAa,IACb,eAAY,IACZ,iBAAc,EAAE,IAC+B;AAC/C,MAAI,CAAC,EACD,OAAU,MAAM,0BAA0B;AAG9C,MAAI,EAAwB,OAAO,GAC/B,QAAO,EAAwB,OAAO;EAG1C,IAAM,IAAgB,EAAM,aAAa;GAAE,UAAU;GAAyB;GAAQ;GAAU,CAAC;AASjG,GAPI,KAAc,MACd,EAAM,aAAgB,GAAe,CACjC,KAAc,GACd,KAAa,EAChB,CAAC,EAGN,EAAM,iBAAoB,GAAe,EAAY;EAErD,IAAM,IAAQ,EAAwB,MAAS,GAAM,EAAc;AAMnE,SAJI,EAAS,SAAS,MACjB,EAAc,kBAAkB,IAG9B;;CAMX,WAAW;EAQP,aAA+D;AAC3D,UAAO,eAAyB,GAAkC;AAC9D,WAAO,CAAC,EAAS,QAAQ,EAAM;;;EAYvC,SAAyG,GAAkB;AACvH,UAAO,eAAyB,GAAkC;AAC9D,QAAI,CAAC,MAAM,QAAQ,EAAO,IAAI,EAAO,WAAW,EAC5C,OAAU,MAAM,+CAA+C;IAGnE,IAAM,IAAQ,EAAE,KAAK,EAAO,KAAI,OAAU,GAAG,IAAQ,GAAO,EAAE,EAAE;AAGhE,WAAO,CAFkB,MAAM,KAAK,YAAY,OAAO,EAAM;;;EAcrE,aAAa,GAA2D;AACpE,UAAO,OAAO,MAAoC;AAC9C,QAAI,CAAC,MAAM,QAAQ,EAAW,IAAI,EAAW,MAAK,MAAK,EAAE,aAAa,QAAQ,CAC1E,OAAU,MAAM,uDAAuD;AAG3E,WAAO,EAAW,OAAM,MAAS,EAAM,KAAK,EAAM,CAAC;;;EAG9D;CAKD,SAAS;EAOL,MAAM,YAAqC;AACvC,WAAQ,MAAM,OAAO,kBAAkB;;EAS3C,YAAY,MAAoF;GAC5F,IAAM,IAAY,oFAAoF,KAAK,UAAU,GAAS,MAAM,EAAE;AAItI,GAFA,EAAc,EAAK,sBAAsB,EAAU,EAEnD,EAAkB,EAAK,YAAY,EAAqB;;EAE/D;CAUD,SAAY,GAA2B,GAAiD;AACpF,MAAI,CAAC,EACD,QAAO,EAAE;EAGb,IAAI,IAAY,EAAU,EAAO;AAEjC,MAAI,CAAC,KAAU,EAAO,WAAW,EAC7B,QAAO;AAGX,OAAK,IAAM,KAAS,GAAQ;GACxB,IAAM,IAAO,EAAM,UAAU,CAAC,MAAM,IAAI,EAClC,IAAQ,EAAe,GAAW,EAAK;AAE7C,OAAI,OAAO,KAAU,YAAY,EAAM,SAAS,GAAG;IAC/C,IAAM,IAAa;KACf,QAAQ,KAAK,EAAkB,EAAM,CAAC;KACtC,UAAU;KACb;AAED,QAAY,EAAe,GAAW,GAAM,EAAW;;;AAI/D,SAAO;;CAQX,iBAA+C,GAA4E;AACvH,SAAO,GAAQ,KAAW,OAAO,EAAQ,OAAQ;;CAUrD,MAAM,cACF,GACA,GACA,GACA,IAAkC,EAAE,EACxB;EACZ,IAAM,IAAkB,MAAM,EAAW,QAAQ,EAAc;AAY/D,SAVK,EAAgB,UAIG,EAAe,QAAO,MAC1C,CAAC,EAAgB,OAAO,MAAM,MAC1B,EAAS,GAAgB,EAAU,CACtC,CACJ,GAPU;;CAmBf,MAAM,mBACF,GACA,GACA,GACA,IAAkC,EAAE,EACd;EACtB,IAAM,IAAkB,MAAM,EAAW,QAAQ,EAAc;AAY/D,SAVK,EAAgB,UAIA,EAAgB,OAAO,QAAQ,MAChD,EAAe,MAAM,MACjB,EAAS,GAAgB,EAAU,CACtC,CACJ,GAPU,EAAE;;CAWpB"}

package/dist/node/package/index.js

@@ -1,11 +1,3 @@
-import { E_PackageType as t } from "./package.type.js";
-import { getLatestPackageVersion as c, getPackage as p, installDependencies as s, setupPackages as k, updatePackage as o } from "./package.util.js";
-export {
-  t as E_PackageType,
-  c as getLatestPackageVersion,
-  p as getPackage,
-  s as installDependencies,
-  k as setupPackages,
-  o as updatePackage
-};
-//# sourceMappingURL=index.js.map
+import { E_PackageType as e } from "./package.type.js";
+import { getLatestPackageVersion as t, getPackage as n, installDependencies as r, setupPackages as i, updatePackage as a } from "./package.util.js";
+export { e as E_PackageType, t as getLatestPackageVersion, n as getPackage, r as installDependencies, i as setupPackages, a as updatePackage };

package/dist/node/package/package.type.js

@@ -1,5 +1,8 @@
-var D = /* @__PURE__ */ ((e) => (e.DEPENDENCY = "dependencies", e.DEV_DEPENDENCY = "devDependencies", e.PEER_DEPENDENCY = "peerDependencies", e.BUNDLE_DEPENDENCY = "bundleDependencies", e.OPTIONAL_DEPENDENCY = "optionalDependencies", e))(D || {});
-export {
-  D as E_PackageType
-};
-//# sourceMappingURL=package.type.js.map
+//#region src/node/package/package.type.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.DEPENDENCY = "dependencies", e.DEV_DEPENDENCY = "devDependencies", e.PEER_DEPENDENCY = "peerDependencies", e.BUNDLE_DEPENDENCY = "bundleDependencies", e.OPTIONAL_DEPENDENCY = "optionalDependencies", e;
+}({});
+//#endregion
+export { e as E_PackageType };
+
+//# sourceMappingURL=package.type.js.map

package/dist/node/package/package.type.js.map

@@ -1 +1 @@
-{"version":3,"file":"package.type.js","sources":["../../../src/node/package/package.type.ts"],"sourcesContent":["export interface I_PackageJson {\n    name?: string;\n    version?: string;\n    dependencies?: Record<string, string>;\n    devDependencies?: Record<string, string>;\n    [key: string]: unknown;\n}\n\nexport interface I_PackageInfo {\n    name: string;\n    currentVersion: string;\n    latestVersion: string;\n    isCurrentProject: boolean;\n    isInstalled: boolean;\n    isUpToDate: boolean;\n    isDependency: boolean;\n    isDevDependency: boolean;\n    installedPath: string;\n    file: I_PackageJson;\n}\n\nexport enum E_PackageType {\n    DEPENDENCY = 'dependencies',\n    DEV_DEPENDENCY = 'devDependencies',\n    PEER_DEPENDENCY = 'peerDependencies',\n    BUNDLE_DEPENDENCY = 'bundleDependencies',\n    OPTIONAL_DEPENDENCY = 'optionalDependencies',\n}\n\nexport interface I_PackageInput {\n    name: string;\n    type?: E_PackageType;\n}\n"],"names":["E_PackageType"],"mappings":"AAqBO,IAAKA,sBAAAA,OACRA,EAAA,aAAa,gBACbA,EAAA,iBAAiB,mBACjBA,EAAA,kBAAkB,oBAClBA,EAAA,oBAAoB,sBACpBA,EAAA,sBAAsB,wBALdA,IAAAA,KAAA,CAAA,CAAA;"}
+{"version":3,"file":"package.type.js","names":[],"sources":["../../../src/node/package/package.type.ts"],"sourcesContent":["export interface I_PackageJson {\n    name?: string;\n    version?: string;\n    dependencies?: Record<string, string>;\n    devDependencies?: Record<string, string>;\n    [key: string]: unknown;\n}\n\nexport interface I_PackageInfo {\n    name: string;\n    currentVersion: string;\n    latestVersion: string;\n    isCurrentProject: boolean;\n    isInstalled: boolean;\n    isUpToDate: boolean;\n    isDependency: boolean;\n    isDevDependency: boolean;\n    installedPath: string;\n    file: I_PackageJson;\n}\n\nexport enum E_PackageType {\n    DEPENDENCY = 'dependencies',\n    DEV_DEPENDENCY = 'devDependencies',\n    PEER_DEPENDENCY = 'peerDependencies',\n    BUNDLE_DEPENDENCY = 'bundleDependencies',\n    OPTIONAL_DEPENDENCY = 'optionalDependencies',\n}\n\nexport interface I_PackageInput {\n    name: string;\n    type?: E_PackageType;\n}\n"],"mappings":";AAqBA,IAAY,IAAL,yBAAA,GAAA;QACH,EAAA,aAAA,gBACA,EAAA,iBAAA,mBACA,EAAA,kBAAA,oBACA,EAAA,oBAAA,sBACA,EAAA,sBAAA;KACH"}