@tinybirdco/sdk 0.0.12 → 0.0.14

package/src/cli/commands/init.ts

@@ -127,6 +127,11 @@ on:
 jobs:
   tinybird:
     runs-on: ubuntu-latest
+    outputs:
+      branch_name: \${{ steps.preview.outputs.branch_name }}
+      branch_id: \${{ steps.preview.outputs.branch_id }}
+      branch_token: \${{ steps.preview.outputs.branch_token }}
+      branch_url: \${{ steps.preview.outputs.branch_url }}
     steps:
       - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v4
@@ -136,7 +141,16 @@ jobs:
           cache: "pnpm"
       - run: pnpm install --frozen-lockfile
       - run: pnpm run tinybird:build
-      - run: pnpm run tinybird:deploy -- --check
+      - name: Create preview branch
+        id: preview
+        run: |
+          result=$(pnpm run tinybird:preview --json 2>&1)
+          echo "$result" | jq -r '"branch_name=" + .branch.name' >> $GITHUB_OUTPUT
+          echo "$result" | jq -r '"branch_id=" + .branch.id' >> $GITHUB_OUTPUT
+          token=$(echo "$result" | jq -r '.branch.token')
+          echo "::add-mask::$token"
+          echo "branch_token=$token" >> $GITHUB_OUTPUT
+          echo "$result" | jq -r '"branch_url=" + .branch.url' >> $GITHUB_OUTPUT
         env:
           TINYBIRD_TOKEN: \${{ secrets.TINYBIRD_TOKEN }}
 `;
@@ -188,7 +202,15 @@ tinybird_ci:
     - corepack enable
     - pnpm install --frozen-lockfile
     - pnpm run tinybird:build
-    - pnpm run tinybird:deploy -- --check
+    - |
+      result=$(pnpm run tinybird:preview --json 2>&1)
+      echo "TINYBIRD_BRANCH_NAME=$(echo "$result" | jq -r '.branch.name')" >> tinybird.env
+      echo "TINYBIRD_BRANCH_ID=$(echo "$result" | jq -r '.branch.id')" >> tinybird.env
+      echo "TINYBIRD_BRANCH_TOKEN=$(echo "$result" | jq -r '.branch.token')" >> tinybird.env
+      echo "TINYBIRD_BRANCH_URL=$(echo "$result" | jq -r '.branch.url')" >> tinybird.env
+  artifacts:
+    reports:
+      dotenv: tinybird.env
   variables:
     TINYBIRD_TOKEN: \${TINYBIRD_TOKEN}
 `;

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

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { generatePreviewBranchName } from "./preview.js";
+
+describe("Preview command", () => {
+  describe("generatePreviewBranchName", () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date("2024-02-06T12:00:00Z"));
+    });
+
+    it("generates name with branch and timestamp", () => {
+      const result = generatePreviewBranchName("feature-branch");
+      expect(result).toBe("tmp_ci_feature_branch_1707220800");
+    });
+
+    it("sanitizes branch name with slashes", () => {
+      const result = generatePreviewBranchName("feature/add-login");
+      expect(result).toBe("tmp_ci_feature_add_login_1707220800");
+    });
+
+    it("sanitizes branch name with dots", () => {
+      const result = generatePreviewBranchName("release.1.0");
+      expect(result).toBe("tmp_ci_release_1_0_1707220800");
+    });
+
+    it("handles complex branch names", () => {
+      const result = generatePreviewBranchName("feature/JIRA-123/add-user-auth");
+      expect(result).toBe("tmp_ci_feature_JIRA_123_add_user_auth_1707220800");
+    });
+
+    it("uses 'unknown' when branch is null", () => {
+      const result = generatePreviewBranchName(null);
+      expect(result).toBe("tmp_ci_unknown_1707220800");
+    });
+
+    it("uses unix timestamp in seconds", () => {
+      // 1707220800 is 2024-02-06T12:00:00Z in seconds
+      const result = generatePreviewBranchName("test");
+      expect(result).toMatch(/_1707220800$/);
+    });
+  });
+});

package/src/cli/commands/preview.ts

@@ -0,0 +1,313 @@
+/**
+ * Preview command - creates ephemeral preview branch and deploys resources
+ */
+
+import { loadConfig, LOCAL_BASE_URL, type ResolvedConfig, type DevMode } from "../config.js";
+import { buildFromInclude, type BuildFromIncludeResult } from "../../generator/index.js";
+import { createBranch, type TinybirdBranch } from "../../api/branches.js";
+import { deployToMain } from "../../api/deploy.js";
+import { buildToTinybird } from "../../api/build.js";
+import {
+  getLocalTokens,
+  getOrCreateLocalWorkspace,
+  LocalNotRunningError,
+} from "../../api/local.js";
+import { sanitizeBranchName, getCurrentGitBranch } from "../git.js";
+import type { BuildApiResult } from "../../api/build.js";
+
+/**
+ * Preview command options
+ */
+export interface PreviewCommandOptions {
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Skip pushing to API (just generate) */
+  dryRun?: boolean;
+  /** Validate deploy with Tinybird API without applying */
+  check?: boolean;
+  /** Override preview branch name */
+  name?: string;
+  /** Override the devMode from config */
+  devModeOverride?: DevMode;
+}
+
+/**
+ * Preview command result
+ */
+export interface PreviewCommandResult {
+  /** Whether the preview was successful */
+  success: boolean;
+  /** Branch information */
+  branch?: {
+    name: string;
+    id: string;
+    token: string;
+    url: string;
+    created_at: string;
+  };
+  /** Build statistics */
+  build?: {
+    datasourceCount: number;
+    pipeCount: number;
+  };
+  /** Deploy result */
+  deploy?: {
+    result: string;
+  };
+  /** Error message if failed */
+  error?: string;
+  /** Duration in milliseconds */
+  durationMs: number;
+}
+
+/**
+ * Generate preview branch name with format: tmp_ci_${branch}_${timestamp}
+ *
+ * @param gitBranch - Current git branch name (or null)
+ * @returns Preview branch name
+ */
+export function generatePreviewBranchName(gitBranch: string | null): string {
+  const timestamp = Math.floor(Date.now() / 1000);
+  const branchPart = gitBranch ? sanitizeBranchName(gitBranch) : "unknown";
+  return `tmp_ci_${branchPart}_${timestamp}`;
+}
+
+/**
+ * Run the preview command
+ *
+ * Creates an ephemeral preview branch and deploys resources to it.
+ * Preview branches are not cached and are meant for CI/testing.
+ *
+ * @param options - Preview options
+ * @returns Preview command result
+ */
+export async function runPreview(options: PreviewCommandOptions = {}): Promise<PreviewCommandResult> {
+  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,
+    };
+  }
+
+  // Get current git branch and generate preview branch name
+  const gitBranch = getCurrentGitBranch();
+  const previewBranchName = options.name ?? generatePreviewBranchName(gitBranch);
+
+  // 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,
+    };
+  }
+
+  const buildStats = {
+    datasourceCount: buildResult.stats.datasourceCount,
+    pipeCount: buildResult.stats.pipeCount,
+  };
+
+  // If dry run, return without creating branch or deploying
+  if (options.dryRun) {
+    return {
+      success: true,
+      branch: {
+        name: previewBranchName,
+        id: "(dry-run)",
+        token: "(dry-run)",
+        url: config.baseUrl,
+        created_at: new Date().toISOString(),
+      },
+      build: buildStats,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  const debug = !!process.env.TINYBIRD_DEBUG;
+  const devMode = options.devModeOverride ?? config.devMode;
+
+  if (debug) {
+    console.log(`[debug] devMode: ${devMode}`);
+    console.log(`[debug] previewBranchName: ${previewBranchName}`);
+  }
+
+  // Handle local mode
+  if (devMode === "local") {
+    try {
+      if (debug) {
+        console.log(`[debug] Getting local tokens from ${LOCAL_BASE_URL}/tokens`);
+      }
+
+      const localTokens = await getLocalTokens();
+
+      // Create workspace with preview branch name
+      if (debug) {
+        console.log(`[debug] Creating local workspace: ${previewBranchName}`);
+      }
+
+      const { workspace, wasCreated } = await getOrCreateLocalWorkspace(localTokens, previewBranchName);
+      if (debug) {
+        console.log(`[debug] Workspace ${wasCreated ? "created" : "found"}: ${workspace.name}`);
+      }
+
+      // Use /v1/build for local (no deploy endpoint in local)
+      const deployResult = await buildToTinybird(
+        {
+          baseUrl: LOCAL_BASE_URL,
+          token: workspace.token,
+        },
+        buildResult.resources
+      );
+
+      if (!deployResult.success) {
+        return {
+          success: false,
+          branch: {
+            name: previewBranchName,
+            id: workspace.id,
+            token: workspace.token,
+            url: LOCAL_BASE_URL,
+            created_at: new Date().toISOString(),
+          },
+          build: buildStats,
+          error: deployResult.error,
+          durationMs: Date.now() - startTime,
+        };
+      }
+
+      return {
+        success: true,
+        branch: {
+          name: previewBranchName,
+          id: workspace.id,
+          token: workspace.token,
+          url: LOCAL_BASE_URL,
+          created_at: new Date().toISOString(),
+        },
+        build: buildStats,
+        deploy: {
+          result: deployResult.result,
+        },
+        durationMs: Date.now() - startTime,
+      };
+    } catch (error) {
+      if (error instanceof LocalNotRunningError) {
+        return {
+          success: false,
+          error: error.message,
+          durationMs: Date.now() - startTime,
+        };
+      }
+      return {
+        success: false,
+        error: `Local preview failed: ${(error as Error).message}`,
+        durationMs: Date.now() - startTime,
+      };
+    }
+  }
+
+  // Cloud mode - create branch and deploy using /v1/deploy
+  let branch: TinybirdBranch;
+  try {
+    if (debug) {
+      console.log(`[debug] Creating preview branch: ${previewBranchName}`);
+    }
+
+    branch = await createBranch(
+      { baseUrl: config.baseUrl, token: config.token },
+      previewBranchName
+    );
+
+    if (debug) {
+      console.log(`[debug] Branch created: ${branch.name} (${branch.id})`);
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to create preview branch: ${(error as Error).message}`,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  if (!branch.token) {
+    return {
+      success: false,
+      error: `Preview branch created but no token returned`,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Deploy to branch using /v1/deploy (production-like experience)
+  let deployResult: BuildApiResult;
+  try {
+    if (debug) {
+      console.log(`[debug] Deploying to preview branch using branch token`);
+    }
+
+    deployResult = await deployToMain(
+      { baseUrl: config.baseUrl, token: branch.token },
+      buildResult.resources,
+      { check: options.check, allowDestructiveOperations: true }
+    );
+  } catch (error) {
+    return {
+      success: false,
+      branch: {
+        name: branch.name,
+        id: branch.id,
+        token: branch.token,
+        url: config.baseUrl,
+        created_at: branch.created_at,
+      },
+      build: buildStats,
+      error: `Deploy failed: ${(error as Error).message}`,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  if (!deployResult.success) {
+    return {
+      success: false,
+      branch: {
+        name: branch.name,
+        id: branch.id,
+        token: branch.token,
+        url: config.baseUrl,
+        created_at: branch.created_at,
+      },
+      build: buildStats,
+      error: deployResult.error,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  return {
+    success: true,
+    branch: {
+      name: branch.name,
+      id: branch.id,
+      token: branch.token,
+      url: config.baseUrl,
+      created_at: branch.created_at,
+    },
+    build: buildStats,
+    deploy: {
+      result: deployResult.result,
+    },
+    durationMs: Date.now() - startTime,
+  };
+}