@tinybirdco/sdk 0.0.3 → 0.0.6

package/src/cli/commands/build.ts

@@ -1,12 +1,17 @@
 /**
- * Build command - generates and pushes resources to Tinybird
+ * Build command - generates and pushes resources to Tinybird branches
  */
 
-import { loadConfig, type ResolvedConfig } from "../config.js";
+import { loadConfig, LOCAL_BASE_URL, type ResolvedConfig, type DevMode } 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";
+import {
+  getLocalTokens,
+  getOrCreateLocalWorkspace,
+  getLocalWorkspaceName,
+  LocalNotRunningError,
+} from "../../api/local.js";
 
 /**
  * Build command options
@@ -18,8 +23,8 @@ export interface BuildCommandOptions {
   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;
+  /** Override the devMode from config */
+  devModeOverride?: DevMode;
 }
 
 /**
@@ -41,7 +46,8 @@ export interface BuildCommandResult {
 /**
  * Run the build command
  *
- * Loads the schema, generates resources, and pushes to Tinybird API.
+ * Builds resources and pushes to Tinybird branches (not main).
+ * Use runDeploy for deploying to production.
  *
  * @param options - Build options
  * @returns Build command result
@@ -86,67 +92,123 @@ export async function runBuild(options: BuildCommandOptions = {}): Promise<Build
     };
   }
 
-  // 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
+  // Determine devMode
+  const devMode = options.devModeOverride ?? config.devMode;
   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}`);
+    console.log(`[debug] devMode: ${devMode}`);
   }
-  if (!config.isMainBranch && config.tinybirdBranch && !options.tokenOverride) {
-    if (debug) {
-      console.log(`[debug] Getting/creating Tinybird branch: ${config.tinybirdBranch}`);
-    }
+
+  let deployResult: BuildApiResult;
+
+  // Handle local mode
+  if (devMode === "local") {
     try {
-      const tinybirdBranch = await getOrCreateBranch(
+      // Get tokens from local container
+      if (debug) {
+        console.log(`[debug] Getting local tokens from ${LOCAL_BASE_URL}/tokens`);
+      }
+
+      const localTokens = await getLocalTokens();
+
+      // Get or create workspace based on branch name
+      const workspaceName = getLocalWorkspaceName(config.tinybirdBranch, config.cwd);
+      if (debug) {
+        console.log(`[debug] Using local workspace: ${workspaceName}`);
+      }
+
+      const { workspace, wasCreated } = await getOrCreateLocalWorkspace(localTokens, workspaceName);
+      if (debug) {
+        console.log(`[debug] Workspace ${wasCreated ? "created" : "found"}: ${workspace.name}`);
+      }
+
+      // Always use /v1/build for local (no deploy endpoint)
+      deployResult = await buildToTinybird(
         {
-          baseUrl: config.baseUrl,
-          token: config.token,
+          baseUrl: LOCAL_BASE_URL,
+          token: workspace.token,
         },
-        config.tinybirdBranch
+        buildResult.resources
       );
-
-      if (!tinybirdBranch.token) {
+    } catch (error) {
+      if (error instanceof LocalNotRunningError) {
         return {
           success: false,
           build: buildResult,
-          error: `Branch '${config.tinybirdBranch}' was created but no token was returned.`,
+          error: error.message,
           durationMs: Date.now() - startTime,
         };
       }
+      return {
+        success: false,
+        build: buildResult,
+        error: `Local build failed: ${(error as Error).message}`,
+        durationMs: Date.now() - startTime,
+      };
+    }
+  } else {
+    // Branch mode (default)
+    // Prevent building to main - must use deploy command
+    // Skip this check if tokenOverride is provided (dev command passes branch token)
+    const isMainBranch = config.isMainBranch || !config.tinybirdBranch;
 
-      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) {
+    if (isMainBranch && !options.tokenOverride) {
       return {
         success: false,
         build: buildResult,
-        error: `Failed to get/create branch: ${(error as Error).message}`,
+        error: `Cannot deploy to main workspace with 'build' command. Use 'tinybird deploy' to deploy to production, or switch to a feature branch.`,
         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 {
+    if (debug) {
+      console.log(`[debug] isMainBranch: ${config.isMainBranch}`);
+      console.log(`[debug] tinybirdBranch: ${config.tinybirdBranch}`);
+      console.log(`[debug] tokenOverride: ${!!options.tokenOverride}`);
+    }
+
+    let effectiveToken = options.tokenOverride ?? config.token;
+
+    // Get or create the Tinybird branch and use its token
+    if (!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;
+        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,
+        };
+      }
+    }
+
+    try {
+      // Always use /v1/build for branches
       deployResult = await buildToTinybird(
         {
           baseUrl: config.baseUrl,
@@ -154,14 +216,14 @@ export async function runBuild(options: BuildCommandOptions = {}): Promise<Build
         },
         buildResult.resources
       );
+    } catch (error) {
+      return {
+        success: false,
+        build: buildResult,
+        error: `Deploy failed: ${(error as Error).message}`,
+        durationMs: Date.now() - startTime,
+      };
     }
-  } catch (error) {
-    return {
-      success: false,
-      build: buildResult,
-      error: `Deploy failed: ${(error as Error).message}`,
-      durationMs: Date.now() - startTime,
-    };
   }
 
   if (!deployResult.success) {

package/src/cli/commands/deploy.ts

@@ -0,0 +1,126 @@
+/**
+ * Deploy command - deploys resources to main Tinybird workspace
+ */
+
+import { loadConfig, type ResolvedConfig } from "../config.js";
+import { buildFromInclude, type BuildFromIncludeResult } from "../../generator/index.js";
+import { deployToMain } from "../../api/deploy.js";
+import type { BuildApiResult } from "../../api/build.js";
+
+/**
+ * Deploy command options
+ */
+export interface DeployCommandOptions {
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Skip pushing to API (just generate) */
+  dryRun?: boolean;
+}
+
+/**
+ * Deploy command result
+ */
+export interface DeployCommandResult {
+  /** Whether the deploy was successful */
+  success: boolean;
+  /** Build result with generated resources */
+  build?: BuildFromIncludeResult;
+  /** Deploy API result (if not dry run) */
+  deploy?: BuildApiResult;
+  /** Error message if failed */
+  error?: string;
+  /** Duration in milliseconds */
+  durationMs: number;
+}
+
+/**
+ * Run the deploy command
+ *
+ * Builds resources and deploys to main Tinybird workspace (production).
+ *
+ * @param options - Deploy options
+ * @returns Deploy command result
+ */
+export async function runDeploy(options: DeployCommandOptions = {}): Promise<DeployCommandResult> {
+  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,
+    };
+  }
+
+  const debug = !!process.env.TINYBIRD_DEBUG;
+
+  if (debug) {
+    console.log(`[debug] Deploying to main workspace`);
+    console.log(`[debug] baseUrl: ${config.baseUrl}`);
+  }
+
+  // Deploy to main workspace using /v1/deploy endpoint
+  let deployResult: BuildApiResult;
+  try {
+    deployResult = await deployToMain(
+      {
+        baseUrl: config.baseUrl,
+        token: config.token,
+      },
+      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,
+  };
+}

package/src/cli/commands/dev.ts

@@ -4,7 +4,7 @@
 
 import * as path from "path";
 import { watch } from "chokidar";
-import { loadConfig, configExists, findConfigFile, hasValidToken, updateConfig, type ResolvedConfig } from "../config.js";
+import { loadConfig, configExists, findConfigFile, hasValidToken, updateConfig, LOCAL_BASE_URL, type ResolvedConfig, type DevMode } from "../config.js";
 import { runBuild, type BuildCommandResult } from "./build.js";
 import { getOrCreateBranch, type TinybirdBranch } from "../../api/branches.js";
 import { browserLogin } from "../auth.js";
@@ -13,6 +13,12 @@ import {
   validatePipeSchemas,
   type SchemaValidationResult,
 } from "../utils/schema-validation.js";
+import {
+  getLocalTokens,
+  getOrCreateLocalWorkspace,
+  getLocalWorkspaceName,
+  type LocalWorkspace,
+} from "../../api/local.js";
 
 /**
  * Login result info
@@ -44,6 +50,8 @@ export interface DevCommandOptions {
   onLoginComplete?: (info: LoginInfo) => void;
   /** Callback when schema validation completes */
   onSchemaValidation?: (result: SchemaValidationResult) => void;
+  /** Override the devMode from config */
+  devModeOverride?: DevMode;
 }
 
 /**
@@ -54,10 +62,14 @@ export interface BranchReadyInfo {
   gitBranch: string | null;
   /** Whether we're on the main branch */
   isMainBranch: boolean;
-  /** Tinybird branch info (null if on main) */
+  /** Tinybird branch info (null if on main or local mode) */
   tinybirdBranch?: TinybirdBranch;
   /** Whether the branch was newly created */
   wasCreated?: boolean;
+  /** Whether using local mode */
+  isLocal?: boolean;
+  /** Local workspace info (only in local mode) */
+  localWorkspace?: LocalWorkspace;
 }
 
 /**
@@ -98,8 +110,19 @@ export async function runDev(options: DevCommandOptions = {}): Promise<DevContro
     );
   }
 
-  // Check if authentication is set up, if not trigger login
-  if (!hasValidToken(cwd)) {
+  // Load config first to determine devMode
+  let config: ResolvedConfig;
+  try {
+    config = loadConfig(cwd);
+  } catch (error) {
+    throw error;
+  }
+
+  // Determine devMode
+  const devMode = options.devModeOverride ?? config.devMode;
+
+  // Check if authentication is set up, if not trigger login (skip for local mode)
+  if (devMode !== "local" && !hasValidToken(cwd)) {
     console.log("No authentication found. Starting login flow...\n");
 
     const authResult = await browserLogin();
@@ -134,51 +157,72 @@ export async function runDev(options: DevCommandOptions = {}): Promise<DevContro
       workspaceName: authResult.workspaceName,
       userEmail: authResult.userEmail,
     });
-  }
 
-  // Load config (now should have valid token)
-  let config: ResolvedConfig;
-  try {
+    // Reload config after login
     config = loadConfig(cwd);
-  } catch (error) {
-    throw error;
   }
 
-  // Determine effective token based on git branch
+  // Determine effective token and branch info based on devMode
   let effectiveToken = config.token;
+  let effectiveBaseUrl = config.baseUrl;
   let branchInfo: BranchReadyInfo = {
     gitBranch: config.gitBranch,
     isMainBranch: config.isMainBranch,
   };
 
-  // If we're on a feature branch, get or create the Tinybird branch
-  // Use tinybirdBranch (sanitized name) for Tinybird API, gitBranch for display
-  if (!config.isMainBranch && config.tinybirdBranch) {
-    const branchName = config.tinybirdBranch; // Sanitized name for Tinybird
-
-    // Always fetch fresh from API to avoid stale cache issues
-    const tinybirdBranch = await getOrCreateBranch(
-      {
-        baseUrl: config.baseUrl,
-        token: config.token,
-      },
-      branchName
-    );
+  if (devMode === "local") {
+    // Local mode: get tokens from local container and set up workspace
+    const localTokens = await getLocalTokens();
+    const workspaceName = getLocalWorkspaceName(config.tinybirdBranch, config.cwd);
+    const { workspace, wasCreated } = await getOrCreateLocalWorkspace(localTokens, workspaceName);
 
-    if (!tinybirdBranch.token) {
+    effectiveToken = workspace.token;
+    effectiveBaseUrl = LOCAL_BASE_URL;
+    branchInfo = {
+      gitBranch: config.gitBranch,
+      isMainBranch: false, // Local mode always uses build, not deploy
+      isLocal: true,
+      localWorkspace: workspace,
+      wasCreated,
+    };
+  } else {
+    // Branch mode: use Tinybird cloud with branches
+    // Prevent dev mode on main branch - must use deploy command
+    if (config.isMainBranch || !config.tinybirdBranch) {
       throw new Error(
-        `Branch '${branchName}' was created but no token was returned. ` +
-          `This may be an API issue.`
+        `Cannot use 'dev' command on main branch. Use 'tinybird deploy' to deploy to production, or switch to a feature branch.`
       );
     }
 
-    effectiveToken = tinybirdBranch.token;
-    branchInfo = {
-      gitBranch: config.gitBranch, // Original git branch name for display
-      isMainBranch: false,
-      tinybirdBranch,
-      wasCreated: tinybirdBranch.wasCreated ?? false,
-    };
+    // Get or create the Tinybird branch
+    // Use tinybirdBranch (sanitized name) for Tinybird API, gitBranch for display
+    if (config.tinybirdBranch) {
+      const branchName = config.tinybirdBranch; // Sanitized name for Tinybird
+
+      // Always fetch fresh from API to avoid stale cache issues
+      const tinybirdBranch = await getOrCreateBranch(
+        {
+          baseUrl: config.baseUrl,
+          token: config.token,
+        },
+        branchName
+      );
+
+      if (!tinybirdBranch.token) {
+        throw new Error(
+          `Branch '${branchName}' was created but no token was returned. ` +
+            `This may be an API issue.`
+        );
+      }
+
+      effectiveToken = tinybirdBranch.token;
+      branchInfo = {
+        gitBranch: config.gitBranch, // Original git branch name for display
+        isMainBranch: false,
+        tinybirdBranch,
+        wasCreated: tinybirdBranch.wasCreated ?? false,
+      };
+    }
   }
 
   // Notify about branch readiness
@@ -209,10 +253,11 @@ export async function runDev(options: DevCommandOptions = {}): Promise<DevContro
     options.onBuildStart?.();
 
     try {
+      // Always use runBuild - main branch is blocked at startup
       const result = await runBuild({
         cwd: config.cwd,
         tokenOverride: effectiveToken,
-        useDeployEndpoint: config.isMainBranch,
+        devModeOverride: devMode,
       });
       options.onBuildComplete?.(result);
 
@@ -234,7 +279,7 @@ export async function runDev(options: DevCommandOptions = {}): Promise<DevContro
             const validation = await validatePipeSchemas({
               entities: result.build.entities,
               pipeNames: changedPipes,
-              baseUrl: config.baseUrl,
+              baseUrl: effectiveBaseUrl,
               token: effectiveToken,
             });