bonecode 1.0.0 → 1.1.0

package/bone/output/workspace/src/debug.ts

@@ -1,66 +1,66 @@
-// Generated by BoneScript compiler. DO NOT EDIT.
-// Runtime error handler with .bone source annotation.
-
-import * as fs from "fs";
-import * as path from "path";
-
-interface BoneMapping {
-  generated_file: string;
-  generated_line: number;
-  bone_line: number;
-  bone_column: number;
-  description: string;
-}
-
-interface BoneSourceMap {
-  version: number;
-  source_hash: string;
-  source_file: string;
-  mappings: BoneMapping[];
-}
-
-let sourceMap: BoneSourceMap | null = null;
-
-function loadSourceMap(): BoneSourceMap | null {
-  if (sourceMap) return sourceMap;
-  const mapPath = path.join(__dirname, "..", "WorkspaceDomain.bone.map");
-  if (!fs.existsSync(mapPath)) return null;
-  try {
-    sourceMap = JSON.parse(fs.readFileSync(mapPath, "utf-8"));
-    return sourceMap;
-  } catch {
-    return null;
-  }
-}
-
-export function annotateBoneError(err: Error, generatedFile: string): string {
-  const map = loadSourceMap();
-  if (!map) return err.stack || err.message;
-
-  // Extract line number from stack trace
-  const lineMatch = err.stack?.match(new RegExp(generatedFile.replace(/[/\\]/g, "[/\\\\]") + ":(\\d+)"));
-  if (!lineMatch) return err.stack || err.message;
-
-  const generatedLine = parseInt(lineMatch[1], 10);
-  const mapping = map.mappings
-    .filter(m => m.generated_file.includes(generatedFile) && m.generated_line <= generatedLine)
-    .sort((a, b) => b.generated_line - a.generated_line)[0];
-
-  if (!mapping) return err.stack || err.message;
-
-  return [
-    `BoneScript source: ${map.source_file}:${mapping.bone_line}:${mapping.bone_column}`,
-    `  Context: ${mapping.description}`,
-    `Generated TS: ${generatedFile}:${generatedLine}`,
-    ``,
-    err.stack || err.message,
-  ].join("\n");
-}
-
-// Global error handler — annotates unhandled errors with .bone context
-process.on("uncaughtException", (err: Error) => {
-  const annotated = annotateBoneError(err, err.stack?.split("\n")[1]?.match(/\((.+):\d+:\d+\)/)?.[1] || "");
-  console.error("[BoneScript] Unhandled error:");
-  console.error(annotated);
-  // process.exit(1); // disabled - errors should not crash the server
-});
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Runtime error handler with .bone source annotation.
+
+import * as fs from "fs";
+import * as path from "path";
+
+interface BoneMapping {
+  generated_file: string;
+  generated_line: number;
+  bone_line: number;
+  bone_column: number;
+  description: string;
+}
+
+interface BoneSourceMap {
+  version: number;
+  source_hash: string;
+  source_file: string;
+  mappings: BoneMapping[];
+}
+
+let sourceMap: BoneSourceMap | null = null;
+
+function loadSourceMap(): BoneSourceMap | null {
+  if (sourceMap) return sourceMap;
+  const mapPath = path.join(__dirname, "..", "WorkspaceDomain.bone.map");
+  if (!fs.existsSync(mapPath)) return null;
+  try {
+    sourceMap = JSON.parse(fs.readFileSync(mapPath, "utf-8"));
+    return sourceMap;
+  } catch {
+    return null;
+  }
+}
+
+export function annotateBoneError(err: Error, generatedFile: string): string {
+  const map = loadSourceMap();
+  if (!map) return err.stack || err.message;
+
+  // Extract line number from stack trace
+  const lineMatch = err.stack?.match(new RegExp(generatedFile.replace(/[/\\]/g, "[/\\\\]") + ":(\\d+)"));
+  if (!lineMatch) return err.stack || err.message;
+
+  const generatedLine = parseInt(lineMatch[1], 10);
+  const mapping = map.mappings
+    .filter(m => m.generated_file.includes(generatedFile) && m.generated_line <= generatedLine)
+    .sort((a, b) => b.generated_line - a.generated_line)[0];
+
+  if (!mapping) return err.stack || err.message;
+
+  return [
+    `BoneScript source: ${map.source_file}:${mapping.bone_line}:${mapping.bone_column}`,
+    `  Context: ${mapping.description}`,
+    `Generated TS: ${generatedFile}:${generatedLine}`,
+    ``,
+    err.stack || err.message,
+  ].join("\n");
+}
+
+// Global error handler — annotates unhandled errors with .bone context
+process.on("uncaughtException", (err: Error) => {
+  const annotated = annotateBoneError(err, err.stack?.split("\n")[1]?.match(/\((.+):\d+:\d+\)/)?.[1] || "");
+  console.error("[BoneScript] Unhandled error:");
+  console.error(annotated);
+  // process.exit(1); // disabled - errors should not crash the server
+});

package/bone/output/workspace/src/events.ts

@@ -1,243 +1,243 @@
-// Generated by BoneScript compiler. DO NOT EDIT.
-// Durable event bus with transactional outbox pattern.
-// Set EVENT_MODE=durable in .env to enable.
-
-import { Pool, PoolClient } from "pg";
-import { v4 as uuid } from "uuid";
-import { pool } from "./db";
-import { logger } from "./logger";
-import { counter } from "./metrics";
-
-export type EventDeliveryMode = "in_process" | "durable";
-
-const MODE: EventDeliveryMode =
-  (process.env.EVENT_MODE as EventDeliveryMode) || "in_process";
-
-// Events requiring exactly_once delivery (deduplicated)
-const EXACTLY_ONCE_EVENTS = new Set<string>(["SnapshotCreated"]);
-
-// Events requiring at_least_once delivery (retried until ack)
-const AT_LEAST_ONCE_EVENTS = new Set<string>(["WorkspaceInitialized"]);
-
-export interface EventMetadata {
-  source: string;
-  timestamp: Date;
-  correlation_id: string;
-  causation_id: string;
-}
-
-export interface SystemEvent {
-  type: string;
-  payload: Record<string, unknown>;
-  metadata: EventMetadata;
-}
-
-type Handler = (event: SystemEvent) => Promise<void>;
-
-// ─── In-Process Bus ──────────────────────────────────────────────────────────
-
-class InProcessBus {
-  private handlers: Map<string, Handler[]> = new Map();
-
-  subscribe(type: string, handler: Handler): void {
-    const existing = this.handlers.get(type) || [];
-    existing.push(handler);
-    this.handlers.set(type, existing);
-  }
-
-  async publish(type: string, payload: Record<string, unknown>, source: string, correlationId?: string): Promise<void> {
-    const event: SystemEvent = {
-      type,
-      payload,
-      metadata: {
-        source,
-        timestamp: new Date(),
-        correlation_id: correlationId || uuid(),
-        causation_id: uuid(),
-      },
-    };
-    counter("event.published", { type, mode: "in_process" });
-    const handlers = this.handlers.get(type) || [];
-    for (const handler of handlers) {
-      try {
-        await handler(event);
-        counter("event.delivered", { type, mode: "in_process" });
-      } catch (e: any) {
-        counter("event.delivery_failed", { type, mode: "in_process" });
-        logger.error("event_handler_failed", { event: type, metadata: { error: e.message } });
-      }
-    }
-  }
-}
-
-// ─── Durable Bus (Transactional Outbox) ──────────────────────────────────────
-
-class DurableBus {
-  private handlers: Map<string, Handler[]> = new Map();
-
-  subscribe(type: string, handler: Handler): void {
-    const existing = this.handlers.get(type) || [];
-    existing.push(handler);
-    this.handlers.set(type, existing);
-  }
-
-  // Write event to outbox within the current transaction (or a new one)
-  async publish(
-    type: string,
-    payload: Record<string, unknown>,
-    source: string,
-    correlationId?: string,
-    client?: PoolClient
-  ): Promise<void> {
-    const eventId = uuid();
-    const corrId = correlationId || uuid();
-    const sql = `
-      INSERT INTO event_outbox (id, event_type, payload, source, correlation_id)
-      VALUES ($1, $2, $3, $4, $5)
-    `;
-    const params = [eventId, type, JSON.stringify({ ...payload, _event_id: eventId }), source, corrId];
-
-    if (client) {
-      // Write within caller's transaction — atomicity guaranteed
-      await client.query(sql, params);
-    } else {
-      await pool.query(sql, params);
-    }
-    counter("event.outboxed", { type });
-  }
-
-  // Called by the background worker
-  async flush(): Promise<void> {
-    const client = await pool.connect();
-    try {
-      await client.query("BEGIN");
-
-      // Fetch pending events (lock rows to prevent concurrent processing)
-      const { rows } = await client.query(`
-        SELECT id, event_type, payload, source, correlation_id, attempts
-        FROM event_outbox
-        WHERE status = 'pending' AND scheduled_at <= NOW()
-        ORDER BY scheduled_at ASC
-        LIMIT 50
-        FOR UPDATE SKIP LOCKED
-      `);
-
-      for (const row of rows) {
-        try {
-          // exactly_once: check deduplication table
-          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
-            const { rows: dup } = await client.query(
-              "SELECT 1 FROM event_processed WHERE event_id = $1",
-              [row.payload._event_id || row.id]
-            );
-            if (dup.length > 0) {
-              await client.query(
-                "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW() WHERE id = $1",
-                [row.id]
-              );
-              continue;
-            }
-          }
-
-          const event: SystemEvent = {
-            type: row.event_type,
-            payload: row.payload,
-            metadata: {
-              source: row.source,
-              timestamp: new Date(),
-              correlation_id: row.correlation_id,
-              causation_id: uuid(),
-            },
-          };
-
-          const handlers = this.handlers.get(row.event_type) || [];
-          for (const handler of handlers) {
-            await handler(event);
-          }
-
-          // Mark delivered
-          await client.query(
-            "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW(), attempts = attempts + 1 WHERE id = $1",
-            [row.id]
-          );
-
-          // Record for exactly_once deduplication
-          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
-            await client.query(
-              "INSERT INTO event_processed (event_id, event_type) VALUES ($1, $2) ON CONFLICT DO NOTHING",
-              [row.payload._event_id || row.id, row.event_type]
-            );
-          }
-
-          counter("event.delivered", { type: row.event_type, mode: "durable" });
-        } catch (e: any) {
-          const maxAttempts = AT_LEAST_ONCE_EVENTS.has(row.event_type) ? 10 : 3;
-          const newAttempts = row.attempts + 1;
-          const status = newAttempts >= maxAttempts ? "dead_letter" : "pending";
-          const backoffMs = Math.min(1000 * Math.pow(2, newAttempts), 300000);
-          await client.query(
-            `UPDATE event_outbox
-             SET attempts = $1, last_error = $2, status = $3,
-                 scheduled_at = NOW() + ($4 || ' milliseconds')::interval
-             WHERE id = $5`,
-            [newAttempts, e.message, status, backoffMs, row.id]
-          );
-          counter("event.delivery_failed", { type: row.event_type, mode: "durable" });
-          logger.error("event_delivery_failed", { event: row.event_type, metadata: { error: e.message, attempts: newAttempts } });
-        }
-      }
-
-      await client.query("COMMIT");
-    } catch (e) {
-      await client.query("ROLLBACK");
-      throw e;
-    } finally {
-      client.release();
-    }
-  }
-
-  // Start background worker
-  startWorker(intervalMs: number = 1000): NodeJS.Timeout {
-    logger.info("event_worker_started", { event: "startup", metadata: { interval_ms: intervalMs } });
-    return setInterval(async () => {
-      try {
-        await this.flush();
-      } catch (e: any) {
-        logger.error("event_worker_error", { event: "flush_failed", metadata: { error: e.message } });
-      }
-    }, intervalMs);
-  }
-}
-
-// ─── Unified Interface ────────────────────────────────────────────────────────
-
-const inProcess = new InProcessBus();
-const durable = new DurableBus();
-
-export const eventBus = {
-  subscribe(type: string, handler: Handler): void {
-    inProcess.subscribe(type, handler);
-    durable.subscribe(type, handler);
-  },
-
-  async publish(
-    type: string,
-    payload: Record<string, unknown>,
-    source: string,
-    correlationId?: string,
-    client?: PoolClient
-  ): Promise<void> {
-    if (MODE === "durable") {
-      await durable.publish(type, payload, source, correlationId, client);
-    } else {
-      await inProcess.publish(type, payload, source, correlationId);
-    }
-  },
-
-  startWorker(intervalMs?: number): NodeJS.Timeout | null {
-    if (MODE === "durable") {
-      return durable.startWorker(intervalMs);
-    }
-    return null;
-  },
-};
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Durable event bus with transactional outbox pattern.
+// Set EVENT_MODE=durable in .env to enable.
+
+import { Pool, PoolClient } from "pg";
+import { v4 as uuid } from "uuid";
+import { pool } from "./db";
+import { logger } from "./logger";
+import { counter } from "./metrics";
+
+export type EventDeliveryMode = "in_process" | "durable";
+
+const MODE: EventDeliveryMode =
+  (process.env.EVENT_MODE as EventDeliveryMode) || "in_process";
+
+// Events requiring exactly_once delivery (deduplicated)
+const EXACTLY_ONCE_EVENTS = new Set<string>(["SnapshotCreated"]);
+
+// Events requiring at_least_once delivery (retried until ack)
+const AT_LEAST_ONCE_EVENTS = new Set<string>(["WorkspaceInitialized"]);
+
+export interface EventMetadata {
+  source: string;
+  timestamp: Date;
+  correlation_id: string;
+  causation_id: string;
+}
+
+export interface SystemEvent {
+  type: string;
+  payload: Record<string, unknown>;
+  metadata: EventMetadata;
+}
+
+type Handler = (event: SystemEvent) => Promise<void>;
+
+// ─── In-Process Bus ──────────────────────────────────────────────────────────
+
+class InProcessBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  async publish(type: string, payload: Record<string, unknown>, source: string, correlationId?: string): Promise<void> {
+    const event: SystemEvent = {
+      type,
+      payload,
+      metadata: {
+        source,
+        timestamp: new Date(),
+        correlation_id: correlationId || uuid(),
+        causation_id: uuid(),
+      },
+    };
+    counter("event.published", { type, mode: "in_process" });
+    const handlers = this.handlers.get(type) || [];
+    for (const handler of handlers) {
+      try {
+        await handler(event);
+        counter("event.delivered", { type, mode: "in_process" });
+      } catch (e: any) {
+        counter("event.delivery_failed", { type, mode: "in_process" });
+        logger.error("event_handler_failed", { event: type, metadata: { error: e.message } });
+      }
+    }
+  }
+}
+
+// ─── Durable Bus (Transactional Outbox) ──────────────────────────────────────
+
+class DurableBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  // Write event to outbox within the current transaction (or a new one)
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    const eventId = uuid();
+    const corrId = correlationId || uuid();
+    const sql = `
+      INSERT INTO event_outbox (id, event_type, payload, source, correlation_id)
+      VALUES ($1, $2, $3, $4, $5)
+    `;
+    const params = [eventId, type, JSON.stringify({ ...payload, _event_id: eventId }), source, corrId];
+
+    if (client) {
+      // Write within caller's transaction — atomicity guaranteed
+      await client.query(sql, params);
+    } else {
+      await pool.query(sql, params);
+    }
+    counter("event.outboxed", { type });
+  }
+
+  // Called by the background worker
+  async flush(): Promise<void> {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+
+      // Fetch pending events (lock rows to prevent concurrent processing)
+      const { rows } = await client.query(`
+        SELECT id, event_type, payload, source, correlation_id, attempts
+        FROM event_outbox
+        WHERE status = 'pending' AND scheduled_at <= NOW()
+        ORDER BY scheduled_at ASC
+        LIMIT 50
+        FOR UPDATE SKIP LOCKED
+      `);
+
+      for (const row of rows) {
+        try {
+          // exactly_once: check deduplication table
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            const { rows: dup } = await client.query(
+              "SELECT 1 FROM event_processed WHERE event_id = $1",
+              [row.payload._event_id || row.id]
+            );
+            if (dup.length > 0) {
+              await client.query(
+                "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW() WHERE id = $1",
+                [row.id]
+              );
+              continue;
+            }
+          }
+
+          const event: SystemEvent = {
+            type: row.event_type,
+            payload: row.payload,
+            metadata: {
+              source: row.source,
+              timestamp: new Date(),
+              correlation_id: row.correlation_id,
+              causation_id: uuid(),
+            },
+          };
+
+          const handlers = this.handlers.get(row.event_type) || [];
+          for (const handler of handlers) {
+            await handler(event);
+          }
+
+          // Mark delivered
+          await client.query(
+            "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW(), attempts = attempts + 1 WHERE id = $1",
+            [row.id]
+          );
+
+          // Record for exactly_once deduplication
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            await client.query(
+              "INSERT INTO event_processed (event_id, event_type) VALUES ($1, $2) ON CONFLICT DO NOTHING",
+              [row.payload._event_id || row.id, row.event_type]
+            );
+          }
+
+          counter("event.delivered", { type: row.event_type, mode: "durable" });
+        } catch (e: any) {
+          const maxAttempts = AT_LEAST_ONCE_EVENTS.has(row.event_type) ? 10 : 3;
+          const newAttempts = row.attempts + 1;
+          const status = newAttempts >= maxAttempts ? "dead_letter" : "pending";
+          const backoffMs = Math.min(1000 * Math.pow(2, newAttempts), 300000);
+          await client.query(
+            `UPDATE event_outbox
+             SET attempts = $1, last_error = $2, status = $3,
+                 scheduled_at = NOW() + ($4 || ' milliseconds')::interval
+             WHERE id = $5`,
+            [newAttempts, e.message, status, backoffMs, row.id]
+          );
+          counter("event.delivery_failed", { type: row.event_type, mode: "durable" });
+          logger.error("event_delivery_failed", { event: row.event_type, metadata: { error: e.message, attempts: newAttempts } });
+        }
+      }
+
+      await client.query("COMMIT");
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+  }
+
+  // Start background worker
+  startWorker(intervalMs: number = 1000): NodeJS.Timeout {
+    logger.info("event_worker_started", { event: "startup", metadata: { interval_ms: intervalMs } });
+    return setInterval(async () => {
+      try {
+        await this.flush();
+      } catch (e: any) {
+        logger.error("event_worker_error", { event: "flush_failed", metadata: { error: e.message } });
+      }
+    }, intervalMs);
+  }
+}
+
+// ─── Unified Interface ────────────────────────────────────────────────────────
+
+const inProcess = new InProcessBus();
+const durable = new DurableBus();
+
+export const eventBus = {
+  subscribe(type: string, handler: Handler): void {
+    inProcess.subscribe(type, handler);
+    durable.subscribe(type, handler);
+  },
+
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    if (MODE === "durable") {
+      await durable.publish(type, payload, source, correlationId, client);
+    } else {
+      await inProcess.publish(type, payload, source, correlationId);
+    }
+  },
+
+  startWorker(intervalMs?: number): NodeJS.Timeout | null {
+    if (MODE === "durable") {
+      return durable.startWorker(intervalMs);
+    }
+    return null;
+  },
+};