@cyberskill/shared 1.208.0 → 1.210.0

package/dist/{src/config → config}/config.type.d.ts

@@ -1,4 +1,4 @@
-import { T_Object } from '../typescript/common.js';
+import { T_Object } from '../typescript/index.js';
 export declare enum E_ConfigType {
     ESLINT = "eslint",
     COMMITLINT = "commitlint",

package/dist/config/config.type.js

@@ -0,0 +1,4 @@
+var T = /* @__PURE__ */ ((t) => (t.ESLINT = "eslint", t.COMMITLINT = "commitlint", t.LINT_STAGED = "lint-staged", t.VITEST_REACT_E2E = "vitest-react-e2e", t.VITEST_REACT_UNIT = "vitest-react-unit", t))(T || {});
+export {
+  T as E_ConfigType
+};

package/dist/{src/config → config}/config.util.d.ts

@@ -1,3 +1,3 @@
-import { T_Object } from '../typescript/common.js';
+import { T_Object } from '../typescript/index.js';
 import { T_ConfigType } from './config.type.js';
 export declare function mergeConfigs(type: T_ConfigType, ...config: T_Object[]): T_Object;

package/dist/config/config.util.js

@@ -0,0 +1,49 @@
+import a from "@antfu/eslint-config";
+import { E_ConfigType as n } from "./config.type.js";
+import g from "./eslint/index.js";
+import { vitestE2E as E } from "./vitest/vitest.e2e.js";
+import { vitestUnit as T } from "./vitest/vitest.unit.js";
+import { deepMerge as i } from "../util/object/object.util.js";
+const c = (...r) => {
+  const e = i(
+    g,
+    ...r.map((o) => o)
+  ), { ignores: t, ...m } = e, s = Array.isArray(t) && t.every((o) => typeof o == "string") ? { ignores: t } : void 0, f = [
+    m,
+    ...s ? [s] : []
+  ];
+  return a(
+    {
+      stylistic: {
+        semi: !0,
+        indent: 4,
+        quotes: "single"
+      },
+      formatters: {
+        css: !0,
+        html: !0,
+        markdown: "prettier"
+      },
+      yaml: !1,
+      react: !0
+    },
+    ...f
+  );
+}, p = {
+  [n.ESLINT]: (r) => c(r),
+  [n.COMMITLINT]: (r) => i(r),
+  [n.LINT_STAGED]: (r) => i(r),
+  [n.VITEST_REACT_UNIT]: (r) => T(r),
+  [n.VITEST_REACT_E2E]: (r) => E(r)
+};
+function A(r, ...e) {
+  const t = p[r];
+  if (!e || e.length === 0)
+    return t({});
+  if (!t)
+    throw new Error(`Unknown config type: ${r}`);
+  return t(...e);
+}
+export {
+  A as mergeConfigs
+};

package/dist/{src/config → config}/env/env.util.js

@@ -1,21 +1,21 @@
 import n from "@dotenvx/dotenvx";
-import { makeValidator as E, cleanEnv as f, str as r } from "envalid";
+import { cleanEnv as E, str as r, makeValidator as f } from "envalid";
 import i from "node:os";
 import a from "node:path";
 import o from "node:process";
-import { E_Environment as m } from "../../typescript/common.js";
-import { CYBERSKILL_STORAGE_DIRECTORY as R } from "./env.constant.js";
+import { CYBERSKILL_STORAGE_DIRECTORY as m } from "./env.constant.js";
+import { E_Environment as R } from "../../typescript/common.type.js";
 let t = !1;
-const l = E((e) => typeof e == "boolean" ? e : typeof e == "string");
+const l = f((e) => typeof e == "boolean" ? e : typeof e == "string");
 function d() {
-  o.env.NODE_ENV !== m.PRODUCTION && !t && (n.config(), t = !0);
+  o.env.NODE_ENV !== R.PRODUCTION && !t && (n.config(), t = !0);
 }
 function p() {
   d();
-  const e = f(o.env, {
+  const e = E(o.env, {
     CWD: r({ default: o.cwd() }),
     DEBUG: l({ default: !1 }),
-    CYBERSKILL_STORAGE_DIRECTORY: r({ default: a.join(i.homedir(), R) })
+    CYBERSKILL_STORAGE_DIRECTORY: r({ default: a.join(i.homedir(), m) })
   });
   return {
     CWD: e.CWD,

package/dist/config/eslint/index.js

@@ -0,0 +1,18 @@
+import * as o from "globals";
+const t = [
+  {
+    languageOptions: {
+      globals: { ...o.node, ...o.browser }
+    },
+    rules: {
+      "perfectionist/sort-imports": ["error", {
+        internalPattern: ["^#.*", "^@/.*"]
+      }],
+      "dot-notation": "off"
+    },
+    ignores: ["build", "dist"]
+  }
+];
+export {
+  t as default
+};

package/dist/config/graphql-codegen/graphql-codegen.util.js

@@ -0,0 +1,37 @@
+import { defineConfig as s } from "@eddeee888/gcg-typescript-resolver-files";
+import { loadEnvFile as c } from "../env/env.util.js";
+c();
+function u({
+  uri: t,
+  from: o,
+  to: e,
+  target: r = "client"
+}) {
+  const n = r === "client", i = r === "server";
+  return {
+    schema: t,
+    ignoreNoDocuments: !0,
+    overwrite: !0,
+    ...n && { documents: [o] },
+    generates: {
+      ...n && {
+        [e]: {
+          preset: "client",
+          presetConfig: {
+            fragmentMasking: !1,
+            persistedDocuments: !0
+          },
+          config: {
+            useTypeImports: !0
+          }
+        }
+      },
+      ...i && {
+        [e]: s()
+      }
+    }
+  };
+}
+export {
+  u as createGraphqlCodegenConfig
+};

package/dist/config/index.js

@@ -0,0 +1,6 @@
+import { E_ConfigType as r } from "./config.type.js";
+import { mergeConfigs as g } from "./config.util.js";
+export {
+  r as E_ConfigType,
+  g as mergeConfigs
+};

package/dist/config/vitest/vitest.e2e.js

@@ -0,0 +1,23 @@
+import r from "@vitejs/plugin-react-swc";
+import { defineConfig as t } from "../../node_modules/.pnpm/vitest@3.2.4_@types_debug@4.1.12_@types_node@24.0.13_@vitest_browser@3.2.4_jiti@2.4.2_j_cac3da623d5688a51c0b1a2270e144db/node_modules/vitest/dist/config.js";
+function s(e) {
+  return t({
+    plugins: [r()],
+    test: {
+      include: ["**/*.test.e2e.?(c|m)[jt]s?(x)"],
+      browser: {
+        enabled: !0,
+        provider: "playwright",
+        instances: [
+          { browser: "chromium" },
+          { browser: "firefox" },
+          { browser: "webkit" }
+        ]
+      }
+    },
+    ...e
+  });
+}
+export {
+  s as vitestE2E
+};

package/dist/config/vitest/vitest.unit.js

@@ -0,0 +1,19 @@
+import e from "@vitejs/plugin-react-swc";
+import { defineConfig as o } from "../../node_modules/.pnpm/vitest@3.2.4_@types_debug@4.1.12_@types_node@24.0.13_@vitest_browser@3.2.4_jiti@2.4.2_j_cac3da623d5688a51c0b1a2270e144db/node_modules/vitest/dist/config.js";
+import { PATH as i } from "../../node/path/path.constant.js";
+function s(t) {
+  return o({
+    plugins: [e()],
+    test: {
+      globals: !0,
+      environment: "jsdom",
+      pool: "vmThreads",
+      include: ["**/*.test.unit.?(c|m)[jt]s?(x)"],
+      setupFiles: [i.VITEST_UNIT_SETUP_CONFIG]
+    },
+    ...t
+  });
+}
+export {
+  s as vitestUnit
+};

package/dist/constant/common.js

@@ -0,0 +1,4 @@
+const e = typeof window < "u";
+export {
+  e as IS_BROWSER
+};

package/dist/node/apollo-server/apollo-server.util.js

@@ -0,0 +1,29 @@
+import { ApolloServer as e } from "@apollo/server";
+import { ApolloServerPluginDrainHttpServer as l } from "@apollo/server/plugin/drainHttpServer";
+import { ApolloServerPluginLandingPageLocalDefault as o, ApolloServerPluginLandingPageProductionDefault as n } from "@apollo/server/plugin/landingPage/default";
+import { log as a } from "../log/log.util.js";
+function c(r) {
+  return new e({
+    schema: r.schema,
+    plugins: [
+      r.isDev ? o() : n(),
+      l({ httpServer: r.server }),
+      ...r.drainServer ? [{
+        async serverWillStart() {
+          return {
+            async drainServer() {
+              r.drainServer?.(), a.info("Apollo Server drainServer hook called");
+            }
+          };
+        }
+      }] : []
+    ],
+    ...r.isDev && {
+      introspection: !0,
+      includeStacktraceInErrorResponses: !0
+    }
+  });
+}
+export {
+  c as createApolloServer
+};

package/dist/node/cli/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import g from "node:process";
+import { hideBin as C } from "yargs/helpers";
+import L from "yargs/yargs";
+import { clearAllErrorLists as s, runCommand as t, getStoredErrorLists as M, resolveCommands as _ } from "../command/command.util.js";
+import { getPackage as O, installDependencies as w } from "../package/package.util.js";
+import { removeSync as y, readFileSync as E, pathExistsSync as h, writeFileSync as l, appendFileSync as R } from "../fs/fs.util.js";
+import { resolve as G } from "../path/path.util.js";
+import { CYBERSKILL_CLI as N, command as i, CYBERSKILL_PACKAGE_NAME as p, PATH as e, SIMPLE_GIT_HOOK_JSON as u, createGitHooksConfig as T } from "../path/path.constant.js";
+import { log as r, catchError as P } from "../log/log.util.js";
+import { E_IssueType as d } from "../log/log.type.js";
+function D() {
+  try {
+    return JSON.parse(
+      E(G(__dirname, "../../../package.json"), "utf-8")
+    ).version;
+  } catch {
+    return "1.0.0";
+  }
+}
+async function S() {
+  h(e.TS_CONFIG) ? await t("Performing TypeScript validation", await i.typescriptCheck()) : r.warn("No TypeScript configuration found. Skipping type check.");
+}
+async function k(n = !1) {
+  n ? await t("Running ESLint with auto-fix", await i.eslintFix()) : await t("Running ESLint check", await i.eslintCheck());
+}
+function f(n, a) {
+  if (!a.length)
+    return;
+  const o = n === "Errors" ? "red" : "yellow";
+  r.printBoxedLog(n === "Errors" ? "✖ Errors" : "⚠ Warnings", a, o);
+}
+async function c() {
+  setTimeout(async () => {
+    const n = await M(), a = n.filter((m) => m.type === d.Error), o = n.filter((m) => m.type === d.Warning);
+    !a.length && !o.length ? r.printBoxedLog("✔ NO ISSUES FOUND", [], "green") : (f("Warnings", o), f("Errors", a), a.length > 0 && g.exit(1));
+  }, 0);
+}
+async function v() {
+  await s();
+  const n = await O({ name: p });
+  if (!n.success) {
+    r.error("Failed to retrieve package information. Aborting lint-staged.");
+    return;
+  }
+  n.result.isCurrentProject && await t(`Building package: ${p}`, await i.build()), await t("Executing lint-staged", await i.lintStaged()), c();
+}
+async function B() {
+  await t("Inspecting ESLint configuration", await i.eslintInspect());
+}
+async function x() {
+  await s(), await Promise.all([S(), k()]), c();
+}
+async function A() {
+  await s(), await Promise.all([S(), k(!0)]), c();
+}
+async function F() {
+  await s(), await t("Validating commit message", await i.commitLint()), c();
+}
+async function I() {
+  await t("Configuring Git hooks", await i.configureGitHook()), y(e.GIT_HOOK);
+  const n = await _(T);
+  l(e.SIMPLE_GIT_HOOKS_JSON, JSON.stringify(n, null, 4));
+  const a = `
+${u}
+`;
+  h(e.GIT_IGNORE) ? E(e.GIT_IGNORE, "utf-8").split(`
+`).includes(u) || R(e.GIT_IGNORE, a) : l(e.GIT_IGNORE, a), await t("Setting up simple-git-hooks", await i.simpleGitHooks());
+}
+async function H() {
+  await w(), await I();
+}
+async function U() {
+  y(e.NODE_MODULES, e.PNPM_LOCK_YAML), await t("Pruning pnpm store", await i.pnpmPruneStore()), await t("Clearing pnpm cache", await i.pnpmCleanCache()), await w(), await I();
+}
+async function K() {
+  await t("Inspecting project dependencies", await i.nodeModulesInspect());
+}
+async function b() {
+  await t("Running unit tests", await i.testUnit());
+}
+async function j() {
+  await t("Running end-to-end tests", await i.testE2e());
+}
+async function J(n) {
+  await t("Creating MongoDB migration", await i.mongoMigrateCreate(n));
+}
+async function V() {
+  await t("Running MongoDB migrations", await i.mongoMigrateUp());
+}
+async function W() {
+  await t("Rolling back MongoDB migration", await i.mongoMigrateDown());
+}
+(async () => {
+  try {
+    await L(C(g.argv)).scriptName(N).usage("$0 <command> [options]").command("lint", "Check code for linting issues", x).command("lint:fix", "Fix linting issues automatically", A).command("lint:inspect", "View active ESLint configuration", B).command("lint-staged", "Run lint checks on staged files", v).command("commitlint", "Validate commit message format", F).command("ready", "Initialize project and dependencies", H).command("reset", "Reset the project and reinstall dependencies", U).command("inspect", "Analyze installed project dependencies", K).command("test:unit", "Run unit test suite", b).command("test:e2e", "Run end-to-end test suite", j).command("mongo:migrate:create <name>", "Create a MongoDB migration", (n) => n.positional("name", {
+      describe: "Migration name",
+      type: "string"
+    }), async (n) => {
+      if (!n.name) {
+        r.error("Migration name is required.");
+        return;
+      }
+      await J(n.name);
+    }).command("mongo:migrate:up", "Apply all MongoDB migrations", V).command("mongo:migrate:down", "Rollback last MongoDB migration", W).demandCommand(1, "Please specify a valid command.").strict().help().alias("h", "help").alias("v", "version").version(D()).epilog(`💡 Tip: Use "--help" with any command to see options
+`).parse();
+  } catch (n) {
+    P(n), g.exit(1);
+  }
+})();

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

@@ -0,0 +1,4 @@
+var N = /* @__PURE__ */ ((I) => (I.CLI = "CLI", I.STRING = "STRING", I.FUNCTION = "FUNCTION", I))(N || {});
+export {
+  N as E_CommandType
+};

package/dist/node/command/command.util.js

@@ -0,0 +1,144 @@
+import { exec as d } from "node:child_process";
+import E from "node:process";
+import * as P from "node:util";
+import { storage as l } from "../storage/storage.util.js";
+import { getPackage as C } from "../package/package.util.js";
+import { E_IssueType as a } from "../log/log.type.js";
+import { CYBERSKILL_PACKAGE_NAME as x, PNPM_EXEC_CLI as y, TSX_CLI as S, CYBERSKILL_CLI_PATH as I, CYBERSKILL_CLI as T } from "../path/path.constant.js";
+import { catchError as g, log as u } from "../log/log.util.js";
+import { getEnv as _ } from "../../config/env/env.util.js";
+const w = _(), k = P.promisify(d);
+async function h() {
+  const r = await C();
+  return r.success ? r.result.name : Date.now().toString();
+}
+async function L(r) {
+  if (r.length === 0)
+    return;
+  const t = await h();
+  try {
+    await l.set(t, r), setTimeout(async () => {
+      const e = await l.getLogLink(t);
+      e && u.info(`📂 Open the error list manually: ${e}`);
+    }, 0);
+  } catch (e) {
+    g(e);
+  }
+}
+async function W() {
+  try {
+    const r = await h();
+    return await l.get(r) ?? [];
+  } catch (r) {
+    return g(r, {
+      returnValue: []
+    });
+  }
+}
+async function U() {
+  try {
+    const r = await h();
+    await l.remove(r);
+  } catch (r) {
+    g(r);
+  }
+}
+function N(r) {
+  const t = [], e = [];
+  let s = "";
+  const i = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s+(\S+)$/, n = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:\s+(\S.+)$/, m = /^✖\s+(.*?)\s+\[(.*?)\]$/;
+  r.split(`
+`).forEach((o) => {
+    if (o.startsWith("/"))
+      s = o.trim();
+    else {
+      const c = i.exec(o) || [], f = n.exec(o) || [], p = m.exec(o) || [];
+      c.length && s ? t.push({
+        file: s,
+        position: `${c[1]}:${c[2]}`,
+        type: c[3] === a.Error ? a.Error : a.Warning,
+        message: c?.[4]?.trim() ?? "",
+        rule: c?.[5]?.trim() ?? ""
+      }) : f.length ? t.push({
+        file: f?.[1] ?? "",
+        position: `${f[2]}:${f[3]}`,
+        type: f[4] === a.Error ? a.Error : a.Warning,
+        message: f?.[5]?.trim() ?? ""
+      }) : p.length ? t.push({
+        file: "commitlint",
+        type: a.Error,
+        message: p?.[1]?.trim() ?? "",
+        rule: p?.[2]?.trim() ?? ""
+      }) : e.push(o.trim());
+    }
+  }), t.length && L(t), w.DEBUG && e.length && (u.warn("Unmatched lines:"), e.forEach((o) => u.info(`  ${o}`)));
+}
+function j(r) {
+  try {
+    const t = JSON.parse(r), e = [];
+    t.forEach(({ filePath: s, messages: i }) => {
+      i.forEach(({ severity: n, line: m, column: o, ruleId: c, message: f }) => {
+        e.push({
+          type: n === 2 ? a.Error : a.Warning,
+          file: s,
+          position: `${m}:${o}`,
+          rule: c,
+          message: f
+        });
+      });
+    }), e.length && L(e);
+  } catch {
+    N(r);
+  }
+}
+async function A(r, t = j) {
+  const e = new AbortController();
+  E.on("SIGINT", () => {
+    u.warn("Process interrupted. Terminating..."), e.abort(), E.exit();
+  });
+  try {
+    if (typeof r == "string") {
+      const { stdout: s, stderr: i } = await k(r, {
+        maxBuffer: 104857600,
+        signal: e.signal
+      });
+      [s, i].forEach((n) => n && t(n));
+    }
+  } catch (s) {
+    const { stdout: i, stderr: n, message: m } = s;
+    [i, n].forEach((o) => o && t(o)), !n && !i && u.error(`Command failed: ${m}`);
+  }
+}
+function Y(r) {
+  return { raw: !0, cmd: r };
+}
+function $(r, t) {
+  return t?.isCurrentProject ? `${y} ${S} ${I} ${r}` : `${y} ${T} ${r}`;
+}
+function B(r, t) {
+  return typeof r == "function" ? $(r(t), t) : typeof r == "object" && r?.raw === !0 ? r.cmd : typeof r == "string" ? $(r, t) : r;
+}
+async function X(r) {
+  const t = await C({ name: x });
+  if (t.success) {
+    const e = { isCurrentProject: t.result.isCurrentProject }, s = typeof r == "function" ? r(e) : r;
+    return Object.fromEntries(
+      Object.entries(s).map(([i, n]) => [i, B(n, e)])
+    );
+  }
+}
+async function F(r, t) {
+  try {
+    u.start(`${r}`), w.DEBUG && u.info(`→ ${t}`), await A(t), u.success(`${r} done.`);
+  } catch (e) {
+    g(e);
+  }
+}
+export {
+  U as clearAllErrorLists,
+  B as formatCommand,
+  W as getStoredErrorLists,
+  Y as rawCommand,
+  X as resolveCommands,
+  F as runCommand
+};

package/dist/node/command/index.js

@@ -0,0 +1,11 @@
+import { E_CommandType as m } from "./command.type.js";
+import { clearAllErrorLists as e, formatCommand as t, getStoredErrorLists as d, rawCommand as n, resolveCommands as s, runCommand as C } from "./command.util.js";
+export {
+  m as E_CommandType,
+  e as clearAllErrorLists,
+  t as formatCommand,
+  d as getStoredErrorLists,
+  n as rawCommand,
+  s as resolveCommands,
+  C as runCommand
+};

package/dist/node/express/express.util.js

@@ -0,0 +1,48 @@
+import { NestFactory as a } from "@nestjs/core";
+import c from "compression";
+import f from "cookie-parser";
+import p from "cors";
+import s from "express";
+import { default as P } from "express";
+import m from "express-session";
+import l from "express-useragent";
+import d from "graphql-upload/graphqlUploadExpress.mjs";
+function x({ isDev: e, whiteList: r, ...o }) {
+  return {
+    origin: (t, i) => {
+      e || !t || r?.includes(t ?? "") ? i(null, !0) : i(new Error("Not allowed by CORS"), !1);
+    },
+    credentials: !0,
+    ...o
+  };
+}
+function b(e) {
+  return p(x(e));
+}
+function h(e) {
+  return m(e);
+}
+function n(e) {
+  e.set("trust proxy", 1), e.use(f()), e.use(s.urlencoded({ extended: !0 })), e.use(c()), e.use(l.express());
+}
+function u(e, r) {
+  r && (Array.isArray(r) ? r : [r]).forEach((t) => {
+    e.use(s.static(t));
+  });
+}
+function G(e) {
+  const r = s();
+  return n(r), u(r, e?.static), r.use(d()), r;
+}
+async function H(e) {
+  const r = await a.create(e.module);
+  return n(r.getHttpAdapter().getInstance()), u(r.getHttpAdapter().getInstance(), e.static), e.filters && r.useGlobalFilters(...e.filters), e.pipes && r.useGlobalPipes(...e.pipes), r;
+}
+export {
+  b as createCors,
+  x as createCorsOptions,
+  G as createExpress,
+  H as createNest,
+  h as createSession,
+  P as express
+};

package/dist/node/express/index.js

@@ -0,0 +1,13 @@
+import { createCors as s, createCorsOptions as t, createExpress as o, createNest as a, createSession as p } from "./express.util.js";
+import { Router as f, default as x } from "express";
+import { default as m } from "body-parser";
+export {
+  f as Router,
+  m as bodyParser,
+  s as createCors,
+  t as createCorsOptions,
+  o as createExpress,
+  a as createNest,
+  p as createSession,
+  x as express
+};

package/dist/node/fs/fs.util.js

@@ -0,0 +1,48 @@
+import e from "fs-extra";
+import y from "node:path";
+const a = e, {
+  lstatSync: p,
+  readdirSync: d,
+  mkdirSync: l,
+  readFileSync: m,
+  unlinkSync: x,
+  statSync: S,
+  createWriteStream: F
+} = e, E = e.readJsonSync;
+function h(t, n, r) {
+  e.writeFileSync(t, n, r ?? "utf-8");
+}
+function v(t, n, r) {
+  e.appendFileSync(t, n, r ?? "utf-8");
+}
+function s(...t) {
+  return t.every((n) => e.pathExistsSync(n));
+}
+function k(...t) {
+  t.forEach((n) => {
+    s(n) && e.removeSync(n);
+  });
+}
+function w(t, n, r = {}) {
+  const { extensions: c, ...o } = r;
+  e.copySync(t, n, {
+    filter: (i) => S(i).isDirectory() || !c || c.length === 0 ? !0 : c.includes(y.extname(i)),
+    ...o
+  });
+}
+export {
+  v as appendFileSync,
+  w as copySync,
+  F as createWriteStream,
+  a as fs,
+  p as lstatSync,
+  l as mkdirSync,
+  s as pathExistsSync,
+  m as readFileSync,
+  E as readJsonSync,
+  d as readdirSync,
+  k as removeSync,
+  S as statSync,
+  x as unlinkSync,
+  h as writeFileSync
+};

package/dist/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/{log.type-DTOvZHyz.js → node/log/log.type.js}

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