@cyberskill/shared 1.208.0 → 1.210.0

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

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

package/dist/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/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/node/mongo/mongo.util.js

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

package/dist/node/package/index.js

@@ -0,0 +1,10 @@
+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
+};

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

@@ -0,0 +1,4 @@
+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
+};