bonescript-compiler 0.2.1 → 0.4.0

package/src/typechecker.ts

@@ -336,24 +336,26 @@ export class TypeChecker {
   // ─── Flow Checking ─────────────────────────────────────────────────────────
 
   private checkFlow(decl: AST.FlowDeclNode) {
-    for (const step of decl.steps) {
-      // Check step action references a valid capability or function
-      if (!this.symbols.capabilities.has(step.action.name) &&
-          !this.symbols.entities.has(step.action.name)) {
-        // Allow — could be a helper function not yet declared
-        // In strict mode this would be T012
-      }
-
-      // Check compensation exists if step has one
-      if (step.compensate) {
-        // Same check — compensation should reference a valid capability
-      }
-    }
-
     // Check at least 2 steps (ontology requirement)
     if (decl.steps.length < 2) {
       this.addError("T012", `Flow '${decl.name}' must have at least 2 steps`, decl.loc);
     }
+
+    for (const step of decl.steps) {
+      // Flow steps may call external service endpoints (not just local capabilities).
+      // Only error if the name collides with a declared entity name, which would be
+      // a definite mistake. Undeclared names are treated as external HTTP calls.
+      if (this.symbols.entities.has(step.action.name)) {
+        this.addError("T013",
+          `Flow '${decl.name}' step '${step.name}' uses entity name '${step.action.name}' as a call — did you mean a capability?`,
+          decl.loc);
+      }
+      if (step.compensate && this.symbols.entities.has(step.compensate.name)) {
+        this.addError("T013",
+          `Flow '${decl.name}' step '${step.name}' compensation uses entity name '${step.compensate.name}' as a call — did you mean a capability?`,
+          decl.loc);
+      }
+    }
   }
 
   // ─── Constraint Checking ───────────────────────────────────────────────────
@@ -496,8 +498,21 @@ export class TypeChecker {
     if (expr.name === "now") return prim("timestamp");
     if (expr.name === "count") return prim("uint");
     if (expr.name === "sum") return prim("uint");
+    if (expr.name === "min" || expr.name === "max") return prim("uint");
+    if (expr.name === "abs") return prim("uint");
+    if (expr.name === "floor" || expr.name === "ceil" || expr.name === "round") return prim("int");
+    if (expr.name === "len" || expr.name === "size") return prim("uint");
+    if (expr.name === "contains" || expr.name === "starts_with" || expr.name === "ends_with") return prim("bool");
+    if (expr.name === "to_string") return prim("string");
+    if (expr.name === "to_int" || expr.name === "to_uint") return prim("int");
+    if (expr.name === "to_float") return prim("float");
+
+    // Check if it's a declared capability — use json as safe fallback for its return
+    if (this.symbols.capabilities.has(expr.name)) {
+      return prim("json");
+    }
 
-    // User-defined — return json as permissive fallback
+    // Unknown user-defined function — permissive fallback
     return prim("json");
   }
 

package/src/types.ts

@@ -1,122 +1,122 @@
-/**
- * BoneScript Type System — Internal type representations.
- * Implements spec/04_TYPE_SYSTEM.md.
- */
-
-export type CVType =
-  | PrimitiveType
-  | GenericType
-  | RecordType
-  | UnionType
-  | TupleType
-  | BottomType;
-
-export interface PrimitiveType {
-  tag: "primitive";
-  name: "string" | "uint" | "int" | "float" | "bool" | "timestamp" | "uuid" | "bytes" | "json";
-}
-
-export interface GenericType {
-  tag: "generic";
-  name: "list" | "set" | "map" | "optional" | "result";
-  args: CVType[];
-}
-
-export interface RecordType {
-  tag: "record";
-  name: string; // entity name
-  fields: Map<string, CVType>;
-}
-
-export interface UnionType {
-  tag: "union";
-  members: CVType[];
-}
-
-export interface TupleType {
-  tag: "tuple";
-  elements: CVType[];
-}
-
-export interface BottomType {
-  tag: "bottom"; // unifies with any optional<T>
-}
-
-// ─── Constructors ────────────────────────────────────────────────────────────
-
-export function prim(name: PrimitiveType["name"]): PrimitiveType {
-  return { tag: "primitive", name };
-}
-
-export function generic(name: GenericType["name"], ...args: CVType[]): GenericType {
-  return { tag: "generic", name, args };
-}
-
-export function record(name: string, fields: Map<string, CVType>): RecordType {
-  return { tag: "record", name, fields };
-}
-
-export const BOTTOM: BottomType = { tag: "bottom" };
-
-// ─── Type Equality ───────────────────────────────────────────────────────────
-
-export function typeEquals(a: CVType, b: CVType): boolean {
-  if (a.tag !== b.tag) {
-    // optional<T> accepts T (implicit wrapping)
-    if (a.tag === "generic" && a.name === "optional" && typeEquals(a.args[0], b)) return true;
-    if (b.tag === "generic" && b.name === "optional" && typeEquals(b.args[0], a)) return true;
-    // bottom unifies with any optional
-    if (a.tag === "bottom" && b.tag === "generic" && b.name === "optional") return true;
-    if (b.tag === "bottom" && a.tag === "generic" && a.name === "optional") return true;
-    return false;
-  }
-
-  switch (a.tag) {
-    case "primitive":
-      return a.name === (b as PrimitiveType).name;
-    case "generic": {
-      const bg = b as GenericType;
-      return a.name === bg.name && a.args.length === bg.args.length &&
-        a.args.every((arg, i) => typeEquals(arg, bg.args[i]));
-    }
-    case "record": {
-      const br = b as RecordType;
-      return a.name === br.name; // nominal for records (entity names)
-    }
-    case "union": {
-      const bu = b as UnionType;
-      return a.members.length === bu.members.length &&
-        a.members.every((m, i) => typeEquals(m, bu.members[i]));
-    }
-    case "tuple": {
-      const bt = b as TupleType;
-      return a.elements.length === bt.elements.length &&
-        a.elements.every((e, i) => typeEquals(e, bt.elements[i]));
-    }
-    case "bottom":
-      return true;
-  }
-}
-
-// ─── Type Display ────────────────────────────────────────────────────────────
-
-export function typeToString(t: CVType): string {
-  switch (t.tag) {
-    case "primitive": return t.name;
-    case "generic": return `${t.name}<${t.args.map(typeToString).join(", ")}>`;
-    case "record": return t.name;
-    case "union": return t.members.map(typeToString).join(" | ");
-    case "tuple": return `(${t.elements.map(typeToString).join(", ")})`;
-    case "bottom": return "bottom";
-  }
-}
-
-// ─── Numeric Type Check ──────────────────────────────────────────────────────
-
-export function isNumeric(t: CVType): boolean {
-  return t.tag === "primitive" && (t.name === "uint" || t.name === "int" || t.name === "float");
-}
-
-export function isComparable(t: CVType): boolean {
-  return isNumeric(t) || (t.tag === "primitive" && (t.name === "string" || t.name === "timestamp"));
-}
+/**
+ * BoneScript Type System — Internal type representations.
+ * Implements spec/04_TYPE_SYSTEM.md.
+ */
+
+export type CVType =
+  | PrimitiveType
+  | GenericType
+  | RecordType
+  | UnionType
+  | TupleType
+  | BottomType;
+
+export interface PrimitiveType {
+  tag: "primitive";
+  name: "string" | "uint" | "int" | "float" | "bool" | "timestamp" | "uuid" | "bytes" | "json";
+}
+
+export interface GenericType {
+  tag: "generic";
+  name: "list" | "set" | "map" | "optional" | "result";
+  args: CVType[];
+}
+
+export interface RecordType {
+  tag: "record";
+  name: string; // entity name
+  fields: Map<string, CVType>;
+}
+
+export interface UnionType {
+  tag: "union";
+  members: CVType[];
+}
+
+export interface TupleType {
+  tag: "tuple";
+  elements: CVType[];
+}
+
+export interface BottomType {
+  tag: "bottom"; // unifies with any optional<T>
+}
+
+// ─── Constructors ────────────────────────────────────────────────────────────
+
+export function prim(name: PrimitiveType["name"]): PrimitiveType {
+  return { tag: "primitive", name };
+}
+
+export function generic(name: GenericType["name"], ...args: CVType[]): GenericType {
+  return { tag: "generic", name, args };
+}
+
+export function record(name: string, fields: Map<string, CVType>): RecordType {
+  return { tag: "record", name, fields };
+}
+
+export const BOTTOM: BottomType = { tag: "bottom" };
+
+// ─── Type Equality ───────────────────────────────────────────────────────────
+
+export function typeEquals(a: CVType, b: CVType): boolean {
+  if (a.tag !== b.tag) {
+    // optional<T> accepts T (implicit wrapping)
+    if (a.tag === "generic" && a.name === "optional" && typeEquals(a.args[0], b)) return true;
+    if (b.tag === "generic" && b.name === "optional" && typeEquals(b.args[0], a)) return true;
+    // bottom unifies with any optional
+    if (a.tag === "bottom" && b.tag === "generic" && b.name === "optional") return true;
+    if (b.tag === "bottom" && a.tag === "generic" && a.name === "optional") return true;
+    return false;
+  }
+
+  switch (a.tag) {
+    case "primitive":
+      return a.name === (b as PrimitiveType).name;
+    case "generic": {
+      const bg = b as GenericType;
+      return a.name === bg.name && a.args.length === bg.args.length &&
+        a.args.every((arg, i) => typeEquals(arg, bg.args[i]));
+    }
+    case "record": {
+      const br = b as RecordType;
+      return a.name === br.name; // nominal for records (entity names)
+    }
+    case "union": {
+      const bu = b as UnionType;
+      return a.members.length === bu.members.length &&
+        a.members.every((m, i) => typeEquals(m, bu.members[i]));
+    }
+    case "tuple": {
+      const bt = b as TupleType;
+      return a.elements.length === bt.elements.length &&
+        a.elements.every((e, i) => typeEquals(e, bt.elements[i]));
+    }
+    case "bottom":
+      return true;
+  }
+}
+
+// ─── Type Display ────────────────────────────────────────────────────────────
+
+export function typeToString(t: CVType): string {
+  switch (t.tag) {
+    case "primitive": return t.name;
+    case "generic": return `${t.name}<${t.args.map(typeToString).join(", ")}>`;
+    case "record": return t.name;
+    case "union": return t.members.map(typeToString).join(" | ");
+    case "tuple": return `(${t.elements.map(typeToString).join(", ")})`;
+    case "bottom": return "bottom";
+  }
+}
+
+// ─── Numeric Type Check ──────────────────────────────────────────────────────
+
+export function isNumeric(t: CVType): boolean {
+  return t.tag === "primitive" && (t.name === "uint" || t.name === "int" || t.name === "float");
+}
+
+export function isComparable(t: CVType): boolean {
+  return isNumeric(t) || (t.tag === "primitive" && (t.name === "string" || t.name === "timestamp"));
+}

package/src/verifier.ts

@@ -41,16 +41,19 @@ export class Verifier {
   verify(system: IR.IRSystem, files: EmittedFile[]): VerifyResult {
     const issues: VerifyIssue[] = [];
 
-    // ─── IR Validation ─────────────────────────────────────────────────────
-
+    // ─── IR Validation ────────────────────────────────────────────────────────
     this.checkDependencies(system, issues);
+    this.checkEventSources(system, issues);       // V002
     this.checkDuplicateIds(system, issues);
     this.checkModels(system, issues);
     this.checkStateMachines(system, issues);
     this.checkCircularDeps(system, issues);
+    this.checkPreconditions(system, issues);       // V005
+    this.checkMethodEffects(system, issues);       // V006
+    this.checkAuthDependencies(system, issues);    // V011
+    this.checkResolutionMap(system, issues);       // V012
 
-    // ─── Generated Code Validation ─────────────────────────────────────────
-
+    // ─── Generated Code Validation ────────────────────────────────────────────
     this.checkTypeScriptSyntax(files, issues);
     this.checkSqlSyntax(files, issues);
     this.checkImports(files, issues);
@@ -333,6 +336,150 @@ export class Verifier {
       }
     }
   }
+
+
+  // ─── V002: Event source exists as a module ────────────────────────────────
+  private checkEventSources(system: IR.IRSystem, issues: VerifyIssue[]) {
+    const moduleIds = new Set(system.modules.map(m => m.id));
+    for (const ev of system.events) {
+      if (ev.source && ev.source !== "unknown" && !moduleIds.has(ev.source)) {
+        issues.push({
+          code: "V002",
+          severity: "warning",
+          message: `Event '${ev.name}' source '${ev.source}' does not match any module id`,
+          location: ev.id,
+        });
+      }
+    }
+  }
+
+  // ─── V005: Preconditions reference accessible fields ─────────────────────
+  private checkPreconditions(system: IR.IRSystem, issues: VerifyIssue[]) {
+    // Build a map of all model field names by model name (lowercase for case-insensitive lookup)
+    const modelFields = new Map<string, Set<string>>();
+    for (const mod of system.modules) {
+      for (const model of mod.models) {
+        const fields = new Set(model.fields.map(f => f.name));
+        // Add ontology-entailed fields always present
+        fields.add("id"); fields.add("created_at"); fields.add("updated_at"); fields.add("state");
+        modelFields.set(model.name, fields);
+        modelFields.set(model.name.toLowerCase(), fields);
+      }
+    }
+
+    // Simple field-path extractor: finds "word.word" patterns in a serialized expression
+    const fieldPathPattern = /\b([a-zA-Z_]\w*)\.([a-zA-Z_]\w*)\b/g;
+
+    for (const mod of system.modules) {
+      for (const iface of mod.interfaces) {
+        for (const method of iface.methods) {
+          for (const pre of method.preconditions) {
+            let match: RegExpExecArray | null;
+            fieldPathPattern.lastIndex = 0;
+            while ((match = fieldPathPattern.exec(pre.expression)) !== null) {
+              const [, paramName, fieldName] = match;
+              // Skip known non-field patterns (e.g. "now()", numeric literals)
+              if (paramName === "now" || /^\d/.test(paramName)) continue;
+              // Check if the field exists in any model — warn if not found
+              const foundInAnyModel = [...modelFields.values()].some(f => f.has(fieldName));
+              if (!foundInAnyModel) {
+                issues.push({
+                  code: "V005",
+                  severity: "warning",
+                  message: `Precondition in '${method.name}' references '${paramName}.${fieldName}' — field '${fieldName}' not found in any model`,
+                  location: `${mod.id}.${method.name}`,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ─── V006: Effects target fields that exist ───────────────────────────────
+  private checkMethodEffects(system: IR.IRSystem, issues: VerifyIssue[]) {
+    // Build a map of all model field names by model name
+    const modelFields = new Map<string, Set<string>>();
+    for (const mod of system.modules) {
+      for (const model of mod.models) {
+        const fields = new Set(model.fields.map(f => f.name));
+        modelFields.set(model.name, fields);
+        modelFields.set(model.name.toLowerCase(), fields);
+      }
+    }
+
+    for (const mod of system.modules) {
+      for (const iface of mod.interfaces) {
+        for (const method of iface.methods) {
+          for (const effect of method.effects) {
+            const parts = effect.target.split(".");
+            if (parts.length < 2) continue;
+            const fieldName = parts[1];
+            // Try to find the model — check all models for the field
+            // (we can't always resolve the param name to a model here without type info)
+            // Only error if the field name looks like a typo (not found in ANY model)
+            const foundInAnyModel = [...modelFields.values()].some(fields => fields.has(fieldName));
+            if (!foundInAnyModel && !["state", "status", "owner_id"].includes(fieldName)) {
+              issues.push({
+                code: "V006",
+                severity: "warning",
+                message: `Effect target '${effect.target}' in method '${method.name}' — field '${fieldName}' not found in any model`,
+                location: `${mod.id}.${method.name}`,
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ─── V011: Authenticated methods' modules depend on auth ─────────────────
+  private checkAuthDependencies(system: IR.IRSystem, issues: VerifyIssue[]) {
+    const authModuleIds = new Set(
+      system.modules
+        .filter(m => m.kind === "auth_service" || m.config["auth_method"])
+        .map(m => m.id)
+    );
+
+    for (const mod of system.modules) {
+      const hasAuthenticatedMethod = mod.interfaces.some(i =>
+        i.methods.some(m => m.authenticated)
+      );
+      if (!hasAuthenticatedMethod) continue;
+
+      // Module must either be an auth service itself or depend on one
+      const isAuthService = mod.kind === "auth_service";
+      const dependsOnAuth = mod.dependencies.some(dep => authModuleIds.has(dep));
+      const hasAuthConfig = mod.config["auth_method"] && mod.config["auth_method"] !== "none";
+
+      if (!isAuthService && !dependsOnAuth && !hasAuthConfig && authModuleIds.size > 0) {
+        issues.push({
+          code: "V011",
+          severity: "warning",
+          message: `Module '${mod.name}' has authenticated methods but does not declare an auth dependency`,
+          location: mod.id,
+        });
+      }
+    }
+  }
+
+  // ─── V012: Resolution map is complete ────────────────────────────────────
+  private checkResolutionMap(system: IR.IRSystem, issues: VerifyIssue[]) {
+    // Resolution map must have at least the system-level keys
+    const required = ["system.name", "system.version", "system.domain"];
+    for (const key of required) {
+      if (!system.resolution[key]) {
+        issues.push({
+          code: "V012",
+          severity: "warning",
+          message: `Resolution map missing required key '${key}' — run constraint solver`,
+          location: system.name,
+        });
+      }
+    }
+  }
+
 }
 
 function resolvePath(base: string, relative: string): string {