thatcher 1.0.41 → 1.0.43

package/src/lib/monitor.js

@@ -0,0 +1,285 @@
+// Merged from db-monitor.js + resource-monitor.js into one pluggable-probe
+// monitor rather than two hardcoded monitor types. A "probe" is anything
+// shaped like { name, start(), stop(), collect() } registered into the
+// shared registry below; the db and resource probes that used to be two
+// separate files are now just the two probes registered by default. Every
+// original exported function name is preserved unchanged for call-site
+// compatibility (getDatabaseStats, clearDatabaseStats, wrapDatabase,
+// getCPUUsage, getMemoryUsage, getDiskUsage, collectResources,
+// startMonitoring, stopMonitoring, getCurrentResources).
+
+import os from 'os';
+import fs from 'fs';
+import { recordDatabase, recordResource } from './metrics-collector.js';
+import { createLogger } from './logger.js';
+
+const log = createLogger('[Monitor]');
+
+// ---------------------------------------------------------------------------
+// Pluggable probe registry
+// ---------------------------------------------------------------------------
+const probes = new Map();
+
+function registerProbe(name, probe) {
+  probes.set(name, probe);
+  return probe;
+}
+
+function getProbe(name) {
+  return probes.get(name);
+}
+
+function listProbes() {
+  return Array.from(probes.keys());
+}
+
+// ---------------------------------------------------------------------------
+// db probe — from db-monitor.js
+// ---------------------------------------------------------------------------
+const dbStats = {
+  connections: 0,
+  activeQueries: 0,
+  locks: 0,
+  slowQueries: []
+};
+
+function recordSlowQuery(sql, duration) {
+  dbStats.slowQueries.push({
+    sql: sql.substring(0, 200),
+    duration,
+    timestamp: Date.now()
+  });
+
+  if (dbStats.slowQueries.length > 100) {
+    dbStats.slowQueries.shift();
+  }
+}
+
+export function wrapDatabase(db) {
+  const originalPrepare = db.prepare.bind(db);
+
+  db.prepare = function(sql) {
+    const stmt = originalPrepare(sql);
+    const originalRun = stmt.run.bind(stmt);
+    const originalGet = stmt.get.bind(stmt);
+    const originalAll = stmt.all.bind(stmt);
+
+    stmt.run = function(...args) {
+      const start = process.hrtime.bigint();
+      dbStats.activeQueries++;
+
+      try {
+        const result = originalRun(...args);
+        const duration = Number(process.hrtime.bigint() - start) / 1000000;
+
+        recordDatabase('run', duration, sql);
+        if (duration > 100) {
+          recordSlowQuery(sql, duration);
+        }
+
+        return result;
+      } catch (err) {
+        recordDatabase('error', 0, sql);
+        throw err;
+      } finally {
+        dbStats.activeQueries--;
+      }
+    };
+
+    stmt.get = function(...args) {
+      const start = process.hrtime.bigint();
+      dbStats.activeQueries++;
+
+      try {
+        const result = originalGet(...args);
+        const duration = Number(process.hrtime.bigint() - start) / 1000000;
+
+        recordDatabase('get', duration, sql);
+        if (duration > 100) {
+          recordSlowQuery(sql, duration);
+        }
+
+        return result;
+      } catch (err) {
+        recordDatabase('error', 0, sql);
+        throw err;
+      } finally {
+        dbStats.activeQueries--;
+      }
+    };
+
+    stmt.all = function(...args) {
+      const start = process.hrtime.bigint();
+      dbStats.activeQueries++;
+
+      try {
+        const result = originalAll(...args);
+        const duration = Number(process.hrtime.bigint() - start) / 1000000;
+
+        recordDatabase('all', duration, sql);
+        if (duration > 100) {
+          recordSlowQuery(sql, duration);
+        }
+
+        return result;
+      } catch (err) {
+        recordDatabase('error', 0, sql);
+        throw err;
+      } finally {
+        dbStats.activeQueries--;
+      }
+    };
+
+    return stmt;
+  };
+
+  return db;
+}
+
+export function getDatabaseStats() {
+  return {
+    connections: dbStats.connections,
+    activeQueries: dbStats.activeQueries,
+    locks: dbStats.locks,
+    slowQueries: dbStats.slowQueries.slice(-10)
+  };
+}
+
+export function clearDatabaseStats() {
+  dbStats.slowQueries.length = 0;
+}
+
+registerProbe('db', {
+  name: 'db',
+  start: () => {},
+  stop: () => {},
+  collect: getDatabaseStats,
+  clear: clearDatabaseStats,
+});
+
+// ---------------------------------------------------------------------------
+// resource probe — from resource-monitor.js
+// ---------------------------------------------------------------------------
+let monitoringInterval = null;
+let dbPath = null;
+
+export function getCPUUsage() {
+  const cpus = os.cpus();
+  let totalIdle = 0;
+  let totalTick = 0;
+
+  cpus.forEach(cpu => {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type];
+    }
+    totalIdle += cpu.times.idle;
+  });
+
+  const idle = totalIdle / cpus.length;
+  const total = totalTick / cpus.length;
+  const usage = 1 - (idle / total);
+
+  return Math.max(0, Math.min(1, usage));
+}
+
+export function getMemoryUsage() {
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const usedMem = totalMem - freeMem;
+
+  return {
+    total: totalMem,
+    used: usedMem,
+    free: freeMem,
+    percentage: usedMem / totalMem
+  };
+}
+
+export function getDiskUsage() {
+  if (!dbPath) return null;
+
+  try {
+    const stats = fs.statSync(dbPath);
+    const totalSpace = 1024 * 1024 * 1024 * 100;
+    const usedSpace = stats.size;
+
+    return {
+      total: totalSpace,
+      used: usedSpace,
+      percentage: usedSpace / totalSpace
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+export function collectResources() {
+  try {
+    const cpu = getCPUUsage();
+    const memory = getMemoryUsage();
+    const disk = getDiskUsage();
+
+    recordResource(
+      cpu,
+      memory.percentage,
+      disk?.percentage
+    );
+
+    return { cpu, memory, disk };
+  } catch (err) {
+    log.error('collection error:', { message: err?.message || String(err) });
+    return null;
+  }
+}
+
+export function startMonitoring(interval = 5000, databasePath = null) {
+  if (monitoringInterval) {
+    stopMonitoring();
+  }
+
+  dbPath = databasePath;
+
+  monitoringInterval = setInterval(() => {
+    collectResources();
+  }, interval);
+}
+
+export function stopMonitoring() {
+  if (monitoringInterval) {
+    clearInterval(monitoringInterval);
+    monitoringInterval = null;
+  }
+}
+
+export function getCurrentResources() {
+  return collectResources();
+}
+
+registerProbe('resource', {
+  name: 'resource',
+  start: startMonitoring,
+  stop: stopMonitoring,
+  collect: getCurrentResources,
+});
+
+// ---------------------------------------------------------------------------
+// Probe registry surface (new — the pluggable-probe pattern the merge adds)
+// ---------------------------------------------------------------------------
+export { registerProbe, getProbe, listProbes };
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__dbMonitor = {
+    getDatabaseStats,
+    clearDatabaseStats
+  };
+  globalThis.__resources = {
+    getCurrentResources,
+    startMonitoring,
+    stopMonitoring
+  };
+  globalThis.__monitor = {
+    registerProbe,
+    getProbe,
+    listProbes,
+  };
+}

package/src/lib/next-shim.js

@@ -0,0 +1,294 @@
+// next-shim.js
+//
+// Merged compatibility layer standing in for parts of the real Next.js API
+// surface, so thatcher's route handlers (src/app/api/**/route.js) and
+// server.js can run outside actual Next.js (e.g. under plain Node/Express).
+//
+// This is the union of the former src/lib/next-compat.js and
+// src/lib/next-polyfills.js, combined verbatim (no behavior changes).
+//
+// Supports:
+//   - NextRequest: constructed from a raw Node IncomingMessage + parsed body
+//     + url. `.method`, `.headers` (Proxy giving both `.get(name)` /
+//     `.has(name)` fetch-style access AND raw `headers['x']` index access,
+//     case-insensitive via lowercasing), `.url`, `.body`. `.json()` returns
+//     the already-parsed body; `.text()` returns it as a string (or
+//     JSON.stringify's it if not already a string).
+//   - NextResponse: `.body`, `.status` (default 200), `.headers` (a Map).
+//     `.json()` returns `.body`. Static `NextResponse.json(body, init)`
+//     constructs one. Static `NextResponse.redirect(url, status = 307)`
+//     constructs a redirect response with a `Location` header.
+//   - readBody(req): buffers a raw Node request stream into a JSON-parsed
+//     object (falls back to the raw string on parse failure), with a
+//     10 MB body-size cap that destroys the request and rejects if
+//     exceeded.
+//   - normalizeHeaderName(key): maps a lowercased header name to its
+//     canonical mixed-case form for a small fixed set of common headers
+//     (content-type, content-length, set-cookie, cache-control, expires,
+//     etag, last-modified, location, date, connection); passes through
+//     unrecognized keys unchanged.
+//   - registerGlobals(): assigns NextRequest/NextResponse onto globalThis.
+//   - cookies() (async, server-side only -- throws if `window` is defined):
+//     reads the request's `Cookie` header (via AsyncLocalStorage-scoped
+//     request, falling back to the last value passed to
+//     setCurrentRequest()) into a name->value map, and returns an object
+//     with `.get(name)` (returns `{name, value}` or undefined), `.set(name,
+//     value, options)` / `.delete(name)` (append a Set-Cookie header onto
+//     the AsyncLocalStorage-scoped response via `res.setHeader`, supporting
+//     `path`/`maxAge`/`expires`/`secure`/`httpOnly`/`sameSite` options), and
+//     `.getAll()` / `.has(name)`.
+//   - headers(): a STUB read-only headers accessor -- `.get()` always
+//     returns null, `.has()` always returns false, `.getSetCookie()` /
+//     `.entries()` always return an empty array. It does NOT read the
+//     actual request headers (unlike `cookies()`, which does).
+//   - setCurrentRequest(req) / setCurrentResponse(res): set a module-level
+//     fallback request/response used by cookies() when no
+//     AsyncLocalStorage context is active.
+//   - runWithContext(req, res, fn): runs `fn` inside an AsyncLocalStorage
+//     context carrying `{req, res}`, so cookies() can resolve the current
+//     request/response without them being threaded through every call.
+//   - revalidatePath() / revalidateTag(): both no-op stubs.
+//   - redirect(path, status = 302): server-side throws an Error tagged
+//     `error.type = 'redirect'` with `.location`/`.status` (for a caller to
+//     catch and translate into an actual HTTP redirect); client-side
+//     (`typeof window !== 'undefined'`) sets `window.location.href`
+//     directly instead of throwing.
+//   - notFound(): server-side throws a plain `Error('notFound()')`;
+//     client-side sets `window.location.href = '/404'`.
+//
+// Does NOT support:
+//   - Streaming request/response bodies (readBody fully buffers before
+//     resolving; NextResponse.body is a plain in-memory value, not a
+//     ReadableStream).
+//   - `NextRequest.nextUrl` (parsed URL object with `.searchParams` etc.) --
+//     only a raw `.url` string is exposed.
+//   - `NextRequest.cookies` as a request-bound property -- cookie access is
+//     only available via the separate top-level `cookies()` function.
+//   - Any real Web Headers object -- `NextRequest.headers` is a Proxy over
+//     a plain object, and `NextResponse.headers` is a bare Map, neither
+//     implements the full Headers interface (no `.append()`, `.forEach()`,
+//     `.delete()`, iteration protocol, etc).
+//   - Edge runtime APIs (no `NextFetchEvent`, no `waitUntil`, no Edge
+//     `fetch` overrides).
+//   - Middleware matchers / `middleware.js` config conventions.
+//   - `headers()` returning real request headers -- it is a hardcoded stub
+//     that never reflects the actual incoming request.
+//   - Response streaming helpers (`NextResponse.next()`, rewriting, etc.)
+//     -- only `.json()` and `.redirect()` static constructors exist.
+//   - Any multipart/form-data or non-JSON body parsing in readBody --
+//     non-JSON bodies resolve as a raw string.
+
+import { AsyncLocalStorage } from 'async_hooks';
+
+const MAX_BODY_SIZE = 10 * 1024 * 1024;
+
+// Wrap node's raw (plain-object, lowercased) headers so both the Fetch-style
+// `headers.get('x')` API and direct `headers['x']` index access work. Node
+// already lowercases header names; `.get()` lowercases its argument to match.
+function wrapHeaders(raw) {
+  const h = raw || {};
+  return new Proxy(h, {
+    get(target, prop) {
+      if (prop === 'get') return (name) => target[String(name).toLowerCase()] ?? null;
+      if (prop === 'has') return (name) => String(name).toLowerCase() in target;
+      return target[prop];
+    },
+  });
+}
+
+export class NextRequest {
+  constructor(req, body, url) {
+    this.method = req.method;
+    this.headers = wrapHeaders(req.headers);
+    this.url = url;
+    this.body = body;
+  }
+
+  async json() {
+    return this.body;
+  }
+
+  async text() {
+    return typeof this.body === 'string' ? this.body : JSON.stringify(this.body);
+  }
+}
+
+export class NextResponse {
+  constructor(body, init = {}) {
+    this.body = body;
+    this.status = init.status || 200;
+    this.headers = new Map(Object.entries(init.headers || {}));
+  }
+
+  async json() {
+    return this.body;
+  }
+
+  static json(body, init = {}) {
+    return new NextResponse(body, init);
+  }
+
+  static redirect(url, status = 307) {
+    return new NextResponse(null, {
+      status,
+      headers: { Location: url }
+    });
+  }
+}
+
+export async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    let size = 0;
+    req.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new Error('Request body too large'));
+        return;
+      }
+      data += chunk;
+    });
+    req.on('end', () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch {
+        resolve(data);
+      }
+    });
+    req.on('error', (err) => reject(err));
+  });
+}
+
+const HEADER_MAP = {
+  'content-type': 'Content-Type',
+  'content-length': 'Content-Length',
+  'set-cookie': 'Set-Cookie',
+  'cache-control': 'Cache-Control',
+  'expires': 'Expires',
+  'etag': 'ETag',
+  'last-modified': 'Last-Modified',
+  'location': 'Location',
+  'date': 'Date',
+  'connection': 'Connection',
+};
+
+export function normalizeHeaderName(key) {
+  return HEADER_MAP[key.toLowerCase()] || key;
+}
+
+export function registerGlobals() {
+  globalThis.NextRequest = NextRequest;
+  globalThis.NextResponse = NextResponse;
+}
+
+const requestContext = new AsyncLocalStorage();
+
+let fallbackRequest = null;
+let fallbackResponse = null;
+
+export function setCurrentRequest(req) {
+  fallbackRequest = req;
+}
+
+export function setCurrentResponse(res) {
+  fallbackResponse = res;
+}
+
+export function runWithContext(req, res, fn) {
+  return requestContext.run({ req, res }, fn);
+}
+
+function getRequest() {
+  const store = requestContext.getStore();
+  return store?.req || fallbackRequest;
+}
+
+function getResponse() {
+  const store = requestContext.getStore();
+  return store?.res || fallbackResponse;
+}
+
+export async function cookies() {
+  if (typeof window !== 'undefined') {
+    throw new Error('cookies() should only be called on the server side');
+  }
+
+  const req = getRequest();
+  const res = getResponse();
+  const cookieHeader = req?.headers?.cookie || '';
+  const cookieMap = {};
+
+  if (cookieHeader) {
+    cookieHeader.split(';').forEach(cookie => {
+      const [name, value] = cookie.split('=').map(s => s.trim());
+      if (name) cookieMap[name] = decodeURIComponent(value || '');
+    });
+  }
+
+  return {
+    get: (name) => {
+      const value = cookieMap[name];
+      return value ? { name, value } : undefined;
+    },
+    set: (name, value, options = {}) => {
+      if (!res) return;
+      let setCookieValue = `${name}=${encodeURIComponent(value)}`;
+      if (options.path) setCookieValue += `; Path=${options.path}`;
+      if (options.maxAge) setCookieValue += `; Max-Age=${options.maxAge}`;
+      if (options.expires) setCookieValue += `; Expires=${options.expires}`;
+      if (options.secure) setCookieValue += '; Secure';
+      if (options.httpOnly) setCookieValue += '; HttpOnly';
+      if (options.sameSite) setCookieValue += `; SameSite=${options.sameSite}`;
+      const existing = res.getHeader('Set-Cookie') || [];
+      const setCookies = Array.isArray(existing) ? existing : [existing];
+      res.setHeader('Set-Cookie', [...setCookies, setCookieValue]);
+    },
+    delete: (name) => {
+      if (!res) return;
+      const setCookieValue = `${name}=; Path=/; Max-Age=0`;
+      const existing = res.getHeader('Set-Cookie') || [];
+      const setCookies = Array.isArray(existing) ? existing : [existing];
+      res.setHeader('Set-Cookie', [...setCookies, setCookieValue]);
+    },
+    getAll: () => {
+      return Object.entries(cookieMap).map(([name, value]) => ({ name, value }));
+    },
+    has: (name) => {
+      return name in cookieMap;
+    },
+  };
+}
+
+export function headers() {
+  return {
+    get: (name) => null,
+    getSetCookie: () => [],
+    has: (name) => false,
+    entries: () => [],
+  };
+}
+
+export function revalidatePath() {}
+
+export function revalidateTag() {}
+
+export function redirect(path, status = 302) {
+  if (typeof window !== 'undefined') {
+    window.location.href = path;
+  } else {
+    const error = new Error(`Redirect to ${path}`);
+    error.type = 'redirect';
+    error.location = path;
+    error.status = status;
+    throw error;
+  }
+}
+
+export function notFound() {
+  if (typeof window !== 'undefined') {
+    window.location.href = '/404';
+  } else {
+    throw new Error('notFound()');
+  }
+}