@tinybirdco/sdk 0.0.7 → 0.0.9

package/src/cli/utils/package-manager.ts

@@ -3,42 +3,145 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 
-/**
- * Detect package manager and return the appropriate run command
- */
-export function detectPackageManagerRunCmd(cwd: string = process.cwd()): string {
-  // Check lockfiles first (most reliable)
-  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
+export type PackageManager = "pnpm" | "yarn" | "bun" | "npm";
+const TINYBIRD_SDK_PACKAGE = "@tinybirdco/sdk";
+
+function detectPackageManagerFromLockfile(dir: string): PackageManager | undefined {
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(dir, "yarn.lock"))) return "yarn";
+  if (existsSync(join(dir, "bun.lockb"))) return "bun";
+  if (existsSync(join(dir, "package-lock.json"))) return "npm";
+  return undefined;
+}
+
+function detectPackageManagerFromWorkspace(dir: string): PackageManager | undefined {
+  if (existsSync(join(dir, "pnpm-workspace.yaml"))) return "pnpm";
+  if (existsSync(join(dir, "pnpm-workspace.yml"))) return "pnpm";
+  return undefined;
+}
+
+function detectPackageManagerFromPackageJson(
+  dir: string
+): PackageManager | undefined {
+  const packageJsonPath = join(dir, "package.json");
+  if (!existsSync(packageJsonPath)) return undefined;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const pm = packageJson.packageManager;
+    if (typeof pm !== "string") return undefined;
+    if (pm.startsWith("pnpm")) return "pnpm";
+    if (pm.startsWith("yarn")) return "yarn";
+    if (pm.startsWith("bun")) return "bun";
+    if (pm.startsWith("npm")) return "npm";
+  } catch {
+    return undefined;
   }
-  if (existsSync(join(cwd, "yarn.lock"))) {
-    return "yarn";
+  return undefined;
+}
+
+function getSearchDirs(start: string): string[] {
+  const dirs: string[] = [];
+  let current = resolve(start);
+  while (true) {
+    dirs.push(current);
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return dirs;
+}
+
+function findNearestPackageJson(start: string): string | undefined {
+  for (const dir of getSearchDirs(start)) {
+    const packageJsonPath = join(dir, "package.json");
+    if (existsSync(packageJsonPath)) return packageJsonPath;
   }
-  if (existsSync(join(cwd, "bun.lockb"))) {
-    return "bun run";
+  return undefined;
+}
+
+export function getPackageManagerRunCmd(packageManager: PackageManager): string {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm run";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun run";
+    case "npm":
+    default:
+      return "npm run";
+  }
+}
+
+export function getPackageManagerInstallCmd(
+  packageManager: PackageManager
+): string {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "bun":
+      return "bun install";
+    case "npm":
+    default:
+      return "npm install";
   }
-  if (existsSync(join(cwd, "package-lock.json"))) {
-    return "npm run";
+}
+
+/**
+ * Detect package manager (npm, pnpm, yarn, or bun)
+ */
+export function detectPackageManager(cwd: string = process.cwd()): PackageManager {
+  for (const dir of getSearchDirs(cwd)) {
+    const fromLockfile = detectPackageManagerFromLockfile(dir);
+    if (fromLockfile) return fromLockfile;
+
+    const fromWorkspace = detectPackageManagerFromWorkspace(dir);
+    if (fromWorkspace) return fromWorkspace;
+
+    const fromPackageJson = detectPackageManagerFromPackageJson(dir);
+    if (fromPackageJson) return fromPackageJson;
   }
 
-  // Check packageManager field in package.json
-  const packageJsonPath = join(cwd, "package.json");
-  if (existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-      const pm = packageJson.packageManager;
-      if (typeof pm === "string") {
-        if (pm.startsWith("pnpm")) return "pnpm";
-        if (pm.startsWith("yarn")) return "yarn";
-        if (pm.startsWith("bun")) return "bun run";
-      }
-    } catch {
-      // Ignore parse errors
-    }
+  return "npm";
+}
+
+export function detectPackageManagerInstallCmd(
+  cwd: string = process.cwd()
+): string {
+  return getPackageManagerInstallCmd(detectPackageManager(cwd));
+}
+
+export function hasTinybirdSdkDependency(cwd: string = process.cwd()): boolean {
+  const packageJsonPath = findNearestPackageJson(cwd);
+  if (!packageJsonPath) return false;
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const dependencyFields = [
+      packageJson.dependencies,
+      packageJson.devDependencies,
+      packageJson.peerDependencies,
+      packageJson.optionalDependencies,
+    ];
+
+    return dependencyFields.some(
+      (deps) =>
+        deps &&
+        typeof deps === "object" &&
+        Object.prototype.hasOwnProperty.call(deps, TINYBIRD_SDK_PACKAGE)
+    );
+  } catch {
+    return false;
   }
+}
 
-  // Default to npm
-  return "npm run";
+/**
+ * Detect package manager and return the appropriate run command
+ */
+export function detectPackageManagerRunCmd(cwd: string = process.cwd()): string {
+  return getPackageManagerRunCmd(detectPackageManager(cwd));
 }

package/src/codegen/index.test.ts

@@ -74,6 +74,18 @@ describe("generateDatasourceCode", () => {
     expect(code).toContain(" * Event tracking data");
     expect(code).toContain(" */");
   });
+
+  it("includes forward query when present", () => {
+    const ds: DatasourceInfo = {
+      name: "events",
+      columns: [{ name: "id", type: "String" }],
+      engine: { type: "MergeTree", sorting_key: "id" },
+      forward_query: "SELECT id",
+    };
+
+    const code = generateDatasourceCode(ds);
+    expect(code).toContain("forwardQuery: `SELECT id`");
+  });
 });
 
 describe("generatePipeCode", () => {

package/src/codegen/index.ts

@@ -20,6 +20,9 @@ export function generateDatasourceCode(ds: DatasourceInfo): string {
   const typeName = toPascalCase(ds.name);
   const lines: string[] = [];
 
+  // Check if any columns have jsonpath set
+  const hasJsonpath = ds.columns.some((col) => col.jsonpath);
+
   // JSDoc comment
   if (ds.description) {
     lines.push("/**");
@@ -33,6 +36,11 @@ export function generateDatasourceCode(ds: DatasourceInfo): string {
     lines.push(`  description: "${escapeString(ds.description)}",`);
   }
 
+  // Add jsonPaths: false if no columns use jsonpath
+  if (!hasJsonpath) {
+    lines.push("  jsonPaths: false,");
+  }
+
   // Schema
   lines.push("  schema: {");
   for (const col of ds.columns) {
@@ -45,6 +53,11 @@ export function generateDatasourceCode(ds: DatasourceInfo): string {
   const engineCode = generateEngineCode(ds.engine);
   lines.push(`  engine: ${engineCode},`);
 
+  if (ds.forward_query) {
+    const formattedQuery = formatSqlForTemplate(ds.forward_query);
+    lines.push(`  forwardQuery: \`${formattedQuery}\`,`);
+  }
+
   lines.push("});");
   lines.push("");
   lines.push(`export type ${typeName}Row = InferRow<typeof ${varName}>;`);
@@ -377,3 +390,110 @@ export function generateAllFiles(
     pipeCount: pipes.length,
   };
 }
+
+/**
+ * Generate a single combined tinybird.ts file with all definitions
+ */
+export function generateCombinedFile(
+  datasources: DatasourceInfo[],
+  pipes: PipeInfo[]
+): string {
+  const lines: string[] = [
+    "/**",
+    " * Tinybird Definitions",
+    " *",
+    " * This file contains all datasource and endpoint definitions.",
+    " * Generated from existing workspace resources.",
+    " */",
+    "",
+  ];
+
+  // Build imports
+  const sdkImports: string[] = ["createTinybirdClient", "t"];
+
+  if (datasources.length > 0) {
+    sdkImports.push("defineDatasource", "engine", "type InferRow");
+  }
+
+  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"
+  );
+
+  if (pipes.length > 0) {
+    sdkImports.push("node");
+  }
+  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");
+  }
+
+  lines.push(`import {`);
+  lines.push(`  ${sdkImports.join(",\n  ")},`);
+  lines.push(`} from "@tinybirdco/sdk";`);
+  lines.push("");
+
+  // Datasources section
+  if (datasources.length > 0) {
+    lines.push("// ============================================================================");
+    lines.push("// Datasources");
+    lines.push("// ============================================================================");
+    lines.push("");
+
+    for (const ds of datasources) {
+      lines.push(generateDatasourceCode(ds));
+      lines.push("");
+    }
+  }
+
+  // Pipes/Endpoints section
+  if (pipes.length > 0) {
+    lines.push("// ============================================================================");
+    lines.push("// Endpoints");
+    lines.push("// ============================================================================");
+    lines.push("");
+
+    for (const pipe of pipes) {
+      lines.push(generatePipeCode(pipe));
+      lines.push("");
+    }
+  }
+
+  // Client section
+  lines.push("// ============================================================================");
+  lines.push("// Client");
+  lines.push("// ============================================================================");
+  lines.push("");
+
+  const dsNames =
+    datasources.length > 0
+      ? datasources.map((ds) => toCamelCase(ds.name)).join(", ")
+      : "";
+  const endpoints = pipes.filter((p) => p.type === "endpoint");
+  const pipeNames =
+    endpoints.length > 0
+      ? endpoints.map((p) => toCamelCase(p.name)).join(", ")
+      : "";
+
+  lines.push("export const tinybird = createTinybirdClient({");
+  lines.push(`  datasources: { ${dsNames} },`);
+  lines.push(`  pipes: { ${pipeNames} },`);
+  lines.push("});");
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/generator/datasource.test.ts

@@ -81,6 +81,19 @@ describe('Datasource Generator', () => {
       const result = generateDatasource(ds);
       expect(result.content).toContain('ENGINE_TTL "timestamp + INTERVAL 90 DAY"');
     });
+
+    it('includes forward query when provided', () => {
+      const ds = defineDatasource('test_ds', {
+        schema: {
+          id: t.string(),
+        },
+        forwardQuery: 'SELECT id',
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain('FORWARD_QUERY >');
+      expect(result.content).toContain('    SELECT id');
+    });
   });
 
   describe('Column formatting', () => {

package/src/generator/datasource.ts

@@ -163,6 +163,23 @@ function generateKafkaConfig(kafka: KafkaConfig): string {
   return parts.join("\n");
 }
 
+/**
+ * Generate forward query section
+ */
+function generateForwardQuery(forwardQuery?: string): string | null {
+  if (!forwardQuery) {
+    return null;
+  }
+
+  const trimmed = forwardQuery.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const lines = trimmed.split(/\r?\n/);
+  return ["FORWARD_QUERY >", ...lines.map((line) => `    ${line}`)].join("\n");
+}
+
 /**
  * Generate a .datasource file content from a DatasourceDefinition
  *
@@ -224,6 +241,13 @@ export function generateDatasource(
     parts.push(generateKafkaConfig(datasource.options.kafka));
   }
 
+  // Add forward query if present
+  const forwardQuery = generateForwardQuery(datasource.options.forwardQuery);
+  if (forwardQuery) {
+    parts.push("");
+    parts.push(forwardQuery);
+  }
+
   return {
     name: datasource._name,
     content: parts.join("\n"),

package/src/schema/datasource.ts

@@ -71,6 +71,11 @@ export interface DatasourceOptions<TSchema extends SchemaDefinition> {
    * Defaults to true.
    */
   jsonPaths?: boolean;
+  /**
+   * Forward query used to evolve a datasource with incompatible schema changes.
+   * This should be the SELECT clause only (no FROM/WHERE).
+   */
+  forwardQuery?: string;
   /** Kafka ingestion configuration */
   kafka?: KafkaConfig;
 }