thatcher 1.0.7 → 1.0.34

package/src/lib/error-boundary.js

@@ -1,134 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from 'react/jsx-runtime';
-
-const errorBoundaryState = new Map();
-
-export class ErrorBoundary {
-  constructor(id, options = {}) {
-    this.id = id;
-    this.fallback = options.fallback || this.defaultFallback.bind(this);
-    this.onError = options.onError;
-    this.reset = this.reset.bind(this);
-
-    errorBoundaryState.set(id, {
-      hasError: false,
-      error: null,
-      errorInfo: null,
-      retryCount: 0
-    });
-  }
-
-  getState() {
-    return errorBoundaryState.get(this.id);
-  }
-
-  setState(updates) {
-    const current = this.getState();
-    errorBoundaryState.set(this.id, { ...current, ...updates });
-  }
-
-  catchError(error, errorInfo = {}) {
-    const state = this.getState();
-
-    console.error(`[ErrorBoundary:${this.id}] Caught error:`, error);
-
-    this.setState({
-      hasError: true,
-      error,
-      errorInfo,
-      retryCount: state.retryCount + 1
-    });
-
-    if (this.onError) {
-      this.onError(error, errorInfo);
-    }
-  }
-
-  reset() {
-    this.setState({
-      hasError: false,
-      error: null,
-      errorInfo: null
-    });
-  }
-
-  defaultFallback(error, retry) {
-    const state = this.getState();
-
-    return _jsxs('div', {
-      className: 'p-6 bg-error-content border border-error rounded-lg',
-      children: [
-        _jsx('h2', {
-          className: 'text-xl font-bold mb-2 text-error',
-          children: 'Something went wrong'
-        }),
-        _jsx('p', {
-          className: 'text-sm mb-4',
-          children: String(error?.message || 'An unexpected error occurred')
-        }),
-        state.retryCount < 3 && _jsx('button', {
-          onClick: retry,
-          className: 'btn btn-primary btn-sm',
-          children: 'Try again'
-        }),
-        state.retryCount >= 3 && _jsx('p', {
-          className: 'text-sm text-error',
-          children: 'Please refresh the page or contact support'
-        })
-      ]
-    });
-  }
-
-  render(children) {
-    const state = this.getState();
-
-    if (state.hasError) {
-      return this.fallback(state.error, this.reset);
-    }
-
-    return children;
-  }
-}
-
-export function createErrorBoundary(id, options = {}) {
-  return new ErrorBoundary(id, options);
-}
-
-export function wrapWithErrorBoundary(component, id, options = {}) {
-  const boundary = createErrorBoundary(id, options);
-
-  return (...args) => {
-    try {
-      const result = component(...args);
-      return boundary.render(result);
-    } catch (error) {
-      boundary.catchError(error);
-      return boundary.render(null);
-    }
-  };
-}
-
-export async function tryCatch(fn, fallback = null) {
-  try {
-    return await fn();
-  } catch (error) {
-    console.error('[tryCatch] Error caught:', error);
-    return fallback;
-  }
-}
-
-export function safeRender(component, props = {}, fallback = null) {
-  try {
-    return component(props);
-  } catch (error) {
-    console.error('[safeRender] Render error:', error);
-    return fallback || _jsx('div', {
-      className: 'p-4 text-error',
-      children: 'Failed to render component'
-    });
-  }
-}
-
-if (typeof global !== 'undefined') {
-  global.errorBoundaryState = errorBoundaryState;
-  global.createErrorBoundary = createErrorBoundary;
-}

package/src/lib/errors.js

@@ -1,69 +0,0 @@
-import { HTTP } from '@/config/constants';
-
-export class AppError extends Error {
-  constructor(message, code = 'ERROR', statusCode = HTTP.INTERNAL_ERROR, context = {}) {
-    super(message);
-    this.name = 'AppError';
-    this.code = code;
-    this.statusCode = statusCode;
-    this.context = context;
-  }
-
-  toJSON() {
-    return {
-      status: 'error',
-      message: this.message,
-      code: this.code,
-      statusCode: this.statusCode,
-      context: this.context,
-    };
-  }
-}
-
-export class ValidationError extends AppError {
-  constructor(message, errors = {}) {
-    super(message, 'VALIDATION_ERROR', HTTP.BAD_REQUEST);
-    this.errors = errors;
-  }
-
-  toJSON() {
-    return {
-      status: 'error',
-      message: this.message,
-      code: this.code,
-      statusCode: this.statusCode,
-      errors: this.errors,
-      context: this.context,
-    };
-  }
-}
-
-export class AuthError extends AppError {
-  constructor(message = 'Authentication required') {
-    super(message, 'UNAUTHORIZED', HTTP.UNAUTHORIZED);
-  }
-}
-
-export class ForbiddenError extends AppError {
-  constructor(message = 'Permission denied') {
-    super(message, 'FORBIDDEN', HTTP.FORBIDDEN);
-  }
-}
-
-export class NotFoundError extends AppError {
-  constructor(message = 'Not found') {
-    super(message, 'NOT_FOUND', HTTP.NOT_FOUND);
-  }
-}
-
-export class ConflictError extends AppError {
-  constructor(message = 'Conflict') {
-    super(message, 'CONFLICT', HTTP.CONFLICT);
-  }
-}
-
-export class ServerError extends AppError {
-  constructor(message = 'Server error', code = 'SERVER_ERROR') {
-    super(message, code, HTTP.INTERNAL_ERROR);
-  }
-}

package/src/lib/health-monitor.js

@@ -1,134 +0,0 @@
-import { getDatabase } from '@/engine';
-
-const healthState = {
-  checks: new Map(),
-  history: [],
-  lastCheck: null,
-  status: 'unknown'
-};
-
-export function registerHealthCheck(name, checkFn, options = {}) {
-  const { critical = false, timeout = 5000 } = options;
-
-  healthState.checks.set(name, {
-    name,
-    checkFn,
-    critical,
-    timeout,
-    lastResult: null,
-    lastCheck: null
-  });
-}
-
-export async function runHealthCheck(name) {
-  const check = healthState.checks.get(name);
-  if (!check) return null;
-
-  const start = Date.now();
-
-  try {
-    const timeoutPromise = new Promise((_, reject) =>
-      setTimeout(() => reject(new Error('Health check timeout')), check.timeout)
-    );
-
-    const checkPromise = check.checkFn();
-
-    await Promise.race([checkPromise, timeoutPromise]);
-
-    const result = {
-      status: 'healthy',
-      latency: Date.now() - start,
-      timestamp: new Date().toISOString()
-    };
-
-    check.lastResult = result;
-    check.lastCheck = Date.now();
-
-    return result;
-  } catch (error) {
-    const result = {
-      status: 'unhealthy',
-      error: String(error?.message || error),
-      latency: Date.now() - start,
-      timestamp: new Date().toISOString()
-    };
-
-    check.lastResult = result;
-    check.lastCheck = Date.now();
-
-    if (check.critical) {
-      console.error(`[HEALTH] Critical check failed: ${name}`, error);
-    }
-
-    return result;
-  }
-}
-
-export async function runAllHealthChecks() {
-  const results = {};
-  const checks = Array.from(healthState.checks.keys());
-
-  for (const name of checks) {
-    results[name] = await runHealthCheck(name);
-  }
-
-  const allHealthy = Object.values(results).every(r => r.status === 'healthy');
-  const criticalUnhealthy = Array.from(healthState.checks.values())
-    .filter(c => c.critical && c.lastResult?.status === 'unhealthy')
-    .length > 0;
-
-  const status = criticalUnhealthy ? 'critical' : allHealthy ? 'healthy' : 'degraded';
-
-  const summary = {
-    status,
-    timestamp: new Date().toISOString(),
-    checks: results,
-    uptime: process.uptime()
-  };
-
-  healthState.lastCheck = summary;
-  healthState.status = status;
-  healthState.history.push(summary);
-
-  if (healthState.history.length > 100) {
-    healthState.history.shift();
-  }
-
-  return summary;
-}
-
-export function getHealthStatus() {
-  return healthState.lastCheck || { status: 'unknown', checks: {} };
-}
-
-export function getHealthHistory() {
-  return healthState.history.slice(-20);
-}
-
-registerHealthCheck('database', async () => {
-  const db = getDatabase();
-  db.prepare('SELECT 1').get();
-}, { critical: true, timeout: 2000 });
-
-registerHealthCheck('memory', async () => {
-  const usage = process.memoryUsage();
-  const heapUsedMB = usage.heapUsed / 1024 / 1024;
-
-  if (heapUsedMB > 512) {
-    throw new Error(`High memory usage: ${heapUsedMB.toFixed(0)}MB`);
-  }
-}, { critical: false, timeout: 1000 });
-
-registerHealthCheck('uptime', async () => {
-  const uptime = process.uptime();
-  if (uptime < 5) {
-    throw new Error('Recently restarted');
-  }
-}, { critical: false, timeout: 100 });
-
-if (typeof global !== 'undefined') {
-  global.healthState = healthState;
-  global.runHealthCheck = runHealthCheck;
-  global.runAllHealthChecks = runAllHealthChecks;
-  global.getHealthStatus = getHealthStatus;
-}

package/src/lib/index-optimizer.js

@@ -1,96 +0,0 @@
-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/query-engine-write.js

@@ -1,221 +0,0 @@
-/**
- * Query Engine - Write operations (create, update, delete)
- * Adapted from moonlanding/src/lib/query-engine-write.js
- */
-
-import { getDatabase } from './database-core.js';
-import { getSpec } from '../config/spec-helpers.js';
-import { RECORD_STATUS } from '../config/constants.js';
-import { now, genId } from './database-core.js';
-import { executeHook } from './hook-engine.js';
-import { broadcastUpdate } from './realtime-server.js'; // Optional
-import { createLogger } from './logger.js';
-import { getConfigEngineSync } from './config-generator-engine.js';
-
-const db = getDatabase();
-const logger = createLogger('[WriteEngine]');
-
-/**
- * Create a new record
- * @param {string} entity - Entity name
- * @param {object} data - Record data
- * @param {object} user - User performing the action
- * @returns {object} Created record
- */
-export function create(entity, data, user) {
-  const spec = getSpec(entity);
-  if (!spec) throw new Error(`Entity not found: ${entity}`);
-
-  const tableName = entity === 'user' ? 'users' : entity;
-  const record = {
-    ...data,
-    id: genId(),
-    created_by: user?.id || null,
-    created_at: now(),
-    updated_at: null,
-    status: data.status || RECORD_STATUS.ACTIVE,
-  };
-
-  // Auto fields and field coercion
-  for (const [key, field] of Object.entries(spec.fields || {})) {
-    if (field.auto === 'increment') {
-      // Get max + 1 (simplified)
-      const maxRow = db.prepare(`SELECT MAX("${key}") as max FROM "${tableName}"`).get();
-      record[key] = (maxRow?.max || 0) + 1;
-    }
-    if (field.auto === 'uuid' && !record[key]) {
-      record[key] = genId();
-    }
-    if (field.auto === 'timestamp' && !record[key]) {
-      record[key] = now();
-    }
-  }
-
-  // Build INSERT
-  const columns = Object.keys(record).filter(k => record[k] !== undefined);
-  const placeholders = columns.map(() => '?').join(', ');
-  const values = columns.map(k => record[k]);
-
-  const sql = `INSERT INTO "${tableName}" (${columns.map(c => `"${c}"`).join(', ')}) VALUES (${placeholders})`;
-
-  try {
-    const info = db.prepare(sql).run(...values);
-    record.id = info.lastInsertRowid ? String(info.lastInsertRowid) : record.id;
-  } catch (e) {
-    logger.error(`Create ${entity} failed`, { error: e.message, data: record });
-    throw new Error(`Failed to create ${entity}: ${e.message}`);
-  }
-
-  // Execute hooks
-  executeHook(`create:${entity}:after`, {
-    entity,
-    id: record.id,
-    data: record,
-    user,
-  }).catch(err => logger.error('create hook error', err));
-
-  return record;
-}
-
-/**
- * Update an existing record
- * @param {string} entity
- * @param {string|number} id
- * @param {object} data - Fields to update
- * @param {object} user - User performing the action
- * @returns {object} Updated record
- */
-export function update(entity, id, data, user) {
-  const spec = getSpec(entity);
-  if (!spec) throw new Error(`Entity not found: ${entity}`);
-
-  const tableName = entity === 'user' ? 'users' : entity;
-
-  // Fetch existing record
-  const existing = db.prepare(`SELECT * FROM "${tableName}" WHERE id = ?`).get(id);
-  if (!existing) {
-    throw new Error(`${entity} with id ${id} not found`);
-  }
-
-  const updateData = {
-    ...data,
-    updated_at: now(),
-  };
-
-  // Build UPDATE statement
-  const setClauses = [];
-  const values = [];
-
-  for (const [key, value] of Object.entries(updateData)) {
-    if (value !== undefined) {
-      setClauses.push(`"${key}" = ?`);
-      values.push(value);
-    }
-  }
-
-  if (setClauses.length === 0) {
-    return existing; // Nothing to update
-  }
-
-  values.push(id);
-  const sql = `UPDATE "${tableName}" SET ${setClauses.join(', ')} WHERE id = ?`;
-
-  try {
-    db.prepare(sql).run(...values);
-  } catch (e) {
-    logger.error(`Update ${entity} ${id} failed`, { error: e.message, data: updateData });
-    throw new Error(`Failed to update ${entity}: ${e.message}`);
-  }
-
-  // Fetch updated record
-  const updated = db.prepare(`SELECT * FROM "${tableName}" WHERE id = ?`).get(id);
-
-  // Execute hooks
-  executeHook(`update:${entity}:after`, {
-    entity,
-    id,
-    data: updated,
-    before: existing,
-    after: updated,
-    user,
-  }).catch(err => logger.error('update hook error', err));
-
-  return updated;
-}
-
-/**
- * Delete (soft delete) a record
- * @param {string} entity
- * @param {string|number} id
- * @param {object} user - User performing the action
- * @returns {object} Deleted record
- */
-export function remove(entity, id) {
-  const spec = getSpec(entity);
-  if (!spec) throw new Error(`Entity not found: ${entity}`);
-
-  const tableName = entity === 'user' ? 'users' : entity;
-
-  const existing = db.prepare(`SELECT * FROM "${tableName}" WHERE id = ?`).get(id);
-  if (!existing) {
-    throw new Error(`${entity} with id ${id} not found`);
-  }
-
-  const hasStatus = spec.fields && 'status' in spec.fields;
-  const hasArchived = spec.fields && 'archived' in spec.fields;
-
-  let result;
-
-  if (hasStatus) {
-    // Soft delete
-    const sql = `UPDATE "${tableName}" SET status = ?, updated_at = ? WHERE id = ?`;
-    db.prepare(sql).run(RECORD_STATUS.DELETED, now(), id);
-    result = { ...existing, status: RECORD_STATUS.DELETED };
-  } else if (hasArchived) {
-    // Archive instead
-    const sql = `UPDATE "${tableName}" SET archived = 1, updated_at = ? WHERE id = ?`;
-    db.prepare(sql).run(now(), id);
-    result = { ...existing, archived: 1 };
-  } else {
-    // Hard delete
-    const sql = `DELETE FROM "${tableName}" WHERE id = ?`;
-    db.prepare(sql).run(id);
-    result = existing;
-  }
-
-  // Execute hooks
-  executeHook(`delete:${entity}:after`, {
-    entity,
-    id,
-    data: result,
-    user,
-  }).catch(err => logger.error('delete hook error', err));
-
-  return result;
-}
-
-/**
- * Bulk create multiple records
- * @param {string} entity
- * @param {Array<object>} records
- * @param {object} user
- * @returns {Array} Created records
- */
-export function bulkCreate(entity, records, user) {
-  return db.transaction((recordsData) => {
-    return recordsData.map(data => create(entity, data, user));
-  })(records);
-}
-
-/**
- * Hard delete all records (for cleanup)
- * @param {string} entity
- */
-export function hardDeleteAll(entity) {
-  const spec = getSpec(entity);
-  if (!spec) throw new Error(`Entity not found: ${entity}`);
-
-  const tableName = entity === 'user' ? 'users' : entity;
-  const sql = `DELETE FROM "${tableName}"`;
-  db.prepare(sql).run();
-}