bonescript-compiler 0.5.3 → 0.5.4

package/dist/lowering.js

@@ -1,24 +1,84 @@
 "use strict";
 /**
- * BoneScript Lowering — Stage 4 of the compilation pipeline.
+ * bone ir Lowering — Stage 4 of the compilation pipeline.
  * Converts typed AST into the Architecture IR (spec/07_IR_SPEC.md).
  *
- * This file is the orchestrator. The actual lowering logic lives in:
- *   lowering_helpers.ts   — makeId, parseDurationMs, serializeExpr/Type
- *   lowering_entities.ts  — lowerEntity, lowerCapability, lowerField, makeCrudMethod
- *   lowering_channels.ts  — lowerStore, lowerChannel, lowerEvent, lowerFlow
+ * Rules:
+ * - One module per semantic component
+ * - All IDs are deterministic (derived from system name + component name)
+ * - All ontology-entailed fields are inserted
+ * - Effects are serialized in declaration order
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowering = void 0;
-const lowering_helpers_1 = require("./lowering_helpers");
-const lowering_entities_1 = require("./lowering_entities");
-const lowering_channels_1 = require("./lowering_channels");
+const crypto_1 = require("crypto");
+function toSnakeCase(s) {
+    return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+// ─── Deterministic ID Generation ─────────────────────────────────────────────
+function makeId(systemName, kind, name) {
+    const input = `${systemName}.${kind}.${name}`;
+    return (0, crypto_1.createHash)("sha256").update(input).digest("hex").slice(0, 16);
+}
+// ─── Duration Parsing ────────────────────────────────────────────────────────
+function parseDurationMs(dur) {
+    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 * 1000;
+        case "m": return value * 60000;
+        case "h": return value * 3600000;
+        case "d": return value * 86400000;
+        default: return null;
+    }
+}
+// ─── Type Expression Serialization ───────────────────────────────────────────
+function serializeType(t) {
+    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 ────────────────────────────────────────────────
+function serializeExpr(e) {
+    switch (e.kind) {
+        case "Literal":
+            if (e.type === "string")
+                return `"${e.value}"`;
+            if (e.type === "list")
+                return `[${e.value.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)})`;
+    }
+}
+// ─── Lowering Engine ─────────────────────────────────────────────────────────
 class Lowering {
     constructor() {
         this.systemName = "";
     }
     lower(program, sourceHash) {
-        return program.systems.map(sys => this.lowerSystem(sys, sourceHash));
+        const systems = [];
+        for (const sys of program.systems) {
+            systems.push(this.lowerSystem(sys, sourceHash));
+        }
+        return systems;
     }
     lowerSystem(sys, sourceHash) {
         this.systemName = sys.name;
@@ -26,7 +86,7 @@ class Lowering {
         const events = [];
         const flows = [];
         const invariants = [];
-        // Partition declarations by kind
+        // Collect declarations by type
         const entities = sys.declarations.filter((d) => d.kind === "EntityDecl");
         const capabilities = sys.declarations.filter((d) => d.kind === "CapabilityDecl");
         const channels = sys.declarations.filter((d) => d.kind === "ChannelDecl");
@@ -36,70 +96,36 @@ class Lowering {
         const policies = sys.declarations.filter((d) => d.kind === "PolicyDecl");
         const flowDecls = sys.declarations.filter((d) => d.kind === "FlowDecl");
         const extensionPoints = sys.declarations.filter((d) => d.kind === "ExtensionPointDecl");
-        // Stores → data_store modules
+        // Lower stores → data_store modules
         for (const store of stores) {
-            modules.push((0, lowering_channels_1.lowerStore)(this.systemName, store));
+            modules.push(this.lowerStore(store));
         }
-        // Entities → api_service modules (with CRUD + related capabilities)
+        // Lower entities → api_service modules (with CRUD + capabilities)
         for (const entity of entities) {
             const relatedCaps = capabilities.filter(c => c.params.some(p => p.type.kind === "EntityRefType" && p.type.name === entity.name));
-            modules.push((0, lowering_entities_1.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 => (0, lowering_entities_1.lowerCapability)(cap));
-            modules.push({
-                id: (0, lowering_helpers_1.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" },
-            });
+            modules.push(this.lowerEntity(entity, relatedCaps, stores));
         }
-        // Channels → realtime_service modules
+        // Lower channels → realtime_service modules
         for (const channel of channels) {
-            modules.push((0, lowering_channels_1.lowerChannel)(this.systemName, channel));
+            modules.push(this.lowerChannel(channel));
         }
-        // Build a map from event name → emitting module id by scanning all capabilities
-        // across all entities. This resolves the event source before lowering events.
-        const eventSourceMap = new Map();
-        for (const entity of entities) {
-            const moduleId = (0, lowering_helpers_1.makeId)(this.systemName, "api_service", `${entity.name}Service`);
-            const relatedCaps = capabilities.filter(c => c.params.some(p => p.type.kind === "EntityRefType" && p.type.name === entity.name));
-            for (const cap of relatedCaps) {
-                for (const emit of cap.emits) {
-                    if (!eventSourceMap.has(emit.eventName)) {
-                        eventSourceMap.set(emit.eventName, moduleId);
-                    }
-                }
-            }
-        }
-        // Events
+        // Lower events
         for (const ev of eventDecls) {
-            const source = eventSourceMap.get(ev.name) || "unknown";
-            events.push((0, lowering_channels_1.lowerEvent)(this.systemName, ev, source));
+            events.push(this.lowerEvent(ev));
         }
-        // Flows
+        // Lower flows
         for (const flow of flowDecls) {
-            flows.push((0, lowering_channels_1.lowerFlow)(this.systemName, flow));
+            flows.push(this.lowerFlow(flow));
         }
-        // Constraints → invariants
+        // Lower constraints → invariants
         for (const c of constraints) {
             invariants.push({
-                id: (0, lowering_helpers_1.makeId)(this.systemName, "invariant", c.name),
-                expression: (0, lowering_helpers_1.serializeExpr)(c.expr),
+                id: makeId(this.systemName, "invariant", c.name),
+                expression: serializeExpr(c.expr),
                 scope: "global",
             });
         }
-        // Gateway module (always present per ontology)
+        // Add gateway module (ontology: always present)
         const gatewayConfig = {
             rate_limit: 1000,
             cors: true,
@@ -107,13 +133,15 @@ class Lowering {
         };
         if (policies.length > 0) {
             const mainPolicy = policies[0];
-            if (mainPolicy.rateLimit)
+            if (mainPolicy.rateLimit) {
                 gatewayConfig["rate_limit"] = mainPolicy.rateLimit.count;
-            if (mainPolicy.encryption)
+            }
+            if (mainPolicy.encryption) {
                 gatewayConfig["encryption"] = mainPolicy.encryption;
+            }
         }
         modules.push({
-            id: (0, lowering_helpers_1.makeId)(this.systemName, "gateway", "APIGateway"),
+            id: makeId(this.systemName, "gateway", "APIGateway"),
             kind: "gateway",
             name: "APIGateway",
             interfaces: [],
@@ -121,9 +149,7 @@ class Lowering {
             events: [],
             state_machines: [],
             relations: [],
-            dependencies: modules
-                .filter(m => m.kind === "api_service" || m.kind === "realtime_service")
-                .map(m => m.id),
+            dependencies: modules.filter(m => m.kind === "api_service" || m.kind === "realtime_service").map(m => m.id),
             config: gatewayConfig,
         });
         return {
@@ -138,12 +164,337 @@ class Lowering {
             resolution: {},
             extension_points: extensionPoints.map(ep => ({
                 name: ep.name,
-                params: ep.params.map(p => ({ name: p.name, type: (0, lowering_helpers_1.serializeType)(p.type) })),
-                returns: ep.returns ? (0, lowering_helpers_1.serializeType)(ep.returns) : null,
+                params: ep.params.map(p => ({ name: p.name, type: serializeType(p.type) })),
+                returns: ep.returns ? serializeType(ep.returns) : null,
                 stable: ep.stable,
             })),
         };
     }
+    // ─── Store Lowering ────────────────────────────────────────────────────────
+    lowerStore(store) {
+        // Strip "Store" suffix from model name so SellerStore → Seller → table "sellers"
+        const entityName = store.name.replace(/Store$/, "") || store.name;
+        const model = {
+            name: entityName,
+            fields: store.schema.map(f => this.lowerField(f)),
+            primary_key: "id",
+            indexes: [],
+            constraints: [],
+        };
+        // Add id field if not present
+        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(this.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 } : {}),
+            },
+        };
+    }
+    // ─── Entity Lowering ───────────────────────────────────────────────────────
+    lowerEntity(entity, capabilities, stores) {
+        const moduleId = makeId(this.systemName, "api_service", `${entity.name}Service`);
+        // Build model from entity fields + ontology entailments
+        const fields = [
+            { 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()" },
+        ];
+        for (const f of entity.owns) {
+            fields.push(this.lowerField(f));
+        }
+        // Add derived fields as generated columns (stored: false = virtual)
+        const derivedFields = entity.derived.map(d => ({
+            name: d.name,
+            type: "json", // type inferred at runtime
+            nullable: true,
+            unique: false,
+            indexed: false,
+            default_value: `GENERATED ALWAYS AS (${serializeExpr(d.expr)}) STORED`,
+        }));
+        // Build indexes from entity index declarations
+        const indexes = [];
+        for (const idx of entity.indexes) {
+            indexes.push({ fields: idx, unique: false });
+        }
+        // Build constraints from entity constraints
+        const modelConstraints = [];
+        for (const c of entity.constraints) {
+            const serialized = serializeExpr(c);
+            // Detect unique constraints
+            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 = {
+            name: entity.name,
+            fields: [...fields, ...derivedFields],
+            primary_key: "id",
+            indexes,
+            constraints: modelConstraints,
+        };
+        // Build state machine if entity has states
+        const stateMachines = [];
+        if (entity.states) {
+            const states = entity.states.nodes.map(n => n.name);
+            const transitions = [];
+            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,
+            });
+        }
+        // Build interface from capabilities
+        const methods = [];
+        // CRUD methods (always generated for entities)
+        methods.push(this.makeCrudMethod("create", entity.name, fields));
+        methods.push(this.makeCrudMethod("read", entity.name, fields));
+        methods.push(this.makeCrudMethod("update", entity.name, fields));
+        methods.push(this.makeCrudMethod("delete", entity.name, fields));
+        methods.push(this.makeCrudMethod("list", entity.name, fields));
+        // Capability-derived methods
+        for (const cap of capabilities) {
+            methods.push(this.lowerCapability(cap));
+        }
+        const iface = {
+            name: `I${entity.name}Service`,
+            methods,
+        };
+        // Find related store
+        const relatedStore = stores.find(s => s.name.toLowerCase().includes(entity.name.toLowerCase()));
+        const deps = [];
+        if (relatedStore) {
+            deps.push(makeId(this.systemName, "data_store", relatedStore.name));
+        }
+        // Lower relations
+        const relations = entity.relations.map(rel => {
+            const fromTable = toSnakeCase(entity.name) + "s";
+            const toTable = toSnakeCase(rel.target) + "s";
+            let foreignKey;
+            let junctionTable;
+            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,
+            };
+        });
+        return {
+            id: moduleId,
+            kind: "api_service",
+            name: `${entity.name}Service`,
+            interfaces: [iface],
+            models: [model],
+            events: [],
+            state_machines: stateMachines,
+            relations,
+            dependencies: deps,
+            config: {
+                authenticated: entity.auth !== null && entity.auth !== "none",
+                auth_method: entity.auth || "none",
+            },
+        };
+    }
+    makeCrudMethod(op, entityName, fields) {
+        const input = 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,
+        };
+    }
+    lowerCapability(cap) {
+        const input = cap.params.map(p => ({
+            name: p.name,
+            type: serializeType(p.type),
+            nullable: false,
+            unique: false,
+            indexed: false,
+            default_value: null,
+        }));
+        const preconditions = cap.requires.map(r => ({
+            expression: serializeExpr(r),
+            description: serializeExpr(r),
+        }));
+        const effects = cap.effects.map(e => ({
+            target: e.target.path.join("."),
+            op: e.op === "=" ? "assign" : e.op === "+=" ? "add" : "remove",
+            value: serializeExpr(e.value),
+        }));
+        const emissions = cap.emits.map(e => e.eventName);
+        // Lower pipeline if present
+        let pipeline = 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,
+            };
+        }
+        // Lower algorithm if present
+        let algorithm = 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,
+            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 || "exponential",
+                interval_ms: parseDurationMs(cap.retry.interval) || 1000,
+            } : null,
+            pipeline,
+            algorithm,
+            sync: cap.sync,
+        };
+    }
+    // ─── Channel Lowering ──────────────────────────────────────────────────────
+    lowerChannel(channel) {
+        return {
+            id: makeId(this.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 ────────────────────────────────────────────────────────
+    lowerEvent(ev) {
+        return {
+            id: makeId(this.systemName, "event", ev.name),
+            name: ev.name,
+            payload: ev.payload.map(f => this.lowerField(f)),
+            source: "unknown", // resolved during dependency resolution
+            delivery: ev.delivery || "at_least_once",
+            ordering: "fifo",
+            ttl_ms: parseDurationMs(ev.ttl),
+        };
+    }
+    // ─── Flow Lowering ─────────────────────────────────────────────────────────
+    lowerFlow(flow) {
+        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,
+            })),
+        };
+    }
+    // ─── Field Lowering ────────────────────────────────────────────────────────
+    lowerField(f) {
+        return {
+            name: f.name,
+            type: serializeType(f.type),
+            nullable: f.type.kind === "GenericType" && f.type.name === "optional",
+            unique: false,
+            indexed: false,
+            default_value: f.defaultValue ? serializeExpr(f.defaultValue) : null,
+        };
+    }
 }
 exports.Lowering = Lowering;
 //# sourceMappingURL=lowering.js.map