thatcher 1.0.4

package/src/lib/progress-components.js

@@ -0,0 +1,181 @@
+export function createLinearProgress(options = {}) {
+  const {
+    percentage = 0,
+    label = '',
+    color = '#007bff',
+    height = 8,
+    showLabel = true
+  } = options;
+
+  const container = document.createElement('div');
+  container.className = 'linear-progress-container';
+  container.style.cssText = `
+    width: 100%;
+  `;
+
+  const bar = document.createElement('div');
+  bar.className = 'linear-progress-bar';
+  bar.style.cssText = `
+    width: 100%;
+    height: ${height}px;
+    background: #e0e0e0;
+    border-radius: ${height / 2}px;
+    overflow: hidden;
+    position: relative;
+  `;
+
+  const fill = document.createElement('div');
+  fill.className = 'linear-progress-fill';
+  fill.style.cssText = `
+    height: 100%;
+    width: ${Math.min(100, Math.max(0, percentage))}%;
+    background: ${color};
+    border-radius: ${height / 2}px;
+    transition: width 0.3s ease;
+    position: relative;
+  `;
+
+  bar.appendChild(fill);
+
+  if (showLabel) {
+    const labelEl = document.createElement('div');
+    labelEl.className = 'linear-progress-label';
+    labelEl.style.cssText = `
+      text-align: center;
+      margin-top: 0.5rem;
+      font-size: 0.875rem;
+      color: #666;
+      font-weight: 500;
+    `;
+    labelEl.textContent = label || `${percentage}%`;
+
+    container.appendChild(bar);
+    container.appendChild(labelEl);
+  } else {
+    container.appendChild(bar);
+  }
+
+  return {
+    element: container,
+    setPercentage: (newPercentage) => {
+      const clamped = Math.min(100, Math.max(0, newPercentage));
+      fill.style.width = clamped + '%';
+      const labelEl = container.querySelector('.linear-progress-label');
+      if (labelEl) {
+        labelEl.textContent = label || `${clamped}%`;
+      }
+    }
+  };
+}
+
+export function createCircularProgress(options = {}) {
+  const {
+    percentage = 0,
+    radius = 50,
+    strokeWidth = 4,
+    color = '#007bff',
+    backgroundColor = '#e0e0e0',
+    showLabel = true
+  } = options;
+
+  const size = radius * 2 + strokeWidth;
+  const circumference = 2 * Math.PI * (radius - strokeWidth / 2);
+
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  svg.setAttribute('width', size);
+  svg.setAttribute('height', size);
+  svg.setAttribute('viewBox', `0 0 ${size} ${size}`);
+  svg.style.cssText = `
+    transform: rotate(-90deg);
+  `;
+
+  const bgCircle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+  bgCircle.setAttribute('cx', size / 2);
+  bgCircle.setAttribute('cy', size / 2);
+  bgCircle.setAttribute('r', radius - strokeWidth / 2);
+  bgCircle.setAttribute('fill', 'none');
+  bgCircle.setAttribute('stroke', backgroundColor);
+  bgCircle.setAttribute('stroke-width', strokeWidth);
+
+  const progressCircle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+  progressCircle.setAttribute('cx', size / 2);
+  progressCircle.setAttribute('cy', size / 2);
+  progressCircle.setAttribute('r', radius - strokeWidth / 2);
+  progressCircle.setAttribute('fill', 'none');
+  progressCircle.setAttribute('stroke', color);
+  progressCircle.setAttribute('stroke-width', strokeWidth);
+  progressCircle.setAttribute('stroke-dasharray', circumference);
+  progressCircle.setAttribute('stroke-linecap', 'round');
+
+  const offset = circumference - (percentage / 100) * circumference;
+  progressCircle.setAttribute('stroke-dashoffset', offset);
+  progressCircle.style.cssText = `
+    transition: stroke-dashoffset 0.3s ease;
+  `;
+
+  svg.appendChild(bgCircle);
+  svg.appendChild(progressCircle);
+
+  const container = document.createElement('div');
+  container.className = 'circular-progress-container';
+  container.style.cssText = `
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 1rem;
+  `;
+
+  const svgWrapper = document.createElement('div');
+  svgWrapper.style.cssText = `
+    position: relative;
+    width: ${size}px;
+    height: ${size}px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  `;
+
+  svgWrapper.appendChild(svg);
+
+  if (showLabel) {
+    const label = document.createElement('div');
+    label.className = 'circular-progress-label';
+    label.style.cssText = `
+      position: absolute;
+      text-align: center;
+      font-size: 1.5rem;
+      font-weight: 600;
+      color: ${color};
+    `;
+    label.textContent = `${percentage}%`;
+    svgWrapper.appendChild(label);
+  }
+
+  container.appendChild(svgWrapper);
+
+  return {
+    element: container,
+    setPercentage: (newPercentage) => {
+      const clamped = Math.min(100, Math.max(0, newPercentage));
+      const newOffset = circumference - (clamped / 100) * circumference;
+      progressCircle.setAttribute('stroke-dashoffset', newOffset);
+
+      const labelEl = svgWrapper.querySelector('.circular-progress-label');
+      if (labelEl) {
+        labelEl.textContent = `${clamped}%`;
+      }
+    }
+  };
+}
+
+export function renderProgressBar(percentage, label = '') {
+  const html = `
+    <div style="width: 100%; background: #e0e0e0; height: 8px; border-radius: 4px; overflow: hidden;">
+      <div style="height: 100%; width: ${percentage}%; background: #007bff; border-radius: 4px; transition: width 0.3s;"></div>
+    </div>
+    <div style="text-align: center; margin-top: 0.5rem; font-size: 0.875rem; color: #666;">
+      ${label || percentage + '%'}
+    </div>
+  `;
+  return html;
+}

package/src/lib/query-cache.js

@@ -0,0 +1,126 @@
+const stmtCache = new Map();
+const resultCache = new Map();
+const queryCache = new Map();
+let cacheHits = 0;
+let cacheMisses = 0;
+let stmtCacheHits = 0;
+let stmtCacheMisses = 0;
+
+const MAX_STMT_CACHE = 500;
+const MAX_RESULT_CACHE = 200;
+const MAX_QUERY_CACHE = 100;
+const DEFAULT_TTL = 30000;
+
+const TTL_CONFIG = {
+  user: 60000,
+  users: 60000,
+  client: 120000,
+  engagement: 10000,
+  rfi: 5000,
+  audit_logs: 0,
+  sessions: 5000,
+  email: 1000,
+  default: DEFAULT_TTL
+};
+
+export const prepareStmt = (db, sql) => {
+  const cached = stmtCache.get(sql);
+  if (cached) {
+    stmtCacheHits++;
+    return cached;
+  }
+
+  stmtCacheMisses++;
+  if (stmtCache.size >= MAX_STMT_CACHE) {
+    const firstKey = stmtCache.keys().next().value;
+    stmtCache.delete(firstKey);
+  }
+
+  const stmt = db.prepare(sql);
+  stmtCache.set(sql, stmt);
+  return stmt;
+};
+
+export const getCached = (key, entity = 'default') => {
+  const entry = resultCache.get(key);
+  if (!entry) {
+    cacheMisses++;
+    return null;
+  }
+
+  const ttl = TTL_CONFIG[entity] || TTL_CONFIG.default;
+  if (ttl === 0) {
+    cacheMisses++;
+    return null;
+  }
+
+  if (Date.now() - entry.timestamp > ttl) {
+    resultCache.delete(key);
+    cacheMisses++;
+    return null;
+  }
+
+  cacheHits++;
+  return entry.data;
+};
+
+export const setCached = (key, data, entity = 'default') => {
+  const ttl = TTL_CONFIG[entity] || TTL_CONFIG.default;
+  if (ttl === 0) return;
+
+  if (resultCache.size >= MAX_RESULT_CACHE) {
+    const firstKey = resultCache.keys().next().value;
+    resultCache.delete(firstKey);
+  }
+
+  resultCache.set(key, { data, timestamp: Date.now() });
+};
+
+export const invalidate = (pattern) => {
+  if (!pattern) {
+    resultCache.clear();
+    queryCache.clear();
+    return;
+  }
+
+  const regex = new RegExp(pattern);
+  for (const key of resultCache.keys()) {
+    if (regex.test(key)) resultCache.delete(key);
+  }
+  for (const key of queryCache.keys()) {
+    if (regex.test(key)) queryCache.delete(key);
+  }
+};
+
+export const cacheQuery = (key, fn) => {
+  const cached = queryCache.get(key);
+  if (cached) return cached;
+
+  if (queryCache.size >= MAX_QUERY_CACHE) {
+    const firstKey = queryCache.keys().next().value;
+    queryCache.delete(firstKey);
+  }
+
+  const result = fn();
+  queryCache.set(key, result);
+  return result;
+};
+
+export const getStats = () => ({
+  cacheHits,
+  cacheMisses,
+  hitRate: cacheHits + cacheMisses > 0 ? (cacheHits / (cacheHits + cacheMisses) * 100).toFixed(2) + '%' : '0%',
+  stmtCacheHits,
+  stmtCacheMisses,
+  stmtHitRate: stmtCacheHits + stmtCacheMisses > 0 ? (stmtCacheHits / (stmtCacheHits + stmtCacheMisses) * 100).toFixed(2) + '%' : '0%',
+  stmtCacheSize: stmtCache.size,
+  resultCacheSize: resultCache.size,
+  queryCacheSize: queryCache.size
+});
+
+export const clearStats = () => {
+  cacheHits = 0;
+  cacheMisses = 0;
+  stmtCacheHits = 0;
+  stmtCacheMisses = 0;
+};

package/src/lib/query-engine-write.js

@@ -0,0 +1,221 @@
+/**
+ * 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();
+}