bonescript-compiler 0.7.0 → 0.8.0

package/src/emit_sqlite.ts

@@ -0,0 +1,562 @@
+/**
+ * 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 $1, $2, ... placeholders to SQLite ? placeholders.`,
+    `// The generated route handlers use $N because the Postgres backend is the`,
+    `// canonical target; this keeps the surface uniform.`,
+    `function translateSql(sql: string): string {`,
+    `  return sql.replace(/\\$(\\d+)/g, "?");`,
+    `}`,
+    ``,
+    `// 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;`,
+    `}`,
+    ``,
+    `export async function query<T = any>(text: string, params: any[] = []): Promise<T[]> {`,
+    `  const db = getDb();`,
+    `  const { sql: stripped, hadReturning } = stripReturning(text);`,
+    `  const sql = translateSql(stripped);`,
+    `  const trimmed = sql.trim().toUpperCase();`,
+    `  if (trimmed.startsWith("SELECT") || trimmed.startsWith("WITH")) {`,
+    `    return db.prepare(sql).all(...params) as T[];`,
+    `  }`,
+    `  // INSERT / UPDATE / DELETE`,
+    `  const stmt = db.prepare(sql);`,
+    `  const info = stmt.run(...params);`,
+    `  if (hadReturning) {`,
+    `    const table = extractTable(sql);`,
+    `    if (!table) return [];`,
+    `    if (trimmed.startsWith("INSERT")) {`,
+    `      // Look up by id (which is in params[0] for our generated INSERT shape)`,
+    `      const id = params[0];`,
+    `      const row = db.prepare(\`SELECT * FROM \${table} WHERE id = ?\`).get(id);`,
+    `      return row ? [row as T] : [];`,
+    `    }`,
+    `    if (trimmed.startsWith("UPDATE")) {`,
+    `      // The id parameter for our generated UPDATE shape is params[0] (WHERE id = $1).`,
+    `      const id = params[0];`,
+    `      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 = translateSql(stripped);`,
+    `  const info = db.prepare(sql).run(...params);`,
+    `  return info.changes;`,
+    `}`,
+    ``,
+    `export async function transaction<T>(fn: (client: any) => Promise<T>): Promise<T> {`,
+    `  const db = getDb();`,
+    `  // better-sqlite3 transactions are synchronous; we adapt with deasync-style`,
+    `  // immediate execution. The fn here uses query/execute which read the same db.`,
+    `  const txn = db.transaction(async () => await fn({ query: query, execute: execute }));`,
+    `  return await txn();`,
+    `}`,
+    ``,
+    `// 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 {
+  // 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(), "app.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 {
+  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",
+    },
+    dependencies: {
+      express: "4.22.2",
+      "better-sqlite3": "11.5.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/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 ────────────────────────────────────────────────────────
+
+export class SqliteEmitter {
+  emit(system: IR.IRSystem): EmittedFile[] {
+    const files: EmittedFile[] = [];
+
+    // 1. Package + tsconfig
+    files.push({ path: "package.json", content: emitSqlitePackageJson(system), language: "json", source_module: "root" });
+    files.push({ path: "tsconfig.json", content: this.emitTsConfig(), language: "json", source_module: "root" });
+    files.push({ path: ".env.example", content: this.emitEnvExample(system), language: "yaml", source_module: "root" });
+
+    // 2. Schema files + collect for migration runner
+    const schemas: string[] = [];
+    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);
+          files.push(file);
+          schemas.push(file.content);
+        }
+      }
+    }
+
+    // 3. Outbox + audit infra schemas
+    files.push({ path: "migrations/event_outbox.sql", content: emitSqliteOutboxSchema(), language: "sql", source_module: "infra" });
+    files.push({ path: "migrations/audit_log.sql", content: emitSqliteAuditSchema(), language: "sql", source_module: "infra" });
+    schemas.push(emitSqliteOutboxSchema());
+    schemas.push(emitSqliteAuditSchema());
+
+    // 4. DB client
+    files.push({ path: "src/db.ts", content: emitSqliteDbClient(system), language: "typescript", source_module: "infra" });
+
+    // 5. Migration runner
+    files.push({ path: "src/migrate.ts", content: emitSqliteMigration(system, schemas), language: "typescript", source_module: "infra" });
+
+    // 6. README
+    files.push({ path: "README.md", content: this.emitReadme(system), language: "yaml", source_module: "root" });
+
+    return files;
+  }
+
+  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)
+
+# Path to the SQLite database file. Defaults to ./<system_name>.db
+SQLITE_PATH=./${toSnakeCase(system.name)}.db
+
+PORT=3000
+NODE_ENV=development
+
+JWT_SECRET=
+EVENT_MODE=in_process
+`;
+  }
+
+  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.
+
+## Why SQLite
+
+This target produces a self-contained backend with no external services:
+- No Postgres / Redis to start
+- No Docker
+- The whole database is one file you can copy, version, or back up easily
+
+It's ideal for local development, demos, integration tests, and small
+single-node deployments. For production multi-writer workloads, use the
+default Express target which generates a Postgres-backed project.
+`;
+  }
+}

package/src/index.ts

@@ -17,6 +17,7 @@ export type { SolverResult } from "./solver";
 export { FullEmitter } from "./emit_full";
 export { NakamaEmitter } from "./emit_nakama";
 export { PrismaEmitter } from "./emit_prisma";
+export { SqliteEmitter } from "./emit_sqlite";
 export type { NakamaEmittedFile } from "./emit_nakama";
 export type { EmittedFile } from "./emitter";
 export { Verifier } from "./verifier";
@@ -44,6 +45,7 @@ export { mergeWithExisting, extractImplementations, validateExtensions } from ".
 // New emitters
 export { emitOpenApiSpec, emitOpenApiJson } from "./emit_openapi";
 export { emitTypescriptSdk, emitSdkPackageJson } from "./emit_sdk";
+export { emitReactHooks } from "./emit_react";
 export { emitZodSchemas } from "./emit_zod";
 export { emitPostmanCollection } from "./emit_postman";
 export { emitSeedFile } from "./emit_seed";