@tinybirdco/sdk 0.0.1

package/src/cli/commands/dev.ts

@@ -0,0 +1,334 @@
+/**
+ * Dev command - watch mode with automatic sync
+ */
+
+import * as path from "path";
+import { watch } from "chokidar";
+import { loadConfig, configExists, findConfigFile, hasValidToken, updateConfig, type ResolvedConfig } from "../config.js";
+import { runBuild, type BuildCommandResult } from "./build.js";
+import { getOrCreateBranch, type TinybirdBranch } from "../../api/branches.js";
+import { browserLogin } from "../auth.js";
+import { saveTinybirdToken } from "../env.js";
+import {
+  validatePipeSchemas,
+  type SchemaValidationResult,
+} from "../utils/schema-validation.js";
+
+/**
+ * Login result info
+ */
+export interface LoginInfo {
+  /** Workspace name */
+  workspaceName?: string;
+  /** User email */
+  userEmail?: string;
+}
+
+/**
+ * Dev command options
+ */
+export interface DevCommandOptions {
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Debounce delay in milliseconds (default: 100) */
+  debounce?: number;
+  /** Callback when build starts */
+  onBuildStart?: () => void;
+  /** Callback when build completes */
+  onBuildComplete?: (result: BuildCommandResult) => void;
+  /** Callback when an error occurs */
+  onError?: (error: Error) => void;
+  /** Callback when branch is created/detected */
+  onBranchReady?: (info: BranchReadyInfo) => void;
+  /** Callback when login is needed and completed */
+  onLoginComplete?: (info: LoginInfo) => void;
+  /** Callback when schema validation completes */
+  onSchemaValidation?: (result: SchemaValidationResult) => void;
+}
+
+/**
+ * Information about the branch being used
+ */
+export interface BranchReadyInfo {
+  /** Git branch name */
+  gitBranch: string | null;
+  /** Whether we're on the main branch */
+  isMainBranch: boolean;
+  /** Tinybird branch info (null if on main) */
+  tinybirdBranch?: TinybirdBranch;
+  /** Whether the branch was newly created */
+  wasCreated?: boolean;
+}
+
+/**
+ * Dev command controller
+ */
+export interface DevController {
+  /** Stop watching and clean up */
+  stop: () => Promise<void>;
+  /** Trigger a manual rebuild */
+  rebuild: () => Promise<BuildCommandResult>;
+  /** The configuration being used */
+  config: ResolvedConfig;
+  /** The effective token (branch token or main token) */
+  effectiveToken: string;
+  /** Branch info */
+  branchInfo: BranchReadyInfo;
+}
+
+/**
+ * Run the dev command
+ *
+ * Watches for file changes and automatically rebuilds and pushes to Tinybird.
+ * Automatically manages Tinybird branches based on git branch:
+ * - Main branch: uses workspace token and /v1/deploy
+ * - Feature branches: creates/reuses Tinybird branch and uses /v1/build
+ *
+ * @param options - Dev options
+ * @returns Dev controller
+ */
+export async function runDev(options: DevCommandOptions = {}): Promise<DevController> {
+  const cwd = options.cwd ?? process.cwd();
+  const debounceMs = options.debounce ?? 100;
+
+  // Check if project is initialized
+  if (!configExists(cwd)) {
+    throw new Error(
+      "No tinybird.json found. Run 'npx tinybird init' to initialize a project."
+    );
+  }
+
+  // Check if authentication is set up, if not trigger login
+  if (!hasValidToken(cwd)) {
+    console.log("No authentication found. Starting login flow...\n");
+
+    const authResult = await browserLogin();
+
+    if (!authResult.success || !authResult.token) {
+      throw new Error(
+        authResult.error ?? "Login failed. Run 'npx tinybird login' to authenticate."
+      );
+    }
+
+    // Find the config file (may be in parent directory)
+    const configPath = findConfigFile(cwd);
+    if (!configPath) {
+      throw new Error("No tinybird.json found. Run 'npx tinybird init' first.");
+    }
+
+    // Save token to .env.local (in same directory as tinybird.json)
+    const configDir = path.dirname(configPath);
+    saveTinybirdToken(configDir, authResult.token);
+
+    // Update baseUrl in tinybird.json if it changed
+    if (authResult.baseUrl) {
+      updateConfig(configPath, {
+        baseUrl: authResult.baseUrl,
+      });
+    }
+
+    // Set the token in the environment for this session
+    process.env.TINYBIRD_TOKEN = authResult.token;
+
+    options.onLoginComplete?.({
+      workspaceName: authResult.workspaceName,
+      userEmail: authResult.userEmail,
+    });
+  }
+
+  // Load config (now should have valid token)
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    throw error;
+  }
+
+  // Determine effective token based on git branch
+  let effectiveToken = config.token;
+  let branchInfo: BranchReadyInfo = {
+    gitBranch: config.gitBranch,
+    isMainBranch: config.isMainBranch,
+  };
+
+  // If we're on a feature branch, get or create the Tinybird branch
+  // Use tinybirdBranch (sanitized name) for Tinybird API, gitBranch for display
+  if (!config.isMainBranch && config.tinybirdBranch) {
+    const branchName = config.tinybirdBranch; // Sanitized name for Tinybird
+
+    // Always fetch fresh from API to avoid stale cache issues
+    const tinybirdBranch = await getOrCreateBranch(
+      {
+        baseUrl: config.baseUrl,
+        token: config.token,
+      },
+      branchName
+    );
+
+    if (!tinybirdBranch.token) {
+      throw new Error(
+        `Branch '${branchName}' was created but no token was returned. ` +
+          `This may be an API issue.`
+      );
+    }
+
+    effectiveToken = tinybirdBranch.token;
+    branchInfo = {
+      gitBranch: config.gitBranch, // Original git branch name for display
+      isMainBranch: false,
+      tinybirdBranch,
+      wasCreated: tinybirdBranch.wasCreated ?? false,
+    };
+  }
+
+  // Notify about branch readiness
+  options.onBranchReady?.(branchInfo);
+
+  // Get directories to watch from include paths
+  const watchDirs = new Set<string>();
+  for (const includePath of config.include) {
+    const absolutePath = path.isAbsolute(includePath)
+      ? includePath
+      : path.resolve(config.cwd, includePath);
+    watchDirs.add(path.dirname(absolutePath));
+  }
+
+  // Debounce state
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  let isBuilding = false;
+  let pendingBuild = false;
+
+  // Build function
+  async function doBuild(): Promise<BuildCommandResult> {
+    if (isBuilding) {
+      pendingBuild = true;
+      return { success: false, error: "Build already in progress", durationMs: 0 };
+    }
+
+    isBuilding = true;
+    options.onBuildStart?.();
+
+    try {
+      const result = await runBuild({
+        cwd: config.cwd,
+        tokenOverride: effectiveToken,
+        useDeployEndpoint: config.isMainBranch,
+      });
+      options.onBuildComplete?.(result);
+
+      // Validate pipe schemas after successful deploy
+      if (
+        result.success &&
+        result.build?.entities &&
+        result.deploy?.pipes &&
+        options.onSchemaValidation
+      ) {
+        // Get changed pipes from deploy result
+        const changedPipes = [
+          ...result.deploy.pipes.created,
+          ...result.deploy.pipes.changed,
+        ];
+
+        if (changedPipes.length > 0) {
+          try {
+            const validation = await validatePipeSchemas({
+              entities: result.build.entities,
+              pipeNames: changedPipes,
+              baseUrl: config.baseUrl,
+              token: effectiveToken,
+            });
+
+            options.onSchemaValidation(validation);
+          } catch (validationError) {
+            // Don't fail the build due to validation errors
+            options.onError?.(validationError as Error);
+          }
+        }
+      }
+
+      return result;
+    } catch (error) {
+      const result: BuildCommandResult = {
+        success: false,
+        error: (error as Error).message,
+        durationMs: 0,
+      };
+      options.onBuildComplete?.(result);
+      return result;
+    } finally {
+      isBuilding = false;
+
+      // If there was a pending build, trigger it
+      if (pendingBuild) {
+        pendingBuild = false;
+        scheduleBuild();
+      }
+    }
+  }
+
+  // Schedule a debounced build
+  function scheduleBuild(): void {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      doBuild().catch((error) => {
+        options.onError?.(error as Error);
+      });
+    }, debounceMs);
+  }
+
+  // Set up file watcher for all include directories
+  const watcher = watch(Array.from(watchDirs), {
+    ignored: [
+      /(^|[\/\\])\../, // Ignore dotfiles
+      /node_modules/,
+      /\.tinybird-schema-.*\.mjs$/, // Ignore temporary bundle files
+      /\.tinybird-entities-.*\.mjs$/, // Ignore temporary entity files
+    ],
+    persistent: true,
+    ignoreInitial: true,
+  });
+
+  // Watch for changes
+  watcher.on("change", (filePath) => {
+    if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+      scheduleBuild();
+    }
+  });
+
+  watcher.on("add", (filePath) => {
+    if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+      scheduleBuild();
+    }
+  });
+
+  watcher.on("unlink", (filePath) => {
+    if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+      scheduleBuild();
+    }
+  });
+
+  watcher.on("error", (error: unknown) => {
+    options.onError?.(error instanceof Error ? error : new Error(String(error)));
+  });
+
+  // Do initial build
+  await doBuild();
+
+  // Return controller
+  return {
+    stop: async () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      await watcher.close();
+    },
+    rebuild: doBuild,
+    config,
+    effectiveToken,
+    branchInfo,
+  };
+}

package/src/cli/commands/init.test.ts

@@ -0,0 +1,249 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { runInit } from "./init.js";
+
+// Mock the auth module to avoid browser login
+vi.mock("../auth.js", () => ({
+  browserLogin: vi.fn().mockResolvedValue({ success: false }),
+}));
+
+describe("Init Command", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-init-test-"));
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("folder structure creation", () => {
+    it("creates tinybird folder with datasources.ts, pipes.ts, client.ts when project has no src folder", async () => {
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+      expect(result.created).toContain("tinybird/datasources.ts");
+      expect(result.created).toContain("tinybird/pipes.ts");
+      expect(result.created).toContain("tinybird/client.ts");
+      expect(fs.existsSync(path.join(tempDir, "tinybird", "datasources.ts"))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, "tinybird", "pipes.ts"))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, "tinybird", "client.ts"))).toBe(true);
+    });
+
+    it("creates src/tinybird folder with files when project has src folder", async () => {
+      // Create src folder to simulate existing project
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+      expect(result.created).toContain("src/tinybird/datasources.ts");
+      expect(result.created).toContain("src/tinybird/pipes.ts");
+      expect(result.created).toContain("src/tinybird/client.ts");
+      expect(
+        fs.existsSync(path.join(tempDir, "src", "tinybird", "datasources.ts"))
+      ).toBe(true);
+      expect(
+        fs.existsSync(path.join(tempDir, "src", "tinybird", "pipes.ts"))
+      ).toBe(true);
+      expect(
+        fs.existsSync(path.join(tempDir, "src", "tinybird", "client.ts"))
+      ).toBe(true);
+    });
+
+    it("creates tinybird.json with correct include paths for tinybird folder", async () => {
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+      expect(result.created).toContain("tinybird.json");
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).toEqual([
+        "tinybird/datasources.ts",
+        "tinybird/pipes.ts",
+      ]);
+    });
+
+    it("creates tinybird.json with correct include paths for src/tinybird", async () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).toEqual([
+        "src/tinybird/datasources.ts",
+        "src/tinybird/pipes.ts",
+      ]);
+    });
+  });
+
+  describe("config file creation", () => {
+    it("creates tinybird.json with default values", async () => {
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+
+      expect(config.token).toBe("${TINYBIRD_TOKEN}");
+      expect(config.baseUrl).toBe("https://api.tinybird.co");
+    });
+
+    it("skips tinybird.json if it already exists", async () => {
+      const existingConfig = { schema: "custom.ts", token: "existing" };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(existingConfig)
+      );
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+      expect(result.skipped).toContain("tinybird.json");
+
+      // Verify it wasn't overwritten
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.schema).toBe("custom.ts");
+    });
+
+    it("overwrites tinybird.json with force option", async () => {
+      const existingConfig = { include: ["custom.ts"], token: "existing" };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(existingConfig)
+      );
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true });
+
+      expect(result.success).toBe(true);
+      expect(result.created).toContain("tinybird.json");
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).toEqual([
+        "tinybird/datasources.ts",
+        "tinybird/pipes.ts",
+      ]);
+    });
+  });
+
+  describe("file content creation", () => {
+    it("creates datasources.ts with example datasource and InferRow type", async () => {
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      const content = fs.readFileSync(
+        path.join(tempDir, "tinybird", "datasources.ts"),
+        "utf-8"
+      );
+
+      expect(content).toContain("defineDatasource");
+      expect(content).toContain("export const pageViews");
+      expect(content).toContain("InferRow");
+      expect(content).toContain("PageViewsRow");
+    });
+
+    it("creates pipes.ts with example endpoint and types", async () => {
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      const content = fs.readFileSync(
+        path.join(tempDir, "tinybird", "pipes.ts"),
+        "utf-8"
+      );
+
+      expect(content).toContain("defineEndpoint");
+      expect(content).toContain("export const topPages");
+      expect(content).toContain("InferParams");
+      expect(content).toContain("InferOutputRow");
+      expect(content).toContain("TopPagesParams");
+      expect(content).toContain("TopPagesOutput");
+    });
+
+    it("creates client.ts with createTinybirdClient", async () => {
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      const content = fs.readFileSync(
+        path.join(tempDir, "tinybird", "client.ts"),
+        "utf-8"
+      );
+
+      expect(content).toContain("createTinybirdClient");
+      expect(content).toContain("export const tinybird");
+      expect(content).toContain("pageViews");
+      expect(content).toContain("topPages");
+    });
+
+    it("skips files that already exist", async () => {
+      fs.mkdirSync(path.join(tempDir, "tinybird"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird", "datasources.ts"),
+        "// existing content"
+      );
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(result.success).toBe(true);
+      expect(result.skipped).toContain("tinybird/datasources.ts");
+
+      // Verify it wasn't overwritten
+      const content = fs.readFileSync(
+        path.join(tempDir, "tinybird", "datasources.ts"),
+        "utf-8"
+      );
+      expect(content).toBe("// existing content");
+    });
+
+    it("overwrites files with force option", async () => {
+      fs.mkdirSync(path.join(tempDir, "tinybird"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird", "datasources.ts"),
+        "// existing content"
+      );
+
+      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true });
+
+      expect(result.success).toBe(true);
+      expect(result.created).toContain("tinybird/datasources.ts");
+
+      const content = fs.readFileSync(
+        path.join(tempDir, "tinybird", "datasources.ts"),
+        "utf-8"
+      );
+      expect(content).toContain("defineDatasource");
+    });
+  });
+
+  describe("directory creation", () => {
+    it("creates tinybird directory if it does not exist", async () => {
+      expect(fs.existsSync(path.join(tempDir, "tinybird"))).toBe(false);
+
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(fs.existsSync(path.join(tempDir, "tinybird"))).toBe(true);
+    });
+
+    it("creates src/tinybird directory if project has src folder", async () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+      expect(fs.existsSync(path.join(tempDir, "src", "tinybird"))).toBe(false);
+
+      await runInit({ cwd: tempDir, skipLogin: true });
+
+      expect(fs.existsSync(path.join(tempDir, "src", "tinybird"))).toBe(true);
+    });
+  });
+});