bonescript-compiler 0.5.1 → 0.5.3

package/src/emitter.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * BoneScript Code Emitter — Stage 6 of the compilation pipeline.
  * Implements spec/09_CODEGEN.md.
  *
@@ -7,6 +7,10 @@
  */
 
 import * as IR from "./ir";
+import { emitCapabilityBody } from "./emit_capability";
+import { emitPipelineBody, emitAlgorithmBody } from "./emit_composition";
+import { toSnakeCase } from "./lowering_helpers";
+import { toTsType } from "./emit_router";
 
 export interface EmittedFile {
   path: string;
@@ -41,19 +45,6 @@ const SQL_TYPE_MAP: Record<string, string> = {
   json: "JSONB",
 };
 
-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 `Set<${toTsType(setMatch[1])}>`;
-  const mapMatch = irType.match(/^map<(.+),\s*(.+)>$/);
-  if (mapMatch) return `Map<${toTsType(mapMatch[1])}, ${toTsType(mapMatch[2])}>`;
-  const optMatch = irType.match(/^optional<(.+)>$/);
-  if (optMatch) return `${toTsType(optMatch[1])} | null`;
-  // Entity reference or unknown
-  return irType;
-}
 
 function toSqlType(irType: string): string {
   if (SQL_TYPE_MAP[irType]) return SQL_TYPE_MAP[irType];
@@ -68,9 +59,6 @@ function sqlCheckConstraint(irType: string): string {
   return "";
 }
 
-function toSnakeCase(s: string): string {
-  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-}
 
 // ─── Emitter ─────────────────────────────────────────────────────────────────
 
@@ -167,12 +155,6 @@ export class Emitter {
     // Add cardinality CHECK constraints from relations
     // has_one: enforce at most 1 child row via a partial unique index (emitted below)
     // has_many with explicit max: enforce via CHECK on count (done via trigger — see below)
-    for (const rel of (mod as any).relations_with_cardinality || []) {
-      if (rel.cardinality && rel.cardinality.max !== "*" && typeof rel.cardinality.max === "number") {
-        // Will be enforced via trigger — placeholder comment
-        fieldLines.push(`  -- cardinality: ${rel.name} max ${rel.cardinality.max} (enforced by trigger)`);
-      }
-    }
 
     lines.push(fieldLines.join(",\n"));
     lines.push(`);`);
@@ -462,8 +444,6 @@ export class Emitter {
 
     // Real implementation — delegate to emitCapabilityBody for capabilities,
     // or generate CRUD SQL for standard methods
-    const { emitCapabilityBody } = require("./emit_capability");
-    const { emitPipelineBody, emitAlgorithmBody } = require("./emit_composition");
 
     if (method.pipeline) {
       lines.push(emitPipelineBody(method, "    "));
@@ -473,10 +453,14 @@ export class Emitter {
       // Capability with effects/preconditions — use the full capability body emitter
       try {
         lines.push(emitCapabilityBody(method, mod, system, "    "));
-      } catch {
-        // Fallback: emit a descriptive stub if body generation fails
+      } catch (err: unknown) {
+        // Body generation failed — emit a visible compile-time warning in the generated
+        // file so the developer knows this method needs attention, rather than silently
+        // producing a broken stub.
+        const msg = err instanceof Error ? err.message : String(err);
+        lines.push(`    // ⚠ COMPILER WARNING: emitCapabilityBody failed for '${method.name}': ${msg.replace(/`/g, "'")}`);
         lines.push(`    // Effects: ${method.effects.map((e: any) => e.target + " " + e.op + " " + e.value).join("; ")}`);
-        lines.push(`    return { ok: false, error: { code: "NOT_IMPLEMENTED", message: "${method.name} not yet implemented" } };`);
+        lines.push(`    return { ok: false, error: { code: "CODEGEN_FAILED", message: "Body generation failed for '${method.name}': " + ${JSON.stringify(msg)} } };`);
       }
     } else {
       // CRUD or simple method — emit a typed not-implemented stub

package/src/extension_manager.ts

@@ -19,6 +19,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as AST from "./ast";
+import { toTsType } from "./emit_router";
 
 // ─── Sentinel Helpers ────────────────────────────────────────────────────────
 
@@ -36,19 +37,6 @@ export function isStubImplementation(code: string): boolean {
 
 // ─── Stub Generator ──────────────────────────────────────────────────────────
 
-function toTsType(irType: string): string {
-  const map: Record<string, string> = {
-    string: "string", uint: "number", int: "number", float: "number",
-    bool: "boolean", timestamp: "Date", uuid: "string", bytes: "Buffer", json: "unknown",
-  };
-  if (map[irType]) return 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;
-}
-
 function serializeType(t: AST.TypeExprNode): string {
   switch (t.kind) {
     case "PrimitiveType": return t.name;

package/src/lowering.ts

@@ -11,7 +11,7 @@
 import * as AST from "./ast";
 import * as IR from "./ir";
 import { makeId, serializeExpr, serializeType } from "./lowering_helpers";
-import { lowerEntity } from "./lowering_entities";
+import { lowerEntity, lowerCapability } from "./lowering_entities";
 import { lowerStore, lowerChannel, lowerEvent, lowerFlow } from "./lowering_channels";
 
 export class Lowering {
@@ -53,6 +53,32 @@ export class Lowering {
       modules.push(lowerEntity(this.systemName, entity, relatedCaps, stores));
     }
 
+    // Standalone capabilities (no entity params) → utility api_service module
+    // These include algorithm capabilities, pure-function capabilities, etc.
+    const attachedCaps = new Set(
+      entities.flatMap(entity =>
+        capabilities.filter(c =>
+          c.params.some(p => p.type.kind === "EntityRefType" && p.type.name === entity.name)
+        )
+      )
+    );
+    const standaloneCaps = capabilities.filter(c => !attachedCaps.has(c));
+    if (standaloneCaps.length > 0) {
+      const utilMethods = standaloneCaps.map(cap => lowerCapability(cap));
+      modules.push({
+        id: makeId(this.systemName, "api_service", "UtilityService"),
+        kind: "api_service",
+        name: "UtilityService",
+        interfaces: [{ name: "IUtilityService", methods: utilMethods }],
+        models: [],
+        events: [],
+        state_machines: [],
+        relations: [],
+        dependencies: [],
+        config: { authenticated: false, auth_method: "none" },
+      });
+    }
+
     // Channels → realtime_service modules
     for (const channel of channels) {
       modules.push(lowerChannel(this.systemName, channel));

package/src/optimizer.ts

@@ -50,14 +50,17 @@ export function optimize(system: IR.IRSystem): OptimizationResult {
 function deadModuleElimination(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
   const reachable = new Set<string>();
 
-  // Seed: always-reachable kinds
+  // Seed: entry-point kinds that are always reachable by definition.
+  // worker_service, event_bus, and cache are infrastructure modules that are
+  // only reachable if something depends on them — they are NOT seeded here so
+  // that truly orphaned infrastructure modules can be eliminated.
   for (const m of s.modules) {
-    if (["gateway", "frontend", "auth_service", "api_service", "realtime_service", "data_store", "event_bus", "cache"].includes(m.kind)) {
+    if (["gateway", "frontend", "auth_service", "api_service", "realtime_service", "data_store"].includes(m.kind)) {
       reachable.add(m.id);
     }
   }
 
-  // Propagate reachability
+  // Propagate reachability through the dependency graph
   let changed = true;
   while (changed) {
     changed = false;

package/src/solver.ts

@@ -59,7 +59,7 @@ const DOMAIN_DEFAULTS: Record<string, DomainDefaults> = {
   },
   iot_system: {
     auth: "apikey",
-    engine: "dynamodb",
+    engine: "postgresql", // dynamodb is not yet supported by the emitter (T014); use postgresql
     session_engine: "redis",
     sync: "eventual",
     channel_transport: "grpc_stream",

package/src/typechecker.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * BoneScript Type Checker — Stage 3 of the compilation pipeline.
  * Implements spec/04_TYPE_SYSTEM.md.
  *
@@ -180,6 +180,7 @@ export class TypeChecker {
       case "ExtensionPointDecl": this.checkExtensionPoint(decl); break;
       case "StoreDecl": this.checkStore(decl); break;
       case "PolicyDecl": this.checkPolicy(decl); break;
+      case "EventDecl": this.checkEvent(decl); break;
     }
   }
 
@@ -524,8 +525,22 @@ export class TypeChecker {
     if (condType && !this.isBoolish(condType)) {
       this.addError("T005", "Ternary condition must be bool", expr.loc);
     }
-    // result type is type of consequent (assume both branches same type)
-    return this.inferExprType(expr.consequent, ctx);
+    // Both branches must have compatible types
+    const consequentType = this.inferExprType(expr.consequent, ctx);
+    const alternateType  = this.inferExprType(expr.alternate, ctx);
+    if (
+      consequentType && alternateType &&
+      !typeEquals(consequentType, alternateType) &&
+      !this.isAssignable(consequentType, alternateType) &&
+      !this.isAssignable(alternateType, consequentType)
+    ) {
+      this.addError(
+        "T017",
+        `Ternary branches have incompatible types: consequent is ${typeToString(consequentType)}, alternate is ${typeToString(alternateType)}`,
+        expr.loc,
+      );
+    }
+    return consequentType;
   }
 
   // ─── Helpers ───────────────────────────────────────────────────────────────
@@ -635,10 +650,38 @@ export class TypeChecker {
     }
   }
 
+  // ─── Event Checking ───────────────────────────────────────────────────────────
 
-}
+  private static readonly VALID_DELIVERY_MODES = new Set(["at_least_once", "at_most_once", "exactly_once"]);
+
+  private checkEvent(decl: AST.EventDeclNode): void {
+    // Check payload field types resolve and have no duplicates
+    const seen = new Set<string>();
+    for (const field of decl.payload) {
+      if (seen.has(field.name)) {
+        this.addError("T009", `Duplicate field name '${field.name}' in event '${decl.name}'`, field.loc);
+      }
+      seen.add(field.name);
+
+      const resolved = this.resolveTypeExpr(field.type);
+      if (!resolved) {
+        this.addError("T001", `Event '${decl.name}' payload field '${field.name}' references undefined type`, field.loc);
+      }
+    }
+
+    // Check delivery mode is valid
+    if (decl.delivery && !TypeChecker.VALID_DELIVERY_MODES.has(decl.delivery)) {
+      this.addError(
+        "T016",
+        `Event '${decl.name}' has invalid delivery mode '${decl.delivery}'. ` +
+        `Valid values: ${[...TypeChecker.VALID_DELIVERY_MODES].join(", ")}.`,
+        decl.loc,
+      );
+    }
+  }
 // ─── Type Context ────────────────────────────────────────────────────────────
 
+}
 class TypeContext {
   private locals: Map<string, CVType>;
   private symbols: SymbolTable;

package/src/verifier.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * BoneScript Verifier — Stage 7 of the compilation pipeline.
  * Implements spec/07_IR_SPEC.md §5 (IR Validation Rules).
  *
@@ -197,7 +197,7 @@ export class Verifier {
     const visited = new Set<string>();
     const inStack = new Set<string>();
 
-    const dfs = (node: string, path: string[]): boolean => {
+    const dfs = (node: string, path: string[]): void => {
       if (inStack.has(node)) {
         const cycle = [...path.slice(path.indexOf(node)), node];
         const names = cycle.map(id => system.modules.find(m => m.id === id)?.name || id);
@@ -207,9 +207,9 @@ export class Verifier {
           message: `Circular dependency: ${names.join(" → ")}`,
           location: node,
         });
-        return true;
+        return;
       }
-      if (visited.has(node)) return false;
+      if (visited.has(node)) return;
 
       visited.add(node);
       inStack.add(node);
@@ -221,7 +221,6 @@ export class Verifier {
       }
 
       inStack.delete(node);
-      return false;
     };
 
     for (const [id] of graph) {