bonescript-compiler 0.2.1 → 0.4.0

package/src/emit_router.ts

@@ -0,0 +1,409 @@
+/**
+ * BoneScript Router Emitter
+ * Generates Express route files (CRUD + capability endpoints) and
+ * state machine runtime files for each entity.
+ */
+
+import * as IR from "./ir";
+import { emitCapabilityBody } from "./emit_capability";
+
+// ─── Shared helpers ───────────────────────────────────────────────────────────
+
+export function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+export function toCamelCase(s: string): string {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+const TS_TYPE_MAP: Record<string, string> = {
+  string: "string", uint: "number", int: "number", float: "number",
+  bool: "boolean", timestamp: "Date", uuid: "string", bytes: "Buffer", json: "unknown",
+};
+
+export function toTsType(irType: string): string {
+  if (TS_TYPE_MAP[irType]) return TS_TYPE_MAP[irType];
+  const m = irType.match(/^(list|set)<(.+)>$/);
+  if (m) return `${toTsType(m[2])}[]`;
+  const om = irType.match(/^optional<(.+)>$/);
+  if (om) return `${toTsType(om[1])} | null`;
+  return irType;
+}
+
+// ─── Unknown function collector ───────────────────────────────────────────────
+
+const KNOWN_FUNCTIONS = new Set([
+  "now", "count", "sum", "min", "max", "avg", "length", "size",
+  "shortestPath", "topologicalSort", "binarySearch", "bipartiteMatching",
+  "roundRobin", "weightedAverage", "percentile", "rankBy", "consistentHash",
+]);
+
+function collectUnknownFunctions(mod: IR.IRModule): Set<string> {
+  const found = new Set<string>();
+  for (const iface of mod.interfaces) {
+    for (const method of iface.methods) {
+      for (const effect of method.effects) extractFunctionCalls(effect.value, found);
+      for (const pre of method.preconditions) extractFunctionCalls(pre.expression, found);
+    }
+  }
+  return found;
+}
+
+function extractFunctionCalls(expr: string, found: Set<string>): void {
+  const pattern = /\b([a-zA-Z_]\w*)\s*\(/g;
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(expr)) !== null) {
+    const name = match[1];
+    if (!KNOWN_FUNCTIONS.has(name)) found.add(name);
+  }
+}
+
+// ─── State Machine Runtime ────────────────────────────────────────────────────
+
+export function emitStateMachineRuntime(sm: IR.IRStateMachine): string {
+  const lines: string[] = [];
+  const stateUnion = sm.states.map(s => `"${s}"`).join(" | ");
+
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(``);
+  lines.push(`export type ${sm.entity}State = ${stateUnion};`);
+  lines.push(``);
+  lines.push(`export const ${sm.entity.toUpperCase()}_INITIAL: ${sm.entity}State = "${sm.initial}";`);
+  lines.push(``);
+  lines.push(`const TRANSITIONS: Record<${sm.entity}State, Record<string, ${sm.entity}State>> = {`);
+  for (const state of sm.states) {
+    const trans = sm.transitions.filter(t => t.from === state);
+    const entries = trans.map(t => `"${t.trigger}": "${t.to}"`).join(", ");
+    lines.push(`  "${state}": { ${entries} },`);
+  }
+  lines.push(`};`);
+  lines.push(``);
+  lines.push(`export function transition${sm.entity}(`);
+  lines.push(`  current: ${sm.entity}State,`);
+  lines.push(`  trigger: string,`);
+  lines.push(`  guard?: () => boolean`);
+  lines.push(`): { ok: true; next: ${sm.entity}State } | { ok: false; error: string } {`);
+  lines.push(`  const next = TRANSITIONS[current]?.[trigger];`);
+  lines.push(`  if (!next) return { ok: false, error: \`Invalid transition: \${current} --[\${trigger}]--> ?\` };`);
+  lines.push(`  if (guard && !guard()) return { ok: false, error: \`Guard failed for transition: \${current} --[\${trigger}]--> \${next}\` };`);
+  lines.push(`  return { ok: true, next };`);
+  lines.push(`}`);
+  lines.push(``);
+
+  return lines.join("\n");
+}
+
+// ─── Entity Router ────────────────────────────────────────────────────────────
+
+export function emitEntityRouter(mod: IR.IRModule, system: IR.IRSystem): string {
+  const entityModel = mod.models[0];
+  if (!entityModel) return "";
+
+  const tableName = toSnakeCase(entityModel.name) + "s";
+  const routeBase = toSnakeCase(entityModel.name) + "s";
+  const lines: string[] = [];
+
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`// Service: ${mod.name}`);
+  lines.push(`import { Router, Request, Response } from "express";`);
+  lines.push(`import { v4 as uuid } from "uuid";`);
+  lines.push(`import { query, queryOne, execute, pool } from "../db";`);
+  lines.push(`import { eventBus } from "../events";`);
+  lines.push(`import { requireAuth, AuthContext } from "../auth";`);
+  lines.push(`import { logger } from "../logger";`);
+  lines.push(`import { counter } from "../metrics";`);
+  lines.push(`import * as __algorithms from "../algorithms";`);
+  lines.push(`const { shortestPath, topologicalSort, binarySearch, bipartiteMatching, roundRobin, weightedAverage, percentile, rankBy, consistentHash } = __algorithms as any;`);
+  lines.push(``);
+
+  // Import broadcastToChannel if any capability uses sync: realtime
+  const hasRealtime = mod.interfaces.some(i => i.methods.some(m => m.sync === "realtime"));
+  if (hasRealtime) {
+    // Only import if websocket.ts will be generated (system has realtime_service modules)
+    const hasWebSocket = system.modules.some(m => m.kind === "realtime_service");
+    if (hasWebSocket) {
+      lines.push(`import { broadcastToChannel } from "../websocket";`);
+    } else {
+      // No WebSocket server — define a no-op stub so the route file still compiles
+      lines.push(`// No realtime_service declared — broadcastToChannel is a no-op`);
+      lines.push(`function broadcastToChannel(_channel: string, _msg: unknown, _exclude?: unknown): void {}`);
+    }
+    lines.push(``);
+  }
+  const unknownFunctions = collectUnknownFunctions(mod);
+  if (unknownFunctions.size > 0) {
+    lines.push(`// User-defined functions referenced in effects — implement these or use extension_point`);
+    for (const fn of unknownFunctions) lines.push(`declare function ${fn}(...args: any[]): any;`);
+    lines.push(``);
+  }
+
+  if (mod.state_machines.length > 0) {
+    const sm = mod.state_machines[0];
+    lines.push(`import { transition${sm.entity}, ${sm.entity.toUpperCase()}_INITIAL } from "../state_machines/${toSnakeCase(sm.entity)}";`);
+    lines.push(``);
+  }
+
+  lines.push(`export const ${toCamelCase(routeBase)}Router = Router();`);
+  lines.push(``);
+
+  // CREATE
+  const insertFields = entityModel.fields.filter(f =>
+    f.name !== "id" && f.name !== "created_at" && f.name !== "updated_at"
+  );
+  lines.push(`// CREATE`);
+  lines.push(`${toCamelCase(routeBase)}Router.post("/", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  try {`);
+  lines.push(`    const id = uuid();`);
+  lines.push(`    const { ${insertFields.map(f => f.name).join(", ")} } = req.body;`);
+  if (mod.state_machines.length > 0) {
+    lines.push(`    const state = ${mod.state_machines[0].entity.toUpperCase()}_INITIAL;`);
+  }
+  const allInsertFields = ["id", ...insertFields.map(f => f.name)];
+  if (mod.state_machines.length > 0 && !insertFields.find(f => f.name === "state")) {
+    allInsertFields.push("state");
+  }
+  const placeholders = allInsertFields.map((_, i) => `$${i + 1}`).join(", ");
+  const values = allInsertFields.map(f => f === "id" ? "id" : f === "state" ? "state" : f).join(", ");
+  lines.push(`    const sql = \`INSERT INTO ${tableName} (${allInsertFields.join(", ")}) VALUES (${placeholders}) RETURNING *\`;`);
+  lines.push(`    const rows = await query(sql, [${values}]);`);
+  lines.push(`    counter("entity.created", { entity: "${entityModel.name}" });`);
+  lines.push(`    res.status(201).json(rows[0]);`);
+  lines.push(`  } catch (e: any) {`);
+  lines.push(`    res.status(400).json({ error: { code: "CREATE_FAILED", message: e.message } });`);
+  lines.push(`  }`);
+  lines.push(`});`);
+  lines.push(``);
+
+  // READ
+  lines.push(`// READ`);
+  lines.push(`${toCamelCase(routeBase)}Router.get("/:id", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  try {`);
+  lines.push(`    const row = await queryOne(\`SELECT * FROM ${tableName} WHERE id = $1\`, [req.params.id]);`);
+  lines.push(`    if (!row) return res.status(404).json({ error: { code: "NOT_FOUND", message: "Not found" } });`);
+  lines.push(`    res.json(row);`);
+  lines.push(`  } catch (e: any) {`);
+  lines.push(`    res.status(500).json({ error: { code: "DB_ERROR", message: e.message } });`);
+  lines.push(`  }`);
+  lines.push(`});`);
+  lines.push(``);
+
+  // LIST — COUNT(*) OVER() window function avoids a separate COUNT round-trip
+  const joinRelations = mod.relations.filter(r => r.kind === "has_one" || r.kind === "belongs_to");
+  lines.push(`// LIST`);
+  lines.push(`${toCamelCase(routeBase)}Router.get("/", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  try {`);
+  lines.push(`    const page = parseInt(req.query.page as string) || 1;`);
+  lines.push(`    const pageSize = Math.min(parseInt(req.query.page_size as string) || 50, 100);`);
+  lines.push(`    const offset = (page - 1) * pageSize;`);
+  if (joinRelations.length > 0) {
+    const joinClauses = joinRelations.map(r => {
+      const alias = r.to_table.slice(0, -1);
+      return r.kind === "belongs_to"
+        ? `LEFT JOIN ${r.to_table} ${alias} ON ${tableName}.${r.foreign_key} = ${alias}.id`
+        : `LEFT JOIN ${r.to_table} ${alias} ON ${alias}.${r.foreign_key} = ${tableName}.id`;
+    }).join(" ");
+    const relCols = joinRelations.map(r => `row_to_json(${r.to_table.slice(0, -1)}.*) as ${r.name}`).join(", ");
+    lines.push(`    const rows = await query(\`SELECT ${tableName}.*, ${relCols}, COUNT(*) OVER() AS __total FROM ${tableName} ${joinClauses} ORDER BY ${tableName}.created_at DESC LIMIT $1 OFFSET $2\`, [pageSize, offset]);`);
+  } else {
+    lines.push(`    const rows = await query(\`SELECT *, COUNT(*) OVER() AS __total FROM ${tableName} ORDER BY created_at DESC LIMIT $1 OFFSET $2\`, [pageSize, offset]);`);
+  }
+  lines.push(`    const total = rows.length > 0 ? parseInt((rows[0] as any).__total) : 0;`);
+  lines.push(`    const items = rows.map((r: any) => { const { __total, ...rest } = r; return rest; });`);
+  lines.push(`    res.json({ items, total, page, page_size: pageSize });`);
+  lines.push(`  } catch (e: any) {`);
+  lines.push(`    res.status(500).json({ error: { code: "DB_ERROR", message: e.message } });`);
+  lines.push(`  }`);
+  lines.push(`});`);
+  lines.push(``);
+
+  // UPDATE — column allowlist prevents SQL injection via field name interpolation
+  const updatableFields = entityModel.fields.filter(f =>
+    f.name !== "id" && f.name !== "created_at" && f.name !== "updated_at"
+  );
+  const allowedCols = updatableFields.map(f => `"${f.name}"`).join(", ");
+  lines.push(`// UPDATE`);
+  lines.push(`${toCamelCase(routeBase)}Router.put("/:id", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  // Only allow known columns — prevents SQL injection via field name interpolation`);
+  lines.push(`  const ALLOWED_COLUMNS = new Set([${allowedCols}]);`);
+  lines.push(`  const rawFields = { ...req.body };`);
+  lines.push(`  const fields: Record<string, unknown> = {};`);
+  lines.push(`  for (const key of Object.keys(rawFields)) {`);
+  lines.push(`    if (ALLOWED_COLUMNS.has(key)) fields[key] = rawFields[key];`);
+  lines.push(`  }`);
+  lines.push(`  if (Object.keys(fields).length === 0) {`);
+  lines.push(`    return res.status(400).json({ error: { code: "NO_VALID_FIELDS", message: "No valid fields to update" } });`);
+  lines.push(`  }`);
+  if (mod.state_machines.length > 0) {
+    const sm = mod.state_machines[0];
+    lines.push(`  if (fields.state !== undefined) {`);
+    lines.push(`    const current = await queryOne<{ state: string }>(\`SELECT state FROM ${tableName} WHERE id = $1\`, [req.params.id]);`);
+    lines.push(`    if (!current) return res.status(404).json({ error: { code: "NOT_FOUND", message: "Not found" } });`);
+    lines.push(`    const trigger = \`\${current.state}_to_\${fields.state}\`;`);
+    lines.push(`    const tr = transition${sm.entity}(current.state as any, trigger);`);
+    lines.push(`    if (!tr.ok) return res.status(422).json({ error: { code: "INVALID_TRANSITION", message: \`Cannot transition from \${current.state} to \${fields.state}\` } });`);
+    lines.push(`  }`);
+  }
+  lines.push(`  const sets = Object.keys(fields).map((k, i) => \`\${k} = $\${i + 2}\`).join(", ");`);
+  lines.push(`  const values = Object.values(fields);`);
+  lines.push(`  const sql = \`UPDATE ${tableName} SET \${sets}, updated_at = NOW() WHERE id = $1 RETURNING *\`;`);
+  lines.push(`  const rows = await query(sql, [req.params.id, ...values]);`);
+  lines.push(`  if (rows.length === 0) return res.status(404).json({ error: { code: "NOT_FOUND", message: "Not found" } });`);
+  lines.push(`  res.json(rows[0]);`);
+  lines.push(`});`);
+  lines.push(``);
+
+  // DELETE
+  lines.push(`// DELETE`);
+  lines.push(`${toCamelCase(routeBase)}Router.delete("/:id", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  try {`);
+  lines.push(`    const count = await execute(\`DELETE FROM ${tableName} WHERE id = $1\`, [req.params.id]);`);
+  lines.push(`    if (count === 0) return res.status(404).json({ error: { code: "NOT_FOUND", message: "Not found" } });`);
+  lines.push(`    res.status(204).send();`);
+  lines.push(`  } catch (e: any) {`);
+  lines.push(`    res.status(500).json({ error: { code: "DB_ERROR", message: e.message } });`);
+  lines.push(`  }`);
+  lines.push(`});`);
+  lines.push(``);
+
+  // Capability endpoints
+  for (const iface of mod.interfaces) {
+    for (const method of iface.methods) {
+      if (["create", "read", "update", "delete", "list"].includes(method.name)) continue;
+      lines.push(emitCapabilityEndpoint(method, mod, tableName, system));
+    }
+  }
+
+  // Relation endpoints
+  for (const rel of mod.relations) {
+    if (rel.kind === "has_many") {
+      lines.push(`// RELATION: ${rel.name} (has_many ${rel.to_entity})`);
+      lines.push(`${toCamelCase(routeBase)}Router.get("/:id/${rel.name}", requireAuth, async (req: Request, res: Response) => {`);
+      lines.push(`  try {`);
+      lines.push(`    const page = parseInt(req.query.page as string) || 1;`);
+      lines.push(`    const pageSize = Math.min(parseInt(req.query.page_size as string) || 50, 100);`);
+      lines.push(`    const offset = (page - 1) * pageSize;`);
+      lines.push(`    // COUNT(*) OVER() avoids a separate COUNT round-trip`);
+      lines.push(`    const rows = await query(\`SELECT *, COUNT(*) OVER() AS __total FROM ${rel.to_table} WHERE ${rel.foreign_key} = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3\`, [req.params.id, pageSize, offset]);`);
+      lines.push(`    const total = rows.length > 0 ? parseInt((rows[0] as any).__total) : 0;`);
+      lines.push(`    const items = rows.map((r: any) => { const { __total, ...rest } = r; return rest; });`);
+      lines.push(`    res.json({ items, total, page, page_size: pageSize });`);
+      lines.push(`  } catch (e: any) {`);
+      lines.push(`    res.status(500).json({ error: { code: "DB_ERROR", message: e.message } });`);
+      lines.push(`  }`);
+      lines.push(`});`);
+      lines.push(``);
+    }
+    if (rel.kind === "many_to_many" && rel.junction_table) {
+      lines.push(`// RELATION: ${rel.name} (many_to_many ${rel.to_entity})`);
+      lines.push(`${toCamelCase(routeBase)}Router.get("/:id/${rel.name}", requireAuth, async (req: Request, res: Response) => {`);
+      lines.push(`  try {`);
+      lines.push(`    const rows = await query(\`SELECT ${rel.to_table}.* FROM ${rel.to_table} INNER JOIN ${rel.junction_table} ON ${rel.junction_table}.${rel.to_table.slice(0, -1)}_id = ${rel.to_table}.id WHERE ${rel.junction_table}.${rel.from_table.slice(0, -1)}_id = $1\`, [req.params.id]);`);
+      lines.push(`    res.json({ items: rows, total: rows.length });`);
+      lines.push(`  } catch (e: any) {`);
+      lines.push(`    res.status(500).json({ error: { code: "DB_ERROR", message: e.message } });`);
+      lines.push(`  }`);
+      lines.push(`});`);
+      lines.push(``);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ─── Capability Endpoint ──────────────────────────────────────────────────────
+
+export function emitCapabilityEndpoint(
+  method: IR.IRMethod,
+  mod: IR.IRModule,
+  tableName: string,
+  system: IR.IRSystem,
+): string {
+  const lines: string[] = [];
+  const routerName = toCamelCase(toSnakeCase(mod.models[0]?.name || mod.name) + "s") + "Router";
+  const endpoint = `/${method.name.replace(/_/g, "-")}`;
+  const isTransactional = method.sync === "transactional";
+
+  lines.push(`// CAPABILITY: ${method.name}${isTransactional ? " [transactional]" : ""}${method.retry ? ` [retry: ${method.retry.max_attempts}x ${method.retry.backoff}]` : ""}`);
+  lines.push(`${routerName}.post("${endpoint}", requireAuth, async (req: Request, res: Response) => {`);
+  lines.push(`  const auth: AuthContext = (req as any).auth;`);
+
+  if (method.retry) {
+    const { max_attempts, backoff, interval_ms } = method.retry;
+    lines.push(`  let __attempt = 0;`);
+    lines.push(`  const __maxAttempts = ${max_attempts};`);
+    lines.push(`  const __intervalMs = ${interval_ms};`);
+    lines.push(`  const __backoff = "${backoff}";`);
+    lines.push(`  while (__attempt < __maxAttempts) {`);
+    lines.push(`    __attempt++;`);
+    lines.push(`    try {`);
+  }
+
+  if (isTransactional) {
+    lines.push(`  const __client = await pool.connect();`);
+    lines.push(`  try {`);
+    lines.push(`    await __client.query("BEGIN");`);
+  } else if (method.sync === "realtime") {
+    lines.push(`  try {`);
+    lines.push(`    // sync: realtime — execute then broadcast to WebSocket channel`);
+  } else if (method.sync === "eventual") {
+    lines.push(`  try {`);
+    lines.push(`    // sync: eventual — effects applied, events queued via outbox`);
+  } else if (method.sync === "batch") {
+    lines.push(`  try {`);
+    lines.push(`    // sync: batch — enqueued for batch processing`);
+    lines.push(`    const { enqueueBatch } = require("../batch");`);
+    lines.push(`    const result = await enqueueBatch("${mod.name}.${method.name}", req.body);`);
+    lines.push(`    res.json({ ok: true, action: "${method.name}", queued: true, result });`);
+    lines.push(`    return;`);
+  } else {
+    lines.push(`  try {`);
+  }
+
+  if (method.pipeline) {
+    const { emitPipelineBody } = require("./emit_composition");
+    lines.push(emitPipelineBody(method, "    "));
+  } else if (method.algorithm) {
+    const { emitAlgorithmBody } = require("./emit_composition");
+    lines.push(emitAlgorithmBody(method, "    "));
+  } else {
+    lines.push(emitCapabilityBody(method, mod, system, "    "));
+  }
+
+  if (isTransactional) {
+    lines.push(`    await __client.query("COMMIT");`);
+    lines.push(`  } catch (e: any) {`);
+    lines.push(`    await __client.query("ROLLBACK");`);
+    lines.push(`    res.status(400).json({ error: { code: "CAPABILITY_FAILED", message: e.message } });`);
+    lines.push(`  } finally {`);
+    lines.push(`    __client.release();`);
+    lines.push(`  }`);
+  } else if (method.sync === "realtime") {
+    lines.push(`    broadcastToChannel("${mod.name}", { type: "${method.name}", payload: req.body, actor: auth.actor_id });`);
+    lines.push(`  } catch (e: any) {`);
+    lines.push(`    res.status(400).json({ error: { code: "CAPABILITY_FAILED", message: e.message } });`);
+    lines.push(`  }`);
+  } else {
+    lines.push(`  } catch (e: any) {`);
+    lines.push(`    res.status(400).json({ error: { code: "CAPABILITY_FAILED", message: e.message } });`);
+    lines.push(`  }`);
+  }
+
+  if (method.retry) {
+    lines.push(`    } catch (e: any) {`);
+    lines.push(`      if (__attempt >= __maxAttempts) {`);
+    lines.push(`        res.status(503).json({ error: { code: "MAX_RETRIES_EXCEEDED", message: e.message, attempts: __attempt } });`);
+    lines.push(`        return;`);
+    lines.push(`      }`);
+    lines.push(`      const delay = __backoff === "exponential" ? __intervalMs * Math.pow(2, __attempt - 1)`);
+    lines.push(`        : __backoff === "linear" ? __intervalMs * __attempt`);
+    lines.push(`        : __intervalMs;`);
+    lines.push(`      await new Promise(r => setTimeout(r, delay));`);
+    lines.push(`    }`);
+    lines.push(`  } // end retry loop`);
+  }
+
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join("\n");
+}