bonescript-compiler 0.5.3 → 0.5.4

package/src/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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;
+    fields: Map<string, CVType>;
+}
+export interface UnionType {
+    tag: "union";
+    members: CVType[];
+}
+export interface TupleType {
+    tag: "tuple";
+    elements: CVType[];
+}
+export interface BottomType {
+    tag: "bottom";
+}
+export declare function prim(name: PrimitiveType["name"]): PrimitiveType;
+export declare function generic(name: GenericType["name"], ...args: CVType[]): GenericType;
+export declare function record(name: string, fields: Map<string, CVType>): RecordType;
+export declare const BOTTOM: BottomType;
+export declare function typeEquals(a: CVType, b: CVType): boolean;
+export declare function typeToString(t: CVType): string;
+export declare function isNumeric(t: CVType): boolean;
+export declare function isComparable(t: CVType): boolean;

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,19 +41,17 @@ 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
+    this.checkAuthDependencies(system, issues);
+
+    // ─── Generated Code Validation ─────────────────────────────────────────
 
-    // ─── Generated Code Validation ────────────────────────────────────────────
     this.checkTypeScriptSyntax(files, issues);
     this.checkSqlSyntax(files, issues);
     this.checkImports(files, issues);
@@ -197,7 +195,7 @@ export class Verifier {
     const visited = new Set<string>();
     const inStack = new Set<string>();
 
-    const dfs = (node: string, path: string[]): void => {
+    const dfs = (node: string, path: string[]): boolean => {
       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 +205,9 @@ export class Verifier {
           message: `Circular dependency: ${names.join(" → ")}`,
           location: node,
         });
-        return;
+        return true;
       }
-      if (visited.has(node)) return;
+      if (visited.has(node)) return false;
 
       visited.add(node);
       inStack.add(node);
@@ -221,6 +219,7 @@ export class Verifier {
       }
 
       inStack.delete(node);
+      return false;
     };
 
     for (const [id] of graph) {
@@ -232,6 +231,46 @@ export class Verifier {
 
   // ─── Generated TypeScript Validation ───────────────────────────────────────
 
+
+  // --- V011: Authenticated methods require auth dependency -------------------
+
+  private checkAuthDependencies(system: IR.IRSystem, issues: VerifyIssue[]) {
+    // Collect all module IDs that are auth_service kind
+    const authServiceIds = new Set(
+      system.modules.filter(m => m.kind === "auth_service").map(m => m.id)
+    );
+
+    for (const mod of system.modules) {
+      // Skip auth services themselves
+      if (mod.kind === "auth_service") continue;
+
+      // Check if any method in this module is authenticated
+      const hasAuthenticatedMethod = mod.interfaces.some(iface =>
+        iface.methods.some(method => method.authenticated)
+      );
+
+      if (!hasAuthenticatedMethod) continue;
+
+      // Check if the module declares a dependency on at least one auth_service
+      const dependsOnAuth = mod.dependencies.some(dep => authServiceIds.has(dep));
+
+      if (!dependsOnAuth) {
+        // Collect the authenticated method names for a helpful message
+        const authMethods: string[] = [];
+        for (const iface of mod.interfaces) {
+          for (const method of iface.methods) {
+            if (method.authenticated) authMethods.push(method.name);
+          }
+        }
+        issues.push({
+          code: "V011",
+          severity: "warning",
+          message: `Module '${mod.name}' has authenticated method(s) [${authMethods.join(', ')}] but does not declare a dependency on an auth_service module`,
+          location: mod.id,
+        });
+      }
+    }
+  }
   private checkTypeScriptSyntax(files: EmittedFile[], issues: VerifyIssue[]) {
     for (const file of files) {
       if (file.language !== "typescript") continue;
@@ -335,150 +374,6 @@ 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 {