bonescript-compiler 0.7.0 → 0.9.0

package/src/emit_sqlite.ts

@@ -0,0 +1,898 @@
+/**
+ * BoneScript SQLite Target Emitter
+ *
+ * Generates a SQLite-flavored project: same shape as the Express target but
+ * with a SQLite type map, no triggers, and the better-sqlite3 driver in place
+ * of pg.
+ *
+ * SQLite differences from PostgreSQL that this emitter handles:
+ *   - No JSONB / no native UUID — TEXT for both
+ *   - No CREATE OR REPLACE FUNCTION / no triggers needed (we do updated_at in app code)
+ *   - Parameter style is ? not $1, $2 — but better-sqlite3 also supports named (:name)
+ *   - No SKIP LOCKED, no transactional outbox locking semantics — outbox uses simpler ordering
+ *   - No CHECK constraints with subqueries — basic CHECK only
+ *
+ * Strategy: keep the SQL flat and portable. Use better-sqlite3's prepared
+ * statements. Keep the public interface identical to the Postgres target so
+ * route handlers and capability bodies don't need to change.
+ */
+
+import * as IR from "./ir";
+import { EmittedFile } from "./emitter";
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+// ─── SQLite type mapping ──────────────────────────────────────────────────────
+
+const SQLITE_TYPE_MAP: Record<string, string> = {
+  string: "TEXT",
+  uint: "INTEGER",
+  int: "INTEGER",
+  float: "REAL",
+  bool: "INTEGER",        // 0 / 1
+  timestamp: "TEXT",       // ISO 8601 string
+  uuid: "TEXT",
+  bytes: "BLOB",
+  json: "TEXT",            // JSON-encoded text
+};
+
+export function toSqliteType(irType: string): string {
+  if (SQLITE_TYPE_MAP[irType]) return SQLITE_TYPE_MAP[irType];
+  if (irType.startsWith("list<") || irType.startsWith("set<") || irType.startsWith("map<")) return "TEXT";
+  if (irType.startsWith("optional<")) return toSqliteType(irType.slice(9, -1));
+  return "TEXT";
+}
+
+// ─── Schema emission ──────────────────────────────────────────────────────────
+
+export function emitSqliteSchema(model: IR.IRModel, mod: IR.IRModule, system: IR.IRSystem): EmittedFile {
+  const tableName = toSnakeCase(model.name) + "s";
+  const lines: string[] = [];
+
+  lines.push(`-- Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`-- Source: ${system.source_hash}`);
+  lines.push(`-- Module: ${mod.name}`);
+  lines.push(`-- Engine: sqlite`);
+  lines.push(``);
+  lines.push(`CREATE TABLE IF NOT EXISTS ${tableName} (`);
+
+  const fieldLines: string[] = [];
+  for (const field of model.fields) {
+    let line = `  ${field.name} ${toSqliteType(field.type)}`;
+    if (!field.nullable) line += " NOT NULL";
+
+    // SQLite default value handling. The Postgres-flavored defaults need translation.
+    if (field.default_value) {
+      if (field.default_value === "gen_random_uuid()" || field.default_value === "uuid()") {
+        // SQLite has no built-in UUID generator. We rely on app code to fill `id`
+        // before insert. No DEFAULT clause emitted.
+      } else if (field.default_value === "now()") {
+        line += " DEFAULT (datetime('now'))";
+      } else if (field.default_value.startsWith("GENERATED ALWAYS AS")) {
+        // Generated columns — supported in SQLite 3.31+
+        line += ` ${field.default_value}`;
+      } else {
+        line += ` DEFAULT ${field.default_value}`;
+      }
+    } else if (field.name === "created_at" || field.name === "updated_at") {
+      line += " DEFAULT (datetime('now'))";
+    }
+
+    if (field.name === model.primary_key) line += " PRIMARY KEY";
+    fieldLines.push(line);
+  }
+
+  // Unique constraints (declared inline in CREATE TABLE)
+  for (const c of model.constraints) {
+    if (c.kind === "unique") {
+      fieldLines.push(`  CONSTRAINT ${tableName}_${c.target}_unique UNIQUE (${c.target})`);
+    }
+  }
+
+  // Foreign keys for belongs_to relations
+  for (const rel of mod.relations || []) {
+    if (rel.kind === "belongs_to") {
+      fieldLines.push(`  FOREIGN KEY (${rel.foreign_key}) REFERENCES ${rel.to_table}(id) ON DELETE CASCADE`);
+    }
+  }
+
+  lines.push(fieldLines.join(",\n"));
+  lines.push(`);`);
+  lines.push(``);
+
+  // Indexes
+  for (const idx of model.indexes) {
+    const idxName = `idx_${tableName}_${idx.fields.join("_")}`;
+    const unique = idx.unique ? "UNIQUE " : "";
+    lines.push(`CREATE ${unique}INDEX IF NOT EXISTS ${idxName} ON ${tableName} (${idx.fields.join(", ")});`);
+  }
+
+  // FK indexes for belongs_to relations
+  for (const rel of mod.relations || []) {
+    if (rel.kind === "belongs_to") {
+      lines.push(`CREATE INDEX IF NOT EXISTS idx_${tableName}_${rel.foreign_key} ON ${tableName} (${rel.foreign_key});`);
+    }
+  }
+
+  // Junction tables for many_to_many
+  for (const rel of mod.relations || []) {
+    if (rel.kind === "many_to_many" && rel.junction_table) {
+      lines.push(``);
+      lines.push(`CREATE TABLE IF NOT EXISTS ${rel.junction_table} (`);
+      lines.push(`  ${rel.from_table.slice(0, -1)}_id TEXT NOT NULL REFERENCES ${rel.from_table}(id) ON DELETE CASCADE,`);
+      lines.push(`  ${rel.to_table.slice(0, -1)}_id TEXT NOT NULL REFERENCES ${rel.to_table}(id) ON DELETE CASCADE,`);
+      lines.push(`  created_at TEXT NOT NULL DEFAULT (datetime('now')),`);
+      lines.push(`  PRIMARY KEY (${rel.from_table.slice(0, -1)}_id, ${rel.to_table.slice(0, -1)}_id)`);
+      lines.push(`);`);
+    }
+  }
+
+  // Note: No triggers for updated_at in SQLite. The DB client wrapper handles
+  // it on every UPDATE by interpolating the current timestamp.
+
+  return {
+    path: `migrations/${toSnakeCase(model.name)}.sql`,
+    content: lines.join("\n") + "\n",
+    language: "sql",
+    source_module: mod.id,
+  };
+}
+
+// ─── Outbox / audit infra schemas (SQLite flavor) ─────────────────────────────
+
+export function emitSqliteOutboxSchema(): string {
+  return `-- BoneScript: Transactional Outbox (SQLite)
+-- Generated by BoneScript compiler. DO NOT EDIT.
+
+CREATE TABLE IF NOT EXISTS event_outbox (
+  id TEXT PRIMARY KEY,
+  event_type TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  source TEXT NOT NULL,
+  correlation_id TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  scheduled_at TEXT NOT NULL DEFAULT (datetime('now')),
+  delivered_at TEXT,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  status TEXT NOT NULL DEFAULT 'pending'
+    CHECK (status IN ('pending', 'delivered', 'failed', 'dead_letter'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_event_outbox_status ON event_outbox (status, scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_event_outbox_created ON event_outbox (created_at);
+
+CREATE TABLE IF NOT EXISTS event_processed (
+  event_id TEXT PRIMARY KEY,
+  event_type TEXT NOT NULL,
+  processed_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_event_processed_type ON event_processed (event_type, processed_at);
+`;
+}
+
+export function emitSqliteAuditSchema(): string {
+  return `-- BoneScript: Audit log (SQLite)
+-- Generated by BoneScript compiler. DO NOT EDIT.
+
+CREATE TABLE IF NOT EXISTS audit_log (
+  id TEXT PRIMARY KEY,
+  actor_id TEXT,
+  action TEXT NOT NULL,
+  entity_type TEXT,
+  entity_id TEXT,
+  payload TEXT,
+  ip_address TEXT,
+  user_agent TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_audit_log_actor ON audit_log (actor_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_audit_log_entity ON audit_log (entity_type, entity_id);
+CREATE INDEX IF NOT EXISTS idx_audit_log_action ON audit_log (action, created_at);
+`;
+}
+
+// ─── DB client (SQLite flavor, drop-in API replacement for the pg client) ─────
+
+export function emitSqliteDbClient(system: IR.IRSystem): string {
+  return [
+    `// Generated by BoneScript compiler. DO NOT EDIT.`,
+    `// SQLite database client. API-compatible with the Postgres client so route`,
+    `// handlers don't need to change between targets.`,
+    `import Database from "better-sqlite3";`,
+    `import * as path from "path";`,
+    ``,
+    `let _db: Database.Database | null = null;`,
+    ``,
+    `function getDb(): Database.Database {`,
+    `  if (!_db) {`,
+    `    const dbPath = process.env.SQLITE_PATH || path.resolve(process.cwd(), "${toSnakeCase(system.name)}.db");`,
+    `    _db = new Database(dbPath);`,
+    `    _db.pragma("journal_mode = WAL");`,
+    `    _db.pragma("foreign_keys = ON");`,
+    `    _db.pragma("synchronous = NORMAL");`,
+    `  }`,
+    `  return _db;`,
+    `}`,
+    ``,
+    `// Translate Postgres-style SQL to SQLite-compatible SQL.`,
+    `//`,
+    `// Handles:`,
+    `//   - $1, $2, ... → ? (and rebuilds params for out-of-order references)`,
+    `//   - NOW() → datetime('now')`,
+    `//   - row_to_json(t.*) → json_object(...) — best-effort, see comment below`,
+    `//`,
+    `// We can't translate every Postgres-ism. Capability effects that use`,
+    `// jsonb_set / jsonb_agg / jsonb_array_elements still fail at runtime; if`,
+    `// you hit those, refactor the capability or use the Express target.`,
+    `function translateSql(sql: string, params: any[]): { sql: string; params: any[] } {`,
+    `  let out = sql.replace(/\\bNOW\\s*\\(\\s*\\)/gi, "datetime('now')");`,
+    ``,
+    `  // row_to_json(t.*) → json_object('col', t.col, ...) is hard to do without`,
+    `  // knowing the columns. As a degraded fallback, replace it with the table`,
+    `  // alias so the LIST join still returns *something* (the joined table's id).`,
+    `  // The "as <name>" still works; consumers will see a string instead of an`,
+    `  // object. This is a known limitation.`,
+    `  out = out.replace(/row_to_json\\((\\w+)\\.\\*\\)/gi, "$1.id");`,
+    ``,
+    `  // Postgres-style placeholders → SQLite ?, with param rewrite for`,
+    `  // out-of-order references (e.g. "WHERE id = $1 AND ... = $2" vs`,
+    `  // "SET col = $2 WHERE id = $1").`,
+    `  const newParams: any[] = [];`,
+    `  out = out.replace(/\\$(\\d+)/g, (_m, n) => {`,
+    `    newParams.push(params[parseInt(n, 10) - 1]);`,
+    `    return "?";`,
+    `  });`,
+    `  return { sql: out, params: newParams };`,
+    `}`,
+    ``,
+    `// Strip Postgres-only RETURNING * — better-sqlite3 returns the inserted/updated`,
+    `// row separately via .get(). We post-process by looking up the row by id.`,
+    `function stripReturning(sql: string): { sql: string; hadReturning: boolean } {`,
+    `  const m = sql.match(/^(.*?)\\s+RETURNING\\s+\\*\\s*;?\\s*$/is);`,
+    `  if (m) return { sql: m[1], hadReturning: true };`,
+    `  return { sql, hadReturning: false };`,
+    `}`,
+    ``,
+    `// Extract table name from an INSERT or UPDATE for RETURNING * emulation.`,
+    `function extractTable(sql: string): string | null {`,
+    `  const ins = sql.match(/INSERT\\s+INTO\\s+([\\w]+)/i);`,
+    `  if (ins) return ins[1];`,
+    `  const upd = sql.match(/UPDATE\\s+([\\w]+)/i);`,
+    `  if (upd) return upd[1];`,
+    `  return null;`,
+    `}`,
+    ``,
+    // Parse the WHERE clause to find the param index that holds the id. The
+    // generated SQL uses two shapes:
+    //   - emit_runtime PUT:    "UPDATE t SET ... WHERE id = $1"     → idIdx = 1
+    //   - emit_capability:     "UPDATE t SET col = $1 WHERE id = $2" → idIdx = 2
+    // For INSERT the row id is always $1 by convention.
+    `function findIdParamIndex(sql: string, params: any[]): any {`,
+    `  // Look for "WHERE id = $N" or "WHERE id = ?" (after translation).`,
+    `  const m = sql.match(/WHERE\\s+id\\s*=\\s*\\$(\\d+)/i);`,
+    `  if (m) {`,
+    `    const idx = parseInt(m[1], 10) - 1;`,
+    `    return params[idx];`,
+    `  }`,
+    `  // Translated form: count which "?" corresponds to the WHERE id.`,
+    `  const beforeWhere = sql.split(/WHERE\\s+id\\s*=\\s*\\?/i)[0] || "";`,
+    `  const placeholdersBeforeId = (beforeWhere.match(/\\?/g) || []).length;`,
+    `  return params[placeholdersBeforeId];`,
+    `}`,
+    ``,
+    `export async function query<T = any>(text: string, params: any[] = []): Promise<T[]> {`,
+    `  const db = getDb();`,
+    `  const { sql: stripped, hadReturning } = stripReturning(text);`,
+    `  const { sql, params: translatedParams } = translateSql(stripped, params);`,
+    `  const trimmed = sql.trim().toUpperCase();`,
+    `  if (trimmed.startsWith("SELECT") || trimmed.startsWith("WITH")) {`,
+    `    return db.prepare(sql).all(...translatedParams) as T[];`,
+    `  }`,
+    `  // INSERT / UPDATE / DELETE`,
+    `  const stmt = db.prepare(sql);`,
+    `  const info = stmt.run(...translatedParams);`,
+    `  if (hadReturning) {`,
+    `    const table = extractTable(sql);`,
+    `    if (!table) return [];`,
+    `    if (trimmed.startsWith("INSERT")) {`,
+    `      // Generated INSERTs have id as the first column → params[0].`,
+    `      const id = params[0];`,
+    `      const row = db.prepare(\`SELECT * FROM \${table} WHERE id = ?\`).get(id);`,
+    `      return row ? [row as T] : [];`,
+    `    }`,
+    `    if (trimmed.startsWith("UPDATE")) {`,
+    `      // Find the id from the WHERE clause regardless of param order.`,
+    `      const id = findIdParamIndex(stripped, params);`,
+    `      if (id === undefined) return [];`,
+    `      const row = db.prepare(\`SELECT * FROM \${table} WHERE id = ?\`).get(id);`,
+    `      return row ? [row as T] : [];`,
+    `    }`,
+    `  }`,
+    `  // Fall back to changes count expressed as a single-row response`,
+    `  return [{ rowCount: info.changes } as unknown as T];`,
+    `}`,
+    ``,
+    `export async function queryOne<T = any>(text: string, params: any[] = []): Promise<T | null> {`,
+    `  const rows = await query<T>(text, params);`,
+    `  return rows[0] || null;`,
+    `}`,
+    ``,
+    `export async function execute(text: string, params: any[] = []): Promise<number> {`,
+    `  const db = getDb();`,
+    `  const { sql: stripped } = stripReturning(text);`,
+    `  const { sql, params: translatedParams } = translateSql(stripped, params);`,
+    `  const info = db.prepare(sql).run(...translatedParams);`,
+    `  return info.changes;`,
+    `}`,
+    ``,
+    `// Run a function inside a SQLite transaction.`,
+    `//`,
+    `// IMPORTANT: better-sqlite3 transactions are synchronous. The callback runs`,
+    `// to completion before COMMIT — but if you do "await" inside it for a Promise`,
+    `// other than another query()/execute(), the transaction will commit before`,
+    `// the awaited work finishes.`,
+    `//`,
+    `// In practice this is fine: query()/execute() above are async only at the`,
+    `// type level; their bodies are synchronous because better-sqlite3 is.`,
+    `// The transaction will be safely committed once the callback returns, and`,
+    `// any chained query/execute calls inside it run on the same database in the`,
+    `// same transaction.`,
+    `//`,
+    `// Don't put fetch(), setTimeout, or other genuinely-async work inside fn.`,
+    `export async function transaction<T>(fn: (client: { query: typeof query; execute: typeof execute }) => Promise<T> | T): Promise<T> {`,
+    `  const db = getDb();`,
+    `  let result!: T;`,
+    `  let promise: Promise<T> | null = null;`,
+    `  const txn = db.transaction(() => {`,
+    `    const r = fn({ query, execute });`,
+    `    if (r instanceof Promise) {`,
+    `      // Capture the promise; await outside the synchronous transaction.`,
+    `      // Note: this means async work inside fn runs OUTSIDE the transaction,`,
+    `      // which may be a bug in caller code. Better to keep fn synchronous.`,
+    `      promise = r;`,
+    `      return;`,
+    `    }`,
+    `    result = r as T;`,
+    `  });`,
+    `  txn();`,
+    `  if (promise) return await promise;`,
+    `  return result;`,
+    `}`,
+    ``,
+    `// Compatibility shim: the Postgres path uses pool.connect()/release() for nested`,
+    `// transactions. SQLite has no pool. We expose a no-op client wrapper so generated`,
+    `// route handlers can call __client.query() / __client.release() unchanged.`,
+    `export const pool = {`,
+    `  async connect() {`,
+    `    const db = getDb();`,
+    `    let inTxn = false;`,
+    `    return {`,
+    `      async query(text: string, params: any[] = []) {`,
+    `        const upper = text.trim().toUpperCase();`,
+    `        if (upper === "BEGIN") { db.prepare("BEGIN").run(); inTxn = true; return { rows: [] }; }`,
+    `        if (upper === "COMMIT") { db.prepare("COMMIT").run(); inTxn = false; return { rows: [] }; }`,
+    `        if (upper === "ROLLBACK") { try { db.prepare("ROLLBACK").run(); } catch {} inTxn = false; return { rows: [] }; }`,
+    `        const rows = await query(text, params);`,
+    `        return { rows, rowCount: rows.length };`,
+    `      },`,
+    `      release() { /* no-op for sqlite */ },`,
+    `    };`,
+    `  },`,
+    `  async query(text: string, params: any[] = []) {`,
+    `    const rows = await query(text, params);`,
+    `    return { rows, rowCount: rows.length };`,
+    `  },`,
+    `  async end() { if (_db) { _db.close(); _db = null; } },`,
+    `  on() { /* no-op */ },`,
+    `};`,
+    ``,
+  ].join("\n");
+}
+
+// ─── Migration runner (SQLite flavor) ─────────────────────────────────────────
+
+export function emitSqliteMigration(_system: IR.IRSystem, schemas: string[]): string {
+  const system = _system; // alias for use below — kept underscore for backwards compat
+  // Build deterministic blocks just like the Postgres path does.
+  const lines: string[] = [];
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`// SQLite migration runner with a schema_migrations ledger.`);
+  lines.push(`require("dotenv").config();`);
+  lines.push(`import * as fs from "fs";`);
+  lines.push(`import * as path from "path";`);
+  lines.push(`import { createHash } from "crypto";`);
+  lines.push(`import Database from "better-sqlite3";`);
+  lines.push(``);
+  lines.push(`interface Block { id: string; checksum: string; sql: string; }`);
+  lines.push(``);
+  lines.push(`const GENERATED_BLOCKS: Block[] = [`);
+
+  // Use the same deterministic ordering as the Postgres migrate emitter
+  schemas.forEach((sql, i) => {
+    const checksum = require("crypto").createHash("sha256").update(sql).digest("hex");
+    const tableMatch = sql.match(/CREATE TABLE IF NOT EXISTS\s+(\w+)/i);
+    const slug = (tableMatch?.[1] || `block_${i}`).toLowerCase();
+    const id = `${String(i).padStart(4, "0")}_${slug}`;
+    const escaped = sql.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+    lines.push(`  { id: ${JSON.stringify(id)}, checksum: ${JSON.stringify(checksum)}, sql: \`${escaped}\` },`);
+  });
+
+  lines.push(`];`);
+  lines.push(``);
+  lines.push(`function loadManualBlocks(): Block[] {`);
+  lines.push(`  const dir = path.resolve(__dirname, "..", "migrations", "_manual");`);
+  lines.push(`  if (!fs.existsSync(dir)) return [];`);
+  lines.push(`  return fs.readdirSync(dir)`);
+  lines.push(`    .filter(f => f.endsWith(".sql"))`);
+  lines.push(`    .sort()`);
+  lines.push(`    .map(f => {`);
+  lines.push(`      const sql = fs.readFileSync(path.join(dir, f), "utf-8");`);
+  lines.push(`      return { id: "manual_" + f.replace(/\\.sql$/, ""), checksum: createHash("sha256").update(sql).digest("hex"), sql };`);
+  lines.push(`    });`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`async function migrate() {`);
+  lines.push(`  const dbPath = process.env.SQLITE_PATH || path.resolve(process.cwd(), "${toSnakeCase(_system.name)}.db");`);
+  lines.push(`  const db = new Database(dbPath);`);
+  lines.push(`  db.pragma("foreign_keys = ON");`);
+  lines.push(``);
+  lines.push(`  db.exec(\`CREATE TABLE IF NOT EXISTS schema_migrations (`);
+  lines.push(`    id TEXT PRIMARY KEY,`);
+  lines.push(`    checksum TEXT NOT NULL,`);
+  lines.push(`    applied_at TEXT NOT NULL DEFAULT (datetime('now')),`);
+  lines.push(`    duration_ms INTEGER NOT NULL DEFAULT 0`);
+  lines.push(`  );\`);`);
+  lines.push(``);
+  lines.push(`  const all = [...GENERATED_BLOCKS, ...loadManualBlocks()];`);
+  lines.push(`  const existing = db.prepare("SELECT id, checksum FROM schema_migrations").all() as Array<{ id: string; checksum: string }>;`);
+  lines.push(`  const seen = new Map(existing.map(r => [r.id, r.checksum]));`);
+  lines.push(``);
+  lines.push(`  let applied = 0, skipped = 0;`);
+  lines.push(`  for (const block of all) {`);
+  lines.push(`    const prior = seen.get(block.id);`);
+  lines.push(`    if (prior === block.checksum) { skipped++; continue; }`);
+  lines.push(`    if (prior && prior !== block.checksum) {`);
+  lines.push(`      throw new Error(\`Migration \${block.id} was previously applied with a different checksum.\`);`);
+  lines.push(`    }`);
+  lines.push(`    const start = Date.now();`);
+  lines.push(`    db.exec("BEGIN");`);
+  lines.push(`    try {`);
+  lines.push(`      db.exec(block.sql);`);
+  lines.push(`      db.prepare("INSERT INTO schema_migrations (id, checksum, duration_ms) VALUES (?, ?, ?)")`);
+  lines.push(`        .run(block.id, block.checksum, Date.now() - start);`);
+  lines.push(`      db.exec("COMMIT");`);
+  lines.push(`      console.log(\`  applied \${block.id} (\${Date.now() - start}ms)\`);`);
+  lines.push(`      applied++;`);
+  lines.push(`    } catch (e) {`);
+  lines.push(`      try { db.exec("ROLLBACK"); } catch {}`);
+  lines.push(`      throw e;`);
+  lines.push(`    }`);
+  lines.push(`  }`);
+  lines.push(`  console.log(\`Migrations complete: \${applied} applied, \${skipped} already up to date.\`);`);
+  lines.push(`  db.close();`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`migrate().catch(e => { console.error(e); process.exit(1); });`);
+
+  return lines.join("\n");
+}
+
+// ─── Package.json (SQLite flavor) ─────────────────────────────────────────────
+
+export function emitSqlitePackageJson(system: IR.IRSystem): string {
+  // Full backend deps, but with better-sqlite3 instead of pg.
+  const pkg = {
+    name: toSnakeCase(system.name),
+    version: system.version,
+    private: true,
+    scripts: {
+      build: "tsc",
+      start: "node dist/index.js",
+      dev: "ts-node src/index.ts",
+      migrate: "ts-node src/migrate.ts",
+      seed: "ts-node src/seed.ts",
+    },
+    dependencies: {
+      // Pinned versions match the Express target except pg → better-sqlite3.
+      express: "4.22.2",
+      "better-sqlite3": "11.5.0",
+      ws: "8.18.0",
+      uuid: "10.0.0",
+      cors: "2.8.5",
+      helmet: "8.0.0",
+      "express-rate-limit": "7.5.0",
+      jsonwebtoken: "9.0.2",
+      dotenv: "16.4.7",
+      "node-cron": "3.0.3",
+      zod: "3.23.8",
+    },
+    devDependencies: {
+      "@types/express": "4.17.21",
+      "@types/node": "20.14.0",
+      "@types/better-sqlite3": "7.6.11",
+      "@types/ws": "8.5.13",
+      "@types/cors": "2.8.17",
+      "@types/jsonwebtoken": "9.0.7",
+      "@types/uuid": "10.0.0",
+      "@types/node-cron": "3.0.11",
+      typescript: "5.6.3",
+      "ts-node": "10.9.2",
+    },
+  };
+  return JSON.stringify(pkg, null, 2);
+}
+
+// ─── Top-level emitter ────────────────────────────────────────────────────────
+
+import { FullEmitter, FullEmitterOptions } from "./emit_full";
+
+export class SqliteEmitter {
+  /**
+   * Emit a complete SQLite-backed Express project.
+   *
+   * Strategy: delegate the bulk of generation to FullEmitter (routes, auth,
+   * websocket, etc), then swap out the Postgres-specific pieces for SQLite
+   * equivalents. The generated routes use a Postgres-shaped SQL surface that
+   * our SQLite db.ts client translates at runtime (NOW() → datetime('now'),
+   * $N → ?, RETURNING * → re-select by id).
+   *
+   * What's swapped:
+   *   - package.json       SQLite deps (better-sqlite3) instead of pg
+   *   - .env.example       SQLite-shaped env vars
+   *   - src/db.ts          better-sqlite3 client with SQL translation
+   *   - src/migrate.ts     SQLite migration runner
+   *   - migrations/*.sql   SQLite-flavored DDL (TEXT, no JSONB, etc.)
+   *   - README.md          SQLite-aware quick start
+   *
+   * What's removed:
+   *   - docker-compose.yaml, Dockerfile, k8s/deployment.yaml — SQLite is
+   *     single-file; no service orchestration needed
+   *
+   * Known limitations:
+   *   - Capability bodies that use jsonb_set / jsonb_agg / jsonb_array_elements
+   *     fail at runtime. Refactor those capabilities or use the Express target.
+   *   - Durable event delivery (EVENT_MODE=durable) requires Postgres-only
+   *     features (FOR UPDATE SKIP LOCKED). Default is in_process which works
+   *     fine on SQLite.
+   *   - row_to_json(t.*) in LIST joins degrades to t.id (no full join object).
+   */
+  emit(system: IR.IRSystem, options: FullEmitterOptions = {}): EmittedFile[] {
+    // 1. Generate the full Express project
+    const fullFiles = new FullEmitter().emit(system, options);
+
+    // 2. Files we replace with SQLite equivalents (keyed by path)
+    const replacements = this.buildReplacements(system);
+
+    // 3. Files we drop entirely (Postgres-specific infra)
+    const drops = new Set<string>([
+      "docker-compose.yaml",
+      "Dockerfile",
+      ".dockerignore",
+      "k8s/deployment.yaml",
+      "src/migration_diff.ts", // Postgres-specific schema diff
+    ]);
+
+    const out: EmittedFile[] = [];
+    for (const f of fullFiles) {
+      if (drops.has(f.path)) continue;
+
+      // Migrations need wholesale replacement: regenerate per-entity SQLite SQL.
+      if (f.path.startsWith("migrations/") && f.path.endsWith(".sql") &&
+          f.path !== "migrations/event_outbox.sql" &&
+          f.path !== "migrations/audit_log.sql") {
+        // We re-emit these from scratch below.
+        continue;
+      }
+
+      const replacement = replacements.get(f.path);
+      if (replacement) {
+        out.push(replacement);
+        replacements.delete(f.path);
+        continue;
+      }
+      out.push(f);
+    }
+
+    // 4. Append per-entity SQLite migrations
+    const seenPaths = new Set<string>();
+    for (const mod of system.modules) {
+      if (mod.kind === "data_store" || mod.kind === "api_service") {
+        for (const model of mod.models) {
+          const file = emitSqliteSchema(model, mod, system);
+          if (seenPaths.has(file.path)) continue;
+          seenPaths.add(file.path);
+          out.push(file);
+        }
+      }
+    }
+
+    // 5. Add the SQLite migration runner (rebuilt with all schemas in scope)
+    const allSchemas: string[] = out
+      .filter(f => f.path.startsWith("migrations/") && f.path.endsWith(".sql"))
+      .map(f => f.content);
+    out.push({
+      path: "src/migrate.ts",
+      content: emitSqliteMigration(system, allSchemas),
+      language: "typescript",
+      source_module: "infra",
+    });
+
+    // 6. Add any replacements that weren't already handled (i.e. files unique to SQLite)
+    for (const r of replacements.values()) {
+      out.push(r);
+    }
+
+    return out;
+  }
+
+  private buildReplacements(system: IR.IRSystem): Map<string, EmittedFile> {
+    const map = new Map<string, EmittedFile>();
+
+    map.set("package.json", {
+      path: "package.json",
+      content: emitSqlitePackageJson(system),
+      language: "json",
+      source_module: "root",
+    });
+
+    map.set(".env.example", {
+      path: ".env.example",
+      content: this.emitEnvExample(system),
+      language: "yaml",
+      source_module: "root",
+    });
+
+    map.set("src/db.ts", {
+      path: "src/db.ts",
+      content: emitSqliteDbClient(system),
+      language: "typescript",
+      source_module: "infra",
+    });
+
+    map.set("src/events.ts", {
+      path: "src/events.ts",
+      content: this.emitInProcessEventBus(system),
+      language: "typescript",
+      source_module: "infra",
+    });
+
+    map.set("migrations/event_outbox.sql", {
+      path: "migrations/event_outbox.sql",
+      content: emitSqliteOutboxSchema(),
+      language: "sql",
+      source_module: "infra",
+    });
+
+    map.set("migrations/audit_log.sql", {
+      path: "migrations/audit_log.sql",
+      content: emitSqliteAuditSchema(),
+      language: "sql",
+      source_module: "infra",
+    });
+
+    map.set("README.md", {
+      path: "README.md",
+      content: this.emitReadme(system),
+      language: "yaml",
+      source_module: "root",
+    });
+
+    return map;
+  }
+
+  /**
+   * In-process-only event bus for SQLite.
+   *
+   * The default Express target's events.ts has a durable mode backed by a
+   * Postgres outbox with FOR UPDATE SKIP LOCKED. SQLite has no equivalent,
+   * so we ship a simpler bus that only does in-memory delivery. Callers
+   * can still use the same eventBus.publish() / .subscribe() API; only
+   * `EVENT_MODE=durable` is unsupported.
+   */
+  private emitInProcessEventBus(system: IR.IRSystem): string {
+    const lines: string[] = [];
+    lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+    lines.push(`// In-process event bus (SQLite target — durable mode is Postgres-only).`);
+    lines.push(``);
+    lines.push(`import { v4 as uuid } from "uuid";`);
+    lines.push(`import { logger } from "./logger";`);
+    lines.push(`import { counter } from "./metrics";`);
+    lines.push(``);
+    lines.push(`export interface EventMetadata {`);
+    lines.push(`  source: string;`);
+    lines.push(`  timestamp: Date;`);
+    lines.push(`  correlation_id: string;`);
+    lines.push(`  causation_id: string;`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export interface SystemEvent {`);
+    lines.push(`  type: string;`);
+    lines.push(`  payload: Record<string, unknown>;`);
+    lines.push(`  metadata: EventMetadata;`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`type Handler = (event: SystemEvent) => Promise<void>;`);
+    lines.push(``);
+    lines.push(`class InProcessBus {`);
+    lines.push(`  private handlers: Map<string, Handler[]> = new Map();`);
+    lines.push(``);
+    lines.push(`  subscribe(type: string, handler: Handler): void {`);
+    lines.push(`    const existing = this.handlers.get(type) || [];`);
+    lines.push(`    existing.push(handler);`);
+    lines.push(`    this.handlers.set(type, existing);`);
+    lines.push(`  }`);
+    lines.push(``);
+    lines.push(`  async publish(`);
+    lines.push(`    type: string,`);
+    lines.push(`    payload: Record<string, unknown>,`);
+    lines.push(`    source: string,`);
+    lines.push(`    correlationId?: string,`);
+    lines.push(`    _client?: unknown,`);
+    lines.push(`  ): Promise<void> {`);
+    lines.push(`    const event: SystemEvent = {`);
+    lines.push(`      type,`);
+    lines.push(`      payload,`);
+    lines.push(`      metadata: {`);
+    lines.push(`        source,`);
+    lines.push(`        timestamp: new Date(),`);
+    lines.push(`        correlation_id: correlationId || uuid(),`);
+    lines.push(`        causation_id: uuid(),`);
+    lines.push(`      },`);
+    lines.push(`    };`);
+    lines.push(`    counter("event.published", { type, mode: "in_process" });`);
+    lines.push(`    const handlers = this.handlers.get(type) || [];`);
+    lines.push(`    for (const handler of handlers) {`);
+    lines.push(`      try {`);
+    lines.push(`        await handler(event);`);
+    lines.push(`        counter("event.delivered", { type, mode: "in_process" });`);
+    lines.push(`      } catch (e: any) {`);
+    lines.push(`        counter("event.delivery_failed", { type, mode: "in_process" });`);
+    lines.push(`        logger.error("event_handler_failed", { event: type, metadata: { error: e.message } });`);
+    lines.push(`      }`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push(``);
+    lines.push(`  startWorker(_intervalMs?: number): null {`);
+    lines.push(`    // No-op for in-process mode.`);
+    lines.push(`    return null;`);
+    lines.push(`  }`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`if (process.env.EVENT_MODE === "durable") {`);
+    lines.push(`  console.warn("[events] EVENT_MODE=durable is not supported on the SQLite target. Falling back to in_process.");`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export const eventBus = new InProcessBus();`);
+    lines.push(``);
+    return lines.join("\n");
+  }
+
+  private emitTsConfig(): string {
+    const cfg = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        lib: ["ES2020", "DOM"],
+        outDir: "./dist",
+        rootDir: "./src",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        declaration: true,
+        sourceMap: true,
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"],
+    };
+    return JSON.stringify(cfg, null, 2);
+  }
+
+  private emitEnvExample(system: IR.IRSystem): string {
+    return `# ${system.name} (SQLite target)
+# Copy to .env and customize.
+
+# --- Database ---
+# Path to the SQLite database file. Defaults to ./<system_name>.db
+SQLITE_PATH=./${toSnakeCase(system.name)}.db
+
+# --- Required in production ---
+# Generate with: node -e "console.log(require('crypto').randomBytes(48).toString('hex'))"
+JWT_SECRET=
+
+# --- Server ---
+PORT=3000
+NODE_ENV=development
+
+# --- CORS ---
+# Comma-separated list of allowed origins. Leave empty to disallow cross-origin requests.
+ALLOWED_ORIGINS=
+
+# --- Event delivery ---
+# in_process: in-memory bus, no durability — recommended for SQLite.
+# durable mode (Postgres outbox + FOR UPDATE SKIP LOCKED) is not supported.
+EVENT_MODE=in_process
+
+# --- Request timeout ---
+REQUEST_TIMEOUT_MS=30000
+
+# --- Notifications ---
+# NOTIFY_PROVIDER=log|resend|sendgrid|webhook (default: log)
+NOTIFY_PROVIDER=log
+NOTIFY_API_KEY=
+NOTIFY_FROM_EMAIL=noreply@example.com
+
+# --- Webhook delivery ---
+NOTIFY_WEBHOOK_URL=
+NOTIFY_WEBHOOK_SECRET=
+`;
+  }
+
+  private emitReadme(system: IR.IRSystem): string {
+    return `# ${system.name} (SQLite target)
+
+Generated by BoneScript compiler. Source hash: ${system.source_hash}
+
+## Quick Start
+
+\`\`\`bash
+npm install
+npm run migrate
+npm run dev
+\`\`\`
+
+The database file will be created at \`./${toSnakeCase(system.name)}.db\` by
+default. Override with the \`SQLITE_PATH\` environment variable.
+
+The server starts at http://localhost:3000 with all routes wired:
+
+- CRUD endpoints for every entity
+- Capability endpoints (\`POST /<entity>s/<capability-name>\`)
+- Health checks at \`/health/live\`, \`/health/ready\`, \`/health/metrics\`
+- Admin panel at \`/admin\`
+
+## Why SQLite
+
+Self-contained, single-file database. No external services to start, no
+Docker, no Postgres. The whole database is one file you can copy, version,
+or back up.
+
+Ideal for: local development, demos, integration tests, single-node
+deployments. For production multi-writer workloads, use the default Express
+target (Postgres-backed).
+
+## Auth
+
+Send a Bearer token in the Authorization header:
+
+\`\`\`
+Authorization: Bearer <jwt-token>
+\`\`\`
+
+Generate a token by signing with the same \`JWT_SECRET\` from your \`.env\`.
+
+## Differences from the Postgres target
+
+- Schema uses \`TEXT\`/\`INTEGER\` instead of \`VARCHAR\`/\`BIGINT\`/\`JSONB\`
+- The DB client (\`src/db.ts\`) translates Postgres-flavored SQL at runtime:
+  - \`$N\` placeholders → \`?\` (with param array reordering)
+  - \`NOW()\` → \`datetime('now')\`
+  - \`RETURNING *\` → re-select by id
+  - \`row_to_json(t.*)\` in LIST joins degrades to \`t.id\` only
+- Durable event mode (\`EVENT_MODE=durable\`) is not supported on SQLite —
+  it requires Postgres-only \`FOR UPDATE SKIP LOCKED\`. Use \`in_process\`.
+- Capability bodies that reference \`jsonb_set\`, \`jsonb_agg\`, or
+  \`jsonb_array_elements\` will fail at runtime. Refactor those capabilities
+  or compile to the Express target.
+
+## Environment
+
+Copy \`.env.example\` to \`.env\` and configure.
+`;
+  }
+}