thatcher 1.0.4

package/src/lib/logger.js

@@ -0,0 +1,55 @@
+/**
+ * Structured Logger - Consistent logging across the SDK
+ * Simple wrapper with prefix support
+ */
+
+const LOG_PREFIXES = {
+  API: '[API]',
+  DB: '[DB]',
+  AUTH: '[AUTH]',
+  CONFIG: '[Config]',
+  SERVICE: '[Service]',
+  system: '[System]',
+  email: '[Email]',
+  validation: '[Validation]',
+  database: '[DB]',
+  hook: '[Hook]',
+  workflow: '[Workflow]',
+};
+
+/**
+ * Create a logger with prefix
+ * @param {string} prefix - Log prefix (from LOG_PREFIXES or custom)
+ * @returns {object} Logger with methods
+ */
+export function createLogger(prefix) {
+  const logger = {
+    error: (msg, meta = {}) => {
+      console.error(`${prefix} ${msg}`, meta);
+    },
+    warn: (msg, meta = {}) => {
+      console.warn(`${prefix} ${msg}`, meta);
+    },
+    info: (msg, meta = {}) => {
+      console.info(`${prefix} ${msg}`, meta);
+    },
+    debug: (msg, meta = {}) => {
+      if (process.env.DEBUG === 'true') {
+        console.debug(`${prefix} ${msg}`, meta);
+      }
+    },
+  };
+
+  return logger;
+}
+
+/**
+ * Get prefixed logger
+ * @param {string} key - Key from LOG_PREFIXES
+ * @returns {object}
+ */
+export function getLogger(key) {
+  return createLogger(LOG_PREFIXES[key] || `[${key.toUpperCase()}]`);
+}
+
+export { LOG_PREFIXES };

package/src/lib/metrics-collector.js

@@ -0,0 +1,102 @@
+/**
+ * Metrics Collector - Request metrics and stats
+ */
+
+const metrics = {
+  requests: [],
+  slowQueries: [],
+  errors: [],
+  startTime: Date.now(),
+};
+
+let _requestCount = 0;
+
+/**
+ * Record a request
+ * @param {string} endpoint
+ * @param {string} method
+ * @param {number} durationMs
+ * @param {number} statusCode
+ */
+export function recordRequest(endpoint, method, durationMs, statusCode) {
+  _requestCount++;
+
+  const record = {
+    timestamp: Date.now(),
+    endpoint,
+    method,
+    durationMs,
+    statusCode,
+  };
+
+  metrics.requests.push(record);
+
+  // Keep last 1000 requests
+  if (metrics.requests.length > 1000) {
+    metrics.requests.shift();
+  }
+
+  // Track slow queries (>500ms)
+  if (durationMs > 500) {
+    metrics.slowQueries.push(record);
+  }
+
+  // Track errors
+  if (statusCode >= 400) {
+    metrics.errors.push(record);
+  }
+}
+
+/**
+ * Get all metrics
+ * @returns {object}
+ */
+export function getMetrics() {
+  const now = Date.now();
+  const uptimeSec = Math.floor((now - metrics.startTime) / 1000);
+
+  const requests = metrics.requests;
+  const recent = requests.filter(r => now - r.timestamp < 60000); // last minute
+
+  const avgDuration = recent.length
+    ? recent.reduce((sum, r) => sum + r.durationMs, 0) / recent.length
+    : 0;
+
+  const errorRate = recent.length
+    ? recent.filter(r => r.statusCode >= 400).length / recent.length
+    : 0;
+
+  return {
+    uptime_seconds: uptimeSec,
+    total_requests: _requestCount,
+    requests_per_minute: recent.length,
+    average_response_time_ms: Math.round(avgDuration),
+    error_rate_percent: Math.round(errorRate * 100),
+    slow_queries: metrics.slowQueries.slice(-10),
+    recent_errors: metrics.errors.slice(-10),
+  };
+}
+
+/**
+ * Get summary statistics
+ * @returns {object}
+ */
+export function getSummary() {
+  const m = getMetrics();
+  return {
+    requests: m.total_requests,
+    avgMs: m.average_response_time_ms,
+    errors: m.recent_errors.length,
+  };
+}
+
+/**
+ * Reset metrics (for testing)
+ */
+export function resetMetrics() {
+  metrics.requests = [];
+  metrics.slowQueries = [];
+  metrics.errors = [];
+  _requestCount = 0;
+  metrics.startTime = Date.now();
+}

package/src/lib/minifier.js

@@ -0,0 +1,19 @@
+export function minifyJS(code) {
+  return code
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^\s+/gm, '')
+    .replace(/\s+$/gm, '')
+    .replace(/\n+/g, '\n')
+    .replace(/\s*([{}()\[\];:,=<>!+\-*\/&|?])\s*/g, '$1')
+    .trim();
+}
+
+export function minifyCSS(css) {
+  return css
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/\s*([{}:;,>~+])\s*/g, '$1')
+    .replace(/;}/g, '}')
+    .trim();
+}

package/src/lib/monitoring-init.js

@@ -0,0 +1,67 @@
+import { startMonitoring as startResourceMonitoring } from '@/lib/resource-monitor.js'
+import { checkAllThresholds, registerAlertHandler } from '@/lib/alert-manager.js'
+import { getAllMetrics } from '@/lib/metrics-collector.js'
+import { info, warn, error } from '@/lib/log-aggregator.js'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+let alertCheckInterval = null
+let initialized = false
+
+function initializeMonitoring(config = {}) {
+  if (initialized) {
+    warn('Monitoring already initialized')
+    return
+  }
+
+  const {
+    resourceInterval = 5000,
+    alertCheckInterval: alertInterval = 10000,
+    dbPath = path.join(__dirname, '../../data/app.db')
+  } = config
+
+  startResourceMonitoring(resourceInterval, dbPath)
+  info('Resource monitoring started', { interval: resourceInterval })
+
+  alertCheckInterval = setInterval(() => {
+    try {
+      const metrics = getAllMetrics()
+      checkAllThresholds(metrics)
+    } catch (err) {
+      error('Alert check failed', { error: err.message })
+    }
+  }, alertInterval)
+
+  info('Alert checking started', { interval: alertInterval })
+
+  registerAlertHandler((alert) => {
+    if (alert.severity === 'critical') {
+      error(`CRITICAL ALERT: ${alert.message}`, alert.metadata)
+    } else if (alert.severity === 'warning') {
+      warn(`WARNING: ${alert.message}`, alert.metadata)
+    }
+  })
+
+  info('Alert handlers registered')
+
+  initialized = true
+  info('Monitoring system initialized')
+}
+
+async function shutdownMonitoring() {
+  if (!initialized) return
+
+  if (alertCheckInterval) {
+    clearInterval(alertCheckInterval)
+    alertCheckInterval = null
+  }
+
+  const { stopMonitoring } = await import('@/lib/resource-monitor.js')
+  stopMonitoring()
+
+  initialized = false
+  info('Monitoring system shutdown')
+}
+
+export { initializeMonitoring, shutdownMonitoring }

package/src/lib/next-compat.js

@@ -0,0 +1,80 @@
+const MAX_BODY_SIZE = 10 * 1024 * 1024;
+
+export class NextRequest {
+  constructor(req, body, url) {
+    this.method = req.method;
+    this.headers = 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);
+  }
+}
+
+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;
+}

package/src/lib/next-polyfills.js

@@ -0,0 +1,135 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+const requestContext = new AsyncLocalStorage();
+
+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 }
+    });
+  }
+}
+
+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()');
+  }
+}

package/src/lib/perf-monitor.js

@@ -0,0 +1,91 @@
+const metrics = new Map()
+const thresholds = { render: 100, query: 50, api: 200, total: 500 }
+let enabled = process.env.PERF_MONITOR !== 'false'
+
+export function startTimer(key) {
+  if (!enabled) return null
+  const start = process.hrtime.bigint()
+  return { key, start }
+}
+
+export function endTimer(timer) {
+  if (!enabled || !timer) return 0
+  const end = process.hrtime.bigint()
+  const ms = Number(end - timer.start) / 1000000
+  recordMetric(timer.key, ms)
+  return ms
+}
+
+export function recordMetric(key, value) {
+  if (!enabled) return
+  if (!metrics.has(key)) metrics.set(key, [])
+  const arr = metrics.get(key)
+  arr.push({ value, ts: Date.now() })
+  if (arr.length > 1000) arr.shift()
+}
+
+export function getMetrics(key) {
+  if (!key) return Object.fromEntries(metrics.entries())
+  return metrics.get(key) || []
+}
+
+export function getStats(key) {
+  const data = metrics.get(key) || []
+  if (data.length === 0) return null
+  const values = data.map(d => d.value)
+  values.sort((a, b) => a - b)
+  return {
+    count: values.length,
+    min: values[0],
+    max: values[values.length - 1],
+    avg: values.reduce((a, b) => a + b, 0) / values.length,
+    p50: values[Math.floor(values.length * 0.5)],
+    p95: values[Math.floor(values.length * 0.95)],
+    p99: values[Math.floor(values.length * 0.99)]
+  }
+}
+
+export function checkThreshold(key, value) {
+  if (!enabled) return true
+  const limit = thresholds[key]
+  if (limit && value > limit) {
+    console.warn(`[PERF] ${key} exceeded threshold: ${value.toFixed(2)}ms > ${limit}ms`)
+    return false
+  }
+  return true
+}
+
+export function setThreshold(key, ms) {
+  thresholds[key] = ms
+}
+
+export function clearMetrics() {
+  metrics.clear()
+}
+
+export function enable() {
+  enabled = true
+}
+
+export function disable() {
+  enabled = false
+}
+
+export function measure(key, fn) {
+  const timer = startTimer(key)
+  try {
+    const result = fn()
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        const ms = endTimer(timer)
+        checkThreshold(key, ms)
+      })
+    }
+    const ms = endTimer(timer)
+    checkThreshold(key, ms)
+    return result
+  } catch (err) {
+    endTimer(timer)
+    throw err
+  }
+}