thatcher 1.0.4

package/src/lib/hot-reload/promise-container.js

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'events';
+
+export class PromiseContainer extends EventEmitter {
+  constructor() {
+    super();
+    this.activePromises = new Set();
+    this.rejectionHandlers = new Map();
+    this.globalHandler = null;
+  }
+
+  wrap(promise, context = 'anonymous') {
+    const tracked = promise
+      .catch(err => {
+        this.emit('rejection', { error: err, context });
+        if (this.globalHandler) {
+          this.globalHandler(err, context);
+        }
+        return Promise.reject(err);
+      })
+      .finally(() => {
+        this.activePromises.delete(tracked);
+      });
+
+    this.activePromises.add(tracked);
+    return tracked;
+  }
+
+  setGlobalHandler(handler) {
+    this.globalHandler = handler;
+  }
+
+  async drainAll(timeout = 5000) {
+    if (this.activePromises.size === 0) return;
+
+    const drainPromise = Promise.allSettled([...this.activePromises]);
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Drain timeout')), timeout)
+    );
+
+    try {
+      await Promise.race([drainPromise, timeoutPromise]);
+    } catch (err) {
+      console.warn(`Promise drain timeout: ${this.activePromises.size} promises still active`);
+    }
+  }
+
+  getStats() {
+    return {
+      active: this.activePromises.size,
+      hasGlobalHandler: !!this.globalHandler
+    };
+  }
+}
+
+export const globalContainer = new PromiseContainer();
+
+globalContainer.setGlobalHandler((err, context) => {
+  console.error(`[PromiseContainer] Unhandled rejection in ${context}:`, err);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[Process] Unhandled Promise Rejection:', reason);
+  globalContainer.emit('processRejection', { reason, promise });
+});
+
+export const contain = globalContainer.wrap.bind(globalContainer);

package/src/lib/hot-reload/route-wrapper.js

@@ -0,0 +1,46 @@
+import { safeError } from './safe-error.js';
+import { contain } from './promise-container.js';
+
+export function wrapRouteHandler(handler, options = {}) {
+  const { logErrors = true, sendErrorResponse = true, context = 'route' } = options;
+
+  return async function wrappedHandler(req, res) {
+    try {
+      const result = await contain(
+        Promise.resolve(handler(req, res)),
+        `${context}:${req.method}:${req.url}`
+      );
+      return result;
+    } catch (err) {
+      if (logErrors) {
+        console.error(`[RouteError:${context}] ${req.method} ${req.url}:`, err);
+      }
+      if (sendErrorResponse && !res.headersSent) {
+        const safe = safeError(err);
+        const statusCode = err.statusCode || err.status || 500;
+        res.statusCode = statusCode;
+        res.setHeader('Content-Type', 'application/json');
+        const body = JSON.stringify({
+          error: safe.message,
+          type: safe.type,
+          ...(process.env.NODE_ENV === 'development' && { stack: safe.stack })
+        });
+        res.setHeader('Content-Length', Buffer.byteLength(body, 'utf-8'));
+        res.end(body);
+      }
+      throw err;
+    }
+  };
+}
+
+export function wrapRouteHandlers(handlers) {
+  const wrapped = {};
+  for (const [method, handler] of Object.entries(handlers)) {
+    if (typeof handler === 'function') {
+      wrapped[method] = wrapRouteHandler(handler, { context: method });
+    } else {
+      wrapped[method] = handler;
+    }
+  }
+  return wrapped;
+}

package/src/lib/hot-reload/safe-error.js

@@ -0,0 +1,51 @@
+export function safeError(err) {
+  if (!err) return { message: 'Unknown error', type: 'Error' };
+  if (typeof err === 'string') return { message: err, type: 'String' };
+
+  const safe = {
+    message: err.message || String(err),
+    type: err.constructor?.name || 'Error',
+    code: err.code,
+    statusCode: err.statusCode,
+    status: err.status
+  };
+
+  if (err.stack && typeof err.stack === 'string') {
+    safe.stack = err.stack;
+  }
+
+  for (const key of Object.keys(err)) {
+    if (safe[key] !== undefined) continue;
+    const value = err[key];
+    const type = typeof value;
+    if (value === null || type === 'undefined') continue;
+    if (type === 'string' || type === 'number' || type === 'boolean') {
+      safe[key] = value;
+    } else if (type === 'object' && !Array.isArray(value)) {
+      try { safe[key] = safeError(value); } catch { safe[key] = String(value); }
+    } else if (Array.isArray(value)) {
+      safe[key] = value.map(v => {
+        const vType = typeof v;
+        if (vType === 'string' || vType === 'number' || vType === 'boolean') return v;
+        return String(v);
+      });
+    } else {
+      safe[key] = String(value);
+    }
+  }
+  return safe;
+}
+
+export function safeStringify(obj, space = 0) {
+  try {
+    return JSON.stringify(obj, (key, value) => {
+      if (value instanceof Error) return safeError(value);
+      const type = typeof value;
+      if (type === 'symbol' || type === 'function' || type === 'undefined') return String(value);
+      if (type === 'bigint') return value.toString();
+      return value;
+    }, space);
+  } catch (err) {
+    return JSON.stringify({ error: 'Serialization failed', message: String(err) }, null, space);
+  }
+}

package/src/lib/hot-reload/supervisor.js

@@ -0,0 +1,161 @@
+import { EventEmitter } from 'events';
+
+export class Supervisor extends EventEmitter {
+  constructor(name, workerFn, options = {}) {
+    super();
+    this.name = name;
+    this.workerFn = workerFn;
+    this.options = {
+      maxRestarts: options.maxRestarts || 5,
+      restartWindow: options.restartWindow || 60000,
+      backoffMs: options.backoffMs || 1000,
+      maxBackoffMs: options.maxBackoffMs || 30000,
+      onError: options.onError || null,
+      ...options
+    };
+
+    this.worker = null;
+    this.restarts = [];
+    this.currentBackoff = this.options.backoffMs;
+    this.running = false;
+    this.stopping = false;
+
+    if (this.listenerCount('error') === 0) {
+      this.on('error', (data) => {
+        console.error(`[Supervisor:${this.name}] Worker error:`, data.error?.message || data.error);
+      });
+    }
+  }
+
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    this.stopping = false;
+    await this._startWorker();
+  }
+
+  async stop() {
+    this.stopping = true;
+    this.running = false;
+    if (this.worker && typeof this.worker.stop === 'function') {
+      await this.worker.stop();
+    }
+    this.worker = null;
+  }
+
+  async restart() {
+    await this.stop();
+    this.restarts = [];
+    this.currentBackoff = this.options.backoffMs;
+    await this.start();
+  }
+
+  async _startWorker() {
+    if (!this.running || this.stopping) return;
+
+    try {
+      this.worker = await this.workerFn();
+      this.emit('started', this.name);
+      this.currentBackoff = this.options.backoffMs;
+
+      if (this.worker && typeof this.worker.on === 'function') {
+        this.worker.on('error', (err) => this._handleError(err));
+      }
+    } catch (err) {
+      await this._handleError(err);
+    }
+  }
+
+  async _handleError(err) {
+    this.emit('error', { name: this.name, error: err });
+
+    if (this.options.onError) {
+      try {
+        await this.options.onError(err);
+      } catch (handlerErr) {
+        console.error(`[Supervisor:${this.name}] Error handler failed:`, handlerErr);
+      }
+    }
+
+    if (!this.running || this.stopping) return;
+
+    const now = Date.now();
+    this.restarts = this.restarts.filter(t => now - t < this.options.restartWindow);
+    this.restarts.push(now);
+
+    if (this.restarts.length > this.options.maxRestarts) {
+      console.error(`[Supervisor:${this.name}] Max restarts exceeded. Giving up.`);
+      this.emit('giveup', this.name);
+      this.running = false;
+      return;
+    }
+
+    await new Promise(resolve => setTimeout(resolve, this.currentBackoff));
+    this.currentBackoff = Math.min(this.currentBackoff * 2, this.options.maxBackoffMs);
+
+    await this._startWorker();
+  }
+
+  getStats() {
+    return {
+      name: this.name,
+      running: this.running,
+      stopping: this.stopping,
+      restarts: this.restarts.length,
+      maxRestarts: this.options.maxRestarts,
+      currentBackoff: this.currentBackoff,
+      hasWorker: !!this.worker
+    };
+  }
+}
+
+export class SupervisorTree extends EventEmitter {
+  constructor() {
+    super();
+    this.supervisors = new Map();
+  }
+
+  register(name, workerFn, options) {
+    const supervisor = new Supervisor(name, workerFn, options);
+    supervisor.on('error', (data) => this.emit('childError', data));
+    supervisor.on('giveup', (name) => this.emit('childGiveup', name));
+    this.supervisors.set(name, supervisor);
+    return supervisor;
+  }
+
+  async start(name) {
+    const supervisor = this.supervisors.get(name);
+    if (!supervisor) throw new Error(`Supervisor ${name} not found`);
+    await supervisor.start();
+  }
+
+  async stop(name) {
+    const supervisor = this.supervisors.get(name);
+    if (!supervisor) throw new Error(`Supervisor ${name} not found`);
+    await supervisor.stop();
+  }
+
+  async startAll() {
+    await Promise.all([...this.supervisors.values()].map(s => s.start()));
+  }
+
+  async stopAll() {
+    await Promise.all([...this.supervisors.values()].map(s => s.stop()));
+  }
+
+  async restart(name) {
+    const supervisor = this.supervisors.get(name);
+    if (!supervisor) throw new Error(`Supervisor ${name} not found`);
+    await supervisor.restart();
+  }
+
+  getStats() {
+    const stats = {};
+    for (const [name, supervisor] of this.supervisors.entries()) {
+      stats[name] = supervisor.getStats();
+    }
+    return stats;
+  }
+}
+
+export const globalTree = new SupervisorTree();

package/src/lib/hot-reload/timeout-wrapper.js

@@ -0,0 +1,52 @@
+export class TimeoutError extends Error {
+  constructor(message, operation) {
+    super(message);
+    this.name = 'TimeoutError';
+    this.operation = operation;
+  }
+}
+
+export function withTimeout(promise, ms, operation = 'operation') {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new TimeoutError(`${operation} timed out after ${ms}ms`, operation));
+    }, ms);
+    promise
+      .then(value => { clearTimeout(timer); resolve(value); })
+      .catch(err => { clearTimeout(timer); reject(err); });
+  });
+}
+
+export function withAbortableTimeout(fn, ms, operation = 'operation') {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const timeoutId = setTimeout(() => { controller.abort(); }, ms);
+
+  return fn(signal)
+    .then(result => { clearTimeout(timeoutId); return result; })
+    .catch(err => {
+      clearTimeout(timeoutId);
+      if (err.name === 'AbortError') {
+        throw new TimeoutError(`${operation} aborted after ${ms}ms`, operation);
+      }
+      throw err;
+    });
+}
+
+export async function retry(fn, options = {}) {
+  const { maxRetries = 3, delayMs = 1000, backoff = true, onRetry = null } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries) {
+        const delay = backoff ? delayMs * Math.pow(2, attempt) : delayMs;
+        if (onRetry) onRetry(err, attempt + 1, delay);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}

package/src/lib/http-methods-factory.js

@@ -0,0 +1,25 @@
+import { createUniversalHandler } from '@/lib/universal-handler';
+import { setCurrentRequest } from '@/engine.server';
+
+function createMethodHandler(entityNameOrGetter) {
+  return async function(request, context) {
+    setCurrentRequest(request);
+    const entityName = typeof entityNameOrGetter === 'function'
+      ? await entityNameOrGetter(context)
+      : entityNameOrGetter;
+
+    const handler = createUniversalHandler(entityName);
+    return await handler(request, context);
+  };
+}
+
+export function createHttpMethods(entityNameOrGetter) {
+  const handler = createMethodHandler(entityNameOrGetter);
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    PATCH: handler,
+    DELETE: handler,
+  };
+}

package/src/lib/index-optimizer.js

@@ -0,0 +1,96 @@
+import { getDatabase } from '@/lib/database-core';
+
+const COMPOSITE_INDEXES = [
+  { name: 'idx_engagement_client_stage', table: 'engagement', columns: ['client_id', 'stage'], where: "status != 'deleted'" },
+  { name: 'idx_engagement_status_created', table: 'engagement', columns: ['status', 'created_at'] },
+  { name: 'idx_engagement_stage_created', table: 'engagement', columns: ['stage', 'created_at'] },
+  { name: 'idx_rfi_engagement_client_status', table: 'rfi', columns: ['engagement_id', 'client_status'] },
+  { name: 'idx_rfi_engagement_auditor_status', table: 'rfi', columns: ['engagement_id', 'auditor_status'] },
+  { name: 'idx_rfi_engagement_status', table: 'rfi', columns: ['engagement_id', 'status'] },
+  { name: 'idx_users_client_role', table: 'users', columns: ['client_id', 'role', 'status'] },
+  { name: 'idx_users_email_active', table: 'users', columns: ['email'], where: "status = 'active'" },
+  { name: 'idx_users_type_status', table: 'users', columns: ['type', 'status'] },
+  { name: 'idx_sessions_expires', table: 'sessions', columns: ['expires_at'] },
+  { name: 'idx_sessions_user_expires', table: 'sessions', columns: ['user_id', 'expires_at'] },
+  { name: 'idx_audit_composite', table: 'audit_logs', columns: ['entity_type', 'entity_id', 'created_at'] },
+  { name: 'idx_audit_user_created', table: 'audit_logs', columns: ['user_id', 'created_at'] },
+  { name: 'idx_email_status_created', table: 'email', columns: ['status', 'created_at'] },
+  { name: 'idx_email_recipient', table: 'email', columns: ['recipient_email', 'created_at'] },
+  { name: 'idx_rfi_questions_rfi_status', table: 'rfi_questions', columns: ['rfi_id', 'status'] },
+  { name: 'idx_rfi_questions_assigned', table: 'rfi_questions', columns: ['assigned_to', 'status'] },
+  { name: 'idx_chat_messages_rfi_created', table: 'chat_messages', columns: ['rfi_id', 'created_at'] },
+  { name: 'idx_chat_mentions_user_resolved', table: 'chat_mentions', columns: ['user_id', 'resolved'] },
+  { name: 'idx_password_reset_expires', table: 'password_reset_tokens', columns: ['expires_at', 'used'] }
+];
+
+const indexExists = (db, indexName) => {
+  try {
+    const result = db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name=?").get(indexName);
+    return !!result;
+  } catch {
+    return false;
+  }
+};
+
+export const createOptimizedIndexes = () => {
+  const db = getDatabase();
+  const created = [];
+  const skipped = [];
+  const errors = [];
+
+  for (const idx of COMPOSITE_INDEXES) {
+    if (indexExists(db, idx.name)) {
+      skipped.push(idx.name);
+      continue;
+    }
+
+    try {
+      const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(idx.table);
+      if (!tableExists) {
+        skipped.push(`${idx.name} (table ${idx.table} not found)`);
+        continue;
+      }
+
+      const columns = idx.columns.map(c => `"${c}"`).join(', ');
+      const wherePart = idx.where ? ` WHERE ${idx.where}` : '';
+      const sql = `CREATE INDEX IF NOT EXISTS "${idx.name}" ON "${idx.table}"(${columns})${wherePart}`;
+
+      db.exec(sql);
+      created.push(idx.name);
+    } catch (e) {
+      errors.push({ index: idx.name, error: e.message });
+    }
+  }
+
+  return { created, skipped, errors, total: COMPOSITE_INDEXES.length };
+};
+
+export const analyzeQuery = (sql) => {
+  const db = getDatabase();
+  try {
+    const plan = db.prepare(`EXPLAIN QUERY PLAN ${sql}`).all();
+    return plan;
+  } catch (e) {
+    return [{ error: e.message }];
+  }
+};
+
+export const getIndexUsage = () => {
+  const db = getDatabase();
+  try {
+    const indexes = db.prepare("SELECT name, tbl_name FROM sqlite_master WHERE type='index' AND sql IS NOT NULL ORDER BY tbl_name, name").all();
+    return indexes;
+  } catch {
+    return [];
+  }
+};
+
+export const optimizeDatabase = () => {
+  const db = getDatabase();
+  try {
+    db.exec('ANALYZE');
+    return { status: 'success', message: 'Database statistics updated' };
+  } catch (e) {
+    return { status: 'error', error: e.message };
+  }
+};

package/src/lib/index.js

@@ -0,0 +1,35 @@
+export * from '@/lib/query-engine';
+export * from '@/lib/validate';
+export * from '@/lib/field-types';
+export * from '@/lib/field-iterator';
+export * from '@/lib/list-data-transform';
+export * from '@/lib/api-helpers';
+export * from '@/lib/logger';
+export { can, check, canAccessRow } from '@/services/permission.service';
+export * from '@/lib/status-helpers';
+export * from '@/lib/route-helpers';
+export * from '@/lib/utils';
+export {
+  AppError,
+  ValidationError,
+  NotFoundError,
+  PermissionError,
+  UnauthorizedError,
+  ConflictError,
+  DatabaseError,
+  ExternalAPIError,
+  errorHandler,
+  apiErrorHandler,
+  normalizeError,
+  formatErrorResponse,
+  createErrorLogger,
+} from '@/lib/error-handler';
+export { createApiHandler } from '@/lib/api';
+export * from '@/lib/errors';
+export { getDatabase, migrate, genId, now } from '@/lib/database-core';
+export { logAction, getAuditHistory, getEntityAuditTrail, getActionStats, getUserStats } from '@/lib/audit-logger';
+export * from '@/lib/realtime-server';
+export * from '@/lib/hook-engine';
+export * from '@/lib/events-engine';
+export * from '@/lib/workflow-engine';
+export * from '@/lib/field-registry';

package/src/lib/list-data-transform.js

@@ -0,0 +1,39 @@
+export function filterByQuery(data, query, searchFields = ['name', 'title', 'description']) {
+  if (!query) return data;
+  const lower = query.toLowerCase();
+  return data.filter(row =>
+    searchFields.some(field =>
+      String(row[field] || '').toLowerCase().includes(lower)
+    )
+  );
+}
+
+export function groupByField(data, field) {
+  if (!field) return { '': data };
+  return data.reduce((acc, row) => {
+    const g = row[field] || 'Other';
+    (acc[g] = acc[g] || []).push(row);
+    return acc;
+  }, {});
+}
+
+export function compareValues(a, b, dir = 'asc') {
+  if (a == null && b == null) return 0;
+  if (a == null) return dir === 'asc' ? 1 : -1;
+  if (b == null) return dir === 'asc' ? -1 : 1;
+  const cmp = a < b ? -1 : a > b ? 1 : 0;
+  return dir === 'asc' ? cmp : -cmp;
+}
+
+export function sortByField(rows, field, dir) {
+  if (!field) return rows;
+  return [...rows].sort((a, b) => compareValues(a[field], b[field], dir));
+}
+
+export function sortGroups(grouped, field, dir) {
+  const result = {};
+  for (const [group, rows] of Object.entries(grouped)) {
+    result[group] = sortByField(rows, field, dir);
+  }
+  return result;
+}

package/src/lib/log-aggregator.js

@@ -0,0 +1,116 @@
+const logs = []
+const maxLogs = 10000
+
+const levels = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  critical: 4
+}
+
+let currentLevel = levels.info
+
+function log(level, message, metadata = {}) {
+  if (levels[level] < currentLevel) return
+
+  const entry = {
+    level,
+    message,
+    metadata,
+    timestamp: Date.now(),
+    iso: new Date().toISOString()
+  }
+
+  logs.push(entry)
+  if (logs.length > maxLogs) logs.shift()
+
+  const prefix = `[${entry.iso}] [${level.toUpperCase()}]`
+  const metaStr = Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : ''
+
+  if (level === 'error' || level === 'critical') {
+    console.error(prefix, message, metaStr)
+  } else if (level === 'warn') {
+    console.warn(prefix, message, metaStr)
+  } else {
+  }
+}
+
+function debug(message, metadata) {
+  log('debug', message, metadata)
+}
+
+function info(message, metadata) {
+  log('info', message, metadata)
+}
+
+function warn(message, metadata) {
+  log('warn', message, metadata)
+}
+
+function error(message, metadata) {
+  log('error', message, metadata)
+}
+
+function critical(message, metadata) {
+  log('critical', message, metadata)
+}
+
+function getLogs(filter = {}) {
+  let filtered = logs
+
+  if (filter.level) {
+    const minLevel = levels[filter.level]
+    filtered = filtered.filter(l => levels[l.level] >= minLevel)
+  }
+
+  if (filter.since) {
+    filtered = filtered.filter(l => l.timestamp >= filter.since)
+  }
+
+  if (filter.search) {
+    const search = filter.search.toLowerCase()
+    filtered = filtered.filter(l =>
+      l.message.toLowerCase().includes(search) ||
+      JSON.stringify(l.metadata).toLowerCase().includes(search)
+    )
+  }
+
+  const limit = filter.limit || 100
+  return filtered.slice(-limit)
+}
+
+function clearLogs() {
+  logs.length = 0
+}
+
+function setLogLevel(level) {
+  if (levels[level] !== undefined) {
+    currentLevel = levels[level]
+  }
+}
+
+export {
+  log,
+  debug,
+  info,
+  warn,
+  error,
+  critical,
+  getLogs,
+  clearLogs,
+  setLogLevel
+}
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__logs = {
+    debug,
+    info,
+    warn,
+    error,
+    critical,
+    getLogs,
+    clearLogs,
+    setLogLevel
+  }
+}