bonescript-compiler 0.2.1 → 0.4.0

package/src/lowering_channels.ts

@@ -0,0 +1,107 @@
+/**
+ * BoneScript Channel / Event / Flow / Store Lowering
+ * Converts ChannelDecl, EventDecl, FlowDecl, and StoreDecl AST nodes into IR.
+ */
+
+import * as AST from "./ast";
+import * as IR from "./ir";
+import { makeId, parseDurationMs, serializeExpr } from "./lowering_helpers";
+import { lowerField as lowerFieldHelper } from "./lowering_entities";
+
+// Re-export lowerField so lowering.ts can use a single import
+export { lowerField } from "./lowering_entities";
+
+// ─── Store Lowering ───────────────────────────────────────────────────────────
+
+export function lowerStore(systemName: string, store: AST.StoreDeclNode): IR.IRModule {
+  const entityName = store.name.replace(/Store$/, "") || store.name;
+  const model: IR.IRModel = {
+    name: entityName,
+    fields: store.schema.map(lowerFieldHelper),
+    primary_key: "id",
+    indexes: [],
+    constraints: [],
+  };
+
+  if (!model.fields.find(f => f.name === "id")) {
+    model.fields.unshift({
+      name: "id", type: "uuid", nullable: false, unique: true, indexed: true, default_value: "gen_random_uuid()",
+    });
+  }
+
+  return {
+    id: makeId(systemName, "data_store", store.name),
+    kind: "data_store",
+    name: store.name,
+    interfaces: [],
+    models: [model],
+    events: [],
+    state_machines: [],
+    relations: [],
+    dependencies: [],
+    config: {
+      engine: store.engine || "postgresql",
+      replicas: store.replicas || 1,
+      ...(store.retention ? { retention_ms: parseDurationMs(store.retention) || 0 } : {}),
+      ...(store.partition ? { partition_key: store.partition } : {}),
+    },
+  };
+}
+
+// ─── Channel Lowering ─────────────────────────────────────────────────────────
+
+export function lowerChannel(systemName: string, channel: AST.ChannelDeclNode): IR.IRModule {
+  return {
+    id: makeId(systemName, "realtime_service", channel.name),
+    kind: "realtime_service",
+    name: channel.name,
+    interfaces: [{
+      name: `I${channel.name}Channel`,
+      methods: [
+        { name: "connect",   input: [], output: "connection",   preconditions: [], effects: [], emissions: [], idempotent: false, authenticated: true, timeout_ms: 5000, retry: null, pipeline: null, algorithm: null, sync: null },
+        { name: "subscribe", input: [{ name: "topic", type: "string", nullable: false, unique: false, indexed: false, default_value: null }], output: "subscription", preconditions: [], effects: [], emissions: [], idempotent: true, authenticated: true, timeout_ms: 5000, retry: null, pipeline: null, algorithm: null, sync: null },
+        { name: "publish",   input: [{ name: "message", type: "json", nullable: false, unique: false, indexed: false, default_value: null }], output: "void", preconditions: [], effects: [], emissions: [], idempotent: false, authenticated: true, timeout_ms: 5000, retry: null, pipeline: null, algorithm: null, sync: null },
+      ],
+    }],
+    models: [],
+    events: [],
+    state_machines: [],
+    relations: [],
+    dependencies: [],
+    config: {
+      transport:   channel.transport   || "websocket",
+      ordering:    channel.ordering    || "fifo",
+      persistence: channel.persistence || "none",
+      max_size:    channel.maxSize     || 10000,
+    },
+  };
+}
+
+// ─── Event Lowering ───────────────────────────────────────────────────────────
+
+export function lowerEvent(systemName: string, ev: AST.EventDeclNode, source: string): IR.IREvent {
+  return {
+    id: makeId(systemName, "event", ev.name),
+    name: ev.name,
+    payload: ev.payload.map(lowerFieldHelper),
+    source,
+    delivery: (ev.delivery as IR.IRDeliveryMode) || "at_least_once",
+    ordering: "fifo",
+    ttl_ms: parseDurationMs(ev.ttl),
+  };
+}
+
+// ─── Flow Lowering ────────────────────────────────────────────────────────────
+
+export function lowerFlow(_systemName: string, flow: AST.FlowDeclNode): IR.IRFlow {
+  return {
+    name: flow.name,
+    steps: flow.steps.map(s => ({
+      name: s.name,
+      action: `${s.action.name}(${s.action.args.map(serializeExpr).join(", ")})`,
+      compensation: s.compensate
+        ? `${s.compensate.name}(${s.compensate.args.map(serializeExpr).join(", ")})`
+        : null,
+    })),
+  };
+}

package/src/lowering_entities.ts

@@ -0,0 +1,248 @@
+/**
+ * BoneScript Entity Lowering
+ * Converts EntityDecl + CapabilityDecl AST nodes into IR api_service modules.
+ * Also handles field lowering and CRUD method generation.
+ */
+
+import * as AST from "./ast";
+import * as IR from "./ir";
+import { makeId, parseDurationMs, serializeType, serializeExpr, toSnakeCase } from "./lowering_helpers";
+
+// ─── Field Lowering ───────────────────────────────────────────────────────────
+
+export function lowerField(f: AST.FieldNode): IR.IRField {
+  const type = serializeType(f.type);
+  // defaultValue is an ExprNode | null — serialize it to a string if present
+  const defaultValue = f.defaultValue ? serializeExpr(f.defaultValue) : null;
+  return {
+    name: f.name,
+    type,
+    nullable: false,
+    unique: false,
+    indexed: false,
+    default_value: defaultValue,
+  };
+}
+
+// ─── CRUD Method Generation ───────────────────────────────────────────────────
+
+export function makeCrudMethod(op: string, entityName: string, fields: IR.IRField[]): IR.IRMethod {
+  const input: IR.IRField[] =
+    op === "create" || op === "update"
+      ? fields.filter(f => f.name !== "id" && f.name !== "created_at" && f.name !== "updated_at")
+      : op === "list"
+        ? [
+            { name: "page",      type: "uint", nullable: true, unique: false, indexed: false, default_value: "1" },
+            { name: "page_size", type: "uint", nullable: true, unique: false, indexed: false, default_value: "50" },
+          ]
+        : [{ name: "id", type: "uuid", nullable: false, unique: true, indexed: true, default_value: null }];
+
+  return {
+    name: op,
+    input,
+    output: op === "list" ? `list<${entityName}>` : op === "delete" ? "bool" : entityName,
+    preconditions: [],
+    effects: [],
+    emissions: [],
+    idempotent: op === "read" || op === "list",
+    authenticated: true,
+    timeout_ms: 30000,
+    retry: null,
+    pipeline: null,
+    algorithm: null,
+    sync: null,
+  };
+}
+
+// ─── Capability Lowering ──────────────────────────────────────────────────────
+
+export function lowerCapability(cap: AST.CapabilityDeclNode): IR.IRMethod {
+  const input: IR.IRField[] = cap.params.map(p => ({
+    name: p.name,
+    type: serializeType(p.type),
+    nullable: false,
+    unique: false,
+    indexed: false,
+    default_value: null,
+  }));
+
+  const preconditions: IR.IRPrecondition[] = cap.requires.map(r => ({
+    expression: serializeExpr(r),
+    description: serializeExpr(r),
+  }));
+
+  const effects: IR.IREffect[] = cap.effects.map(e => ({
+    target: e.target.path.join("."),
+    op: e.op === "=" ? "assign" as const : e.op === "+=" ? "add" as const : "remove" as const,
+    value: serializeExpr(e.value),
+  }));
+
+  let pipeline: IR.IRPipeline | null = null;
+  if (cap.pipeline) {
+    pipeline = {
+      parallel: cap.pipeline.parallel,
+      steps: cap.pipeline.steps.map(step => ({
+        call_name: step.call.name,
+        call_args: step.call.args.map(a => serializeExpr(a)),
+        bind_as: step.bindAs,
+      })),
+      on_error: cap.pipeline.onError ? {
+        action: cap.pipeline.onError.action,
+        call_name: cap.pipeline.onError.call?.name || null,
+        call_args: cap.pipeline.onError.call?.args.map(a => serializeExpr(a)) || [],
+      } : null,
+    };
+  }
+
+  let algorithm: IR.IRAlgorithm | null = null;
+  if (cap.algorithm) {
+    algorithm = {
+      catalog_name: cap.algorithm.name,
+      bindings: cap.algorithm.using.map(b => ({
+        param: b.param,
+        value: serializeExpr(b.value),
+      })),
+    };
+  }
+
+  return {
+    name: cap.name,
+    input,
+    output: cap.returns ? serializeType(cap.returns) : "result<void, error>",
+    preconditions,
+    effects,
+    emissions: cap.emits.map(e => e.eventName),
+    idempotent: cap.idempotent || false,
+    authenticated: true,
+    timeout_ms: parseDurationMs(cap.timeout) || 30000,
+    retry: cap.retry ? {
+      max_attempts: cap.retry.maxAttempts || 3,
+      backoff: (cap.retry.backoff as IR.IRRetryPolicy["backoff"]) || "exponential",
+      interval_ms: parseDurationMs(cap.retry.interval) || 1000,
+    } : null,
+    pipeline,
+    algorithm,
+    sync: cap.sync,
+  };
+}
+
+// ─── Entity Lowering ──────────────────────────────────────────────────────────
+
+export function lowerEntity(
+  systemName: string,
+  entity: AST.EntityDeclNode,
+  capabilities: AST.CapabilityDeclNode[],
+  stores: AST.StoreDeclNode[],
+): IR.IRModule {
+  const moduleId = makeId(systemName, "api_service", `${entity.name}Service`);
+
+  // Ontology-entailed fields + declared fields
+  const fields: IR.IRField[] = [
+    { name: "id",         type: "uuid",      nullable: false, unique: true,  indexed: true,  default_value: "gen_random_uuid()" },
+    { name: "created_at", type: "timestamp", nullable: false, unique: false, indexed: true,  default_value: "now()" },
+    { name: "updated_at", type: "timestamp", nullable: false, unique: false, indexed: false, default_value: "now()" },
+    ...entity.owns.map(lowerField),
+  ];
+
+  const derivedFields: IR.IRField[] = entity.derived.map(d => ({
+    name: d.name,
+    type: "json",
+    nullable: true,
+    unique: false,
+    indexed: false,
+    default_value: `GENERATED ALWAYS AS (${serializeExpr(d.expr)}) STORED`,
+  }));
+
+  const indexes: IR.IRIndex[] = entity.indexes.map(idx => ({ fields: idx, unique: false }));
+
+  const modelConstraints: IR.IRModelConstraint[] = [];
+  for (const c of entity.constraints) {
+    const serialized = serializeExpr(c);
+    if (c.kind === "FieldRef" && c.path[c.path.length - 1] === "unique") {
+      const field = c.path.slice(0, -1).join(".");
+      modelConstraints.push({ kind: "unique", target: field, params: {} });
+      indexes.push({ fields: [field], unique: true });
+    } else {
+      modelConstraints.push({ kind: "check", target: entity.name, params: { expression: serialized } });
+    }
+  }
+
+  const model: IR.IRModel = {
+    name: entity.name,
+    fields: [...fields, ...derivedFields],
+    primary_key: "id",
+    indexes,
+    constraints: modelConstraints,
+  };
+
+  // State machine
+  const stateMachines: IR.IRStateMachine[] = [];
+  if (entity.states) {
+    const states = entity.states.nodes.map(n => n.name);
+    const transitions: IR.IRTransition[] = [];
+    for (const node of entity.states.nodes) {
+      for (const target of node.transitions) {
+        transitions.push({ from: node.name, to: target, trigger: `${node.name}_to_${target}`, guard: null });
+      }
+      for (const target of node.branches) {
+        transitions.push({ from: node.name, to: target, trigger: `${node.name}_to_${target}`, guard: null });
+      }
+    }
+    stateMachines.push({ entity: entity.name, states, initial: states[0], transitions });
+  }
+
+  // Methods: CRUD + capabilities
+  const methods: IR.IRMethod[] = [
+    makeCrudMethod("create", entity.name, fields),
+    makeCrudMethod("read",   entity.name, fields),
+    makeCrudMethod("update", entity.name, fields),
+    makeCrudMethod("delete", entity.name, fields),
+    makeCrudMethod("list",   entity.name, fields),
+    ...capabilities.map(lowerCapability),
+  ];
+
+  // Relations
+  const relations: IR.IRRelation[] = entity.relations.map(rel => {
+    const fromTable = toSnakeCase(entity.name) + "s";
+    const toTable   = toSnakeCase(rel.target) + "s";
+    let foreignKey: string;
+    let junctionTable: string | undefined;
+
+    switch (rel.relationType) {
+      case "belongs_to":
+        foreignKey = toSnakeCase(rel.target) + "_id";
+        break;
+      case "has_one":
+      case "has_many":
+        foreignKey = toSnakeCase(entity.name) + "_id";
+        break;
+      case "many_to_many":
+        foreignKey = toSnakeCase(entity.name) + "_id";
+        junctionTable = [fromTable, toTable].sort().join("_");
+        break;
+      default:
+        foreignKey = toSnakeCase(rel.target) + "_id";
+    }
+
+    return { name: rel.name, kind: rel.relationType, from_entity: entity.name, to_entity: rel.target, from_table: fromTable, to_table: toTable, foreign_key: foreignKey, junction_table: junctionTable };
+  });
+
+  const relatedStore = stores.find(s => s.name.toLowerCase().includes(entity.name.toLowerCase()));
+  const deps = relatedStore ? [makeId(systemName, "data_store", relatedStore.name)] : [];
+
+  return {
+    id: moduleId,
+    kind: "api_service",
+    name: `${entity.name}Service`,
+    interfaces: [{ name: `I${entity.name}Service`, methods }],
+    models: [model],
+    events: [],
+    state_machines: stateMachines,
+    relations,
+    dependencies: deps,
+    config: {
+      authenticated: entity.auth !== null && entity.auth !== "none",
+      auth_method: entity.auth || "none",
+    },
+  };
+}

package/src/lowering_helpers.ts

@@ -0,0 +1,75 @@
+/**
+ * BoneScript Lowering Helpers
+ * Shared utilities used across all lowering phases:
+ *   - Deterministic ID generation
+ *   - Duration string parsing
+ *   - AST type/expression serialization
+ */
+
+import { createHash } from "crypto";
+import * as AST from "./ast";
+
+// ─── Deterministic ID Generation ─────────────────────────────────────────────
+
+export function makeId(systemName: string, kind: string, name: string): string {
+  return createHash("sha256")
+    .update(`${systemName}.${kind}.${name}`)
+    .digest("hex")
+    .slice(0, 16);
+}
+
+// ─── Duration Parsing ─────────────────────────────────────────────────────────
+
+export function parseDurationMs(dur: string | null): number | null {
+  if (!dur) return null;
+  const match = dur.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "ms": return value;
+    case "s":  return value * 1_000;
+    case "m":  return value * 60_000;
+    case "h":  return value * 3_600_000;
+    case "d":  return value * 86_400_000;
+    default:   return null;
+  }
+}
+
+// ─── Type Expression Serialization ───────────────────────────────────────────
+
+export function serializeType(t: AST.TypeExprNode): string {
+  switch (t.kind) {
+    case "PrimitiveType":  return t.name;
+    case "GenericType":    return `${t.name}<${t.typeArgs.map(serializeType).join(", ")}>`;
+    case "EntityRefType":  return t.name;
+    case "TupleType":      return `(${t.elements.map(serializeType).join(", ")})`;
+    case "UnionType":      return t.members.map(serializeType).join(" | ");
+  }
+}
+
+// ─── Expression Serialization ─────────────────────────────────────────────────
+
+export function serializeExpr(e: AST.ExprNode): string {
+  switch (e.kind) {
+    case "Literal":
+      if (e.type === "string") return `"${e.value}"`;
+      if (e.type === "list")   return `[${(e.value as AST.ExprNode[]).map(serializeExpr).join(", ")}]`;
+      return String(e.value);
+    case "FieldRef":
+      return e.path.join(".");
+    case "BinaryExpr":
+      return `(${serializeExpr(e.left)} ${e.op} ${serializeExpr(e.right)})`;
+    case "UnaryExpr":
+      return `(${e.op} ${serializeExpr(e.operand)})`;
+    case "CallExpr":
+      return `${e.name}(${e.args.map(serializeExpr).join(", ")})`;
+    case "TernaryExpr":
+      return `(${serializeExpr(e.condition)} ? ${serializeExpr(e.consequent)} : ${serializeExpr(e.alternate)})`;
+  }
+}
+
+// ─── Shared snake_case helper ─────────────────────────────────────────────────
+
+export function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}

package/src/module_loader.ts

@@ -1,114 +1,112 @@
-/**
- * BoneScript Module Loader — Resolves import declarations across multiple .bone files.
- *
- * Behavior:
- * - Tracks loaded files to avoid cycles
- * - Resolves relative paths from importing file
- * - Merges imported declarations into a single AST
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { Lexer } from "./lexer";
-import { Parser } from "./parser";
-import { RecoveringParser } from "./parser_recovery";
-import { ParseError } from "./parser_base";
-import * as AST from "./ast";
-
-export interface LoadResult {
-  ast: AST.ProgramNode | null;
-  errors: { file: string; error: ParseError }[];
-  loadedFiles: string[];
-}
-
-export class ModuleLoader {
-  private loaded = new Map<string, AST.ProgramNode>();
-  private inProgress = new Set<string>();
-  private errors: { file: string; error: ParseError }[] = [];
-
-  load(entryFile: string): LoadResult {
-    const resolved = path.resolve(entryFile);
-    const ast = this.loadFile(resolved);
-
-    return {
-      ast,
-      errors: this.errors,
-      loadedFiles: Array.from(this.loaded.keys()),
-    };
-  }
-
-  private loadFile(filePath: string): AST.ProgramNode | null {
-    if (this.loaded.has(filePath)) return this.loaded.get(filePath)!;
-    if (this.inProgress.has(filePath)) {
-      this.errors.push({
-        file: filePath,
-        error: new ParseError(`Circular import detected: ${filePath}`, { line: 1, column: 1, offset: 0 }),
-      });
-      return null;
-    }
-
-    if (!fs.existsSync(filePath)) {
-      this.errors.push({
-        file: filePath,
-        error: new ParseError(`File not found: ${filePath}`, { line: 1, column: 1, offset: 0 }),
-      });
-      return null;
-    }
-
-    this.inProgress.add(filePath);
-
-    const source = fs.readFileSync(filePath, "utf-8");
-    const tokens = new Lexer(source).tokenize();
-    const result = new RecoveringParser(tokens).parse();
-
-    for (const err of result.errors) {
-      this.errors.push({ file: filePath, error: err });
-    }
-
-    if (!result.ast) {
-      this.inProgress.delete(filePath);
-      return null;
-    }
-
-    // Resolve imports recursively
-    const importedSystems: AST.SystemDeclNode[] = [];
-    for (const sys of result.ast.systems) {
-      const imports = sys.declarations.filter((d): d is AST.ImportDeclNode => d.kind === "ImportDecl");
-      for (const imp of imports) {
-        const importPath = path.resolve(path.dirname(filePath), imp.from);
-        const importedAst = this.loadFile(importPath);
-        if (importedAst) {
-          importedSystems.push(...importedAst.systems);
-        }
-      }
-    }
-
-    // Merge imported systems' declarations into current systems
-    if (importedSystems.length > 0) {
-      const mergedSystems = result.ast.systems.map(sys => {
-        const importedDecls: AST.DeclarationNode[] = [];
-        for (const imported of importedSystems) {
-          // Add imported entities, events, etc. (skip imports themselves)
-          for (const d of imported.declarations) {
-            if (d.kind !== "ImportDecl") importedDecls.push(d);
-          }
-        }
-        return {
-          ...sys,
-          declarations: [...sys.declarations.filter(d => d.kind !== "ImportDecl"), ...importedDecls],
-        };
-      });
-      result.ast.systems = mergedSystems;
-    } else {
-      // Remove import declarations from final AST
-      result.ast.systems = result.ast.systems.map(sys => ({
-        ...sys,
-        declarations: sys.declarations.filter(d => d.kind !== "ImportDecl"),
-      }));
-    }
-
-    this.loaded.set(filePath, result.ast);
-    this.inProgress.delete(filePath);
-    return result.ast;
-  }
-}
+/**
+ * BoneScript Module Loader — Resolves import declarations across multiple .bone files.
+ *
+ * Behavior:
+ * - Tracks loaded files to avoid cycles
+ * - Resolves relative paths from importing file
+ * - Merges imported declarations into a single AST
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { Lexer } from "./lexer";
+import { RecoveringParser } from "./parser_recovery";
+import { ParseError } from "./parser_base";
+import * as AST from "./ast";
+
+export interface LoadResult {
+  ast: AST.ProgramNode | null;
+  errors: { file: string; error: ParseError }[];
+  loadedFiles: string[];
+}
+
+export class ModuleLoader {
+  private loaded = new Map<string, AST.ProgramNode>();
+  private inProgress = new Set<string>();
+  private errors: { file: string; error: ParseError }[] = [];
+
+  async load(entryFile: string): Promise<LoadResult> {
+    const resolved = path.resolve(entryFile);
+    const ast = await this.loadFile(resolved);
+    return {
+      ast,
+      errors: this.errors,
+      loadedFiles: Array.from(this.loaded.keys()),
+    };
+  }
+
+  private async loadFile(filePath: string): Promise<AST.ProgramNode | null> {
+    if (this.loaded.has(filePath)) return this.loaded.get(filePath)!;
+    if (this.inProgress.has(filePath)) {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`Circular import detected: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    // Check existence without blocking the event loop
+    try {
+      await fs.promises.access(filePath);
+    } catch {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`File not found: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    this.inProgress.add(filePath);
+
+    const source = await fs.promises.readFile(filePath, "utf-8");
+    const tokens = new Lexer(source).tokenize();
+    const result = new RecoveringParser(tokens).parse();
+
+    for (const err of result.errors) {
+      this.errors.push({ file: filePath, error: err });
+    }
+
+    if (!result.ast) {
+      this.inProgress.delete(filePath);
+      return null;
+    }
+
+    // Resolve imports recursively (in parallel where possible)
+    const importedSystems: AST.SystemDeclNode[] = [];
+    for (const sys of result.ast.systems) {
+      const imports = sys.declarations.filter((d): d is AST.ImportDeclNode => d.kind === "ImportDecl");
+      // Load all imports for this system in parallel
+      const importedAsts = await Promise.all(
+        imports.map(imp => {
+          const importPath = path.resolve(path.dirname(filePath), imp.from);
+          return this.loadFile(importPath);
+        })
+      );
+      for (const importedAst of importedAsts) {
+        if (importedAst) importedSystems.push(...importedAst.systems);
+      }
+    }
+
+    // Merge imported declarations into current systems
+    if (importedSystems.length > 0) {
+      result.ast.systems = result.ast.systems.map(sys => {
+        const importedDecls: AST.DeclarationNode[] = importedSystems.flatMap(imported =>
+          imported.declarations.filter(d => d.kind !== "ImportDecl")
+        );
+        return {
+          ...sys,
+          declarations: [...sys.declarations.filter(d => d.kind !== "ImportDecl"), ...importedDecls],
+        };
+      });
+    } else {
+      result.ast.systems = result.ast.systems.map(sys => ({
+        ...sys,
+        declarations: sys.declarations.filter(d => d.kind !== "ImportDecl"),
+      }));
+    }
+
+    this.loaded.set(filePath, result.ast);
+    this.inProgress.delete(filePath);
+    return result.ast;
+  }
+}