@tinybirdco/sdk 0.0.1

package/src/cli/config.test.ts

@@ -0,0 +1,359 @@
+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 {
+  hasSrcFolder,
+  getLibDir,
+  getRelativeLibDir,
+  getTinybirdSchemaPath,
+  getRelativeSchemaPath,
+  findConfigFile,
+  loadConfig,
+  getConfigPath,
+  configExists,
+  updateConfig,
+  hasValidToken,
+} from "./config.js";
+
+describe("Config", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-config-test-"));
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+    vi.restoreAllMocks();
+  });
+
+  describe("hasSrcFolder", () => {
+    it("returns true when src folder exists", () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      expect(hasSrcFolder(tempDir)).toBe(true);
+    });
+
+    it("returns false when src folder does not exist", () => {
+      expect(hasSrcFolder(tempDir)).toBe(false);
+    });
+
+    it("returns false when src is a file not a folder", () => {
+      fs.writeFileSync(path.join(tempDir, "src"), "not a folder");
+
+      expect(hasSrcFolder(tempDir)).toBe(false);
+    });
+  });
+
+  describe("getLibDir", () => {
+    it("returns src/tinybird when project has src folder", () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      expect(getLibDir(tempDir)).toBe(path.join(tempDir, "src", "tinybird"));
+    });
+
+    it("returns tinybird when project does not have src folder", () => {
+      expect(getLibDir(tempDir)).toBe(path.join(tempDir, "tinybird"));
+    });
+  });
+
+  describe("getRelativeLibDir", () => {
+    it("returns src/tinybird when project has src folder", () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      expect(getRelativeLibDir(tempDir)).toBe("src/tinybird");
+    });
+
+    it("returns tinybird when project does not have src folder", () => {
+      expect(getRelativeLibDir(tempDir)).toBe("tinybird");
+    });
+  });
+
+  describe("getTinybirdSchemaPath", () => {
+    it("returns src/tinybird/datasources.ts when project has src folder", () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      expect(getTinybirdSchemaPath(tempDir)).toBe(
+        path.join(tempDir, "src", "tinybird", "datasources.ts")
+      );
+    });
+
+    it("returns tinybird/datasources.ts when project does not have src folder", () => {
+      expect(getTinybirdSchemaPath(tempDir)).toBe(
+        path.join(tempDir, "tinybird", "datasources.ts")
+      );
+    });
+  });
+
+  describe("getRelativeSchemaPath", () => {
+    it("returns src/tinybird/datasources.ts when project has src folder", () => {
+      fs.mkdirSync(path.join(tempDir, "src"));
+
+      expect(getRelativeSchemaPath(tempDir)).toBe("src/tinybird/datasources.ts");
+    });
+
+    it("returns tinybird/datasources.ts when project does not have src folder", () => {
+      expect(getRelativeSchemaPath(tempDir)).toBe("tinybird/datasources.ts");
+    });
+  });
+
+  describe("findConfigFile", () => {
+    it("finds tinybird.json in current directory", () => {
+      const configPath = path.join(tempDir, "tinybird.json");
+      fs.writeFileSync(configPath, "{}");
+
+      expect(findConfigFile(tempDir)).toBe(configPath);
+    });
+
+    it("finds tinybird.json in parent directory", () => {
+      const nestedDir = path.join(tempDir, "src", "app");
+      fs.mkdirSync(nestedDir, { recursive: true });
+      const configPath = path.join(tempDir, "tinybird.json");
+      fs.writeFileSync(configPath, "{}");
+
+      expect(findConfigFile(nestedDir)).toBe(configPath);
+    });
+
+    it("returns null when no config file exists", () => {
+      expect(findConfigFile(tempDir)).toBe(null);
+    });
+  });
+
+  describe("getConfigPath", () => {
+    it("returns path to tinybird.json in directory", () => {
+      expect(getConfigPath(tempDir)).toBe(path.join(tempDir, "tinybird.json"));
+    });
+  });
+
+  describe("configExists", () => {
+    it("returns true when config exists", () => {
+      fs.writeFileSync(path.join(tempDir, "tinybird.json"), "{}");
+
+      expect(configExists(tempDir)).toBe(true);
+    });
+
+    it("returns false when config does not exist", () => {
+      expect(configExists(tempDir)).toBe(false);
+    });
+  });
+
+  describe("loadConfig", () => {
+    beforeEach(() => {
+      // Mock git functions to avoid git dependency in tests
+      vi.mock("./git.js", () => ({
+        getCurrentGitBranch: () => "main",
+        isMainBranch: () => true,
+        getTinybirdBranchName: () => null,
+      }));
+    });
+
+    it("throws error when no config file exists", () => {
+      expect(() => loadConfig(tempDir)).toThrow("Could not find tinybird.json");
+    });
+
+    it("loads config with include array", () => {
+      const config = {
+        include: ["lib/datasources.ts", "lib/pipes.ts"],
+        token: "test-token",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+
+      expect(result.include).toEqual(["lib/datasources.ts", "lib/pipes.ts"]);
+      expect(result.token).toBe("test-token");
+      expect(result.baseUrl).toBe("https://api.tinybird.co");
+    });
+
+    it("loads legacy config with schema (backward compat)", () => {
+      const config = {
+        schema: "src/lib/tinybird.ts",
+        token: "test-token",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+
+      // Legacy schema is converted to include array
+      expect(result.include).toEqual(["src/lib/tinybird.ts"]);
+    });
+
+    it("loads config with custom baseUrl", () => {
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "test-token",
+        baseUrl: "https://api.us-east.tinybird.co",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+
+      expect(result.baseUrl).toBe("https://api.us-east.tinybird.co");
+    });
+
+    it("interpolates environment variables in token", () => {
+      process.env.TEST_TINYBIRD_TOKEN = "secret-token-from-env";
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "${TEST_TINYBIRD_TOKEN}",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+
+      expect(result.token).toBe("secret-token-from-env");
+      delete process.env.TEST_TINYBIRD_TOKEN;
+    });
+
+    it("throws error when env var is not set", () => {
+      delete process.env.NONEXISTENT_VAR;
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "${NONEXISTENT_VAR}",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow(
+        "Environment variable NONEXISTENT_VAR is not set"
+      );
+    });
+
+    it("throws error when include field is missing", () => {
+      const config = {
+        token: "test-token",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow("Missing 'include' field");
+    });
+
+    it("throws error when token field is missing", () => {
+      const config = {
+        schema: "lib/tinybird.ts",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow("Missing 'token' field");
+    });
+
+    it("throws error for invalid JSON", () => {
+      fs.writeFileSync(path.join(tempDir, "tinybird.json"), "not valid json");
+
+      expect(() => loadConfig(tempDir)).toThrow("Failed to parse");
+    });
+  });
+
+  describe("updateConfig", () => {
+    it("updates existing config file", () => {
+      const configPath = path.join(tempDir, "tinybird.json");
+      const initialConfig = {
+        schema: "lib/tinybird.ts",
+        token: "${TINYBIRD_TOKEN}",
+        baseUrl: "https://api.tinybird.co",
+      };
+      fs.writeFileSync(configPath, JSON.stringify(initialConfig));
+
+      updateConfig(configPath, { baseUrl: "https://api.us-east.tinybird.co" });
+
+      const updatedConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      expect(updatedConfig.baseUrl).toBe("https://api.us-east.tinybird.co");
+      expect(updatedConfig.schema).toBe("lib/tinybird.ts");
+      expect(updatedConfig.token).toBe("${TINYBIRD_TOKEN}");
+    });
+
+    it("throws error when config file does not exist", () => {
+      const configPath = path.join(tempDir, "nonexistent.json");
+
+      expect(() => updateConfig(configPath, { baseUrl: "test" })).toThrow(
+        "Config not found"
+      );
+    });
+  });
+
+  describe("hasValidToken", () => {
+    it("returns false when no config exists", () => {
+      expect(hasValidToken(tempDir)).toBe(false);
+    });
+
+    it("returns true when token is literal value", () => {
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "p.some-token",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(hasValidToken(tempDir)).toBe(true);
+    });
+
+    it("returns true when token env var is set", () => {
+      process.env.HAS_VALID_TOKEN_TEST = "some-value";
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "${HAS_VALID_TOKEN_TEST}",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(hasValidToken(tempDir)).toBe(true);
+      delete process.env.HAS_VALID_TOKEN_TEST;
+    });
+
+    it("returns false when token env var is not set", () => {
+      delete process.env.MISSING_TOKEN_VAR;
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "${MISSING_TOKEN_VAR}",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(hasValidToken(tempDir)).toBe(false);
+    });
+
+    it("returns false when token field is empty", () => {
+      const config = {
+        schema: "lib/tinybird.ts",
+        token: "",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(hasValidToken(tempDir)).toBe(false);
+    });
+  });
+});

package/src/cli/config.ts

@@ -0,0 +1,335 @@
+/**
+ * Configuration loader for tinybird.json
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { getCurrentGitBranch, isMainBranch, getTinybirdBranchName } from "./git.js";
+
+/**
+ * Tinybird configuration file structure
+ */
+export interface TinybirdConfig {
+  /** Array of TypeScript files to scan for datasources and pipes */
+  include?: string[];
+  /** @deprecated Use `include` instead. Path to the TypeScript schema entry point */
+  schema?: string;
+  /** API token (supports ${ENV_VAR} interpolation) */
+  token: string;
+  /** Tinybird API base URL (optional, defaults to EU region) */
+  baseUrl?: string;
+}
+
+/**
+ * Resolved configuration with all values expanded
+ */
+export interface ResolvedConfig {
+  /** Array of TypeScript files to scan for datasources and pipes */
+  include: string[];
+  /** Resolved API token (workspace main token) */
+  token: string;
+  /** Tinybird API base URL */
+  baseUrl: string;
+  /** Path to the config file */
+  configPath: string;
+  /** Working directory */
+  cwd: string;
+  /** Current git branch (null if not in git repo or detached HEAD) */
+  gitBranch: string | null;
+  /** Sanitized branch name for Tinybird (symbols replaced with underscores) */
+  tinybirdBranch: string | null;
+  /** Whether we're on the main/master branch */
+  isMainBranch: boolean;
+}
+
+/**
+ * Default base URL (EU region)
+ */
+const DEFAULT_BASE_URL = "https://api.tinybird.co";
+
+/**
+ * Config file name
+ */
+const CONFIG_FILE = "tinybird.json";
+
+/**
+ * Tinybird folder name
+ */
+const TINYBIRD_FOLDER = "tinybird";
+
+/**
+ * Detect if project has a src folder
+ */
+export function hasSrcFolder(cwd: string): boolean {
+  const srcPath = path.join(cwd, "src");
+  return fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory();
+}
+
+/**
+ * Get the tinybird directory path based on project structure
+ * Returns 'src/tinybird' if project has src folder, otherwise 'tinybird'
+ */
+export function getTinybirdDir(cwd: string): string {
+  return hasSrcFolder(cwd) ? path.join(cwd, "src", TINYBIRD_FOLDER) : path.join(cwd, TINYBIRD_FOLDER);
+}
+
+/**
+ * Get the relative tinybird directory path based on project structure
+ */
+export function getRelativeTinybirdDir(cwd: string): string {
+  return hasSrcFolder(cwd) ? `src/${TINYBIRD_FOLDER}` : TINYBIRD_FOLDER;
+}
+
+/**
+ * Get the datasources.ts path based on project structure
+ */
+export function getDatasourcesPath(cwd: string): string {
+  return path.join(getTinybirdDir(cwd), "datasources.ts");
+}
+
+/**
+ * Get the pipes.ts path based on project structure
+ */
+export function getPipesPath(cwd: string): string {
+  return path.join(getTinybirdDir(cwd), "pipes.ts");
+}
+
+/**
+ * Get the client.ts path based on project structure
+ */
+export function getClientPath(cwd: string): string {
+  return path.join(getTinybirdDir(cwd), "client.ts");
+}
+
+// Legacy exports for backwards compatibility
+export function getLibDir(cwd: string): string {
+  return getTinybirdDir(cwd);
+}
+
+export function getRelativeLibDir(cwd: string): string {
+  return getRelativeTinybirdDir(cwd);
+}
+
+export function getTinybirdSchemaPath(cwd: string): string {
+  return getDatasourcesPath(cwd);
+}
+
+export function getRelativeSchemaPath(cwd: string): string {
+  return `${getRelativeTinybirdDir(cwd)}/datasources.ts`;
+}
+
+/**
+ * Interpolate environment variables in a string
+ *
+ * Supports ${VAR_NAME} syntax
+ */
+function interpolateEnvVars(value: string): string {
+  return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
+    const envValue = process.env[envVar];
+    if (envValue === undefined) {
+      throw new Error(`Environment variable ${envVar} is not set`);
+    }
+    return envValue;
+  });
+}
+
+/**
+ * Find the config file by walking up the directory tree
+ *
+ * @param startDir - Directory to start searching from
+ * @returns Path to the config file, or null if not found
+ */
+export function findConfigFile(startDir: string): string | null {
+  let currentDir = startDir;
+
+  while (true) {
+    const configPath = path.join(currentDir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      // Reached root
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+/**
+ * Load and resolve the tinybird.json configuration
+ *
+ * @param cwd - Working directory to start searching from (defaults to process.cwd())
+ * @returns Resolved configuration
+ *
+ * @example
+ * ```ts
+ * const config = loadConfig();
+ * console.log(config.schema); // 'lib/tinybird.ts' or 'src/lib/tinybird.ts'
+ * console.log(config.token);  // 'p.xxx' (resolved from ${TINYBIRD_TOKEN})
+ * ```
+ */
+export function loadConfig(cwd: string = process.cwd()): ResolvedConfig {
+  const configPath = findConfigFile(cwd);
+
+  if (!configPath) {
+    throw new Error(
+      `Could not find ${CONFIG_FILE}. Run 'npx tinybird init' to create one.`
+    );
+  }
+
+  let rawContent: string;
+  try {
+    rawContent = fs.readFileSync(configPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read ${configPath}: ${(error as Error).message}`);
+  }
+
+  let config: TinybirdConfig;
+  try {
+    config = JSON.parse(rawContent) as TinybirdConfig;
+  } catch (error) {
+    throw new Error(`Failed to parse ${configPath}: ${(error as Error).message}`);
+  }
+
+  // Validate required fields - need either include or schema
+  if (!config.include && !config.schema) {
+    throw new Error(`Missing 'include' field in ${configPath}. Add an array of files to scan for datasources and pipes.`);
+  }
+
+  if (!config.token) {
+    throw new Error(`Missing 'token' field in ${configPath}`);
+  }
+
+  // Resolve include paths (support legacy schema field)
+  let include: string[];
+  if (config.include) {
+    include = config.include;
+  } else if (config.schema) {
+    // Legacy mode: treat schema as a single include path
+    include = [config.schema];
+  } else {
+    // Should never reach here due to validation above
+    include = [];
+  }
+
+  // Get the directory containing the config file
+  const configDir = path.dirname(configPath);
+
+  // Resolve token (may contain env vars)
+  let resolvedToken: string;
+  try {
+    resolvedToken = interpolateEnvVars(config.token);
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve token in ${configPath}: ${(error as Error).message}`
+    );
+  }
+
+  // Resolve base URL
+  let resolvedBaseUrl = DEFAULT_BASE_URL;
+  if (config.baseUrl) {
+    try {
+      resolvedBaseUrl = interpolateEnvVars(config.baseUrl);
+    } catch (error) {
+      throw new Error(
+        `Failed to resolve baseUrl in ${configPath}: ${(error as Error).message}`
+      );
+    }
+  }
+
+  // Detect git branch
+  const gitBranch = getCurrentGitBranch();
+  const tinybirdBranch = getTinybirdBranchName();
+
+  return {
+    include,
+    token: resolvedToken,
+    baseUrl: resolvedBaseUrl,
+    configPath,
+    cwd: configDir,
+    gitBranch,
+    tinybirdBranch,
+    isMainBranch: isMainBranch(),
+  };
+}
+
+/**
+ * Check if a config file exists in the given directory
+ */
+export function configExists(cwd: string = process.cwd()): boolean {
+  return findConfigFile(cwd) !== null;
+}
+
+/**
+ * Get the expected config file path for a directory
+ */
+export function getConfigPath(cwd: string = process.cwd()): string {
+  return path.join(cwd, CONFIG_FILE);
+}
+
+/**
+ * Update specific fields in tinybird.json
+ *
+ * Throws an error if the config file doesn't exist to prevent creating
+ * partial config files that would break loadConfig.
+ *
+ * @param configPath - Path to the config file
+ * @param updates - Fields to update
+ * @throws Error if config file doesn't exist
+ */
+export function updateConfig(
+  configPath: string,
+  updates: Partial<TinybirdConfig>
+): void {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config not found at ${configPath}`);
+  }
+
+  const content = fs.readFileSync(configPath, "utf-8");
+  const config = JSON.parse(content) as TinybirdConfig;
+
+  // Merge updates
+  const updated = { ...config, ...updates };
+
+  fs.writeFileSync(configPath, JSON.stringify(updated, null, 2) + "\n");
+}
+
+/**
+ * Check if a valid token is configured (either in file or via env var)
+ *
+ * @param cwd - Working directory to search from
+ * @returns true if a valid token exists
+ */
+export function hasValidToken(cwd: string = process.cwd()): boolean {
+  try {
+    const configPath = findConfigFile(cwd);
+    if (!configPath) {
+      return false;
+    }
+
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content) as TinybirdConfig;
+
+    if (!config.token) {
+      return false;
+    }
+
+    // Check if token is a placeholder or env var reference
+    if (config.token.includes("${")) {
+      // Try to resolve the env var
+      try {
+        const resolved = interpolateEnvVars(config.token);
+        return Boolean(resolved);
+      } catch {
+        return false;
+      }
+    }
+
+    // Token is a literal value
+    return Boolean(config.token);
+  } catch {
+    return false;
+  }
+}