@cyberskill/shared 3.0.0 → 3.1.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"command.util.js","sources":["../../../src/node/command/command.util.ts"],"sourcesContent":["import { exec, execFile } from 'node:child_process';\nimport process from 'node:process';\nimport * as util from 'node:util';\n\nimport { getEnv } from '#config/env/index.js';\n\nimport type { I_IssueEntry } from '../log/index.js';\nimport type { I_CommandContext, I_EslintError, T_Command, T_CommandMapInput } from './command.type.js';\n\nimport { catchError, E_IssueType, log } from '../log/index.js';\nimport { getPackage } from '../package/index.js';\nimport { CYBERSKILL_CLI, CYBERSKILL_CLI_PATH, CYBERSKILL_PACKAGE_NAME, PNPM_EXEC_CLI, TSX_CLI } from '../path/index.js';\nimport { storage } from '../storage/index.js';\n\nconst execPromise = util.promisify(exec);\nconst execFilePromise = util.promisify(execFile);\nconst SHELL_METACHARACTERS = /[|&;<>`$(){}\\[\\]!#~*?]/;\n\n/**\n * Retrieves the package name for the current project.\n * This function attempts to get the package name from the current project's package.json.\n * If the package information cannot be retrieved, it returns a timestamp as a fallback.\n *\n * @returns A promise that resolves to the package name or a timestamp string.\n */\nasync function getPackageName() {\n    const pkg = await getPackage();\n\n    if (!pkg.success) {\n        return Date.now().toString();\n    }\n\n    return pkg.result.name;\n}\n\n/**\n * Saves a list of error entries to persistent storage.\n * This function stores error information with the package name as the key,\n * and provides a log link for manual inspection of the stored errors.\n *\n * @param errorList - An array of error entries to be stored.\n * @returns A promise that resolves when the storage operation is complete.\n */\nasync function saveErrorListToStorage(errorList: I_IssueEntry[]): Promise<void> {\n    if (errorList.length === 0) {\n        return;\n    }\n\n    const packageName = await getPackageName();\n\n    try {\n        const existingErrors = await getStoredErrorLists();\n        const mergedErrors = [...existingErrors, ...errorList];\n\n        await storage.set(packageName, mergedErrors);\n\n        setTimeout(async () => {\n            const logPath = await storage.getLogLink(packageName);\n\n            if (logPath) {\n                log.info(`📂 Open the error list manually: ${logPath}`);\n            }\n        }, 0);\n    }\n    catch (error) {\n        catchError(error);\n    }\n}\n\n/**\n * Retrieves all stored error lists from persistent storage.\n * This function fetches error entries that were previously saved using the package name as the key.\n *\n * @returns A promise that resolves to an array of error entries, or an empty array if none are found.\n */\nexport async function getStoredErrorLists(): Promise<I_IssueEntry[]> {\n    try {\n        const packageName = await getPackageName();\n        const allErrors = await storage.get<I_IssueEntry[]>(packageName);\n\n        return allErrors ?? [];\n    }\n    catch (error) {\n        return catchError<I_IssueEntry[]>(error, {\n            returnValue: [],\n        });\n    }\n}\n\n/**\n * Clears all stored error lists from persistent storage.\n * This function removes all error entries associated with the current package name.\n *\n * @returns A promise that resolves when the clearing operation is complete.\n */\nexport async function clearAllErrorLists(): Promise<void> {\n    try {\n        const packageName = await getPackageName();\n        await storage.remove(packageName);\n    }\n    catch (error) {\n        catchError(error);\n    }\n}\n\n/**\n * Parses text-based error output and converts it to structured error entries.\n * This function processes command output that contains error information in text format,\n * extracting file paths, line numbers, error types, messages, and rule violations.\n * It handles multiple error formats including ESLint, TypeScript, and commitlint errors.\n *\n * @param output - The raw text output from a command execution containing error information.\n */\nasync function parseTextErrors(output: string): Promise<void> {\n    const errorList: I_IssueEntry[] = [];\n    const unmatchedLines: string[] = [];\n    let lastFilePath = '';\n    const eslintErrorDetailsRegex = /^\\s*(\\d+):(\\d+)\\s+(error|warning)\\s+(.+)\\s+(\\S+)$/;\n    const tsRegex = /^(.+?)\\((\\d+),(\\d+)\\):\\s+(error|warning)\\s+TS\\d+:\\s+(\\S.+)$/;\n    const commitlintRegex = /^✖\\s+(.+)\\s+\\[([^\\]]*)\\]$/;\n\n    output.split('\\n').forEach((line) => {\n        if (line.startsWith('/')) {\n            lastFilePath = line.trim();\n        }\n        else {\n            const eslintMatch = eslintErrorDetailsRegex.exec(line) || [];\n            const tsMatch = tsRegex.exec(line) || [];\n            const commitlintMatch = commitlintRegex.exec(line) || [];\n\n            if (eslintMatch.length && lastFilePath) {\n                errorList.push({\n                    file: lastFilePath,\n                    position: `${eslintMatch[1]}:${eslintMatch[2]}`,\n                    type: eslintMatch[3] === E_IssueType.Error ? E_IssueType.Error : E_IssueType.Warning,\n                    message: eslintMatch?.[4]?.trim() ?? '',\n                    rule: eslintMatch?.[5]?.trim() ?? '',\n                });\n            }\n            else if (tsMatch.length) {\n                errorList.push({\n                    file: tsMatch?.[1] ?? '',\n                    position: `${tsMatch[2]}:${tsMatch[3]}`,\n                    type: tsMatch[4] === E_IssueType.Error ? E_IssueType.Error : E_IssueType.Warning,\n                    message: tsMatch?.[5]?.trim() ?? '',\n                });\n            }\n            else if (commitlintMatch.length) {\n                errorList.push({\n                    file: 'commitlint',\n                    type: E_IssueType.Error,\n                    message: commitlintMatch?.[1]?.trim() ?? '',\n                    rule: commitlintMatch?.[2]?.trim() ?? '',\n                });\n            }\n            else {\n                unmatchedLines.push(line.trim());\n            }\n        }\n    });\n\n    if (errorList.length) {\n        await saveErrorListToStorage(errorList);\n    }\n\n    if (getEnv().DEBUG && unmatchedLines.length) {\n        log.warn(`Unmatched lines:`);\n        unmatchedLines.forEach(line => log.info(`  ${line}`));\n    }\n}\n\n/**\n * Parses command output that contains structured error information.\n * This function attempts to parse JSON-formatted error output (typically from ESLint)\n * and converts it to structured error entries. If JSON parsing fails, it falls back\n * to text-based parsing.\n *\n * @param output - The command output to parse, expected to be JSON-formatted error data.\n */\nasync function parseCommandOutput(output: string): Promise<void> {\n    try {\n        const results: I_EslintError[] = JSON.parse(output);\n        const errorList: I_IssueEntry[] = [];\n\n        results.forEach(({ filePath, messages }) => {\n            messages.forEach(({ severity, line, column, ruleId, message }) => {\n                errorList.push({\n                    type: severity === 2 ? E_IssueType.Error : E_IssueType.Warning,\n                    file: filePath,\n                    position: `${line}:${column}`,\n                    rule: ruleId,\n                    message,\n                });\n            });\n        });\n\n        if (errorList.length) {\n            await saveErrorListToStorage(errorList);\n        }\n    }\n    catch {\n        await parseTextErrors(output);\n    }\n}\n\n/**\n * Executes a command and processes its output for errors.\n * This function runs a command with proper signal handling for graceful termination,\n * processes both stdout and stderr for error information, and handles command failures.\n *\n * @param command - The command string to execute, or undefined if no command should be run.\n * @param parser - The function to use for parsing command output (defaults to parseCommandOutput).\n * @returns A promise that resolves when the command execution is complete.\n */\nasync function executeCommand(command: string | void, parser = parseCommandOutput, options: { timeout?: number } = {}): Promise<void> {\n    const controller = new AbortController();\n\n    process.on('SIGINT', () => {\n        log.warn('Process interrupted. Terminating...');\n        controller.abort();\n        process.exit();\n    });\n\n    try {\n        if (typeof command === 'string') {\n            const execOptions = {\n                maxBuffer: 10 * 1024 * 1024,\n                signal: controller.signal,\n                timeout: options.timeout,\n            };\n\n            let result: { stdout: string; stderr: string };\n\n            if (SHELL_METACHARACTERS.test(command)) {\n                result = await execPromise(command, execOptions);\n            }\n            else {\n                const parts = command.split(/\\s+/).filter(Boolean);\n                result = await execFilePromise(parts[0]!, parts.slice(1), execOptions);\n            }\n\n            await Promise.all([result.stdout, result.stderr].map(output => output && parser(output)));\n        }\n    }\n    catch (error) {\n        const { stdout, stderr, message } = error as {\n            stdout?: string;\n            stderr?: string;\n            message: string;\n        };\n\n        await Promise.all([stdout, stderr].map(output => output && parser(output)));\n\n        if (!stderr && !stdout) {\n            log.error(`Command failed: ${message}`);\n        }\n    }\n}\n\n/**\n * Creates a raw command object that bypasses CLI formatting.\n * This function wraps a command string in an object that indicates it should be executed\n * as-is without any additional CLI formatting or path resolution.\n *\n * @param cmd - The raw command string to be executed directly.\n * @returns An object containing the raw command with a flag indicating it should not be formatted.\n */\nexport function rawCommand(cmd: string) {\n    return { raw: true, cmd };\n}\n\n/**\n * Formats a command for CLI execution based on the current project context.\n * This function determines whether to use the current project's CLI path or the global CLI,\n * and formats the command accordingly with the appropriate executable paths.\n *\n * @param command - The command string to format.\n * @param context - Optional context information about the current project.\n * @returns The formatted command string ready for execution.\n */\nfunction formatCLI(command: string, context?: I_CommandContext) {\n    if (context?.isCurrentProject) {\n        return `${PNPM_EXEC_CLI} ${TSX_CLI} ${CYBERSKILL_CLI_PATH} ${command}`;\n    }\n\n    return `${PNPM_EXEC_CLI} ${CYBERSKILL_CLI} ${command}`;\n}\n\n/**\n * Formats a command based on its type and context.\n * This function handles different command types:\n * - Function commands: Executes the function with context and formats the result\n * - Raw commands: Returns the command as-is without formatting\n * - String commands: Formats them as CLI commands\n *\n * @param command - The command to format, which can be a string, function, or raw command object.\n * @param context - Optional context information for command execution.\n * @returns The formatted command string ready for execution.\n */\nexport function formatCommand(command: T_Command, context?: I_CommandContext) {\n    if (typeof command === 'function') {\n        return formatCLI(command(context), context);\n    }\n\n    if (typeof command === 'object' && command?.raw === true) {\n        return command.cmd;\n    }\n\n    if (typeof command === 'string') {\n        return formatCLI(command, context);\n    }\n\n    return command;\n}\n\n/**\n * Resolves a map of commands by formatting them based on the current project context.\n * This function takes a command map (either static or dynamic) and formats all commands\n * using the appropriate CLI paths based on whether the current project is the Cyberskill package.\n *\n * @param input - The command map to resolve, which can be static or a function that returns a map.\n * @returns A promise that resolves to an object with formatted command strings, or undefined if package info cannot be retrieved.\n */\nexport async function resolveCommands(input: T_CommandMapInput) {\n    const packageData = await getPackage({ name: CYBERSKILL_PACKAGE_NAME });\n\n    if (packageData.success) {\n        const ctx: I_CommandContext = { isCurrentProject: packageData.result.isCurrentProject };\n        const commands = typeof input === 'function' ? input(ctx) : input;\n\n        return Object.fromEntries(\n            Object.entries(commands).map(([key, cmd]) => [key, formatCommand(cmd, ctx)]),\n        );\n    }\n}\n\n/**\n * Executes a command with proper logging and error handling.\n * This function provides a standardized way to run commands with:\n * - Progress logging with start and success messages\n * - Debug logging of the actual command when DEBUG mode is enabled\n * - Error handling and reporting\n *\n * @param label - A human-readable label describing what the command does.\n * @param command - The command string to execute, or undefined if no command should be run.\n * @returns A promise that resolves when the command execution is complete.\n */\nexport async function runCommand(label: string, command: string | void, options: { timeout?: number; throwOnError?: boolean } = {}) {\n    let timer: NodeJS.Timeout | undefined;\n\n    try {\n        const startTime = Date.now();\n        log.start(`${label}`);\n\n        if (getEnv().DEBUG) {\n            log.info(`→ ${command}`);\n        }\n        else {\n            timer = setInterval(() => {\n                const elapsed = Math.floor((Date.now() - startTime) / 1000);\n\n                if (elapsed > 0) {\n                    process.stdout.write(`\\r⏳ ${label}... ${elapsed}s`);\n                }\n            }, 100);\n        }\n\n        await executeCommand(command, parseCommandOutput, options);\n\n        if (timer) {\n            clearInterval(timer);\n            process.stdout.write(`\\r\\x1B[K`);\n        }\n\n        log.success(`${label} done.`);\n    }\n    catch (error) {\n        if (timer) {\n            clearInterval(timer);\n            process.stdout.write(`\\r\\x1B[K`);\n        }\n\n        if (options.throwOnError) {\n            throw error;\n        }\n        catchError(error);\n    }\n}\n"],"names":["exec","execFile","process","util","storage","getPackage","CYBERSKILL_PACKAGE_NAME","PNPM_EXEC_CLI","TSX_CLI","CYBERSKILL_CLI_PATH","CYBERSKILL_CLI","E_IssueType","log","catchError","getEnv","execPromise","execFilePromise","SHELL_METACHARACTERS","getPackageName","pkg","saveErrorListToStorage","errorList","packageName","mergedErrors","getStoredErrorLists","logPath","error","clearAllErrorLists","parseTextErrors","output","unmatchedLines","lastFilePath","eslintErrorDetailsRegex","tsRegex","commitlintRegex","line","eslintMatch","tsMatch","commitlintMatch","parseCommandOutput","results","filePath","messages","severity","column","ruleId","message","executeCommand","command","parser","options","controller","execOptions","result","parts","stdout","stderr","rawCommand","cmd","formatCLI","context","formatCommand","resolveCommands","input","packageData","ctx","commands","key","runCommand","label","timer","startTime","elapsed"],"mappings":"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"}

package/dist/node/command/index.js

@@ -9,3 +9,4 @@ export {
   s as resolveCommands,
   C as runCommand
 };
+//# sourceMappingURL=index.js.map

package/dist/node/command/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/node/express/express.type.d.ts

@@ -6,6 +6,9 @@ export { Router } from 'express';
 export interface I_ExpressOptions {
     isDev?: boolean;
     static?: string | string[];
+    maxFileSize?: number;
+    maxFiles?: number;
+    jsonLimit?: string;
 }
 export interface I_NestOptions {
     module: Type<object>;
@@ -13,6 +16,7 @@ export interface I_NestOptions {
     static?: string | string[];
     filters?: ExceptionFilter[];
     pipes?: ValidationPipe[];
+    jsonLimit?: string;
 }
 export type T_CorsType = 'node' | 'nest';
 interface I_BaseCorsOptions {

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

@@ -1,54 +1,72 @@
-import { NestFactory as u } from "@nestjs/core";
-import a from "compression";
-import f from "cookie-parser";
-import m from "cors";
-import s from "express";
-import { default as $ } from "express";
-import l from "express-session";
+import u from "node:process";
+import { NestFactory as n } from "@nestjs/core";
+import l from "compression";
+import m from "cookie-parser";
+import f from "cors";
+import i from "express";
+import { default as G } from "express";
+import d from "express-session";
 import { express as p } from "express-useragent";
-import d from "graphql-upload/graphqlUploadExpress.mjs";
-import x from "helmet";
-function y({ isDev: e, whiteList: r, ...o }) {
+import x from "graphql-upload/graphqlUploadExpress.mjs";
+import y from "helmet";
+function E({ isDev: e, whiteList: r, ...t }) {
   return {
-    origin: (t, i) => {
-      e || !t || r?.includes(t ?? "") ? i(null, !0) : i(new Error("Not allowed by CORS"), !1);
+    origin: (s, o) => {
+      e || !s || r?.includes(s ?? "") ? o(null, !0) : o(new Error("Not allowed by CORS"), !1);
     },
     credentials: !0,
-    ...o
+    ...t
   };
 }
-function C(e) {
-  return m(y(e));
+function F(e) {
+  return f(E(e));
 }
-function N(e) {
-  return l(e);
+function P(e) {
+  const r = {
+    resave: !1,
+    saveUninitialized: !1,
+    cookie: {
+      httpOnly: !0,
+      sameSite: "lax",
+      secure: u.env.NODE_ENV === "production"
+    }
+  };
+  return d({
+    ...r,
+    ...e,
+    cookie: { ...r.cookie, ...e.cookie }
+  });
 }
-function c(e, r = !1) {
+function c(e, r = !1, t = "1mb") {
   e.set("trust proxy", 1), e.use(
-    x({
+    y({
       crossOriginEmbedderPolicy: r ? !1 : void 0,
       contentSecurityPolicy: r ? !1 : void 0
     })
-  ), e.use(f()), e.use(s.urlencoded({ extended: !0 })), e.use(a()), e.use(p());
+  ), e.use(m()), e.use(i.json({ limit: t })), e.use(i.urlencoded({ extended: !0, limit: t })), e.use(l()), e.use(p());
 }
-function n(e, r) {
-  r && (Array.isArray(r) ? r : [r]).forEach((t) => {
-    e.use(`/${t}`, s.static(t));
+function a(e, r) {
+  r && (Array.isArray(r) ? r : [r]).forEach((s) => {
+    e.use(`/${s}`, i.static(s));
   });
 }
-function O(e) {
-  const r = s();
-  return c(r, e?.isDev), n(r, e?.static), r.use(d()), r;
+function z(e) {
+  const r = i();
+  return c(r, e?.isDev, e?.jsonLimit), a(r, e?.static), r.use(x({
+    maxFileSize: e?.maxFileSize ?? 1e7,
+    maxFiles: e?.maxFiles ?? 10
+  })), r;
 }
-async function G(e) {
-  const r = await u.create(e.module);
-  return c(r.getHttpAdapter().getInstance(), e.isDev), n(r.getHttpAdapter().getInstance(), e.static), e.filters && r.useGlobalFilters(...e.filters), e.pipes && r.useGlobalPipes(...e.pipes), r;
+async function C(e) {
+  const r = await n.create(e.module);
+  return c(r.getHttpAdapter().getInstance(), e.isDev, e.jsonLimit), a(r.getHttpAdapter().getInstance(), e.static), e.filters && r.useGlobalFilters(...e.filters), e.pipes && r.useGlobalPipes(...e.pipes), r;
 }
 export {
-  C as createCors,
-  y as createCorsOptions,
-  O as createExpress,
-  G as createNest,
-  N as createSession,
-  $ as express
+  F as createCors,
+  E as createCorsOptions,
+  z as createExpress,
+  C as createNest,
+  P as createSession,
+  G as express
 };
+//# sourceMappingURL=express.util.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"express.util.js","sources":["../../../src/node/express/express.util.ts"],"sourcesContent":["import type { INestApplication } from '@nestjs/common';\nimport type { Application, RequestHandler } from 'express';\nimport type { SessionOptions } from 'express-session';\n\nimport process from 'node:process';\n\nimport { NestFactory } from '@nestjs/core';\nimport bodyParser from 'body-parser';\nimport compression from 'compression';\nimport cookieParser from 'cookie-parser';\nimport cors from 'cors';\nimport express from 'express';\nimport session from 'express-session';\nimport { express as useragent } from 'express-useragent';\nimport graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';\nimport helmet from 'helmet';\n\nimport type { I_ExpressOptions, I_NestOptions, T_CorsOptions, T_CorsType } from './express.type.js';\n\n/**\n * Creates CORS options with environment-specific configuration.\n * This function generates CORS options based on the development environment,\n * including whitelist configuration for allowed origins.\n *\n * @param options - CORS configuration options.\n * @param options.isDev - Whether the application is running in development mode.\n * @param options.whiteList - Array of allowed origins for CORS requests.\n * @returns CORS options object configured for the specified environment.\n */\nexport function createCorsOptions<T extends T_CorsType>({ isDev, whiteList, ...rest }: T_CorsOptions<T>) {\n    return {\n        origin: (origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) => {\n            if (isDev || !origin || whiteList?.includes(origin ?? '')) {\n                callback(null, true);\n            }\n            else {\n                callback(new Error('Not allowed by CORS'), false);\n            }\n        },\n        credentials: true,\n        ...rest,\n    };\n}\n\n/**\n * Creates a CORS middleware function with the specified configuration.\n * This function creates a CORS middleware that can be used with both Express and NestJS applications,\n * applying the configured CORS options for origin validation and credential handling.\n *\n * @param options - CORS configuration options to apply to the middleware.\n * @returns A CORS middleware function ready to be used in Express or NestJS applications.\n */\nexport function createCors<T extends T_CorsType>(options: T_CorsOptions<T>) {\n    return cors<cors.CorsRequest>(createCorsOptions(options));\n}\n\n/**\n * Creates a session middleware function with the specified configuration.\n * This function creates an Express session middleware that can be used to handle user sessions\n * with the provided session options including secret, cookie settings, and storage configuration.\n *\n * @param options - Session configuration options including secret, cookie settings, and storage.\n * @returns A session middleware function ready to be used in Express applications.\n */\nexport function createSession(options: SessionOptions): RequestHandler {\n    const secureDefaults: Partial<SessionOptions> = {\n        resave: false,\n        saveUninitialized: false,\n        cookie: {\n            httpOnly: true,\n            sameSite: 'lax',\n            secure: process.env['NODE_ENV'] === 'production',\n        },\n    };\n\n    return session({\n        ...secureDefaults,\n        ...options,\n        cookie: { ...secureDefaults.cookie, ...options.cookie },\n    });\n}\n\n/**\n * Sets up common middleware for Express applications.\n * This function configures essential middleware including:\n * - Trust proxy settings for proper IP handling\n * - Cookie parsing for request cookies\n * - URL-encoded body parsing for form data\n * - Compression for response optimization\n * - User agent parsing for device/browser detection\n *\n * @param app - The Express application instance to configure with middleware.\n */\nfunction setupMiddleware(app: Application, isDev = false, jsonLimit = '1mb') {\n    app.set('trust proxy', 1);\n    app.use(\n        helmet({\n            crossOriginEmbedderPolicy: isDev ? false : undefined,\n            contentSecurityPolicy: isDev ? false : undefined,\n        }),\n    );\n    app.use(cookieParser());\n    app.use(express.json({ limit: jsonLimit }));\n    app.use(express.urlencoded({ extended: true, limit: jsonLimit }));\n    app.use(compression());\n    app.use(useragent());\n}\n\n/**\n * Sets up static file serving for Express applications.\n * This function configures static file serving for the specified folders,\n * making files in those directories accessible via HTTP requests.\n *\n * @param app - The Express application instance to configure with static file serving.\n * @param staticFolders - A string or array of strings representing the paths to serve statically.\n */\nfunction setupStaticFolders(app: Application, staticFolders?: string | string[]) {\n    if (staticFolders) {\n        const statics = Array.isArray(staticFolders) ? staticFolders : [staticFolders];\n        statics.forEach((folder) => {\n            app.use(`/${folder}`, express.static(folder));\n        });\n    }\n}\n\n/**\n * Creates and configures an Express application with common middleware and settings.\n * This function sets up a complete Express application with:\n * - Essential middleware (cookies, body parsing, compression, user agent)\n * - Static file serving for specified folders\n * - GraphQL upload support for file uploads\n *\n * @param options - Optional configuration for the Express application including static folder paths.\n * @returns A configured Express application instance ready for use.\n */\nexport function createExpress(options?: I_ExpressOptions): Application {\n    const app = express();\n\n    setupMiddleware(app, options?.isDev, options?.jsonLimit);\n    setupStaticFolders(app, options?.static);\n    app.use(graphqlUploadExpress({\n        maxFileSize: options?.maxFileSize ?? 10_000_000,\n        maxFiles: options?.maxFiles ?? 10,\n    }));\n\n    return app;\n}\n\n/**\n * Creates and configures a NestJS application with Express integration.\n * This function sets up a NestJS application with:\n * - Express HTTP adapter configuration\n * - Common middleware (cookies, body parsing, compression, user agent)\n * - Static file serving for specified folders\n * - Global filters and pipes if provided\n *\n * @param options - Configuration options for the NestJS application including module, static folders, filters, and pipes.\n * @returns A promise that resolves to a configured NestJS application instance.\n */\nexport async function createNest(options: I_NestOptions): Promise<INestApplication> {\n    const app = await NestFactory.create(options.module);\n\n    setupMiddleware(app.getHttpAdapter().getInstance(), options.isDev, options.jsonLimit);\n    setupStaticFolders(app.getHttpAdapter().getInstance(), options.static);\n\n    if (options.filters) {\n        app.useGlobalFilters(...options.filters);\n    }\n\n    if (options.pipes) {\n        app.useGlobalPipes(...options.pipes);\n    }\n\n    return app;\n}\n\nexport { bodyParser, express };\n"],"names":["createCorsOptions","isDev","whiteList","rest","origin","callback","createCors","options","cors","createSession","secureDefaults","process","session","setupMiddleware","app","jsonLimit","helmet","cookieParser","express","compression","useragent","setupStaticFolders","staticFolders","folder","createExpress","graphqlUploadExpress","createNest","NestFactory"],"mappings":";;;;;;;;;;;AA6BO,SAASA,EAAwC,EAAE,OAAAC,GAAO,WAAAC,GAAW,GAAGC,KAA0B;AACrG,SAAO;AAAA,IACH,QAAQ,CAACC,GAA4BC,MAA2D;AAC5F,MAAIJ,KAAS,CAACG,KAAUF,GAAW,SAASE,KAAU,EAAE,IACpDC,EAAS,MAAM,EAAI,IAGnBA,EAAS,IAAI,MAAM,qBAAqB,GAAG,EAAK;AAAA,IAExD;AAAA,IACA,aAAa;AAAA,IACb,GAAGF;AAAA,EAAA;AAEX;AAUO,SAASG,EAAiCC,GAA2B;AACxE,SAAOC,EAAuBR,EAAkBO,CAAO,CAAC;AAC5D;AAUO,SAASE,EAAcF,GAAyC;AACnE,QAAMG,IAA0C;AAAA,IAC5C,QAAQ;AAAA,IACR,mBAAmB;AAAA,IACnB,QAAQ;AAAA,MACJ,UAAU;AAAA,MACV,UAAU;AAAA,MACV,QAAQC,EAAQ,IAAI,aAAgB;AAAA,IAAA;AAAA,EACxC;AAGJ,SAAOC,EAAQ;AAAA,IACX,GAAGF;AAAA,IACH,GAAGH;AAAA,IACH,QAAQ,EAAE,GAAGG,EAAe,QAAQ,GAAGH,EAAQ,OAAA;AAAA,EAAO,CACzD;AACL;AAaA,SAASM,EAAgBC,GAAkBb,IAAQ,IAAOc,IAAY,OAAO;AACzE,EAAAD,EAAI,IAAI,eAAe,CAAC,GACxBA,EAAI;AAAA,IACAE,EAAO;AAAA,MACH,2BAA2Bf,IAAQ,KAAQ;AAAA,MAC3C,uBAAuBA,IAAQ,KAAQ;AAAA,IAAA,CAC1C;AAAA,EAAA,GAELa,EAAI,IAAIG,GAAc,GACtBH,EAAI,IAAII,EAAQ,KAAK,EAAE,OAAOH,EAAA,CAAW,CAAC,GAC1CD,EAAI,IAAII,EAAQ,WAAW,EAAE,UAAU,IAAM,OAAOH,EAAA,CAAW,CAAC,GAChED,EAAI,IAAIK,GAAa,GACrBL,EAAI,IAAIM,GAAW;AACvB;AAUA,SAASC,EAAmBP,GAAkBQ,GAAmC;AAC7E,EAAIA,MACgB,MAAM,QAAQA,CAAa,IAAIA,IAAgB,CAACA,CAAa,GACrE,QAAQ,CAACC,MAAW;AACxB,IAAAT,EAAI,IAAI,IAAIS,CAAM,IAAIL,EAAQ,OAAOK,CAAM,CAAC;AAAA,EAChD,CAAC;AAET;AAYO,SAASC,EAAcjB,GAAyC;AACnE,QAAMO,IAAMI,EAAA;AAEZ,SAAAL,EAAgBC,GAAKP,GAAS,OAAOA,GAAS,SAAS,GACvDc,EAAmBP,GAAKP,GAAS,MAAM,GACvCO,EAAI,IAAIW,EAAqB;AAAA,IACzB,aAAalB,GAAS,eAAe;AAAA,IACrC,UAAUA,GAAS,YAAY;AAAA,EAAA,CAClC,CAAC,GAEKO;AACX;AAaA,eAAsBY,EAAWnB,GAAmD;AAChF,QAAMO,IAAM,MAAMa,EAAY,OAAOpB,EAAQ,MAAM;AAEnD,SAAAM,EAAgBC,EAAI,iBAAiB,YAAA,GAAeP,EAAQ,OAAOA,EAAQ,SAAS,GACpFc,EAAmBP,EAAI,eAAA,EAAiB,YAAA,GAAeP,EAAQ,MAAM,GAEjEA,EAAQ,WACRO,EAAI,iBAAiB,GAAGP,EAAQ,OAAO,GAGvCA,EAAQ,SACRO,EAAI,eAAe,GAAGP,EAAQ,KAAK,GAGhCO;AACX;"}

package/dist/node/express/index.js

@@ -11,3 +11,4 @@ export {
   p as createSession,
   x as express
 };
+//# sourceMappingURL=index.js.map

package/dist/node/express/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/node/fs/fs.test.unit.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -54,3 +54,4 @@ export {
   F as unlinkSync,
   u as writeFileSync
 };
+//# sourceMappingURL=fs.util.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.util.js","sources":["../../../src/node/fs/fs.util.ts"],"sourcesContent":["import fsExtra from 'fs-extra';\nimport path from 'node:path';\n\nimport type { I_CopySyncOptions } from './fs.type.js';\n\n/**\n * Re-export of the fs-extra module for file system operations.\n */\nexport const fs = fsExtra;\n\nexport const {\n    lstatSync,\n    readdirSync,\n    mkdirSync,\n    readFileSync,\n    unlinkSync,\n    statSync,\n    createWriteStream,\n} = fsExtra;\n\nexport const readJsonSync: typeof fsExtra.readJsonSync = fsExtra.readJsonSync;\n\n/**\n * Writes data to a file synchronously with UTF-8 encoding as default.\n * This function provides a simplified interface for writing files with automatic UTF-8 encoding\n * when no specific options are provided.\n *\n * @param file - The file path or file descriptor to write to.\n * @param data - The data to write to the file (string or Uint8Array).\n * @param options - Optional write file options (defaults to UTF-8 encoding).\n */\nexport function writeFileSync(file: fsExtra.PathOrFileDescriptor, data: string | Uint8Array, options?: fsExtra.WriteFileOptions): void {\n    fsExtra.writeFileSync(file, data, options ?? 'utf-8');\n}\n\n/**\n * Appends data to a file synchronously with UTF-8 encoding as default.\n * This function provides a simplified interface for appending to files with automatic UTF-8 encoding\n * when no specific options are provided.\n *\n * @param path - The file path or file descriptor to append to.\n * @param data - The data to append to the file (string or Uint8Array).\n * @param options - Optional write file options (defaults to UTF-8 encoding).\n */\nexport function appendFileSync(path: fsExtra.PathOrFileDescriptor, data: string | Uint8Array, options?: fsExtra.WriteFileOptions): void {\n    fsExtra.appendFileSync(path, data, options ?? 'utf-8');\n}\n\n/**\n * Checks if all specified paths exist synchronously.\n * This function verifies that every path in the provided array exists in the file system.\n * Returns true only if all paths exist, false if any path is missing.\n *\n * @param paths - An array of file or directory paths to check for existence.\n * @returns True if all paths exist, false if any path is missing.\n */\nexport function pathExistsSync(...paths: string[]) {\n    return paths.every(path => fsExtra.pathExistsSync(path));\n}\n\n/**\n * Removes files or directories synchronously if they exist.\n * This function safely removes multiple files or directories by checking for existence\n * before attempting removal, preventing errors for non-existent paths.\n *\n * @param paths - An array of file or directory paths to remove.\n */\nexport function removeSync(...paths: string[]) {\n    paths.forEach((filePath) => {\n        if (pathExistsSync(filePath)) {\n            fsExtra.removeSync(filePath);\n        }\n    });\n}\n\n/**\n * Copies files and directories synchronously with optional filtering.\n * This function copies files from source to destination with support for:\n * - Extension-based filtering (only copy files with specified extensions)\n * - Directory preservation (always copy directories regardless of extension filter)\n * - Additional copy options from fs-extra\n *\n * @param src - The source path to copy from.\n * @param dest - The destination path to copy to.\n * @param options - Optional copy configuration including extensions filter and other fs-extra options.\n */\nexport function copySync(src: string, dest: string, options: I_CopySyncOptions = {}): void {\n    const { extensions, ...rest } = options;\n\n    fsExtra.copySync(src, dest, {\n        filter: (srcPath: string) => {\n            if (statSync(srcPath).isDirectory()) {\n                return true;\n            }\n\n            if (!extensions || extensions.length === 0) {\n                return true;\n            }\n\n            return extensions.includes(path.extname(srcPath));\n        },\n        ...rest,\n    });\n}\n\n/**\n * Adds an entry to the .gitignore file if it doesn't already exist.\n * Creates the .gitignore file if it doesn't exist.\n *\n * @param gitIgnorePath - The absolute path to the .gitignore file.\n * @param entry - The entry name to add (e.g. '.agent', '.simple-git-hooks.json').\n */\nexport function addGitIgnoreEntry(gitIgnorePath: string, entry: string): void {\n    const gitIgnoreContent = `\\n${entry}\\n`;\n\n    if (pathExistsSync(gitIgnorePath)) {\n        const gitignore = readFileSync(gitIgnorePath, 'utf-8').split('\\n');\n\n        if (!gitignore.includes(entry)) {\n            appendFileSync(gitIgnorePath, gitIgnoreContent);\n        }\n    }\n    else {\n        writeFileSync(gitIgnorePath, gitIgnoreContent);\n    }\n}\n"],"names":["fsExtra","path","fs","lstatSync","readdirSync","mkdirSync","readFileSync","unlinkSync","statSync","createWriteStream","readJsonSync","writeFileSync","file","data","options","appendFileSync","pathExistsSync","paths","removeSync","filePath","copySync","src","dest","extensions","rest","srcPath","addGitIgnoreEntry","gitIgnorePath","entry","gitIgnoreContent"],"mappings":"AAQO,OAAAA,OAAA;AAAA,OAAAC,OAAA;AAAA,MAAMC,IAAKF,GAEL;AAAA,EACT,WAAAG;AAAA,EACA,aAAAC;AAAA,EACA,WAAAC;AAAA,EACA,cAAAC;AAAA,EACA,YAAAC;AAAA,EACA,UAAAC;AAAA,EACA,mBAAAC;AACJ,IAAIT,GAESU,IAA4CV,EAAQ;AAW1D,SAASW,EAAcC,GAAoCC,GAA2BC,GAA0C;AACnI,EAAAd,EAAQ,cAAcY,GAAMC,GAAMC,KAAW,OAAO;AACxD;AAWO,SAASC,EAAed,GAAoCY,GAA2BC,GAA0C;AACpI,EAAAd,EAAQ,eAAeC,GAAMY,GAAMC,KAAW,OAAO;AACzD;AAUO,SAASE,KAAkBC,GAAiB;AAC/C,SAAOA,EAAM,MAAM,CAAAhB,MAAQD,EAAQ,eAAeC,CAAI,CAAC;AAC3D;AASO,SAASiB,KAAcD,GAAiB;AAC3C,EAAAA,EAAM,QAAQ,CAACE,MAAa;AACxB,IAAIH,EAAeG,CAAQ,KACvBnB,EAAQ,WAAWmB,CAAQ;AAAA,EAEnC,CAAC;AACL;AAaO,SAASC,EAASC,GAAaC,GAAcR,IAA6B,CAAA,GAAU;AACvF,QAAM,EAAE,YAAAS,GAAY,GAAGC,EAAA,IAASV;AAEhC,EAAAd,EAAQ,SAASqB,GAAKC,GAAM;AAAA,IACxB,QAAQ,CAACG,MACDjB,EAASiB,CAAO,EAAE,iBAIlB,CAACF,KAAcA,EAAW,WAAW,IAC9B,KAGJA,EAAW,SAAStB,EAAK,QAAQwB,CAAO,CAAC;AAAA,IAEpD,GAAGD;AAAA,EAAA,CACN;AACL;AASO,SAASE,EAAkBC,GAAuBC,GAAqB;AAC1E,QAAMC,IAAmB;AAAA,EAAKD,CAAK;AAAA;AAEnC,EAAIZ,EAAeW,CAAa,IACVrB,EAAaqB,GAAe,OAAO,EAAE,MAAM;AAAA,CAAI,EAElD,SAASC,CAAK,KACzBb,EAAeY,GAAeE,CAAgB,IAIlDlB,EAAcgB,GAAeE,CAAgB;AAErD;"}

package/dist/node/fs/index.js

@@ -16,3 +16,4 @@ export {
   F as unlinkSync,
   f as writeFileSync
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/node/log/index.js

@@ -6,3 +6,4 @@ export {
   E as log,
   c as throwError
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/node/log/log.test.unit.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -2,3 +2,4 @@ var n = /* @__PURE__ */ ((r) => (r.Error = "error", r.Warning = "warning", r))(n
 export {
   n as E_IssueType
 };
+//# sourceMappingURL=log.type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.type.js","sources":["../../../src/node/log/log.type.ts"],"sourcesContent":["import type { I_Log as I_LogCommon } from '#typescript/index.js';\n\n/**\n * Enum representing the type of issues for logging and error handling.\n * - Error: Represents an error issue.\n * - Warning: Represents a warning issue.\n */\nexport enum E_IssueType {\n    Error = 'error',\n    Warning = 'warning',\n}\n\nexport interface I_IssueEntry {\n    type: E_IssueType;\n    file: string;\n    message: string;\n    position?: string;\n    rule?: string;\n}\n\nexport interface I_ThrowError {\n    message?: string;\n    status?: {\n        CODE: string | number;\n        MESSAGE: string;\n    };\n    type?: 'graphql' | 'rest';\n}\n\nexport interface I_Log extends I_LogCommon {\n    printBoxedLog: (\n        title: string,\n        issues: I_IssueEntry[],\n        color?: string,\n    ) => void;\n}\n\nexport interface I_CatchErrorOptions {\n    shouldLog?: boolean;\n    returnValue?: unknown;\n    callback?: (error: Error) => void;\n}\n"],"names":["E_IssueType"],"mappings":"AAOO,IAAKA,sBAAAA,OACRA,EAAA,QAAQ,SACRA,EAAA,UAAU,WAFFA,IAAAA,KAAA,CAAA,CAAA;"}

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

@@ -70,3 +70,4 @@ export {
   m as log,
   S as throwError
 };
+//# sourceMappingURL=log.util.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.util.js","sources":["../../../src/node/log/log.util.ts"],"sourcesContent":["import type { ChalkInstance } from 'chalk';\n\nimport chalk from 'chalk';\nimport consola from 'consola';\nimport { GraphQLError } from 'graphql';\n\nimport type { I_Return } from '#typescript/index.js';\n\nimport { getEnv } from '#config/env/index.js';\nimport { RESPONSE_STATUS } from '#constant/index.js';\n\nimport type { I_CatchErrorOptions, I_IssueEntry, I_Log, I_ThrowError } from './log.type.js';\n\nconst env = getEnv();\n\n/**\n * Throws a standardized error with optional status information and type specification.\n * This function creates and throws errors that can be either GraphQL errors (with extensions)\n * or standard JavaScript errors, depending on the specified type.\n *\n * @param options - Error configuration including message, status information, and error type.\n * @param options.message - The error message to display.\n * @param options.status - The response status information (defaults to INTERNAL_SERVER_ERROR).\n * @param options.type - The type of error to throw ('graphql' or 'rest', defaults to 'graphql').\n * @throws {GraphQLError} When type is 'graphql', throws a GraphQL error with extensions.\n * @throws {Error} When type is 'rest' or unspecified, throws a standard JavaScript error.\n */\nexport function throwError({\n    message,\n    status = RESPONSE_STATUS.INTERNAL_SERVER_ERROR,\n    type = 'graphql',\n}: I_ThrowError): never {\n    const responseMessage\n        = message ?? status.MESSAGE ?? 'Internal server error';\n\n    if (type === 'graphql') {\n        throw new GraphQLError(responseMessage, {\n            extensions: { code: status.CODE },\n        });\n    }\n\n    else {\n        throw new Error(responseMessage);\n    }\n}\n\nif (!env.DEBUG) {\n    consola.level = 4;\n}\n\n/**\n * Gets a chalk color instance by keyword name.\n * This function safely retrieves a chalk color function by name, falling back to green\n * if the specified color is not available or invalid.\n *\n * @param color - The color keyword to get the chalk instance for.\n * @returns A chalk instance for the specified color, or green as fallback.\n */\nfunction chalkKeyword(color: string): ChalkInstance {\n    const chalkColor = chalk[color as keyof typeof chalk];\n\n    return typeof chalkColor === 'function' ? (chalkColor as ChalkInstance) : chalk.green;\n}\n\n/**\n * Enhanced logging interface that extends consola with custom functionality.\n * This object provides all standard consola logging methods plus additional features\n * like boxed log printing for structured error/warning display.\n */\nexport const log: I_Log = {\n    silent: consola.silent,\n    level: consola.level,\n    fatal: consola.fatal,\n    error: consola.error,\n    warn: consola.warn,\n    log: consola.log,\n    info: consola.info,\n    success: consola.success,\n    ready: consola.ready,\n    start: consola.start,\n    box: consola.box,\n    debug: consola.debug,\n    trace: consola.trace,\n    verbose: consola.verbose,\n    /**\n     * Prints a boxed log with structured issue information.\n     * This method displays issues (errors or warnings) in a formatted box with:\n     * - File paths and line/column positions\n     * - Rule violations (if applicable)\n     * - Error/warning messages\n     * - Color-coded output based on issue type\n     *\n     * @param title - The title to display in the box header.\n     * @param issues - An array of issue entries to display.\n     * @param color - The color to use for highlighting (defaults to 'red').\n     */\n    printBoxedLog(title: string, issues: I_IssueEntry[], color = 'red') {\n        if (!issues?.length) {\n            consola.box(chalk.green(title));\n            return;\n        }\n\n        issues.forEach(({ file, position, rule, message }) => {\n            const positionSuffix = position ? `:${position}` : '';\n            const filePath = `${file}${positionSuffix}`;\n            consola.log(`${chalk.gray('File:')} ${chalk.blue(filePath)}`);\n\n            if (rule) {\n                consola.log(`   ${chalkKeyword(color)('Rule:')} ${rule}`);\n            }\n\n            consola.log(`   ${chalkKeyword(color)('Message:')} ${message}`);\n        });\n\n        consola.box(chalkKeyword(color)(`${title} : ${issues.length}`));\n\n        consola.log(chalk.gray('─'.repeat(40)));\n    },\n};\n\n/**\n * Catches and handles errors with configurable behavior.\n * This function provides a standardized way to handle errors with options for:\n * - Logging control (whether to log the error)\n * - Return value specification (what to return on error)\n * - Custom callback execution (additional error handling)\n *\n * @param errorInput - The error to catch and handle.\n * @param options - Configuration options for error handling behavior.\n * @returns Either the specified return value or a standardized error response object.\n */\nexport function catchError<T = unknown>(errorInput: unknown, options: I_CatchErrorOptions & { returnValue: T }): T;\nexport function catchError<T = unknown>(errorInput: unknown, options?: I_CatchErrorOptions): I_Return<T>;\nexport function catchError<T = unknown>(errorInput: unknown, options?: I_CatchErrorOptions): I_Return<T> | T {\n    const { shouldLog = true, returnValue, callback } = options ?? {};\n\n    const error = errorInput instanceof Error\n        ? errorInput\n        : new Error(typeof errorInput === 'string' ? errorInput : 'Unknown error');\n\n    if (shouldLog) {\n        log.error(error.message);\n    }\n\n    if (callback && typeof callback === 'function') {\n        callback(error);\n    }\n\n    if (returnValue) {\n        return returnValue as T;\n    }\n\n    return {\n        success: false,\n        message: error.message,\n        code: RESPONSE_STATUS.INTERNAL_SERVER_ERROR.CODE,\n    };\n}\n"],"names":["env","getEnv","throwError","message","status","RESPONSE_STATUS","type","responseMessage","GraphQLError","consola","chalkKeyword","color","chalkColor","chalk","log","title","issues","file","position","rule","positionSuffix","filePath","catchError","errorInput","options","shouldLog","returnValue","callback","error"],"mappings":";;;;;AAaA,MAAMA,IAAMC,EAAA;AAcL,SAASC,EAAW;AAAA,EACvB,SAAAC;AAAA,EACA,QAAAC,IAASC,EAAgB;AAAA,EACzB,MAAAC,IAAO;AACX,GAAwB;AACpB,QAAMC,IACAJ,KAAWC,EAAO,WAAW;AAEnC,QAAIE,MAAS,YACH,IAAIE,EAAaD,GAAiB;AAAA,IACpC,YAAY,EAAE,MAAMH,EAAO,KAAA;AAAA,EAAK,CACnC,IAIK,IAAI,MAAMG,CAAe;AAEvC;AAEKP,EAAI,UACLS,EAAQ,QAAQ;AAWpB,SAASC,EAAaC,GAA8B;AAChD,QAAMC,IAAaC,EAAMF,CAA2B;AAEpD,SAAO,OAAOC,KAAe,aAAcA,IAA+BC,EAAM;AACpF;AAOO,MAAMC,IAAa;AAAA,EACtB,QAAQL,EAAQ;AAAA,EAChB,OAAOA,EAAQ;AAAA,EACf,OAAOA,EAAQ;AAAA,EACf,OAAOA,EAAQ;AAAA,EACf,MAAMA,EAAQ;AAAA,EACd,KAAKA,EAAQ;AAAA,EACb,MAAMA,EAAQ;AAAA,EACd,SAASA,EAAQ;AAAA,EACjB,OAAOA,EAAQ;AAAA,EACf,OAAOA,EAAQ;AAAA,EACf,KAAKA,EAAQ;AAAA,EACb,OAAOA,EAAQ;AAAA,EACf,OAAOA,EAAQ;AAAA,EACf,SAASA,EAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAajB,cAAcM,GAAeC,GAAwBL,IAAQ,OAAO;AAChE,QAAI,CAACK,GAAQ,QAAQ;AACjB,MAAAP,EAAQ,IAAII,EAAM,MAAME,CAAK,CAAC;AAC9B;AAAA,IACJ;AAEA,IAAAC,EAAO,QAAQ,CAAC,EAAE,MAAAC,GAAM,UAAAC,GAAU,MAAAC,GAAM,SAAAhB,QAAc;AAClD,YAAMiB,IAAiBF,IAAW,IAAIA,CAAQ,KAAK,IAC7CG,IAAW,GAAGJ,CAAI,GAAGG,CAAc;AACzC,MAAAX,EAAQ,IAAI,GAAGI,EAAM,KAAK,OAAO,CAAC,IAAIA,EAAM,KAAKQ,CAAQ,CAAC,EAAE,GAExDF,KACAV,EAAQ,IAAI,MAAMC,EAAaC,CAAK,EAAE,OAAO,CAAC,IAAIQ,CAAI,EAAE,GAG5DV,EAAQ,IAAI,MAAMC,EAAaC,CAAK,EAAE,UAAU,CAAC,IAAIR,CAAO,EAAE;AAAA,IAClE,CAAC,GAEDM,EAAQ,IAAIC,EAAaC,CAAK,EAAE,GAAGI,CAAK,MAAMC,EAAO,MAAM,EAAE,CAAC,GAE9DP,EAAQ,IAAII,EAAM,KAAK,IAAI,OAAO,EAAE,CAAC,CAAC;AAAA,EAC1C;AACJ;AAeO,SAASS,EAAwBC,GAAqBC,GAAgD;AACzG,QAAM,EAAE,WAAAC,IAAY,IAAM,aAAAC,GAAa,UAAAC,EAAA,IAAaH,KAAW,CAAA,GAEzDI,IAAQL,aAAsB,QAC9BA,IACA,IAAI,MAAM,OAAOA,KAAe,WAAWA,IAAa,eAAe;AAU7E,SARIE,KACAX,EAAI,MAAMc,EAAM,OAAO,GAGvBD,KAAY,OAAOA,KAAa,cAChCA,EAASC,CAAK,GAGdF,KAIG;AAAA,IACH,SAAS;AAAA,IACT,SAASE,EAAM;AAAA,IACf,MAAMvB,EAAgB,sBAAsB;AAAA,EAAA;AAEpD;"}

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

@@ -1,4 +1,6 @@
 export * from './mongo.constant.js';
 export * from './mongo.controller.js';
+export * from './mongo.dynamic-populate.js';
+export * from './mongo.populate.js';
 export * from './mongo.type.js';
 export * from './mongo.util.js';

package/dist/node/mongo/index.js

@@ -1,17 +1,26 @@
 import { MONGO_MIGRATE_OPTIONS as r, MONGO_SLUG_MAX_ATTEMPTS as t } from "./mongo.constant.js";
-import { MongoController as n, MongooseController as M } from "./mongo.controller.js";
-import { C_Collection as m, C_Db as p, C_Document as C, C_Model as O } from "./mongo.type.js";
-import { applyNestedPopulate as N, convertEnumToModelName as f, mongo as x } from "./mongo.util.js";
+import { filterDynamicVirtualsFromPopulate as m, isMongooseDoc as p, isObject as n, populateDynamicVirtuals as a, remapDynamicPopulate as M } from "./mongo.dynamic-populate.js";
+import { applyNestedPopulate as _ } from "./mongo.populate.js";
+import { C_Collection as f, C_Db as u, C_Document as s, C_Model as x } from "./mongo.type.js";
+import { convertEnumToModelName as O, mongo as D } from "./mongo.util.js";
+import { MongoController as N } from "./mongo.controller.native.js";
+import { MongooseController as g } from "./mongo.controller.mongoose.js";
 export {
-  m as C_Collection,
-  p as C_Db,
-  C as C_Document,
-  O as C_Model,
+  f as C_Collection,
+  u as C_Db,
+  s as C_Document,
+  x as C_Model,
   r as MONGO_MIGRATE_OPTIONS,
   t as MONGO_SLUG_MAX_ATTEMPTS,
-  n as MongoController,
-  M as MongooseController,
-  N as applyNestedPopulate,
-  f as convertEnumToModelName,
-  x as mongo
+  N as MongoController,
+  g as MongooseController,
+  _ as applyNestedPopulate,
+  O as convertEnumToModelName,
+  m as filterDynamicVirtualsFromPopulate,
+  p as isMongooseDoc,
+  n as isObject,
+  D as mongo,
+  a as populateDynamicVirtuals,
+  M as remapDynamicPopulate
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}