@tinybirdco/sdk 0.0.4 → 0.0.6

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

@@ -187,9 +187,16 @@ export async function runDev(options: DevCommandOptions = {}): Promise<DevContro
     };
   } else {
     // Branch mode: use Tinybird cloud with branches
-    // If we're on a feature branch, get or create the Tinybird branch
+    // Prevent dev mode on main branch - must use deploy command
+    if (config.isMainBranch || !config.tinybirdBranch) {
+      throw new Error(
+        `Cannot use 'dev' command on main branch. Use 'tinybird deploy' to deploy to production, or switch to a feature branch.`
+      );
+    }
+
+    // Get or create the Tinybird branch
     // Use tinybirdBranch (sanitized name) for Tinybird API, gitBranch for display
-    if (!config.isMainBranch && config.tinybirdBranch) {
+    if (config.tinybirdBranch) {
       const branchName = config.tinybirdBranch; // Sanitized name for Tinybird
 
       // Always fetch fresh from API to avoid stale cache issues
@@ -246,10 +253,10 @@ 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: devMode !== "local" && config.isMainBranch,
         devModeOverride: devMode,
       });
       options.onBuildComplete?.(result);

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import { runInit } from "./init.js";
+import { runInit, findExistingDatafiles } from "./init.js";
 
 // Mock the auth module to avoid browser login
 vi.mock("../auth.js", () => ({
@@ -25,15 +25,15 @@ describe("Init Command", () => {
   });
 
   describe("folder structure creation", () => {
-    it("creates tinybird folder with datasources.ts, pipes.ts, client.ts when project has no src folder", async () => {
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+    it("creates tinybird folder with datasources.ts, endpoints.ts, client.ts when project has no src folder", async () => {
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("tinybird/datasources.ts");
-      expect(result.created).toContain("tinybird/pipes.ts");
+      expect(result.created).toContain("tinybird/endpoints.ts");
       expect(result.created).toContain("tinybird/client.ts");
       expect(fs.existsSync(path.join(tempDir, "tinybird", "datasources.ts"))).toBe(true);
-      expect(fs.existsSync(path.join(tempDir, "tinybird", "pipes.ts"))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, "tinybird", "endpoints.ts"))).toBe(true);
       expect(fs.existsSync(path.join(tempDir, "tinybird", "client.ts"))).toBe(true);
     });
 
@@ -41,17 +41,17 @@ describe("Init Command", () => {
       // Create src folder to simulate existing project
       fs.mkdirSync(path.join(tempDir, "src"));
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "src/tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("src/tinybird/datasources.ts");
-      expect(result.created).toContain("src/tinybird/pipes.ts");
+      expect(result.created).toContain("src/tinybird/endpoints.ts");
       expect(result.created).toContain("src/tinybird/client.ts");
       expect(
         fs.existsSync(path.join(tempDir, "src", "tinybird", "datasources.ts"))
       ).toBe(true);
       expect(
-        fs.existsSync(path.join(tempDir, "src", "tinybird", "pipes.ts"))
+        fs.existsSync(path.join(tempDir, "src", "tinybird", "endpoints.ts"))
       ).toBe(true);
       expect(
         fs.existsSync(path.join(tempDir, "src", "tinybird", "client.ts"))
@@ -59,7 +59,7 @@ describe("Init Command", () => {
     });
 
     it("creates tinybird.json with correct include paths for tinybird folder", async () => {
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("tinybird.json");
@@ -69,14 +69,14 @@ describe("Init Command", () => {
       );
       expect(config.include).toEqual([
         "tinybird/datasources.ts",
-        "tinybird/pipes.ts",
+        "tinybird/endpoints.ts",
       ]);
     });
 
     it("creates tinybird.json with correct include paths for src/tinybird", async () => {
       fs.mkdirSync(path.join(tempDir, "src"));
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "src/tinybird" });
 
       expect(result.success).toBe(true);
 
@@ -85,14 +85,14 @@ describe("Init Command", () => {
       );
       expect(config.include).toEqual([
         "src/tinybird/datasources.ts",
-        "src/tinybird/pipes.ts",
+        "src/tinybird/endpoints.ts",
       ]);
     });
   });
 
   describe("config file creation", () => {
     it("creates tinybird.json with default values", async () => {
-      await runInit({ cwd: tempDir, skipLogin: true });
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       const config = JSON.parse(
         fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
@@ -109,7 +109,7 @@ describe("Init Command", () => {
         JSON.stringify(existingConfig)
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.skipped).toContain("tinybird.json");
@@ -128,7 +128,7 @@ describe("Init Command", () => {
         JSON.stringify(existingConfig)
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("tinybird.json");
@@ -138,14 +138,14 @@ describe("Init Command", () => {
       );
       expect(config.include).toEqual([
         "tinybird/datasources.ts",
-        "tinybird/pipes.ts",
+        "tinybird/endpoints.ts",
       ]);
     });
   });
 
   describe("file content creation", () => {
     it("creates datasources.ts with example datasource and InferRow type", async () => {
-      await runInit({ cwd: tempDir, skipLogin: true });
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       const content = fs.readFileSync(
         path.join(tempDir, "tinybird", "datasources.ts"),
@@ -158,11 +158,11 @@ describe("Init Command", () => {
       expect(content).toContain("PageViewsRow");
     });
 
-    it("creates pipes.ts with example endpoint and types", async () => {
-      await runInit({ cwd: tempDir, skipLogin: true });
+    it("creates endpoints.ts with example endpoint and types", async () => {
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       const content = fs.readFileSync(
-        path.join(tempDir, "tinybird", "pipes.ts"),
+        path.join(tempDir, "tinybird", "endpoints.ts"),
         "utf-8"
       );
 
@@ -175,7 +175,7 @@ describe("Init Command", () => {
     });
 
     it("creates client.ts with createTinybirdClient", async () => {
-      await runInit({ cwd: tempDir, skipLogin: true });
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       const content = fs.readFileSync(
         path.join(tempDir, "tinybird", "client.ts"),
@@ -195,7 +195,7 @@ describe("Init Command", () => {
         "// existing content"
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.skipped).toContain("tinybird/datasources.ts");
@@ -215,7 +215,7 @@ describe("Init Command", () => {
         "// existing content"
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, force: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("tinybird/datasources.ts");
@@ -229,14 +229,14 @@ describe("Init Command", () => {
   });
 
   describe("package.json scripts", () => {
-    it("adds tinybird:dev and tinybird:build scripts to existing package.json", async () => {
+    it("adds tinybird:dev, tinybird:build, and tinybird:deploy scripts to existing package.json", async () => {
       const packageJson = { name: "test-project", scripts: { dev: "next dev" } };
       fs.writeFileSync(
         path.join(tempDir, "package.json"),
         JSON.stringify(packageJson, null, 2)
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).toContain("package.json (added tinybird scripts)");
@@ -246,6 +246,7 @@ describe("Init Command", () => {
       );
       expect(updatedPackageJson.scripts["tinybird:dev"]).toBe("tinybird dev");
       expect(updatedPackageJson.scripts["tinybird:build"]).toBe("tinybird build");
+      expect(updatedPackageJson.scripts["tinybird:deploy"]).toBe("tinybird deploy");
       expect(updatedPackageJson.scripts.dev).toBe("next dev"); // preserved
     });
 
@@ -255,6 +256,7 @@ describe("Init Command", () => {
         scripts: {
           "tinybird:dev": "custom dev command",
           "tinybird:build": "custom build command",
+          "tinybird:deploy": "custom deploy command",
         },
       };
       fs.writeFileSync(
@@ -262,7 +264,7 @@ describe("Init Command", () => {
         JSON.stringify(packageJson, null, 2)
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).not.toContain("package.json (added tinybird scripts)");
@@ -272,6 +274,7 @@ describe("Init Command", () => {
       );
       expect(updatedPackageJson.scripts["tinybird:dev"]).toBe("custom dev command");
       expect(updatedPackageJson.scripts["tinybird:build"]).toBe("custom build command");
+      expect(updatedPackageJson.scripts["tinybird:deploy"]).toBe("custom deploy command");
     });
 
     it("creates scripts object if package.json has no scripts", async () => {
@@ -281,7 +284,7 @@ describe("Init Command", () => {
         JSON.stringify(packageJson, null, 2)
       );
 
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
 
@@ -293,7 +296,7 @@ describe("Init Command", () => {
     });
 
     it("does not fail if no package.json exists", async () => {
-      const result = await runInit({ cwd: tempDir, skipLogin: true });
+      const result = await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(result.success).toBe(true);
       expect(result.created).not.toContain("package.json (added tinybird scripts)");
@@ -304,7 +307,7 @@ describe("Init Command", () => {
     it("creates tinybird directory if it does not exist", async () => {
       expect(fs.existsSync(path.join(tempDir, "tinybird"))).toBe(false);
 
-      await runInit({ cwd: tempDir, skipLogin: true });
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "tinybird" });
 
       expect(fs.existsSync(path.join(tempDir, "tinybird"))).toBe(true);
     });
@@ -313,9 +316,215 @@ describe("Init Command", () => {
       fs.mkdirSync(path.join(tempDir, "src"));
       expect(fs.existsSync(path.join(tempDir, "src", "tinybird"))).toBe(false);
 
-      await runInit({ cwd: tempDir, skipLogin: true });
+      await runInit({ cwd: tempDir, skipLogin: true, devMode: "branch", clientPath: "src/tinybird" });
 
       expect(fs.existsSync(path.join(tempDir, "src", "tinybird"))).toBe(true);
     });
   });
+
+  describe("findExistingDatafiles", () => {
+    it("finds .datasource files in the project", () => {
+      fs.mkdirSync(path.join(tempDir, "datasources"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "datasources", "events.datasource"), "");
+      fs.writeFileSync(path.join(tempDir, "datasources", "users.datasource"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toContain("datasources/events.datasource");
+      expect(files).toContain("datasources/users.datasource");
+    });
+
+    it("finds .pipe files in the project", () => {
+      fs.mkdirSync(path.join(tempDir, "pipes"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "pipes", "top_events.pipe"), "");
+      fs.writeFileSync(path.join(tempDir, "pipes", "analytics.pipe"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toContain("pipes/analytics.pipe");
+      expect(files).toContain("pipes/top_events.pipe");
+    });
+
+    it("finds both .datasource and .pipe files", () => {
+      fs.mkdirSync(path.join(tempDir, "tinybird"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "tinybird", "events.datasource"), "");
+      fs.writeFileSync(path.join(tempDir, "tinybird", "top_events.pipe"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toHaveLength(2);
+      expect(files).toContain("tinybird/events.datasource");
+      expect(files).toContain("tinybird/top_events.pipe");
+    });
+
+    it("skips node_modules directory", () => {
+      fs.mkdirSync(path.join(tempDir, "node_modules", "some-package"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "node_modules", "some-package", "test.datasource"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).not.toContain("node_modules/some-package/test.datasource");
+      expect(files).toHaveLength(0);
+    });
+
+    it("skips hidden directories", () => {
+      fs.mkdirSync(path.join(tempDir, ".git", "hooks"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, ".git", "hooks", "test.datasource"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).not.toContain(".git/hooks/test.datasource");
+      expect(files).toHaveLength(0);
+    });
+
+    it("skips dist and build directories", () => {
+      fs.mkdirSync(path.join(tempDir, "dist"), { recursive: true });
+      fs.mkdirSync(path.join(tempDir, "build"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "dist", "test.datasource"), "");
+      fs.writeFileSync(path.join(tempDir, "build", "test.pipe"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toHaveLength(0);
+    });
+
+    it("returns empty array when no datafiles exist", () => {
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toEqual([]);
+    });
+
+    it("respects maxDepth parameter", () => {
+      // Create a deeply nested file
+      fs.mkdirSync(path.join(tempDir, "a", "b", "c", "d", "e", "f"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "a", "b", "c", "d", "e", "f", "deep.datasource"), "");
+      // Create a shallow file
+      fs.writeFileSync(path.join(tempDir, "a", "shallow.datasource"), "");
+
+      const filesDefault = findExistingDatafiles(tempDir, 5);
+      expect(filesDefault).toContain("a/shallow.datasource");
+      expect(filesDefault).not.toContain("a/b/c/d/e/f/deep.datasource");
+
+      const filesDeep = findExistingDatafiles(tempDir, 10);
+      expect(filesDeep).toContain("a/b/c/d/e/f/deep.datasource");
+    });
+
+    it("returns files in sorted order", () => {
+      fs.mkdirSync(path.join(tempDir, "datasources"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "datasources", "zebra.datasource"), "");
+      fs.writeFileSync(path.join(tempDir, "datasources", "alpha.datasource"), "");
+      fs.writeFileSync(path.join(tempDir, "datasources", "beta.datasource"), "");
+
+      const files = findExistingDatafiles(tempDir);
+
+      expect(files).toEqual([
+        "datasources/alpha.datasource",
+        "datasources/beta.datasource",
+        "datasources/zebra.datasource",
+      ]);
+    });
+  });
+
+  describe("existing datafiles detection", () => {
+    it("includes existing datafiles in config when user opts in", async () => {
+      // Create existing datafiles
+      fs.mkdirSync(path.join(tempDir, "datasources"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "datasources", "events.datasource"), "");
+      fs.mkdirSync(path.join(tempDir, "pipes"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "pipes", "top_events.pipe"), "");
+
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: true,
+        devMode: "branch",
+        clientPath: "tinybird",
+        skipDatafilePrompt: true,
+        includeExistingDatafiles: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.existingDatafiles).toContain("datasources/events.datasource");
+      expect(result.existingDatafiles).toContain("pipes/top_events.pipe");
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).toContain("datasources/events.datasource");
+      expect(config.include).toContain("pipes/top_events.pipe");
+    });
+
+    it("does not include existing datafiles when user opts out", async () => {
+      // Create existing datafiles
+      fs.mkdirSync(path.join(tempDir, "datasources"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "datasources", "events.datasource"), "");
+
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: true,
+        devMode: "branch",
+        clientPath: "tinybird",
+        skipDatafilePrompt: true,
+        includeExistingDatafiles: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.existingDatafiles).toBeUndefined();
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).not.toContain("datasources/events.datasource");
+      expect(config.include).toEqual([
+        "tinybird/datasources.ts",
+        "tinybird/endpoints.ts",
+      ]);
+    });
+
+    it("preserves TypeScript include paths alongside datafiles", async () => {
+      // Create existing datafiles
+      fs.mkdirSync(path.join(tempDir, "datasources"), { recursive: true });
+      fs.writeFileSync(path.join(tempDir, "datasources", "events.datasource"), "");
+
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: true,
+        devMode: "branch",
+        clientPath: "tinybird",
+        skipDatafilePrompt: true,
+        includeExistingDatafiles: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      // Should have both TypeScript files AND datafiles
+      expect(config.include).toContain("tinybird/datasources.ts");
+      expect(config.include).toContain("tinybird/endpoints.ts");
+      expect(config.include).toContain("datasources/events.datasource");
+    });
+
+    it("handles projects with no existing datafiles", async () => {
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: true,
+        devMode: "branch",
+        clientPath: "tinybird",
+        skipDatafilePrompt: true,
+        includeExistingDatafiles: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.existingDatafiles).toBeUndefined();
+
+      const config = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "tinybird.json"), "utf-8")
+      );
+      expect(config.include).toEqual([
+        "tinybird/datasources.ts",
+        "tinybird/endpoints.ts",
+      ]);
+    });
+  });
 });