bonescript-compiler 0.2.0

package/src/emit_batch.ts

@@ -0,0 +1,140 @@
+/**
+ * BoneScript Batch Executor Emitter
+ * Generates a batch processing module for sync: batch capabilities.
+ * Batch capabilities are queued and processed in configurable intervals.
+ */
+
+import * as IR from "./ir";
+
+export function emitBatchExecutor(system: IR.IRSystem): string {
+  // Collect all batch capabilities
+  const batchMethods: { modName: string; method: IR.IRMethod }[] = [];
+  for (const mod of system.modules) {
+    for (const iface of mod.interfaces) {
+      for (const method of iface.methods) {
+        if (method.sync === "batch") {
+          batchMethods.push({ modName: mod.name, method });
+        }
+      }
+    }
+  }
+
+  if (batchMethods.length === 0) return "";
+
+  const lines: string[] = [];
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`// Batch executor for sync: batch capabilities.`);
+  lines.push(`// Set BATCH_INTERVAL_MS to control flush frequency (default: 5000ms).`);
+  lines.push(``);
+  lines.push(`import { query } from "./db";`);
+  lines.push(`import { logger } from "./logger";`);
+  lines.push(`import { counter, histogram } from "./metrics";`);
+  lines.push(``);
+
+  // Batch queue type
+  lines.push(`interface BatchItem {`);
+  lines.push(`  capability: string;`);
+  lines.push(`  payload: Record<string, unknown>;`);
+  lines.push(`  enqueuedAt: Date;`);
+  lines.push(`  resolve: (result: any) => void;`);
+  lines.push(`  reject: (err: Error) => void;`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Per-capability queues
+  lines.push(`const queues: Map<string, BatchItem[]> = new Map([`);
+  for (const { modName, method } of batchMethods) {
+    lines.push(`  ["${modName}.${method.name}", []],`);
+  }
+  lines.push(`]);`);
+  lines.push(``);
+
+  // Enqueue function
+  lines.push(`export function enqueueBatch(capability: string, payload: Record<string, unknown>): Promise<any> {`);
+  lines.push(`  return new Promise((resolve, reject) => {`);
+  lines.push(`    const queue = queues.get(capability);`);
+  lines.push(`    if (!queue) {`);
+  lines.push(`      reject(new Error(\`Unknown batch capability: \${capability}\`));`);
+  lines.push(`      return;`);
+  lines.push(`    }`);
+  lines.push(`    queue.push({ capability, payload, enqueuedAt: new Date(), resolve, reject });`);
+  lines.push(`    counter("batch.enqueued", { capability });`);
+  lines.push(`  });`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Flush function — processes all queued items
+  lines.push(`async function flushBatch(capability: string, items: BatchItem[]): Promise<void> {`);
+  lines.push(`  if (items.length === 0) return;`);
+  lines.push(`  const start = Date.now();`);
+  lines.push(`  logger.info("batch_flush_started", { event: capability, metadata: { count: items.length } });`);
+  lines.push(``);
+  lines.push(`  // Process items in a single DB transaction`);
+  lines.push(`  const { pool } = require("./db");`);
+  lines.push(`  const client = await pool.connect();`);
+  lines.push(`  try {`);
+  lines.push(`    await client.query("BEGIN");`);
+  lines.push(`    for (const item of items) {`);
+  lines.push(`      try {`);
+  lines.push(`        // Execute the batch item`);
+  lines.push(`        // Each capability's batch handler is registered below`);
+  lines.push(`        const handler = batchHandlers.get(capability);`);
+  lines.push(`        if (handler) {`);
+  lines.push(`          const result = await handler(item.payload, client);`);
+  lines.push(`          item.resolve(result);`);
+  lines.push(`        } else {`);
+  lines.push(`          item.reject(new Error(\`No batch handler for \${capability}\`));`);
+  lines.push(`        }`);
+  lines.push(`      } catch (e: any) {`);
+  lines.push(`        item.reject(e);`);
+  lines.push(`      }`);
+  lines.push(`    }`);
+  lines.push(`    await client.query("COMMIT");`);
+  lines.push(`    histogram("batch.duration_ms", Date.now() - start, { capability });`);
+  lines.push(`    counter("batch.processed", { capability, count: String(items.length) });`);
+  lines.push(`    logger.info("batch_flush_completed", { event: capability, metadata: { count: items.length, duration_ms: Date.now() - start } });`);
+  lines.push(`  } catch (e: any) {`);
+  lines.push(`    await client.query("ROLLBACK");`);
+  lines.push(`    for (const item of items) item.reject(e);`);
+  lines.push(`    logger.error("batch_flush_failed", { event: capability, metadata: { error: e.message } });`);
+  lines.push(`  } finally {`);
+  lines.push(`    client.release();`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Batch handler registry
+  lines.push(`type BatchHandler = (payload: Record<string, unknown>, client: any) => Promise<any>;`);
+  lines.push(`const batchHandlers: Map<string, BatchHandler> = new Map();`);
+  lines.push(``);
+  lines.push(`export function registerBatchHandler(capability: string, handler: BatchHandler): void {`);
+  lines.push(`  batchHandlers.set(capability, handler);`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Batch worker — flushes all queues on interval
+  lines.push(`export function startBatchWorker(intervalMs: number = parseInt(process.env.BATCH_INTERVAL_MS || "5000")): NodeJS.Timeout {`);
+  lines.push(`  logger.info("batch_worker_started", { event: "startup", metadata: { interval_ms: intervalMs } });`);
+  lines.push(`  return setInterval(async () => {`);
+  lines.push(`    for (const [capability, queue] of queues) {`);
+  lines.push(`      if (queue.length === 0) continue;`);
+  lines.push(`      const batch = queue.splice(0, queue.length); // drain queue atomically`);
+  lines.push(`      await flushBatch(capability, batch).catch(e => {`);
+  lines.push(`        logger.error("batch_worker_error", { event: capability, metadata: { error: e.message } });`);
+  lines.push(`      });`);
+  lines.push(`    }`);
+  lines.push(`  }, intervalMs);`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Capability-specific stub handlers
+  for (const { modName, method } of batchMethods) {
+    const key = `${modName}.${method.name}`;
+    lines.push(`// Batch handler for ${key}`);
+    lines.push(`// Register your implementation:`);
+    lines.push(`// registerBatchHandler("${key}", async (payload, client) => { ... });`);
+    lines.push(``);
+  }
+
+  return lines.join("\n");
+}

package/src/emit_capability.ts

@@ -0,0 +1,436 @@
+/**
+ * BoneScript Capability Body Emitter
+ *
+ * Translates IR effects and preconditions into real TypeScript + SQL.
+ */
+
+import * as IR from "./ir";
+
+// ─── Expression Parser ────────────────────────────────────────────────────────
+// Parses the serialized expression strings from the IR back into a structured form.
+
+type ExprKind =
+  | { kind: "literal"; value: string; raw: string }
+  | { kind: "field"; path: string[] }
+  | { kind: "binop"; op: string; left: Expr; right: Expr }
+  | { kind: "call"; name: string; args: Expr[] };
+
+type Expr = ExprKind;
+
+function parseExprStr(s: string): Expr {
+  s = s.trim();
+
+  // Strip outer parens
+  if (s.startsWith("(") && s.endsWith(")")) {
+    return parseExprStr(s.slice(1, -1));
+  }
+
+  // String literal
+  if (s.startsWith('"') && s.endsWith('"')) {
+    return { kind: "literal", value: s.slice(1, -1), raw: s };
+  }
+
+  // Number literal
+  if (/^-?\d+(\.\d+)?$/.test(s)) {
+    return { kind: "literal", value: s, raw: s };
+  }
+
+  // Boolean
+  if (s === "true" || s === "false") {
+    return { kind: "literal", value: s, raw: s };
+  }
+
+  // Binary operators (check in precedence order, right-to-left to handle left-assoc)
+  const binOps = [" or ", " and ", " == ", " != ", " >= ", " <= ", " > ", " < ", " in ", " contains ", " + ", " - ", " * ", " / "];
+  for (const op of binOps) {
+    const idx = findBinOp(s, op);
+    if (idx !== -1) {
+      const left = parseExprStr(s.slice(0, idx));
+      const right = parseExprStr(s.slice(idx + op.length));
+      return { kind: "binop", op: op.trim(), left, right };
+    }
+  }
+
+  // Function call: name(args)
+  const callMatch = s.match(/^(\w+)\((.*)?\)$/);
+  if (callMatch) {
+    const args = callMatch[2] ? splitArgs(callMatch[2]).map(parseExprStr) : [];
+    return { kind: "call", name: callMatch[1], args };
+  }
+
+  // Field reference: a.b.c
+  if (/^[\w.]+$/.test(s)) {
+    return { kind: "field", path: s.split(".") };
+  }
+
+  // Fallback: treat as opaque literal
+  return { kind: "literal", value: s, raw: s };
+}
+
+function findBinOp(s: string, op: string): number {
+  let depth = 0;
+  for (let i = 0; i <= s.length - op.length; i++) {
+    const ch = s[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (depth === 0 && s.slice(i, i + op.length) === op) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function splitArgs(s: string): string[] {
+  const args: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of s) {
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "," && depth === 0) {
+      args.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) args.push(current.trim());
+  return args;
+}
+
+// ─── Entity Resolution ────────────────────────────────────────────────────────
+// Determines which entities need to be fetched from the DB for a capability.
+
+interface EntityFetch {
+  paramName: string;    // capability parameter name (e.g., "item")
+  entityType: string;   // entity type name (e.g., "Item")
+  tableName: string;    // SQL table name (e.g., "items")
+  idField: string;      // request body field for the ID (e.g., "item_id")
+}
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function getEntityFetches(method: IR.IRMethod, mod: IR.IRModule, system: IR.IRSystem): EntityFetch[] {
+  const fetches: EntityFetch[] = [];
+  const seen = new Set<string>();
+
+  // Build a map of all entity names → table names across the whole system
+  const allModels = new Map<string, string>(); // entityName → tableName
+  for (const m of system.modules) {
+    for (const model of m.models) {
+      allModels.set(model.name, toSnakeCase(model.name) + "s");
+      allModels.set(model.name.toLowerCase(), toSnakeCase(model.name) + "s");
+    }
+  }
+
+  for (const param of method.input) {
+    const tableName = allModels.get(param.type) || allModels.get(param.type.toLowerCase());
+    if (tableName && !seen.has(param.name)) {
+      seen.add(param.name);
+      fetches.push({
+        paramName: param.name,
+        entityType: param.type,
+        tableName,
+        idField: param.name + "_id",
+      });
+    }
+  }
+
+  return fetches;
+}
+
+// ─── Precondition Compiler ────────────────────────────────────────────────────
+
+interface CompiledPrecondition {
+  code: string;       // TypeScript guard clause
+  description: string;
+}
+
+function compilePrecondition(expr: Expr, indent: string): string {
+  const condition = exprToTs(expr, true);
+  const description = exprToDescription(expr).replace(/"/g, '\\"');
+  return [
+    `${indent}if (${condition}) {`,
+    `${indent}  return res.status(422).json({ error: { code: "PRECONDITION_FAILED", message: ${JSON.stringify(description)} } });`,
+    `${indent}}`,
+  ].join("\n");
+}
+
+function exprToTs(expr: Expr, negate: boolean = false): string {
+  const inner = exprToTsInner(expr);
+  return negate ? `!(${inner})` : inner;
+}
+
+function exprToTsInner(expr: Expr): string {
+  switch (expr.kind) {
+    case "literal":
+      if (expr.value === "true") return "true";
+      if (expr.value === "false") return "false";
+      if (/^"/.test(expr.raw)) return expr.raw;
+      return expr.value;
+
+    case "field":
+      // Convert field path to JS property access
+      return expr.path.join("?.");
+
+    case "binop": {
+      const l = exprToTsInner(expr.left);
+      const r = exprToTsInner(expr.right);
+      switch (expr.op) {
+        case "==": return `${l} === ${r}`;
+        case "!=": return `${l} !== ${r}`;
+        case "and": return `(${l} && ${r})`;
+        case "or": return `(${l} || ${r})`;
+        case "in": return `[${r}].flat().includes(${l})`;
+        case "contains": return `${l}?.includes(${r})`;
+        case ">": case "<": case ">=": case "<=":
+        case "+": case "-": case "*": case "/":
+          return `${l} ${expr.op} ${r}`;
+        default: return `${l} ${expr.op} ${r}`;
+      }
+    }
+
+    case "call":
+      if (expr.name === "now") return "new Date()";
+      return `${expr.name}(${expr.args.map(exprToTsInner).join(", ")})`;
+  }
+}
+
+function exprToDescription(expr: Expr): string {
+  switch (expr.kind) {
+    case "literal": return expr.raw;
+    case "field": return expr.path.join(".");
+    case "binop": {
+      const l = exprToDescription(expr.left);
+      const r = exprToDescription(expr.right);
+      return `${l} ${expr.op} ${r}`;
+    }
+    case "call": return `${expr.name}(${expr.args.map(exprToDescription).join(", ")})`;
+  }
+}
+
+// ─── Effect Compiler ──────────────────────────────────────────────────────────
+
+interface CompiledEffect {
+  sql: string;
+  params: string[];
+  description: string;
+}
+
+function compileEffect(effect: IR.IREffect, mod: IR.IRModule, system: IR.IRSystem, paramIdx: { n: number }): CompiledEffect | null {
+  const targetParts = effect.target.split(".");
+  if (targetParts.length < 2) return null;
+
+  const entityParam = targetParts[0];   // e.g., "item" or "trade"
+  const fieldName = targetParts[1];     // e.g., "quantity" or "offered_items"
+  const nestedPath = targetParts.slice(2); // e.g., ["owner_id"] for nested JSONB
+
+  // Find the model for this entity param — search across all modules
+  const model = (() => {
+    for (const m of system.modules) {
+      const found = m.models.find(mdl =>
+        toSnakeCase(mdl.name) === entityParam ||
+        mdl.name.toLowerCase() === entityParam.toLowerCase()
+      );
+      if (found) return found;
+    }
+    return mod.models.find(m =>
+      toSnakeCase(m.name) === entityParam ||
+      m.name.toLowerCase() === entityParam.toLowerCase()
+    );
+  })();
+  if (!model) return null;
+
+  const tableName = toSnakeCase(model.name) + "s";
+  const valueExpr = parseExprStr(effect.value);
+  const valueTs = exprToTsInner(valueExpr);
+  const idParam = `req.body.${entityParam}_id || req.params.id`;
+
+  // Detect if the param is a list type (bulk operation)
+  const isBulk = effect.target.includes("[]") ||
+    (entityParam.endsWith("s") && !model.name.toLowerCase().endsWith("s"));
+  const bulkIdParam = `req.body.${entityParam}_ids || req.body.${entityParam}?.map((x: any) => x.id)`;
+  const whereClause = isBulk
+    ? `WHERE id = ANY($2::uuid[])`
+    : `WHERE id = ${`$${2}`}`;
+
+  // Handle nested JSONB path: trade.offered_items.owner_id
+  if (nestedPath.length > 0) {
+    const jsonbField = fieldName;
+    const jsonbPath = nestedPath.join(".");
+    const p1 = `$${paramIdx.n++}`;
+    const p2 = `$${paramIdx.n++}`;
+    // Use jsonb_set to update nested path
+    const jsonbPathLiteral = `'{${nestedPath.join(",")}}'`;
+    return {
+      sql: `UPDATE ${tableName} SET ${jsonbField} = jsonb_set(COALESCE(${jsonbField}, '{}'), ${jsonbPathLiteral}, to_jsonb(${p1}::text), true), updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+      params: [valueTs, idParam],
+      description: `${effect.target} = ${effect.value}`,
+    };
+  }
+
+  switch (effect.op) {
+    case "assign": {
+      const p1 = `$${paramIdx.n++}`;
+      const p2 = `$${paramIdx.n++}`;
+      return {
+        sql: `UPDATE ${tableName} SET ${fieldName} = ${p1}, updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+        params: [valueTs, idParam],
+        description: `${effect.target} = ${effect.value}`,
+      };
+    }
+    case "add": {
+      const p1 = `$${paramIdx.n++}`;
+      const p2 = `$${paramIdx.n++}`;
+      const fieldType = model.fields.find(f => f.name === fieldName)?.type || "";
+      const isNumeric = ["uint", "int", "float"].includes(fieldType);
+      if (isNumeric) {
+        return {
+          sql: `UPDATE ${tableName} SET ${fieldName} = ${fieldName} + ${p1}, updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+          params: [valueTs, idParam],
+          description: `${effect.target} += ${effect.value}`,
+        };
+      } else {
+        return {
+          sql: `UPDATE ${tableName} SET ${fieldName} = ${fieldName} || jsonb_build_array(${p1}::jsonb), updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+          params: [valueTs, idParam],
+          description: `${effect.target} += ${effect.value}`,
+        };
+      }
+    }
+    case "remove": {
+      const p1 = `$${paramIdx.n++}`;
+      const p2 = `$${paramIdx.n++}`;
+      const fieldType = model.fields.find(f => f.name === fieldName)?.type || "";
+      const isNumeric = ["uint", "int", "float"].includes(fieldType);
+      if (isNumeric) {
+        return {
+          sql: `UPDATE ${tableName} SET ${fieldName} = ${fieldName} - ${p1}, updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+          params: [valueTs, idParam],
+          description: `${effect.target} -= ${effect.value}`,
+        };
+      } else {
+        return {
+          sql: `UPDATE ${tableName} SET ${fieldName} = (SELECT jsonb_agg(elem) FROM jsonb_array_elements(${fieldName}) elem WHERE elem != ${p1}::jsonb), updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+          params: [valueTs, idParam],
+          description: `${effect.target} -= ${effect.value}`,
+        };
+      }
+    }
+  }
+}
+
+// ─── Main Capability Body Emitter ─────────────────────────────────────────────
+
+export function emitCapabilityBody(
+  method: IR.IRMethod,
+  mod: IR.IRModule,
+  system: IR.IRSystem,
+  indent: string = "    "
+): string {
+  const lines: string[] = [];
+  const fetches = getEntityFetches(method, mod, system);
+
+  // 0. Destructure primitive params from req.body
+  const primitiveParams = method.input.filter(p => {
+    const isPrimitive = ["string", "uint", "int", "float", "bool", "timestamp", "uuid", "bytes", "json"].includes(p.type);
+    const isListOrSet = p.type.startsWith("list<") || p.type.startsWith("set<");
+    const isEntityFetch = fetches.some(f => f.paramName === p.name);
+    return (isPrimitive || isListOrSet) && !isEntityFetch;
+  });
+
+  if (primitiveParams.length > 0) {
+    const destructured = primitiveParams.map(p => p.name).join(", ");
+    lines.push(`${indent}const { ${destructured} } = req.body;`);
+    lines.push(``);
+  }
+
+  // 1. Fetch entities referenced in preconditions/effects
+  if (fetches.length > 0) {
+    lines.push(`${indent}// Fetch entities`);
+    for (const fetch of fetches) {
+      const idExpr = `req.body.${fetch.idField} || req.params.id`;
+      lines.push(`${indent}const ${fetch.paramName} = await queryOne(\`SELECT * FROM ${fetch.tableName} WHERE id = $1\`, [${idExpr}]);`);
+      lines.push(`${indent}if (!${fetch.paramName}) {`);
+      lines.push(`${indent}  return res.status(404).json({ error: { code: "NOT_FOUND", message: "${fetch.paramName} not found" } });`);
+      lines.push(`${indent}}`);
+    }
+    lines.push(``);
+  }
+
+  // 2. Precondition checks
+  if (method.preconditions.length > 0) {
+    lines.push(`${indent}// Preconditions`);
+    for (const pre of method.preconditions) {
+      try {
+        const expr = parseExprStr(pre.expression);
+        lines.push(compilePrecondition(expr, indent));
+      } catch {
+        // Fallback: emit as comment if parsing fails
+        lines.push(`${indent}// CHECK: ${pre.description}`);
+      }
+    }
+    lines.push(``);
+  }
+
+  // 3. Effects (applied in declaration order, each in its own query)
+  if (method.effects.length > 0) {
+    lines.push(`${indent}// Effects (applied in declaration order)`);
+    const effectResults: string[] = [];
+
+    for (const effect of method.effects) {
+      // Each effect gets its own parameter numbering starting at 1
+      const paramIdx = { n: 1 };
+      const compiled = compileEffect(effect, mod, system, paramIdx);
+      if (compiled) {
+        const resultVar = `__effect_${effectResults.length}`;
+        effectResults.push(resultVar);
+        lines.push(`${indent}const ${resultVar} = await query(\`${compiled.sql}\`, [${compiled.params.join(", ")}]);`);
+        lines.push(`${indent}if (!${resultVar} || ${resultVar}.length === 0) {`);
+        lines.push(`${indent}  throw new Error("Effect failed: ${compiled.description.replace(/"/g, '\\"')}");`);
+        lines.push(`${indent}}`);
+      } else {
+        // Fallback for complex effects we can't compile
+        lines.push(`${indent}// EFFECT: ${effect.target} ${effect.op === "assign" ? "=" : effect.op === "add" ? "+=" : "-="} ${effect.value}`);
+        lines.push(`${indent}// TODO: Implement this effect manually`);
+      }
+    }
+    lines.push(``);
+  }
+
+  // 4. Event emissions
+  if (method.emissions.length > 0) {
+    lines.push(`${indent}// Emit events`);
+    for (const ev of method.emissions) {
+      const payload = buildEventPayload(method, fetches);
+      if (method.sync === "transactional") {
+        lines.push(`${indent}await eventBus.publish("${ev}", ${payload}, "${mod.name}", auth.trace_id, __client);`);
+      } else {
+        lines.push(`${indent}await eventBus.publish("${ev}", ${payload}, "${mod.name}", auth.trace_id);`);
+      }
+    }
+    lines.push(``);
+  }
+
+  // 5. Return result
+  const resultEntity = fetches[0];
+  if (resultEntity) {
+    lines.push(`${indent}res.json({ ok: true, action: "${method.name}", entity: ${resultEntity.paramName} });`);
+  } else {
+    lines.push(`${indent}res.json({ ok: true, action: "${method.name}" });`);
+  }
+
+  return lines.join("\n");
+}
+
+function buildEventPayload(method: IR.IRMethod, fetches: EntityFetch[]): string {
+  const fields: string[] = [];
+  for (const fetch of fetches) {
+    fields.push(`${fetch.paramName}_id: ${fetch.paramName}?.id`);
+  }
+  fields.push(`timestamp: new Date().toISOString()`);
+  fields.push(`actor_id: auth.actor_id`);
+  return `{ ${fields.join(", ")} }`;
+}