@tinybirdco/sdk 0.0.1

package/src/cli/commands/branch.ts

@@ -0,0 +1,306 @@
+/**
+ * Branch management commands
+ */
+
+import { loadConfig, type ResolvedConfig } from "../config.js";
+import {
+  listBranches,
+  getBranch,
+  deleteBranch,
+  type TinybirdBranch,
+  BranchApiError,
+} from "../../api/branches.js";
+import { getWorkspace } from "../../api/workspaces.js";
+import {
+  getBranchToken,
+  removeBranch as removeCachedBranch,
+  listCachedBranches,
+} from "../branch-store.js";
+
+/**
+ * Branch command options
+ */
+export interface BranchCommandOptions {
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+}
+
+/**
+ * Result of listing branches
+ */
+export interface BranchListResult {
+  /** Whether the operation was successful */
+  success: boolean;
+  /** List of branches */
+  branches?: TinybirdBranch[];
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Result of getting branch status
+ */
+export interface BranchStatusResult {
+  /** Whether the operation was successful */
+  success: boolean;
+  /** Current git branch */
+  gitBranch: string | null;
+  /** Sanitized Tinybird branch name */
+  tinybirdBranchName: string | null;
+  /** Whether we're on the main branch */
+  isMainBranch: boolean;
+  /** Tinybird branch info (if exists) */
+  tinybirdBranch?: TinybirdBranch;
+  /** Whether a cached token exists */
+  hasCachedToken: boolean;
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Result of deleting a branch
+ */
+export interface BranchDeleteResult {
+  /** Whether the operation was successful */
+  success: boolean;
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * List all Tinybird branches
+ *
+ * @param options - Command options
+ * @returns List result
+ */
+export async function runBranchList(
+  options: BranchCommandOptions = {}
+): Promise<BranchListResult> {
+  const cwd = options.cwd ?? process.cwd();
+
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+    };
+  }
+
+  try {
+    const branches = await listBranches({
+      baseUrl: config.baseUrl,
+      token: config.token,
+    });
+
+    return {
+      success: true,
+      branches,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+    };
+  }
+}
+
+/**
+ * Get current branch status
+ *
+ * @param options - Command options
+ * @returns Status result
+ */
+export async function runBranchStatus(
+  options: BranchCommandOptions = {}
+): Promise<BranchStatusResult> {
+  const cwd = options.cwd ?? process.cwd();
+
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    return {
+      success: false,
+      gitBranch: null,
+      tinybirdBranchName: null,
+      isMainBranch: false,
+      hasCachedToken: false,
+      error: (error as Error).message,
+    };
+  }
+
+  const gitBranch = config.gitBranch;
+  const tinybirdBranchName = config.tinybirdBranch; // Sanitized name
+  const isMainBranch = config.isMainBranch;
+
+  // Fetch the workspace ID from the API
+  let workspaceId: string;
+  try {
+    const workspace = await getWorkspace({
+      baseUrl: config.baseUrl,
+      token: config.token,
+    });
+    workspaceId = workspace.id;
+  } catch (error) {
+    return {
+      success: false,
+      gitBranch,
+      tinybirdBranchName,
+      isMainBranch,
+      hasCachedToken: false,
+      error: (error as Error).message,
+    };
+  }
+
+  // Check for cached token (use sanitized name)
+  const cachedBranch = tinybirdBranchName ? getBranchToken(workspaceId, tinybirdBranchName) : null;
+  const hasCachedToken = cachedBranch !== null;
+
+  // If on main branch, just return status
+  if (isMainBranch || !tinybirdBranchName) {
+    return {
+      success: true,
+      gitBranch,
+      tinybirdBranchName,
+      isMainBranch,
+      hasCachedToken,
+    };
+  }
+
+  // Try to get the Tinybird branch info (use sanitized name)
+  try {
+    const tinybirdBranch = await getBranch(
+      {
+        baseUrl: config.baseUrl,
+        token: config.token,
+      },
+      tinybirdBranchName
+    );
+
+    return {
+      success: true,
+      gitBranch,
+      tinybirdBranchName,
+      isMainBranch,
+      tinybirdBranch,
+      hasCachedToken,
+    };
+  } catch (error) {
+    // If 404, branch doesn't exist yet
+    if (error instanceof BranchApiError && error.status === 404) {
+      return {
+        success: true,
+        gitBranch,
+        tinybirdBranchName,
+        isMainBranch,
+        hasCachedToken,
+      };
+    }
+
+    return {
+      success: false,
+      gitBranch,
+      tinybirdBranchName,
+      isMainBranch,
+      hasCachedToken,
+      error: (error as Error).message,
+    };
+  }
+}
+
+/**
+ * Delete a Tinybird branch
+ *
+ * @param name - Branch name to delete
+ * @param options - Command options
+ * @returns Delete result
+ */
+export async function runBranchDelete(
+  name: string,
+  options: BranchCommandOptions = {}
+): Promise<BranchDeleteResult> {
+  const cwd = options.cwd ?? process.cwd();
+
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+    };
+  }
+
+  try {
+    // Fetch the workspace ID from the API
+    const workspace = await getWorkspace({
+      baseUrl: config.baseUrl,
+      token: config.token,
+    });
+    const workspaceId = workspace.id;
+
+    // Delete from Tinybird API
+    await deleteBranch(
+      {
+        baseUrl: config.baseUrl,
+        token: config.token,
+      },
+      name
+    );
+
+    // Remove from local cache
+    removeCachedBranch(workspaceId, name);
+
+    return {
+      success: true,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+    };
+  }
+}
+
+/**
+ * List cached branches (requires API call to get workspace ID)
+ */
+export async function runBranchListCached(
+  options: BranchCommandOptions = {}
+): Promise<{ branches: Record<string, { id: string; createdAt: string }> }> {
+  const cwd = options.cwd ?? process.cwd();
+
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch {
+    return { branches: {} };
+  }
+
+  // Fetch the workspace ID from the API
+  let workspaceId: string;
+  try {
+    const workspace = await getWorkspace({
+      baseUrl: config.baseUrl,
+      token: config.token,
+    });
+    workspaceId = workspace.id;
+  } catch {
+    return { branches: {} };
+  }
+
+  const cached = listCachedBranches(workspaceId);
+
+  // Return without tokens for security
+  const branches: Record<string, { id: string; createdAt: string }> = {};
+  for (const [name, info] of Object.entries(cached)) {
+    branches[name] = {
+      id: info.id,
+      createdAt: info.createdAt,
+    };
+  }
+
+  return { branches };
+}

package/src/cli/commands/build.ts

@@ -0,0 +1,183 @@
+/**
+ * Build command - generates and pushes resources to Tinybird
+ */
+
+import { loadConfig, type ResolvedConfig } from "../config.js";
+import { buildFromInclude, type BuildFromIncludeResult } from "../../generator/index.js";
+import { buildToTinybird, type BuildApiResult } from "../../api/build.js";
+import { deployToMain } from "../../api/deploy.js";
+import { getOrCreateBranch } from "../../api/branches.js";
+
+/**
+ * Build command options
+ */
+export interface BuildCommandOptions {
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Skip pushing to API (just generate) */
+  dryRun?: boolean;
+  /** Override the token from config (used for branch tokens) */
+  tokenOverride?: string;
+  /** Use /v1/deploy instead of /v1/build (for main branch) */
+  useDeployEndpoint?: boolean;
+}
+
+/**
+ * Build command result
+ */
+export interface BuildCommandResult {
+  /** Whether the build was successful */
+  success: boolean;
+  /** Build result with generated resources */
+  build?: BuildFromIncludeResult;
+  /** Build API result (if not dry run) */
+  deploy?: BuildApiResult;
+  /** Error message if failed */
+  error?: string;
+  /** Duration in milliseconds */
+  durationMs: number;
+}
+
+/**
+ * Run the build command
+ *
+ * Loads the schema, generates resources, and pushes to Tinybird API.
+ *
+ * @param options - Build options
+ * @returns Build command result
+ */
+export async function runBuild(options: BuildCommandOptions = {}): Promise<BuildCommandResult> {
+  const startTime = Date.now();
+  const cwd = options.cwd ?? process.cwd();
+
+  // Load config
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Build resources from include paths
+  let buildResult: BuildFromIncludeResult;
+  try {
+    buildResult = await buildFromInclude({
+      includePaths: config.include,
+      cwd: config.cwd,
+    });
+  } catch (error) {
+    return {
+      success: false,
+      error: `Build failed: ${(error as Error).message}`,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // If dry run, return without pushing
+  if (options.dryRun) {
+    return {
+      success: true,
+      build: buildResult,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Deploy to Tinybird
+  // Determine token and endpoint based on git branch
+  let effectiveToken = options.tokenOverride ?? config.token;
+  let useDeployEndpoint = options.useDeployEndpoint ?? config.isMainBranch;
+
+  // For feature branches, get or create the Tinybird branch and use its token
+  const debug = !!process.env.TINYBIRD_DEBUG;
+  if (debug) {
+    console.log(`[debug] isMainBranch: ${config.isMainBranch}`);
+    console.log(`[debug] tinybirdBranch: ${config.tinybirdBranch}`);
+    console.log(`[debug] tokenOverride: ${!!options.tokenOverride}`);
+  }
+  if (!config.isMainBranch && config.tinybirdBranch && !options.tokenOverride) {
+    if (debug) {
+      console.log(`[debug] Getting/creating Tinybird branch: ${config.tinybirdBranch}`);
+    }
+    try {
+      const tinybirdBranch = await getOrCreateBranch(
+        {
+          baseUrl: config.baseUrl,
+          token: config.token,
+        },
+        config.tinybirdBranch
+      );
+
+      if (!tinybirdBranch.token) {
+        return {
+          success: false,
+          build: buildResult,
+          error: `Branch '${config.tinybirdBranch}' was created but no token was returned.`,
+          durationMs: Date.now() - startTime,
+        };
+      }
+
+      effectiveToken = tinybirdBranch.token;
+      useDeployEndpoint = false; // Always use /v1/build for branches
+      if (debug) {
+        console.log(`[debug] Using branch token for branch: ${config.tinybirdBranch}`);
+      }
+    } catch (error) {
+      return {
+        success: false,
+        build: buildResult,
+        error: `Failed to get/create branch: ${(error as Error).message}`,
+        durationMs: Date.now() - startTime,
+      };
+    }
+  }
+
+  let deployResult: BuildApiResult;
+  try {
+    // Use /v1/deploy for main branch, /v1/build for feature branches
+    if (useDeployEndpoint) {
+      deployResult = await deployToMain(
+        {
+          baseUrl: config.baseUrl,
+          token: effectiveToken,
+        },
+        buildResult.resources
+      );
+    } else {
+      deployResult = await buildToTinybird(
+        {
+          baseUrl: config.baseUrl,
+          token: effectiveToken,
+        },
+        buildResult.resources
+      );
+    }
+  } catch (error) {
+    return {
+      success: false,
+      build: buildResult,
+      error: `Deploy failed: ${(error as Error).message}`,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  if (!deployResult.success) {
+    return {
+      success: false,
+      build: buildResult,
+      deploy: deployResult,
+      error: deployResult.error,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  return {
+    success: true,
+    build: buildResult,
+    deploy: deployResult,
+    durationMs: Date.now() - startTime,
+  };
+}