thatcher 1.0.7 → 1.0.34

package/src/engine.server.js

@@ -1,28 +1,18 @@
-/**
- * Auth Engine - Lucia session management and Google OAuth
- * Simplified extraction from moonlanding/src/engine.server.js
- */
-
+// Simplified extraction from moonlanding/src/engine.server.js
 import { Lucia } from 'lucia';
-import { BetterSqlite3Adapter } from '@lucia-auth/adapter-sqlite';
 import { Google } from 'arctic';
 import bcrypt from 'bcrypt';
-import { getDatabase } from './lib/database-core.js';
+import { BusyBaseLuciaAdapter } from './lib/busybase-lucia-adapter.js';
 import { buildConfig, hasGoogleAuth } from './config/env.js';
 
 let _lucia = null;
 let _google = null;
 let _adapter = null;
 
-/**
- * Initialize auth engine with database and config
- * @param {object} [config] - Optional config override
- */
 export function initAuth(config = null) {
   const cfg = config || buildConfig();
-  const db = getDatabase(cfg.db.path);
 
-  _adapter = new BetterSqlite3Adapter(db, { user: 'users', session: 'sessions' });
+  _adapter = new BusyBaseLuciaAdapter();
 
   _lucia = new Lucia(_adapter, {
     sessionCookie: {
@@ -54,29 +44,16 @@ export function initAuth(config = null) {
   return { lucia: _lucia, google: _google };
 }
 
-/**
- * Get Lucia instance
- * @returns {Lucia}
- */
 export function getLucia() {
   if (!_lucia) initAuth();
   return _lucia;
 }
 
-/**
- * Get Google OAuth client
- * @returns {Google|null}
- */
 export function getGoogle() {
   if (!_google) initAuth();
   return _google;
 }
 
-/**
- * Parse cookies from header
- * @param {string} cookieHeader
- * @returns {object}
- */
 function parseCookies(cookieHeader) {
   const cookies = {};
   if (!cookieHeader) return cookies;
@@ -89,18 +66,10 @@ function parseCookies(cookieHeader) {
 
 let _currentRequest = null;
 
-/**
- * Set current request context (for auth)
- * @param {object} req
- */
 export function setCurrentRequest(req) {
   _currentRequest = req;
 }
 
-/**
- * Get current user from session
- * @returns {object|null}
- */
 export async function getUser() {
   try {
     const request = _currentRequest;
@@ -120,21 +89,12 @@ export async function getUser() {
   }
 }
 
-/**
- * Require user (throw if not authenticated)
- * @returns {Promise<object>}
- */
 export async function requireUser() {
   const user = await getUser();
   if (!user) throw new Error('Unauthorized');
   return user;
 }
 
-/**
- * Create a new session
- * @param {string} userId
- * @returns {{session: object, sessionCookie: object}}
- */
 export async function createSession(userId) {
   const lucia = getLucia();
   // Note: cookies() requires Next.js polyfill in moonlanding; for SDK we return session data
@@ -143,66 +103,36 @@ export async function createSession(userId) {
   return { session, sessionCookie };
 }
 
-/**
- * Invalidate current session
- */
 export async function invalidateSession() {
   const lucia = getLucia();
   // Simplified - caller handles cookie clearing
   // In full app this uses @lucia-auth/adapter-sqlite's cookie management
 }
 
-/**
- * Hash password with bcrypt
- * @param {string} password
- * @returns {Promise<string>}
- */
 export async function hashPassword(password) {
   return bcrypt.hash(password, 12);
 }
 
-/**
- * Verify password
- * @param {string} password
- * @param {string} hash
- * @returns {Promise<boolean>}
- */
 export async function verifyPassword(password, hash) {
   return bcrypt.compare(password, hash);
 }
 
-/**
- * Get user by email
- * @param {string} email
- * @returns {object|null}
- */
-export function getUserByEmail(email) {
-  const db = getDatabase();
-  return db.prepare('SELECT * FROM users WHERE email = ?').get(email);
+export async function getUserByEmail(email) {
+  const { getBy } = await import('./lib/busybase-store.js');
+  return getBy('user', 'email', email);
 }
 
-/**
- * Create a new user
- * @param {object} userData
- * @returns {object}
- */
 export async function createUser(userData) {
   const hashedPassword = await hashPassword(userData.password);
-  const { create } = await import('./query-engine-write.js');
+  const { create } = await import('./lib/busybase-store.js');
   return create('user', {
     ...userData,
     password: hashedPassword,
   }, { id: 'system' });
 }
 
-/**
- * Authenticate user with credentials
- * @param {string} email
- * @param {string} password
- * @returns {object|null} User if valid, null otherwise
- */
 export async function authenticate(email, password) {
-  const user = getUserByEmail(email);
+  const user = await getUserByEmail(email);
   if (!user) return null;
 
   const valid = await verifyPassword(password, user.password);

package/src/index.js

@@ -1,12 +1,10 @@
-/**
- * Thatcher SDK - Configuration-Driven Application Framework
- */
-
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { createLogger } from './lib/logger.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const log = createLogger('[Thatcher]');
 
 // Forward-declare so we can set later
 let _configEngine = null;
@@ -15,19 +13,18 @@ let _pluginsLoaded = false;
 let _server = null;
 let _hotReloadWatchers = [];
 
-/**
- * Resolve a path relative to this package's src directory as an import URL
- * @param {string} relative - Path like './src/lib/database-core.js'
- * @returns {string} file:// URL
- */
 function resolveModule(relative) {
   const abs = path.resolve(__dirname, relative);
   return pathToFileURL(abs).href;
 }
 
-/**
- * Thatcher class - main API
- */
+// busybase stores data in a directory. Callers pass `databasePath` which may be
+// either a directory or a path ending in a db filename (.db/.sqlite); reduce the
+// latter to its containing directory.
+function databasePathToDir(p) {
+  return /\.(db|sqlite|sqlite3)$/i.test(p) ? path.dirname(p) : p;
+}
+
 export class Thatcher {
   constructor(options = {}) {
     this.options = this.normalizeOptions(options);
@@ -51,9 +48,6 @@ export class Thatcher {
     };
   }
 
-  /**
-   * Initialize the system (config, DB, plugins)
-   */
   async init() {
     if (this.initialized) return this;
 
@@ -78,9 +72,6 @@ export class Thatcher {
     return this;
   }
 
-  /**
-   * Load master configuration
-   */
   async loadConfig() {
     const { config } = this.options;
     let masterConfig;
@@ -138,21 +129,31 @@ export class Thatcher {
     this.config = masterConfig;
   }
 
-  /**
-   * Initialize database with schema from config
-   */
   async initDatabase() {
     if (_databaseInitialized) return;
-    const { migrate } = await import(resolveModule('./lib/database-core.js'));
-    migrate(_configEngine);
-    const { getDatabase } = await import(resolveModule('./lib/database-core.js'));
-    getDatabase(); // prime the connection
+    const { createEmbedded } = await import('busybase/embedded');
+    // Honour the caller's chosen location. `databasePath` is the documented
+    // option; busybase wants a directory, so a value that looks like a db file
+    // is reduced to its dirname. `dataDir` and BUSYBASE_DIR remain fallbacks.
+    const dir = this.options.dataDir
+      || (this.options.databasePath ? databasePathToDir(this.options.databasePath) : null)
+      || process.env.BUSYBASE_DIR
+      || 'busybase_data';
+    const client = await createEmbedded({ dir });
+
+    const store = await import(resolveModule('./lib/busybase-store.js'));
+    store.setBusyBaseClient(client);
+    const audit = await import(resolveModule('./lib/busybase-audit.js'));
+    audit.setBusyBaseClient(client);
+
+    this.busybase = client;
+    globalThis.__thatcherBusyBase = client;
+    if (globalThis.__debug__) {
+      globalThis.__debug__.expose('datastore', { kind: () => 'busybase', dir: () => dir }, 'Data Store');
+    }
     _databaseInitialized = true;
   }
 
-  /**
-   * Load .plugin.js files
-   */
   async loadPlugins() {
     if (_pluginsLoaded) return;
 
@@ -179,7 +180,7 @@ export class Thatcher {
               _configEngine.registerPlugin(plugin.entityName, plugin);
             }
           } catch (e) {
-            console.error(`[plugins] Failed to load ${file}:`, e.message);
+            log.error(`plugins: failed to load ${file}: ${e.message}`);
           }
         }
       }
@@ -188,9 +189,6 @@ export class Thatcher {
     _pluginsLoaded = true;
   }
 
-  /**
-   * Setup hot reload watchers
-   */
   setupHotReload() {
     const dirs = [
       path.resolve(process.cwd(), 'config'),
@@ -204,13 +202,13 @@ export class Thatcher {
       try {
         const watcher = fs.watch(dir, { recursive: true }, (_, filename) => {
           if (filename && (filename.endsWith('.js') || filename.endsWith('.jsx') || filename.endsWith('.yml'))) {
-            console.log(`[HotReload] ${filename} changed`);
+            log.info(`hot reload: ${filename} changed`);
             this.invalidateCache();
           }
         });
         _hotReloadWatchers.push(watcher);
       } catch (err) {
-        console.warn(`[HotReload] Failed to watch ${dir}:`, err.message);
+        log.warn(`hot reload: failed to watch ${dir}: ${err.message}`);
       }
     }
   }
@@ -221,9 +219,6 @@ export class Thatcher {
     }
   }
 
-  /**
-   * Start HTTP server
-   */
   async startServer(opts = {}) {
     if (!this.initialized) throw new Error('Call init() first');
 
@@ -241,15 +236,12 @@ export class Thatcher {
 
     return new Promise((resolve) => {
       _server.listen(port, host, () => {
-        console.log(`\n▲ Thatcher Server\n- Local: http://localhost:${port}\n✓ Ready\n`);
+        console.log(`\n> Thatcher Server\n- Local: http://localhost:${port}\n[OK] Ready\n`);
         resolve(_server);
       });
     });
   }
 
-  /**
-   * Stop server
-   */
   async stop() {
     if (_server) {
       _server.close();
@@ -259,30 +251,18 @@ export class Thatcher {
     _hotReloadWatchers = [];
   }
 
-  /**
-   * Get config engine
-   */
   getConfigEngine() {
     return _configEngine;
   }
 
-  /**
-   * Get entity spec
-   */
   getEntitySpec(name) {
     return _configEngine?.generateEntitySpec(name);
   }
 
-  /**
-   * List all entities
-   */
   getAllEntities() {
     return _configEngine?.getAllEntities() || [];
   }
 
-  /**
-   * Get workflow definition
-   */
   getWorkflow(name) {
     return _configEngine?.getWorkflow(name);
   }
@@ -290,32 +270,32 @@ export class Thatcher {
   // === CRUD operations ===
 
   async list(entity, where = {}, opts = {}) {
-    const { list } = await import(resolveModule('./lib/query-engine.js'));
+    const { list } = await import(resolveModule('./lib/busybase-store.js'));
     return list(entity, where, opts);
   }
 
   async get(entity, id) {
-    const { get } = await import(resolveModule('./lib/query-engine.js'));
+    const { get } = await import(resolveModule('./lib/busybase-store.js'));
     return get(entity, id);
   }
 
   async create(entity, data, user) {
-    const { create } = await import(resolveModule('./lib/query-engine-write.js'));
+    const { create } = await import(resolveModule('./lib/busybase-store.js'));
     return create(entity, data, user);
   }
 
   async update(entity, id, data, user) {
-    const { update } = await import(resolveModule('./lib/query-engine-write.js'));
+    const { update } = await import(resolveModule('./lib/busybase-store.js'));
     return update(entity, id, data, user);
   }
 
   async delete(entity, id) {
-    const { remove } = await import(resolveModule('./lib/query-engine-write.js'));
+    const { remove } = await import(resolveModule('./lib/busybase-store.js'));
     return remove(entity, id);
   }
 
   async search(entity, query, where = {}, opts = {}) {
-    const { search } = await import(resolveModule('./lib/query-engine.js'));
+    const { search } = await import(resolveModule('./lib/busybase-store.js'));
     return search(entity, query, where, opts);
   }
 
@@ -353,21 +333,16 @@ export class Thatcher {
   // === Database transaction ===
 
   async withTransaction(callback) {
-    const { withTransaction } = await import(resolveModule('./lib/query-engine.js'));
-    return withTransaction(callback);
+    // busybase has no transaction primitive; the old query-engine's withTransaction
+    // was a pass-through, so preserve that contract rather than import a dead file.
+    return callback();
   }
 }
 
-/**
- * Create thatcher instance
- */
 export function createThatcher(options) {
   return new Thatcher(options);
 }
 
-/**
- * Quick-start helper
- */
 export async function startThatcher(options = {}) {
   const t = new Thatcher(options);
   await t.init();

package/src/lib/alert-manager.js

@@ -1,3 +1,7 @@
+import { createLogger } from './logger.js';
+
+const log = createLogger('[AlertManager]');
+
 const alerts = []
 const alertHandlers = []
 const thresholds = {
@@ -105,13 +109,13 @@ function triggerAlert(type, message, metadata = {}) {
   alerts.push(alert)
   if (alerts.length > 1000) alerts.shift()
 
-  console.error(`[ALERT] [${alert.severity.toUpperCase()}] ${type}: ${message}`, metadata)
+  log.error(`[${alert.severity.toUpperCase()}] ${type}: ${message}`, metadata)
 
   for (const handler of alertHandlers) {
     try {
       handler(alert)
     } catch (err) {
-      console.error('[AlertManager] Handler error:', err)
+      log.error('handler error:', { message: err.message })
     }
   }
 }
@@ -133,7 +137,7 @@ function checkAllThresholds(allMetrics) {
     checkResources(allMetrics.resources)
     checkDatabase(allMetrics.database)
   } catch (err) {
-    console.error('[AlertManager] Check error:', err)
+    log.error('check error:', { message: err.message })
   }
 }
 

package/src/lib/api-helpers.js

@@ -4,16 +4,17 @@ import { getSpec } from '@/config/spec-helpers';
 import { migrate } from '@/engine';
 import { getUser } from '@/engine.server';
 import { can } from '@/services/permission.service';
-import { logger } from '@/lib/logger';
+import { createLogger } from '@/lib/logger';
 import { HTTP } from '@/config/constants';
 import { ERROR_MESSAGES } from '@/config';
 
+const log = createLogger('[API]');
+
 let dbInit = false;
 export function ensureDb() {
   if (!dbInit) {
     migrate();
     dbInit = true;
-  } else {
   }
 }
 
@@ -41,7 +42,7 @@ export async function withEntityAccess(entity, action, handler) {
     if (!can(user, spec, action)) return unauthorized(action);
     return await handler(spec, user);
   } catch (e) {
-    logger.apiError(action, entity, e);
+    log.error(`${action} ${entity}: ${e.message}`);
     return serverError(e.message);
   }
 }

package/src/lib/api.js

@@ -2,7 +2,7 @@ import { getUser } from '@/engine.server';
 import { getSpec } from '@/config/spec-helpers';
 import { API_ENDPOINTS } from '@/config';
 import { can } from '@/services/permission.service';
-import { list, get, create, update, remove, listWithPagination, search } from '@/lib/query-engine';
+import { get, create, update, remove, listWithPagination, search } from '@/lib/busybase-store';
 import { validateEntity, validateUpdate, hasErrors } from '@/lib/validate';
 import { broadcastUpdate } from '@/lib/realtime-server';
 import { UnauthorizedError, PermissionError, NotFoundError, ValidationError, AppError } from '@/lib/error-handler';
@@ -24,16 +24,16 @@ const createHandler = (entity, action) => async (request, { params, searchParams
 
   if (action === 'list') {
     if (q) {
-      const items = search(entity, q);
+      const items = await search(entity, q);
       return ok({ items });
     }
-    const { items, pagination } = listWithPagination(entity, {}, page, pageSize);
+    const { items, pagination } = await listWithPagination(entity, {}, page, pageSize);
     return paginated(items, pagination);
   }
 
   if (action === 'get') {
     if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
-    const item = get(entity, id);
+    const item = await get(entity, id);
     if (!item) throw NotFoundError(entity, id);
     return ok(item);
   }
@@ -43,31 +43,31 @@ const createHandler = (entity, action) => async (request, { params, searchParams
     const errors = await validateEntity(spec, data);
     if (hasErrors(errors)) throw new ValidationError('Validation failed', errors);
 
-    const result = create(entity, data, user);
+    const result = await create(entity, data, user);
     broadcastUpdate(API_ENDPOINTS.entity(entity), 'create', result);
     return created(result);
   }
 
   if (action === 'update') {
     if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
-    const prev = get(entity, id);
+    const prev = await get(entity, id);
     if (!prev) throw NotFoundError(entity, id);
 
     const data = await request.json();
     const errors = await validateUpdate(spec, id, data);
     if (hasErrors(errors)) throw new ValidationError('Validation failed', errors);
 
-    update(entity, id, data, user);
-    const result = get(entity, id);
+    await update(entity, id, data, user);
+    const result = await get(entity, id);
     broadcastUpdate(API_ENDPOINTS.entityId(entity, id), 'update', result);
     return ok(result);
   }
 
   if (action === 'delete') {
     if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
-    if (!get(entity, id)) throw NotFoundError(entity, id);
+    if (!(await get(entity, id))) throw NotFoundError(entity, id);
 
-    remove(entity, id);
+    await remove(entity, id);
     broadcastUpdate(API_ENDPOINTS.entityId(entity, id), 'delete', { id });
     return ok({ success: true });
   }