@devshub198211/devguard 2.0.1

package/dist/chunk-6IXDDYYA.js

@@ -0,0 +1,345 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+import * as os from 'os';
+
+// src/dx/env-safe.ts
+function parseDotenv(content) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (typeof content !== "string") return result;
+  const lines = content.split(/\r?\n/);
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = line.slice(0, eqIdx).trim();
+    let val = line.slice(eqIdx + 1).trim();
+    if (!key || key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (!/^[a-zA-Z_][a-zA-Z0-9_.]*$/.test(key)) continue;
+    if (!val.startsWith('"') && !val.startsWith("'")) {
+      val = val.split(/\s+#/)[0].trim();
+    }
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	");
+    }
+    result[key] = val;
+  }
+  return result;
+}
+function loadDotenvFile(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) return /* @__PURE__ */ Object.create(null);
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile() || stat.size > 1 * 1024 * 1024) return /* @__PURE__ */ Object.create(null);
+    return parseDotenv(fs.readFileSync(resolved, "utf-8"));
+  } catch {
+    return /* @__PURE__ */ Object.create(null);
+  }
+}
+function coerce(key, raw, spec) {
+  const val = raw.trim();
+  if (spec.type === "string") {
+    if (spec.minLength !== void 0 && val.length < spec.minLength) throw new Error(`${key}: too short (min ${spec.minLength} chars)`);
+    if (spec.maxLength !== void 0 && val.length > spec.maxLength) throw new Error(`${key}: too long (max ${spec.maxLength} chars)`);
+    if (spec.enum && !spec.enum.includes(val)) throw new Error(`${key}: must be one of [${spec.enum.join(", ")}]`);
+    if (spec.regex && !spec.regex.test(val)) throw new Error(`${key}: does not match expected pattern`);
+    return val;
+  }
+  if (spec.type === "number" || spec.type === "integer") {
+    const n = spec.type === "integer" ? parseInt(val, 10) : parseFloat(val);
+    if (isNaN(n)) throw new Error(`${key}: expected ${spec.type}`);
+    if (!isFinite(n)) throw new Error(`${key}: value must be finite`);
+    if (spec.min !== void 0 && n < spec.min) throw new Error(`${key}: too small (min ${spec.min})`);
+    if (spec.max !== void 0 && n > spec.max) throw new Error(`${key}: too large (max ${spec.max})`);
+    return n;
+  }
+  if (spec.type === "boolean") {
+    if (["true", "1", "yes", "on"].includes(val.toLowerCase())) return true;
+    if (["false", "0", "no", "off"].includes(val.toLowerCase())) return false;
+    throw new Error(`${key}: expected boolean (true/false/1/0/yes/no)`);
+  }
+  if (spec.type === "url") {
+    try {
+      new URL(val);
+      return val;
+    } catch {
+      throw new Error(`${key}: invalid URL`);
+    }
+  }
+  if (spec.type === "email") {
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val)) throw new Error(`${key}: invalid email`);
+    return val;
+  }
+  if (spec.type === "json") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      throw new Error(`${key}: invalid JSON`);
+    }
+  }
+  if (spec.type === "csv") {
+    return val.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return val;
+}
+function parseEnv(schema, source = process.env) {
+  const errors = [];
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [key, spec] of Object.entries(schema)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const raw = source[key] ?? spec.default;
+    const isRequired = spec.required !== false && spec.default === void 0;
+    if (raw === void 0 || raw === "") {
+      if (isRequired) {
+        const hint = spec.example ? ` (example: ${spec.example})` : "";
+        const desc = spec.description ? ` \u2014 ${spec.description}` : "";
+        errors.push(`  \u2717 ${key}: required but missing${desc}${hint}`);
+      }
+      continue;
+    }
+    try {
+      result[key] = coerce(key, raw, spec);
+    } catch (e) {
+      const errorMsg = e.message ?? "validation failed";
+      if (spec.secret) {
+        errors.push(`  \u2717 ${key}: ${errorMsg}`);
+      } else {
+        errors.push(`  \u2717 ${errorMsg} (got: "${raw}")`);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    const msg = `
+\u{1F6A8} env-safe: ${errors.length} environment variable error(s):
+
+${errors.join("\n")}
+
+Fix these in your .env file before starting.
+`;
+    throw new Error(msg);
+  }
+  return result;
+}
+function loadEnv(schema, opts) {
+  const { envFiles = [".env", ".env.local"], override = false } = opts ?? {};
+  const merged = /* @__PURE__ */ Object.create(null);
+  for (const file of envFiles) {
+    if (typeof file !== "string") continue;
+    const fullPath = path.resolve(process.cwd(), file);
+    const parsed = loadDotenvFile(fullPath);
+    for (const [k, v] of Object.entries(parsed)) {
+      if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+      if (override || !(k in merged)) merged[k] = v;
+    }
+  }
+  const combined = { ...merged };
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+    if (override || !(k in merged)) combined[k] = v;
+  }
+  return parseEnv(schema, combined);
+}
+function generateExample(schema) {
+  const lines = ["# Generated by devguard env-safe", ""];
+  for (const [key, spec] of Object.entries(schema)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (spec.description) lines.push(`# ${spec.description}`);
+    const hint = spec.example ?? (spec.enum ? spec.enum[0] : spec.type.toUpperCase());
+    const req = spec.required !== false && !spec.default ? " (required)" : spec.default ? ` (default: ${spec.default})` : "";
+    lines.push(`# Type: ${spec.type}${req}`);
+    lines.push(`${key}=${hint}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var LEVEL_NUM = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 };
+var LEVEL_COLOR = { trace: "\x1B[90m", debug: "\x1B[36m", info: "\x1B[32m", warn: "\x1B[33m", error: "\x1B[31m", fatal: "\x1B[35m" };
+var RESET = "\x1B[0m";
+var PROTECTED_FIELDS = /* @__PURE__ */ new Set(["level", "levelNum", "msg", "time", "pid", "hostname"]);
+function redactValue(val) {
+  if (typeof val === "string" && val.length > 4) return val.slice(0, 2) + "****";
+  return "****";
+}
+function safeStringify(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(obj, (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      if (typeof value === "bigint") return value.toString();
+      return value;
+    });
+  } catch {
+    return '"[Unserializable]"';
+  }
+}
+var OTLPExporter = class {
+  constructor(cfg) {
+    this.batch = [];
+    this._warnCount = 0;
+    this._isFlushing = false;
+    this.timer = null;
+    this.cfg = { headers: {}, batchSize: 100, flushIntervalMs: 5e3, ...cfg };
+    try {
+      new URL(this.cfg.endpoint);
+    } catch {
+      throw new Error(`Invalid OTLP endpoint URL: ${cfg.endpoint}`);
+    }
+    this.timer = setInterval(() => this.flush(), this.cfg.flushIntervalMs);
+    if (this.timer.unref) this.timer.unref();
+  }
+  push(record) {
+    this.batch.push(record);
+    if (this.batch.length >= this.cfg.batchSize) this.flush();
+  }
+  flush() {
+    if (this.batch.length === 0) return;
+    if (this._isFlushing) return;
+    this._isFlushing = true;
+    const records = this.batch.splice(0);
+    try {
+      const body = JSON.stringify({ resourceLogs: [{ resource: {}, scopeLogs: [{ logRecords: records.map((r) => ({
+        timeUnixNano: String(Date.parse(r.time) * 1e6),
+        severityNumber: r.levelNum,
+        severityText: r.level.toUpperCase(),
+        body: { stringValue: r.msg },
+        attributes: Object.entries(r).filter(([k]) => !PROTECTED_FIELDS.has(k)).map(([k, v]) => ({ key: k, value: { stringValue: String(v) } }))
+      })) }] }] });
+      const url = new URL(this.cfg.endpoint);
+      const lib = url.protocol === "https:" ? https : http;
+      const req = lib.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.cfg.headers }
+      });
+      req.on("error", (e) => {
+        if (this._warnCount++ < 3) {
+          process.stderr.write(`[devguard/log-otlp] OTLP export failed: ${e.message} (further errors suppressed)
+`);
+        }
+      });
+      req.write(body);
+      req.end();
+    } finally {
+      this._isFlushing = false;
+    }
+  }
+  destroy() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.flush();
+  }
+};
+var _hostname = os.hostname();
+var Logger = class _Logger {
+  constructor(opts, bindings = {}) {
+    this.opts = opts;
+    this.minLevel = LEVEL_NUM[opts.level ?? "info"];
+    this.redactSet = new Set(opts.redact ?? []);
+    this.exporter = opts.otlp ? new OTLPExporter(opts.otlp) : null;
+    this.dest = opts.destination ?? process.stdout;
+    this.bindings = bindings;
+  }
+  log(level, msg, data) {
+    if (LEVEL_NUM[level] < this.minLevel) return;
+    if (this.opts.output === "silent") return;
+    let traceCtx = {};
+    try {
+      traceCtx = this.opts.traceContext?.() ?? {};
+    } catch {
+    }
+    const record = {
+      level,
+      levelNum: LEVEL_NUM[level],
+      msg,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid,
+      hostname: _hostname,
+      ...this.bindings,
+      ...traceCtx,
+      ...this.opts.service ? { service: this.opts.service } : {}
+    };
+    if (data) {
+      for (const [k, v] of Object.entries(data)) {
+        if (PROTECTED_FIELDS.has(k)) continue;
+        if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+        record[k] = this.redactSet.has(k) ? redactValue(v) : v;
+      }
+    }
+    const output = this.opts.output ?? (process.env.NODE_ENV === "development" || process.stdout.isTTY ? "pretty" : "json");
+    if (output === "pretty") {
+      const color = LEVEL_COLOR[level];
+      const ts = record.time.slice(11, 23);
+      const extras = Object.entries(record).filter(([k]) => !PROTECTED_FIELDS.has(k));
+      const extraStr = extras.length ? "  " + extras.map(([k, v]) => `${k}=${safeStringify(v)}`).join(" ") : "";
+      this.dest.write(`${color}${ts} ${level.toUpperCase().padEnd(5)}${RESET} ${msg}${extraStr}
+`);
+    } else {
+      this.dest.write(safeStringify(record) + "\n");
+    }
+    this.exporter?.push(record);
+  }
+  trace(msg, data) {
+    this.log("trace", msg, data);
+  }
+  debug(msg, data) {
+    this.log("debug", msg, data);
+  }
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  fatal(msg, data) {
+    this.log("fatal", msg, data);
+  }
+  /** Create a child logger with additional bound fields */
+  child(bindings) {
+    return new _Logger(this.opts, { ...this.bindings, ...bindings });
+  }
+  /** Attach trace context for automatic injection */
+  withTrace(ctx) {
+    return new _Logger({ ...this.opts, traceContext: () => ctx }, this.bindings);
+  }
+  /** Flush OTLP buffer before process exit */
+  flush() {
+    this.exporter?.flush();
+  }
+  destroy() {
+    this.exporter?.destroy();
+  }
+  /** Middleware: log all HTTP requests */
+  requestMiddleware() {
+    const log = this;
+    return function logRequest(req, res, next) {
+      const start = Date.now();
+      res.on("finish", () => {
+        log.info("http request", {
+          method: req.method,
+          url: req.url,
+          status: res.statusCode,
+          durationMs: Date.now() - start,
+          ip: req.ip ?? req.connection?.remoteAddress,
+          userAgent: req.headers["user-agent"]
+        });
+      });
+      next();
+    };
+  }
+};
+function createLogger(opts = {}) {
+  return new Logger(opts);
+}
+
+export { Logger, createLogger, generateExample, loadDotenvFile, loadEnv, parseDotenv, parseEnv };