thatcher 1.0.4

package/src/lib/error-boundary.js

@@ -0,0 +1,134 @@
+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/error-handler.js

@@ -0,0 +1,84 @@
+/**
+ * Error Handling - Centralized error types and utilities
+ */
+
+export class AppError extends Error {
+  constructor(message, code = 'APP_ERROR', status = 500, details = null) {
+    super(message);
+    this.name = 'AppError';
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, AppError);
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message = 'Authentication required') {
+    super(message, 'UNAUTHORIZED', 401);
+    this.name = 'UnauthorizedError';
+  }
+}
+
+export class PermissionError extends AppError {
+  constructor(message = 'Permission denied') {
+    super(message, 'PERMISSION_DENIED', 403);
+    this.name = 'PermissionError';
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(entity = 'Resource', id = null) {
+    const msg = id ? `${entity} with id ${id} not found` : `${entity} not found`;
+    super(msg, 'NOT_FOUND', 404);
+    this.name = 'NotFoundError';
+    this.entity = entity;
+    this.id = id;
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message = 'Validation failed', errors = {}) {
+    super(message, 'VALIDATION_ERROR', 422);
+    this.name = 'ValidationError';
+    this.errors = errors;
+  }
+}
+
+export class DatabaseError extends AppError {
+  constructor(operation = 'Database operation', originalError = null) {
+    super(`Database ${operation} failed: ${originalError?.message || 'unknown error'}`, 'DATABASE_ERROR', 500);
+    this.name = 'DatabaseError';
+    this.originalError = originalError;
+  }
+}
+
+export class ConflictError extends AppError {
+  constructor(message = 'Resource already exists') {
+    super(message, 'CONFLICT', 409);
+    this.name = 'ConflictError';
+  }
+}
+
+export class BadRequestError extends AppError {
+  constructor(message = 'Invalid request') {
+    super(message, 'BAD_REQUEST', 400);
+    this.name = 'BadRequestError';
+  }
+}
+
+/**
+ * Create an error logger
+ * @param {string} context
+ * @returns {object}
+ */
+export function createErrorLogger(context = '') {
+  return {
+    error: (msg, meta = {}) => {
+      console.error(`[${context}] ${msg}`, meta);
+    },
+    warn: (msg, meta = {}) => {
+      console.warn(`[${context}] ${msg}`, meta);
+    },
+  };
+}

package/src/lib/error-recovery.js

@@ -0,0 +1,190 @@
+import { retryWithBackoff, withCircuitBreaker, checkpoint, restoreCheckpoint, logRecovery, normalizeError } from '@/lib/error-handler';
+import { AppError } from '@/lib/errors';
+import { HTTP } from '@/config/constants';
+
+const recoveryState = { supervisors: new Map(), lastHealthCheck: null };
+
+export function createSupervisor(name, fn, options = {}) {
+  const { maxRestarts = 5, restartWindow = 60000, onRestart = null } = options;
+
+  const supervisor = {
+    name,
+    fn,
+    restarts: [],
+    state: 'running',
+    lastError: null,
+    maxRestarts,
+    restartWindow,
+    onRestart
+  };
+
+  recoveryState.supervisors.set(name, supervisor);
+  return supervisor;
+}
+
+export async function supervise(name, fn, options = {}) {
+  const supervisor = recoveryState.supervisors.get(name) || createSupervisor(name, fn, options);
+
+  const now = Date.now();
+  supervisor.restarts = supervisor.restarts.filter(t => now - t < supervisor.restartWindow);
+
+  if (supervisor.restarts.length >= supervisor.maxRestarts) {
+    const error = new AppError(
+      `Supervisor ${name} exceeded restart limit`,
+      'SUPERVISOR_LIMIT',
+      HTTP.INTERNAL_ERROR,
+      { restarts: supervisor.restarts.length }
+    );
+    supervisor.state = 'failed';
+    supervisor.lastError = error;
+    console.error(`[SUPERVISOR] ${name} failed permanently after ${supervisor.restarts.length} restarts`);
+    throw error;
+  }
+
+  try {
+    supervisor.state = 'running';
+    const result = await fn();
+    supervisor.restarts = [];
+    return result;
+  } catch (error) {
+    supervisor.restarts.push(now);
+    supervisor.lastError = normalizeError(error);
+
+    if (supervisor.onRestart) {
+      await supervisor.onRestart(error, supervisor.restarts.length);
+    }
+
+    logRecovery({ supervisor: name, restarts: supervisor.restarts.length }, 'supervisor_restart');
+
+    if (supervisor.restarts.length < supervisor.maxRestarts) {
+      const delay = Math.min(1000 * Math.pow(2, supervisor.restarts.length - 1), 30000);
+      console.warn(`[SUPERVISOR] ${name} restarting in ${delay}ms (attempt ${supervisor.restarts.length})`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+      return supervise(name, fn, options);
+    }
+
+    throw error;
+  }
+}
+
+export async function degradedMode(fn, fallback, options = {}) {
+  const { timeout = 5000 } = options;
+
+  try {
+    const result = await Promise.race([
+      fn(),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Operation timeout')), timeout)
+      )
+    ]);
+    return { mode: 'normal', result };
+  } catch (error) {
+    console.warn('[DEGRADED] Falling back to degraded mode', { error: error.message });
+    const result = await fallback();
+    return { mode: 'degraded', result };
+  }
+}
+
+export async function healthCheck(checks) {
+  const results = {};
+  const timestamp = new Date().toISOString();
+
+  for (const [name, checkFn] of Object.entries(checks)) {
+    try {
+      const start = Date.now();
+      await checkFn();
+      results[name] = { status: 'healthy', latency: Date.now() - start };
+    } catch (error) {
+      results[name] = {
+        status: 'unhealthy',
+        error: String(error.message || error),
+        timestamp
+      };
+    }
+  }
+
+  const overall = Object.values(results).every(r => r.status === 'healthy') ? 'healthy' : 'degraded';
+
+  recoveryState.lastHealthCheck = { timestamp, overall, checks: results };
+
+  return { status: overall, timestamp, checks: results };
+}
+
+export function isolateFailure(fn, defaultValue = null) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      console.error('[ISOLATE] Failure contained', {
+        function: fn.name,
+        error: String(error.message || error)
+      });
+      return defaultValue;
+    }
+  };
+}
+
+export async function withRecovery(fn, options = {}) {
+  const {
+    retry = true,
+    circuitBreaker = null,
+    supervisor = null,
+    checkpointName = null,
+    fallback = null
+  } = options;
+
+  let operation = fn;
+
+  if (checkpointName) {
+    const savedState = restoreCheckpoint(checkpointName);
+    if (savedState) {
+    }
+  }
+
+  if (supervisor) {
+    operation = () => supervise(supervisor, operation, options);
+  }
+
+  if (circuitBreaker) {
+    operation = () => withCircuitBreaker(circuitBreaker, operation, options);
+  }
+
+  if (retry) {
+    operation = () => retryWithBackoff(operation, options);
+  }
+
+  try {
+    const result = await operation();
+
+    if (checkpointName) {
+      checkpoint(checkpointName, result);
+    }
+
+    return result;
+  } catch (error) {
+    if (fallback) {
+      console.warn('[RECOVERY] Using fallback after error', { error: error.message });
+      return fallback();
+    }
+    throw error;
+  }
+}
+
+export function getSupervisorStats() {
+  return {
+    supervisors: Array.from(recoveryState.supervisors.entries()).map(([name, s]) => ({
+      name,
+      state: s.state,
+      restarts: s.restarts.length,
+      lastError: s.lastError ? String(s.lastError.message) : null
+    })),
+    lastHealthCheck: recoveryState.lastHealthCheck
+  };
+}
+
+if (typeof global !== 'undefined') {
+  global.recoveryState = recoveryState;
+  global.getSupervisorStats = getSupervisorStats;
+  global.supervise = supervise;
+  global.healthCheck = healthCheck;
+}

package/src/lib/error-resilience.js

@@ -0,0 +1,130 @@
+import { HTTP } from '@/config/constants';
+import { AppError } from '@/lib/errors';
+import { normalizeError } from '@/lib/error-handler';
+
+const errorState = { errors: [], circuitBreakers: new Map(), checkpoints: new Map() };
+
+export async function retryWithBackoff(fn, options = {}) {
+  const { maxAttempts = 3, delay = 1000, backoff = 2, context = {} } = options;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt === maxAttempts) {
+        const normalized = normalizeError(error);
+        console.error(`[RETRY] Final attempt failed:`, { ...context, attempt, error: normalized.toJSON() });
+        throw normalized;
+      }
+
+      const waitTime = delay * Math.pow(backoff, attempt - 1);
+      console.warn(`[RETRY] Attempt ${attempt} failed, retrying in ${waitTime}ms`, context);
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+    }
+  }
+}
+
+export function createCircuitBreaker(name, options = {}) {
+  const { threshold = 5, resetTimeout = 30000 } = options;
+
+  if (!errorState.circuitBreakers.has(name)) {
+    errorState.circuitBreakers.set(name, {
+      failures: 0,
+      state: 'closed',
+      lastFailure: null,
+      nextAttempt: null,
+      threshold,
+      resetTimeout
+    });
+  }
+
+  return errorState.circuitBreakers.get(name);
+}
+
+export async function withCircuitBreaker(name, fn, options = {}) {
+  const breaker = createCircuitBreaker(name, options);
+
+  if (breaker.state === 'open') {
+    const now = Date.now();
+    if (breaker.nextAttempt && now < breaker.nextAttempt) {
+      throw new AppError(`Service unavailable: ${name}`, 'CIRCUIT_OPEN', HTTP.SERVICE_UNAVAILABLE, { nextAttempt: breaker.nextAttempt });
+    }
+    breaker.state = 'half-open';
+  }
+
+  try {
+    const result = await fn();
+    if (breaker.state === 'half-open') {
+    }
+    breaker.failures = 0;
+    breaker.state = 'closed';
+    return result;
+  } catch (error) {
+    breaker.failures++;
+    breaker.lastFailure = Date.now();
+
+    if (breaker.failures >= breaker.threshold) {
+      breaker.state = 'open';
+      breaker.nextAttempt = Date.now() + breaker.resetTimeout;
+      console.error(`[CIRCUIT] ${name} opened after ${breaker.failures} failures`);
+    }
+
+    throw error;
+  }
+}
+
+export function checkpoint(name, state) {
+  errorState.checkpoints.set(name, {
+    state: JSON.parse(JSON.stringify(state)),
+    timestamp: Date.now()
+  });
+}
+
+export function restoreCheckpoint(name) {
+  const cp = errorState.checkpoints.get(name);
+  if (cp) {
+    return cp.state;
+  }
+  return null;
+}
+
+export function logRecovery(context, action) {
+  errorState.errors.push({
+    type: 'recovery',
+    context,
+    action,
+    timestamp: new Date().toISOString()
+  });
+  if (errorState.errors.length > 1000) errorState.errors.shift();
+}
+
+export function getErrorStats() {
+  const recent = errorState.errors.slice(-100);
+  const byType = {};
+
+  for (const err of recent) {
+    byType[err.type || 'error'] = (byType[err.type || 'error'] || 0) + 1;
+  }
+
+  return {
+    total: errorState.errors.length,
+    recent: recent.length,
+    byType,
+    circuitBreakers: Array.from(errorState.circuitBreakers.entries()).map(([name, state]) => ({
+      name,
+      state: state.state,
+      failures: state.failures,
+      lastFailure: state.lastFailure ? new Date(state.lastFailure).toISOString() : null
+    })),
+    checkpoints: Array.from(errorState.checkpoints.keys())
+  };
+}
+
+if (typeof global !== 'undefined') {
+  global.errorState = errorState;
+  global.getErrorStats = getErrorStats;
+  global.retryWithBackoff = retryWithBackoff;
+  global.withCircuitBreaker = withCircuitBreaker;
+  global.checkpoint = checkpoint;
+  global.restoreCheckpoint = restoreCheckpoint;
+}

package/src/lib/errors.js

@@ -0,0 +1,69 @@
+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);
+  }
+}