@cyberskill/shared 1.199.0 → 1.201.0

package/dist/src/node/fs/index.js

@@ -0,0 +1,17 @@
+import { appendFileSync as c, copySync as y, createWriteStream as S, fs as r, lstatSync as t, mkdirSync as a, pathExistsSync as i, readFileSync as d, readJsonSync as s, readdirSync as l, removeSync as o, statSync as p, unlinkSync as m, writeFileSync as F } from "./fs.util.js";
+export {
+  c as appendFileSync,
+  y as copySync,
+  S as createWriteStream,
+  r as fs,
+  t as lstatSync,
+  a as mkdirSync,
+  i as pathExistsSync,
+  d as readFileSync,
+  s as readJsonSync,
+  l as readdirSync,
+  o as removeSync,
+  p as statSync,
+  m as unlinkSync,
+  F as writeFileSync
+};

package/dist/src/node/log/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./log.type.cjs"),r=require("./log.util.cjs");exports.E_IssueType=o.E_IssueType;exports.catchError=r.catchError;exports.log=r.log;exports.throwError=r.throwError;

package/dist/src/node/log/index.d.ts

@@ -0,0 +1,2 @@
+export * from './log.type.js';
+export * from './log.util.js';

package/dist/src/node/log/index.js

@@ -0,0 +1,8 @@
+import { E_IssueType as e } from "./log.type.js";
+import { catchError as p, log as E, throwError as c } from "./log.util.js";
+export {
+  e as E_IssueType,
+  p as catchError,
+  E as log,
+  c as throwError
+};

package/dist/src/node/log/log.type.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var e=(r=>(r.Error="error",r.Warning="warning",r))(e||{});exports.E_IssueType=e;

package/dist/src/node/log/log.type.d.ts

@@ -0,0 +1,28 @@
+import { I_Log as I_LogCommon } from '../../typescript/index.js';
+export declare enum E_IssueType {
+    Error = "error",
+    Warning = "warning"
+}
+export interface I_IssueEntry {
+    type: E_IssueType;
+    file: string;
+    message: string;
+    position?: string;
+    rule?: string;
+}
+export interface T_ThrowError {
+    message?: string;
+    status?: {
+        CODE: string | number;
+        MESSAGE: string;
+    };
+    type?: 'graphql' | 'rest';
+}
+export interface I_Log extends I_LogCommon {
+    printBoxedLog: (title: string, issues: I_IssueEntry[], color?: string) => void;
+}
+export interface I_CatchErrorOptions {
+    shouldLog?: boolean;
+    returnValue?: unknown;
+    callback?: (error: Error) => void;
+}

package/dist/src/node/log/log.type.js

@@ -0,0 +1,4 @@
+var n = /* @__PURE__ */ ((r) => (r.Error = "error", r.Warning = "warning", r))(n || {});
+export {
+  n as E_IssueType
+};

package/dist/src/node/log/log.util.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("chalk"),r=require("consola"),u=require("graphql"),i=require("../../config/env/env.util.cjs"),E=require("../../constant/response-status.cjs"),h=i.getEnv();function R({message:o,status:e=E.RESPONSE_STATUS.INTERNAL_SERVER_ERROR,type:t="graphql"}){var n;const c=(n=o!=null?o:e.MESSAGE)!=null?n:"Internal server error";throw t==="graphql"?new u.GraphQLError(c,{extensions:{code:e.CODE}}):new Error(c)}h.DEBUG||(r.level=4);function g(o){const e=a[o];return typeof e=="function"?e:a.green}const f={silent:r.silent,level:r.level,fatal:r.fatal,error:r.error,warn:r.warn,log:r.log,info:r.info,success:r.success,ready:r.ready,start:r.start,box:r.box,debug:r.debug,trace:r.trace,verbose:r.verbose,printBoxedLog(o,e,t="red"){if(!(e!=null&&e.length)){r.box(a.green(o));return}e.forEach(({file:c,position:n,rule:l,message:s})=>{r.log(`${a.gray("File:")} ${a.blue(`${c}${n?`:${n}`:""}`)}`),l&&r.log(`   ${g(t)("Rule:")} ${l}`),r.log(`   ${g(t)("Message:")} ${s}`)}),r.box(g(t)(`${o} : ${e.length}`)),r.log(a.gray("─".repeat(40)))}};function S(o,e){const{shouldLog:t=!0,returnValue:c,callback:n}=e!=null?e:{},l=o instanceof Error?o:new Error(typeof o=="string"?o:"Unknown error");return t&&f.error(l.message),n&&typeof n=="function"&&n(l),c||{success:!1,message:l.message,code:E.RESPONSE_STATUS.INTERNAL_SERVER_ERROR.CODE}}exports.catchError=S;exports.log=f;exports.throwError=R;

package/dist/src/node/log/log.util.d.ts

@@ -0,0 +1,8 @@
+import { I_Return } from '../../typescript/index.js';
+import { I_CatchErrorOptions, I_Log, T_ThrowError } from './log.type.js';
+export declare function throwError({ message, status, type, }: T_ThrowError): never;
+export declare const log: I_Log;
+export declare function catchError<T = unknown>(errorInput: unknown, options: I_CatchErrorOptions & {
+    returnValue: T;
+}): T;
+export declare function catchError<T = unknown>(errorInput: unknown, options?: I_CatchErrorOptions): I_Return<T>;

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

@@ -0,0 +1,60 @@
+import c from "chalk";
+import r from "consola";
+import { GraphQLError as h } from "graphql";
+import { getEnv as R } from "../../config/env/env.util.js";
+import { RESPONSE_STATUS as E } from "../../constant/response-status.js";
+const i = R();
+function u({
+  message: o,
+  status: e = E.INTERNAL_SERVER_ERROR,
+  type: t = "graphql"
+}) {
+  var n;
+  const l = (n = o != null ? o : e.MESSAGE) != null ? n : "Internal server error";
+  throw t === "graphql" ? new h(l, {
+    extensions: { code: e.CODE }
+  }) : new Error(l);
+}
+i.DEBUG || (r.level = 4);
+function f(o) {
+  const e = c[o];
+  return typeof e == "function" ? e : c.green;
+}
+const $ = {
+  silent: r.silent,
+  level: r.level,
+  fatal: r.fatal,
+  error: r.error,
+  warn: r.warn,
+  log: r.log,
+  info: r.info,
+  success: r.success,
+  ready: r.ready,
+  start: r.start,
+  box: r.box,
+  debug: r.debug,
+  trace: r.trace,
+  verbose: r.verbose,
+  printBoxedLog(o, e, t = "red") {
+    if (!(e != null && e.length)) {
+      r.box(c.green(o));
+      return;
+    }
+    e.forEach(({ file: l, position: n, rule: a, message: g }) => {
+      r.log(`${c.gray("File:")} ${c.blue(`${l}${n ? `:${n}` : ""}`)}`), a && r.log(`   ${f(t)("Rule:")} ${a}`), r.log(`   ${f(t)("Message:")} ${g}`);
+    }), r.box(f(t)(`${o} : ${e.length}`)), r.log(c.gray("─".repeat(40)));
+  }
+};
+function v(o, e) {
+  const { shouldLog: t = !0, returnValue: l, callback: n } = e != null ? e : {}, a = o instanceof Error ? o : new Error(typeof o == "string" ? o : "Unknown error");
+  return t && $.error(a.message), n && typeof n == "function" && n(a), l || {
+    success: !1,
+    message: a.message,
+    code: E.INTERNAL_SERVER_ERROR.CODE
+  };
+}
+export {
+  v as catchError,
+  $ as log,
+  u as throwError
+};

package/dist/src/node/mongo/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./mongo.constant.cjs"),o=require("./mongo.type.cjs"),e=require("./mongo.util.cjs"),t=require("mongoose-aggregate-paginate-v2"),r=require("mongoose-paginate-v2");exports.MONGO_MIGRATE_OPTIONS=n.MONGO_MIGRATE_OPTIONS;exports.C_Collection=o.C_Collection;exports.C_Db=o.C_Db;exports.C_Document=o.C_Document;exports.C_Model=o.C_Model;exports.MongoController=e.MongoController;exports.MongooseController=e.MongooseController;exports.mongo=e.mongo;exports.aggregatePaginate=t;exports.mongoosePaginate=r;

package/dist/src/node/mongo/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mongo.constant.js';
+export * from './mongo.type.js';
+export * from './mongo.util.js';

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

@@ -0,0 +1,17 @@
+import { MONGO_MIGRATE_OPTIONS as r } from "./mongo.constant.js";
+import { C_Collection as a, C_Db as n, C_Document as g, C_Model as l } from "./mongo.type.js";
+import { MongoController as f, MongooseController as C, mongo as _ } from "./mongo.util.js";
+import { default as x } from "mongoose-aggregate-paginate-v2";
+import { default as s } from "mongoose-paginate-v2";
+export {
+  a as C_Collection,
+  n as C_Db,
+  g as C_Document,
+  l as C_Model,
+  r as MONGO_MIGRATE_OPTIONS,
+  f as MongoController,
+  C as MongooseController,
+  x as aggregatePaginate,
+  _ as mongo,
+  s as mongoosePaginate
+};

package/dist/src/node/mongo/mongo.constant.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const O="MONGO_MIGRATE_OPTIONS";exports.MONGO_MIGRATE_OPTIONS=O;

package/dist/src/node/mongo/mongo.constant.d.ts

@@ -0,0 +1 @@
+export declare const MONGO_MIGRATE_OPTIONS = "MONGO_MIGRATE_OPTIONS";

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

@@ -0,0 +1,4 @@
+const O = "MONGO_MIGRATE_OPTIONS";
+export {
+  O as MONGO_MIGRATE_OPTIONS
+};

package/dist/src/node/mongo/mongo.type.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("mongodb"),t=require("mongoose");class s extends o.Db{}class l extends t.Document{}class n extends t.Model{}class c extends o.Collection{}exports.C_Collection=c;exports.C_Db=s;exports.C_Document=l;exports.C_Model=n;

package/dist/src/node/mongo/mongo.type.d.ts

@@ -0,0 +1,156 @@
+import { DeleteResult, Filter, InsertManyResult, InsertOneResult, OptionalUnlessRequiredId, UpdateResult, WithId, Collection, Db } from 'mongodb';
+import { AggregatePaginateModel, AggregatePaginateResult, ClientSession, ErrorHandlingMiddlewareFunction, ErrorHandlingMiddlewareWithOption, FilterQuery, InsertManyOptions, PaginateModel, PaginateOptions, PaginateResult, PipelineStage, PopulateOption, PopulateOptions, PostMiddlewareFunction, PreMiddlewareFunction, PreSaveMiddlewareFunction, ProjectionType, QueryOptions, QueryWithHelpers, Schema, SchemaDefinition, UpdateQuery, default as mongoose, Document, Model } from 'mongoose';
+export declare class C_Db extends Db {
+}
+export type T_Filter<T> = Filter<T>;
+export type T_InsertOneResult<T> = InsertOneResult<T>;
+export type T_InsertManyResult<T> = InsertManyResult<T>;
+export type T_UpdateResult = UpdateResult;
+export type T_DeleteResult = DeleteResult;
+export type T_WithId<T> = WithId<T>;
+export type T_OptionalUnlessRequiredId<T> = OptionalUnlessRequiredId<T>;
+export declare class C_Document extends Document {
+}
+export declare class C_Model extends Model {
+}
+export declare class C_Collection<T extends Partial<C_Document>> extends Collection<T> {
+}
+export interface I_ExtendedModel<T extends Partial<C_Document>> extends Model<T>, PaginateModel<T>, AggregatePaginateModel<T> {
+}
+export type T_FilterQuery<T> = FilterQuery<T>;
+export type T_ProjectionType<T> = ProjectionType<T>;
+export type T_QueryOptions<T> = QueryOptions<T>;
+export type T_PaginateOptions = PaginateOptions;
+export type T_PopulateOption = PopulateOption;
+export type T_PopulateOptions = PopulateOptions;
+export type T_PipelineStage = PipelineStage;
+export type T_PaginateResult<T> = PaginateResult<T>;
+export type T_AggregatePaginateResult<T> = AggregatePaginateResult<T>;
+export type T_InsertManyOptions = InsertManyOptions;
+export type T_UpdateQuery<T> = UpdateQuery<T>;
+export type T_QueryWithHelpers<T> = QueryWithHelpers<T, T>;
+export type T_PreMiddlewareFunction<T> = PreMiddlewareFunction<T>;
+export type T_PreSaveMiddlewareFunction<T> = PreSaveMiddlewareFunction<T>;
+export type T_PostMiddlewareFunction<T> = PostMiddlewareFunction<T>;
+export type T_ErrorHandlingMiddlewareFunction<T> = ErrorHandlingMiddlewareFunction<T>;
+export type T_ErrorHandlingMiddlewareWithOption<T> = ErrorHandlingMiddlewareWithOption<T>;
+export type T_MongooseShema<T> = mongoose.Schema<T>;
+export type T_Input_MongooseSchema<T> = SchemaDefinition<T>;
+export type T_MongoosePlugin = (schema: Schema, options?: Record<string, unknown>) => void;
+export interface I_GenericDocument extends Partial<C_Document> {
+    id: string;
+    isDel: boolean;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export type T_Omit_Create = 'id' | 'isDel' | 'createdAt' | 'updatedAt';
+export type T_Omit_Update = 'id' | 'createdAt' | 'updatedAt';
+interface I_VirtualNestedOptions {
+    [key: string]: I_VirtualNestedOptions | number | string | boolean;
+}
+interface I_VirtualOptions {
+    ref: string;
+    localField: string;
+    foreignField: string;
+    count?: boolean;
+    justOne?: boolean;
+    options?: I_VirtualNestedOptions;
+}
+interface I_MongooseOptions<T> {
+    mongoose: typeof mongoose;
+    virtuals?: {
+        name: keyof T | string;
+        options?: I_VirtualOptions;
+        get?: (this: T) => void;
+    }[];
+}
+export interface I_CreateSchemaOptions<T> extends I_MongooseOptions<T> {
+    schema: T_Input_MongooseSchema<T>;
+    standalone?: boolean;
+}
+export type T_MongooseMiddlewareMethod = string | RegExp;
+export type T_MongooseMiddlewarePreFunction<T> = T_PreMiddlewareFunction<T> & T_PreSaveMiddlewareFunction<T>;
+export type T_MongooseMiddlewarePostFunction<T> = T_PostMiddlewareFunction<T> & T_ErrorHandlingMiddlewareFunction<T> & T_ErrorHandlingMiddlewareWithOption<T>;
+export type T_MongooseHookNextFunction = (error?: Error) => void;
+export interface I_MongooseModelMiddleware<T extends Partial<C_Document>> {
+    method: T_MongooseMiddlewareMethod;
+    pre?: T_MongooseMiddlewarePreFunction<T & T_QueryWithHelpers<T>>;
+    post?: T_MongooseMiddlewarePostFunction<T>;
+}
+export interface I_CreateModelOptions<T extends Partial<C_Document>> extends I_MongooseOptions<T> {
+    schema: T_Input_MongooseSchema<T>;
+    name: string;
+    aggregate?: boolean;
+    middlewares?: I_MongooseModelMiddleware<T>[];
+    pagination?: boolean;
+}
+export type T_Input_Populate = string | string[] | T_PopulateOptions | T_PopulateOptions[];
+export interface T_PaginateOptionsWithPopulate extends T_PaginateOptions, Omit<T_PopulateOption, 'populate'> {
+    populate?: T_Input_Populate;
+}
+export interface I_Input_FindOne<T> extends T_PopulateOption {
+    filter: T_FilterQuery<T>;
+    projection?: T_ProjectionType<T>;
+    options?: T_QueryOptions<T>;
+}
+export interface I_Input_FindAll<T> extends T_PopulateOption {
+    filter: T_FilterQuery<T>;
+    projection?: T_ProjectionType<T>;
+    options?: T_QueryOptions<T>;
+}
+export type I_Input_FindPaging<T = undefined> = T extends undefined ? {
+    options?: T_PaginateOptionsWithPopulate;
+} : {
+    filter?: T_FilterQuery<T>;
+    options?: T_PaginateOptionsWithPopulate;
+};
+export interface I_Input_FindPagingAggregate {
+    pipeline: T_PipelineStage[];
+    options?: T_PaginateOptionsWithPopulate;
+}
+export interface I_Input_CreateOne<T> {
+    doc: T;
+}
+export interface I_Input_CreateMany<T> {
+    docs: T[];
+}
+export interface I_UpdateOptionsExtended extends Omit<QueryOptions, 'session'> {
+    session?: ClientSession;
+}
+export interface I_Input_UpdateOne<T> extends T_PopulateOption {
+    filter: T_FilterQuery<T>;
+    update: T_UpdateQuery<T>;
+    options?: I_UpdateOptionsExtended;
+}
+export interface I_Input_UpdateMany<T> extends T_PopulateOption {
+    filter: T_FilterQuery<T>;
+    update: T_UpdateQuery<T>;
+    options?: I_UpdateOptionsExtended;
+}
+export interface I_DeleteOptionsExtended extends Omit<QueryOptions, 'session'> {
+    session?: ClientSession;
+}
+export interface I_Input_DeleteOne<T> {
+    filter: T_FilterQuery<T>;
+    options?: I_DeleteOptionsExtended;
+}
+export interface I_Input_DeleteMany<T> {
+    filter: T_FilterQuery<T>;
+    options?: I_DeleteOptionsExtended;
+}
+export interface I_InputSlug<T> {
+    field: string;
+    filter?: T_FilterQuery<T>;
+}
+export interface I_Input_CreateSlug<T> extends I_InputSlug<T> {
+    from: T;
+}
+export interface I_Input_CheckSlug<T> extends I_InputSlug<T> {
+    slug: string;
+    from: T;
+}
+export interface I_Input_GenerateSlug<T> extends I_InputSlug<T> {
+    slug: string;
+    isObject: boolean;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { Db as o, Collection as s } from "mongodb";
+import { Document as t, Model as l } from "mongoose";
+class d extends o {
+}
+class m extends t {
+}
+class C extends l {
+}
+class r extends s {
+}
+export {
+  r as C_Collection,
+  d as C_Db,
+  m as C_Document,
+  C as C_Model
+};

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

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

package/dist/src/node/mongo/mongo.util.d.ts

@@ -0,0 +1,236 @@
+import { default as mongooseRaw } from 'mongoose';
+import { default as migrate } from 'migrate-mongo';
+import { default as aggregatePaginate } from 'mongoose-aggregate-paginate-v2';
+import { default as mongoosePaginate } from 'mongoose-paginate-v2';
+import { I_Return } from '../../typescript/index.js';
+import { C_Db, C_Document, I_CreateModelOptions, I_CreateSchemaOptions, I_DeleteOptionsExtended, I_ExtendedModel, I_GenericDocument, I_Input_CheckSlug, I_Input_CreateSlug, I_Input_GenerateSlug, I_MongooseModelMiddleware, I_UpdateOptionsExtended, T_AggregatePaginateResult, T_DeleteResult, T_Filter, T_FilterQuery, T_Input_Populate, T_InsertManyOptions, T_MongoosePlugin, T_MongooseShema, T_PaginateOptionsWithPopulate, T_PaginateResult, T_PipelineStage, T_ProjectionType, T_QueryOptions, T_UpdateQuery, T_UpdateResult, T_WithId } from './mongo.type.js';
+export { aggregatePaginate, mongoosePaginate };
+export declare const mongo: {
+    getDateTime(now?: Date): string;
+    createGenericFields({ returnDateAs, }?: {
+        returnDateAs?: "string" | "date";
+    }): I_GenericDocument;
+    applyPlugins<T>(schema: T_MongooseShema<T>, plugins: Array<T_MongoosePlugin | false>): void;
+    applyMiddlewares<T extends Partial<C_Document>>(schema: T_MongooseShema<T>, middlewares: I_MongooseModelMiddleware<T>[]): void;
+    createGenericSchema(mongoose: typeof mongooseRaw): mongooseRaw.Schema<I_GenericDocument, mongooseRaw.Model<I_GenericDocument, any, any, any, mongooseRaw.Document<unknown, any, I_GenericDocument, any> & I_GenericDocument & Required<{
+        _id: unknown;
+    }> & {
+        __v: number;
+    }, any>, {}, {}, {}, {}, mongooseRaw.DefaultSchemaOptions, I_GenericDocument, mongooseRaw.Document<unknown, {}, mongooseRaw.FlatRecord<I_GenericDocument>, {}> & mongooseRaw.FlatRecord<I_GenericDocument> & Required<{
+        _id: unknown;
+    }> & {
+        __v: number;
+    }>;
+    createSchema<T>({ mongoose, schema, virtuals, standalone, }: I_CreateSchemaOptions<T>): T_MongooseShema<T>;
+    createModel<T extends Partial<C_Document>>({ mongoose: currentMongooseInstance, name, schema, pagination, aggregate, virtuals, middlewares, }: I_CreateModelOptions<T>): I_ExtendedModel<T>;
+    validator: {
+        isRequired<T>(): (this: T, value: unknown) => Promise<boolean>;
+        isUnique<T extends {
+            constructor: {
+                exists: (query: Record<string, unknown>) => Promise<unknown>;
+            };
+        }>(fields: string[]): (this: T, value: unknown) => Promise<boolean>;
+        matchesRegex(regexArray: RegExp[]): (value: string) => Promise<boolean>;
+    };
+    migrate: {
+        setConfig: (options: Partial<migrate.config.Config>) => void;
+        init(): Promise<void>;
+        create(description: string): Promise<string>;
+        up(db: mongooseRaw.mongo.Db, client: mongooseRaw.mongo.MongoClient): Promise<string[]>;
+        down(db: mongooseRaw.mongo.Db, client: mongooseRaw.mongo.MongoClient): Promise<string[]>;
+        status(db: mongooseRaw.mongo.Db): Promise<migrate.MigrationStatus[]>;
+        database: typeof migrate.database;
+        config: typeof migrate.config;
+    };
+    regexify<T>(filter?: T_FilterQuery<T>, fields?: (keyof T | string)[]): T_FilterQuery<T>;
+};
+export declare class MongoController<D extends Partial<C_Document>> {
+    private collection;
+    constructor(db: C_Db, collectionName: string);
+    createOne(document: D | Partial<D>): Promise<I_Return<D | Partial<D>>>;
+    createMany(documents: (D | Partial<D>)[]): Promise<I_Return<(D | Partial<D>)[]>>;
+    findOne(filter: T_Filter<D>): Promise<I_Return<T_WithId<D>>>;
+    findAll(filter?: T_Filter<D>): Promise<I_Return<T_WithId<D>[]>>;
+    count(filter?: T_Filter<D>): Promise<I_Return<number>>;
+    updateOne(filter: T_Filter<D>, update: Partial<D>): Promise<I_Return<T_UpdateResult>>;
+    updateMany(filter: T_Filter<D>, update: Partial<D>): Promise<I_Return<T_UpdateResult>>;
+    deleteOne(filter: T_Filter<D>): Promise<I_Return<T_DeleteResult>>;
+    deleteMany(filter: T_Filter<D>): Promise<I_Return<T_DeleteResult>>;
+}
+export declare class MongooseController<T extends Partial<C_Document>> {
+    private model;
+    constructor(model: I_ExtendedModel<T>);
+    private getModelName;
+    findOne(filter?: T_FilterQuery<T>, projection?: T_ProjectionType<T>, options?: T_QueryOptions<T>, populate?: T_Input_Populate): Promise<I_Return<T>>;
+    findAll(filter?: T_FilterQuery<T>, projection?: T_ProjectionType<T>, options?: T_QueryOptions<T>, populate?: T_Input_Populate): Promise<I_Return<T[]>>;
+    findPaging(filter?: T_FilterQuery<T>, options?: T_PaginateOptionsWithPopulate): Promise<I_Return<T_PaginateResult<T>>>;
+    findPagingAggregate(pipeline: T_PipelineStage[], options?: T_PaginateOptionsWithPopulate): Promise<I_Return<T_AggregatePaginateResult<T>>>;
+    count(filter?: T_FilterQuery<T>): Promise<I_Return<number>>;
+    createOne(doc: T | Partial<T>): Promise<I_Return<T>>;
+    createMany(docs: (T | Partial<T>)[], options?: T_InsertManyOptions): Promise<I_Return<T[]>>;
+    updateOne(filter?: T_FilterQuery<T>, update?: T_UpdateQuery<T>, options?: I_UpdateOptionsExtended): Promise<I_Return<T>>;
+    updateMany(filter?: T_FilterQuery<T>, update?: T_UpdateQuery<T>, options?: I_UpdateOptionsExtended): Promise<I_Return<T_UpdateResult>>;
+    deleteOne(filter?: T_FilterQuery<T>, options?: I_DeleteOptionsExtended): Promise<I_Return<T>>;
+    deleteMany(filter?: T_FilterQuery<T>, options?: I_DeleteOptionsExtended): Promise<I_Return<T_DeleteResult>>;
+    createShortId(id: string, length?: number): Promise<I_Return<string>>;
+    createSlugQuery({ slug, field, isObject, filter }: I_Input_GenerateSlug<T>): {
+        $or: ({
+            [x: string]: string;
+            slugHistory?: undefined;
+        } | {
+            slugHistory: {
+                $elemMatch: {
+                    [x: string]: string;
+                };
+            };
+        })[];
+        _id?: any;
+        $assertPopulated?: any;
+        $clearModifiedPaths?: any;
+        $clone?: any;
+        $createModifiedPathsSnapshot?: any;
+        $getAllSubdocs?: any;
+        $ignore?: any;
+        $isDefault?: any;
+        $isDeleted?: any;
+        $getPopulatedDocs?: any;
+        $inc?: any;
+        $isEmpty?: any;
+        $isValid?: any;
+        $locals?: any;
+        $markValid?: any;
+        $model?: any;
+        $op?: any;
+        $restoreModifiedPathsSnapshot?: any;
+        $session?: any;
+        $set?: any;
+        $where?: any;
+        baseModelName?: any;
+        collection?: any;
+        db?: any;
+        deleteOne?: any;
+        depopulate?: any;
+        directModifiedPaths?: any;
+        equals?: any;
+        errors?: any;
+        get?: any;
+        getChanges?: any;
+        id?: any;
+        increment?: any;
+        init?: any;
+        invalidate?: any;
+        isDirectModified?: any;
+        isDirectSelected?: any;
+        isInit?: any;
+        isModified?: any;
+        isNew?: any;
+        isSelected?: any;
+        markModified?: any;
+        model?: any;
+        modifiedPaths?: any;
+        overwrite?: any;
+        $parent?: any;
+        populate?: any;
+        populated?: any;
+        replaceOne?: any;
+        save?: any;
+        schema?: any;
+        set?: any;
+        toJSON?: any;
+        toObject?: any;
+        unmarkModified?: any;
+        updateOne?: any;
+        validate?: any;
+        validateSync?: any;
+        $and?: mongooseRaw.FilterQuery<T>[] | undefined;
+        $nor?: mongooseRaw.FilterQuery<T>[] | undefined;
+        $text?: {
+            $search: string;
+            $language?: string;
+            $caseSensitive?: boolean;
+            $diacriticSensitive?: boolean;
+        };
+        $comment?: string;
+        $expr?: Record<string, any>;
+    } | {
+        $or: ({
+            slug: string;
+            slugHistory?: undefined;
+        } | {
+            slugHistory: string;
+            slug?: undefined;
+        })[];
+        _id?: any;
+        $assertPopulated?: any;
+        $clearModifiedPaths?: any;
+        $clone?: any;
+        $createModifiedPathsSnapshot?: any;
+        $getAllSubdocs?: any;
+        $ignore?: any;
+        $isDefault?: any;
+        $isDeleted?: any;
+        $getPopulatedDocs?: any;
+        $inc?: any;
+        $isEmpty?: any;
+        $isValid?: any;
+        $locals?: any;
+        $markValid?: any;
+        $model?: any;
+        $op?: any;
+        $restoreModifiedPathsSnapshot?: any;
+        $session?: any;
+        $set?: any;
+        $where?: any;
+        baseModelName?: any;
+        collection?: any;
+        db?: any;
+        deleteOne?: any;
+        depopulate?: any;
+        directModifiedPaths?: any;
+        equals?: any;
+        errors?: any;
+        get?: any;
+        getChanges?: any;
+        id?: any;
+        increment?: any;
+        init?: any;
+        invalidate?: any;
+        isDirectModified?: any;
+        isDirectSelected?: any;
+        isInit?: any;
+        isModified?: any;
+        isNew?: any;
+        isSelected?: any;
+        markModified?: any;
+        model?: any;
+        modifiedPaths?: any;
+        overwrite?: any;
+        $parent?: any;
+        populate?: any;
+        populated?: any;
+        replaceOne?: any;
+        save?: any;
+        schema?: any;
+        set?: any;
+        toJSON?: any;
+        toObject?: any;
+        unmarkModified?: any;
+        updateOne?: any;
+        validate?: any;
+        validateSync?: any;
+        $and?: mongooseRaw.FilterQuery<T>[] | undefined;
+        $nor?: mongooseRaw.FilterQuery<T>[] | undefined;
+        $text?: {
+            $search: string;
+            $language?: string;
+            $caseSensitive?: boolean;
+            $diacriticSensitive?: boolean;
+        };
+        $comment?: string;
+        $expr?: Record<string, any>;
+    };
+    createUniqueSlug({ slug, field, isObject, filter }: I_Input_GenerateSlug<T>): Promise<string>;
+    createSlug<R = string>({ field, from, filter }: I_Input_CreateSlug<T>): Promise<I_Return<R>>;
+    checkSlug({ slug, field, from, filter }: I_Input_CheckSlug<T>): Promise<I_Return<boolean>>;
+    aggregate(pipeline: T_PipelineStage[]): Promise<I_Return<T[]>>;
+}