thatcher 1.0.4 → 1.0.6

package/package.json

@@ -1,9 +1,26 @@
 {
   "name": "thatcher",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "A config-driven application framework for building data-intensive web apps without code. 100% feature-complete extraction from moonlanding.",
   "main": "src/index.js",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./engine.server": "./src/engine.server.js",
+    "./lib/*": "./src/lib/*.js",
+    "./lib/*.js": "./src/lib/*.js",
+    "./ui/*": "./src/ui/*.js",
+    "./ui/*.js": "./src/ui/*.js",
+    "./config/*": "./src/config/*.js",
+    "./config/*.js": "./src/config/*.js",
+    "./services/*": "./src/services/*.js",
+    "./services/*.js": "./src/services/*.js",
+    "./migration/*": "./src/migration/*.js",
+    "./validation/*": "./src/validation/*.js",
+    "./adapters/*": "./src/adapters/*.js",
+    "./plugins/*": "./src/plugins/*.js",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "thatcher": "src/cli.js",
     "thatcher-dev": "src/cli.js"

package/src/app/api/debug/[[...path]]/route.js

@@ -0,0 +1,217 @@
+/**
+ * Debug API Routes - Comprehensive observability endpoints
+ * Exposes all subsystem state as JSON for debugging and monitoring
+ */
+
+import { tracer } from '@/lib/tracing.js';
+import { perfProfiler } from '@/lib/perf-profiler.js';
+import { debugRegistry } from '@/lib/debug-registry.js';
+import { getExportSink } from '@/lib/export-sink.js';
+import { getXStateWorkflowEngine } from '@/lib/xstate-workflow-engine.js';
+import { getHyperFormulaService } from '@/lib/hyperformula-service.js';
+import { getBusyBaseAdapter } from '@/lib/busybase-adapter.js';
+import { hookEngine } from '@/lib/hook-engine.js';
+import { createLogger } from '@/lib/logger.js';
+
+const logger = createLogger('[DebugAPI]');
+
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body, null, 2), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function errorResponse(message, status = 400) {
+  return jsonResponse({ error: message }, status);
+}
+
+export async function GET(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+  const params = url.searchParams;
+
+  try {
+    if (path === '/api/debug') {
+      return jsonResponse({
+        subsystems: {
+          tracing: tracer.getStats(),
+          performance: perfProfiler.getAllStats().length,
+          xstate: getXStateWorkflowEngine()?.getStats() || null,
+          hyperformula: getHyperFormulaService()?.getStats() || null,
+          busybase: getBusyBaseAdapter()?.getStats() || null,
+          hooks: hookEngine.stats(),
+          export: getExportSink()?.getStats() || null,
+          health: debugRegistry.health(),
+        },
+        timestamp: Date.now(),
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+      });
+    }
+
+    if (path === '/api/debug/traces') {
+      const limit = parseInt(params.get('limit') || '100');
+      const status = params.get('status');
+      const minDuration = parseFloat(params.get('duration'));
+
+      let traces = tracer.getRecentTraces(limit * 10);
+
+      if (status) {
+        traces = traces.filter(t => t.status === status);
+      }
+
+      if (minDuration) {
+        traces = traces.filter(t => t.duration && t.duration > minDuration);
+      }
+
+      return jsonResponse({ traces: traces.slice(-limit), count: traces.length });
+    }
+
+    if (path.startsWith('/api/debug/traces/')) {
+      const traceId = path.split('/api/debug/traces/')[1];
+      const trace = tracer.getTraceById(traceId);
+      if (!trace) return errorResponse(`Trace "${traceId}" not found`, 404);
+      return jsonResponse(trace);
+    }
+
+    if (path === '/api/debug/formulas') {
+      const service = getHyperFormulaService();
+      if (!service) return errorResponse('HyperFormula not initialized', 503);
+      return jsonResponse({
+        sheets: service.listSheets(),
+        stats: service.getStats(),
+        log: service.getStats().evaluationLogSize,
+      });
+    }
+
+    if (path.startsWith('/api/debug/formulas/')) {
+      const service = getHyperFormulaService();
+      if (!service) return errorResponse('HyperFormula not initialized', 503);
+      const sheetName = decodeURIComponent(path.split('/api/debug/formulas/')[1]);
+      const info = service.getSheetInfo(sheetName);
+      if (!info) return errorResponse(`Sheet "${sheetName}" not found`, 404);
+      return jsonResponse({
+        ...info,
+        values: service.getSheetValues(sheetName),
+      });
+    }
+
+    if (path === '/api/debug/machines') {
+      const engine = getXStateWorkflowEngine();
+      if (!engine) return errorResponse('XState engine not initialized', 503);
+      return jsonResponse({
+        actors: engine.getActiveActors(),
+        machines: engine.getCachedMachines(),
+        stats: engine.getStats(),
+      });
+    }
+
+    if (path.startsWith('/api/debug/machines/')) {
+      const engine = getXStateWorkflowEngine();
+      if (!engine) return errorResponse('XState engine not initialized', 503);
+      const actorKey = path.split('/api/debug/machines/')[1];
+      const snapshot = engine.getSnapshot(...actorKey.split(':'));
+      if (!snapshot) return errorResponse(`Actor "${actorKey}" not found`, 404);
+      return jsonResponse({
+        actorKey,
+        value: snapshot.value,
+        context: snapshot.context,
+        done: snapshot.done,
+      });
+    }
+
+    if (path === '/api/debug/hooks') {
+      return jsonResponse({
+        stats: hookEngine.stats(),
+        events: Object.keys(hookEngine.stats()),
+        totalHandlers: Object.values(hookEngine.stats()).reduce((a, b) => a + b, 0),
+      });
+    }
+
+    if (path === '/api/debug/database') {
+      const dbMonitor = globalThis.__dbMonitor;
+      const busybase = getBusyBaseAdapter();
+
+      return jsonResponse({
+        monitor: dbMonitor ? {
+          activeQueries: dbMonitor.activeQueries?.length || 0,
+          slowQueries: dbMonitor.slowQueries?.slice(-20) || [],
+          stats: dbMonitor.stats?.(),
+        } : null,
+        busybase: busybase ? busybase.getStats() : null,
+      });
+    }
+
+    if (path === '/api/debug/realtime') {
+      const channels = globalThis.__channels || {};
+      return jsonResponse({
+        channels: Object.keys(channels),
+        subscribers: Object.entries(channels).map(([name, ch]) => ({
+          name,
+          subscriberCount: ch.subscribers?.length || 0,
+        })),
+      });
+    }
+
+    if (path === '/api/debug/health') {
+      return jsonResponse(debugRegistry.health());
+    }
+
+    if (path === '/api/debug/metrics') {
+      const metrics = globalThis.__metrics;
+      return jsonResponse({
+        metrics: metrics ? {
+          requests: metrics.requests?.slice(-100) || [],
+          slowQueries: metrics.slowQueries || [],
+          errors: metrics.errors?.slice(-50) || [],
+          stats: metrics.getStats?.(),
+        } : null,
+        performance: perfProfiler.getAllStats(),
+        slowOperations: perfProfiler.getSlowOperations(),
+        regressions: perfProfiler.detectRegressions(),
+      });
+    }
+
+    if (path === '/api/debug/system') {
+      return jsonResponse({
+        pid: process.pid,
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        cpuUsage: process.cpuUsage(),
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        env: {
+          NODE_ENV: process.env.NODE_ENV,
+          DEBUG: process.env.DEBUG,
+          PORT: process.env.PORT,
+        },
+      });
+    }
+
+    if (path === '/api/debug/perf') {
+      return jsonResponse({
+        stats: perfProfiler.getAllStats(),
+        slow: perfProfiler.getSlowOperations(),
+        regressions: perfProfiler.detectRegressions(),
+        alerts: perfProfiler.getAlerts(),
+        thresholds: Object.fromEntries(perfProfiler._thresholds),
+      });
+    }
+
+    if (path === '/api/debug/export') {
+      const sink = getExportSink();
+      return jsonResponse(sink ? sink.getStats() : { enabled: false });
+    }
+
+    if (path === '/api/debug/registry') {
+      return jsonResponse(debugRegistry.toJSON());
+    }
+
+    return errorResponse(`Unknown debug endpoint: ${path}`, 404);
+  } catch (error) {
+    logger.error('Debug API error', { error: error.message, path });
+    return errorResponse(error.message, 500);
+  }
+}

package/src/app/api/formula/[[...path]]/route.js

@@ -0,0 +1,142 @@
+/**
+ * Formula API Routes - HyperFormula operations via HTTP
+ */
+
+import { getHyperFormulaService, createHyperFormulaService } from '@/lib/hyperformula-service.js';
+import { createLogger } from '@/lib/logger.js';
+
+const logger = createLogger('[FormulaAPI]');
+
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function errorResponse(message, status = 400) {
+  return jsonResponse({ error: message }, status);
+}
+
+async function ensureService() {
+  let service = getHyperFormulaService();
+  if (!service) {
+    service = await createHyperFormulaService();
+  }
+  return service;
+}
+
+export async function GET(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+
+  if (path === '/api/formula/sheets') {
+    const service = await ensureService();
+    return jsonResponse({ sheets: service.listSheets(), stats: service.getStats() });
+  }
+
+  if (path.startsWith('/api/formula/sheet/')) {
+    const sheetName = decodeURIComponent(path.split('/api/formula/sheet/')[1]);
+    const service = await ensureService();
+    const info = service.getSheetInfo(sheetName);
+    if (!info) return errorResponse(`Sheet "${sheetName}" not found`, 404);
+
+    return jsonResponse({
+      ...info,
+      values: service.getSheetValues(sheetName),
+    });
+  }
+
+  return errorResponse('Not found', 404);
+}
+
+export async function POST(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+
+  try {
+    const body = await request.json();
+
+    if (path === '/api/formula/evaluate') {
+      const service = await ensureService();
+
+      if (body.formula) {
+        const { result, duration } = service.evaluateFormula(body.formula);
+        return jsonResponse({ formula: body.formula, result, durationMs: Math.round(duration * 100) / 100 });
+      }
+
+      if (body.sheet && body.cell && body.value !== undefined) {
+        service.setCellContents(body.sheet, body.cell, body.value);
+        return jsonResponse({ success: true, sheet: body.sheet, cell: body.cell });
+      }
+
+      return errorResponse('Missing formula or sheet/cell/value', 400);
+    }
+
+    if (path === '/api/formula/sheet') {
+      const service = await ensureService();
+
+      if (body.action === 'create') {
+        const { name, sheetId } = service.createSheet(body.name, body.data);
+        return jsonResponse({ name, sheetId }, 201);
+      }
+
+      if (body.action === 'remove') {
+        service.removeSheet(body.name);
+        return jsonResponse({ success: true });
+      }
+
+      if (body.action === 'rename') {
+        service.renameSheet(body.oldName, body.newName);
+        return jsonResponse({ success: true });
+      }
+
+      if (body.action === 'setContent') {
+        service.setSheetContent(body.name, body.data);
+        return jsonResponse({ success: true });
+      }
+
+      return errorResponse('Unknown action. Use: create, remove, rename, setContent', 400);
+    }
+
+    if (path === '/api/formula/validate') {
+      const service = await ensureService();
+
+      if (!body.formula) {
+        return errorResponse('Missing formula', 400);
+      }
+
+      const result = service.validateFormula(body.formula);
+      return jsonResponse(result);
+    }
+
+    if (path === '/api/formula/cell') {
+      const service = await ensureService();
+
+      if (!body.sheet || !body.cell) {
+        return errorResponse('Missing sheet or cell', 400);
+      }
+
+      const value = service.getCellValue(body.sheet, body.cell);
+      const formula = service.getCellFormula(body.sheet, body.cell);
+
+      return jsonResponse({ sheet: body.sheet, cell: body.cell, value, formula });
+    }
+
+    if (path === '/api/formula/dependencies') {
+      const service = await ensureService();
+
+      if (!body.sheet || !body.cell) {
+        return errorResponse('Missing sheet or cell', 400);
+      }
+
+      const deps = service.getDependencies(body.sheet, body.cell);
+      return jsonResponse({ sheet: body.sheet, cell: body.cell, dependencies: deps });
+    }
+
+    return errorResponse('Not found', 404);
+  } catch (error) {
+    logger.error('Formula API error', { error: error.message });
+    return errorResponse(error.message, 500);
+  }
+}

package/src/cli.js

@@ -12,7 +12,6 @@
  */
 
 import { startThatcher, Thatcher } from './index.js';
-import { command } from 'commander'; // We'll use simple args parsing
 import * as readline from 'readline';
 
 const args = process.argv.slice(2);

package/src/config/spec-helpers.js

@@ -10,6 +10,12 @@
  * @returns {object|null} Entity specification or null if not found
  */
 export function getSpec(name, configEngine) {
+  // Callers across the framework invoke getSpec(name) without threading the engine
+  // (moon's getSpec self-resolved it). Fall back to the singleton when omitted.
+  if (!configEngine) {
+    const g = globalThis.__thatcherConfigEngine;
+    if (g) configEngine = g;
+  }
   try {
     return configEngine.generateEntitySpec(name);
   } catch (error) {

package/src/engine.server.js

@@ -7,8 +7,8 @@ import { Lucia } from 'lucia';
 import { BetterSqlite3Adapter } from '@lucia-auth/adapter-sqlite';
 import { Google } from 'arctic';
 import bcrypt from 'bcrypt';
-import { getDatabase } from './database-core.js';
-import { buildConfig, hasGoogleAuth } from '../config/env.js';
+import { getDatabase } from './lib/database-core.js';
+import { buildConfig, hasGoogleAuth } from './config/env.js';
 
 let _lucia = null;
 let _google = null;

package/src/index.js

@@ -116,9 +116,19 @@ export class Thatcher {
       throw new Error('No configuration provided. Supply config path or object.');
     }
 
-    // Init config engine
-    const { ConfigGeneratorEngine } = await import(resolveModule('./src/lib/config-generator-engine.js'));
+    // Init config engine AND set the module-level singleton that getConfigEngineSync()
+    // returns. The server, plugin loader, and generateEntitySpec all read the singleton
+    // via getConfigEngineSync(), so a locally-newed engine alone leaves them uninitialized.
+    const engineMod = await import(resolveModule('./lib/config-generator-engine.js'));
+    const { ConfigGeneratorEngine, setConfigEngine } = engineMod;
     _configEngine = new ConfigGeneratorEngine(masterConfig);
+    setConfigEngine(_configEngine);
+    this.configEngine = _configEngine;
+    // Cross-module-instance bridge: tsx can load config-generator-engine.js as two
+    // distinct module instances (static import vs resolveModule file:// URL), so the
+    // module-level singleton set above is not always visible to server.js. globalThis
+    // is the one registry both instances share.
+    globalThis.__thatcherConfigEngine = _configEngine;
 
     // Debug exposure
     if (globalThis.__debug__) {
@@ -220,7 +230,7 @@ export class Thatcher {
     const port = opts.port || this.options.server.port;
     const host = opts.host || this.options.server.host;
 
-    const { createServer } = await import(resolveModule('./src/server/server.js'));
+    const { createServer } = await import(resolveModule('./server/server.js'));
     _server = createServer({
       thatcher: this,
       config: this.config,
@@ -280,44 +290,44 @@ export class Thatcher {
   // === CRUD operations ===
 
   async list(entity, where = {}, opts = {}) {
-    const { list } = await import(resolveModule('./src/lib/query-engine.js'));
+    const { list } = await import(resolveModule('./lib/query-engine.js'));
     return list(entity, where, opts);
   }
 
   async get(entity, id) {
-    const { get } = await import(resolveModule('./src/lib/query-engine.js'));
+    const { get } = await import(resolveModule('./lib/query-engine.js'));
     return get(entity, id);
   }
 
   async create(entity, data, user) {
-    const { create } = await import(resolveModule('./src/lib/query-engine-write.js'));
+    const { create } = await import(resolveModule('./lib/query-engine-write.js'));
     return create(entity, data, user);
   }
 
   async update(entity, id, data, user) {
-    const { update } = await import(resolveModule('./src/lib/query-engine-write.js'));
+    const { update } = await import(resolveModule('./lib/query-engine-write.js'));
     return update(entity, id, data, user);
   }
 
   async delete(entity, id) {
-    const { remove } = await import(resolveModule('./src/lib/query-engine-write.js'));
+    const { remove } = await import(resolveModule('./lib/query-engine-write.js'));
     return remove(entity, id);
   }
 
   async search(entity, query, where = {}, opts = {}) {
-    const { search } = await import(resolveModule('./src/lib/query-engine.js'));
+    const { search } = await import(resolveModule('./lib/query-engine.js'));
     return search(entity, query, where, opts);
   }
 
   // === Workflow ===
 
   async transition(entityType, entityId, workflowName, toState, user, reason = '') {
-    const { transition } = await import(resolveModule('./src/lib/workflow-engine.js'));
+    const { transition } = await import(resolveModule('./lib/workflow-engine.js'));
     return transition(entityType, entityId, workflowName, toState, user, reason);
   }
 
   async getAvailableTransitions(workflowName, currentState, user, record = null) {
-    const { getAvailableTransitions } = await import(resolveModule('./src/lib/workflow-engine.js'));
+    const { getAvailableTransitions } = await import(resolveModule('./lib/workflow-engine.js'));
     return getAvailableTransitions(workflowName, currentState, user, record);
   }
 

package/src/lib/auth-middleware.js

@@ -3,8 +3,8 @@
  * Adapted from moonlanding/src/lib/auth-middleware.js
  */
 
-import { getUser, lucia } from '../engine.server.js'; // Will need to adapt
-import { getSpec } from './spec-helpers.js';
+import { getUser, getLucia } from '../engine.server.js';
+import { getSpec } from '../config/spec-helpers.js';
 import { can } from '../services/permission.service.js';
 import { UnauthorizedError, PermissionError, NotFoundError } from './error-handler.js';
 
@@ -26,6 +26,8 @@ const actionMap = {
 export function getSessionToken(req) {
   const cookieHeader = req?.headers?.cookie || '';
   if (!cookieHeader) return null;
+  let lucia = null;
+  try { lucia = getLucia(); } catch { /* auth not initialized yet */ }
   const cookieName = lucia?.sessionCookieName || 'thatcher_session';
   const match = cookieHeader.split(';').find(c => c.trim().startsWith(cookieName + '='));
   if (!match) return null;

package/src/lib/busybase-adapter.js

@@ -0,0 +1,162 @@
+/**
+ * BusyBase Database Adapter - Supabase-compatible database layer for Thatcher
+ * Supports embedded mode (in-process) and remote mode (HTTP client)
+ */
+
+import { createLogger } from './logger.js';
+import { hookEngine } from './hook-engine.js';
+
+const logger = createLogger('[BusyBase]');
+
+let _bbInstance = null;
+let _bbMode = null;
+let _bbConfig = null;
+let _realtimeChannels = new Map();
+
+export class BusyBaseAdapter {
+  constructor(config = {}) {
+    this.config = {
+      mode: config.mode || 'embedded',
+      url: config.url || 'http://localhost:54321',
+      project: config.project || 'local',
+      dir: config.dir || 'busybase_data',
+      hooks: config.hooks !== false,
+      ...config,
+    };
+    this.initialized = false;
+    this._client = null;
+    this._embedded = null;
+  }
+
+  async init() {
+    if (this.initialized) return this;
+
+    if (this.config.mode === 'embedded') {
+      const { createEmbedded } = await import('busybase/embedded');
+      this._embedded = await createEmbedded({ dir: this.config.dir });
+      this._client = this._embedded;
+      logger.info('Embedded mode initialized', { dir: this.config.dir });
+    } else {
+      const { default: BB, createClient } = await import('busybase');
+      this._client = BB(this.config.url, this.config.project);
+      logger.info('Remote mode initialized', { url: this.config.url });
+    }
+
+    if (this.config.hooks) {
+      this._registerBusyBaseHooks();
+    }
+
+    this.initialized = true;
+    _bbInstance = this;
+    _bbMode = this.config.mode;
+    _bbConfig = this.config;
+
+    if (globalThis.__debug__) {
+      globalThis.__debug__.expose('busybase', {
+        mode: () => _bbMode,
+        config: () => _bbConfig,
+        client: () => this._client,
+        channels: () => Array.from(_realtimeChannels.keys()),
+        stats: () => this.getStats(),
+      }, 'BusyBase Adapter');
+    }
+
+    return this;
+  }
+
+  _registerBusyBaseHooks() {
+    const hookMap = {
+      beforeInsert: 'beforeInsert',
+      afterInsert: 'afterInsert',
+      beforeUpdate: 'beforeUpdate',
+      afterUpdate: 'afterUpdate',
+      beforeDelete: 'beforeDelete',
+      afterDelete: 'afterDelete',
+      beforeSelect: 'beforeSelect',
+      afterSelect: 'afterSelect',
+    };
+
+    for (const [bbHook, thEvent] of Object.entries(hookMap)) {
+      if (globalThis.__busybase_hooks__) {
+        globalThis.__busybase_hooks__[bbHook] = async (table, data, ...rest) => {
+          const context = { table, data, ...rest };
+          await hookEngine.execute(`busybase:${thEvent}`, context);
+          return context.data;
+        };
+      }
+    }
+  }
+
+  async subscribe(table, callback, event = '*') {
+    if (this.config.mode === 'embedded') {
+      logger.warn('Realtime subscriptions not supported in embedded mode');
+      return () => {};
+    }
+
+    const channelName = `${table}-${event}-${Date.now()}`;
+    const channel = this._client.channel(channelName)
+      .on('postgres_changes', { event, schema: 'public', table }, (payload) => {
+        callback(payload);
+      })
+      .subscribe((status) => {
+        logger.info('Channel subscription', { table, event, status });
+      });
+
+    _realtimeChannels.set(channelName, { channel, table, event, callback });
+
+    return () => {
+      channel.unsubscribe();
+      _realtimeChannels.delete(channelName);
+    };
+  }
+
+  async unsubscribeAll() {
+    for (const [name, { channel }] of _realtimeChannels.entries()) {
+      channel.unsubscribe();
+    }
+    _realtimeChannels.clear();
+    if (this._client?.removeAllChannels) {
+      this._client.removeAllChannels();
+    }
+  }
+
+  getClient() {
+    return this._client;
+  }
+
+  getStats() {
+    return {
+      mode: _bbMode,
+      channels: _realtimeChannels.size,
+      initialized: this.initialized,
+    };
+  }
+
+  async close() {
+    await this.unsubscribeAll();
+    _bbInstance = null;
+    _bbMode = null;
+    _bbConfig = null;
+    this.initialized = false;
+  }
+}
+
+export async function createBusyBaseAdapter(config = {}) {
+  const adapter = new BusyBaseAdapter(config);
+  await adapter.init();
+  return adapter;
+}
+
+export function getBusyBaseAdapter() {
+  return _bbInstance;
+}
+
+export function getBusyBaseClient() {
+  return _bbInstance?._client;
+}
+
+export function isBusyBaseAvailable() {
+  return _bbInstance?.initialized === true;
+}
+
+export default BusyBaseAdapter;