thatcher 1.0.4

package/src/lib/alert-manager.js

@@ -0,0 +1,189 @@
+const alerts = []
+const alertHandlers = []
+const thresholds = {
+  errorRate: { window: 60000, maxErrors: 10 },
+  p95Latency: { threshold: 500 },
+  p99Latency: { threshold: 1000 },
+  memoryUsage: { threshold: 0.9 },
+  diskUsage: { threshold: 0.9 },
+  dbConnections: { threshold: 100 },
+  slowQuery: { threshold: 1000 }
+}
+
+let alertingEnabled = true
+const alertCooldowns = new Map()
+
+function checkErrorRate(errorMetrics) {
+  const now = Date.now()
+  const window = thresholds.errorRate.window
+  let recentErrors = 0
+
+  for (const [endpoint, data] of Object.entries(errorMetrics.byEndpoint)) {
+    const recent = (data.recent || []).filter(e => (now - e.ts) < window)
+    recentErrors += recent.length
+  }
+
+  if (recentErrors > thresholds.errorRate.maxErrors) {
+    triggerAlert('error_rate', `High error rate: ${recentErrors} errors in last ${window/1000}s`, {
+      count: recentErrors,
+      threshold: thresholds.errorRate.maxErrors
+    })
+  }
+}
+
+function checkLatency(requestMetrics) {
+  for (const [endpoint, stats] of Object.entries(requestMetrics)) {
+    if (stats.p95 > thresholds.p95Latency.threshold) {
+      triggerAlert('p95_latency', `P95 latency exceeded for ${endpoint}: ${stats.p95.toFixed(2)}ms`, {
+        endpoint,
+        p95: stats.p95,
+        threshold: thresholds.p95Latency.threshold
+      })
+    }
+
+    if (stats.p99 > thresholds.p99Latency.threshold) {
+      triggerAlert('p99_latency', `P99 latency exceeded for ${endpoint}: ${stats.p99.toFixed(2)}ms`, {
+        endpoint,
+        p99: stats.p99,
+        threshold: thresholds.p99Latency.threshold
+      })
+    }
+  }
+}
+
+function checkResources(resourceMetrics) {
+  if (!resourceMetrics) return
+
+  if (resourceMetrics.memory && resourceMetrics.memory.avg > thresholds.memoryUsage.threshold) {
+    triggerAlert('memory_usage', `High memory usage: ${(resourceMetrics.memory.avg * 100).toFixed(1)}%`, {
+      usage: resourceMetrics.memory.avg,
+      threshold: thresholds.memoryUsage.threshold
+    })
+  }
+
+  if (resourceMetrics.disk && resourceMetrics.disk.avg > thresholds.diskUsage.threshold) {
+    triggerAlert('disk_usage', `High disk usage: ${(resourceMetrics.disk.avg * 100).toFixed(1)}%`, {
+      usage: resourceMetrics.disk.avg,
+      threshold: thresholds.diskUsage.threshold
+    })
+  }
+}
+
+function checkDatabase(dbMetrics) {
+  for (const [operation, stats] of Object.entries(dbMetrics)) {
+    if (stats.p95 > thresholds.slowQuery.threshold) {
+      triggerAlert('slow_query', `Slow ${operation}: ${stats.p95.toFixed(2)}ms`, {
+        operation,
+        p95: stats.p95,
+        threshold: thresholds.slowQuery.threshold
+      })
+    }
+  }
+}
+
+function triggerAlert(type, message, metadata = {}) {
+  if (!alertingEnabled) return
+
+  const cooldownKey = `${type}:${message}`
+  const now = Date.now()
+  const lastAlert = alertCooldowns.get(cooldownKey)
+
+  if (lastAlert && (now - lastAlert) < 60000) {
+    return
+  }
+
+  alertCooldowns.set(cooldownKey, now)
+
+  const alert = {
+    type,
+    message,
+    metadata,
+    timestamp: now,
+    severity: getSeverity(type)
+  }
+
+  alerts.push(alert)
+  if (alerts.length > 1000) alerts.shift()
+
+  console.error(`[ALERT] [${alert.severity.toUpperCase()}] ${type}: ${message}`, metadata)
+
+  for (const handler of alertHandlers) {
+    try {
+      handler(alert)
+    } catch (err) {
+      console.error('[AlertManager] Handler error:', err)
+    }
+  }
+}
+
+function getSeverity(type) {
+  if (type.includes('error_rate') || type.includes('memory') || type.includes('disk')) {
+    return 'critical'
+  }
+  if (type.includes('p99') || type.includes('slow_query')) {
+    return 'warning'
+  }
+  return 'info'
+}
+
+function checkAllThresholds(allMetrics) {
+  try {
+    checkErrorRate(allMetrics.errors)
+    checkLatency(allMetrics.requests)
+    checkResources(allMetrics.resources)
+    checkDatabase(allMetrics.database)
+  } catch (err) {
+    console.error('[AlertManager] Check error:', err)
+  }
+}
+
+function registerAlertHandler(handler) {
+  alertHandlers.push(handler)
+}
+
+function getRecentAlerts(limit = 50) {
+  return alerts.slice(-limit)
+}
+
+function clearAlerts() {
+  alerts.length = 0
+  alertCooldowns.clear()
+}
+
+function setThreshold(metric, value) {
+  if (thresholds[metric]) {
+    if (typeof thresholds[metric] === 'object' && 'threshold' in thresholds[metric]) {
+      thresholds[metric].threshold = value
+    } else {
+      thresholds[metric] = value
+    }
+  }
+}
+
+function enableAlerting() {
+  alertingEnabled = true
+}
+
+function disableAlerting() {
+  alertingEnabled = false
+}
+
+export {
+  checkAllThresholds,
+  triggerAlert,
+  registerAlertHandler,
+  getRecentAlerts,
+  clearAlerts,
+  setThreshold,
+  enableAlerting,
+  disableAlerting
+}
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__alerts = {
+    getRecentAlerts,
+    triggerAlert,
+    clearAlerts,
+    setThreshold
+  }
+}

package/src/lib/api-error-wrapper.js

@@ -0,0 +1,125 @@
+import { normalizeError, createErrorLogger, retryWithBackoff } from '@/lib/error-handler';
+import { NextResponse } from '@/lib/next-polyfills';
+import { HTTP } from '@/config/constants';
+
+const logger = createErrorLogger('API');
+
+export function wrapAPIRoute(handler, options = {}) {
+  const { retry = false, timeout = 30000, logErrors = true } = options;
+
+  return async (request, context) => {
+    const startTime = Date.now();
+    const url = new URL(request.url);
+
+    try {
+      const operation = async () => {
+        const timeoutPromise = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error(`Request timeout after ${timeout}ms`)), timeout)
+        );
+
+        const handlerPromise = handler(request, context);
+
+        return await Promise.race([handlerPromise, timeoutPromise]);
+      };
+
+      const result = retry
+        ? await retryWithBackoff(operation, { maxAttempts: 3, context: { url: url.pathname } })
+        : await operation();
+
+      const duration = Date.now() - startTime;
+
+      if (duration > 1000) {
+        logger.warn('Slow request', { url: url.pathname, duration });
+      }
+
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const normalized = normalizeError(error);
+
+      if (logErrors) {
+        logger.error('Request failed', {
+          url: url.pathname,
+          method: request.method,
+          error: normalized.toJSON(),
+          duration
+        });
+      }
+
+      return NextResponse.json(
+        normalized.toJSON(),
+        {
+          status: normalized.statusCode,
+          headers: { 'Content-Type': 'application/json' }
+        }
+      );
+    }
+  };
+}
+
+export function wrapGETRoute(handler, options = {}) {
+  return wrapAPIRoute(handler, { ...options, retry: true });
+}
+
+export function wrapPOSTRoute(handler, options = {}) {
+  return wrapAPIRoute(handler, options);
+}
+
+export function wrapPUTRoute(handler, options = {}) {
+  return wrapAPIRoute(handler, options);
+}
+
+export function wrapDELETERoute(handler, options = {}) {
+  return wrapAPIRoute(handler, options);
+}
+
+export function createAPIHandler(handlers) {
+  const wrapped = {};
+
+  if (handlers.GET) wrapped.GET = wrapGETRoute(handlers.GET);
+  if (handlers.POST) wrapped.POST = wrapPOSTRoute(handlers.POST);
+  if (handlers.PUT) wrapped.PUT = wrapPUTRoute(handlers.PUT);
+  if (handlers.DELETE) wrapped.DELETE = wrapDELETERoute(handlers.DELETE);
+  if (handlers.PATCH) wrapped.PATCH = wrapAPIRoute(handlers.PATCH);
+  if (handlers.HEAD) wrapped.HEAD = wrapAPIRoute(handlers.HEAD);
+
+  return wrapped;
+}
+
+export async function safeJSONParse(text, fallback = null) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    logger.warn('JSON parse failed', { error: error.message });
+    return fallback;
+  }
+}
+
+export async function safeReadBody(request, fallback = {}) {
+  try {
+    const text = await request.text();
+    return text ? await safeJSONParse(text, fallback) : fallback;
+  } catch (error) {
+    logger.warn('Body read failed', { error: error.message });
+    return fallback;
+  }
+}
+
+export function validateRequired(data, fields) {
+  const missing = [];
+
+  for (const field of fields) {
+    if (data[field] === undefined || data[field] === null || data[field] === '') {
+      missing.push(field);
+    }
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required fields: ${missing.join(', ')}`);
+  }
+}
+
+export function sanitizeError(error) {
+  const safe = String(error?.message || error || 'Unknown error');
+  return safe.substring(0, 500);
+}

package/src/lib/api-helpers.js

@@ -0,0 +1,53 @@
+
+import { NextResponse } from '@/lib/next-polyfills';
+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 { HTTP } from '@/config/constants';
+import { ERROR_MESSAGES } from '@/config';
+
+let dbInit = false;
+export function ensureDb() {
+  if (!dbInit) {
+    migrate();
+    dbInit = true;
+  } else {
+  }
+}
+
+const withMetadata = (data, status = HTTP.OK, type = 'success') => ({
+  status,
+  type,
+  timestamp: new Date().toISOString(),
+  data,
+  ...(!data.error && { success: true }),
+});
+
+export const ok = (data) => NextResponse.json(withMetadata(data, HTTP.OK, 'success'));
+export const created = (data) => NextResponse.json(withMetadata(data, HTTP.CREATED, 'created'), { status: HTTP.CREATED });
+export const notFound = (entity = 'Resource') => NextResponse.json(withMetadata({ error: ERROR_MESSAGES.notFound(entity) }, HTTP.NOT_FOUND, 'error'), { status: HTTP.NOT_FOUND });
+export const badRequest = (reason = 'invalid data') => NextResponse.json(withMetadata({ error: ERROR_MESSAGES.invalidRequest(reason) }, HTTP.BAD_REQUEST, 'error'), { status: HTTP.BAD_REQUEST });
+export const unauthorized = (action = 'perform this action') => NextResponse.json(withMetadata({ error: ERROR_MESSAGES.permission.denied }, HTTP.FORBIDDEN, 'error'), { status: HTTP.FORBIDDEN });
+export const serverError = (msg = null) => NextResponse.json(withMetadata({ error: msg || ERROR_MESSAGES.operationFailed('server operation') }, HTTP.INTERNAL_ERROR, 'error'), { status: HTTP.INTERNAL_ERROR });
+
+export async function withEntityAccess(entity, action, handler) {
+  ensureDb();
+  try {
+    let spec;
+    try { spec = getSpec(entity); } catch { return notFound(entity); }
+    const user = await getUser();
+    if (!can(user, spec, action)) return unauthorized(action);
+    return await handler(spec, user);
+  } catch (e) {
+    logger.apiError(action, entity, e);
+    return serverError(e.message);
+  }
+}
+
+export async function parseParams(params) {
+  const { entity, path = [] } = await params;
+  const [id, childKey] = path;
+  return { entity, id, childKey, path };
+}

package/src/lib/api.js

@@ -0,0 +1,82 @@
+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 { validateEntity, validateUpdate, hasErrors } from '@/lib/validate';
+import { broadcastUpdate } from '@/lib/realtime-server';
+import { UnauthorizedError, PermissionError, NotFoundError, ValidationError, AppError } from '@/lib/error-handler';
+import { ok, created, paginated } from '@/lib/response-formatter';
+import { QueryAdapter } from '@/lib/query-string-adapter';
+import { withErrorHandler } from '@/lib/with-error-handler';
+import { HTTP } from '@/config/constants';
+
+const createHandler = (entity, action) => async (request, { params, searchParams }) => {
+  const user = await getUser();
+  if (!user) throw UnauthorizedError('Authentication required');
+
+  const spec = getSpec(entity);
+  if (!spec) throw NotFoundError('entity', entity);
+  if (!can(user, spec, action)) throw PermissionError(`Cannot ${action} ${entity}`);
+
+  const { id } = params;
+  const { q, page, pageSize } = QueryAdapter.fromSearchParams(searchParams, spec);
+
+  if (action === 'list') {
+    if (q) {
+      const items = search(entity, q);
+      return ok({ items });
+    }
+    const { items, pagination } = 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);
+    if (!item) throw NotFoundError(entity, id);
+    return ok(item);
+  }
+
+  if (action === 'create') {
+    const data = await request.json();
+    const errors = await validateEntity(spec, data);
+    if (hasErrors(errors)) throw new ValidationError('Validation failed', errors);
+
+    const result = 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);
+    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);
+    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);
+
+    remove(entity, id);
+    broadcastUpdate(API_ENDPOINTS.entityId(entity, id), 'delete', { id });
+    return ok({ success: true });
+  }
+
+  throw new AppError('Unknown action', 'BAD_REQUEST', HTTP.BAD_REQUEST);
+};
+
+export const createApiHandler = (entity, action) =>
+  withErrorHandler(
+    (request, { params, searchParams }) => createHandler(entity, action)(request, { params, searchParams }),
+    `API:${entity}:${action}`
+  );

package/src/lib/audit-logger-enhanced.js

@@ -0,0 +1,117 @@
+import { getDatabase, genId, now } from '@/lib/database-core';
+import { Mutex } from '@/lib/hot-reload/mutex';
+
+const db = getDatabase();
+const auditMutex = new Mutex('audit-logger-enhanced');
+
+export const LOG_LEVELS = { DEBUG: 'debug', INFO: 'info', WARN: 'warn', ERROR: 'error' };
+export const OPERATION_TYPES = { CREATE: 'create', UPDATE: 'update', DELETE: 'delete', READ: 'read', AUTH: 'auth', AUTHZ: 'authz' };
+
+const MAX_LOG_SIZE = 10000;
+const MAX_STACK_DEPTH = 20;
+
+export const logStructured = ({ level = LOG_LEVELS.INFO, operation, entityType, entityId, userId, action, details = {}, error = null, performanceMs = null }) => {
+  return auditMutex.runExclusive(() => {
+    const id = genId();
+    const timestamp = now();
+    const logEntry = {
+      id, timestamp, level, operation, entity_type: entityType, entity_id: entityId, user_id: userId, action,
+      details: JSON.stringify(details).substring(0, MAX_LOG_SIZE),
+      error_message: error ? String(error.message || error).substring(0, MAX_LOG_SIZE) : null,
+      error_stack: error && error.stack ? String(error.stack).split('\n').slice(0, MAX_STACK_DEPTH).join('\n') : null,
+      performance_ms: performanceMs,
+    };
+    db.prepare(`INSERT INTO structured_logs (id, timestamp, level, operation, entity_type, entity_id, user_id, action, details, error_message, error_stack, performance_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      id, timestamp, level, operation, entityType, entityId, userId, action, logEntry.details, logEntry.error_message, logEntry.error_stack, performanceMs
+    );
+    return id;
+  });
+};
+
+export const logCreate = (entityType, entityId, userId, afterState) => {
+  return logStructured({ level: LOG_LEVELS.INFO, operation: OPERATION_TYPES.CREATE, entityType, entityId, userId, action: 'create', details: { after_state: afterState } });
+};
+
+export const logUpdate = (entityType, entityId, userId, beforeState, afterState) => {
+  return logStructured({ level: LOG_LEVELS.INFO, operation: OPERATION_TYPES.UPDATE, entityType, entityId, userId, action: 'update', details: { before_state: beforeState, after_state: afterState } });
+};
+
+export const logDelete = (entityType, entityId, userId, beforeState) => {
+  return logStructured({ level: LOG_LEVELS.INFO, operation: OPERATION_TYPES.DELETE, entityType, entityId, userId, action: 'delete', details: { before_state: beforeState } });
+};
+
+export const logAuthSuccess = (userId, method, metadata = {}) => {
+  return logStructured({ level: LOG_LEVELS.INFO, operation: OPERATION_TYPES.AUTH, entityType: 'auth', entityId: userId, userId, action: 'login_success', details: { method, ...metadata } });
+};
+
+export const logAuthFailure = (email, reason, metadata = {}) => {
+  return logStructured({ level: LOG_LEVELS.WARN, operation: OPERATION_TYPES.AUTH, entityType: 'auth', entityId: email, userId: null, action: 'login_failure', details: { reason, ...metadata } });
+};
+
+export const logAuthzFailure = (userId, entityType, entityId, requiredPermission, metadata = {}) => {
+  return logStructured({ level: LOG_LEVELS.WARN, operation: OPERATION_TYPES.AUTHZ, entityType, entityId, userId, action: 'access_denied', details: { required_permission: requiredPermission, ...metadata } });
+};
+
+export const logPerformance = (operation, entityType, durationMs, userId = null, metadata = {}) => {
+  const level = durationMs > 1000 ? LOG_LEVELS.WARN : LOG_LEVELS.DEBUG;
+  return logStructured({ level, operation: 'performance', entityType, entityId: null, userId, action: operation, performanceMs: durationMs, details: metadata });
+};
+
+export const logError = (error, context = {}) => {
+  return logStructured({ level: LOG_LEVELS.ERROR, operation: 'error', entityType: context.entityType || 'system', entityId: context.entityId || null, userId: context.userId || null, action: context.action || 'error', error, details: context });
+};
+
+export const searchLogs = (filters = {}, page = 1, pageSize = 100) => {
+  const wc = [], params = [];
+  if (filters.level) { wc.push('level = ?'); params.push(filters.level); }
+  if (filters.operation) { wc.push('operation = ?'); params.push(filters.operation); }
+  if (filters.entityType) { wc.push('entity_type = ?'); params.push(filters.entityType); }
+  if (filters.entityId) { wc.push('entity_id = ?'); params.push(filters.entityId); }
+  if (filters.userId) { wc.push('user_id = ?'); params.push(filters.userId); }
+  if (filters.action) { wc.push('action = ?'); params.push(filters.action); }
+  if (filters.fromDate) { wc.push('timestamp >= ?'); params.push(filters.fromDate); }
+  if (filters.toDate) { wc.push('timestamp <= ?'); params.push(filters.toDate); }
+  if (filters.searchText) { wc.push('(details LIKE ? OR error_message LIKE ? OR action LIKE ?)'); const escaped = filters.searchText.replace(/[%_]/g, c => '\\' + c); const pat = `%${escaped}%`; params.push(pat, pat, pat); }
+  const where = wc.length ? 'WHERE ' + wc.join(' AND ') : '';
+  const { count: total } = db.prepare(`SELECT COUNT(*) as count FROM structured_logs ${where}`).get(...params);
+  const offset = (page - 1) * pageSize;
+  const items = db.prepare(`SELECT * FROM structured_logs ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
+  return { items: items.map(i => ({ ...i, details: i.details ? JSON.parse(i.details) : null })), pagination: { page, pageSize, total, totalPages: Math.ceil(total / pageSize) } };
+};
+
+export const getLogStats = (fromDate, toDate) => {
+  const byLevel = db.prepare('SELECT level, COUNT(*) as count FROM structured_logs WHERE timestamp >= ? AND timestamp <= ? GROUP BY level').all(fromDate, toDate);
+  const byOperation = db.prepare('SELECT operation, COUNT(*) as count FROM structured_logs WHERE timestamp >= ? AND timestamp <= ? GROUP BY operation ORDER BY count DESC').all(fromDate, toDate);
+  const byEntity = db.prepare('SELECT entity_type, COUNT(*) as count FROM structured_logs WHERE timestamp >= ? AND timestamp <= ? GROUP BY entity_type ORDER BY count DESC LIMIT 20').all(fromDate, toDate);
+  const errorRate = db.prepare('SELECT COUNT(*) as total, SUM(CASE WHEN level = ? THEN 1 ELSE 0 END) as errors FROM structured_logs WHERE timestamp >= ? AND timestamp <= ?').get(LOG_LEVELS.ERROR, fromDate, toDate);
+  const avgPerf = db.prepare('SELECT AVG(performance_ms) as avg, MAX(performance_ms) as max FROM structured_logs WHERE timestamp >= ? AND timestamp <= ? AND performance_ms IS NOT NULL').get(fromDate, toDate);
+  return { byLevel, byOperation, byEntity, errorRate: errorRate.total > 0 ? errorRate.errors / errorRate.total : 0, avgPerformanceMs: avgPerf.avg, maxPerformanceMs: avgPerf.max };
+};
+
+export const rotateLogsOlderThan = (daysOld = 90) => {
+  const cutoffTimestamp = now() - (daysOld * 24 * 60 * 60);
+  const archiveId = genId();
+  const archived = db.prepare('SELECT * FROM structured_logs WHERE timestamp < ?').all(cutoffTimestamp);
+  if (archived.length > 0) {
+    db.prepare('INSERT INTO archived_logs (archive_id, archived_at, log_data) VALUES (?, ?, ?)').run(archiveId, now(), JSON.stringify(archived));
+    db.prepare('DELETE FROM structured_logs WHERE timestamp < ?').run(cutoffTimestamp);
+  }
+  return { archived: archived.length, archiveId };
+};
+
+export const ensureTables = () => {
+  db.exec(`CREATE TABLE IF NOT EXISTS structured_logs (
+    id TEXT PRIMARY KEY, timestamp INTEGER NOT NULL, level TEXT NOT NULL, operation TEXT, entity_type TEXT,
+    entity_id TEXT, user_id TEXT, action TEXT, details TEXT, error_message TEXT, error_stack TEXT, performance_ms REAL
+  )`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_structured_logs_timestamp ON structured_logs(timestamp)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_structured_logs_level ON structured_logs(level)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_structured_logs_entity ON structured_logs(entity_type, entity_id)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_structured_logs_user ON structured_logs(user_id)`);
+  db.exec(`CREATE TABLE IF NOT EXISTS archived_logs (
+    archive_id TEXT PRIMARY KEY, archived_at INTEGER NOT NULL, log_data TEXT NOT NULL
+  )`);
+};
+
+ensureTables();