triva 0.0.2 → 0.3.0

package/lib/log.js

@@ -0,0 +1,261 @@
+/*!
+ * Triva - Logging System
+ * Copyright (c) 2026 Kris Powers
+ * License MIT
+ */
+
+'use strict';
+
+import { parse as parseUrl } from 'url';
+import { parseUA } from './ua-parser.js';
+import { parseCookies } from './cookie-parser.js';
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+
+/* ---------------- Log Entry Structure ---------------- */
+class LogEntry {
+  constructor(req) {
+    const parsedUrl = parseUrl(req.url, true);
+    
+    this.timestamp = Date.now();
+    this.datetime = new Date().toISOString();
+    this.method = req.method;
+    this.url = req.url;
+    this.pathname = parsedUrl.pathname;
+    this.query = parsedUrl.query || {};
+    this.headers = { ...req.headers };
+    this.ip = req.socket?.remoteAddress || req.connection?.remoteAddress || 'unknown';
+    this.userAgent = req.headers['user-agent'] || 'unknown';
+    
+    // Parse and include cookies
+    this.cookies = req.cookies || parseCookies(req.headers.cookie);
+    
+    this.statusCode = null;
+    this.responseTime = null;
+    this.throttle = req.triva?.throttle || null;
+    
+    // Include parsed UA data from throttle if available, otherwise null
+    // Will be populated by LogStorage.push() if not present
+    this.uaData = req.triva?.throttle?.uaData || null;
+    
+    this.metadata = {};
+  }
+
+  setResponse(statusCode, responseTime) {
+    this.statusCode = statusCode;
+    this.responseTime = responseTime;
+    return this;
+  }
+
+  addMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+}
+
+/* ---------------- Log Storage ---------------- */
+class LogStorage {
+  constructor() {
+    this.entries = [];
+    this.retention = {
+      enabled: true,
+      maxEntries: 100000
+    };
+    this.stats = {
+      total: 0,
+      evicted: 0,
+      methods: {},
+      statusCodes: {}
+    };
+  }
+
+  _setRetention(config) {
+    this.retention = {
+      enabled: Boolean(config.enabled),
+      maxEntries: Number(config.maxEntries) || 100000
+    };
+  }
+
+  _enforceRetention() {
+    if (!this.retention.enabled) return;
+
+    if (this.entries.length > this.retention.maxEntries) {
+      const toRemove = this.entries.length - this.retention.maxEntries;
+      this.entries.splice(0, toRemove);
+      this.stats.evicted += toRemove;
+    }
+  }
+
+  async push(req) {
+    const entry = new LogEntry(req);
+    
+    // Parse UA data if not already available from throttle
+    if (!entry.uaData && entry.userAgent && entry.userAgent !== 'unknown') {
+      entry.uaData = await parseUA(entry.userAgent);
+    }
+    
+    // Update stats
+    this.stats.total++;
+    this.stats.methods[entry.method] = (this.stats.methods[entry.method] || 0) + 1;
+    
+    this.entries.push(entry);
+    this._enforceRetention();
+    
+    return entry;
+  }
+
+  async get(filter = {}) {
+    if (filter === 'all' || filter.all) {
+      return this.entries;
+    }
+
+    let results = [...this.entries];
+
+    // Filter by method
+    if (filter.method) {
+      const methods = Array.isArray(filter.method) ? filter.method : [filter.method];
+      results = results.filter(e => methods.includes(e.method));
+    }
+
+    // Filter by status code
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      results = results.filter(e => e.statusCode && statuses.includes(e.statusCode));
+    }
+
+    // Filter by IP
+    if (filter.ip) {
+      results = results.filter(e => e.ip === filter.ip);
+    }
+
+    // Filter by pathname pattern
+    if (filter.pathname) {
+      const pattern = new RegExp(filter.pathname);
+      results = results.filter(e => pattern.test(e.pathname));
+    }
+
+    // Filter by date range
+    if (filter.from) {
+      const fromTime = typeof filter.from === 'number' ? filter.from : new Date(filter.from).getTime();
+      results = results.filter(e => e.timestamp >= fromTime);
+    }
+
+    if (filter.to) {
+      const toTime = typeof filter.to === 'number' ? filter.to : new Date(filter.to).getTime();
+      results = results.filter(e => e.timestamp <= toTime);
+    }
+
+    // Filter by throttle status
+    if (filter.throttled !== undefined) {
+      results = results.filter(e => {
+        if (!e.throttle) return false;
+        return filter.throttled ? e.throttle.restricted : !e.throttle.restricted;
+      });
+    }
+
+    // Limit results
+    if (filter.limit) {
+      results = results.slice(-filter.limit);
+    }
+
+    return results;
+  }
+
+  async getStats() {
+    const recent = this.entries.slice(-1000);
+    
+    const statusCodeDist = {};
+    const methodDist = {};
+    const throttledCount = recent.filter(e => e.throttle?.restricted).length;
+    
+    recent.forEach(entry => {
+      if (entry.statusCode) {
+        statusCodeDist[entry.statusCode] = (statusCodeDist[entry.statusCode] || 0) + 1;
+      }
+      methodDist[entry.method] = (methodDist[entry.method] || 0) + 1;
+    });
+
+    const responseTimes = recent
+      .filter(e => e.responseTime !== null)
+      .map(e => e.responseTime);
+
+    const avgResponseTime = responseTimes.length > 0
+      ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length
+      : 0;
+
+    return {
+      total: this.stats.total,
+      stored: this.entries.length,
+      evicted: this.stats.evicted,
+      retention: this.retention,
+      recent: {
+        count: recent.length,
+        throttled: throttledCount,
+        throttleRate: recent.length > 0 ? (throttledCount / recent.length) * 100 : 0,
+        avgResponseTime: Math.round(avgResponseTime),
+        statusCodes: statusCodeDist,
+        methods: methodDist
+      }
+    };
+  }
+
+  async clear() {
+    const count = this.entries.length;
+    this.entries = [];
+    return { cleared: count };
+  }
+
+  async search(query) {
+    const lowerQuery = query.toLowerCase();
+    
+    return this.entries.filter(entry => {
+      return (
+        entry.pathname.toLowerCase().includes(lowerQuery) ||
+        entry.url.toLowerCase().includes(lowerQuery) ||
+        entry.userAgent.toLowerCase().includes(lowerQuery) ||
+        entry.ip.includes(query) ||
+        entry.method.toLowerCase().includes(lowerQuery)
+      );
+    });
+  }
+
+  async export(filter = 'all', filename = null) {
+    // Get logs based on filter
+    const logsToExport = filter === 'all' || !filter ? this.entries : await this.get(filter);
+    
+    // Generate filename if not provided
+    if (!filename) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      filename = `triva-logs-${timestamp}.json`;
+    }
+    
+    // Ensure .json extension
+    if (!filename.endsWith('.json')) {
+      filename += '.json';
+    }
+    
+    // Prepare export data
+    const exportData = {
+      exportedAt: new Date().toISOString(),
+      totalLogs: logsToExport.length,
+      filter: typeof filter === 'object' ? filter : { type: filter },
+      logs: logsToExport
+    };
+    
+    // Write to file in current working directory
+    const filepath = join(process.cwd(), filename);
+    await writeFile(filepath, JSON.stringify(exportData, null, 2), 'utf-8');
+    
+    return {
+      success: true,
+      filename,
+      filepath,
+      count: logsToExport.length
+    };
+  }
+}
+
+/* ---------------- Export Singleton ---------------- */
+const log = new LogStorage();
+
+export { log, LogEntry };

package/lib/middleware.js

@@ -0,0 +1,237 @@
+/*!
+ * Triva
+ * Copyright (c) 2026 Kris Powers
+ * License MIT
+ */
+
+'use strict';
+
+import { log } from "./log.js";
+import { cache } from './cache.js'
+import { parseUA } from './ua-parser.js';
+import crypto from "crypto"; // Needed for throttle internally
+
+/* ---------------- Throttle Class ---------------- */
+class Throttle {
+  constructor(options = {}) {
+    if (!options.limit || !options.window_ms) {
+      throw new Error("limit and window_ms are required");
+    }
+
+    this.baseConfig = {
+      limit: options.limit,
+      windowMs: options.window_ms,
+      burstLimit: options.burst_limit || 20,
+      burstWindowMs: options.burst_window_ms || 1000,
+      banThreshold: options.ban_threshold || 5,
+      banMs: options.ban_ms || 24 * 60 * 60 * 1000,
+      violationDecayMs: options.violation_decay_ms || 60 * 60 * 1000,
+      uaRotationThreshold: options.ua_rotation_threshold || 5,
+    };
+
+    this.policies =
+      typeof options.policies === "function" ? options.policies : null;
+
+    this.namespace = options.namespace || "throttle";
+
+    // Normalize retention config
+    const retention = {
+      enabled: Boolean(options.retention?.enabled),
+      maxEntries: Number(options.retention?.maxEntries) || 0
+    };
+
+    // Inject retention policy into logger
+    log._setRetention(retention);
+  }
+
+  _now() {
+    return Date.now();
+  }
+
+  _hashUA(ua) {
+    return crypto.createHash("sha256").update(ua).digest("hex");
+  }
+
+  _key(ip, uaHash) {
+    return `${this.namespace}:${ip}:${uaHash}`;
+  }
+
+  _ipKey(ip) {
+    return `${this.namespace}:ip:${ip}`;
+  }
+
+  _banKey(ip) {
+    return `${this.namespace}:ban:${ip}`;
+  }
+
+  _weightFromUA(ua) {
+    const l = ua.toLowerCase();
+    if (
+      l.includes("bot") ||
+      l.includes("crawler") ||
+      l.includes("spider") ||
+      l.includes("scrapy") ||
+      l.includes("curl") ||
+      l.includes("wget")
+    )
+      return 5;
+    if (
+      l.includes("openai") ||
+      l.includes("gpt") ||
+      l.includes("anthropic") ||
+      l.includes("claude") ||
+      l.includes("ai")
+    )
+      return 10;
+    return 1;
+  }
+
+  _resolveConfig(context, ip, ua) {
+    if (!this.policies) return this.baseConfig;
+    const override = this.policies({ ip, ua, context }) || {};
+    return { ...this.baseConfig, ...override };
+  }
+
+  async check(ip, ua, context = {}) {
+    if (!ip || !ua) return { restricted: true, reason: "invalid_identity", uaData: null };
+
+    const now = this._now();
+    const uaHash = this._hashUA(ua);
+    const config = this._resolveConfig(context, ip, ua);
+
+    // Parse user agent for detailed information
+    const uaData = await parseUA(ua);
+
+    const key = this._key(ip, uaHash);
+    const ipKey = this._ipKey(ip);
+    const banKey = this._banKey(ip);
+
+    const ban = await cache.get(banKey);
+    if (ban && ban.banned_until > now) {
+      return { restricted: true, reason: "auto_ban", uaData };
+    }
+
+    let ipRecord = (await cache.get(ipKey)) || { uas: [] };
+
+    if (!ipRecord.uas.includes(uaHash)) {
+      ipRecord.uas.push(uaHash);
+      if (ipRecord.uas.length > config.uaRotationThreshold) {
+        return { restricted: true, reason: "ua_rotation", uaData };
+      }
+      await cache.set(ipKey, ipRecord);
+    }
+
+    let record = (await cache.get(key)) || {
+      hits: [],
+      burst: [],
+      violations: 0,
+      last_violation: 0,
+    };
+
+    if (record.violations > 0 && now - record.last_violation > config.violationDecayMs) {
+      record.violations--;
+      record.last_violation = now;
+    }
+
+    // Use UA parsed data to determine weight
+    let baseWeight = 1;
+    if (uaData.bot.isBot) {
+      baseWeight = uaData.bot.isAI ? 10 : 5;
+    }
+
+    const weight =
+      typeof config.weight_multiplier === "number"
+        ? Math.ceil(baseWeight * config.weight_multiplier)
+        : baseWeight;
+
+    record.hits = record.hits.filter((ts) => ts >= now - config.windowMs);
+    record.burst = record.burst.filter((ts) => ts >= now - config.burstWindowMs);
+
+    if (record.burst.length + weight > config.burstLimit) {
+      await this._violation(record, key, banKey, config);
+      return { restricted: true, reason: "burst_limit", uaData };
+    }
+
+    if (record.hits.length + weight > config.limit) {
+      await this._violation(record, key, banKey, config);
+      return { restricted: true, reason: "sliding_window", uaData };
+    }
+
+    for (let i = 0; i < weight; i++) {
+      record.hits.push(now);
+      record.burst.push(now);
+    }
+
+    await cache.set(key, record);
+    return { restricted: false, reason: "ok", uaData };
+  }
+
+  async _violation(record, key, banKey, config) {
+    record.violations++;
+    record.last_violation = this._now();
+    if (record.violations >= config.banThreshold) {
+      await cache.set(banKey, { banned_until: this._now() + config.banMs });
+    }
+    await cache.set(key, record);
+  }
+}
+
+/* ---------------- Middleware Core ---------------- */
+class MiddlewareCore {
+  constructor(options = {}) {
+    this.options = options;
+
+    if (options.throttle) this.throttle = new Throttle(options.throttle);
+
+    const retention = {
+      enabled: options.retention?.enabled !== false,
+      maxEntries: Number(options.retention?.maxEntries) || 100_000,
+    };
+
+    log._setRetention(retention);
+  }
+
+  async handle(req, res, next) {
+    try {
+      if (this.throttle) {
+        const ip = req.socket?.remoteAddress || req.connection?.remoteAddress;
+        const ua = req.headers["user-agent"];
+        const result = await this.throttle.check(ip, ua);
+
+        req.triva = req.triva || {};
+        req.triva.throttle = result;
+
+        if (result.restricted) {
+          res.statusCode = 429;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "throttled", reason: result.reason }));
+          return;
+        }
+      }
+
+      if (typeof next === "function") next();
+      queueMicrotask(() => this.processSnapshot(req, res));
+    } catch (err) {
+      if (typeof next === "function") return next(err);
+      throw err;
+    }
+  }
+
+  processSnapshot(req) {
+    this.buildLog(req);
+  }
+
+  async buildLog(req) {
+    await log.push(req);
+  }
+}
+
+/* ---------------- Export Factory ---------------- */
+function middleware(options = {}) {
+  const core = new MiddlewareCore(options);
+  return function middleware(req, res, next) {
+    core.handle(req, res, next);
+  };
+}
+
+export { middleware };

package/lib/ua-parser.js

@@ -0,0 +1,130 @@
+/*!
+ * Triva - User Agent Parser
+ * Copyright (c) 2026 Kris Powers
+ * License MIT
+ */
+
+"use strict";
+
+async function parseUA(input) {
+    const ua =
+        typeof input === "string"
+            ? input
+            : input?.["user-agent"] || "";
+
+    const lowerUA = ua.toLowerCase();
+
+    const result = {
+        ua,
+        browser: { name: null, version: null, major: null },
+        engine: { name: null },
+        os: { name: null, version: null },
+        device: { type: "desktop", model: null },
+        cpu: { architecture: null },
+        bot: {
+            isBot: false,
+            isAI: false,
+            isCrawler: false,
+            name: null,
+            category: null
+        }
+    };
+
+    /* ---------------------------------------------
+     * BOT / AI DETECTION
+     * ------------------------------------------- */
+
+    const botSignatures = [
+        { name: "GPTBot", match: /gptbot/, category: "ai-crawler" },
+        { name: "ClaudeBot", match: /claudebot/, category: "ai-crawler" },
+        { name: "PerplexityBot", match: /perplexity/, category: "ai-crawler" },
+        { name: "Googlebot", match: /googlebot/, category: "search" },
+        { name: "Bingbot", match: /bingbot/, category: "search" },
+        { name: "Generic Bot", match: /bot|crawler|spider|curl|wget|python/i, category: "generic" }
+    ];
+
+    for (const bot of botSignatures) {
+        if (bot.match.test(lowerUA)) {
+            result.bot.isBot = true;
+            result.bot.isCrawler = true;
+            result.bot.isAI = bot.category.includes("ai");
+            result.bot.name = bot.name;
+            result.bot.category = bot.category;
+            break;
+        }
+    }
+
+    /* ---------------------------------------------
+     * BROWSER DETECTION (ORDER MATTERS)
+     * ------------------------------------------- */
+
+    const browserRules = [
+        { name: "Edge", regex: /edg\/([\d.]+)/i },
+        { name: "Opera", regex: /opr\/([\d.]+)/i },
+        { name: "Chrome", regex: /chrome\/([\d.]+)/i },
+        { name: "Firefox", regex: /firefox\/([\d.]+)/i },
+        { name: "Safari", regex: /version\/([\d.]+).*safari/i }
+    ];
+
+    for (const rule of browserRules) {
+        const match = ua.match(rule.regex);
+        if (match) {
+            result.browser.name = rule.name;
+            result.browser.version = match[1];
+            result.browser.major = match[1].split(".")[0];
+            break;
+        }
+    }
+
+    /* ---------------------------------------------
+     * ENGINE DETECTION (FIXED)
+     * ------------------------------------------- */
+
+    if (/chrome|chromium|crios/i.test(ua)) {
+        result.engine.name = "Blink";
+    } else if (/gecko/i.test(ua) && !/like gecko/i.test(ua)) {
+        result.engine.name = "Gecko";
+    } else if (/applewebkit/i.test(ua)) {
+        result.engine.name = "WebKit";
+    }
+
+    /* ---------------------------------------------
+     * OS DETECTION (FIXED)
+     * ------------------------------------------- */
+
+    const osRules = [
+        { name: "Windows", regex: /windows nt ([\d.]+)/i },
+        { name: "macOS", regex: /mac os x ([\d_]+)/i },
+        { name: "Android", regex: /android ([\d.]+)/i },
+        { name: "iOS", regex: /iphone os ([\d_]+)/i },
+        { name: "Linux", regex: /linux/i }
+    ];
+
+    for (const rule of osRules) {
+        const match = ua.match(rule.regex);
+        if (match) {
+            result.os.name = rule.name;
+            result.os.version = match[1]?.replace(/_/g, ".") || null;
+            break;
+        }
+    }
+
+    /* ---------------------------------------------
+     * DEVICE TYPE
+     * ------------------------------------------- */
+
+    if (/mobile/i.test(ua)) result.device.type = "mobile";
+    else if (/tablet/i.test(ua)) result.device.type = "tablet";
+
+    /* ---------------------------------------------
+     * CPU ARCH
+     * ------------------------------------------- */
+
+    if (/arm|aarch64/i.test(ua)) result.cpu.architecture = "arm";
+    else if (/x64|win64|amd64/i.test(ua)) result.cpu.architecture = "amd64";
+    else if (/x86/i.test(ua)) result.cpu.architecture = "x86";
+
+    return result;
+}
+
+export { parseUA };

package/package.json

@@ -1,12 +1,33 @@
 {
   "name": "triva",
-  "version": "0.0.2",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.3.0",
+  "description": "Enterprise Node.js HTTP framework with middleware, throttling, logging, caching, error tracking, and cookie support",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": ""
+  "keywords": [
+    "http",
+    "server",
+    "framework",
+    "middleware",
+    "throttle",
+    "rate-limit",
+    "logging",
+    "cache",
+    "cookies",
+    "error-tracking"
+  ],
+  "author": "Kris Powers",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "lib/",
+    "README.md",
+    "LICENSE",
+    "index.d.ts"
+  ]
 }