@tinybirdco/sdk 0.0.2 → 0.0.4

package/src/api/local.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, beforeAll, afterEach, afterAll } from "vitest";
+import { setupServer } from "msw/node";
+import { http, HttpResponse } from "msw";
+import {
+  getLocalTokens,
+  listLocalWorkspaces,
+  createLocalWorkspace,
+  getOrCreateLocalWorkspace,
+  isLocalRunning,
+  getLocalWorkspaceName,
+  LocalNotRunningError,
+  LocalApiError,
+} from "./local.js";
+import { LOCAL_BASE_URL } from "../cli/config.js";
+
+const server = setupServer();
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("Local API", () => {
+  describe("isLocalRunning", () => {
+    it("returns true when local container is running", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/tokens`, () => {
+          return HttpResponse.json({
+            user_token: "user-token",
+            admin_token: "admin-token",
+            workspace_admin_token: "workspace-token",
+          });
+        })
+      );
+
+      const result = await isLocalRunning();
+      expect(result).toBe(true);
+    });
+
+    it("returns false when local container is not running", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/tokens`, () => {
+          return HttpResponse.error();
+        })
+      );
+
+      const result = await isLocalRunning();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getLocalTokens", () => {
+    it("returns tokens from local container", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/tokens`, () => {
+          return HttpResponse.json({
+            user_token: "user-token-123",
+            admin_token: "admin-token-456",
+            workspace_admin_token: "workspace-token-789",
+          });
+        })
+      );
+
+      const tokens = await getLocalTokens();
+
+      expect(tokens.user_token).toBe("user-token-123");
+      expect(tokens.admin_token).toBe("admin-token-456");
+      expect(tokens.workspace_admin_token).toBe("workspace-token-789");
+    });
+
+    it("throws LocalNotRunningError when container is not running", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/tokens`, () => {
+          return HttpResponse.error();
+        })
+      );
+
+      await expect(getLocalTokens()).rejects.toThrow(LocalNotRunningError);
+    });
+
+    it("throws LocalApiError when response is invalid", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/tokens`, () => {
+          return HttpResponse.json({
+            // Missing required fields
+            user_token: "user-token",
+          });
+        })
+      );
+
+      await expect(getLocalTokens()).rejects.toThrow(LocalApiError);
+    });
+  });
+
+  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" },
+            ],
+          });
+        })
+      );
+
+      const result = await listLocalWorkspaces("admin-token");
+
+      expect(result.organizationId).toBe("org-123");
+      expect(result.workspaces).toHaveLength(2);
+      expect(result.workspaces[0]).toEqual({
+        id: "ws-1",
+        name: "Workspace1",
+        token: "token-1",
+      });
+    });
+
+    it("throws LocalApiError on failure", async () => {
+      server.use(
+        http.get(`${LOCAL_BASE_URL}/v1/user/workspaces`, () => {
+          return new HttpResponse("Not found", { status: 404 });
+        })
+      );
+
+      await expect(listLocalWorkspaces("admin-token")).rejects.toThrow(LocalApiError);
+    });
+  });
+
+  describe("createLocalWorkspace", () => {
+    it("creates a new workspace", async () => {
+      server.use(
+        http.post(`${LOCAL_BASE_URL}/v1/workspaces`, async ({ request }) => {
+          const formData = await request.text();
+          const params = new URLSearchParams(formData);
+          return HttpResponse.json({
+            id: "new-ws-id",
+            name: params.get("name"),
+            token: "new-ws-token",
+          });
+        })
+      );
+
+      const result = await createLocalWorkspace("user-token", "TestWorkspace");
+
+      expect(result.id).toBe("new-ws-id");
+      expect(result.name).toBe("TestWorkspace");
+      expect(result.token).toBe("new-ws-token");
+    });
+
+    it("throws LocalApiError on failure", async () => {
+      server.use(
+        http.post(`${LOCAL_BASE_URL}/v1/workspaces`, () => {
+          return new HttpResponse("Server error", { status: 500 });
+        })
+      );
+
+      await expect(createLocalWorkspace("user-token", "TestWorkspace")).rejects.toThrow(
+        LocalApiError
+      );
+    });
+  });
+
+  describe("getOrCreateLocalWorkspace", () => {
+    const tokens = {
+      user_token: "user-token",
+      admin_token: "admin-token",
+      workspace_admin_token: "default-token",
+    };
+
+    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" },
+            ],
+          });
+        })
+      );
+
+      const result = await getOrCreateLocalWorkspace(tokens, "MyWorkspace");
+
+      expect(result.wasCreated).toBe(false);
+      expect(result.workspace.name).toBe("MyWorkspace");
+      expect(result.workspace.token).toBe("existing-token");
+    });
+
+    it("creates new workspace if not found", async () => {
+      let createCalled = false;
+
+      server.use(
+        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: [], // Empty initially
+          });
+        }),
+        http.post(`${LOCAL_BASE_URL}/v1/workspaces`, () => {
+          createCalled = true;
+          return HttpResponse.json({
+            id: "new-ws",
+            name: "NewWorkspace",
+            token: "new-token",
+          });
+        })
+      );
+
+      const result = await getOrCreateLocalWorkspace(tokens, "NewWorkspace");
+
+      expect(result.wasCreated).toBe(true);
+      expect(result.workspace.name).toBe("NewWorkspace");
+      expect(result.workspace.token).toBe("new-token");
+    });
+  });
+
+  describe("getLocalWorkspaceName", () => {
+    it("uses branch name when available", () => {
+      const name = getLocalWorkspaceName("feature_branch", "/some/path");
+      expect(name).toBe("feature_branch");
+    });
+
+    it("uses hash-based name when no branch", () => {
+      const name = getLocalWorkspaceName(null, "/some/path");
+      expect(name).toMatch(/^Build_[a-f0-9]{16}$/);
+    });
+
+    it("generates consistent hash for same path", () => {
+      const name1 = getLocalWorkspaceName(null, "/same/path");
+      const name2 = getLocalWorkspaceName(null, "/same/path");
+      expect(name1).toBe(name2);
+    });
+
+    it("generates different hash for different paths", () => {
+      const name1 = getLocalWorkspaceName(null, "/path/one");
+      const name2 = getLocalWorkspaceName(null, "/path/two");
+      expect(name1).not.toBe(name2);
+    });
+  });
+});

package/src/api/local.ts

@@ -0,0 +1,270 @@
+/**
+ * Local Tinybird container API client
+ * For use with tinybird-local Docker image
+ */
+
+import * as crypto from "crypto";
+import { LOCAL_BASE_URL } from "../cli/config.js";
+
+/**
+ * Tokens returned by the local /tokens endpoint
+ */
+export interface LocalTokens {
+  /** User token for user-level operations */
+  user_token: string;
+  /** Admin token for admin operations like listing workspaces */
+  admin_token: string;
+  /** Default workspace admin token */
+  workspace_admin_token: string;
+}
+
+/**
+ * Workspace info from local Tinybird
+ */
+export interface LocalWorkspace {
+  /** Workspace ID */
+  id: string;
+  /** Workspace name */
+  name: string;
+  /** Workspace token */
+  token: string;
+}
+
+/**
+ * Response from /v1/user/workspaces endpoint
+ */
+interface UserWorkspacesResponse {
+  organization_id?: string;
+  workspaces: Array<{
+    id: string;
+    name: string;
+    token: string;
+  }>;
+}
+
+/**
+ * Error thrown when local container is not running
+ */
+export class LocalNotRunningError extends Error {
+  constructor() {
+    super(
+      `Tinybird local is not running. Start it with:\n` +
+        `docker run -d -p 7181:7181 --name tinybird-local tinybirdco/tinybird-local:latest`
+    );
+    this.name = "LocalNotRunningError";
+  }
+}
+
+/**
+ * Error thrown by local API operations
+ */
+export class LocalApiError extends Error {
+  constructor(
+    message: string,
+    public readonly status?: number,
+    public readonly body?: unknown
+  ) {
+    super(message);
+    this.name = "LocalApiError";
+  }
+}
+
+/**
+ * Check if local Tinybird container is running
+ *
+ * @returns true if container is running and healthy
+ */
+export async function isLocalRunning(): Promise<boolean> {
+  try {
+    const response = await fetch(`${LOCAL_BASE_URL}/tokens`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get tokens from local Tinybird container
+ *
+ * @returns Local tokens
+ * @throws LocalNotRunningError if container is not running
+ */
+export async function getLocalTokens(): Promise<LocalTokens> {
+  try {
+    const response = await fetch(`${LOCAL_BASE_URL}/tokens`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!response.ok) {
+      throw new LocalApiError(
+        `Failed to get local tokens: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+
+    const tokens = (await response.json()) as LocalTokens;
+
+    // Validate response structure
+    if (!tokens.user_token || !tokens.admin_token || !tokens.workspace_admin_token) {
+      throw new LocalApiError(
+        "Invalid tokens response from local Tinybird - missing required fields"
+      );
+    }
+
+    return tokens;
+  } catch (error) {
+    if (error instanceof LocalApiError) {
+      throw error;
+    }
+    // Connection error - container not running
+    throw new LocalNotRunningError();
+  }
+}
+
+/**
+ * List workspaces in local Tinybird
+ *
+ * @param adminToken - Admin token from getLocalTokens()
+ * @returns List of workspaces with their info
+ */
+export async function listLocalWorkspaces(
+  adminToken: string
+): Promise<{ workspaces: LocalWorkspace[]; organizationId?: string }> {
+  const url = `${LOCAL_BASE_URL}/v1/user/workspaces?with_organization=true&token=${adminToken}`;
+
+  const response = await fetch(url, {
+    method: "GET",
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new LocalApiError(
+      `Failed to list local workspaces: ${response.status} ${response.statusText}`,
+      response.status,
+      body
+    );
+  }
+
+  const data = (await response.json()) as UserWorkspacesResponse;
+
+  return {
+    workspaces: data.workspaces.map((ws) => ({
+      id: ws.id,
+      name: ws.name,
+      token: ws.token,
+    })),
+    organizationId: data.organization_id,
+  };
+}
+
+/**
+ * Create a workspace in local Tinybird
+ *
+ * @param userToken - User token from getLocalTokens()
+ * @param workspaceName - Name for the new workspace
+ * @param organizationId - Organization ID to assign workspace to
+ * @returns Created workspace info
+ */
+export async function createLocalWorkspace(
+  userToken: string,
+  workspaceName: string,
+  organizationId?: string
+): Promise<LocalWorkspace> {
+  const url = `${LOCAL_BASE_URL}/v1/workspaces`;
+
+  const formData = new URLSearchParams();
+  formData.append("name", workspaceName);
+  if (organizationId) {
+    formData.append("assign_to_organization_id", organizationId);
+  }
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${userToken}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: formData.toString(),
+  });
+
+  if (!response.ok) {
+    const responseBody = await response.text();
+    throw new LocalApiError(
+      `Failed to create local workspace: ${response.status} ${response.statusText}`,
+      response.status,
+      responseBody
+    );
+  }
+
+  const data = (await response.json()) as { id: string; name: string; token: string };
+
+  return {
+    id: data.id,
+    name: data.name,
+    token: data.token,
+  };
+}
+
+/**
+ * Get or create a workspace in local Tinybird
+ *
+ * @param tokens - Tokens from getLocalTokens()
+ * @param workspaceName - Name of the workspace to get or create
+ * @returns Workspace info and whether it was newly created
+ */
+export async function getOrCreateLocalWorkspace(
+  tokens: LocalTokens,
+  workspaceName: string
+): Promise<{ workspace: LocalWorkspace; wasCreated: boolean }> {
+  // List existing workspaces
+  const { workspaces, organizationId } = await listLocalWorkspaces(tokens.admin_token);
+
+  // Check if workspace already exists
+  const existing = workspaces.find((ws) => ws.name === workspaceName);
+  if (existing) {
+    return { workspace: existing, wasCreated: false };
+  }
+
+  // Create new workspace
+  await createLocalWorkspace(
+    tokens.user_token,
+    workspaceName,
+    organizationId
+  );
+
+  // Fetch the workspace again to get the token (create response may not include it)
+  const { workspaces: updatedWorkspaces } = await listLocalWorkspaces(tokens.admin_token);
+  const newWorkspace = updatedWorkspaces.find((ws) => ws.name === workspaceName);
+
+  if (!newWorkspace) {
+    throw new LocalApiError(
+      `Created workspace '${workspaceName}' but could not find it in workspace list`
+    );
+  }
+
+  return { workspace: newWorkspace, wasCreated: true };
+}
+
+/**
+ * Get workspace name for local mode based on git branch or path
+ *
+ * @param tinybirdBranch - Sanitized git branch name (or null if not in git)
+ * @param cwd - Current working directory (used for hash if no branch)
+ * @returns Workspace name to use
+ */
+export function getLocalWorkspaceName(
+  tinybirdBranch: string | null,
+  cwd: string
+): string {
+  if (tinybirdBranch) {
+    return tinybirdBranch;
+  }
+
+  // No branch detected - use hash of path like Python implementation
+  const hash = crypto.createHash("sha256").update(cwd).digest("hex");
+  return `Build_${hash.substring(0, 16)}`;
+}