thatcher 1.0.4 → 1.0.6

package/src/lib/config-field-helpers.js

@@ -2,7 +2,7 @@
  * Config Field Helpers - Field definition processing and validation
  */
 
-import { getSpec } from './spec-helpers.js';
+import { getSpec } from '../config/spec-helpers.js';
 
 /**
  * Generate fields from field overrides

package/src/lib/config-generator-engine.js

@@ -13,6 +13,7 @@ export class ConfigGeneratorEngine {
     if (!masterConfig) throw new Error('[ConfigGeneratorEngine] masterConfig is required');
     this.masterConfig = deepFreeze(masterConfig);
     this.specCache = new LRUCache(100);
+    this.debugMode = false;
     this._plugins = new Map();
   }
 
@@ -362,6 +363,11 @@ export class ConfigGeneratorEngine {
       }
     }
 
+    // Entity variants (ported from moonlanding: passthrough additive spec field)
+    if (entityDef.variants) {
+      spec.variants = deepClone(entityDef.variants);
+    }
+
     // List options
     if (entityDef.list) {
       spec.list = {
@@ -406,6 +412,13 @@ export class ConfigGeneratorEngine {
 let _singleton = null;
 
 export function getConfigEngineSync() {
+  // tsx can instantiate this module twice (static import vs resolveModule file://
+  // URL), so _singleton set in one instance is invisible to the other. The bootstrap
+  // mirrors the engine onto globalThis.__thatcherConfigEngine; fall back to it so every
+  // module instance resolves the same engine.
+  if (!_singleton && globalThis.__thatcherConfigEngine) {
+    _singleton = globalThis.__thatcherConfigEngine;
+  }
   if (!_singleton) {
     throw new Error('ConfigEngine not initialized. Call initConfig() first.');
   }
@@ -437,6 +450,17 @@ export async function initConfig(configSource) {
   return _singleton;
 }
 
+/**
+ * Set the singleton config engine directly (used by the bootstrap in index.js,
+ * which constructs the engine from an already-parsed config object). This is what
+ * makes getConfigEngineSync() resolve for the server/plugin/spec paths.
+ * @param {ConfigGeneratorEngine} engine
+ */
+export function setConfigEngine(engine) {
+  _singleton = engine;
+  return _singleton;
+}
+
 /**
  * Reset singleton (for hot reload)
  */

package/src/lib/crud-handlers.js

@@ -15,6 +15,7 @@ import { permissionService } from '../services/permission.service.js';
 import { parse as parseQuery } from './query-string-adapter.js';
 import { now } from './database-core.js';
 import { getConfigEngineSync } from './config-generator-engine.js';
+import { logAction } from './audit-logger.js';
 
 /**
  * Build a complete set of CRUD handlers for an entity
@@ -112,6 +113,9 @@ export function createCrudHandlers(entityName, spec) {
       const sanitized = sanitizeData(entityName, rawData, spec);
       const record = create(entityName, sanitized, user);
 
+      // Audit log (ported from moon)
+      logAction(entityName, record.id, 'create', user?.id, null, record);
+
       // Execute hooks
       executeHook(`create:${entityName}:after`, {
         entity: entityName,
@@ -150,6 +154,9 @@ export function createCrudHandlers(entityName, spec) {
       const sanitized = sanitizeData(entityName, rawData, spec, existing);
       const record = update(entityName, id, sanitized, user);
 
+      // Audit log (ported from moon)
+      logAction(entityName, id, 'update', user?.id, existing, record);
+
       executeHook(`update:${entityName}:after`, {
         entity: entityName,
         id,
@@ -178,7 +185,20 @@ export function createCrudHandlers(entityName, spec) {
         throw new AppError('Access denied', 'FORBIDDEN', HTTP.FORBIDDEN);
       }
 
-      const result = remove(entityName, id);
+      // Delete strategy (ported from moon): immutable entities are archived,
+      // entities with a status field are soft-deleted, otherwise hard-removed.
+      let result;
+      if (spec.immutable === true && spec.immutable_strategy === 'move_to_archive') {
+        const archiveData = { archived: true, archived_at: now(), archived_by: user?.id };
+        result = update(entityName, id, archiveData, user);
+        logAction(entityName, id, 'archive', user?.id, existing, archiveData);
+      } else if (spec.fields?.status) {
+        result = update(entityName, id, { status: 'deleted' }, user);
+        logAction(entityName, id, 'delete', user?.id, existing, { status: 'deleted' });
+      } else {
+        result = remove(entityName, id);
+        logAction(entityName, id, 'delete', user?.id, existing, null);
+      }
 
       executeHook(`delete:${entityName}:after`, {
         entity: entityName,

package/src/lib/database-core.js

@@ -6,6 +6,7 @@
 import Database from 'better-sqlite3';
 import fs from 'fs';
 import path from 'path';
+import { runMigrations } from './database-migrations.js';
 
 const SQL_TYPES = {
   id: 'TEXT PRIMARY KEY',
@@ -216,14 +217,10 @@ export function migrate(configEngine) {
  * @param {object} specs
  */
 function runCustomMigrations(dbInstance, specs) {
-  // Placeholder for custom migration logic
-  // Can be extended via plugins
+  // Delegate to the dedicated migrations module (ported from moonlanding):
+  // idempotent triggers, activity_log + notification tables, etc.
   try {
-    // Create triggers for updated_at timestamps
-    for (const entityName of Object.keys(specs)) {
-      const tableName = entityName === 'user' ? 'users' : entityName;
-      // Add timestamp triggers if needed
-    }
+    runMigrations(dbInstance);
   } catch (e) {
     console.error('[Database] Custom migrations failed:', e.message);
   }

package/src/lib/database-migrations.js

@@ -13,6 +13,16 @@ export function runMigrations(db) {
     createTimestampTriggers,
     createActivityLogTable,
     createNotificationTable,
+    createSessionsTable,
+    createChatTables,
+    createAuditLogsTable,
+    createRfiTables,
+    createPasswordResetTokensTable,
+    addHighlightColumns,
+    migrateRfiSectionTable,
+    createSystemSettingsTable,
+    createRecreationLogTable,
+    createBugReportTable,
   ];
 
   for (const migration of migrations) {
@@ -94,3 +104,247 @@ function createNotificationTable(db) {
     CREATE INDEX IF NOT EXISTS idx_notification_user ON notification(user_id, read_at);
   `);
 }
+
+/**
+ * Create sessions table (Lucia auth)
+ * @param {object} db
+ */
+function createSessionsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+  `);
+}
+
+/**
+ * Create chat tables (messages + mentions)
+ * @param {object} db
+ */
+function createChatTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id TEXT PRIMARY KEY,
+      rfi_id TEXT,
+      user_id TEXT,
+      content TEXT,
+      attachments TEXT,
+      reactions TEXT DEFAULT '{}',
+      mentions TEXT DEFAULT '[]',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER,
+      FOREIGN KEY (rfi_id) REFERENCES rfi(id),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS chat_mentions (
+      id TEXT PRIMARY KEY,
+      message_id TEXT NOT NULL,
+      user_id TEXT,
+      resolved BOOLEAN DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (message_id) REFERENCES chat_messages(id),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_rfi ON chat_messages(rfi_id);
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_user ON chat_messages(user_id);
+    CREATE INDEX IF NOT EXISTS idx_chat_mentions_message ON chat_mentions(message_id);
+    CREATE INDEX IF NOT EXISTS idx_chat_mentions_user ON chat_mentions(user_id);
+  `);
+}
+
+/**
+ * Create audit_logs table (before/after state audit trail)
+ * Distinct from activity_log; preserved as an additive table.
+ * @param {object} db
+ */
+function createAuditLogsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS audit_logs (
+      id TEXT PRIMARY KEY,
+      entity_type TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      user_id TEXT,
+      before_state TEXT,
+      after_state TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audit_logs_entity ON audit_logs(entity_type, entity_id);
+    CREATE INDEX IF NOT EXISTS idx_audit_logs_user ON audit_logs(user_id);
+    CREATE INDEX IF NOT EXISTS idx_audit_logs_created ON audit_logs(created_at);
+  `);
+}
+
+/**
+ * Create RFI tables (rfis, questions, responses)
+ * @param {object} db
+ */
+function createRfiTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS rfis (
+      id TEXT PRIMARY KEY,
+      engagement_id TEXT NOT NULL,
+      status TEXT DEFAULT 'draft',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (engagement_id) REFERENCES engagement(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS rfi_questions (
+      id TEXT PRIMARY KEY,
+      rfi_id TEXT NOT NULL,
+      question TEXT NOT NULL,
+      category TEXT,
+      assigned_to TEXT,
+      due_date TEXT,
+      status TEXT DEFAULT 'pending',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (rfi_id) REFERENCES rfis(id),
+      FOREIGN KEY (assigned_to) REFERENCES users(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS rfi_responses (
+      id TEXT PRIMARY KEY,
+      question_id TEXT NOT NULL,
+      response TEXT,
+      attachments TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (question_id) REFERENCES rfi_questions(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_rfis_engagement ON rfis(engagement_id);
+    CREATE INDEX IF NOT EXISTS idx_rfis_status ON rfis(status);
+    CREATE INDEX IF NOT EXISTS idx_rfi_questions_rfi ON rfi_questions(rfi_id);
+    CREATE INDEX IF NOT EXISTS idx_rfi_questions_status ON rfi_questions(status);
+    CREATE INDEX IF NOT EXISTS idx_rfi_responses_question ON rfi_responses(question_id);
+  `);
+}
+
+/**
+ * Create password_reset_tokens table
+ * @param {object} db
+ */
+function createPasswordResetTokensTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS password_reset_tokens (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      token TEXT NOT NULL UNIQUE,
+      expires_at INTEGER NOT NULL,
+      used INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_token ON password_reset_tokens(token);
+    CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_user ON password_reset_tokens(user_id);
+  `);
+}
+
+/**
+ * Add flags/tags columns to highlight table (idempotent — ignores duplicate-column error)
+ * @param {object} db
+ */
+function addHighlightColumns(db) {
+  for (const col of ['flags', 'tags']) {
+    try {
+      db.exec(`ALTER TABLE highlight ADD COLUMN ${col} TEXT`);
+    } catch (e) {
+      // Column already exists or table not present yet
+    }
+  }
+}
+
+/**
+ * Rebuild rfi_section table if it lacks an id column (legacy shape)
+ * @param {object} db
+ */
+function migrateRfiSectionTable(db) {
+  let cols = [];
+  try {
+    cols = db.prepare('PRAGMA table_info(rfi_section)').all().map(c => c.name);
+  } catch (e) {
+    return;
+  }
+  if (!cols.includes('id')) {
+    db.exec(`DROP TABLE IF EXISTS rfi_section`);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS rfi_section (
+        id TEXT PRIMARY KEY,
+        engagement_id TEXT NOT NULL,
+        name TEXT NOT NULL DEFAULT '',
+        sort_order INTEGER DEFAULT 0,
+        created_at INTEGER,
+        FOREIGN KEY (engagement_id) REFERENCES engagement(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_rfi_section_engagement ON rfi_section(engagement_id);
+    `);
+  }
+}
+
+/**
+ * Create system_settings key/value table
+ * @param {object} db
+ */
+function createSystemSettingsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS system_settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER
+    );
+  `);
+}
+
+/**
+ * Create recreation_log table
+ * @param {object} db
+ */
+function createRecreationLogTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS recreation_log (
+      id TEXT PRIMARY KEY,
+      engagement_id TEXT,
+      client_id TEXT,
+      engagement_type_id TEXT,
+      status TEXT,
+      details TEXT,
+      error TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_recreation_log_created ON recreation_log(created_at);
+    CREATE INDEX IF NOT EXISTS idx_recreation_log_status ON recreation_log(status);
+  `);
+}
+
+/**
+ * Create bug_report table
+ * @param {object} db
+ */
+function createBugReportTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS bug_report (
+      id TEXT PRIMARY KEY,
+      user_id TEXT,
+      summary TEXT,
+      description TEXT,
+      url TEXT,
+      user_agent TEXT,
+      viewport TEXT,
+      status TEXT DEFAULT 'open',
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bug_report_created ON bug_report(created_at);
+  `);
+}

package/src/lib/date-utils.js

@@ -157,3 +157,167 @@ export function formatDuration(seconds) {
   const days = Math.floor(hrs / 24);
   return `${days}d`;
 }
+
+// ---------------------------------------------------------------------------
+// Additive helpers ported from moonlanding (adapted to Unix-seconds model)
+// ---------------------------------------------------------------------------
+
+/**
+ * Whether a timestamp falls on a working day (Mon–Fri).
+ * @param {number} timestamp - Unix seconds
+ * @returns {boolean}
+ */
+export function isWorkingDay(timestamp) {
+  if (!timestamp) return false;
+  const day = new Date(timestamp * 1000).getDay();
+  return day !== 0 && day !== 6;
+}
+
+/**
+ * Count working days (inclusive) between two Unix-seconds timestamps.
+ * @param {number} startTs - Unix seconds
+ * @param {number} endTs - Unix seconds
+ * @returns {number}
+ */
+export function getWorkingDaysDiff(startTs, endTs) {
+  if (!startTs || !endTs) return 0;
+  const end = new Date(endTs * 1000);
+  const current = new Date(startTs * 1000);
+  let count = 0;
+  while (current <= end) {
+    if (current.getDay() !== 0 && current.getDay() !== 6) count++;
+    current.setDate(current.getDate() + 1);
+  }
+  return count;
+}
+
+/**
+ * Add a number of working days (Mon–Fri) to a Unix-seconds timestamp.
+ * @param {number} startTs - Unix seconds
+ * @param {number} numDays
+ * @returns {number} Unix seconds
+ */
+export function addWorkingDays(startTs, numDays) {
+  if (!startTs || numDays <= 0) return startTs;
+  const date = new Date(startTs * 1000);
+  let added = 0;
+  while (added < numDays) {
+    date.setDate(date.getDate() + 1);
+    if (date.getDay() !== 0 && date.getDay() !== 6) added++;
+  }
+  return Math.floor(date.getTime() / 1000);
+}
+
+/**
+ * Financial year (Mar 1 – Feb end) for a Unix-seconds timestamp.
+ * @param {number} [timestamp] - Unix seconds (defaults to now)
+ * @returns {number|null}
+ */
+export function getFinancialYear(timestamp) {
+  const ms = timestamp ? timestamp * 1000 : Date.now();
+  const date = new Date(ms);
+  if (isNaN(date.getTime())) return null;
+  const month = date.getMonth();
+  const year = date.getFullYear();
+  return month >= 2 ? year : year - 1;
+}
+
+/**
+ * Start/end Unix-seconds bounds for a financial year (Mar 1 – Feb end).
+ * @param {number} year
+ * @returns {{ start: number, end: number }}
+ */
+export function getFinancialYearRange(year) {
+  const start = new Date(year, 2, 1);
+  const lastDay = new Date(year + 1, 2, 0).getDate();
+  const end = new Date(year + 1, 1, lastDay);
+  return {
+    start: Math.floor(start.getTime() / 1000),
+    end: Math.floor(end.getTime() / 1000),
+  };
+}
+
+/**
+ * Format an amount as currency.
+ * @param {number|string} amount
+ * @param {string} [currency='ZAR']
+ * @param {string} [locale='en-ZA']
+ * @returns {string|null}
+ */
+export function formatCurrency(amount, currency = 'ZAR', locale = 'en-ZA') {
+  if (amount === null || amount === undefined) return null;
+  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
+  if (isNaN(num)) return null;
+  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(num);
+}
+
+/**
+ * Format a number with fixed decimals.
+ * @param {number|string} value
+ * @param {number} [decimals=0]
+ * @param {string} [locale='en-ZA']
+ * @returns {string|null}
+ */
+export function formatNumber(value, decimals = 0, locale = 'en-ZA') {
+  if (value === null || value === undefined) return null;
+  const num = typeof value === 'string' ? parseFloat(value) : value;
+  if (isNaN(num)) return null;
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  }).format(num);
+}
+
+/**
+ * Human-readable file size.
+ * @param {number} bytes
+ * @returns {string|null}
+ */
+export function formatFileSize(bytes) {
+  if (bytes === null || bytes === undefined || bytes < 0) return null;
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const size = bytes / Math.pow(1024, i);
+  return `${size.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+
+/**
+ * Truncate text to a maximum length, appending a suffix.
+ * @param {*} text
+ * @param {number} [maxLength=100]
+ * @param {string} [suffix='...']
+ * @returns {string}
+ */
+export function truncateText(text, maxLength = 100, suffix = '...') {
+  if (!text) return '';
+  const str = String(text);
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength) + suffix;
+}
+
+/**
+ * Convert a Unix-seconds timestamp to a UTC ISO-8601 string.
+ * @param {number} timestamp - Unix seconds
+ * @returns {string|null}
+ */
+export function toUtcIso(timestamp) {
+  if (!timestamp) return null;
+  const date = new Date(timestamp * 1000);
+  if (isNaN(date.getTime())) return null;
+  return date.toISOString();
+}
+
+/**
+ * Normalize a Firestore timestamp (or number/date) to Unix seconds.
+ * @param {*} ts
+ * @returns {number|null}
+ */
+export function fromFirestoreTimestamp(ts) {
+  if (!ts) return null;
+  if (ts._seconds !== undefined) return ts._seconds;
+  if (ts.seconds !== undefined) return ts.seconds;
+  if (typeof ts === 'number') return ts;
+  const d = new Date(ts);
+  return isNaN(d.getTime()) ? null : Math.floor(d.getTime() / 1000);
+}