bonescript-compiler 0.6.2 → 0.8.0

package/src/emit_prisma.ts

@@ -0,0 +1,346 @@
+/**
+ * BoneScript Prisma Schema Emitter
+ * Generates a Prisma schema file from the IR.
+ *
+ * Maps BoneScript entities, relations, and constraints to Prisma's
+ * schema language. Produces a single `schema.prisma` file that can
+ * be used with `npx prisma migrate dev` and `npx prisma generate`.
+ */
+
+import * as IR from "./ir";
+import { EmittedFile } from "./emitter";
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function toPascalCase(s: string): string {
+  return s.replace(/(^|[-_\s])(\w)/g, (_, __, c: string) => c.toUpperCase());
+}
+
+// ─── Type Mapping ─────────────────────────────────────────────────────────────
+
+const PRISMA_TYPE_MAP: Record<string, string> = {
+  string: "String",
+  uint: "Int",
+  int: "Int",
+  float: "Float",
+  bool: "Boolean",
+  timestamp: "DateTime",
+  uuid: "String",
+  bytes: "Bytes",
+  json: "Json",
+};
+
+function toPrismaType(irType: string): string {
+  if (PRISMA_TYPE_MAP[irType]) return PRISMA_TYPE_MAP[irType];
+  const listMatch = irType.match(/^(list|set)<(.+)>$/);
+  if (listMatch) return `${toPrismaType(listMatch[2])}[]`;
+  const optMatch = irType.match(/^optional<(.+)>$/);
+  if (optMatch) return `${toPrismaType(optMatch[1])}?`;
+  // Entity reference — will be handled as a relation
+  return "String";
+}
+
+function toPrismaNativeType(irType: string): string | null {
+  switch (irType) {
+    case "uuid": return "@db.Uuid";
+    case "string": return null; // default is fine
+    case "json": return null; // Json maps directly
+    case "bytes": return null;
+    case "timestamp": return "@db.Timestamptz";
+    case "float": return "@db.DoublePrecision";
+    case "uint": return "@db.BigInt";
+    case "int": return "@db.BigInt";
+    default: return null;
+  }
+}
+
+// ─── Prisma Emitter ───────────────────────────────────────────────────────────
+
+export class PrismaEmitter {
+  emit(system: IR.IRSystem): EmittedFile[] {
+    const files: EmittedFile[] = [];
+    files.push({
+      path: "prisma/schema.prisma",
+      content: this.emitSchema(system),
+      language: "typescript", // closest match for syntax highlighting
+      source_module: "prisma",
+    });
+    return files;
+  }
+
+  private emitSchema(system: IR.IRSystem): string {
+    const lines: string[] = [];
+
+    // Header
+    lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+    lines.push(`// Source: ${system.name} (${system.source_hash})`);
+    lines.push(`// Run: npx prisma migrate dev --name init`);
+    lines.push(`//      npx prisma generate`);
+    lines.push(``);
+
+    // Datasource
+    lines.push(`datasource db {`);
+    lines.push(`  provider = "postgresql"`);
+    lines.push(`  url      = env("DATABASE_URL")`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Generator
+    lines.push(`generator client {`);
+    lines.push(`  provider = "prisma-client-js"`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Collect all models across modules, deduplicating by name
+    const modelMap = new Map<string, { model: IR.IRModel; mod: IR.IRModule }>();
+    const allRelations: IR.IRRelation[] = [];
+
+    for (const mod of system.modules) {
+      if (mod.kind === "data_store" || mod.kind === "api_service") {
+        for (const model of mod.models) {
+          if (!modelMap.has(model.name)) {
+            modelMap.set(model.name, { model, mod });
+          }
+        }
+        allRelations.push(...mod.relations);
+      }
+    }
+
+    // Deduplicate relations by a stable key
+    const seenRelations = new Set<string>();
+    const uniqueRelations: IR.IRRelation[] = [];
+    for (const rel of allRelations) {
+      const key = `${rel.from_entity}:${rel.to_entity}:${rel.kind}:${rel.foreign_key}`;
+      if (!seenRelations.has(key)) {
+        seenRelations.add(key);
+        uniqueRelations.push(rel);
+      }
+    }
+
+    // Build a lookup: entity name → relations where it's the "from" side
+    const relationsFrom = new Map<string, IR.IRRelation[]>();
+    const relationsTo = new Map<string, IR.IRRelation[]>();
+    for (const rel of uniqueRelations) {
+      if (!relationsFrom.has(rel.from_entity)) relationsFrom.set(rel.from_entity, []);
+      relationsFrom.get(rel.from_entity)!.push(rel);
+      if (!relationsTo.has(rel.to_entity)) relationsTo.set(rel.to_entity, []);
+      relationsTo.get(rel.to_entity)!.push(rel);
+    }
+
+    // Emit each model
+    for (const [name, { model, mod }] of modelMap) {
+      lines.push(this.emitModel(name, model, mod, relationsFrom.get(name) || [], relationsTo.get(name) || [], modelMap));
+      lines.push(``);
+    }
+
+    // Emit junction tables for many_to_many
+    for (const rel of uniqueRelations) {
+      if (rel.kind === "many_to_many" && rel.junction_table) {
+        lines.push(this.emitJunctionModel(rel));
+        lines.push(``);
+      }
+    }
+
+    // Emit audit_log and event_outbox models (infrastructure)
+    lines.push(this.emitAuditLogModel());
+    lines.push(``);
+    lines.push(this.emitEventOutboxModel());
+    lines.push(``);
+
+    return lines.join("\n");
+  }
+
+  private emitModel(
+    name: string,
+    model: IR.IRModel,
+    mod: IR.IRModule,
+    relationsFrom: IR.IRRelation[],
+    relationsTo: IR.IRRelation[],
+    allModels: Map<string, { model: IR.IRModel; mod: IR.IRModule }>
+  ): string {
+    const lines: string[] = [];
+    const tableName = toSnakeCase(name) + "s";
+
+    lines.push(`model ${toPascalCase(name)} {`);
+
+    // Fields
+    for (const field of model.fields) {
+      lines.push(`  ${this.emitField(field, model, name)}`);
+    }
+
+    // State field (if entity has a state machine)
+    const hasSM = mod.state_machines.some(sm => sm.entity === name);
+    const hasStateField = model.fields.some(f => f.name === "state");
+    if (hasSM && !hasStateField) {
+      lines.push(`  state         String`);
+    }
+
+    // Relation fields
+    for (const rel of relationsFrom) {
+      if (rel.kind === "belongs_to") {
+        // The FK field is already in the model fields. Add the relation object.
+        const targetModel = toPascalCase(rel.to_entity);
+        const fieldName = toSnakeCase(rel.to_entity);
+        lines.push(`  ${fieldName}   ${targetModel}  @relation(fields: [${rel.foreign_key}], references: [id], onDelete: Cascade)`);
+      } else if (rel.kind === "has_many") {
+        const targetModel = toPascalCase(rel.to_entity);
+        const fieldName = toSnakeCase(rel.to_entity) + "s";
+        lines.push(`  ${fieldName}  ${targetModel}[]`);
+      } else if (rel.kind === "has_one") {
+        const targetModel = toPascalCase(rel.to_entity);
+        const fieldName = toSnakeCase(rel.to_entity);
+        lines.push(`  ${fieldName}   ${targetModel}?`);
+      }
+    }
+
+    // Inverse relations (where this model is the "to" side)
+    for (const rel of relationsTo) {
+      if (rel.kind === "belongs_to") {
+        // This model is the target of a belongs_to — add the inverse has_many
+        const sourceModel = toPascalCase(rel.from_entity);
+        const fieldName = toSnakeCase(rel.from_entity) + "s";
+        // Only add if not already covered by relationsFrom
+        const alreadyCovered = relationsFrom.some(r =>
+          r.to_entity === rel.from_entity && r.kind === "has_many"
+        );
+        if (!alreadyCovered) {
+          lines.push(`  ${fieldName}  ${sourceModel}[]`);
+        }
+      }
+    }
+
+    // Table mapping
+    lines.push(``);
+    lines.push(`  @@map("${tableName}")`);
+
+    // Indexes
+    for (const idx of model.indexes) {
+      if (idx.unique) {
+        lines.push(`  @@unique([${idx.fields.join(", ")}])`);
+      } else {
+        lines.push(`  @@index([${idx.fields.join(", ")}])`);
+      }
+    }
+
+    lines.push(`}`);
+    return lines.join("\n");
+  }
+
+  private emitField(field: IR.IRField, model: IR.IRModel, entityName: string): string {
+    const parts: string[] = [];
+
+    // Field name (padded for alignment)
+    parts.push(field.name.padEnd(14));
+
+    // Type
+    let prismaType = toPrismaType(field.type);
+    if (field.nullable) prismaType += "?";
+    parts.push(prismaType.padEnd(12));
+
+    // Attributes
+    const attrs: string[] = [];
+
+    // Primary key
+    if (field.name === model.primary_key) {
+      attrs.push("@id");
+    }
+
+    // Default values
+    if (field.name === "id" && field.type === "uuid") {
+      attrs.push("@default(uuid())");
+    } else if (field.name === "created_at" || (field.type === "timestamp" && field.name.includes("created"))) {
+      attrs.push("@default(now())");
+    } else if (field.name === "updated_at") {
+      attrs.push("@updatedAt");
+    } else if (field.default_value) {
+      const dv = this.mapDefaultValue(field.default_value, field.type);
+      if (dv) attrs.push(dv);
+    }
+
+    // Unique constraint (skip if already primary key — @id implies uniqueness)
+    if (field.unique && field.name !== model.primary_key) {
+      attrs.push("@unique");
+    }
+
+    // Native type annotation
+    const nativeType = toPrismaNativeType(field.type);
+    if (nativeType) {
+      attrs.push(nativeType);
+    }
+
+    if (attrs.length > 0) {
+      parts.push(attrs.join(" "));
+    }
+
+    return parts.join(" ").trimEnd();
+  }
+
+  private mapDefaultValue(value: string, type: string): string | null {
+    if (value === "gen_random_uuid()" || value === "uuid()") return "@default(uuid())";
+    if (value === "now()") return "@default(now())";
+    if (value === "true" || value === "false") return `@default(${value})`;
+    if (/^\d+$/.test(value)) return `@default(${value})`;
+    if (/^\d+\.\d+$/.test(value)) return `@default(${value})`;
+    if (value.startsWith('"') && value.endsWith('"')) return `@default(${value})`;
+    return null;
+  }
+
+  private emitJunctionModel(rel: IR.IRRelation): string {
+    const lines: string[] = [];
+    const fromCol = toSnakeCase(rel.from_entity) + "_id";
+    const toCol = toSnakeCase(rel.to_entity) + "_id";
+
+    lines.push(`model ${toPascalCase(rel.junction_table!)} {`);
+    lines.push(`  ${fromCol.padEnd(14)} String       @db.Uuid`);
+    lines.push(`  ${toCol.padEnd(14)} String       @db.Uuid`);
+    lines.push(`  created_at     DateTime     @default(now()) @db.Timestamptz`);
+    lines.push(``);
+    lines.push(`  ${toSnakeCase(rel.from_entity).padEnd(14)} ${toPascalCase(rel.from_entity)}  @relation(fields: [${fromCol}], references: [id], onDelete: Cascade)`);
+    lines.push(`  ${toSnakeCase(rel.to_entity).padEnd(14)} ${toPascalCase(rel.to_entity)}  @relation(fields: [${toCol}], references: [id], onDelete: Cascade)`);
+    lines.push(``);
+    lines.push(`  @@id([${fromCol}, ${toCol}])`);
+    lines.push(`  @@index([${fromCol}])`);
+    lines.push(`  @@index([${toCol}])`);
+    lines.push(`  @@map("${rel.junction_table}")`);
+    lines.push(`}`);
+    return lines.join("\n");
+  }
+
+  private emitAuditLogModel(): string {
+    return `model AuditLog {
+  id             String       @id @default(uuid()) @db.Uuid
+  actor_id       String?      @db.Uuid
+  action         String
+  entity_type    String
+  entity_id      String?      @db.Uuid
+  payload        Json?
+  ip             String?
+  user_agent     String?
+  trace_id       String?      @db.Uuid
+  created_at     DateTime     @default(now()) @db.Timestamptz
+
+  @@index([actor_id])
+  @@index([entity_type, entity_id])
+  @@index([created_at])
+  @@map("audit_log")
+}`;
+  }
+
+  private emitEventOutboxModel(): string {
+    return `model EventOutbox {
+  id             String       @id @default(uuid()) @db.Uuid
+  event_type     String
+  payload        Json
+  status         String       @default("pending")
+  attempts       Int          @default(0)
+  created_at     DateTime     @default(now()) @db.Timestamptz
+  processed_at   DateTime?    @db.Timestamptz
+  error          String?
+
+  @@index([status, created_at])
+  @@map("event_outbox")
+}`;
+  }
+}

package/src/emit_react.ts

@@ -0,0 +1,236 @@
+/**
+ * BoneScript React Hooks Emitter
+ *
+ * Generates a typed React hooks file (sdk/react.ts) on top of the existing
+ * fetch SDK. Hooks are zero-dep — they use React's built-in useState +
+ * useEffect rather than pulling in @tanstack/react-query so consumers can
+ * decide their own data layer.
+ *
+ * For each entity:
+ *   useList<Entity>()      → { data, loading, error, refetch }
+ *   use<Entity>(id)        → { data, loading, error, refetch }
+ *   useCreate<Entity>()    → mutate(input) → Promise<Entity>
+ *   useUpdate<Entity>()    → mutate(id, patch) → Promise<Entity>
+ *   useDelete<Entity>()    → mutate(id) → Promise<void>
+ *
+ * For each capability:
+ *   useCapability<Name>()  → mutate(input) → Promise<unknown>
+ *
+ * Hooks are framework-agnostic in shape (no react-query, no SWR) so they work
+ * with Next.js, Vite, CRA, or any plain React app.
+ */
+
+import * as IR from "./ir";
+import { EmittedFile } from "./emitter";
+
+function toSnakeCase(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+
+function toPascalCase(s: string): string {
+  return s.replace(/(^|[-_\s])(\w)/g, (_, __, c: string) => c.toUpperCase());
+}
+
+const TS_TYPE_MAP: Record<string, string> = {
+  string: "string", uint: "number", int: "number", float: "number",
+  bool: "boolean", timestamp: "string", uuid: "string", bytes: "string", json: "unknown",
+};
+
+function toTsType(irType: string): string {
+  if (TS_TYPE_MAP[irType]) return TS_TYPE_MAP[irType];
+  const m = irType.match(/^(list|set)<(.+)>$/);
+  if (m) return `${toTsType(m[2])}[]`;
+  const om = irType.match(/^optional<(.+)>$/);
+  if (om) return `${toTsType(om[1])} | null`;
+  return irType;
+}
+
+export function emitReactHooks(system: IR.IRSystem): EmittedFile {
+  const lines: string[] = [];
+
+  lines.push(`// Generated by BoneScript compiler. DO NOT EDIT.`);
+  lines.push(`// React hooks for the ${system.name} API.`);
+  lines.push(`//`);
+  lines.push(`// Pair with sdk/client.ts. Pass an instance of <System>Client to <ApiProvider>.`);
+  lines.push(``);
+  lines.push(`import { useCallback, useEffect, useState, createContext, useContext, ReactNode, createElement } from "react";`);
+  lines.push(``);
+
+  // Entity types (forward-declared so the hooks compile without importing the SDK)
+  // We re-declare them here to keep this file independent — the consumer can
+  // also import these types from sdk/client.ts if they prefer.
+  const apiModules = system.modules.filter(m => m.kind === "api_service" && m.models.length > 0);
+  for (const mod of apiModules) {
+    const model = mod.models[0];
+    lines.push(`export interface ${toPascalCase(model.name)} {`);
+    for (const field of model.fields) {
+      const optional = field.nullable ? "?" : "";
+      lines.push(`  ${field.name}${optional}: ${toTsType(field.type)};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+  }
+
+  lines.push(`export interface ApiClient {`);
+  lines.push(`  baseUrl: string;`);
+  lines.push(`  getToken: () => string | null;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`async function apiFetch<T>(client: ApiClient, method: string, path: string, body?: unknown): Promise<T> {`);
+  lines.push(`  const headers: Record<string, string> = { "Content-Type": "application/json" };`);
+  lines.push(`  const token = client.getToken();`);
+  lines.push(`  if (token) headers["Authorization"] = "Bearer " + token;`);
+  lines.push(`  const res = await fetch(client.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(`    let errMsg = "Request failed: " + res.status;`);
+  lines.push(`    try { const j = await res.json() as { error?: { message?: string } }; if (j.error?.message) errMsg = j.error.message; } catch {}`);
+  lines.push(`    throw new Error(errMsg);`);
+  lines.push(`  }`);
+  lines.push(`  if (res.status === 204) return undefined as unknown as T;`);
+  lines.push(`  return await res.json() as T;`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Provider + context. createElement avoids needing JSX in this generated file.
+  lines.push(`const ApiContext = createContext<ApiClient | null>(null);`);
+  lines.push(``);
+  lines.push(`export interface ApiProviderProps {`);
+  lines.push(`  client: ApiClient;`);
+  lines.push(`  children: ReactNode;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`export function ApiProvider(props: ApiProviderProps) {`);
+  lines.push(`  return createElement(ApiContext.Provider, { value: props.client }, props.children);`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`function useApi(): ApiClient {`);
+  lines.push(`  const ctx = useContext(ApiContext);`);
+  lines.push(`  if (!ctx) throw new Error("useApi must be used inside <ApiProvider>");`);
+  lines.push(`  return ctx;`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Generic shape helpers
+  lines.push(`export interface QueryState<T> {`);
+  lines.push(`  data: T | null;`);
+  lines.push(`  loading: boolean;`);
+  lines.push(`  error: Error | null;`);
+  lines.push(`  refetch: () => Promise<void>;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`export interface MutationState<TInput, TOutput> {`);
+  lines.push(`  mutate: (input: TInput) => Promise<TOutput>;`);
+  lines.push(`  loading: boolean;`);
+  lines.push(`  error: Error | null;`);
+  lines.push(`  reset: () => void;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`export interface PaginatedResponse<T> {`);
+  lines.push(`  items: T[];`);
+  lines.push(`  total: number;`);
+  lines.push(`  page: number;`);
+  lines.push(`  page_size: number;`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Generic primitive hooks. Specific entity / capability hooks below wrap these.
+  lines.push(`function useQueryGeneric<T>(method: string, path: string, deps: unknown[]): QueryState<T> {`);
+  lines.push(`  const client = useApi();`);
+  lines.push(`  const [data, setData] = useState<T | null>(null);`);
+  lines.push(`  const [loading, setLoading] = useState(true);`);
+  lines.push(`  const [error, setError] = useState<Error | null>(null);`);
+  lines.push(`  const fetchOnce = useCallback(async () => {`);
+  lines.push(`    setLoading(true); setError(null);`);
+  lines.push(`    try { const result = await apiFetch<T>(client, method, path); setData(result); }`);
+  lines.push(`    catch (e: unknown) { setError(e instanceof Error ? e : new Error(String(e))); }`);
+  lines.push(`    finally { setLoading(false); }`);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  lines.push(`  }, [client, method, path]);`);
+  lines.push(`  useEffect(() => { void fetchOnce(); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, deps);`);
+  lines.push(`  return { data, loading, error, refetch: fetchOnce };`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`function useMutationGeneric<TInput, TOutput>(builder: (input: TInput) => { method: string; path: string; body?: unknown }): MutationState<TInput, TOutput> {`);
+  lines.push(`  const client = useApi();`);
+  lines.push(`  const [loading, setLoading] = useState(false);`);
+  lines.push(`  const [error, setError] = useState<Error | null>(null);`);
+  lines.push(`  const mutate = useCallback(async (input: TInput): Promise<TOutput> => {`);
+  lines.push(`    setLoading(true); setError(null);`);
+  lines.push(`    try { const req = builder(input); return await apiFetch<TOutput>(client, req.method, req.path, req.body); }`);
+  lines.push(`    catch (e: unknown) { const err = e instanceof Error ? e : new Error(String(e)); setError(err); throw err; }`);
+  lines.push(`    finally { setLoading(false); }`);
+  lines.push(`  }, [client, builder]);`);
+  lines.push(`  const reset = useCallback(() => setError(null), []);`);
+  lines.push(`  return { mutate, loading, error, reset };`);
+  lines.push(`}`);
+  lines.push(``);
+
+  // Per-entity hooks
+  for (const mod of apiModules) {
+    const model = mod.models[0];
+    const entity = toPascalCase(model.name);
+    const tableName = toSnakeCase(model.name) + "s";
+    const route = `/${tableName}`;
+
+    lines.push(`// ─── ${entity} ───────────────────────────────────────────────────────────`);
+    lines.push(``);
+
+    // List
+    lines.push(`export function useList${entity}(): QueryState<PaginatedResponse<${entity}>> {`);
+    lines.push(`  return useQueryGeneric<PaginatedResponse<${entity}>>("GET", "${route}", []);`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Read
+    lines.push(`export function use${entity}(id: string | null): QueryState<${entity}> {`);
+    lines.push(`  return useQueryGeneric<${entity}>("GET", id ? \`${route}/\${id}\` : "${route}", [id]);`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Create
+    const createInputType = `Partial<${entity}>`;
+    lines.push(`export function useCreate${entity}(): MutationState<${createInputType}, ${entity}> {`);
+    lines.push(`  return useMutationGeneric<${createInputType}, ${entity}>((input) => ({ method: "POST", path: "${route}", body: input }));`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Update
+    lines.push(`export function useUpdate${entity}(): MutationState<{ id: string; patch: Partial<${entity}> }, ${entity}> {`);
+    lines.push(`  return useMutationGeneric<{ id: string; patch: Partial<${entity}> }, ${entity}>(({ id, patch }) => ({ method: "PUT", path: \`${route}/\${id}\`, body: patch }));`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Delete
+    lines.push(`export function useDelete${entity}(): MutationState<string, void> {`);
+    lines.push(`  return useMutationGeneric<string, void>((id) => ({ method: "DELETE", path: \`${route}/\${id}\` }));`);
+    lines.push(`}`);
+    lines.push(``);
+
+    // Capability hooks
+    for (const iface of mod.interfaces) {
+      for (const method of iface.methods) {
+        if (["create", "read", "update", "delete", "list"].includes(method.name)) continue;
+        const capName = toPascalCase(method.name);
+        const inputType = method.input.length > 0
+          ? `{ ${method.input.map(p => `${p.name}${p.nullable ? "?" : ""}: ${toTsType(p.type)}`).join("; ")} }`
+          : "Record<string, never>";
+        const endpoint = `${route}/${method.name.replace(/_/g, "-")}`;
+        lines.push(`export function useCapability${capName}(): MutationState<${inputType}, unknown> {`);
+        lines.push(`  return useMutationGeneric<${inputType}, unknown>((input) => ({ method: "POST", path: "${endpoint}", body: input }));`);
+        lines.push(`}`);
+        lines.push(``);
+      }
+    }
+  }
+
+  return {
+    path: "sdk/react.ts",
+    content: lines.join("\n"),
+    language: "typescript",
+    source_module: "sdk",
+  };
+}