@tinybirdco/sdk 0.0.34 → 0.0.36

package/src/cli/region-selector.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { selectRegion, getApiHostWithRegionSelection } from "./region-selector.js";
+
+// Mock the regions API
+vi.mock("../api/regions.js", () => ({
+  fetchRegions: vi.fn(),
+}));
+
+// Mock @clack/prompts
+vi.mock("@clack/prompts", () => ({
+  select: vi.fn(),
+  isCancel: vi.fn(),
+  cancel: vi.fn(),
+}));
+
+import { fetchRegions } from "../api/regions.js";
+import * as p from "@clack/prompts";
+
+const mockedFetchRegions = vi.mocked(fetchRegions);
+const mockedSelect = vi.mocked(p.select);
+const mockedIsCancel = vi.mocked(p.isCancel);
+
+describe("selectRegion", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedIsCancel.mockReturnValue(false);
+  });
+
+  it("fetches regions and shows selection prompt with GCP first", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "us-east-1", api_host: "https://api.us.tinybird.co", provider: "aws" },
+      { name: "europe-west3", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.eu.tinybird.co");
+
+    const result = await selectRegion();
+
+    expect(result.success).toBe(true);
+    expect(result.apiHost).toBe("https://api.eu.tinybird.co");
+    expect(result.regionName).toBe("europe-west3");
+    // GCP regions should appear first, then AWS
+    expect(mockedSelect).toHaveBeenCalledWith({
+      message: "Select your Tinybird region",
+      options: [
+        { value: "https://api.eu.tinybird.co", label: "gcp | europe-west3", hint: "api.eu.tinybird.co" },
+        { value: "https://api.us.tinybird.co", label: "aws | us-east-1", hint: "api.us.tinybird.co" },
+      ],
+      initialValue: undefined,
+    });
+  });
+
+  it("uses fallback regions when API fails", async () => {
+    mockedFetchRegions.mockRejectedValue(new Error("Network error"));
+    mockedSelect.mockResolvedValue("https://api.europe-west2.gcp.tinybird.co");
+
+    const result = await selectRegion();
+
+    expect(result.success).toBe(true);
+    expect(result.apiHost).toBe("https://api.europe-west2.gcp.tinybird.co");
+    expect(mockedSelect).toHaveBeenCalled();
+  });
+
+  it("returns cancelled when user cancels", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue(Symbol("cancel"));
+    mockedIsCancel.mockReturnValue(true);
+
+    const result = await selectRegion();
+
+    expect(result.success).toBe(false);
+    expect(result.cancelled).toBe(true);
+  });
+
+  it("uses fallback regions when API returns empty array", async () => {
+    mockedFetchRegions.mockResolvedValue([]);
+    mockedSelect.mockResolvedValue("https://api.tinybird.co");
+
+    const result = await selectRegion();
+
+    expect(result.success).toBe(true);
+    // Should have used fallback regions
+    expect(mockedSelect).toHaveBeenCalled();
+  });
+
+  it("pre-selects region when defaultApiHost is provided", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+      { name: "US", api_host: "https://api.us.tinybird.co", provider: "aws" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.us.tinybird.co");
+
+    const result = await selectRegion("https://api.us.tinybird.co");
+
+    expect(result.success).toBe(true);
+    expect(mockedSelect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        initialValue: "https://api.us.tinybird.co",
+      })
+    );
+  });
+
+  it("does not set initialValue when defaultApiHost does not match any region", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.eu.tinybird.co");
+
+    await selectRegion("https://api.unknown.tinybird.co");
+
+    expect(mockedSelect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        initialValue: undefined,
+      })
+    );
+  });
+});
+
+describe("getApiHostWithRegionSelection", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "region-selector-test-"));
+    vi.clearAllMocks();
+    mockedIsCancel.mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it("pre-selects baseUrl from config when present", async () => {
+    const configPath = path.join(tempDir, "tinybird.config.json");
+    fs.writeFileSync(
+      configPath,
+      JSON.stringify({ baseUrl: "https://api.us-east.tinybird.co" })
+    );
+
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+      { name: "US East", api_host: "https://api.us-east.tinybird.co", provider: "aws" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.us-east.tinybird.co");
+
+    const result = await getApiHostWithRegionSelection(configPath);
+
+    expect(result).toEqual({
+      apiHost: "https://api.us-east.tinybird.co",
+      fromConfig: false,
+    });
+    // Should have called select with initialValue
+    expect(mockedSelect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        initialValue: "https://api.us-east.tinybird.co",
+      })
+    );
+  });
+
+  it("prompts for region when config has no baseUrl", async () => {
+    const configPath = path.join(tempDir, "tinybird.config.json");
+    fs.writeFileSync(configPath, JSON.stringify({ token: "test" }));
+
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.eu.tinybird.co");
+
+    const result = await getApiHostWithRegionSelection(configPath);
+
+    expect(result).toEqual({
+      apiHost: "https://api.eu.tinybird.co",
+      fromConfig: false,
+    });
+    expect(mockedSelect).toHaveBeenCalled();
+  });
+
+  it("prompts for region when config file is null", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.eu.tinybird.co");
+
+    const result = await getApiHostWithRegionSelection(null);
+
+    expect(result).toEqual({
+      apiHost: "https://api.eu.tinybird.co",
+      fromConfig: false,
+    });
+  });
+
+  it("prompts for region when config is not JSON", async () => {
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue("https://api.eu.tinybird.co");
+
+    const result = await getApiHostWithRegionSelection("/path/to/config.mjs");
+
+    expect(result).toEqual({
+      apiHost: "https://api.eu.tinybird.co",
+      fromConfig: false,
+    });
+  });
+
+  it("returns null when user cancels region selection", async () => {
+    const configPath = path.join(tempDir, "tinybird.config.json");
+    fs.writeFileSync(configPath, JSON.stringify({ token: "test" }));
+
+    mockedFetchRegions.mockResolvedValue([
+      { name: "EU", api_host: "https://api.eu.tinybird.co", provider: "gcp" },
+    ]);
+    mockedSelect.mockResolvedValue(Symbol("cancel"));
+    mockedIsCancel.mockReturnValue(true);
+
+    const result = await getApiHostWithRegionSelection(configPath);
+
+    expect(result).toBeNull();
+  });
+});

package/src/cli/region-selector.ts

@@ -0,0 +1,151 @@
+/**
+ * Region selection utility for CLI commands
+ *
+ * Provides interactive region selection using @clack/prompts
+ */
+
+import * as fs from "fs";
+import * as p from "@clack/prompts";
+import { fetchRegions, type TinybirdRegion } from "../api/regions.js";
+
+/**
+ * Default fallback regions if API call fails
+ */
+const FALLBACK_REGIONS: TinybirdRegion[] = [
+  {
+    name: "EU (GCP)",
+    api_host: "https://api.europe-west2.gcp.tinybird.co",
+    provider: "gcp",
+  },
+  {
+    name: "US East (AWS)",
+    api_host: "https://api.us-east.aws.tinybird.co",
+    provider: "aws",
+  },
+  {
+    name: "EU (Default)",
+    api_host: "https://api.tinybird.co",
+    provider: "gcp",
+  },
+];
+
+/**
+ * Result of region selection
+ */
+export interface RegionSelectionResult {
+  /** Whether selection was successful (not cancelled) */
+  success: boolean;
+  /** Selected API host URL */
+  apiHost?: string;
+  /** Selected region name (for display) */
+  regionName?: string;
+  /** Whether user cancelled */
+  cancelled?: boolean;
+}
+
+/**
+ * Prompt user to select a Tinybird region
+ *
+ * Fetches available regions from the API and presents an interactive selection.
+ * Falls back to hardcoded regions if the API call fails.
+ *
+ * @param defaultApiHost - Optional API host to pre-select in the prompt
+ * @returns Selected region info or cancellation result
+ */
+export async function selectRegion(
+  defaultApiHost?: string
+): Promise<RegionSelectionResult> {
+  let regions: TinybirdRegion[];
+
+  // Try to fetch regions from API
+  try {
+    regions = await fetchRegions();
+  } catch {
+    // Fall back to hardcoded regions
+    regions = FALLBACK_REGIONS;
+  }
+
+  // Ensure we have at least one region
+  if (regions.length === 0) {
+    regions = FALLBACK_REGIONS;
+  }
+
+  // Sort regions: GCP first, then AWS
+  regions.sort((a, b) => {
+    if (a.provider === b.provider) return 0;
+    return a.provider === "gcp" ? -1 : 1;
+  });
+
+  // Build options for p.select
+  const options = regions.map((region) => ({
+    value: region.api_host,
+    label: `${region.provider} | ${region.name}`,
+    hint: region.api_host.replace("https://", ""),
+  }));
+
+  // Find initial value if defaultApiHost is provided and matches a region
+  // Normalize URLs for comparison (remove trailing slashes, lowercase)
+  const normalizeUrl = (url: string) => url.toLowerCase().replace(/\/+$/, "");
+  const initialValue = defaultApiHost
+    ? regions.find(
+        (r) => normalizeUrl(r.api_host) === normalizeUrl(defaultApiHost)
+      )?.api_host
+    : undefined;
+
+  const selected = await p.select({
+    message: "Select your Tinybird region",
+    options,
+    initialValue,
+  });
+
+  if (p.isCancel(selected)) {
+    p.cancel("Operation cancelled");
+    return {
+      success: false,
+      cancelled: true,
+    };
+  }
+
+  const selectedRegion = regions.find((r) => r.api_host === selected);
+
+  return {
+    success: true,
+    apiHost: selected as string,
+    regionName: selectedRegion?.name,
+  };
+}
+
+/**
+ * Get API host from config file or prompt for region selection
+ *
+ * @param configPath - Path to config file (or null if no config)
+ * @returns API host URL and source, or null if cancelled
+ */
+export async function getApiHostWithRegionSelection(
+  configPath: string | null
+): Promise<{ apiHost: string; fromConfig: boolean } | null> {
+  let existingBaseUrl: string | undefined;
+
+  // If we have a JSON config file, try to read baseUrl from it
+  if (configPath && configPath.endsWith(".json")) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      existingBaseUrl = config.baseUrl;
+    } catch {
+      // Ignore errors reading config
+    }
+  }
+
+  // Prompt for region selection, pre-selecting existing baseUrl if available
+  const result = await selectRegion(existingBaseUrl);
+
+  if (!result.success || !result.apiHost) {
+    return null;
+  }
+
+  return {
+    apiHost: result.apiHost,
+    fromConfig: false,
+  };
+}

package/src/cli/utils/package-manager.test.ts

@@ -6,6 +6,7 @@ import {
   detectPackageManager,
   detectPackageManagerInstallCmd,
   detectPackageManagerRunCmd,
+  getPackageManagerAddCmd,
   getPackageManagerInstallCmd,
   getPackageManagerRunCmd,
   hasTinybirdSdkDependency,
@@ -196,6 +197,24 @@ describe("getPackageManagerInstallCmd", () => {
   });
 });
 
+describe("getPackageManagerAddCmd", () => {
+  it("maps npm to npm install", () => {
+    expect(getPackageManagerAddCmd("npm")).toBe("npm install");
+  });
+
+  it("maps pnpm to pnpm add", () => {
+    expect(getPackageManagerAddCmd("pnpm")).toBe("pnpm add");
+  });
+
+  it("maps yarn to yarn add", () => {
+    expect(getPackageManagerAddCmd("yarn")).toBe("yarn add");
+  });
+
+  it("maps bun to bun add", () => {
+    expect(getPackageManagerAddCmd("bun")).toBe("bun add");
+  });
+});
+
 describe("detectPackageManagerInstallCmd", () => {
   it("detects install command based on lockfile", () => {
     fs.writeFileSync(path.join(tempDir, "yarn.lock"), "");

package/src/cli/utils/package-manager.ts

@@ -91,6 +91,20 @@ export function getPackageManagerInstallCmd(
   }
 }
 
+export function getPackageManagerAddCmd(packageManager: PackageManager): string {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm add";
+    case "yarn":
+      return "yarn add";
+    case "bun":
+      return "bun add";
+    case "npm":
+    default:
+      return "npm install";
+  }
+}
+
 /**
  * Detect package manager (npm, pnpm, yarn, or bun)
  */