bonescript-compiler 0.3.0 → 0.5.0

package/src/emit_capability.ts

@@ -191,6 +191,7 @@ function compileEffect(
   mod: IR.IRModule,
   system: IR.IRSystem,
   paramIdx: { n: number },
+  method?: IR.IRMethod,
 ): CompiledEffect | null {
   const targetParts = effect.target.split(".");
   if (targetParts.length < 2) return null;
@@ -199,7 +200,20 @@ function compileEffect(
   const fieldName   = targetParts[1];
   const nestedPath  = targetParts.slice(2);
 
+  // Resolve the model: first try matching by param name → entity type via method inputs,
+  // then fall back to matching by entity name directly.
   const model = (() => {
+    // If we have method context, resolve the param name to its entity type
+    if (method) {
+      const param = method.input.find(p => p.name === entityParam);
+      if (param) {
+        for (const m of system.modules) {
+          const found = m.models.find(mdl => mdl.name === param.type || mdl.name.toLowerCase() === param.type.toLowerCase());
+          if (found) return found;
+        }
+      }
+    }
+    // Fall back to matching by entity name directly
     for (const m of system.modules) {
       const found = m.models.find(mdl =>
         toSnakeCase(mdl.name) === entityParam || mdl.name.toLowerCase() === entityParam.toLowerCase()
@@ -221,12 +235,15 @@ function compileEffect(
     const p1 = `$${paramIdx.n++}`;
     const p2 = `$${paramIdx.n++}`;
     const jsonbPathLiteral = `'{${nestedPath.join(",")}}'`;
+    // Use to_jsonb($1) directly — casting via ::text loses type information for
+    // non-string values (numbers, booleans, objects). to_jsonb() handles all
+    // PostgreSQL types correctly without an intermediate text cast.
     return {
       tableName, entityParam, idParam,
       assignments: [],
       description: `${effect.target} = ${effect.value}`,
       standalone: {
-        sql: `UPDATE ${tableName} SET ${fieldName} = jsonb_set(COALESCE(${fieldName}, '{}'), ${jsonbPathLiteral}, to_jsonb(${p1}::text), true), updated_at = NOW() WHERE id = ${p2} RETURNING *`,
+        sql: `UPDATE ${tableName} SET ${fieldName} = jsonb_set(COALESCE(${fieldName}, '{}'), ${jsonbPathLiteral}, to_jsonb(${p1}), true), updated_at = NOW() WHERE id = ${p2} RETURNING *`,
         params: [valueTs, idParam],
       },
     };
@@ -490,7 +507,7 @@ export function emitCapabilityBody(
     lines.push(`${indent}// Effects (batched by entity to minimise round-trips)`);
 
     const paramIdx = { n: 1 };
-    const compiled = method.effects.map(e => compileEffect(e, mod, system, paramIdx));
+    const compiled = method.effects.map(e => compileEffect(e, mod, system, paramIdx, method));
     const { batches, standalones } = batchEffects(compiled);
 
     // Emit batched UPDATEs
@@ -518,12 +535,50 @@ export function emitCapabilityBody(
       lines.push(`${indent}}`);
     }
 
-    // Fallback for effects that couldn't be compiled
+    // Fallback for effects that couldn't be compiled.
+    // Collection-level effects (e.g. list<T>.field = value) are not yet supported
+    // by the batch compiler — emit a clear TODO rather than silently dropping them.
+    // Effects that reference a completely unknown model are a hard error.
     for (const effect of method.effects) {
       const paramIdx2 = { n: 1 };
-      if (!compileEffect(effect, mod, system, paramIdx2)) {
-        lines.push(`${indent}// EFFECT: ${effect.target} ${effect.op === "assign" ? "=" : effect.op === "add" ? "+=" : "-="} ${effect.value}`);
-        lines.push(`${indent}// TODO: Implement this effect manually`);
+      if (!compileEffect(effect, mod, system, paramIdx2, method)) {
+        const targetParts = effect.target.split(".");
+        const paramName = targetParts[0];
+        const param = method.input.find(p => p.name === paramName);
+        const isCollectionEffect = param && (param.type.startsWith("list<") || param.type.startsWith("set<"));
+
+        if (isCollectionEffect) {
+          // Collection-level effects: apply the field update to all items in the collection
+          // using a single batched UPDATE ... WHERE id = ANY($ids::uuid[])
+          const innerType = param.type.replace(/^(list|set)<(.+)>$/, "$2");
+          // Find the model for the inner element type
+          let elemModel: IR.IRModel | undefined;
+          for (const m of system.modules) {
+            elemModel = m.models.find(mdl => mdl.name === innerType || mdl.name.toLowerCase() === innerType.toLowerCase());
+            if (elemModel) break;
+          }
+          const tableName = elemModel ? (elemModel.name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase() + "s") : (innerType.toLowerCase() + "s");
+          const fieldName = targetParts[1];
+          const valueTs = targetParts[1] ? effect.value : "null";
+          const opSql = effect.op === "add"
+            ? `${fieldName} = ${fieldName} + $1`
+            : effect.op === "remove"
+              ? `${fieldName} = ${fieldName} - $1`
+              : `${fieldName} = $1`;
+          lines.push(`${indent}// Collection effect: ${effect.target} ${effect.op === "assign" ? "=" : effect.op === "add" ? "+=" : "-="} ${effect.value}`);
+          lines.push(`${indent}if (${paramName} && ${paramName}.length > 0) {`);
+          lines.push(`${indent}  const __ids_${paramName} = ${paramName}.map((x: any) => x.id ?? x);`);
+          lines.push(`${indent}  await query(`);
+          lines.push(`${indent}    \`UPDATE ${tableName} SET ${opSql}, updated_at = NOW() WHERE id = ANY($2::uuid[])\`,`);
+          lines.push(`${indent}    [${effect.value}, __ids_${paramName}],`);
+          lines.push(`${indent}  );`);
+          lines.push(`${indent}}`);
+        } else {
+          throw new Error(
+            `Unsupported effect in method '${method.name}': target '${effect.target}' could not be resolved to a known model field. ` +
+            `Ensure the effect target matches a declared entity field (e.g. 'entityName.fieldName').`
+          );
+        }
       }
     }
     lines.push(``);

package/src/emit_composition.ts

@@ -57,7 +57,30 @@ export function emitPipelineBody(method: IR.IRMethod, indent: string = "    "):
     } else if (p.on_error.action === "ignore") {
       lines.push(`${indent}  // on_error: ignore — log only`);
     } else if (p.on_error.action === "retry") {
-      lines.push(`${indent}  // on_error: retry not yet supported in inline emission`);
+      // on_error: retry — re-run the entire pipeline with exponential backoff.
+      // Wraps the pipeline steps in a retry loop. The outer try/catch feeds __err here.
+      lines.push(`${indent}  // on_error: retry with exponential backoff`);
+      lines.push(`${indent}  const __maxAttempts = ${method.retry?.max_attempts ?? 3};`);
+      lines.push(`${indent}  const __backoffMs = ${method.retry?.interval_ms ?? 1000};`);
+      lines.push(`${indent}  let __lastErr = __err;`);
+      lines.push(`${indent}  for (let __attempt = 1; __attempt <= __maxAttempts; __attempt++) {`);
+      lines.push(`${indent}    await new Promise(r => setTimeout(r, __backoffMs * Math.pow(2, __attempt - 1)));`);
+      lines.push(`${indent}    try {`);
+      // Re-emit all pipeline steps inside the retry loop
+      for (const step of p.steps) {
+        const callExpr = generateStepCall(step);
+        if (step.bind_as) {
+          lines.push(`${indent}      __pipeline_results["${step.bind_as}"] = await ${callExpr};`);
+        } else {
+          lines.push(`${indent}      await ${callExpr};`);
+        }
+      }
+      lines.push(`${indent}      return { ok: true, value: __pipeline_results } as any; // retry succeeded`);
+      lines.push(`${indent}    } catch (__retryErr: any) {`);
+      lines.push(`${indent}      __lastErr = __retryErr;`);
+      lines.push(`${indent}    }`);
+      lines.push(`${indent}  }`);
+      lines.push(`${indent}  return { ok: false, error: { code: "PIPELINE_RETRY_EXHAUSTED", message: __lastErr.message, attempts: __maxAttempts } } as any;`);
     }
   } else {
     // Default: rollback on error
@@ -100,9 +123,19 @@ function emitParallelPipeline(method: IR.IRMethod, indent: string): string {
 }
 
 function generateStepCall(step: IR.IRPipelineStep): string {
-  // Replace any args that reference previous bindings with __pipeline_results
+  // Substitute any arg that references a previous step's bind_as result
+  // e.g. if a prior step bound its result as "payment", an arg of "payment"
+  // becomes __pipeline_results["payment"]
   const args = step.call_args.map(arg => {
-    // If arg looks like an identifier path, check if it might be a binding ref
+    // Simple identifier that looks like a binding reference
+    if (/^\w+$/.test(arg.trim())) {
+      return `(__pipeline_results["${arg.trim()}"] ?? ${arg.trim()})`;
+    }
+    // Dotted path like "payment.id" — resolve the root from pipeline results
+    const dotMatch = arg.trim().match(/^(\w+)(\..+)$/);
+    if (dotMatch) {
+      return `(__pipeline_results["${dotMatch[1]}"] as any)${dotMatch[2]} ?? undefined`;
+    }
     return arg;
   });
   return `${step.call_name}(${args.join(", ")})`;

package/src/emit_events.ts

@@ -305,3 +305,73 @@ export const eventBus = {
 };
 `;
 }
+
+// ─── Typed Event Publishers ───────────────────────────────────────────────────
+// Generates per-event emitXxx() typed publisher functions as specified in
+// spec/09_CODEGEN.md §5.4. These wrap eventBus.publish with a typed payload
+// interface so callers get compile-time safety instead of raw Record<string,unknown>.
+
+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",
+};
+
+function toTsType(irType: string): string {
+  if (TS_TYPE_MAP[irType]) return TS_TYPE_MAP[irType];
+  const listMatch = irType.match(/^list<(.+)>$/);
+  if (listMatch) return `${toTsType(listMatch[1])}[]`;
+  const setMatch = irType.match(/^set<(.+)>$/);
+  if (setMatch) return `${toTsType(setMatch[1])}[]`;
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return `${toTsType(optMatch[1])} | null`;
+  return irType;
+}
+
+export function emitTypedEventPublishers(system: IR.IRSystem): string {
+  if (system.events.length === 0) return "";
+
+  const lines: string[] = [];
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`// Typed event publisher functions — one per declared event.`);
+  lines.push(`// Import these instead of calling eventBus.publish() directly.`);
+  lines.push(``);
+  lines.push(`import { eventBus } from "./events";`);
+  lines.push(`import type { PoolClient } from "pg";`);
+  lines.push(``);
+
+  for (const ev of system.events) {
+    const ifaceName = `${ev.name}Payload`;
+
+    // Payload interface
+    lines.push(`export interface ${ifaceName} {`);
+    for (const field of ev.payload) {
+      const nullable = field.nullable ? " | null" : "";
+      lines.push(`  ${field.name}: ${toTsType(field.type)}${nullable};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+
+    // Publisher function
+    const sourceId = ev.source && ev.source !== "unknown" ? ev.source : system.name;
+    lines.push(`/**`);
+    lines.push(` * Publish a ${ev.name} event.`);
+    lines.push(` * Delivery: ${ev.delivery}${ev.ttl_ms ? ` | TTL: ${ev.ttl_ms}ms` : ""}`);
+    lines.push(` */`);
+    lines.push(`export async function emit${ev.name}(`);
+    lines.push(`  payload: ${ifaceName},`);
+    lines.push(`  correlationId?: string,`);
+    lines.push(`  client?: PoolClient,`);
+    lines.push(`): Promise<void> {`);
+    lines.push(`  await eventBus.publish(`);
+    lines.push(`    "${ev.name}",`);
+    lines.push(`    payload as unknown as Record<string, unknown>,`);
+    lines.push(`    "${sourceId}",`);
+    lines.push(`    correlationId,`);
+    lines.push(`    client,`);
+    lines.push(`  );`);
+    lines.push(`}`);
+    lines.push(``);
+  }
+
+  return lines.join("\n");
+}

package/src/emit_full.ts

@@ -23,20 +23,38 @@ import {
   emitFailureRules,
   emitMigrationDiff,
 } from "./emit_maintenance";
-import { emitFlowRuntime } from "./emit_extras";
+import { emitFlowRuntime, emitChannelFilters } from "./emit_extras";
 import { emitAlgorithmsFile, collectUsedAlgorithms } from "./emit_composition";
 import { emitExtensionPointStub } from "./extension_manager";
 import * as AST from "./ast";
-import { emitDurableEventBus, emitOutboxSchema } from "./emit_events";
+import { emitDurableEventBus, emitOutboxSchema, emitTypedEventPublishers } from "./emit_events";
 import { emitBatchExecutor } from "./emit_batch";
 import { emitSourceMapFile, emitDebugHandler } from "./emit_sourcemap";
 import { emitTestSuite } from "./emit_tests";
 import { emitDockerfile, emitDockerignore, emitK8sDeployment, emitGithubActions } from "./emit_deploy";
+import { emitModelFile, emitModelsIndex } from "./emit_models";
+import { emitOpenApiSchema } from "./emit_openapi";
 
 function toSnakeCase(s: string): string {
   return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
 }
 
+/** Resolve the auth method for the system from the resolution map or module configs. */
+function resolveSystemAuthMethod(system: IR.IRSystem): "jwt" | "oauth2" | "apikey" {
+  const direct = system.resolution["implied.auth_method"] || system.resolution["system.auth_method"];
+  if (direct === "oauth2" || direct === "apikey" || direct === "jwt") return direct as "jwt" | "oauth2" | "apikey";
+  for (const [key, val] of Object.entries(system.resolution)) {
+    if (key.endsWith(".auth_method") && (val === "oauth2" || val === "apikey" || val === "jwt")) {
+      return val as "jwt" | "oauth2" | "apikey";
+    }
+  }
+  for (const mod of system.modules) {
+    const m = mod.config["auth_method"] as string | undefined;
+    if (m === "oauth2" || m === "apikey" || m === "jwt") return m;
+  }
+  return "jwt";
+}
+
 export class FullEmitter {
   private schemaEmitter = new Emitter();
 
@@ -54,6 +72,37 @@ export class FullEmitter {
     files.push({ path: "src/events.ts", content: emitDurableEventBus(system), language: "typescript", source_module: "infra" });
     // Outbox SQL schema
     files.push({ path: "migrations/event_outbox.sql", content: emitOutboxSchema(), language: "sql", source_module: "infra" });
+
+    // API key table migration (only when auth_method = apikey)
+    const authMethod = resolveSystemAuthMethod(system);
+    if (authMethod === "apikey") {
+      files.push({
+        path: "migrations/api_keys.sql",
+        content: [
+          "-- Generated by BoneScript compiler. DO NOT EDIT.",
+          "-- API key table for apikey auth strategy.",
+          "",
+          "CREATE TABLE IF NOT EXISTS api_keys (",
+          "  id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),",
+          "  actor_id   UUID NOT NULL,",
+          "  key_hash   VARCHAR(64) NOT NULL UNIQUE,",
+          "  key_prefix VARCHAR(16) NOT NULL,",
+          "  name       VARCHAR(255) NOT NULL DEFAULT 'default',",
+          "  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),",
+          "  expires_at TIMESTAMPTZ NOT NULL,",
+          "  revoked    BOOLEAN NOT NULL DEFAULT false",
+          ");",
+          "CREATE INDEX IF NOT EXISTS idx_api_keys_actor ON api_keys (actor_id);",
+          "CREATE INDEX IF NOT EXISTS idx_api_keys_hash  ON api_keys (key_hash);",
+        ].join("\n"),
+        language: "sql",
+        source_module: "infra",
+      });
+    }
+    // Typed event publisher functions (one per declared event)
+    if (system.events.length > 0) {
+      files.push({ path: "src/publishers.ts", content: emitTypedEventPublishers(system), language: "typescript", source_module: "infra" });
+    }
     files.push({ path: "src/auth.ts", content: emitAuthMiddleware(system), language: "typescript", source_module: "infra" });
     files.push({ path: "src/logger.ts", content: emitLogger(system), language: "typescript", source_module: "infra" });
     files.push({ path: "src/metrics.ts", content: emitMetrics(), language: "typescript", source_module: "infra" });
@@ -105,17 +154,24 @@ export class FullEmitter {
         "",
       ];
       for (const ep of system.extension_points) {
-        const params = ep.params.map((p: { name: string; type: string }) => `${p.name}: ${p.type}`).join(", ");
-        const returnType = ep.returns || "void";
-        extLines.push(`/**`);
-        extLines.push(` * Extension point: ${ep.name}`);
-        extLines.push(` * ${ep.stable ? "STABLE: implementation required." : "Optional."}`);
-        extLines.push(` */`);
-        extLines.push(`export function ${ep.name}(${params}): ${returnType} {`);
-        extLines.push(`  // <bonescript:ext:${ep.name}:begin>`);
-        extLines.push(`  throw new Error("Not implemented: ${ep.name}");`);
-        extLines.push(`  // <bonescript:ext:${ep.name}:end>`);
-        extLines.push(`}`);
+        // Use the shared emitExtensionPointStub so the format is consistent
+        // with what extension_manager.ts expects when merging on recompile.
+        const stub = emitExtensionPointStub({
+          kind: "ExtensionPointDecl",
+          loc: { line: 0, column: 0, offset: 0 },
+          name: ep.name,
+          params: ep.params.map(p => ({
+            kind: "Param" as const,
+            loc: { line: 0, column: 0, offset: 0 },
+            name: p.name,
+            type: { kind: "PrimitiveType" as const, loc: { line: 0, column: 0, offset: 0 }, name: p.type },
+          })),
+          returns: ep.returns
+            ? { kind: "PrimitiveType" as const, loc: { line: 0, column: 0, offset: 0 }, name: ep.returns }
+            : null,
+          stable: ep.stable,
+        });
+        extLines.push(stub);
         extLines.push("");
       }
       files.push({
@@ -138,6 +194,79 @@ export class FullEmitter {
       }
     }
 
+    // 3a. Derived field helpers (one file per entity that has derived fields)
+    for (const mod of system.modules) {
+      for (const model of mod.models) {
+        const derivedFields = model.fields.filter(f =>
+          f.default_value && f.default_value.startsWith("GENERATED ALWAYS AS")
+        );
+        if (derivedFields.length === 0) continue;
+        const lines: string[] = [
+          `// Generated by BoneScript compiler. DO NOT EDIT.`,
+          `// Derived field helpers for ${model.name}.`,
+          `// These mirror the GENERATED ALWAYS AS columns in the SQL migration.`,
+          `// Use them when you need the computed value in application code before a DB round-trip.`,
+          ``,
+          `export type ${model.name}Derived = {`,
+        ];
+        for (const f of derivedFields) {
+          lines.push(`  ${f.name}: unknown;`);
+        }
+        lines.push(`};`);
+        lines.push(``);
+        lines.push(`export const ${model.name.toUpperCase()}_DERIVED_FIELDS = [${derivedFields.map(f => `"${f.name}"`).join(", ")}] as const;`);
+        lines.push(``);
+        lines.push(`/** Returns true if the field name is a derived (computed) field on ${model.name}. */`);
+        lines.push(`export function is${model.name}DerivedField(field: string): boolean {`);
+        lines.push(`  return (${model.name.toUpperCase()}_DERIVED_FIELDS as readonly string[]).includes(field);`);
+        lines.push(`}`);
+        files.push({
+          path: `src/derived/${toSnakeCase(model.name)}.ts`,
+          content: lines.join("\n"),
+          language: "typescript",
+          source_module: mod.id,
+        });
+      }
+    }
+
+    // 3b. Channel filter predicates (only if any channel has a filter expression)
+    const realtimeMods = system.modules.filter(m => m.kind === "realtime_service" && m.config["filter"]);
+    if (realtimeMods.length > 0) {
+      const filterLines: string[] = [
+        `// Generated by BoneScript compiler. DO NOT EDIT.`,
+        `// Channel filter predicates — applied before delivering messages to participants.`,
+        ``,
+        `export const CHANNEL_FILTERS: Record<string, (event: any, participant: any) => boolean> = {`,
+      ];
+      for (const mod of realtimeMods) {
+        const filterExpr = String(mod.config["filter"] || "true");
+        // Translate bone field refs to JS: event.field and participant.field pass through,
+        // bare identifiers are assumed to be event properties.
+        const jsFilter = filterExpr
+          .replace(/\band\b/g, "&&")
+          .replace(/\bor\b/g, "||")
+          .replace(/\bnot\b/g, "!")
+          .replace(/\b==\b/g, "===")
+          .replace(/\b!=\b/g, "!==")
+          .replace(/\bcontains\b/g, "?.includes");
+        filterLines.push(`  "${mod.name}": (event, participant) => {`);
+        filterLines.push(`    try { return Boolean(${jsFilter}); } catch { return true; }`);
+        filterLines.push(`  },`);
+      }
+      filterLines.push(`};`);
+      filterLines.push(``);
+      filterLines.push(`export function shouldDeliver(channel: string, event: any, participant: any): boolean {`);
+      filterLines.push(`  const filter = CHANNEL_FILTERS[channel];`);
+      filterLines.push(`  return filter ? filter(event, participant) : true;`);
+      filterLines.push(`}`);
+      files.push({
+        path: "src/channel_filters.ts",
+        content: filterLines.join("\n"),
+        language: "typescript",
+        source_module: "infra",
+      });
+    }
+
     // 4. Source: route files (CRUD + capabilities)
     for (const mod of system.modules) {
       if (mod.kind === "api_service" && mod.models.length > 0) {
@@ -156,7 +285,31 @@ export class FullEmitter {
     // 5. Source: main entry point
     files.push({ path: "src/index.ts", content: emitIndex(system), language: "typescript", source_module: "root" });
 
+    // 5a. Model interfaces, schemas, and validators (one file per model)
+    const modelFiles: string[] = [];
+    for (const mod of system.modules) {
+      for (const model of mod.models) {
+        const modelPath = `src/models/${toSnakeCase(model.name)}.ts`;
+        files.push({
+          path: modelPath,
+          content: emitModelFile(model, mod, system),
+          language: "typescript",
+          source_module: mod.id,
+        });
+        modelFiles.push(modelPath);
+      }
+    }
+    if (modelFiles.length > 0) {
+      files.push({
+        path: "src/models/index.ts",
+        content: emitModelsIndex(system),
+        language: "typescript",
+        source_module: "shared",
+      });
+    }
+
     // 6. SQL migrations — run schema emitter ONCE, then match by model name
+    // Includes both api_service entities AND data_store schemas.
     const schemas: string[] = [];
     const allSchemaFiles = this.schemaEmitter.emit(system);
     for (const mod of system.modules) {
@@ -180,6 +333,12 @@ export class FullEmitter {
     // 9. README
     files.push({ path: "README.md", content: this.emitReadme(system), language: "yaml", source_module: "root" });
 
+    // 9a. OpenAPI schema (spec/09_CODEGEN.md §2 — ApiService secondary target)
+    const openApiContent = emitOpenApiSchema(system);
+    if (openApiContent) {
+      files.push({ path: "openapi.json", content: openApiContent, language: "json", source_module: "root" });
+    }
+
     // 10. Source map + debug handler
     files.push({ path: `${system.name}.bone.map`, content: emitSourceMapFile(system, `${system.name}.bone`), language: "json", source_module: "root" });
     files.push({ path: "src/debug.ts", content: emitDebugHandler(system), language: "typescript", source_module: "infra" });