bonescript-compiler 0.5.4 → 0.5.6

package/src/emit_openapi.ts

@@ -0,0 +1,344 @@
+/**
+ * BoneScript OpenAPI Emitter
+ * Generates OpenAPI 3.0.3 YAML and JSON specs from an IRSystem.
+ */
+
+import * as IR from "./ir";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function toDashCase(s: string): string {
+  return toSnakeCase(s).replace(/_/g, "-");
+}
+
+function toPascalCase(s: string): string {
+  return s.replace(/(^|_)([a-z])/g, (_: string, _p: string, c: string) => c.toUpperCase());
+}
+
+function irTypeToOpenApi(irType: string): Record<string, unknown> {
+  if (irType === "string") return { type: "string" };
+  if (irType === "uint" || irType === "int") return { type: "integer" };
+  if (irType === "float") return { type: "number" };
+  if (irType === "bool") return { type: "boolean" };
+  if (irType === "timestamp") return { type: "string", format: "date-time" };
+  if (irType === "uuid") return { type: "string", format: "uuid" };
+  if (irType === "bytes") return { type: "string", format: "byte" };
+  if (irType === "json") return { type: "object" };
+  const listMatch = irType.match(/^list<(.+)>$/);
+  if (listMatch) return { type: "array", items: irTypeToOpenApi(listMatch[1]) };
+  const setMatch = irType.match(/^set<(.+)>$/);
+  if (setMatch) return { type: "array", items: irTypeToOpenApi(setMatch[1]) };
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return { ...irTypeToOpenApi(optMatch[1]), nullable: true };
+  return { type: "string" };
+}
+
+function ind(n: number): string {
+  return "  ".repeat(n);
+}
+
+function yamlValue(v: unknown, depth: number): string {
+  if (v === null || v === undefined) return "null";
+  if (typeof v === "boolean") return String(v);
+  if (typeof v === "number") return String(v);
+  if (typeof v === "string") {
+    if (
+      v.includes(":") ||
+      v.includes("#") ||
+      v.includes("'") ||
+      v.startsWith("{") ||
+      v.startsWith("[")
+    ) {
+      return JSON.stringify(v);
+    }
+    return v;
+  }
+  if (Array.isArray(v)) {
+    if (v.length === 0) return "[]";
+    return (
+      "\n" +
+      v
+        .map((item) => ind(depth) + "- " + yamlValue(item, depth + 1))
+        .join("\n")
+    );
+  }
+  if (typeof v === "object") {
+    const entries = Object.entries(v as Record<string, unknown>);
+    if (entries.length === 0) return "{}";
+    return (
+      "\n" +
+      entries
+        .map(([k, val]) => {
+          const valStr = yamlValue(val, depth + 1);
+          if (valStr.startsWith("\n")) {
+            return ind(depth) + k + ":" + valStr;
+          }
+          return ind(depth) + k + ": " + valStr;
+        })
+        .join("\n")
+    );
+  }
+  return String(v);
+}
+
+function objToYaml(obj: Record<string, unknown>, depth = 0): string {
+  const lines: string[] = [];
+  for (const [k, v] of Object.entries(obj)) {
+    const valStr = yamlValue(v, depth + 1);
+    if (valStr.startsWith("\n")) {
+      lines.push(ind(depth) + k + ":" + valStr);
+    } else {
+      lines.push(ind(depth) + k + ": " + valStr);
+    }
+  }
+  return lines.join("\n");
+}
+
+// ─── Spec builder ─────────────────────────────────────────────────────────────
+
+function buildSpec(system: IR.IRSystem): Record<string, unknown> {
+  const paths: Record<string, unknown> = {};
+  const schemas: Record<string, unknown> = {};
+
+  for (const mod of system.modules) {
+    if (mod.kind !== "api_service" || mod.models.length === 0) continue;
+
+    const model = mod.models[0];
+    const tableName = toSnakeCase(model.name);
+    const modelName = toPascalCase(model.name);
+    const collectionPath = "/" + tableName + "s";
+    const itemPath = "/" + tableName + "s/{id}";
+
+    const allMethods: IR.IRMethod[] = mod.interfaces.flatMap((i) => i.methods);
+    const crudNames = new Set(["create", "read", "update", "delete", "list"]);
+    const capabilityMethods = allMethods.filter(
+      (m) => !crudNames.has(m.name.toLowerCase())
+    );
+
+    const securityRef = [{ BearerAuth: [] }];
+
+    const listOp: Record<string, unknown> = {
+      summary: "List " + modelName,
+      operationId: "list" + modelName,
+      tags: [modelName],
+      parameters: [
+        { name: "page", in: "query", schema: { type: "integer", default: 1 } },
+        {
+          name: "page_size",
+          in: "query",
+          schema: { type: "integer", default: 50 },
+        },
+      ],
+      responses: {
+        "200": {
+          description: "List of " + modelName,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  items: {
+                    type: "array",
+                    items: { $ref: "#/components/schemas/" + modelName },
+                  },
+                  total: { type: "integer" },
+                  page: { type: "integer" },
+                  page_size: { type: "integer" },
+                },
+              },
+            },
+          },
+        },
+        "401": { description: "Unauthorized" },
+      },
+    };
+
+    const createOp: Record<string, unknown> = {
+      summary: "Create " + modelName,
+      operationId: "create" + modelName,
+      tags: [modelName],
+      security: securityRef,
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: { $ref: "#/components/schemas/" + modelName },
+          },
+        },
+      },
+      responses: {
+        "200": {
+          description: "Created",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/" + modelName },
+            },
+          },
+        },
+        "401": { description: "Unauthorized" },
+        "422": { description: "Precondition failed" },
+        "400": { description: "Bad request" },
+      },
+    };
+
+    paths[collectionPath] = { get: listOp, post: createOp };
+
+    const idParam = [
+      {
+        name: "id",
+        in: "path",
+        required: true,
+        schema: { type: "string", format: "uuid" },
+      },
+    ];
+
+    paths[itemPath] = {
+      get: {
+        summary: "Get " + modelName,
+        operationId: "get" + modelName,
+        tags: [modelName],
+        parameters: idParam,
+        security: securityRef,
+        responses: {
+          "200": {
+            description: "Found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/" + modelName },
+              },
+            },
+          },
+          "401": { description: "Unauthorized" },
+          "400": { description: "Not found" },
+        },
+      },
+      put: {
+        summary: "Update " + modelName,
+        operationId: "update" + modelName,
+        tags: [modelName],
+        parameters: idParam,
+        security: securityRef,
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/" + modelName },
+            },
+          },
+        },
+        responses: {
+          "200": {
+            description: "Updated",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/" + modelName },
+              },
+            },
+          },
+          "401": { description: "Unauthorized" },
+          "422": { description: "Precondition failed" },
+          "400": { description: "Bad request" },
+        },
+      },
+      delete: {
+        summary: "Delete " + modelName,
+        operationId: "delete" + modelName,
+        tags: [modelName],
+        parameters: idParam,
+        security: securityRef,
+        responses: {
+          "200": { description: "Deleted" },
+          "401": { description: "Unauthorized" },
+          "400": { description: "Not found" },
+        },
+      },
+    };
+
+    for (const method of capabilityMethods) {
+      const capPath = collectionPath + "/" + toDashCase(method.name);
+      const capOp: Record<string, unknown> = {
+        summary: method.name + " on " + modelName,
+        operationId: method.name + modelName,
+        tags: [modelName],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/" + modelName },
+            },
+          },
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    ok: { type: "boolean" },
+                    action: { type: "string" },
+                  },
+                },
+              },
+            },
+          },
+          "401": { description: "Unauthorized" },
+          "422": { description: "Precondition failed" },
+          "400": { description: "Bad request" },
+        },
+      };
+      if (method.authenticated) {
+        capOp.security = securityRef;
+      }
+      paths[capPath] = { post: capOp };
+    }
+
+    const properties: Record<string, unknown> = {};
+    for (const field of model.fields) {
+      properties[field.name] = irTypeToOpenApi(field.type);
+    }
+    schemas[modelName] = {
+      type: "object",
+      properties,
+    };
+  }
+
+  return {
+    openapi: "3.0.3",
+    info: {
+      title: system.name,
+      version: system.version,
+      description: "Generated by BoneScript compiler",
+    },
+    servers: [{ url: "http://localhost:3000" }],
+    paths,
+    components: {
+      securitySchemes: {
+        BearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT",
+        },
+      },
+      schemas,
+    },
+  };
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function emitOpenApiSpec(system: IR.IRSystem): string {
+  const spec = buildSpec(system);
+  const lines: string[] = ["# Generated by BoneScript compiler"];
+  lines.push(objToYaml(spec));
+  return lines.join("\n") + "\n";
+}
+
+export function emitOpenApiJson(system: IR.IRSystem): string {
+  return JSON.stringify(buildSpec(system), null, 2);
+}

package/src/emit_postman.ts

@@ -0,0 +1,145 @@
+/**
+ * BoneScript Postman Collection Emitter
+ * Generates a Postman Collection v2.1 JSON from an IRSystem.
+ */
+
+import * as IR from "./ir";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function toDashCase(s: string): string {
+  return toSnakeCase(s).replace(/_/g, "-");
+}
+
+function sampleValue(irType: string): unknown {
+  if (irType === "string") return "example";
+  if (irType === "uint" || irType === "int") return 1;
+  if (irType === "float") return 1.0;
+  if (irType === "bool") return true;
+  if (irType === "uuid") return "00000000-0000-0000-0000-000000000001";
+  if (irType === "timestamp") return "2024-01-01T00:00:00.000Z";
+  if (irType === "bytes") return "";
+  if (irType === "json") return {};
+  const listMatch = irType.match(/^list<(.+)>$/);
+  if (listMatch) return [];
+  const setMatch = irType.match(/^set<(.+)>$/);
+  if (setMatch) return [];
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return null;
+  return "example";
+}
+
+function buildSampleBody(model: IR.IRModel): Record<string, unknown> {
+  const body: Record<string, unknown> = {};
+  for (const field of model.fields) {
+    body[field.name] = sampleValue(field.type);
+  }
+  return body;
+}
+
+function makeRequest(
+  name: string,
+  method: string,
+  url: string,
+  body?: Record<string, unknown>
+): Record<string, unknown> {
+  const headers = [
+    { key: "Content-Type", value: "application/json" },
+    { key: "Authorization", value: "Bearer {{token}}" },
+  ];
+
+  const req: Record<string, unknown> = {
+    name,
+    request: {
+      method,
+      header: headers,
+      url: {
+        raw: url,
+        host: ["{{baseUrl}}"],
+        path: url
+          .replace("{{baseUrl}}/", "")
+          .split("/")
+          .filter(Boolean),
+      },
+    },
+  };
+
+  if (body !== undefined) {
+    (req.request as Record<string, unknown>).body = {
+      mode: "raw",
+      raw: JSON.stringify(body, null, 2),
+      options: { raw: { language: "json" } },
+    };
+  }
+
+  return req;
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function emitPostmanCollection(system: IR.IRSystem): string {
+  const folders: unknown[] = [];
+
+  for (const mod of system.modules) {
+    if (mod.kind !== "api_service" || mod.models.length === 0) continue;
+
+    const model = mod.models[0];
+    const tableName = toSnakeCase(model.name);
+    const baseUrl = `{{baseUrl}}/${tableName}s`;
+    const sampleBody = buildSampleBody(model);
+
+    const items: unknown[] = [
+      makeRequest(`List ${model.name}s`, "GET", baseUrl),
+      makeRequest(`Create ${model.name}`, "POST", baseUrl, sampleBody),
+      makeRequest(`Get ${model.name}`, "GET", `${baseUrl}/:id`),
+      makeRequest(`Update ${model.name}`, "PUT", `${baseUrl}/:id`, sampleBody),
+      makeRequest(`Delete ${model.name}`, "DELETE", `${baseUrl}/:id`),
+    ];
+
+    const crudNames = new Set(["create", "read", "update", "delete", "list"]);
+    const allMethods: IR.IRMethod[] = mod.interfaces.flatMap((i) => i.methods);
+    const capabilityMethods = allMethods.filter(
+      (m) => !crudNames.has(m.name.toLowerCase())
+    );
+
+    for (const method of capabilityMethods) {
+      const dashName = toDashCase(method.name);
+      items.push(
+        makeRequest(
+          method.name + " " + model.name,
+          "POST",
+          `${baseUrl}/${dashName}`,
+          sampleBody
+        )
+      );
+    }
+
+    folders.push({
+      name: mod.name,
+      item: items,
+    });
+  }
+
+  const collection = {
+    info: {
+      name: system.name,
+      schema:
+        "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+    },
+    auth: {
+      type: "bearer",
+      bearer: [{ key: "token", value: "{{token}}", type: "string" }],
+    },
+    variable: [
+      { key: "baseUrl", value: "http://localhost:3000" },
+      { key: "token", value: "" },
+    ],
+    item: folders,
+  };
+
+  return JSON.stringify(collection, null, 2);
+}

package/src/emit_sdk.ts

@@ -0,0 +1,195 @@
+/**
+ * BoneScript TypeScript SDK Emitter
+ * Generates a typed fetch client SDK from an IRSystem.
+ */
+
+import * as IR from "./ir";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function toCamelCase(s: string): string {
+  return s.replace(/_([a-z])/g, (_: string, c: string) => c.toUpperCase());
+}
+
+function toPascalCase(s: string): string {
+  const c = toCamelCase(s);
+  return c.charAt(0).toUpperCase() + c.slice(1);
+}
+
+function irTypeToTs(irType: string): string {
+  if (irType === "string") return "string";
+  if (irType === "uint" || irType === "int") return "number";
+  if (irType === "float") return "number";
+  if (irType === "bool") return "boolean";
+  if (irType === "timestamp") return "string";
+  if (irType === "uuid") return "string";
+  if (irType === "bytes") return "string";
+  if (irType === "json") return "unknown";
+  const listMatch = irType.match(/^list<(.+)>$/);
+  if (listMatch) return irTypeToTs(listMatch[1]) + "[]";
+  const setMatch = irType.match(/^set<(.+)>$/);
+  if (setMatch) return irTypeToTs(setMatch[1]) + "[]";
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return irTypeToTs(optMatch[1]) + " | null";
+  return "unknown";
+}
+
+// ─── SDK generator ────────────────────────────────────────────────────────────
+
+export function emitTypescriptSdk(system: IR.IRSystem): string {
+  const lines: string[] = [];
+  const systemPascal = toPascalCase(system.name.replace(/[^a-zA-Z0-9_]/g, "_"));
+
+  lines.push("// Generated by BoneScript compiler. Import this file into your frontend.");
+  lines.push(`// System: ${system.name} v${system.version}`);
+  lines.push("");
+
+  // Collect all models for interface generation
+  const allModels: { mod: IR.IRModule; model: IR.IRModel }[] = [];
+  for (const mod of system.modules) {
+    if (mod.kind === "api_service" && mod.models.length > 0) {
+      for (const model of mod.models) {
+        allModels.push({ mod, model });
+      }
+    }
+  }
+
+  // Emit TypeScript interfaces
+  for (const { model } of allModels) {
+    const typeName = toPascalCase(model.name);
+    lines.push(`export interface ${typeName} {`);
+    for (const field of model.fields) {
+      const nullable = field.nullable ? " | null" : "";
+      lines.push(`  ${field.name}: ${irTypeToTs(field.type)}${nullable};`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+
+  // Emit client class
+  lines.push(`export class ${systemPascal}Client {`);
+  lines.push(
+    `  constructor(private baseUrl: string, private getToken?: () => string | null) {}`
+  );
+  lines.push("");
+
+  // Private request helper
+  lines.push(
+    `  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {`
+  );
+  lines.push(`    const headers: Record<string, string> = {`);
+  lines.push(`      "Content-Type": "application/json",`);
+  lines.push(`    };`);
+  lines.push(`    if (this.getToken) {`);
+  lines.push(`      const token = this.getToken();`);
+  lines.push(`      if (token) headers["Authorization"] = "Bearer " + token;`);
+  lines.push(`    }`);
+  lines.push(`    const res = await fetch(this.baseUrl + path, {`);
+  lines.push(`      method,`);
+  lines.push(`      headers,`);
+  lines.push(`      body: body !== undefined ? JSON.stringify(body) : undefined,`);
+  lines.push(`    });`);
+  lines.push(`    if (!res.ok) {`);
+  lines.push(
+    `      const text = await res.text().catch(() => res.statusText);`
+  );
+  lines.push(`      throw new Error(\`HTTP \${res.status}: \${text}\`);`);
+  lines.push(`    }`);
+  lines.push(`    if (res.status === 204) return undefined as unknown as T;`);
+  lines.push(`    return res.json() as Promise<T>;`);
+  lines.push(`  }`);
+  lines.push("");
+
+  // Per-entity methods
+  for (const { mod, model } of allModels) {
+    const entity = toPascalCase(model.name);
+    const tableName = toSnakeCase(model.name);
+    const basePath = `/${tableName}s`;
+
+    lines.push(`  // ─── ${entity} ───`);
+    lines.push("");
+
+    lines.push(
+      `  list${entity}(page = 1, pageSize = 50): Promise<{ items: ${entity}[]; total: number; page: number; page_size: number }> {`
+    );
+    lines.push(
+      `    return this.request("GET", \`${basePath}?page=\${page}&page_size=\${pageSize}\`);`
+    );
+    lines.push(`  }`);
+    lines.push("");
+
+    lines.push(`  get${entity}(id: string): Promise<${entity}> {`);
+    lines.push(`    return this.request("GET", \`${basePath}/\${id}\`);`);
+    lines.push(`  }`);
+    lines.push("");
+
+    lines.push(
+      `  create${entity}(data: Partial<${entity}>): Promise<${entity}> {`
+    );
+    lines.push(`    return this.request("POST", "${basePath}", data);`);
+    lines.push(`  }`);
+    lines.push("");
+
+    lines.push(
+      `  update${entity}(id: string, data: Partial<${entity}>): Promise<${entity}> {`
+    );
+    lines.push(`    return this.request("PUT", \`${basePath}/\${id}\`, data);`);
+    lines.push(`  }`);
+    lines.push("");
+
+    lines.push(`  delete${entity}(id: string): Promise<void> {`);
+    lines.push(`    return this.request("DELETE", \`${basePath}/\${id}\`);`);
+    lines.push(`  }`);
+    lines.push("");
+
+    // Capability methods
+    const crudNames = new Set(["create", "read", "update", "delete", "list"]);
+    const allMethods: IR.IRMethod[] = mod.interfaces.flatMap((i) => i.methods);
+    const capabilityMethods = allMethods.filter(
+      (m) => !crudNames.has(m.name.toLowerCase())
+    );
+
+    for (const method of capabilityMethods) {
+      const methodCamel = toCamelCase(method.name);
+      const dashName = toSnakeCase(method.name).replace(/_/g, "-");
+      lines.push(
+        `  ${methodCamel}(data: Record<string, unknown>): Promise<{ ok: boolean; action: string }> {`
+      );
+      lines.push(
+        `    return this.request("POST", "${basePath}/${dashName}", data);`
+      );
+      lines.push(`  }`);
+      lines.push("");
+    }
+  }
+
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+export function emitSdkPackageJson(system: IR.IRSystem): string {
+  const pkgName = toSnakeCase(system.name).replace(/_/g, "-") + "-sdk";
+  return JSON.stringify(
+    {
+      name: pkgName,
+      version: system.version,
+      description: `TypeScript SDK for ${system.name} — generated by BoneScript compiler`,
+      main: "client.js",
+      types: "client.d.ts",
+      scripts: {
+        build: "tsc",
+      },
+      devDependencies: {
+        typescript: "5.3.3",
+      },
+    },
+    null,
+    2
+  );
+}