@tinybirdco/sdk 0.0.1

package/src/cli/index.ts

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+/**
+ * Tinybird CLI
+ * Commands for building and deploying Tinybird projects
+ */
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { Command } from "commander";
+import { runInit } from "./commands/init.js";
+import { runBuild } from "./commands/build.js";
+import { runDev } from "./commands/dev.js";
+import { runLogin } from "./commands/login.js";
+import {
+  runBranchList,
+  runBranchStatus,
+  runBranchDelete,
+} from "./commands/branch.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(
+  readFileSync(resolve(__dirname, "../../package.json"), "utf-8")
+) as { version: string };
+const VERSION = packageJson.version;
+
+/**
+ * Format timestamp for console output
+ */
+function formatTime(): string {
+  return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+
+/**
+ * Create and configure the CLI
+ */
+function createCli(): Command {
+  const program = new Command();
+
+  program
+    .name("tinybird")
+    .description("Tinybird TypeScript SDK CLI")
+    .version(VERSION);
+
+  // Init command
+  program
+    .command("init")
+    .description("Initialize a new Tinybird TypeScript project")
+    .option("-f, --force", "Overwrite existing files")
+    .option("--skip-login", "Skip browser login flow")
+    .action(async (options) => {
+      console.log("Initializing Tinybird project...\n");
+
+      const result = await runInit({
+        force: options.force,
+        skipLogin: options.skipLogin,
+      });
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      if (result.created.length > 0) {
+        console.log("Created:");
+        result.created.forEach((file) => {
+          console.log(`  - ${file}`);
+        });
+      }
+
+      if (result.skipped.length > 0) {
+        console.log("\nSkipped (already exists):");
+        result.skipped.forEach((file) => {
+          console.log(`  - ${file}`);
+        });
+      }
+
+      if (result.loggedIn) {
+        console.log(`\nLogged in successfully!`);
+        if (result.workspaceName) {
+          console.log(`  Workspace: ${result.workspaceName}`);
+        }
+        if (result.userEmail) {
+          console.log(`  User: ${result.userEmail}`);
+        }
+        console.log("\nDone! Next steps:");
+        console.log("  1. Edit src/tinybird/schema.ts with your schema");
+        console.log("  2. Run 'npx tinybird dev' to start development");
+      } else if (result.loggedIn === false) {
+        console.log("\nLogin was skipped or failed.");
+        console.log("\nDone! Next steps:");
+        console.log("  1. Run 'npx tinybird login' to authenticate");
+        console.log("  2. Edit src/tinybird/schema.ts with your schema");
+        console.log("  3. Run 'npx tinybird dev' to start development");
+      } else {
+        console.log("\nDone! Next steps:");
+        console.log("  1. Edit src/tinybird/schema.ts with your schema");
+        console.log("  2. Run 'npx tinybird dev' to start development");
+      }
+    });
+
+  // Login command
+  program
+    .command("login")
+    .description("Authenticate with Tinybird via browser")
+    .action(async () => {
+      console.log("Starting authentication...\n");
+
+      const result = await runLogin();
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      console.log("\nAuthentication successful!");
+      if (result.workspaceName) {
+        console.log(`  Workspace: ${result.workspaceName}`);
+      }
+      if (result.userEmail) {
+        console.log(`  User: ${result.userEmail}`);
+      }
+      if (result.baseUrl) {
+        console.log(`  API Host: ${result.baseUrl}`);
+      }
+    });
+
+  // Build command
+  program
+    .command("build")
+    .description("Build and push resources to Tinybird")
+    .option("--dry-run", "Generate without pushing to API")
+    .option("--debug", "Show debug output including API requests/responses")
+    .action(async (options) => {
+      if (options.debug) {
+        process.env.TINYBIRD_DEBUG = "1";
+      }
+      console.log(`[${formatTime()}] Building...\n`);
+
+      const result = await runBuild({
+        dryRun: options.dryRun,
+      });
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      const { build, deploy } = result;
+
+      if (build) {
+        console.log(`Generated ${build.stats.datasourceCount} datasource(s), ${build.stats.pipeCount} pipe(s)`);
+      }
+
+      if (options.dryRun) {
+        console.log("\n[Dry run] Resources not deployed to API");
+
+        // Show generated content
+        if (build) {
+          console.log("\n--- Generated Datasources ---");
+          build.resources.datasources.forEach((ds) => {
+            console.log(`\n${ds.name}.datasource:`);
+            console.log(ds.content);
+          });
+
+          console.log("\n--- Generated Pipes ---");
+          build.resources.pipes.forEach((pipe) => {
+            console.log(`\n${pipe.name}.pipe:`);
+            console.log(pipe.content);
+          });
+        }
+      } else if (deploy) {
+        if (deploy.result === "no_changes") {
+          console.log("No changes detected - already up to date");
+        } else {
+          console.log(`Deployed to Tinybird successfully`);
+        }
+      }
+
+      console.log(`\n[${formatTime()}] Done in ${result.durationMs}ms`);
+    });
+
+  // Dev command
+  program
+    .command("dev")
+    .description("Watch for changes and sync with Tinybird")
+    .action(async () => {
+      console.log(`tinybird dev v${VERSION}`);
+      console.log("Loading config from tinybird.json...\n");
+
+      try {
+        const controller = await runDev({
+          onLoginComplete: (info) => {
+            console.log("\nAuthentication successful!");
+            if (info.workspaceName) {
+              console.log(`  Workspace: ${info.workspaceName}`);
+            }
+            if (info.userEmail) {
+              console.log(`  User: ${info.userEmail}`);
+            }
+            console.log("");
+          },
+          onBranchReady: (info) => {
+            if (info.isMainBranch) {
+              console.log("On main branch - deploying to workspace\n");
+            } else if (info.gitBranch) {
+              const tinybirdName = info.tinybirdBranch?.name ?? info.gitBranch;
+              if (info.wasCreated) {
+                console.log(`Detected git branch: ${info.gitBranch}`);
+                console.log(`Creating Tinybird branch '${tinybirdName}'...`);
+                console.log("Branch created and token cached.\n");
+              } else {
+                console.log(`Detected git branch: ${info.gitBranch}`);
+                console.log(`Using existing Tinybird branch '${tinybirdName}'\n`);
+              }
+            } else {
+              console.log("Not in a git repository - deploying to workspace\n");
+            }
+          },
+          onBuildStart: () => {
+            console.log(`[${formatTime()}] Building...`);
+          },
+          onBuildComplete: (result) => {
+            if (!result.success) {
+              console.error(`[${formatTime()}] Build failed: ${result.error}`);
+              return;
+            }
+
+            const { deploy } = result;
+
+            if (deploy) {
+              if (deploy.result === "no_changes") {
+                console.log(`[${formatTime()}] No changes detected`);
+              } else {
+                console.log(`[${formatTime()}] Built in ${result.durationMs}ms`);
+
+                // Show datasource changes
+                if (deploy.datasources) {
+                  for (const name of deploy.datasources.created) {
+                    console.log(`  + datasource ${name} (created)`);
+                  }
+                  for (const name of deploy.datasources.changed) {
+                    console.log(`  ~ datasource ${name} (changed)`);
+                  }
+                  for (const name of deploy.datasources.deleted) {
+                    console.log(`  - datasource ${name} (deleted)`);
+                  }
+                }
+
+                // Show pipe changes
+                if (deploy.pipes) {
+                  for (const name of deploy.pipes.created) {
+                    console.log(`  + pipe ${name} (created)`);
+                  }
+                  for (const name of deploy.pipes.changed) {
+                    console.log(`  ~ pipe ${name} (changed)`);
+                  }
+                  for (const name of deploy.pipes.deleted) {
+                    console.log(`  - pipe ${name} (deleted)`);
+                  }
+                }
+              }
+            }
+          },
+          onSchemaValidation: (validation) => {
+            if (validation.issues.length > 0) {
+              console.log(`[${formatTime()}] Schema validation:`);
+              for (const issue of validation.issues) {
+                if (issue.type === "error") {
+                  console.error(`  ERROR [${issue.pipeName}]: ${issue.message}`);
+                } else {
+                  console.warn(`  WARN [${issue.pipeName}]: ${issue.message}`);
+                }
+              }
+            }
+          },
+          onError: (error) => {
+            console.error(`[${formatTime()}] Error: ${error.message}`);
+          },
+        });
+
+        console.log("Watching for changes... (Ctrl+C to stop)\n");
+
+        // Handle shutdown
+        const shutdown = async () => {
+          console.log("\nShutting down...");
+          await controller.stop();
+          process.exit(0);
+        };
+
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+
+        // Keep process alive
+        await new Promise(() => {});
+      } catch (error) {
+        console.error(`Error: ${(error as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Branch command
+  const branchCommand = new Command("branch")
+    .description("Manage Tinybird branches");
+
+  branchCommand
+    .command("list")
+    .description("List all Tinybird branches")
+    .action(async () => {
+      const result = await runBranchList();
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      if (!result.branches || result.branches.length === 0) {
+        console.log("No branches found.");
+        return;
+      }
+
+      console.log("Branches:");
+      result.branches.forEach((branch) => {
+        console.log(`  - ${branch.name} (created: ${branch.created_at})`);
+      });
+    });
+
+  branchCommand
+    .command("status")
+    .description("Show current branch status")
+    .action(async () => {
+      const result = await runBranchStatus();
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      console.log("Branch Status:");
+      console.log(`  Git branch: ${result.gitBranch ?? "(not in git repo)"}`);
+      if (result.tinybirdBranchName && result.tinybirdBranchName !== result.gitBranch) {
+        console.log(`  Tinybird branch name: ${result.tinybirdBranchName} (sanitized)`);
+      }
+      console.log(`  Main branch: ${result.isMainBranch ? "yes" : "no"}`);
+
+      if (result.tinybirdBranch) {
+        console.log(`  Tinybird branch: ${result.tinybirdBranch.name}`);
+        console.log(`  Branch ID: ${result.tinybirdBranch.id}`);
+        console.log(`  Created: ${result.tinybirdBranch.created_at}`);
+      } else if (!result.isMainBranch && result.tinybirdBranchName) {
+        console.log("  Tinybird branch: not created yet");
+        console.log("  (Run 'npx tinybird dev' to create it)");
+      }
+
+      console.log(`  Cached token: ${result.hasCachedToken ? "yes" : "no"}`);
+    });
+
+  branchCommand
+    .command("delete")
+    .description("Delete a Tinybird branch")
+    .argument("<name>", "Branch name to delete")
+    .action(async (name) => {
+      console.log(`Deleting branch '${name}'...`);
+
+      const result = await runBranchDelete(name);
+
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+
+      console.log(`Branch '${name}' deleted successfully.`);
+    });
+
+  program.addCommand(branchCommand);
+
+  return program;
+}
+
+// Run CLI
+const program = createCli();
+program.parse();

package/src/cli/utils/schema-validation.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Tests for schema validation utility
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  _typesAreCompatible,
+  _validateOutputSchema,
+  _hasRequiredParams,
+  _buildDefaultParams,
+} from "./schema-validation.js";
+import type { PipeDefinition } from "../../schema/pipe.js";
+import type { ColumnMeta } from "../../client/types.js";
+
+describe("typesAreCompatible", () => {
+  it("matches identical types", () => {
+    expect(_typesAreCompatible("String", "String")).toBe(true);
+    expect(_typesAreCompatible("Int64", "Int64")).toBe(true);
+    expect(_typesAreCompatible("UInt64", "UInt64")).toBe(true);
+  });
+
+  it("matches Nullable wrapped types", () => {
+    expect(_typesAreCompatible("Nullable(String)", "String")).toBe(true);
+    expect(_typesAreCompatible("Nullable(Int64)", "Int64")).toBe(true);
+  });
+
+  it("matches LowCardinality wrapped types", () => {
+    expect(_typesAreCompatible("LowCardinality(String)", "String")).toBe(true);
+  });
+
+  it("matches LowCardinality(Nullable(...)) wrapped types", () => {
+    expect(
+      _typesAreCompatible("LowCardinality(Nullable(String))", "String")
+    ).toBe(true);
+  });
+
+  it("matches DateTime with timezone to base DateTime", () => {
+    expect(_typesAreCompatible("DateTime('UTC')", "DateTime")).toBe(true);
+    expect(_typesAreCompatible("DateTime('Europe/Madrid')", "DateTime")).toBe(
+      true
+    );
+  });
+
+  it("matches DateTime64 with precision", () => {
+    expect(_typesAreCompatible("DateTime64(3)", "DateTime64")).toBe(true);
+    expect(_typesAreCompatible("DateTime64(6, 'UTC')", "DateTime64")).toBe(
+      true
+    );
+  });
+
+  it("rejects mismatched types", () => {
+    expect(_typesAreCompatible("String", "Int64")).toBe(false);
+    expect(_typesAreCompatible("UInt64", "Int64")).toBe(false);
+    expect(_typesAreCompatible("DateTime", "Date")).toBe(false);
+  });
+});
+
+describe("validateOutputSchema", () => {
+  it("validates matching schema", () => {
+    const responseMeta: ColumnMeta[] = [
+      { name: "id", type: "UInt64" },
+      { name: "name", type: "String" },
+    ];
+
+    const outputSchema = {
+      id: { _tinybirdType: "UInt64" },
+      name: { _tinybirdType: "String" },
+    };
+
+    const result = _validateOutputSchema(responseMeta, outputSchema as any);
+
+    expect(result.valid).toBe(true);
+    expect(result.missingColumns).toHaveLength(0);
+    expect(result.extraColumns).toHaveLength(0);
+    expect(result.typeMismatches).toHaveLength(0);
+  });
+
+  it("detects missing columns", () => {
+    const responseMeta: ColumnMeta[] = [{ name: "id", type: "UInt64" }];
+
+    const outputSchema = {
+      id: { _tinybirdType: "UInt64" },
+      name: { _tinybirdType: "String" },
+    };
+
+    const result = _validateOutputSchema(responseMeta, outputSchema as any);
+
+    expect(result.valid).toBe(false);
+    expect(result.missingColumns).toHaveLength(1);
+    expect(result.missingColumns[0]).toEqual({
+      name: "name",
+      expectedType: "String",
+    });
+  });
+
+  it("detects extra columns", () => {
+    const responseMeta: ColumnMeta[] = [
+      { name: "id", type: "UInt64" },
+      { name: "extra", type: "String" },
+    ];
+
+    const outputSchema = {
+      id: { _tinybirdType: "UInt64" },
+    };
+
+    const result = _validateOutputSchema(responseMeta, outputSchema as any);
+
+    // Extra columns are warnings, not errors
+    expect(result.valid).toBe(true);
+    expect(result.extraColumns).toHaveLength(1);
+    expect(result.extraColumns[0]).toEqual({
+      name: "extra",
+      actualType: "String",
+    });
+  });
+
+  it("detects type mismatches", () => {
+    const responseMeta: ColumnMeta[] = [{ name: "count", type: "Int64" }];
+
+    const outputSchema = {
+      count: { _tinybirdType: "UInt64" },
+    };
+
+    const result = _validateOutputSchema(responseMeta, outputSchema as any);
+
+    expect(result.valid).toBe(false);
+    expect(result.typeMismatches).toHaveLength(1);
+    expect(result.typeMismatches[0]).toEqual({
+      name: "count",
+      expectedType: "UInt64",
+      actualType: "Int64",
+    });
+  });
+
+  it("handles Nullable types as compatible", () => {
+    const responseMeta: ColumnMeta[] = [
+      { name: "value", type: "Nullable(String)" },
+    ];
+
+    const outputSchema = {
+      value: { _tinybirdType: "String" },
+    };
+
+    const result = _validateOutputSchema(responseMeta, outputSchema as any);
+
+    expect(result.valid).toBe(true);
+    expect(result.typeMismatches).toHaveLength(0);
+  });
+});
+
+describe("hasRequiredParams", () => {
+  it("returns false for pipe with no params", () => {
+    const pipe = { _name: "test" } as PipeDefinition;
+    expect(_hasRequiredParams(pipe)).toBe(false);
+  });
+
+  it("returns false for pipe with only optional params", () => {
+    const pipe = {
+      _name: "test",
+      _params: {
+        limit: { _required: false, _default: 10 },
+      },
+    } as unknown as PipeDefinition;
+    expect(_hasRequiredParams(pipe)).toBe(false);
+  });
+
+  it("returns true for pipe with required param without default", () => {
+    const pipe = {
+      _name: "test",
+      _params: {
+        start_date: { _required: true, _default: undefined },
+      },
+    } as unknown as PipeDefinition;
+    expect(_hasRequiredParams(pipe)).toBe(true);
+  });
+
+  it("returns false for required param with default value", () => {
+    const pipe = {
+      _name: "test",
+      _params: {
+        start_date: { _required: true, _default: "2024-01-01" },
+      },
+    } as unknown as PipeDefinition;
+    expect(_hasRequiredParams(pipe)).toBe(false);
+  });
+});
+
+describe("buildDefaultParams", () => {
+  it("returns empty object for pipe with no params", () => {
+    const pipe = { _name: "test" } as PipeDefinition;
+    expect(_buildDefaultParams(pipe)).toEqual({});
+  });
+
+  it("includes params with default values", () => {
+    const pipe = {
+      _name: "test",
+      _params: {
+        limit: { _required: false, _default: 10 },
+        offset: { _required: false, _default: 0 },
+      },
+    } as unknown as PipeDefinition;
+
+    expect(_buildDefaultParams(pipe)).toEqual({
+      limit: 10,
+      offset: 0,
+    });
+  });
+
+  it("excludes params without default values", () => {
+    const pipe = {
+      _name: "test",
+      _params: {
+        limit: { _required: false, _default: 10 },
+        start_date: { _required: true, _default: undefined },
+      },
+    } as unknown as PipeDefinition;
+
+    expect(_buildDefaultParams(pipe)).toEqual({
+      limit: 10,
+    });
+  });
+});