@tinybirdco/sdk 0.0.4 → 0.0.7

package/src/api/deploy.ts

@@ -1,17 +1,55 @@
 /**
  * Deploy resources to Tinybird main workspace
- * Uses the /v1/deploy endpoint (same payload format as /v1/build)
+ * Uses the /v1/deploy endpoint to create a deployment, then sets it live
  */
 
 import type { GeneratedResources } from "../generator/index.js";
-import type { BuildConfig, BuildApiResult, BuildResponse } from "./build.js";
+import type { BuildConfig, BuildApiResult } from "./build.js";
+import { tinybirdFetch } from "./fetcher.js";
+
+/**
+ * Deployment object returned by the /v1/deploy endpoint
+ */
+export interface Deployment {
+  id: string;
+  status: string;
+  live?: boolean;
+  created_at?: string;
+  updated_at?: string;
+}
+
+/**
+ * Response from /v1/deployments list endpoint
+ */
+export interface DeploymentsListResponse {
+  deployments: Deployment[];
+}
+
+/**
+ * Response from /v1/deploy endpoint
+ */
+export interface DeployResponse {
+  result: "success" | "failed";
+  deployment?: Deployment;
+  error?: string;
+  errors?: Array<{ filename?: string; error: string }>;
+}
+
+/**
+ * Response from /v1/deployments/{id} endpoint
+ */
+export interface DeploymentStatusResponse {
+  result: string;
+  deployment: Deployment;
+}
 
 /**
  * Deploy generated resources to Tinybird main workspace
  *
  * Uses the /v1/deploy endpoint which accepts all resources in a single
- * multipart form request. This is used for deploying to the main workspace
- * (not branches).
+ * multipart form request. After creating the deployment, this function:
+ * 1. Polls until the deployment is ready (status === 'data_ready')
+ * 2. Sets the deployment as live via /v1/deployments/{id}/set-live
  *
  * @param config - Build configuration with API URL and token
  * @param resources - Generated resources to deploy
@@ -38,9 +76,18 @@ import type { BuildConfig, BuildApiResult, BuildResponse } from "./build.js";
 export async function deployToMain(
   config: BuildConfig,
   resources: GeneratedResources,
-  options?: { debug?: boolean }
+  options?: {
+    debug?: boolean;
+    pollIntervalMs?: number;
+    maxPollAttempts?: number;
+    check?: boolean;
+  }
 ): Promise<BuildApiResult> {
   const debug = options?.debug ?? !!process.env.TINYBIRD_DEBUG;
+  const pollIntervalMs = options?.pollIntervalMs ?? 1000;
+  const maxPollAttempts = options?.maxPollAttempts ?? 120; // 2 minutes max
+  const baseUrl = config.baseUrl.replace(/\/$/, "");
+
   const formData = new FormData();
 
   // Add datasources
@@ -73,14 +120,49 @@ export async function deployToMain(
     );
   }
 
-  // Make the request to /v1/deploy (instead of /v1/build)
-  const url = `${config.baseUrl.replace(/\/$/, "")}/v1/deploy`;
+  // Step 0: Clean up any stale non-live deployments that might block the new deployment
+  try {
+    const deploymentsUrl = `${baseUrl}/v1/deployments`;
+    const deploymentsResponse = await tinybirdFetch(deploymentsUrl, {
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+      },
+    });
+
+    if (deploymentsResponse.ok) {
+      const deploymentsBody = (await deploymentsResponse.json()) as DeploymentsListResponse;
+      const staleDeployments = deploymentsBody.deployments.filter(
+        (d) => !d.live && d.status !== "live"
+      );
+
+      for (const stale of staleDeployments) {
+        if (debug) {
+          console.log(`[debug] Cleaning up stale deployment: ${stale.id} (status: ${stale.status})`);
+        }
+        await tinybirdFetch(`${baseUrl}/v1/deployments/${stale.id}`, {
+          method: "DELETE",
+          headers: {
+            Authorization: `Bearer ${config.token}`,
+          },
+        });
+      }
+    }
+  } catch (e) {
+    // Ignore errors during cleanup - we'll try to deploy anyway
+    if (debug) {
+      console.log(`[debug] Failed to clean up stale deployments: ${e}`);
+    }
+  }
+
+  // Step 1: Create deployment via /v1/deploy
+  const deployUrlBase = `${baseUrl}/v1/deploy`;
+  const deployUrl = options?.check ? `${deployUrlBase}?check=true` : deployUrlBase;
 
   if (debug) {
-    console.log(`[debug] POST ${url}`);
+    console.log(`[debug] POST ${deployUrl}`);
   }
 
-  const response = await fetch(url, {
+  const response = await tinybirdFetch(deployUrl, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${config.token}`,
@@ -89,7 +171,7 @@ export async function deployToMain(
   });
 
   // Parse response
-  let body: BuildResponse;
+  let body: DeployResponse;
   const rawBody = await response.text();
 
   if (debug) {
@@ -98,7 +180,7 @@ export async function deployToMain(
   }
 
   try {
-    body = JSON.parse(rawBody) as BuildResponse;
+    body = JSON.parse(rawBody) as DeployResponse;
   } catch {
     throw new Error(
       `Failed to parse response from Tinybird API: ${response.status} ${response.statusText}\nBody: ${rawBody}`
@@ -130,8 +212,29 @@ export async function deployToMain(
     };
   }
 
+  if (options?.check) {
+    if (body.result === "failed") {
+      return {
+        success: false,
+        result: "failed",
+        error: formatErrors(),
+        datasourceCount: resources.datasources.length,
+        pipeCount: resources.pipes.length,
+        connectionCount: resources.connections?.length ?? 0,
+      };
+    }
+
+    return {
+      success: true,
+      result: body.result ?? "success",
+      datasourceCount: resources.datasources.length,
+      pipeCount: resources.pipes.length,
+      connectionCount: resources.connections?.length ?? 0,
+    };
+  }
+
   // Handle API result
-  if (body.result === "failed") {
+  if (body.result === "failed" || !body.deployment) {
     return {
       success: false,
       result: "failed",
@@ -142,25 +245,130 @@ export async function deployToMain(
     };
   }
 
+  const deploymentId = body.deployment.id;
+
+  if (debug) {
+    console.log(`[debug] Deployment created with ID: ${deploymentId}`);
+  }
+
+  // Step 2: Poll until deployment is ready
+  let deployment = body.deployment;
+  let attempts = 0;
+
+  while (deployment.status !== "data_ready" && attempts < maxPollAttempts) {
+    await sleep(pollIntervalMs);
+    attempts++;
+
+    if (debug) {
+      console.log(`[debug] Polling deployment status (attempt ${attempts})...`);
+    }
+
+    const statusUrl = `${baseUrl}/v1/deployments/${deploymentId}`;
+    const statusResponse = await tinybirdFetch(statusUrl, {
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+      },
+    });
+
+    if (!statusResponse.ok) {
+      return {
+        success: false,
+        result: "failed",
+        error: `Failed to check deployment status: ${statusResponse.status} ${statusResponse.statusText}`,
+        datasourceCount: resources.datasources.length,
+        pipeCount: resources.pipes.length,
+        connectionCount: resources.connections?.length ?? 0,
+        buildId: deploymentId,
+      };
+    }
+
+    const statusBody = (await statusResponse.json()) as DeploymentStatusResponse;
+    deployment = statusBody.deployment;
+
+    if (debug) {
+      console.log(`[debug] Deployment status: ${deployment.status}`);
+    }
+
+    // Check for failed status
+    if (deployment.status === "failed" || deployment.status === "error") {
+      return {
+        success: false,
+        result: "failed",
+        error: `Deployment failed with status: ${deployment.status}`,
+        datasourceCount: resources.datasources.length,
+        pipeCount: resources.pipes.length,
+        connectionCount: resources.connections?.length ?? 0,
+        buildId: deploymentId,
+      };
+    }
+  }
+
+  if (deployment.status !== "data_ready") {
+    return {
+      success: false,
+      result: "failed",
+      error: `Deployment timed out after ${maxPollAttempts} attempts. Last status: ${deployment.status}`,
+      datasourceCount: resources.datasources.length,
+      pipeCount: resources.pipes.length,
+      connectionCount: resources.connections?.length ?? 0,
+      buildId: deploymentId,
+    };
+  }
+
+  // Step 3: Set the deployment as live
+  const setLiveUrl = `${baseUrl}/v1/deployments/${deploymentId}/set-live`;
+
+  if (debug) {
+    console.log(`[debug] POST ${setLiveUrl}`);
+  }
+
+  const setLiveResponse = await tinybirdFetch(setLiveUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+    },
+  });
+
+  if (!setLiveResponse.ok) {
+    const setLiveBody = await setLiveResponse.text();
+    return {
+      success: false,
+      result: "failed",
+      error: `Failed to set deployment as live: ${setLiveResponse.status} ${setLiveResponse.statusText}\n${setLiveBody}`,
+      datasourceCount: resources.datasources.length,
+      pipeCount: resources.pipes.length,
+      connectionCount: resources.connections?.length ?? 0,
+      buildId: deploymentId,
+    };
+  }
+
+  if (debug) {
+    console.log(`[debug] Deployment ${deploymentId} is now live`);
+  }
+
   return {
     success: true,
-    result: body.result,
+    result: "success",
     datasourceCount: resources.datasources.length,
     pipeCount: resources.pipes.length,
     connectionCount: resources.connections?.length ?? 0,
-    buildId: body.build?.id,
+    buildId: deploymentId,
     pipes: {
-      changed: body.build?.changed_pipe_names ?? [],
-      created: body.build?.new_pipe_names ?? [],
-      deleted: body.build?.deleted_pipe_names ?? [],
+      changed: [],
+      created: [],
+      deleted: [],
     },
     datasources: {
-      changed: body.build?.changed_datasource_names ?? [],
-      created: body.build?.new_datasource_names ?? [],
-      deleted: body.build?.deleted_datasource_names ?? [],
+      changed: [],
+      created: [],
+      deleted: [],
     },
-    // Keep deprecated fields for backwards compatibility
-    changedPipeNames: body.build?.changed_pipe_names ?? [],
-    newPipeNames: body.build?.new_pipe_names ?? [],
   };
 }
+
+/**
+ * Helper function to sleep for a given number of milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/api/fetcher.ts

@@ -0,0 +1,17 @@
+export const TINYBIRD_FROM_PARAM = "ts-sdk";
+
+export type TinybirdFetch = (url: string, init?: RequestInit) => Promise<Response>;
+
+export function withTinybirdFromParam(url: string): string {
+  const parsedUrl = new URL(url);
+  parsedUrl.searchParams.set("from", TINYBIRD_FROM_PARAM);
+  return parsedUrl.toString();
+}
+
+export function createTinybirdFetcher(fetchFn: typeof fetch): TinybirdFetch {
+  return (url, init) => fetchFn(withTinybirdFromParam(url), init);
+}
+
+export function tinybirdFetch(url: string, init?: RequestInit): Promise<Response> {
+  return fetch(withTinybirdFromParam(url), init);
+}

package/src/api/local.test.ts

@@ -94,15 +94,18 @@ describe("Local API", () => {
   describe("listLocalWorkspaces", () => {
     it("returns list of workspaces", async () => {
       server.use(
-        http.get(`${LOCAL_BASE_URL}/v1/user/workspaces`, () => {
-          return HttpResponse.json({
-            organization_id: "org-123",
-            workspaces: [
-              { id: "ws-1", name: "Workspace1", token: "token-1" },
-              { id: "ws-2", name: "Workspace2", token: "token-2" },
-            ],
-          });
-        })
+        http.get(
+          `${LOCAL_BASE_URL}/v1/user/workspaces`,
+          () => {
+            return HttpResponse.json({
+              organization_id: "org-123",
+              workspaces: [
+                { id: "ws-1", name: "Workspace1", token: "token-1" },
+                { id: "ws-2", name: "Workspace2", token: "token-2" },
+              ],
+            });
+          }
+        )
       );
 
       const result = await listLocalWorkspaces("admin-token");
@@ -118,9 +121,12 @@ describe("Local API", () => {
 
     it("throws LocalApiError on failure", async () => {
       server.use(
-        http.get(`${LOCAL_BASE_URL}/v1/user/workspaces`, () => {
-          return new HttpResponse("Not found", { status: 404 });
-        })
+        http.get(
+          `${LOCAL_BASE_URL}/v1/user/workspaces`,
+          () => {
+            return new HttpResponse("Not found", { status: 404 });
+          }
+        )
       );
 
       await expect(listLocalWorkspaces("admin-token")).rejects.toThrow(LocalApiError);
@@ -170,14 +176,17 @@ describe("Local API", () => {
 
     it("returns existing workspace if found", async () => {
       server.use(
-        http.get(`${LOCAL_BASE_URL}/v1/user/workspaces`, () => {
-          return HttpResponse.json({
-            organization_id: "org-123",
-            workspaces: [
-              { id: "existing-ws", name: "MyWorkspace", token: "existing-token" },
-            ],
-          });
-        })
+        http.get(
+          `${LOCAL_BASE_URL}/v1/user/workspaces`,
+          () => {
+            return HttpResponse.json({
+              organization_id: "org-123",
+              workspaces: [
+                { id: "existing-ws", name: "MyWorkspace", token: "existing-token" },
+              ],
+            });
+          }
+        )
       );
 
       const result = await getOrCreateLocalWorkspace(tokens, "MyWorkspace");
@@ -191,21 +200,24 @@ describe("Local API", () => {
       let createCalled = false;
 
       server.use(
-        http.get(`${LOCAL_BASE_URL}/v1/user/workspaces`, () => {
-          // Return different response based on whether create was called
-          if (createCalled) {
+        http.get(
+          `${LOCAL_BASE_URL}/v1/user/workspaces`,
+          () => {
+            // Return different response based on whether create was called
+            if (createCalled) {
+              return HttpResponse.json({
+                organization_id: "org-123",
+                workspaces: [
+                  { id: "new-ws", name: "NewWorkspace", token: "new-token" },
+                ],
+              });
+            }
             return HttpResponse.json({
               organization_id: "org-123",
-              workspaces: [
-                { id: "new-ws", name: "NewWorkspace", token: "new-token" },
-              ],
+              workspaces: [], // Empty initially
             });
           }
-          return HttpResponse.json({
-            organization_id: "org-123",
-            workspaces: [], // Empty initially
-          });
-        }),
+        ),
         http.post(`${LOCAL_BASE_URL}/v1/workspaces`, () => {
           createCalled = true;
           return HttpResponse.json({

package/src/api/local.ts

@@ -5,6 +5,7 @@
 
 import * as crypto from "crypto";
 import { LOCAL_BASE_URL } from "../cli/config.js";
+import { tinybirdFetch } from "./fetcher.js";
 
 /**
  * Tokens returned by the local /tokens endpoint
@@ -76,7 +77,7 @@ export class LocalApiError extends Error {
  */
 export async function isLocalRunning(): Promise<boolean> {
   try {
-    const response = await fetch(`${LOCAL_BASE_URL}/tokens`, {
+    const response = await tinybirdFetch(`${LOCAL_BASE_URL}/tokens`, {
       method: "GET",
       signal: AbortSignal.timeout(5000),
     });
@@ -94,7 +95,7 @@ export async function isLocalRunning(): Promise<boolean> {
  */
 export async function getLocalTokens(): Promise<LocalTokens> {
   try {
-    const response = await fetch(`${LOCAL_BASE_URL}/tokens`, {
+    const response = await tinybirdFetch(`${LOCAL_BASE_URL}/tokens`, {
       method: "GET",
       signal: AbortSignal.timeout(5000),
     });
@@ -136,7 +137,7 @@ export async function listLocalWorkspaces(
 ): Promise<{ workspaces: LocalWorkspace[]; organizationId?: string }> {
   const url = `${LOCAL_BASE_URL}/v1/user/workspaces?with_organization=true&token=${adminToken}`;
 
-  const response = await fetch(url, {
+  const response = await tinybirdFetch(url, {
     method: "GET",
   });
 
@@ -182,7 +183,7 @@ export async function createLocalWorkspace(
     formData.append("assign_to_organization_id", organizationId);
   }
 
-  const response = await fetch(url, {
+  const response = await tinybirdFetch(url, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${userToken}`,