logxpert 1.0.5 → 2.0.3

package/main.js

@@ -1,197 +1,375 @@
 const fs = require('fs');
-const moment = require('moment'); // Add moment as a dependency: npm install moment
+const path = require('path');
+const dayjs = require('dayjs');
 const { createLogger, format, transports } = require('winston');
 require('winston-daily-rotate-file');
 
-/**
- * Helper function to format the timestamp while preserving square brackets.
- * It identifies square brackets and formats only the contents within them,
- * preserving all other text (including the brackets) as literal.
- * If no brackets are provided, the entire string is treated as a Moment.js format.
- *
- * @param {string} fmt - The user-defined format string.
- * @returns {string} - The formatted timestamp.
- *
- * Example:
- *   Input: "This is the date: [YYYY-MM-DD HH:mm:ss] - "
- *   Output: "This is the date: [2025-03-21 15:30:45] - "
- */
-function formatCustomTimestamp(fmt) {
-    // If the format contains both [ and ], we use "template mode".
-    // This allows users to include literal text alongside bracketed date tokens.
-    if (fmt.includes('[') && fmt.includes(']')) {
-        return fmt.split(/(\[[^\]]*\])/).map(part => {
-            if (part.startsWith('[') && part.endsWith(']')) {
-                // Inside brackets: format the content while keeping the brackets literal.
-                const inner = part.slice(1, -1);
-                return '[' + (inner ? moment().format(inner) : '') + ']';
-            }
-            // Outside brackets: treat as literal text to avoid mangling letters.
-            return part;
-        }).join('');
+const VALID_LEVELS = ['error', 'warn', 'info', 'http', 'verbose', 'debug', 'silly'];
+const DEFAULT_CONSOLE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+function formatDefaultTimestamp(d = new Date()) {
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+
+function splitBrackets(fmt) {
+  const parts = [];
+  let current = '';
+  let i = 0;
+  while (i < fmt.length) {
+    if (fmt[i] === '[') {
+      const close = fmt.indexOf(']', i + 1);
+      if (close === -1) {
+        current += fmt.slice(i);
+        break;
+      }
+      if (current) {
+        parts.push(current);
+        current = '';
+      }
+      parts.push(fmt.slice(i, close + 1));
+      i = close + 1;
+    } else {
+      current += fmt[i];
+      i++;
     }
-    // Standard mode: treat the whole string as a moment format string.
-    return moment().format(fmt);
-}
-
-
-/**
- * @typedef {Object} ConsoleOptions
- * @property {boolean} [enableTimestamp=true] - Enable or disable timestamp in console logs.
- * @property {string} [timestampFormat='YYYY-MM-DD HH:mm:ss'] - Custom format for the timestamp.
- *   Use square brackets (e.g., [YYYY-MM-DD]) to mark parts that should be formatted.
- *   Text outside brackets is treated as literal.
- * @property {string} [timestampPrefix=''] - Optional text to prepend to the timestamp.
- * @property {string} [timestampSuffix=''] - Optional text to append to the timestamp.
- */
-
-/**
- * @typedef {Object} FilesOptions
- * @property {string} [folder='logs'] - Directory where log files will be stored.
- * @property {string} [filesName='YYYY-MM-DD'] - Date pattern used in the log file name.
- * @property {string} [maxFile='14d'] - Maximum file retention time.
- * @property {string} [maxSize='20m'] - Maximum file size per log file.
- * @property {boolean} [zippedArchive=false] - Whether to archive logs as zip.
- */
-
-/**
- * @typedef {Object} LogSettingsOptions
- * @property {ConsoleOptions} [console] - Options for customizing console output.
- * @property {FilesOptions} [files] - Options for configuring file logging.
- */
-
-// Custom format for logger output
-const customFormat = format.printf(({ timestamp, level, message }) => {
-    return timestamp ? `${timestamp} [${level}]: ${message}` : `[${level}]: ${message}`;
-});
+  }
+  if (current) parts.push(current);
+  return parts;
+}
 
-// Default console timestamp format
-const defaultConsoleFormat = 'YYYY-MM-DD HH:mm:ss';
+function compileTimestampFormatter(fmt) {
+  if (typeof fmt !== 'string' || !fmt) return formatDefaultTimestamp;
+  if (fmt === DEFAULT_CONSOLE_FORMAT) return formatDefaultTimestamp;
+  if (!fmt.includes('[') || !fmt.includes(']')) return () => dayjs().format(fmt);
+  const parts = splitBrackets(fmt).map((part) => {
+    if (part.startsWith('[') && part.endsWith(']')) {
+      const inner = part.slice(1, -1);
+      return inner ? () => '[' + dayjs().format(inner) + ']' : () => '[]';
+    }
+    return () => part;
+  });
+  return () => parts.map((f) => f()).join('');
+}
 
-// Create the global logger. Its default format will be overridden by the console transport settings.
-const logger = createLogger({
-    level: 'debug',
-    format: format.combine(
-        format.timestamp({ format: () => moment().format(defaultConsoleFormat) }),
-        customFormat
-    )
-});
+function formatCustomTimestamp(fmt) {
+  return compileTimestampFormatter(fmt)();
+}
+
+function formatExtra(meta) {
+  const keys = Object.keys(meta).filter((k) => k !== 'splat' && k !== 'ms');
+  if (!keys.length) return '';
+  try {
+    const picked = {};
+    for (const k of keys) picked[k] = meta[k];
+    return JSON.stringify(picked);
+  } catch {
+    return '';
+  }
+}
 
-// Create default console transport (will be replaced via settings)
-let consoleTransport = new transports.Console({
-    format: format.combine(
-        format.colorize(),
-        format.timestamp({ format: () => moment().format(defaultConsoleFormat) }),
-        customFormat
-    )
+const prettyFormat = format.printf(({ timestamp, level, message, ...meta }) => {
+  const msg = typeof message === 'string' ? message : message == null ? '' : JSON.stringify(message);
+  const extra = formatExtra(meta);
+  const body = [msg, extra].filter(Boolean).join(' ');
+  return timestamp ? `${timestamp} [${level}]: ${body}` : `[${level}]: ${body}`;
 });
-logger.add(consoleTransport);
-
-// Reference to file transport (added via settings)
-let fileTransport;
-
-/**
- * Configures logging settings for both console and file transports.
- *
- * @param {LogSettingsOptions} options - The settings for both console and file logging.
- * @example
- * // Example: Fully custom console timestamp that preserves decorational brackets,
- * // and enabling file logging.
- * log.settings({ 
- *   console: { 
- *     enableTimestamp: true,
- *     timestampFormat: "This is the date: [YYYY-MM-DD HH:mm:ss] - "
- *   },
- *   files: { 
- *     folder: 'logs', 
- *     filesName: 'YYYY-MM-DD', 
- *     maxFile: '14d', 
- *     maxSize: '20m', 
- *     zippedArchive: false 
- *   }
- * });
- */
-function applySettings(options = {}) {
-    if (options.console) {
-        const enableTimestamp = options.console.enableTimestamp !== undefined ? options.console.enableTimestamp : true;
-        const timestampFormat = options.console.timestampFormat || defaultConsoleFormat;
-        const timestampPrefix = options.console.timestampPrefix || '';
-        const timestampSuffix = options.console.timestampSuffix || '';
-
-        // Remove the current console transport
-        logger.remove(consoleTransport);
-
-        // Build the console format based on the enableTimestamp flag.
-        const consoleFormat = enableTimestamp
-            ? format.combine(
-                format.colorize(),
-                format.timestamp({ format: () => timestampPrefix + formatCustomTimestamp(timestampFormat) + timestampSuffix }),
-                customFormat
-            )
-            : format.combine(
-                format((info) => { delete info.timestamp; return info; })(),
-                format.colorize(),
-                customFormat
-            );
-
-        consoleTransport = new transports.Console({
-            format: consoleFormat
-        });
-        logger.add(consoleTransport);
+
+function assertLevel(level) {
+  if (!VALID_LEVELS.includes(level)) throw new Error(`Invalid log level "${level}". Use one of: ${VALID_LEVELS.join(', ')}`);
+}
+
+function stripAnsi(str) {
+  let out = '';
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] !== '\x1b') {
+      out += str[i];
+      i++;
+      continue;
+    }
+    const next = str[i + 1];
+    if (next === ']') {
+      let j = i + 2;
+      while (j < str.length) {
+        if (str[j] === '\x07') { j++; break; }
+        if (str[j] === '\x1b' && str[j + 1] === '\\') { j += 2; break; }
+        j++;
+      }
+      i = j;
+    } else if (next === '[') {
+      let j = i + 2;
+      while (j < str.length && str[j] >= ' ' && str[j] <= '?') j++;
+      if (j < str.length) j++;
+      i = j;
+    } else if (next === '(' || next === ')') {
+      i += 3;
+    } else {
+      i += next === undefined ? 1 : 2;
     }
+  }
+  return out;
+}
+const CONTROL_RE = /[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f]/g;
 
-    if (options.files) {
-        const folder = options.files.folder || 'logs';
-        const datePattern = options.files.filesName || 'YYYY-MM-DD';
-        const maxFiles = options.files.maxFile || '14d';
-        const maxSize = options.files.maxSize || '20m';
-        const zippedArchive = options.files.zippedArchive !== undefined ? options.files.zippedArchive : false;
-
-        if (!fs.existsSync(folder)) {
-            fs.mkdirSync(folder, { recursive: true });
-        }
-
-        if (fileTransport) {
-            logger.remove(fileTransport);
-        }
-
-        fileTransport = new transports.DailyRotateFile({
-            filename: `${folder}/application-%DATE%.log`,
-            datePattern,
-            zippedArchive,
-            maxSize,
-            maxFiles
-        });
-        logger.add(fileTransport);
+function sanitizeMessage(msg) {
+  if (typeof msg !== 'string') return msg;
+  return stripAnsi(msg).replace(CONTROL_RE, '');
+}
+
+function assertFilenameSafe(filename) {
+  if (typeof filename !== 'string' || !filename.trim() || filename.includes('\0')) {
+    throw new Error('files.filename must be a non-empty string');
+  }
+  if (path.isAbsolute(filename) || filename.split(/[\\/]/).includes('..')) {
+    throw new Error('files.filename must not escape the log folder (.. and absolute paths are rejected)');
+  }
+}
+
+function isSafeChar(c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '.' || c === '_' || c === '-';
+}
+
+function isPadChar(c) {
+  return c === '-' || c === '_' || c === '.';
+}
+
+function sanitizeAppName(name) {
+  if (typeof name !== 'string' || !name.trim()) return null;
+  const base = name.trim().slice(0, 200).split('/').pop();
+  let out = '';
+  for (let i = 0; i < base.length; i++) {
+    out += isSafeChar(base[i]) ? base[i] : '-';
+  }
+  let start = 0;
+  while (start < out.length && isPadChar(out[start])) start++;
+  let end = out.length;
+  while (end > start && isPadChar(out[end - 1])) end--;
+  const safe = out.slice(start, end);
+  return safe || null;
+}
+
+let cachedAppName = null;
+function getDefaultAppName() {
+  if (cachedAppName) return cachedAppName;
+  try {
+    const pkgPath = path.resolve(process.cwd(), 'package.json');
+    const raw = fs.readFileSync(pkgPath, 'utf8');
+    cachedAppName = sanitizeAppName(JSON.parse(raw)?.name) ?? 'application';
+  } catch {
+    cachedAppName = 'application';
+  }
+  return cachedAppName;
+}
+
+function resolveRunNumber(folder, prefix, opt) {
+  let enabled = false;
+  let separator = '-';
+  let padding = 0;
+  let startAt = 1;
+  if (opt === true) {
+    enabled = true;
+  } else if (opt && typeof opt === 'object') {
+    enabled = opt.enabled ?? true;
+    if (opt.separator !== undefined) {
+      if (typeof opt.separator !== 'string' || !opt.separator) throw new Error('files.runNumber.separator must be a non-empty string');
+      separator = opt.separator;
+    }
+    if (opt.padding !== undefined) {
+      if (!Number.isInteger(opt.padding) || opt.padding < 0) throw new Error('files.runNumber.padding must be a non-negative integer');
+      padding = opt.padding;
     }
+    if (opt.startAt !== undefined) {
+      if (!Number.isInteger(opt.startAt) || opt.startAt < 0) throw new Error('files.runNumber.startAt must be a non-negative integer');
+      startAt = opt.startAt;
+    }
+  } else if (opt !== undefined && opt !== false) {
+    throw new Error('files.runNumber must be a boolean or an object');
+  }
+  if (!enabled) return null;
+  const counterFile = path.join(folder, `.${prefix}.run`);
+  let next = startAt;
+  try {
+    const raw = fs.readFileSync(counterFile, 'utf8').trim();
+    const prev = parseInt(raw, 10);
+    next = Number.isInteger(prev) ? prev + 1 : startAt;
+  } catch {}
+  try {
+    fs.writeFileSync(counterFile, String(next), 'utf8');
+  } catch {}
+  return separator + String(next).padStart(padding, '0');
+}
+
+function normalizeFilesOptions(files = {}) {
+  const rawFolder = files.folder ?? 'logs';
+  if (typeof rawFolder !== 'string' || !rawFolder.trim() || rawFolder.includes('\0')) {
+    throw new Error('files.folder must be a non-empty string');
+  }
+  const folder = path.normalize(rawFolder);
+  const datePattern = files.datePattern ?? files.dateFormat ?? files.filesName ?? 'YYYY_MM_DD';
+  if (typeof datePattern !== 'string' || !datePattern.trim()) {
+    throw new Error('files.datePattern must be a non-empty string');
+  }
+  const explicitPattern = files.filePattern ?? files.pattern ?? files.filename;
+  const explicitPrefix = files.prefix ?? files.appName;
+  if (explicitPattern !== undefined && explicitPrefix !== undefined) {
+    throw new Error('Do not combine "prefix" with "filePattern", pick one: prefix builds "<prefix>-%DATE%.log" for you, filePattern takes full control');
+  }
+  let filename = explicitPattern ?? `${sanitizeAppName(explicitPrefix) ?? getDefaultAppName()}-%DATE%.log`;
+  filename = filename.split('%datePattern%').join('%DATE%');
+  assertFilenameSafe(filename);
+  if (!filename.includes('%DATE%')) {
+    const ext = path.extname(filename) || '.log';
+    const base = path.basename(filename, ext);
+    filename = `${base}-%DATE%${ext}`;
+  }
+  assertFilenameSafe(filename);
+  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+  const rawPrefix = path.basename(filename).split('%DATE%')[0];
+  let prefixEnd = rawPrefix.length;
+  while (prefixEnd > 0 && isPadChar(rawPrefix[prefixEnd - 1])) prefixEnd--;
+  const prefix = rawPrefix.slice(0, prefixEnd) || 'application';
+  const runSuffix = resolveRunNumber(folder, sanitizeAppName(prefix) ?? 'application', files.runNumber ?? false);
+  if (runSuffix) {
+    const ext = path.extname(filename) || '.log';
+    const base = filename.slice(0, -ext.length);
+    filename = `${base}${runSuffix}${ext}`;
+  }
+  return {
+    folder,
+    datePattern,
+    filename,
+    maxFiles: files.maxFile ?? files.maxFiles ?? '14d',
+    maxSize: files.maxSize ?? '20m',
+    zippedArchive: files.zippedArchive ?? false,
+    level: files.level,
+  };
 }
 
-/**
- * Logs a general message using the info level.
- *
- * @param {string} message - The message to be logged.
- */
-function log(message) {
-    logger.info(message);
+function buildConsoleTransport({ enableTimestamp = true, timestampFormat = DEFAULT_CONSOLE_FORMAT, timestampPrefix = '', timestampSuffix = '', colorize = true, level } = {}) {
+  const parts = [];
+  if (colorize) parts.push(format.colorize());
+  if (enableTimestamp) {
+    const stamp = compileTimestampFormatter(timestampFormat);
+    parts.push(format.timestamp({ format: () => `${timestampPrefix}${stamp()}${timestampSuffix}` }));
+  } else {
+    parts.push(format((info) => { delete info.timestamp; return info; })());
+  }
+  parts.push(format.errors({ stack: true }), format.splat(), prettyFormat);
+  return new transports.Console({ format: format.combine(...parts), level });
 }
 
-log.error = function (message) {
-    logger.error(message);
-};
+function buildFileTransport({ folder, datePattern, filename, maxFiles, maxSize, zippedArchive, level }) {
+  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+  return new transports.DailyRotateFile({
+    filename: path.join(folder, filename),
+    datePattern,
+    zippedArchive,
+    maxSize,
+    maxFiles,
+    level,
+    format: format.combine(format.errors({ stack: true }), format.splat(), format.timestamp(), prettyFormat),
+  });
+}
 
-log.warn = function (message) {
-    logger.warn(message);
-};
+function createLoggerInstance(initial = {}) {
+  const globalLevel = process.env.LOG_LEVEL || initial.level || 'debug';
+  assertLevel(globalLevel);
 
-log.info = function (message) {
-    logger.info(message);
-};
+  const logger = createLogger({
+    level: globalLevel,
+    format: format.combine(format.errors({ stack: true }), format.splat()),
+  });
 
-log.debug = function (message) {
-    logger.debug(message);
-};
+  let consoleTransport = buildConsoleTransport(initial.console);
+  consoleTransport.level = initial.console?.level;
+  logger.add(consoleTransport);
 
-// Expose the settings function for configuring both file logging and console output.
-log.settings = applySettings;
+  let fileTransport = null;
+  let consoleOpts = { ...(initial.console || {}) };
+  let filesOpts = null;
+
+  function applySettings(options = {}) {
+    if (options.level !== undefined) {
+      assertLevel(options.level);
+      logger.level = options.level;
+    }
+    if (options.console) {
+      if (options.console.level !== undefined && options.console.level !== null) assertLevel(options.console.level);
+      consoleOpts = { ...consoleOpts, ...options.console };
+      logger.remove(consoleTransport);
+      consoleTransport = buildConsoleTransport(consoleOpts);
+      consoleTransport.level = consoleOpts.level;
+      logger.add(consoleTransport);
+    }
+    if (options.files) {
+      const normalized = normalizeFilesOptions(options.files);
+      if (normalized.level !== undefined && normalized.level !== null) assertLevel(normalized.level);
+      filesOpts = normalized;
+      if (fileTransport) logger.remove(fileTransport);
+      fileTransport = buildFileTransport(normalized);
+      logger.add(fileTransport);
+    }
+  }
+
+  function isEnabled(level) {
+    const want = logger.levels[level];
+    const current = logger.levels[logger.level];
+    return want !== undefined && current !== undefined && want <= current;
+  }
+
+  function write(level, message, ...meta) {
+    if (typeof message === 'function') {
+      if (!isEnabled(level)) return;
+      message = message();
+    }
+    if (message instanceof Error) {
+      logger.log(level, sanitizeMessage(message.message), { stack: message.stack, ...meta[0] });
+      return;
+    }
+    logger.log(level, sanitizeMessage(message), ...meta);
+  }
+
+  function callable(message, ...meta) {
+    write('info', message, ...meta);
+  }
+
+  callable.error = (m, ...a) => write('error', m, ...a);
+  callable.warn = (m, ...a) => write('warn', m, ...a);
+  callable.info = (m, ...a) => write('info', m, ...a);
+  callable.debug = (m, ...a) => write('debug', m, ...a);
+  callable.http = (m, ...a) => write('http', m, ...a);
+  callable.verbose = (m, ...a) => write('verbose', m, ...a);
+  callable.silly = (m, ...a) => write('silly', m, ...a);
+  callable.log = (level, m, ...a) => { assertLevel(level); write(level, m, ...a); };
+
+  callable.settings = applySettings;
+  callable.setLevel = (level) => { assertLevel(level); logger.level = level; };
+  callable.getLevel = () => logger.level;
+  callable.child = (meta = {}) => {
+    const child = logger.child(meta);
+    return {
+      error: (m, ...a) => child.error(m, ...a),
+      warn: (m, ...a) => child.warn(m, ...a),
+      info: (m, ...a) => child.info(m, ...a),
+      debug: (m, ...a) => child.debug(m, ...a),
+      log: child.log.bind(child),
+    };
+  };
+  callable.close = () => {
+    if (fileTransport) { logger.remove(fileTransport); try { fileTransport.close?.(); } catch {} fileTransport = null; }
+  };
+  callable.createLogger = (opts = {}) => createLoggerInstance(opts);
+  callable._winston = logger;
+
+  if (initial.files) applySettings({ files: initial.files });
+  if (initial.console || initial.level) applySettings({ console: initial.console, level: initial.level });
+
+  return callable;
+}
 
-module.exports = log;
+module.exports = createLoggerInstance();
+module.exports.createLogger = createLoggerInstance;

package/main.mjs

@@ -0,0 +1,14 @@
+import log from './main.js';
+
+export const settings = log.settings;
+export const setLevel = log.setLevel;
+export const getLevel = log.getLevel;
+export const child = log.child;
+export const close = log.close;
+export const createLogger = log.createLogger;
+export const error = log.error;
+export const warn = log.warn;
+export const info = log.info;
+export const debug = log.debug;
+
+export default log;

package/package.json

@@ -1,14 +1,63 @@
 {
   "name": "logxpert",
-  "version": "1.0.5",
-  "description": "A powerful logging library for Node.js",
+  "version": "2.0.3",
+  "description": "A powerful logging library for Node.js with colorful output and daily file rotation",
   "main": "main.js",
-  "repository": "git+https://github.com/lighscent/LogXpert.git",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./main.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./main.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "main.js",
+    "main.mjs",
+    "index.d.ts",
+    "index.d.mts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lighscent/LogXpert.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lighscent/LogXpert/issues"
+  },
+  "homepage": "https://github.com/lighscent/LogXpert#readme",
   "author": "https://github.com/lighscent",
-  "license": "MIT",
+  "license": "Apache-2.0",
+  "keywords": [
+    "logging",
+    "logger",
+    "winston",
+    "daily-rotate",
+    "nodejs"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/logger.test.js",
+    "check:types": "tsc -p test-d --noEmit",
+    "attw": "attw --pack"
+  },
   "dependencies": {
-    "moment": "^2.30.1",
+    "dayjs": "^1.11.23",
     "winston": "^3.19.0",
     "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "typescript": "^7.0.2"
   }
-}
+}