@oxog/log 1.0.0

package/dist/transports/index.js

@@ -0,0 +1,809 @@
+// src/constants.ts
+var LOG_LEVELS = {
+  trace: 10 /* Trace */,
+  debug: 20 /* Debug */,
+  info: 30 /* Info */,
+  warn: 40 /* Warn */,
+  error: 50 /* Error */,
+  fatal: 60 /* Fatal */
+};
+var LEVEL_NAMES = {
+  [10 /* Trace */]: "trace",
+  [20 /* Debug */]: "debug",
+  [30 /* Info */]: "info",
+  [40 /* Warn */]: "warn",
+  [50 /* Error */]: "error",
+  [60 /* Fatal */]: "fatal"
+};
+var LEVEL_COLORS = {
+  trace: "gray",
+  debug: "cyan",
+  info: "blue",
+  warn: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+var LEVEL_LABELS = {
+  trace: "TRACE",
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR",
+  fatal: "FATAL"
+};
+function parseSize(size) {
+  const match = size.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)?$/i);
+  if (!match) {
+    throw new Error(`Invalid size format: ${size}`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "B").toUpperCase();
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+    TB: 1024 * 1024 * 1024 * 1024
+  };
+  return Math.floor(value * (units[unit] ?? 1));
+}
+function parseRotation(rotation) {
+  const match = rotation.match(/^(\d+)\s*(s|m|h|d|w)?$/i);
+  if (!match) {
+    throw new Error(`Invalid rotation format: ${rotation}`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = (match[2] || "s").toLowerCase();
+  const units = {
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3,
+    w: 7 * 24 * 60 * 60 * 1e3
+  };
+  return value * (units[unit] ?? 1e3);
+}
+var IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var IS_BROWSER = typeof window !== "undefined" && typeof window.document !== "undefined";
+var IS_DEV = IS_NODE && process.env["NODE_ENV"] !== "production";
+var IS_TTY = IS_NODE && process.stdout?.isTTY === true;
+
+// src/utils/format.ts
+function formatJson(entry) {
+  return JSON.stringify(entry, jsonReplacer);
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Error) {
+    const errorObj = value;
+    const result = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+    for (const key of Object.keys(errorObj)) {
+      if (!(key in result)) {
+        result[key] = errorObj[key];
+      }
+    }
+    return result;
+  }
+  if (typeof value === "object" && value !== null) {
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof Map) {
+      return Object.fromEntries(value);
+    }
+    if (value instanceof Set) {
+      return Array.from(value);
+    }
+  }
+  return value;
+}
+function safeStringify(value, indent) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    value,
+    (_key, val) => {
+      const replaced = jsonReplacer(_key, val);
+      if (typeof replaced === "object" && replaced !== null) {
+        if (seen.has(replaced)) {
+          return "[Circular]";
+        }
+        seen.add(replaced);
+      }
+      return replaced;
+    },
+    indent
+  );
+}
+function formatPretty(entry, pigment, options = {}) {
+  const parts = [];
+  const { timestamp = true, source = true } = options;
+  if (timestamp && entry.time) {
+    const time = formatTime(entry.time);
+    parts.push(pigment ? pigment.gray(`[${time}]`) : `[${time}]`);
+  }
+  const levelLabel = LEVEL_LABELS[entry.levelName] || entry.levelName.toUpperCase();
+  const levelColor = LEVEL_COLORS[entry.levelName] || "white";
+  if (pigment) {
+    const colorFn = pigment[levelColor];
+    parts.push(colorFn ? colorFn(levelLabel) : levelLabel);
+  } else {
+    parts.push(levelLabel);
+  }
+  if (source && entry.file) {
+    const location = entry.line ? `${entry.file}:${entry.line}` : entry.file;
+    parts.push(pigment ? pigment.dim(`(${location})`) : `(${location})`);
+  }
+  if (entry.msg) {
+    parts.push(entry.msg);
+  }
+  const extra = getExtraFields(entry);
+  if (Object.keys(extra).length > 0) {
+    const extraStr = safeStringify(extra);
+    parts.push(pigment ? pigment.dim(extraStr) : extraStr);
+  }
+  if (entry.err?.stack) {
+    parts.push("\n" + (pigment ? pigment.red(entry.err.stack) : entry.err.stack));
+  }
+  return parts.join(" ");
+}
+function getExtraFields(entry) {
+  const standardFields = /* @__PURE__ */ new Set([
+    "level",
+    "levelName",
+    "time",
+    "msg",
+    "file",
+    "line",
+    "column",
+    "correlationId",
+    "duration",
+    "err",
+    "name"
+  ]);
+  const extra = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (!standardFields.has(key)) {
+      extra[key] = value;
+    }
+  }
+  return extra;
+}
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+
+// src/utils/env.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isTTY() {
+  if (!isNode()) return false;
+  return process.stdout?.isTTY === true;
+}
+function shouldUseColors() {
+  if (isBrowser()) return true;
+  if (!isNode()) return false;
+  if (process.env["NO_COLOR"] !== void 0) return false;
+  if (process.env["FORCE_COLOR"] !== void 0) return true;
+  if (process.env["CI"] !== void 0) return true;
+  return isTTY();
+}
+
+// src/transports/console.ts
+var DEFAULT_LEVEL_COLORS = {
+  trace: "gray",
+  debug: "cyan",
+  info: "blue",
+  warn: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+function consoleTransport(options = {}) {
+  const {
+    colors = shouldUseColors(),
+    timestamp = true,
+    levelColors = {}
+  } = options;
+  const mergedColors = { ...DEFAULT_LEVEL_COLORS, ...levelColors };
+  let pigment;
+  return {
+    name: "console",
+    write(entry) {
+      let output;
+      if (isBrowser()) {
+        writeToBrowserConsole(entry, colors);
+        return;
+      }
+      if (colors && pigment) {
+        output = formatPretty(entry, pigment, { timestamp, source: true });
+      } else if (colors) {
+        output = formatWithAnsi(entry, mergedColors, timestamp);
+      } else {
+        output = formatJson(entry);
+      }
+      if (entry.level >= 50) {
+        process.stderr.write(output + "\n");
+      } else {
+        process.stdout.write(output + "\n");
+      }
+    },
+    flush() {
+    },
+    close() {
+    },
+    supports(env) {
+      return true;
+    }
+  };
+}
+function formatWithAnsi(entry, levelColors, showTimestamp) {
+  const parts = [];
+  if (showTimestamp && entry.time) {
+    const time = formatTime2(entry.time);
+    parts.push(`\x1B[90m[${time}]\x1B[0m`);
+  }
+  const color = getAnsiColor(levelColors[entry.levelName] || "white");
+  const levelLabel = entry.levelName.toUpperCase().padEnd(5);
+  parts.push(`${color}${levelLabel}\x1B[0m`);
+  if (entry.file) {
+    const location = entry.line ? `${entry.file}:${entry.line}` : entry.file;
+    parts.push(`\x1B[90m(${location})\x1B[0m`);
+  }
+  if (entry.msg) {
+    parts.push(entry.msg);
+  }
+  const extra = getExtraFields2(entry);
+  if (Object.keys(extra).length > 0) {
+    parts.push(`\x1B[90m${JSON.stringify(extra)}\x1B[0m`);
+  }
+  if (entry.err?.stack) {
+    parts.push("\n\x1B[31m" + entry.err.stack + "\x1B[0m");
+  }
+  return parts.join(" ");
+}
+function getAnsiColor(colorName) {
+  const colors = {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m",
+    gray: "\x1B[90m",
+    grey: "\x1B[90m"
+  };
+  return colors[colorName] || "\x1B[0m";
+}
+function formatTime2(timestamp) {
+  const date = new Date(timestamp);
+  return date.toTimeString().slice(0, 8);
+}
+function getExtraFields2(entry) {
+  const standardFields = /* @__PURE__ */ new Set([
+    "level",
+    "levelName",
+    "time",
+    "msg",
+    "file",
+    "line",
+    "column",
+    "correlationId",
+    "duration",
+    "err",
+    "name"
+  ]);
+  const extra = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (!standardFields.has(key)) {
+      extra[key] = value;
+    }
+  }
+  return extra;
+}
+function writeToBrowserConsole(entry, styled) {
+  const method = getConsoleMethod(entry.levelName);
+  const consoleObj = console;
+  if (styled) {
+    const styles = getBrowserStyles(entry.levelName);
+    const label = `%c[${entry.levelName.toUpperCase()}]`;
+    const extra = getExtraFields2(entry);
+    if (Object.keys(extra).length > 0) {
+      consoleObj[method](label, styles, entry.msg, extra);
+    } else {
+      consoleObj[method](label, styles, entry.msg);
+    }
+  } else {
+    consoleObj[method](`[${entry.levelName.toUpperCase()}]`, entry.msg, entry);
+  }
+}
+function getConsoleMethod(levelName) {
+  switch (levelName) {
+    case "trace":
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+    case "fatal":
+      return "error";
+    default:
+      return "log";
+  }
+}
+function getBrowserStyles(levelName) {
+  const colors = {
+    trace: "#888888",
+    debug: "#00bcd4",
+    info: "#2196f3",
+    warn: "#ff9800",
+    error: "#f44336",
+    fatal: "#9c27b0"
+  };
+  return `color: ${colors[levelName]}; font-weight: bold;`;
+}
+
+// src/errors.ts
+var LogError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original error if wrapping another error */
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "LogError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var TransportError = class extends LogError {
+  /** Name of the transport that caused the error */
+  transportName;
+  constructor(message, transportName, cause) {
+    super(`[Transport: ${transportName}] ${message}`, "TRANSPORT_ERROR", cause);
+    this.name = "TransportError";
+    this.transportName = transportName;
+  }
+};
+var EnvironmentError = class extends LogError {
+  /** Required environment */
+  requiredEnv;
+  constructor(message, requiredEnv, cause) {
+    super(message, "ENVIRONMENT_ERROR", cause);
+    this.name = "EnvironmentError";
+    this.requiredEnv = requiredEnv;
+  }
+};
+
+// src/transports/file.ts
+function fileTransport(options) {
+  if (!isNode()) {
+    throw new EnvironmentError("File transport is only available in Node.js", "node");
+  }
+  const {
+    path: filePath,
+    rotate,
+    maxSize,
+    maxFiles = 5,
+    compress = false
+  } = options;
+  const maxSizeBytes = maxSize ? parseSize(maxSize) : void 0;
+  const rotationMs = rotate ? parseRotation(rotate) : void 0;
+  let currentSize = 0;
+  let lastRotation = Date.now();
+  let writeStream = null;
+  let fs = null;
+  let path = null;
+  let zlib = null;
+  async function ensureModules() {
+    if (!fs) {
+      fs = await import("fs");
+      path = await import("path");
+      if (compress) {
+        zlib = await import("zlib");
+      }
+    }
+  }
+  async function ensureStream() {
+    await ensureModules();
+    if (!writeStream) {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      if (fs.existsSync(filePath)) {
+        const stats = fs.statSync(filePath);
+        currentSize = stats.size;
+      }
+      writeStream = fs.createWriteStream(filePath, { flags: "a" });
+    }
+    return writeStream;
+  }
+  function shouldRotate() {
+    if (maxSizeBytes && currentSize >= maxSizeBytes) {
+      return true;
+    }
+    if (rotationMs && Date.now() - lastRotation >= rotationMs) {
+      return true;
+    }
+    return false;
+  }
+  async function performRotation() {
+    await ensureModules();
+    if (!writeStream) return;
+    await new Promise((resolve, reject) => {
+      writeStream.once("finish", resolve);
+      writeStream.once("error", reject);
+      writeStream.end();
+    });
+    writeStream = null;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const ext = path.extname(filePath);
+    const base = filePath.slice(0, -ext.length);
+    const rotatedPath = `${base}.${timestamp}${ext}`;
+    fs.renameSync(filePath, rotatedPath);
+    if (compress && zlib) {
+      const gzPath = `${rotatedPath}.gz`;
+      const input = fs.createReadStream(rotatedPath);
+      const output = fs.createWriteStream(gzPath);
+      const gzip = zlib.createGzip();
+      await new Promise((resolve, reject) => {
+        input.pipe(gzip).pipe(output);
+        output.on("finish", () => {
+          fs.unlinkSync(rotatedPath);
+          resolve();
+        });
+        output.on("error", reject);
+      });
+    }
+    await cleanupOldFiles();
+    currentSize = 0;
+    lastRotation = Date.now();
+  }
+  async function cleanupOldFiles() {
+    await ensureModules();
+    const dir = path.dirname(filePath);
+    const baseName = path.basename(filePath);
+    const ext = path.extname(filePath);
+    const prefix = baseName.slice(0, -ext.length);
+    const files = fs.readdirSync(dir).filter((f) => f.startsWith(prefix) && f !== baseName).map((f) => ({
+      name: f,
+      path: path.join(dir, f),
+      mtime: fs.statSync(path.join(dir, f)).mtime.getTime()
+    })).sort((a, b) => b.mtime - a.mtime);
+    while (files.length > maxFiles) {
+      const file = files.pop();
+      fs.unlinkSync(file.path);
+    }
+  }
+  return {
+    name: "file",
+    async write(entry) {
+      if (shouldRotate()) {
+        await performRotation();
+      }
+      const stream = await ensureStream();
+      const line = formatJson(entry) + "\n";
+      const bytes = Buffer.byteLength(line, "utf8");
+      return new Promise((resolve, reject) => {
+        stream.write(line, (err) => {
+          if (err) {
+            reject(new TransportError(`Failed to write to file: ${err.message}`, "file", err));
+          } else {
+            currentSize += bytes;
+            resolve();
+          }
+        });
+      });
+    },
+    async flush() {
+      if (writeStream && "flush" in writeStream) {
+        return new Promise((resolve) => {
+          writeStream.flush(resolve);
+        });
+      }
+    },
+    async close() {
+      if (writeStream) {
+        await new Promise((resolve, reject) => {
+          writeStream.once("finish", resolve);
+          writeStream.once("error", reject);
+          writeStream.end();
+        });
+        writeStream = null;
+      }
+    },
+    supports(env) {
+      return env === "node";
+    }
+  };
+}
+
+// src/transports/stream.ts
+function streamTransport(options) {
+  if (!isNode()) {
+    throw new EnvironmentError("Stream transport is only available in Node.js", "node");
+  }
+  const { stream } = options;
+  if (!stream) {
+    throw new TransportError("Stream is required", "stream");
+  }
+  let closed = false;
+  return {
+    name: "stream",
+    write(entry) {
+      if (closed) {
+        return Promise.reject(new TransportError("Stream is closed", "stream"));
+      }
+      const line = formatJson(entry) + "\n";
+      return new Promise((resolve, reject) => {
+        const canWrite = stream.write(line, (err) => {
+          if (err) {
+            reject(new TransportError(`Failed to write to stream: ${err.message}`, "stream", err));
+          } else {
+            resolve();
+          }
+        });
+        if (!canWrite) {
+          stream.once("drain", () => {
+            resolve();
+          });
+        }
+      });
+    },
+    flush() {
+      return Promise.resolve();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      return new Promise((resolve, reject) => {
+        stream.once("finish", resolve);
+        stream.once("error", (err) => {
+          reject(new TransportError(`Failed to close stream: ${err.message}`, "stream", err));
+        });
+        stream.end();
+      });
+    },
+    supports(env) {
+      return env === "node";
+    }
+  };
+}
+
+// src/transports/http.ts
+function httpTransport(options) {
+  const {
+    url,
+    method = "POST",
+    headers = {},
+    batch = 100,
+    interval = 5e3,
+    retry = 3
+  } = options;
+  if (!url) {
+    throw new TransportError("URL is required", "http");
+  }
+  let buffer = [];
+  let flushTimer = null;
+  let isFlushing = false;
+  let closed = false;
+  function startFlushInterval() {
+    if (flushTimer) return;
+    if (interval > 0) {
+      flushTimer = setInterval(() => {
+        flushBuffer().catch(() => {
+        });
+      }, interval);
+    }
+  }
+  function stopFlushInterval() {
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+  }
+  async function flushBuffer() {
+    if (isFlushing || buffer.length === 0) return;
+    isFlushing = true;
+    const entries = buffer;
+    buffer = [];
+    try {
+      await sendWithRetry(entries);
+    } catch (err) {
+      buffer = [...entries, ...buffer].slice(0, batch * 2);
+      throw err;
+    } finally {
+      isFlushing = false;
+    }
+  }
+  async function sendWithRetry(entries) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= retry; attempt++) {
+      try {
+        await sendEntries(entries);
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < retry) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          await sleep(delay);
+        }
+      }
+    }
+    throw new TransportError(
+      `Failed to send logs after ${retry + 1} attempts: ${lastError?.message}`,
+      "http",
+      lastError || void 0
+    );
+  }
+  async function sendEntries(entries) {
+    const body = JSON.stringify(entries);
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  let started = false;
+  return {
+    name: "http",
+    async write(entry) {
+      if (closed) {
+        throw new TransportError("Transport is closed", "http");
+      }
+      if (!started) {
+        started = true;
+        startFlushInterval();
+      }
+      buffer.push(entry);
+      if (buffer.length >= batch) {
+        await flushBuffer();
+      }
+    },
+    async flush() {
+      await flushBuffer();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      stopFlushInterval();
+      if (buffer.length > 0) {
+        try {
+          await flushBuffer();
+        } catch {
+        }
+      }
+    },
+    supports(_env) {
+      return typeof fetch !== "undefined";
+    }
+  };
+}
+
+// src/transports/localStorage.ts
+function localStorageTransport(options) {
+  if (!isBrowser()) {
+    throw new EnvironmentError("LocalStorage transport is only available in browser", "browser");
+  }
+  const {
+    key,
+    maxSize = "1MB",
+    levels
+  } = options;
+  if (!key) {
+    throw new TransportError("Key is required", "localStorage");
+  }
+  const maxBytes = parseSize(maxSize);
+  const allowedLevels = levels ? new Set(levels.map((l) => LOG_LEVELS[l])) : null;
+  function getStorage() {
+    return window.localStorage;
+  }
+  function loadLogs() {
+    try {
+      const data = getStorage().getItem(key);
+      if (!data) return [];
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  function saveLogs(logs) {
+    const data = JSON.stringify(logs);
+    while (data.length > maxBytes && logs.length > 0) {
+      logs.shift();
+    }
+    try {
+      getStorage().setItem(key, JSON.stringify(logs));
+    } catch (err) {
+      if (logs.length > 10) {
+        logs.splice(0, Math.floor(logs.length / 2));
+        saveLogs(logs);
+      }
+    }
+  }
+  function isLevelAllowed(level) {
+    if (!allowedLevels) return true;
+    return allowedLevels.has(level);
+  }
+  return {
+    name: "localStorage",
+    write(entry) {
+      if (!isLevelAllowed(entry.level)) {
+        return;
+      }
+      const logs = loadLogs();
+      logs.push(entry);
+      saveLogs(logs);
+    },
+    flush() {
+    },
+    close() {
+    },
+    supports(env) {
+      return env === "browser";
+    }
+  };
+}
+function readLogs(key) {
+  if (!isBrowser()) return [];
+  try {
+    const data = window.localStorage.getItem(key);
+    if (!data) return [];
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function clearLogs(key) {
+  if (!isBrowser()) return;
+  window.localStorage.removeItem(key);
+}
+function getStorageUsage(key) {
+  if (!isBrowser()) return 0;
+  const data = window.localStorage.getItem(key);
+  if (!data) return 0;
+  return data.length * 2;
+}
+export {
+  clearLogs,
+  consoleTransport,
+  fileTransport,
+  getStorageUsage,
+  httpTransport,
+  localStorageTransport,
+  readLogs,
+  streamTransport
+};
+//# sourceMappingURL=index.js.map