bonescript-compiler 0.5.8 → 0.6.1

package/src/emit_websocket.ts

@@ -29,7 +29,23 @@ export function emitWebSocketServer(system: IR.IRSystem): string {
   lines.push(`import { eventBus } from "./events";`);
   lines.push(`import { logger } from "./logger";`);
   lines.push(``);
-  lines.push(`const JWT_SECRET = process.env.JWT_SECRET || "bonescript-dev-secret-change-in-production";`);
+  // Use the same secret-loading rules as the HTTP middleware.
+  // Refuse to boot in production without JWT_SECRET; warn in dev.
+  lines.push(`const JWT_SECRET = (() => {`);
+  lines.push(`  const secret = process.env.JWT_SECRET;`);
+  lines.push(`  if (!secret) {`);
+  lines.push(`    if (process.env.NODE_ENV === "production") {`);
+  lines.push(`      console.error("[FATAL] JWT_SECRET environment variable is not set. Refusing to start in production.");`);
+  lines.push(`      process.exit(1);`);
+  lines.push(`    }`);
+  lines.push(`    console.warn("[WARN] JWT_SECRET is not set. Using insecure default — do not use in production.");`);
+  lines.push(`    return "bonescript-dev-secret-do-not-use-in-production";`);
+  lines.push(`  }`);
+  lines.push(`  if (secret.length < 32) {`);
+  lines.push(`    console.warn("[WARN] JWT_SECRET is shorter than 32 characters. Use a longer secret in production.");`);
+  lines.push(`  }`);
+  lines.push(`  return secret;`);
+  lines.push(`})();`);
   lines.push(``);
   // Redis pub/sub for multi-instance support
   lines.push(`// Redis pub/sub for multi-instance WebSocket broadcasting`);
@@ -117,7 +133,11 @@ export function emitWebSocketServer(system: IR.IRSystem): string {
   lines.push(``);
   lines.push(`    let userId: string;`);
   lines.push(`    try {`);
-  lines.push(`      const decoded = jwt.verify(token, JWT_SECRET) as { sub: string };`);
+  lines.push(`      const decoded = jwt.verify(token, JWT_SECRET, {`);
+  lines.push(`        algorithms: ["HS256"],`);
+  lines.push(`        maxAge: process.env.JWT_MAX_AGE || "1h",`);
+  lines.push(`      }) as { sub?: unknown };`);
+  lines.push(`      if (typeof decoded.sub !== "string" || decoded.sub.length === 0) throw new Error("invalid sub");`);
   lines.push(`      userId = decoded.sub;`);
   lines.push(`    } catch {`);
   lines.push(`      socket.send(JSON.stringify({ type: "error", message: "Authentication failed" }));`);

package/src/emit_zod.ts

@@ -62,9 +62,13 @@ export function emitZodSchemas(system: IR.IRSystem): string {
   lines.push(`import { z } from "zod";`);
   lines.push("");
 
-  // Model schemas
+  // Model schemas — dedupe by name since the same entity can appear in both
+  // an api_service module and its backing data_store module.
+  const seenModels = new Set<string>();
   for (const mod of system.modules) {
     for (const model of mod.models) {
+      if (seenModels.has(model.name)) continue;
+      seenModels.add(model.name);
       const schemaName = toPascalCase(model.name) + "Schema";
       const typeName = toPascalCase(model.name);
 
@@ -79,6 +83,12 @@ export function emitZodSchemas(system: IR.IRSystem): string {
       }
       lines.push(`});`);
       lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
+      // Derived schemas for CRUD validation. `omit` drops server-managed fields
+      // and `partial` makes every key optional for PUT.
+      const hasState = model.fields.some(f => f.name === "state");
+      const createPartial = hasState ? ".partial({ state: true })" : "";
+      lines.push(`export const ${toPascalCase(model.name)}CreateSchema = ${schemaName}.omit({ id: true, created_at: true, updated_at: true })${createPartial};`);
+      lines.push(`export const ${toPascalCase(model.name)}UpdateSchema = ${schemaName}.omit({ id: true, created_at: true, updated_at: true }).partial();`);
       lines.push("");
     }
   }

package/src/formatter.ts

@@ -76,7 +76,7 @@ export class Formatter {
 
     if (e.owns.length > 0) {
       if (e.owns.length <= 2) {
-        const fields = e.owns.map(f => `${f.name}: ${this.formatType(f.type)}`).join(", ");
+        const fields = e.owns.map(f => this.formatField(f)).join(", ");
         this.line(`owns: [${fields}]`);
       } else {
         this.line(`owns: [`);
@@ -84,7 +84,7 @@ export class Formatter {
         for (let i = 0; i < e.owns.length; i++) {
           const f = e.owns[i];
           const comma = i < e.owns.length - 1 ? "," : "";
-          this.line(`${f.name}: ${this.formatType(f.type)}${comma}`);
+          this.line(`${this.formatField(f)}${comma}`);
         }
         this.indent--;
         this.line(`]`);
@@ -264,6 +264,13 @@ export class Formatter {
     }
   }
 
+  private formatField(f: AST.FieldNode): string {
+    let s = `${f.name}: ${this.formatType(f.type)}`;
+    if (f.renamedFrom) s += ` @renamed_from(${f.renamedFrom})`;
+    if (f.sensitive) s += ` @sensitive`;
+    return s;
+  }
+
   private formatExpr(e: AST.ExprNode): string {
     switch (e.kind) {
       case "Literal":

package/src/ir.ts

@@ -17,6 +17,8 @@ export interface IRField {
   unique: boolean;
   indexed: boolean;
   default_value: string | null;
+  renamed_from?: string | null;
+  sensitive?: boolean;
 }
 
 // ─── Models ──────────────────────────────────────────────────────────────────

package/src/lexer.ts

@@ -25,6 +25,7 @@ export enum TokenKind {
   Arrow = "Arrow",
   Pipe = "Pipe",
   Semicolon = "Semicolon",
+  At = "At",
 
   // Operators
   Equals = "Equals",
@@ -519,6 +520,7 @@ export class Lexer {
       case "?": this.advance(); return { kind: TokenKind.Question, value: "?", loc };
       case "!": this.advance(); return { kind: TokenKind.Bang, value: "!", loc };
       case ";": this.advance(); return { kind: TokenKind.Semicolon, value: ";", loc };
+      case "@": this.advance(); return { kind: TokenKind.At, value: "@", loc };
     }
 
     // String literal

package/src/lowering.ts

@@ -380,9 +380,9 @@ export class Lowering {
       config: {
         authenticated: entity.auth !== null && entity.auth !== "none",
         auth_method: entity.auth || "none",
-        audit: policies.some(p => p.audit === true),
-        rate_limit: policies.length > 0 && policies[0].rateLimit ? policies[0].rateLimit.count : 0,
-        rate_limit_window_ms: policies.length > 0 && policies[0].rateLimit ? (parseDurationMs(String(policies[0].rateLimit.per)) || 60000) : 60000,
+        audit: policies.some(p => p.audit === true),
+        rate_limit: policies.length > 0 && policies[0].rateLimit ? policies[0].rateLimit.count : 0,
+        rate_limit_window_ms: policies.length > 0 && policies[0].rateLimit ? (parseDurationMs(String(policies[0].rateLimit.per)) || 60000) : 60000,
       },
     };
   }
@@ -554,6 +554,8 @@ export class Lowering {
       unique: false,
       indexed: false,
       default_value: f.defaultValue ? serializeExpr(f.defaultValue) : null,
+      renamed_from: f.renamedFrom ?? null,
+      sensitive: f.sensitive ?? false,
     };
   }
 }

package/src/parse_decls.ts

@@ -33,7 +33,37 @@ export function parseField(s: TokenStream): AST.FieldNode {
   const type = parseTypeExpr(s);
   let defaultValue: AST.ExprNode | null = null;
   if (s.match(TokenKind.Equals)) { defaultValue = parseExpr(s); }
-  return { kind: "Field", loc, name, type, defaultValue };
+  // Optional annotations: @renamed_from(old_name), @sensitive
+  let renamedFrom: string | null = null;
+  let sensitive = false;
+  while (s.check(TokenKind.At)) {
+    s.advance();
+    const annoName = parseIdentOrKeyword(s);
+    if (annoName === "renamed_from") {
+      s.expect(TokenKind.LParen, "renamed_from(old_name)");
+      renamedFrom = parseIdentOrKeyword(s);
+      s.expect(TokenKind.RParen, "renamed_from close");
+    } else if (annoName === "sensitive") {
+      // Bare flag annotation. Optional empty parens for forward compat.
+      sensitive = true;
+      if (s.match(TokenKind.LParen)) {
+        s.expect(TokenKind.RParen, "sensitive close");
+      }
+    } else {
+      // Unknown annotation — accept and ignore for forward compat; consume
+      // an optional (...) payload so it parses cleanly.
+      if (s.match(TokenKind.LParen)) {
+        let depth = 1;
+        while (depth > 0 && !s.check(TokenKind.EOF)) {
+          if (s.check(TokenKind.LParen)) depth++;
+          else if (s.check(TokenKind.RParen)) depth--;
+          if (depth > 0) s.advance();
+        }
+        s.expect(TokenKind.RParen, "annotation close");
+      }
+    }
+  }
+  return { kind: "Field", loc, name, type, defaultValue, renamedFrom, sensitive };
 }
 
 export function parseIdentList(s: TokenStream): string[] {

package/src/typechecker.ts

@@ -404,6 +404,16 @@ export class TypeChecker {
     const path = expr.path;
     if (path.length === 0) return null;
 
+    // Built-in: `caller` resolves to the authenticated actor's identity.
+    // `caller.id` is a uuid; bare `caller` is a record { id: uuid } for now.
+    if (path[0] === "caller") {
+      const callerType = record("Caller", new Map([
+        ["id", prim("uuid")],
+        ["actor_id", prim("uuid")],
+      ]));
+      return this.resolveFieldPath(callerType, path.slice(1), expr);
+    }
+
     // First segment: look up in context
     let currentType = ctx.lookup(path[0]);