@tinybirdco/sdk 0.0.1

package/dist/generator/pipe.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pipe content generator
+ * Converts PipeDefinition to native .pipe file format
+ */
+import type { PipeDefinition } from "../schema/pipe.js";
+/**
+ * Generated pipe content
+ */
+export interface GeneratedPipe {
+    /** Pipe name */
+    name: string;
+    /** The generated .pipe file content */
+    content: string;
+}
+/**
+ * Generate a .pipe file content from a PipeDefinition
+ *
+ * @param pipe - The pipe definition
+ * @returns Generated pipe content
+ *
+ * @example
+ * ```ts
+ * const topEvents = definePipe('top_events', {
+ *   description: 'Get top events by count',
+ *   params: {
+ *     start_date: p.dateTime(),
+ *     limit: p.int32().optional(10),
+ *   },
+ *   nodes: [
+ *     node({
+ *       name: 'endpoint',
+ *       sql: `
+ *         SELECT event_type, count() as count
+ *         FROM events
+ *         WHERE timestamp >= {{DateTime(start_date)}}
+ *         ORDER BY count DESC
+ *         LIMIT {{Int32(limit, 10)}}
+ *       `,
+ *     }),
+ *   ],
+ *   output: {
+ *     event_type: t.string(),
+ *     count: t.uint64(),
+ *   },
+ *   endpoint: true,
+ * });
+ *
+ * const { content } = generatePipe(topEvents);
+ * // Returns:
+ * // DESCRIPTION >
+ * //     Get top events by count
+ * //
+ * // NODE endpoint
+ * // SQL >
+ * //     SELECT event_type, count() as count
+ * //     FROM events
+ * //     WHERE timestamp >= {{DateTime(start_date)}}
+ * //     ORDER BY count DESC
+ * //     LIMIT {{Int32(limit, 10)}}
+ * //
+ * // TYPE endpoint
+ * ```
+ */
+export declare function generatePipe(pipe: PipeDefinition): GeneratedPipe;
+/**
+ * Generate .pipe files for all pipes in a project
+ *
+ * @param pipes - Record of pipe definitions
+ * @returns Array of generated pipe content
+ */
+export declare function generateAllPipes(pipes: Record<string, PipeDefinition>): GeneratedPipe[];
+//# sourceMappingURL=pipe.d.ts.map

package/dist/generator/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/generator/pipe.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EAKf,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;CACjB;AA6FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,aAAa,CA2ChE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GACpC,aAAa,EAAE,CAEjB"}

package/dist/generator/pipe.js

@@ -0,0 +1,174 @@
+/**
+ * Pipe content generator
+ * Converts PipeDefinition to native .pipe file format
+ */
+import { getEndpointConfig, getMaterializedConfig, getCopyConfig } from "../schema/pipe.js";
+/**
+ * Check if SQL contains template parameters like {{...}}
+ */
+function hasDynamicParameters(sql) {
+    return /\{\{[^}]+\}\}/.test(sql);
+}
+/**
+ * Generate a NODE section for the pipe
+ */
+function generateNode(node) {
+    const parts = [];
+    parts.push(`NODE ${node._name}`);
+    if (node.description) {
+        parts.push(`DESCRIPTION >`);
+        parts.push(`    ${node.description}`);
+    }
+    parts.push(`SQL >`);
+    // Check if SQL has dynamic parameters - if so, add % on its own line
+    const isDynamic = hasDynamicParameters(node.sql);
+    if (isDynamic) {
+        parts.push(`    %`);
+    }
+    const sqlLines = node.sql.trim().split("\n");
+    sqlLines.forEach((line) => {
+        parts.push(`    ${line}`);
+    });
+    return parts.join("\n");
+}
+/**
+ * Generate the TYPE endpoint section
+ */
+function generateEndpoint(endpoint) {
+    const parts = ["TYPE endpoint"];
+    if (endpoint.cache?.enabled) {
+        if (endpoint.cache.ttl !== undefined) {
+            parts.push(`CACHE ${endpoint.cache.ttl}`);
+        }
+        else {
+            parts.push("CACHE 60"); // Default cache TTL
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * Generate the TYPE MATERIALIZED section
+ */
+function generateMaterialized(config) {
+    const parts = ["TYPE MATERIALIZED"];
+    // The config is normalized by definePipe to always have `datasource` set.
+    // Use non-null assertion since we know it's always present after normalization.
+    const datasourceName = config.datasource._name;
+    parts.push(`DATASOURCE ${datasourceName}`);
+    if (config.deploymentMethod === "alter") {
+        parts.push("DEPLOYMENT_METHOD alter");
+    }
+    return parts.join("\n");
+}
+/**
+ * Generate the TYPE COPY section
+ */
+function generateCopy(config) {
+    const parts = ["TYPE COPY"];
+    const datasourceName = config.datasource._name;
+    parts.push(`TARGET_DATASOURCE ${datasourceName}`);
+    if (config.copy_schedule) {
+        parts.push(`COPY_SCHEDULE ${config.copy_schedule}`);
+    }
+    if (config.copy_mode) {
+        parts.push(`COPY_MODE ${config.copy_mode}`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Generate a .pipe file content from a PipeDefinition
+ *
+ * @param pipe - The pipe definition
+ * @returns Generated pipe content
+ *
+ * @example
+ * ```ts
+ * const topEvents = definePipe('top_events', {
+ *   description: 'Get top events by count',
+ *   params: {
+ *     start_date: p.dateTime(),
+ *     limit: p.int32().optional(10),
+ *   },
+ *   nodes: [
+ *     node({
+ *       name: 'endpoint',
+ *       sql: `
+ *         SELECT event_type, count() as count
+ *         FROM events
+ *         WHERE timestamp >= {{DateTime(start_date)}}
+ *         ORDER BY count DESC
+ *         LIMIT {{Int32(limit, 10)}}
+ *       `,
+ *     }),
+ *   ],
+ *   output: {
+ *     event_type: t.string(),
+ *     count: t.uint64(),
+ *   },
+ *   endpoint: true,
+ * });
+ *
+ * const { content } = generatePipe(topEvents);
+ * // Returns:
+ * // DESCRIPTION >
+ * //     Get top events by count
+ * //
+ * // NODE endpoint
+ * // SQL >
+ * //     SELECT event_type, count() as count
+ * //     FROM events
+ * //     WHERE timestamp >= {{DateTime(start_date)}}
+ * //     ORDER BY count DESC
+ * //     LIMIT {{Int32(limit, 10)}}
+ * //
+ * // TYPE endpoint
+ * ```
+ */
+export function generatePipe(pipe) {
+    const parts = [];
+    // Add description if present
+    if (pipe.options.description) {
+        parts.push(`DESCRIPTION >\n    ${pipe.options.description}`);
+        parts.push("");
+    }
+    // Add all nodes
+    pipe.options.nodes.forEach((node, index) => {
+        parts.push(generateNode(node));
+        // Add empty line between nodes
+        if (index < pipe.options.nodes.length - 1) {
+            parts.push("");
+        }
+    });
+    // Add endpoint configuration if this is an endpoint
+    const endpointConfig = getEndpointConfig(pipe);
+    if (endpointConfig) {
+        parts.push("");
+        parts.push(generateEndpoint(endpointConfig));
+    }
+    // Add materialized view configuration if this is a materialized view
+    const materializedConfig = getMaterializedConfig(pipe);
+    if (materializedConfig) {
+        parts.push("");
+        parts.push(generateMaterialized(materializedConfig));
+    }
+    // Add copy pipe configuration if this is a copy pipe
+    const copyConfig = getCopyConfig(pipe);
+    if (copyConfig) {
+        parts.push("");
+        parts.push(generateCopy(copyConfig));
+    }
+    return {
+        name: pipe._name,
+        content: parts.join("\n"),
+    };
+}
+/**
+ * Generate .pipe files for all pipes in a project
+ *
+ * @param pipes - Record of pipe definitions
+ * @returns Array of generated pipe content
+ */
+export function generateAllPipes(pipes) {
+    return Object.values(pipes).map(generatePipe);
+}
+//# sourceMappingURL=pipe.js.map

package/dist/generator/pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.js","sourceRoot":"","sources":["../../src/generator/pipe.ts"],"names":[],"mappings":"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"}

package/dist/generator/pipe.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipe.test.d.ts.map

package/dist/generator/pipe.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.test.d.ts","sourceRoot":"","sources":["../../src/generator/pipe.test.ts"],"names":[],"mappings":""}

package/dist/generator/pipe.test.js

@@ -0,0 +1,393 @@
+import { describe, it, expect } from 'vitest';
+import { generatePipe, generateAllPipes } from './pipe.js';
+import { definePipe, defineMaterializedView, node } from '../schema/pipe.js';
+import { defineDatasource } from '../schema/datasource.js';
+import { t } from '../schema/types.js';
+import { p } from '../schema/params.js';
+import { engine } from '../schema/engines.js';
+// Helper to create a simple output schema for tests
+const simpleOutput = { result: t.int32() };
+describe('Pipe Generator', () => {
+    describe('generatePipe', () => {
+        it('generates basic pipe with node', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        sql: 'SELECT * FROM table',
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.name).toBe('test_pipe');
+            expect(result.content).toContain('NODE endpoint');
+            expect(result.content).toContain('SQL >');
+            expect(result.content).toContain('SELECT * FROM table');
+        });
+        it('includes description when provided', () => {
+            const pipe = definePipe('test_pipe', {
+                description: 'Test pipe description',
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('DESCRIPTION >');
+            expect(result.content).toContain('Test pipe description');
+        });
+        it('includes TYPE endpoint when endpoint is true', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('TYPE endpoint');
+        });
+        it('does not include TYPE endpoint when endpoint is false', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: false,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).not.toContain('TYPE endpoint');
+        });
+    });
+    describe('Dynamic SQL detection', () => {
+        it('adds % on its own line for SQL with template parameters', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        sql: 'SELECT * FROM table WHERE id = {{Int32(id)}}',
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('SQL >\n    %\n    SELECT');
+        });
+        it('adds % for SQL with DateTime parameter', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        sql: 'SELECT * FROM table WHERE timestamp >= {{DateTime(start_date)}}',
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('    %\n');
+        });
+        it('does not add % for SQL without template parameters', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        sql: 'SELECT * FROM table',
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).not.toContain('%');
+        });
+        it('does not add % for SQL with curly braces that are not parameters', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        sql: "SELECT JSONExtract(data, 'field', 'String') FROM table",
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).not.toContain('%');
+        });
+    });
+    describe('Multiple nodes', () => {
+        it('generates all nodes with separation', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({ name: 'first', sql: 'SELECT * FROM table1' }),
+                    node({ name: 'second', sql: 'SELECT * FROM first' }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('NODE first');
+            expect(result.content).toContain('NODE second');
+            expect(result.content).toContain('SELECT * FROM table1');
+            expect(result.content).toContain('SELECT * FROM first');
+        });
+        it('includes node descriptions', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [
+                    node({
+                        name: 'endpoint',
+                        description: 'This is a test node',
+                        sql: 'SELECT 1',
+                    }),
+                ],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('NODE endpoint');
+            expect(result.content).toContain('DESCRIPTION >');
+            expect(result.content).toContain('This is a test node');
+        });
+    });
+    describe('Endpoint configuration', () => {
+        it('includes cache when enabled', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: {
+                    enabled: true,
+                    cache: { enabled: true, ttl: 300 },
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('TYPE endpoint');
+            expect(result.content).toContain('CACHE 300');
+        });
+        it('uses default cache TTL when not specified', () => {
+            const pipe = definePipe('test_pipe', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: {
+                    enabled: true,
+                    cache: { enabled: true },
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('CACHE 60');
+        });
+    });
+    describe('generateAllPipes', () => {
+        it('generates all pipes', () => {
+            const pipe1 = definePipe('pipe1', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 1' })],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const pipe2 = definePipe('pipe2', {
+                nodes: [node({ name: 'endpoint', sql: 'SELECT 2' })],
+                output: simpleOutput,
+                endpoint: true,
+            });
+            const results = generateAllPipes({ pipe1, pipe2 });
+            expect(results).toHaveLength(2);
+            expect(results.map(r => r.name).sort()).toEqual(['pipe1', 'pipe2']);
+        });
+    });
+    describe('Full integration', () => {
+        it('generates complete pipe file', () => {
+            const pipe = definePipe('top_pages', {
+                description: 'Get the most visited pages',
+                params: {
+                    start_date: p.dateTime(),
+                    end_date: p.dateTime(),
+                    limit: p.int32().optional(10),
+                },
+                nodes: [
+                    node({
+                        name: 'aggregated',
+                        sql: `
+SELECT
+  pathname,
+  count() AS views
+FROM page_views
+WHERE timestamp >= {{DateTime(start_date)}}
+  AND timestamp <= {{DateTime(end_date)}}
+GROUP BY pathname
+ORDER BY views DESC
+LIMIT {{Int32(limit, 10)}}
+            `.trim(),
+                    }),
+                ],
+                output: {
+                    pathname: t.string(),
+                    views: t.uint64(),
+                },
+                endpoint: true,
+            });
+            const result = generatePipe(pipe);
+            expect(result.name).toBe('top_pages');
+            expect(result.content).toContain('DESCRIPTION >');
+            expect(result.content).toContain('Get the most visited pages');
+            expect(result.content).toContain('NODE aggregated');
+            expect(result.content).toContain('SQL >');
+            expect(result.content).toContain('    %\n');
+            expect(result.content).toContain('pathname');
+            expect(result.content).toContain('{{DateTime(start_date)}}');
+            expect(result.content).toContain('{{Int32(limit, 10)}}');
+            expect(result.content).toContain('TYPE endpoint');
+        });
+    });
+    describe('Materialized Views', () => {
+        const salesByHour = defineDatasource('sales_by_hour', {
+            schema: {
+                day: t.date(),
+                country: t.string().lowCardinality(),
+                total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+            },
+            engine: engine.aggregatingMergeTree({
+                sortingKey: ['day', 'country'],
+            }),
+        });
+        it('generates TYPE MATERIALIZED and DATASOURCE with datasource', () => {
+            const pipe = definePipe('sales_by_hour_mv', {
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: 'SELECT toStartOfDay(date) as day, country, sum(sales) as total_sales FROM teams GROUP BY day, country',
+                    }),
+                ],
+                output: {
+                    day: t.date(),
+                    country: t.string().lowCardinality(),
+                    total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+                },
+                materialized: {
+                    datasource: salesByHour,
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('TYPE MATERIALIZED');
+            expect(result.content).toContain('DATASOURCE sales_by_hour');
+            expect(result.content).not.toContain('TYPE endpoint');
+        });
+        it('generates DEPLOYMENT_METHOD alter when specified', () => {
+            const pipe = definePipe('sales_by_hour_mv', {
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: 'SELECT toStartOfDay(date) as day, country, sum(sales) as total_sales FROM teams GROUP BY day, country',
+                    }),
+                ],
+                output: {
+                    day: t.date(),
+                    country: t.string().lowCardinality(),
+                    total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+                },
+                materialized: {
+                    datasource: salesByHour,
+                    deploymentMethod: 'alter',
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('TYPE MATERIALIZED');
+            expect(result.content).toContain('DATASOURCE sales_by_hour');
+            expect(result.content).toContain('DEPLOYMENT_METHOD alter');
+        });
+        it('does not include DEPLOYMENT_METHOD when not specified', () => {
+            const pipe = definePipe('sales_by_hour_mv', {
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: 'SELECT toStartOfDay(date) as day, country, sum(sales) as total_sales FROM teams GROUP BY day, country',
+                    }),
+                ],
+                output: {
+                    day: t.date(),
+                    country: t.string().lowCardinality(),
+                    total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+                },
+                materialized: {
+                    datasource: salesByHour,
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).not.toContain('DEPLOYMENT_METHOD');
+        });
+        it('generates complete materialized view pipe file', () => {
+            const pipe = definePipe('sales_by_hour_mv', {
+                description: 'Aggregate sales per hour',
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: `
+SELECT
+  toStartOfDay(starting_date) as day,
+  country,
+  sum(sales) as total_sales
+FROM teams
+GROUP BY day, country
+            `.trim(),
+                    }),
+                ],
+                output: {
+                    day: t.date(),
+                    country: t.string().lowCardinality(),
+                    total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+                },
+                materialized: {
+                    datasource: salesByHour,
+                    deploymentMethod: 'alter',
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.name).toBe('sales_by_hour_mv');
+            expect(result.content).toContain('DESCRIPTION >');
+            expect(result.content).toContain('Aggregate sales per hour');
+            expect(result.content).toContain('NODE daily_sales');
+            expect(result.content).toContain('SQL >');
+            expect(result.content).toContain('toStartOfDay(starting_date) as day');
+            expect(result.content).toContain('TYPE MATERIALIZED');
+            expect(result.content).toContain('DATASOURCE sales_by_hour');
+            expect(result.content).toContain('DEPLOYMENT_METHOD alter');
+        });
+        it('works with defineMaterializedView helper using datasource', () => {
+            const pipe = defineMaterializedView('sales_mv', {
+                description: 'Sales materialized view',
+                datasource: salesByHour,
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: 'SELECT toStartOfDay(date) as day, country, sum(sales) as total_sales FROM events GROUP BY day, country',
+                    }),
+                ],
+                deploymentMethod: 'alter',
+            });
+            const result = generatePipe(pipe);
+            expect(result.name).toBe('sales_mv');
+            expect(result.content).toContain('TYPE MATERIALIZED');
+            expect(result.content).toContain('DATASOURCE sales_by_hour');
+            expect(result.content).toContain('DEPLOYMENT_METHOD alter');
+        });
+        it('generates DATASOURCE correctly with datasource field', () => {
+            const pipe = definePipe('sales_by_hour_mv_2', {
+                nodes: [
+                    node({
+                        name: 'daily_sales',
+                        sql: 'SELECT toStartOfDay(date) as day, country, sum(sales) as total_sales FROM teams GROUP BY day, country',
+                    }),
+                ],
+                output: {
+                    day: t.date(),
+                    country: t.string().lowCardinality(),
+                    total_sales: t.simpleAggregateFunction('sum', t.uint64()),
+                },
+                materialized: {
+                    datasource: salesByHour,
+                },
+            });
+            const result = generatePipe(pipe);
+            expect(result.content).toContain('TYPE MATERIALIZED');
+            expect(result.content).toContain('DATASOURCE sales_by_hour');
+        });
+    });
+});
+//# sourceMappingURL=pipe.test.js.map