@tinybirdco/sdk 0.0.4 → 0.0.7

package/src/codegen/index.ts

@@ -0,0 +1,379 @@
+/**
+ * Code generator for converting Tinybird API resources to TypeScript SDK code
+ */
+
+import type { DatasourceInfo, PipeInfo } from "../api/resources.js";
+import { clickhouseTypeToValidator, paramTypeToValidator } from "./type-mapper.js";
+import {
+  toCamelCase,
+  toPascalCase,
+  escapeString,
+  generateEngineCode,
+  formatSqlForTemplate,
+} from "./utils.js";
+
+/**
+ * Generate TypeScript code for a single datasource
+ */
+export function generateDatasourceCode(ds: DatasourceInfo): string {
+  const varName = toCamelCase(ds.name);
+  const typeName = toPascalCase(ds.name);
+  const lines: string[] = [];
+
+  // JSDoc comment
+  if (ds.description) {
+    lines.push("/**");
+    lines.push(` * ${ds.description}`);
+    lines.push(" */");
+  }
+
+  lines.push(`export const ${varName} = defineDatasource("${ds.name}", {`);
+
+  if (ds.description) {
+    lines.push(`  description: "${escapeString(ds.description)}",`);
+  }
+
+  // Schema
+  lines.push("  schema: {");
+  for (const col of ds.columns) {
+    const validator = clickhouseTypeToValidator(col.type);
+    lines.push(`    ${col.name}: ${validator},`);
+  }
+  lines.push("  },");
+
+  // Engine
+  const engineCode = generateEngineCode(ds.engine);
+  lines.push(`  engine: ${engineCode},`);
+
+  lines.push("});");
+  lines.push("");
+  lines.push(`export type ${typeName}Row = InferRow<typeof ${varName}>;`);
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate TypeScript code for a single pipe
+ */
+export function generatePipeCode(pipe: PipeInfo): string {
+  const varName = toCamelCase(pipe.name);
+  const typeName = toPascalCase(pipe.name);
+  const lines: string[] = [];
+
+  // Determine which define function to use
+  let defineFunc = "definePipe";
+  if (pipe.type === "endpoint") {
+    defineFunc = "defineEndpoint";
+  } else if (pipe.type === "materialized") {
+    defineFunc = "defineMaterializedView";
+  } else if (pipe.type === "copy") {
+    defineFunc = "defineCopyPipe";
+  }
+
+  // JSDoc comment
+  if (pipe.description) {
+    lines.push("/**");
+    lines.push(` * ${pipe.description}`);
+    lines.push(" */");
+  }
+
+  lines.push(`export const ${varName} = ${defineFunc}("${pipe.name}", {`);
+
+  if (pipe.description) {
+    lines.push(`  description: "${escapeString(pipe.description)}",`);
+  }
+
+  // For materialized views and copy pipes, add datasource first
+  if (pipe.type === "materialized" && pipe.materialized) {
+    const dsVarName = toCamelCase(pipe.materialized.datasource);
+    lines.push(`  datasource: ${dsVarName},`);
+  } else if (pipe.type === "copy" && pipe.copy) {
+    const dsVarName = toCamelCase(pipe.copy.target_datasource);
+    lines.push(`  datasource: ${dsVarName},`);
+    if (pipe.copy.copy_schedule) {
+      lines.push(`  copy_schedule: "${pipe.copy.copy_schedule}",`);
+    }
+    if (pipe.copy.copy_mode) {
+      lines.push(`  copy_mode: "${pipe.copy.copy_mode}",`);
+    }
+  }
+
+  // Params (for endpoints and regular pipes with params)
+  if (pipe.params.length > 0 && pipe.type !== "materialized" && pipe.type !== "copy") {
+    lines.push("  params: {");
+    for (const param of pipe.params) {
+      const validator = paramTypeToValidator(param.type, param.default, param.required);
+      if (param.description) {
+        lines.push(`    ${param.name}: ${validator}.describe("${escapeString(param.description)}"),`);
+      } else {
+        lines.push(`    ${param.name}: ${validator},`);
+      }
+    }
+    lines.push("  },");
+  }
+
+  // Nodes
+  lines.push("  nodes: [");
+  for (const node of pipe.nodes) {
+    lines.push("    node({");
+    lines.push(`      name: "${node.name}",`);
+    const formattedSql = formatSqlForTemplate(node.sql);
+    lines.push(`      sql: \`${formattedSql}\`,`);
+    lines.push("    }),");
+  }
+  lines.push("  ],");
+
+  // Output (for endpoints)
+  if (pipe.type === "endpoint" && pipe.output_columns.length > 0) {
+    lines.push("  output: {");
+    for (const col of pipe.output_columns) {
+      const validator = clickhouseTypeToValidator(col.type);
+      lines.push(`    ${col.name}: ${validator},`);
+    }
+    lines.push("  },");
+  }
+
+  lines.push("});");
+
+  // Type exports for endpoints
+  if (pipe.type === "endpoint") {
+    lines.push("");
+    lines.push(`export type ${typeName}Params = InferParams<typeof ${varName}>;`);
+    lines.push(`export type ${typeName}Output = InferOutputRow<typeof ${varName}>;`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate the complete datasources.ts file content
+ */
+export function generateDatasourcesFile(datasources: DatasourceInfo[]): string {
+  if (datasources.length === 0) {
+    return `import { defineDatasource, t, engine, type InferRow } from "@tinybirdco/sdk";
+
+// No datasources found in workspace
+`;
+  }
+
+  const imports = [
+    'import { defineDatasource, t, engine, type InferRow } from "@tinybirdco/sdk";',
+    "",
+  ];
+
+  const code = datasources.map((ds) => generateDatasourceCode(ds)).join("\n\n");
+
+  return imports.join("\n") + "\n" + code + "\n";
+}
+
+/**
+ * Generate the complete pipes.ts file content
+ */
+export function generatePipesFile(
+  pipes: PipeInfo[],
+  datasources: DatasourceInfo[]
+): string {
+  if (pipes.length === 0) {
+    return `import { defineEndpoint, node, t, p, type InferParams, type InferOutputRow } from "@tinybirdco/sdk";
+
+// No pipes found in workspace
+`;
+  }
+
+  // Determine which imports are needed
+  const hasMaterialized = pipes.some((p) => p.type === "materialized");
+  const hasCopy = pipes.some((p) => p.type === "copy");
+  const hasEndpoint = pipes.some((p) => p.type === "endpoint");
+  const hasPlainPipe = pipes.some((p) => p.type === "pipe");
+  const hasParams = pipes.some((p) => p.params.length > 0 && p.type !== "materialized" && p.type !== "copy");
+
+  const sdkImports: string[] = ["node", "t"];
+  if (hasParams) {
+    sdkImports.push("p");
+  }
+  if (hasEndpoint) {
+    sdkImports.push("defineEndpoint", "type InferParams", "type InferOutputRow");
+  }
+  if (hasMaterialized) {
+    sdkImports.push("defineMaterializedView");
+  }
+  if (hasCopy) {
+    sdkImports.push("defineCopyPipe");
+  }
+  if (hasPlainPipe) {
+    sdkImports.push("definePipe");
+  }
+
+  const lines: string[] = [
+    `import { ${sdkImports.join(", ")} } from "@tinybirdco/sdk";`,
+  ];
+
+  // Import datasources referenced by materialized/copy pipes
+  const referencedDatasources = new Set<string>();
+  for (const pipe of pipes) {
+    if (pipe.materialized?.datasource) {
+      referencedDatasources.add(pipe.materialized.datasource);
+    }
+    if (pipe.copy?.target_datasource) {
+      referencedDatasources.add(pipe.copy.target_datasource);
+    }
+  }
+
+  if (referencedDatasources.size > 0) {
+    // Verify datasources exist
+    const existingDatasourceNames = new Set(datasources.map((ds) => ds.name));
+    const validReferences = Array.from(referencedDatasources).filter((name) =>
+      existingDatasourceNames.has(name)
+    );
+
+    if (validReferences.length > 0) {
+      const dsImports = validReferences.map((name) => toCamelCase(name)).join(", ");
+      lines.push(`import { ${dsImports} } from "./datasources.js";`);
+    }
+  }
+
+  lines.push("");
+
+  const code = pipes.map((p) => generatePipeCode(p)).join("\n\n");
+
+  return lines.join("\n") + code + "\n";
+}
+
+/**
+ * Generate the complete client.ts file content
+ */
+export function generateClientFile(
+  datasources: DatasourceInfo[],
+  pipes: PipeInfo[]
+): string {
+  const lines: string[] = [
+    "/**",
+    " * Tinybird Client",
+    " *",
+    " * This file defines the typed Tinybird client for your project.",
+    " * Generated from existing workspace resources.",
+    " */",
+    "",
+    'import { createTinybirdClient } from "@tinybirdco/sdk";',
+    "",
+  ];
+
+  // Import datasources
+  if (datasources.length > 0) {
+    const dsImports: string[] = [];
+    const typeImports: string[] = [];
+
+    for (const ds of datasources) {
+      const varName = toCamelCase(ds.name);
+      const typeName = toPascalCase(ds.name);
+      dsImports.push(varName);
+      typeImports.push(`type ${typeName}Row`);
+    }
+
+    lines.push(`import { ${dsImports.join(", ")}, ${typeImports.join(", ")} } from "./datasources.js";`);
+  }
+
+  // Import pipes (only endpoints are useful for the client)
+  const endpoints = pipes.filter((p) => p.type === "endpoint");
+  if (endpoints.length > 0) {
+    const pipeImports: string[] = [];
+    const typeImports: string[] = [];
+
+    for (const pipe of endpoints) {
+      const varName = toCamelCase(pipe.name);
+      const typeName = toPascalCase(pipe.name);
+      pipeImports.push(varName);
+      typeImports.push(`type ${typeName}Params`, `type ${typeName}Output`);
+    }
+
+    lines.push(`import { ${pipeImports.join(", ")}, ${typeImports.join(", ")} } from "./pipes.js";`);
+  }
+
+  lines.push("");
+
+  // Create client
+  lines.push("// Create the typed Tinybird client");
+  lines.push("export const tinybird = createTinybirdClient({");
+
+  if (datasources.length > 0) {
+    const dsNames = datasources.map((ds) => toCamelCase(ds.name)).join(", ");
+    lines.push(`  datasources: { ${dsNames} },`);
+  } else {
+    lines.push("  datasources: {},");
+  }
+
+  if (endpoints.length > 0) {
+    const pipeNames = endpoints.map((p) => toCamelCase(p.name)).join(", ");
+    lines.push(`  pipes: { ${pipeNames} },`);
+  } else {
+    lines.push("  pipes: {},");
+  }
+
+  lines.push("});");
+  lines.push("");
+
+  // Re-export types
+  if (datasources.length > 0 || endpoints.length > 0) {
+    lines.push("// Re-export types for convenience");
+    const typeExports: string[] = [];
+
+    for (const ds of datasources) {
+      const typeName = toPascalCase(ds.name);
+      typeExports.push(`${typeName}Row`);
+    }
+
+    for (const pipe of endpoints) {
+      const typeName = toPascalCase(pipe.name);
+      typeExports.push(`${typeName}Params`, `${typeName}Output`);
+    }
+
+    lines.push(`export type { ${typeExports.join(", ")} };`);
+    lines.push("");
+  }
+
+  // Re-export entities
+  if (datasources.length > 0 || endpoints.length > 0) {
+    lines.push("// Re-export entities");
+    const entityExports: string[] = [];
+
+    for (const ds of datasources) {
+      entityExports.push(toCamelCase(ds.name));
+    }
+
+    for (const pipe of endpoints) {
+      entityExports.push(toCamelCase(pipe.name));
+    }
+
+    lines.push(`export { ${entityExports.join(", ")} };`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Result of generating all files
+ */
+export interface GeneratedFiles {
+  datasourcesContent: string;
+  pipesContent: string;
+  clientContent: string;
+  datasourceCount: number;
+  pipeCount: number;
+}
+
+/**
+ * Generate all TypeScript files from resources
+ */
+export function generateAllFiles(
+  datasources: DatasourceInfo[],
+  pipes: PipeInfo[]
+): GeneratedFiles {
+  return {
+    datasourcesContent: generateDatasourcesFile(datasources),
+    pipesContent: generatePipesFile(pipes, datasources),
+    clientContent: generateClientFile(datasources, pipes),
+    datasourceCount: datasources.length,
+    pipeCount: pipes.length,
+  };
+}

package/src/codegen/type-mapper.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from "vitest";
+import { clickhouseTypeToValidator, paramTypeToValidator } from "./type-mapper.js";
+
+describe("clickhouseTypeToValidator", () => {
+  describe("simple types", () => {
+    it("maps String to t.string()", () => {
+      expect(clickhouseTypeToValidator("String")).toBe("t.string()");
+    });
+
+    it("maps UUID to t.uuid()", () => {
+      expect(clickhouseTypeToValidator("UUID")).toBe("t.uuid()");
+    });
+
+    it("maps integer types", () => {
+      expect(clickhouseTypeToValidator("Int8")).toBe("t.int8()");
+      expect(clickhouseTypeToValidator("Int16")).toBe("t.int16()");
+      expect(clickhouseTypeToValidator("Int32")).toBe("t.int32()");
+      expect(clickhouseTypeToValidator("Int64")).toBe("t.int64()");
+      expect(clickhouseTypeToValidator("Int128")).toBe("t.int128()");
+      expect(clickhouseTypeToValidator("Int256")).toBe("t.int256()");
+    });
+
+    it("maps unsigned integer types", () => {
+      expect(clickhouseTypeToValidator("UInt8")).toBe("t.uint8()");
+      expect(clickhouseTypeToValidator("UInt16")).toBe("t.uint16()");
+      expect(clickhouseTypeToValidator("UInt32")).toBe("t.uint32()");
+      expect(clickhouseTypeToValidator("UInt64")).toBe("t.uint64()");
+      expect(clickhouseTypeToValidator("UInt128")).toBe("t.uint128()");
+      expect(clickhouseTypeToValidator("UInt256")).toBe("t.uint256()");
+    });
+
+    it("maps float types", () => {
+      expect(clickhouseTypeToValidator("Float32")).toBe("t.float32()");
+      expect(clickhouseTypeToValidator("Float64")).toBe("t.float64()");
+    });
+
+    it("maps Bool to t.bool()", () => {
+      expect(clickhouseTypeToValidator("Bool")).toBe("t.bool()");
+      expect(clickhouseTypeToValidator("Boolean")).toBe("t.bool()");
+    });
+
+    it("maps date types", () => {
+      expect(clickhouseTypeToValidator("Date")).toBe("t.date()");
+      expect(clickhouseTypeToValidator("Date32")).toBe("t.date32()");
+      expect(clickhouseTypeToValidator("DateTime")).toBe("t.dateTime()");
+    });
+
+    it("maps JSON to t.json()", () => {
+      expect(clickhouseTypeToValidator("JSON")).toBe("t.json()");
+    });
+
+    it("maps IP types", () => {
+      expect(clickhouseTypeToValidator("IPv4")).toBe("t.ipv4()");
+      expect(clickhouseTypeToValidator("IPv6")).toBe("t.ipv6()");
+    });
+  });
+
+  describe("Nullable wrapper", () => {
+    it("adds .nullable() for Nullable(String)", () => {
+      expect(clickhouseTypeToValidator("Nullable(String)")).toBe("t.string().nullable()");
+    });
+
+    it("adds .nullable() for Nullable(Int32)", () => {
+      expect(clickhouseTypeToValidator("Nullable(Int32)")).toBe("t.int32().nullable()");
+    });
+
+    it("adds .nullable() for Nullable(DateTime)", () => {
+      expect(clickhouseTypeToValidator("Nullable(DateTime)")).toBe("t.dateTime().nullable()");
+    });
+  });
+
+  describe("LowCardinality wrapper", () => {
+    it("adds .lowCardinality() for LowCardinality(String)", () => {
+      expect(clickhouseTypeToValidator("LowCardinality(String)")).toBe("t.string().lowCardinality()");
+    });
+
+    it("handles LowCardinality(Nullable(String))", () => {
+      expect(clickhouseTypeToValidator("LowCardinality(Nullable(String))")).toBe(
+        "t.string().nullable().lowCardinality()"
+      );
+    });
+  });
+
+  describe("parameterized types", () => {
+    it("handles DateTime with timezone", () => {
+      expect(clickhouseTypeToValidator("DateTime('UTC')")).toBe('t.dateTime("UTC")');
+      expect(clickhouseTypeToValidator("DateTime('America/New_York')")).toBe(
+        't.dateTime("America/New_York")'
+      );
+    });
+
+    it("handles DateTime64 with precision", () => {
+      expect(clickhouseTypeToValidator("DateTime64(3)")).toBe("t.dateTime64(3)");
+      expect(clickhouseTypeToValidator("DateTime64(6)")).toBe("t.dateTime64(6)");
+    });
+
+    it("handles DateTime64 with precision and timezone", () => {
+      expect(clickhouseTypeToValidator("DateTime64(3, 'UTC')")).toBe('t.dateTime64(3, "UTC")');
+    });
+
+    it("handles FixedString(N)", () => {
+      expect(clickhouseTypeToValidator("FixedString(10)")).toBe("t.fixedString(10)");
+      expect(clickhouseTypeToValidator("FixedString(255)")).toBe("t.fixedString(255)");
+    });
+
+    it("handles Decimal(P, S)", () => {
+      expect(clickhouseTypeToValidator("Decimal(10, 2)")).toBe("t.decimal(10, 2)");
+      expect(clickhouseTypeToValidator("Decimal(18, 4)")).toBe("t.decimal(18, 4)");
+    });
+  });
+
+  describe("complex types", () => {
+    it("handles Array(T)", () => {
+      expect(clickhouseTypeToValidator("Array(String)")).toBe("t.array(t.string())");
+      expect(clickhouseTypeToValidator("Array(Int32)")).toBe("t.array(t.int32())");
+    });
+
+    it("handles nested Array types", () => {
+      expect(clickhouseTypeToValidator("Array(Array(String))")).toBe(
+        "t.array(t.array(t.string()))"
+      );
+    });
+
+    it("handles Array with Nullable elements", () => {
+      expect(clickhouseTypeToValidator("Array(Nullable(String))")).toBe(
+        "t.array(t.string().nullable())"
+      );
+    });
+
+    it("handles Map(K, V)", () => {
+      expect(clickhouseTypeToValidator("Map(String, Int32)")).toBe(
+        "t.map(t.string(), t.int32())"
+      );
+    });
+  });
+
+  describe("enum types", () => {
+    it("handles Enum8", () => {
+      expect(clickhouseTypeToValidator("Enum8('a' = 1, 'b' = 2)")).toBe(
+        't.enum8("a", "b")'
+      );
+    });
+
+    it("handles Enum16", () => {
+      expect(clickhouseTypeToValidator("Enum16('pending' = 1, 'active' = 2, 'done' = 3)")).toBe(
+        't.enum16("pending", "active", "done")'
+      );
+    });
+  });
+
+  describe("aggregate function types", () => {
+    it("handles SimpleAggregateFunction", () => {
+      expect(clickhouseTypeToValidator("SimpleAggregateFunction(sum, UInt64)")).toBe(
+        't.simpleAggregateFunction("sum", t.uint64())'
+      );
+    });
+
+    it("handles AggregateFunction", () => {
+      expect(clickhouseTypeToValidator("AggregateFunction(uniq, String)")).toBe(
+        't.aggregateFunction("uniq", t.string())'
+      );
+    });
+  });
+
+  describe("unknown types", () => {
+    it("returns string with TODO comment for unknown types", () => {
+      expect(clickhouseTypeToValidator("UnknownType")).toBe(
+        "t.string() /* TODO: Unknown type: UnknownType */"
+      );
+    });
+  });
+});
+
+describe("paramTypeToValidator", () => {
+  describe("simple types", () => {
+    it("maps String to p.string()", () => {
+      expect(paramTypeToValidator("String")).toBe("p.string()");
+    });
+
+    it("maps Int32 to p.int32()", () => {
+      expect(paramTypeToValidator("Int32")).toBe("p.int32()");
+    });
+
+    it("maps DateTime to p.dateTime()", () => {
+      expect(paramTypeToValidator("DateTime")).toBe("p.dateTime()");
+    });
+
+    it("maps Boolean to p.boolean()", () => {
+      expect(paramTypeToValidator("Boolean")).toBe("p.boolean()");
+      expect(paramTypeToValidator("Bool")).toBe("p.boolean()");
+    });
+  });
+
+  describe("optional parameters", () => {
+    it("adds .optional() for non-required params", () => {
+      expect(paramTypeToValidator("String", undefined, false)).toBe("p.string().optional()");
+    });
+
+    it("adds .optional(default) for params with defaults", () => {
+      expect(paramTypeToValidator("Int32", 10)).toBe("p.int32().optional(10)");
+      expect(paramTypeToValidator("String", "test")).toBe('p.string().optional("test")');
+    });
+
+    it("adds .optional(default) even for required params with defaults", () => {
+      expect(paramTypeToValidator("Int32", 5, true)).toBe("p.int32().optional(5)");
+    });
+  });
+
+  describe("DateTime variants", () => {
+    it("handles DateTime64", () => {
+      expect(paramTypeToValidator("DateTime64")).toBe("p.dateTime64()");
+    });
+
+    it("handles DateTime with timezone", () => {
+      expect(paramTypeToValidator("DateTime('UTC')")).toBe("p.dateTime()");
+    });
+  });
+
+  describe("unknown types", () => {
+    it("defaults to p.string() for unknown types", () => {
+      expect(paramTypeToValidator("UnknownType")).toBe("p.string()");
+    });
+  });
+});