bonescript-compiler 0.5.7 → 0.6.0

package/src/emit_full.ts

@@ -39,15 +39,24 @@ import { emitPostmanCollection } from "./emit_postman";
 import { emitSeedFile } from "./emit_seed";
 import { emitAuditSchema, emitAuditMiddleware } from "./emit_audit";
 import { emitAdminPanel } from "./emit_admin";
+import { emitNotifyService } from "./emit_notify";
+import { emitCronJobs } from "./emit_cron";
+import { emitGraphQLSchema } from "./emit_graphql";
 
 function toSnakeCase(s: string): string {
   return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
 }
 
+export interface FullEmitterOptions {
+  noSdk?: boolean;
+  noOpenApi?: boolean;
+  noSeed?: boolean;
+}
+
 export class FullEmitter {
   private schemaEmitter = new Emitter();
 
-  emit(system: IR.IRSystem): EmittedFile[] {
+  emit(system: IR.IRSystem, options: FullEmitterOptions = {}): EmittedFile[] {
     const files: EmittedFile[] = [];
 
     // 1. Package files
@@ -163,15 +172,22 @@ export class FullEmitter {
     // 5. Source: main entry point
     files.push({ path: "src/index.ts", content: emitIndex(system), language: "typescript", source_module: "root" });
 
-    // 6. SQL migrations — run schema emitter ONCE, then match by model name
+    // 6. SQL migrations — run schema emitter ONCE, then match by model name.
+    // Multiple modules (e.g. an api_service AND its backing data_store) can
+    // reference the same model. We dedupe by output path so each table only
+    // appears once in migrations/ and once in the migrate.ts blocks list.
     const schemas: string[] = [];
+    const seenPaths = new Set<string>();
     const allSchemaFiles = this.schemaEmitter.emit(system);
     for (const mod of system.modules) {
       if (mod.kind === "data_store" || mod.kind === "api_service") {
         for (const model of mod.models) {
           const schemaFile = allSchemaFiles.find(f => f.path.includes(toSnakeCase(model.name)) && f.language === "sql");
           if (schemaFile) {
-            files.push({ ...schemaFile, path: `migrations/${schemaFile.path.replace("schema/", "")}` });
+            const targetPath = `migrations/${schemaFile.path.replace("schema/", "")}`;
+            if (seenPaths.has(targetPath)) continue;
+            seenPaths.add(targetPath);
+            files.push({ ...schemaFile, path: targetPath });
             schemas.push(schemaFile.content);
           }
         }
@@ -188,24 +204,40 @@ export class FullEmitter {
     files.push({ path: "README.md", content: this.emitReadme(system), language: "yaml", source_module: "root" });
 
     // 12. OpenAPI spec
-    files.push({ path: "openapi.yaml", content: emitOpenApiSpec(system), language: "yaml", source_module: "docs" });
+    if (!options.noOpenApi) {
+      files.push({ path: "openapi.yaml", content: emitOpenApiSpec(system), language: "yaml", source_module: "docs" });
+      // GraphQL schema (alongside openapi)
+      files.push({ path: "schema.graphql", content: emitGraphQLSchema(system), language: "yaml", source_module: "docs" });
+    }
 
     // 13. TypeScript SDK
-    files.push({ path: "sdk/client.ts", content: emitTypescriptSdk(system), language: "typescript", source_module: "sdk" });
+    if (!options.noSdk) {
+      files.push({ path: "sdk/client.ts", content: emitTypescriptSdk(system), language: "typescript", source_module: "sdk" });
+    }
 
     // 14. Zod schemas
     files.push({ path: "src/schemas.ts", content: emitZodSchemas(system), language: "typescript", source_module: "validation" });
 
     // 15. Postman collection
-    files.push({ path: `${system.name}.postman_collection.json`, content: emitPostmanCollection(system), language: "json", source_module: "docs" });
+    if (!options.noOpenApi) {
+      files.push({ path: `${system.name}.postman_collection.json`, content: emitPostmanCollection(system), language: "json", source_module: "docs" });
+    }
 
     // 16. Seed file
-    files.push({ path: "src/seed.ts", content: emitSeedFile(system), language: "typescript", source_module: "dev" });
+    if (!options.noSeed) {
+      files.push({ path: "src/seed.ts", content: emitSeedFile(system), language: "typescript", source_module: "dev" });
+    }
 
     // 17. Audit log
     files.push({ path: "migrations/audit_log.sql", content: emitAuditSchema(), language: "sql", source_module: "infra" });
     files.push({ path: "src/audit.ts", content: emitAuditMiddleware(system), language: "typescript", source_module: "infra" });
 
+    // 18. Notification service
+    files.push({ path: "src/notify.ts", content: emitNotifyService(system), language: "typescript", source_module: "infra" });
+
+    // 19. Cron jobs
+    files.push({ path: "src/cron.ts", content: emitCronJobs(system), language: "typescript", source_module: "infra" });
+
     // 18. Admin panel
     files.push({ path: "admin/index.html", content: emitAdminPanel(system), language: "yaml", source_module: "admin" });
 
@@ -254,6 +286,12 @@ EVENT_WORKER_INTERVAL_MS=1000
 
 # --- Request timeout ---
 REQUEST_TIMEOUT_MS=30000
+
+# --- Notifications ---
+# NOTIFY_PROVIDER=log|resend|sendgrid (default: log)
+NOTIFY_PROVIDER=log
+NOTIFY_API_KEY=
+NOTIFY_FROM_EMAIL=noreply@example.com
 `;
   }
 

package/src/emit_graphql.ts

@@ -0,0 +1,161 @@
+/**
+ * BoneScript GraphQL Schema Emitter
+ * Generates schema.graphql from an IRSystem.
+ */
+
+import * as IR from "./ir";
+
+function toCamelCase(s: string): string {
+  return s.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+function toCamelCasePlural(s: string): string {
+  const camel = toCamelCase(s);
+  // Simple pluralisation: append 's' (good enough for generated stubs)
+  return camel.endsWith("s") ? camel : camel + "s";
+}
+
+function toGraphQLType(irType: string): string {
+  // Handle optional<X> — nullable in GraphQL (just unwrap, no !)
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return toGraphQLType(optMatch[1]);
+
+  // Handle list<X> / set<X>
+  const listMatch = irType.match(/^(list|set)<(.+)>$/);
+  if (listMatch) return `[${toGraphQLType(listMatch[2])}]`;
+
+  switch (irType) {
+    case "string":    return "String";
+    case "uint":
+    case "int":       return "Int";
+    case "float":     return "Float";
+    case "bool":      return "Boolean";
+    case "timestamp": return "String";
+    case "uuid":      return "ID";
+    case "bytes":     return "String";
+    case "json":      return "String";
+    default:          return "String";
+  }
+}
+
+function isOptional(irType: string): boolean {
+  return irType.startsWith("optional<");
+}
+
+function fieldLine(field: IR.IRField): string {
+  const gqlType = toGraphQLType(field.type);
+  const nullable = isOptional(field.type) || field.nullable;
+  return `  ${field.name}: ${gqlType}${nullable ? "" : "!"}`;
+}
+
+export function emitGraphQLSchema(system: IR.IRSystem): string {
+  const lines: string[] = [];
+
+  lines.push(`# Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`# System: ${system.name} v${system.version}`);
+  lines.push(``);
+
+  // Collect all models from api_service modules
+  const apiModules = system.modules.filter(m => m.kind === "api_service" && m.models.length > 0);
+
+  const queryFields: string[] = [];
+  const mutationFields: string[] = [];
+  const extraTypes: string[] = [];
+
+  for (const mod of apiModules) {
+    const model = mod.models[0];
+    const modelName = model.name;
+    const camelName = toCamelCase(modelName.charAt(0).toLowerCase() + modelName.slice(1));
+    const camelPlural = toCamelCasePlural(modelName.charAt(0).toLowerCase() + modelName.slice(1));
+
+    // ─── type {ModelName} ───
+    lines.push(`type ${modelName} {`);
+    // Always include id, created_at, updated_at
+    lines.push(`  id: ID!`);
+    for (const field of model.fields) {
+      if (field.name === "id") continue; // already emitted
+      lines.push(fieldLine(field));
+    }
+    lines.push(`}`);
+    lines.push(``);
+
+    // ─── type {ModelName}Page ───
+    lines.push(`type ${modelName}Page {`);
+    lines.push(`  items: [${modelName}!]!`);
+    lines.push(`  total: Int!`);
+    lines.push(`  page: Int!`);
+    lines.push(`  pageSize: Int!`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // ─── input {ModelName}Input ───
+    const inputFields = model.fields.filter(
+      f => !["id", "created_at", "updated_at"].includes(f.name)
+    );
+    lines.push(`input ${modelName}Input {`);
+    for (const field of inputFields) {
+      lines.push(fieldLine(field));
+    }
+    lines.push(`}`);
+    lines.push(``);
+
+    // Capability inputs + results
+    const capabilities = mod.interfaces.flatMap(i => i.methods)
+      .filter(m => !["create", "read", "update", "delete", "list"].includes(m.name));
+
+    for (const cap of capabilities) {
+      const capPascal = cap.name.charAt(0).toUpperCase() + toCamelCase(cap.name).slice(1);
+      extraTypes.push(`input ${modelName}${capPascal}Input {`);
+      for (const param of cap.input) {
+        extraTypes.push(fieldLine(param));
+      }
+      extraTypes.push(`}`);
+      extraTypes.push(``);
+    }
+
+    // ─── Query fields ───
+    queryFields.push(`  ${camelName}(id: ID!): ${modelName}`);
+    queryFields.push(`  ${camelPlural}(page: Int, pageSize: Int): ${modelName}Page`);
+
+    // ─── Mutation fields ───
+    mutationFields.push(`  create${modelName}(input: ${modelName}Input!): ${modelName}!`);
+    mutationFields.push(`  update${modelName}(id: ID!, input: ${modelName}Input!): ${modelName}!`);
+    mutationFields.push(`  delete${modelName}(id: ID!): Boolean!`);
+
+    for (const cap of capabilities) {
+      const capCamel = toCamelCase(cap.name);
+      const capPascal = cap.name.charAt(0).toUpperCase() + capCamel.slice(1);
+      mutationFields.push(`  ${capCamel}(input: ${modelName}${capPascal}Input): CapabilityResult!`);
+    }
+  }
+
+  // ─── type CapabilityResult ───
+  lines.push(`type CapabilityResult {`);
+  lines.push(`  ok: Boolean!`);
+  lines.push(`  action: String!`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // ─── Extra capability input types ───
+  for (const l of extraTypes) {
+    lines.push(l);
+  }
+
+  // ─── type Query ───
+  lines.push(`type Query {`);
+  for (const f of queryFields) {
+    lines.push(f);
+  }
+  lines.push(`}`);
+  lines.push(``);
+
+  // ─── type Mutation ───
+  lines.push(`type Mutation {`);
+  for (const f of mutationFields) {
+    lines.push(f);
+  }
+  lines.push(`}`);
+  lines.push(``);
+
+  return lines.join("\n");
+}

package/src/emit_maintenance.ts

@@ -220,9 +220,29 @@ export function emitHealthChecks(system: IR.IRSystem): string {
   lines.push(`});`);
   lines.push(``);
 
-  // Metrics endpoint
-  lines.push(`// Prometheus-style metrics`);
-  lines.push(`healthRouter.get("/metrics", (_req: Request, res: Response) => {`);
+  // Metrics endpoint — restricted to internal callers.
+  // Accepted: shared bearer in METRICS_TOKEN, or loopback / RFC1918 source IPs.
+  // External scrapers must inject the bearer; otherwise 403.
+  lines.push(`// Prometheus-style metrics — restricted to internal callers`);
+  lines.push(`function isInternalMetricsRequest(req: Request): boolean {`);
+  lines.push(`  const expected = process.env.METRICS_TOKEN || "";`);
+  lines.push(`  if (expected) {`);
+  lines.push(`    const header = req.headers.authorization || "";`);
+  lines.push(`    if (header.startsWith("Bearer ") && header.slice(7) === expected) return true;`);
+  lines.push(`  }`);
+  lines.push(`  const ip = (req.ip || "").replace(/^::ffff:/, "");`);
+  lines.push(`  if (ip === "127.0.0.1" || ip === "::1") return true;`);
+  lines.push(`  if (ip.startsWith("10.") || ip.startsWith("192.168.")) return true;`);
+  lines.push(`  // RFC1918 172.16.0.0/12`);
+  lines.push(`  const m = ip.match(/^172\\.(\\d{1,3})\\./);`);
+  lines.push(`  if (m && +m[1] >= 16 && +m[1] <= 31) return true;`);
+  lines.push(`  return false;`);
+  lines.push(`}`);
+  lines.push(`healthRouter.get("/metrics", (req: Request, res: Response) => {`);
+  lines.push(`  if (!isInternalMetricsRequest(req)) {`);
+  lines.push(`    res.status(403).json({ error: { code: "FORBIDDEN", message: "Metrics restricted to internal callers" } });`);
+  lines.push(`    return;`);
+  lines.push(`  }`);
   lines.push(`  res.type("text/plain").send(dumpMetrics());`);
   lines.push(`});`);
   lines.push(``);
@@ -356,6 +376,7 @@ interface Field {
   name: string;
   type: string;
   nullable: boolean;
+  renamed_from?: string | null;
 }
 
 interface Model {
@@ -395,8 +416,18 @@ export function diffModels(oldModels: Model[], newModels: Model[]): string[] {
     const oldFields = new Map(oldModel.fields.map(f => [f.name, f]));
     const newFields = new Map(newModel.fields.map(f => [f.name, f]));
 
+    // Renames first — avoid double-counting as add+drop.
+    const renamedOld = new Set<string>();
+    for (const [fname, field] of newFields) {
+      if (field.renamed_from && oldFields.has(field.renamed_from) && !oldFields.has(fname)) {
+        statements.push(\`ALTER TABLE \${tableName} RENAME COLUMN \${field.renamed_from} TO \${fname};\`);
+        renamedOld.add(field.renamed_from);
+      }
+    }
+
     // New columns (backward-compatible)
     for (const [fname, field] of newFields) {
+      if (field.renamed_from && renamedOld.has(field.renamed_from)) continue;
       if (!oldFields.has(fname)) {
         const sqlType = mapType(field.type);
         const nullability = field.nullable ? "" : " NOT NULL DEFAULT (CASE WHEN false THEN NULL ELSE NULL END)";
@@ -406,6 +437,7 @@ export function diffModels(oldModels: Model[], newModels: Model[]): string[] {
 
     // Removed columns (NOT auto-dropped — backward compat)
     for (const [fname] of oldFields) {
+      if (renamedOld.has(fname)) continue;
       if (!newFields.has(fname)) {
         statements.push(\`-- WARNING: Column \${tableName}.\${fname} removed from schema. Run manually: ALTER TABLE \${tableName} DROP COLUMN \${fname};\`);
       }

package/src/emit_notify.ts

@@ -0,0 +1,88 @@
+/**
+ * BoneScript Notification Service Emitter
+ * Generates src/notify.ts — fires on event emissions.
+ */
+
+import * as IR from "./ir";
+
+function toPascalCase(s: string): string {
+  return s.replace(/(^|[-_\s])(\w)/g, (_, __, c: string) => c.toUpperCase());
+}
+
+export function emitNotifyService(system: IR.IRSystem): string {
+  const lines: string[] = [];
+
+  lines.push(`// Generated by BoneScript compiler.`);
+  lines.push(`// Notification service — fires on event emissions.`);
+  lines.push(`// Configure NOTIFY_PROVIDER=resend|sendgrid|log (default: log)`);
+  lines.push(`// Set NOTIFY_API_KEY and NOTIFY_FROM_EMAIL in .env`);
+  lines.push(``);
+  lines.push(`import { SystemEvent } from "./events";`);
+  lines.push(``);
+  lines.push(`export type NotifyProvider = "resend" | "sendgrid" | "log";`);
+  lines.push(``);
+  lines.push(`const PROVIDER = (process.env.NOTIFY_PROVIDER || "log") as NotifyProvider;`);
+  lines.push(`const API_KEY = process.env.NOTIFY_API_KEY || "";`);
+  lines.push(`const FROM_EMAIL = process.env.NOTIFY_FROM_EMAIL || "noreply@example.com";`);
+  lines.push(``);
+  lines.push(`export interface NotifyMessage {`);
+  lines.push(`  to: string;`);
+  lines.push(`  subject: string;`);
+  lines.push(`  body: string;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`async function sendEmail(msg: NotifyMessage): Promise<void> {`);
+  lines.push(`  if (PROVIDER === "log") {`);
+  lines.push(`    console.log(\`[notify] \${msg.subject} → \${msg.to}\`);`);
+  lines.push(`    return;`);
+  lines.push(`  }`);
+  lines.push(`  if (PROVIDER === "resend") {`);
+  lines.push(`    const res = await fetch("https://api.resend.com/emails", {`);
+  lines.push(`      method: "POST",`);
+  lines.push(`      headers: { "Authorization": \`Bearer \${API_KEY}\`, "Content-Type": "application/json" },`);
+  lines.push(`      body: JSON.stringify({ from: FROM_EMAIL, to: msg.to, subject: msg.subject, html: msg.body }),`);
+  lines.push(`    });`);
+  lines.push(`    if (!res.ok) throw new Error(\`Resend error: \${res.status}\`);`);
+  lines.push(`    return;`);
+  lines.push(`  }`);
+  lines.push(`  if (PROVIDER === "sendgrid") {`);
+  lines.push(`    const res = await fetch("https://api.sendgrid.com/v3/mail/send", {`);
+  lines.push(`      method: "POST",`);
+  lines.push(`      headers: { "Authorization": \`Bearer \${API_KEY}\`, "Content-Type": "application/json" },`);
+  lines.push(`      body: JSON.stringify({ personalizations: [{ to: [{ email: msg.to }] }], from: { email: FROM_EMAIL }, subject: msg.subject, content: [{ type: "text/html", value: msg.body }] }),`);
+  lines.push(`    });`);
+  lines.push(`    if (!res.ok) throw new Error(\`SendGrid error: \${res.status}\`);`);
+  lines.push(`    return;`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Per-event handlers
+  for (const event of system.events) {
+    const eventName = toPascalCase(event.name);
+    lines.push(`// Handler for ${eventName}`);
+    lines.push(`export async function notify${eventName}(event: SystemEvent, recipientEmail: string): Promise<void> {`);
+    lines.push(`  await sendEmail({`);
+    lines.push(`    to: recipientEmail,`);
+    lines.push(`    subject: "${eventName} notification",`);
+    lines.push(`    body: \`<p>Event <strong>${eventName}</strong> occurred.</p><pre>\${JSON.stringify(event.payload, null, 2)}</pre>\`,`);
+    lines.push(`  });`);
+    lines.push(`}`);
+    lines.push(``);
+  }
+
+  // registerNotificationHandlers
+  lines.push(`export function registerNotificationHandlers(eventBus: any): void {`);
+  lines.push(`  // TODO: implement recipient lookup per event type`);
+  for (const event of system.events) {
+    const eventName = toPascalCase(event.name);
+    lines.push(`  // eventBus.subscribe("${eventName}", async (event: SystemEvent) => {`);
+    lines.push(`  //   const recipientEmail = await lookupRecipient(event);`);
+    lines.push(`  //   await notify${eventName}(event, recipientEmail);`);
+    lines.push(`  // });`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+
+  return lines.join("\n");
+}