@tinybirdco/sdk 0.0.39 → 0.0.40

package/src/generator/index.test.ts

@@ -325,5 +325,49 @@ TYPE endpoint
       expect(rawPipe).toBeDefined();
       expect(rawPipe!.content).toBe(rawPipeContent);
     });
+
+    it("supports glob include patterns", async () => {
+      const nestedDir = path.join(tempDir, "tinybird", "legacy");
+      fs.mkdirSync(nestedDir, { recursive: true });
+
+      const datasourceContent = `SCHEMA >
+    id String
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "id"
+`;
+      const datasourcePath = path.join(nestedDir, "events.datasource");
+      fs.writeFileSync(datasourcePath, datasourceContent);
+
+      const pipeContent = `NODE endpoint
+SQL >
+    SELECT * FROM events
+
+TYPE endpoint
+`;
+      const pipePath = path.join(nestedDir, "events.pipe");
+      fs.writeFileSync(pipePath, pipeContent);
+
+      const result = await buildFromInclude({
+        includePaths: ["tinybird/**/*.datasource", "tinybird/**/*.pipe"],
+        cwd: tempDir,
+      });
+
+      expect(result.resources.datasources).toHaveLength(1);
+      expect(result.resources.datasources[0].name).toBe("events");
+      expect(result.resources.datasources[0].content).toBe(datasourceContent);
+      expect(result.resources.pipes).toHaveLength(1);
+      expect(result.resources.pipes[0].name).toBe("events");
+      expect(result.resources.pipes[0].content).toBe(pipeContent);
+    });
+
+    it("throws when include glob matches no files", async () => {
+      await expect(
+        buildFromInclude({
+          includePaths: ["tinybird/**/*.datasource"],
+          cwd: tempDir,
+        })
+      ).rejects.toThrow("Include pattern matched no files");
+    });
   });
 });

package/src/generator/index.ts

@@ -122,7 +122,7 @@ export async function build(options: BuildOptions): Promise<BuildResult> {
  * Build options using include paths
  */
 export interface BuildFromIncludeOptions {
-  /** Array of file paths to scan for datasources and pipes */
+  /** Array of file paths or glob patterns to scan for datasources and pipes */
   includePaths: string[];
   /** Working directory (defaults to cwd) */
   cwd?: string;

package/src/generator/loader.ts

@@ -11,6 +11,7 @@ import { isProjectDefinition, type ProjectDefinition, type DatasourcesDefinition
 import { isDatasourceDefinition, type DatasourceDefinition } from "../schema/datasource.js";
 import { isPipeDefinition, type PipeDefinition } from "../schema/pipe.js";
 import { isConnectionDefinition, type ConnectionDefinition } from "../schema/connection.js";
+import { resolveIncludeFiles } from "./include-paths.js";
 
 /**
  * Result of loading a schema file
@@ -184,7 +185,7 @@ export interface LoadedEntities {
  * Options for loading entities
  */
 export interface LoadEntitiesOptions {
-  /** Array of file paths to scan (can be relative or absolute) */
+  /** Array of file paths or glob patterns to scan (can be relative or absolute) */
   includePaths: string[];
   /** The working directory for resolution (defaults to cwd) */
   cwd?: string;
@@ -211,6 +212,7 @@ export interface LoadEntitiesOptions {
  */
 export async function loadEntities(options: LoadEntitiesOptions): Promise<LoadedEntities> {
   const cwd = options.cwd ?? process.cwd();
+  const includeFiles = resolveIncludeFiles(options.includePaths, cwd);
   const result: LoadedEntities = {
     datasources: {},
     pipes: {},
@@ -220,15 +222,9 @@ export async function loadEntities(options: LoadEntitiesOptions): Promise<Loaded
     sourceFiles: [],
   };
 
-  for (const includePath of options.includePaths) {
-    const absolutePath = path.isAbsolute(includePath)
-      ? includePath
-      : path.resolve(cwd, includePath);
-
-    // Verify the file exists
-    if (!fs.existsSync(absolutePath)) {
-      throw new Error(`Include file not found: ${absolutePath}`);
-    }
+  for (const includeFile of includeFiles) {
+    const includePath = includeFile.sourcePath;
+    const absolutePath = includeFile.absolutePath;
 
     result.sourceFiles.push(includePath);