@tinybirdco/sdk 0.0.68 → 0.0.70

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

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
+import { buildFromInclude } from "../../generator/index.js";
 import { runMigrate } from "./migrate.js";
 
 function writeFile(dir: string, relativePath: string, content: string): void {
@@ -1284,6 +1285,35 @@ TYPE endpoint
     expect(output).not.toContain(", engine,");
   });
 
+  it("migrates datasource with Null engine", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "null_source.datasource",
+      `SCHEMA >
+  id String,
+  timestamp DateTime
+
+ENGINE Null
+`
+    );
+
+    const result = await runMigrate({
+      cwd: tempDir,
+      patterns: ["."],
+      strict: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.errors).toHaveLength(0);
+
+    const output = fs.readFileSync(result.outputPath, "utf-8");
+    expect(output).toContain('export const nullSource = defineDatasource("null_source", {');
+    expect(output).toContain("engine: engine.null(),");
+  });
+
   it("infers MergeTree when engine options exist without ENGINE directive", async () => {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
     tempDirs.push(tempDir);
@@ -1510,6 +1540,51 @@ TYPE endpoint
     expect(output).toContain("{{ Int32(days) }}");
   });
 
+  it("escapes pipe SQL backslashes in migrated TypeScript template literals", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "escape_percent.pipe",
+      String.raw`NODE endpoint
+SQL >
+  %
+  SELECT replaceAll({{ String(value) }}, '\\%', '%') AS value
+TYPE endpoint
+`
+    );
+
+    const result = await runMigrate({
+      cwd: tempDir,
+      patterns: ["."],
+      strict: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.errors).toHaveLength(0);
+
+    const output = fs.readFileSync(result.outputPath, "utf-8");
+    expect(output).toContain(
+      String.raw`SELECT replaceAll({{ String(value) }}, '\\\\%', '%') AS value`
+    );
+
+    fs.writeFileSync(
+      result.outputPath,
+      output.replace("@tinybirdco/sdk", path.resolve(process.cwd(), "src/index.ts"))
+    );
+
+    const build = await buildFromInclude({
+      cwd: tempDir,
+      includePaths: [result.outputPath],
+    });
+
+    expect(build.resources.pipes).toHaveLength(1);
+    expect(build.resources.pipes[0]?.content).toContain(
+      String.raw`SELECT replaceAll({{ String(value) }}, '\\%', '%') AS value`
+    );
+  });
+
   it("migrates datasource with mixed explicit and default json paths", async () => {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
     tempDirs.push(tempDir);

package/src/codegen/utils.test.ts

@@ -187,6 +187,13 @@ describe("generateEngineCode", () => {
     expect(code).toContain('version: "version"');
   });
 
+  it("generates Null engine", () => {
+    const code = generateEngineCode({
+      type: "Null",
+    });
+    expect(code).toBe("engine.null()");
+  });
+
   it("defaults to mergeTree for unknown engine types", () => {
     const code = generateEngineCode({
       type: "UnknownEngine",

package/src/codegen/utils.ts

@@ -81,6 +81,10 @@ export function generateEngineCode(engine: {
   version?: string;
   summing_columns?: string;
 }): string {
+  if (engine.type === "Null") {
+    return "engine.null()";
+  }
+
   const sortingKey = parseSortingKey(engine.sorting_key);
 
   // Build options object
@@ -143,6 +147,7 @@ export function generateEngineCode(engine: {
     AggregatingMergeTree: "engine.aggregatingMergeTree",
     CollapsingMergeTree: "engine.collapsingMergeTree",
     VersionedCollapsingMergeTree: "engine.versionedCollapsingMergeTree",
+    Null: "engine.null",
   };
 
   const engineFunc = engineFunctionMap[engine.type] ?? "engine.mergeTree";

package/src/generator/datasource.test.ts

@@ -51,6 +51,19 @@ describe('Datasource Generator', () => {
       expect(result.content).toContain('ENGINE_SORTING_KEY "id"');
     });
 
+    it('includes Null engine configuration without sorting key', () => {
+      const ds = defineDatasource('test_ds', {
+        schema: {
+          id: t.string(),
+        },
+        engine: engine.null(),
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain('ENGINE Null');
+      expect(result.content).not.toContain('ENGINE_SORTING_KEY');
+    });
+
     it('includes partition key in engine config', () => {
       const ds = defineDatasource('test_ds', {
         schema: {

package/src/generator/pipe.test.ts

@@ -306,6 +306,27 @@ WHERE workspaceId = {{ String(workspaceId) }}
       );
     });
 
+    it('does not emit unsupported keyword args for column params', () => {
+      const pipe = definePipe('visitor_filters', {
+        params: {
+          orderBy: p.column().optional('lastSeen').describe('Column used for sorting'),
+        },
+        nodes: [
+          node({
+            name: 'endpoint',
+            sql: 'SELECT * FROM visitors ORDER BY {{ column(orderBy) }}',
+          }),
+        ],
+        output: simpleOutput,
+        endpoint: true,
+      });
+
+      const result = generatePipe(pipe);
+      expect(result.content).toContain("{{ column(orderBy, 'lastSeen') }}");
+      expect(result.content).not.toContain('column(orderBy, \'lastSeen\', required=False)');
+      expect(result.content).not.toContain('description="Column used for sorting"');
+    });
+
     it('emits param metadata for defineEndpoint helper', () => {
       const pipe = defineEndpoint('test_endpoint', {
         params: {

package/src/generator/pipe.ts

@@ -22,6 +22,7 @@ import type { AnyParamValidator } from "../schema/params.js";
 import {
   getParamDefault,
   getParamDescription,
+  getParamTinybirdType,
   getParamRequiredModifier,
   isParamRequired,
 } from "../schema/params.js";
@@ -134,6 +135,10 @@ function buildParamTemplateArgs(
     nextArgs.push(toTemplateDefaultLiteral(defaultValue as string | number | boolean));
   }
 
+  if (getParamTinybirdType(validator) === "column") {
+    return nextArgs;
+  }
+
   const requiredModifier = getParamRequiredModifier(validator);
   if (requiredModifier && !hasKeywordArg(nextArgs, "required")) {
     nextArgs.push(`required=${isParamRequired(validator) ? "True" : "False"}`);

package/src/index.ts

@@ -88,6 +88,7 @@ export {
 export { engine, getEngineClause, getSortingKey, getPrimaryKey } from "./schema/engines.js";
 export type {
   EngineConfig,
+  MergeTreeEngineConfig,
   BaseMergeTreeConfig,
   MergeTreeConfig,
   ReplacingMergeTreeConfig,
@@ -95,6 +96,7 @@ export type {
   AggregatingMergeTreeConfig,
   CollapsingMergeTreeConfig,
   VersionedCollapsingMergeTreeConfig,
+  NullEngineConfig,
 } from "./schema/engines.js";
 
 // ============ Utilities ============

package/src/migrate/emit-ts.ts

@@ -15,6 +15,10 @@ function escapeString(value: string): string {
   return JSON.stringify(value);
 }
 
+function escapeTemplateLiteral(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${");
+}
+
 function emitObjectKey(key: string): string {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : escapeString(key);
 }
@@ -196,6 +200,7 @@ function engineFunctionName(type: string): string {
     AggregatingMergeTree: "aggregatingMergeTree",
     CollapsingMergeTree: "collapsingMergeTree",
     VersionedCollapsingMergeTree: "versionedCollapsingMergeTree",
+    Null: "null",
   };
   const functionName = map[type];
   if (!functionName) {
@@ -205,6 +210,10 @@ function engineFunctionName(type: string): string {
 }
 
 function emitEngineOptions(engine: DatasourceEngineModel): string {
+  if (engine.type === "Null") {
+    return "engine.null()";
+  }
+
   const options: string[] = [];
 
   if (engine.sortingKey.length === 1) {
@@ -378,7 +387,7 @@ function emitDatasource(ds: DatasourceModel): string {
 
   if (ds.forwardQuery) {
     lines.push("  forwardQuery: `");
-    lines.push(ds.forwardQuery.replace(/`/g, "\\`").replace(/\${/g, "\\${"));
+    lines.push(escapeTemplateLiteral(ds.forwardQuery));
     lines.push("  `,");
   }
 
@@ -561,7 +570,7 @@ function emitPipe(pipe: PipeModel): string {
       lines.push(`      description: ${escapeString(node.description)},`);
     }
     lines.push("      sql: `");
-    lines.push(node.sql.replace(/`/g, "\\`").replace(/\${/g, "\\${"));
+    lines.push(escapeTemplateLiteral(node.sql));
     lines.push("      `,");
     lines.push("    }),");
   }

package/src/migrate/parse-datasource.ts

@@ -540,7 +540,7 @@ export function parseDatasourceFile(resource: ResourceFile): DatasourceModel {
     engineType = "MergeTree";
   }
 
-  if (engineType && sortingKey.length === 0) {
+  if (engineType && engineType !== "Null" && sortingKey.length === 0) {
     throw new MigrationParseError(
       resource.filePath,
       "datasource",

package/src/schema/engines.test.ts

@@ -100,6 +100,13 @@ describe('Engine Configurations', () => {
     });
   });
 
+  describe('Null', () => {
+    it('creates Null config', () => {
+      const config = engine.null();
+      expect(config.type).toBe('Null');
+    });
+  });
+
   describe('getEngineClause', () => {
     it('generates basic MergeTree clause', () => {
       const config = engine.mergeTree({ sortingKey: ['id'] });
@@ -187,6 +194,12 @@ describe('Engine Configurations', () => {
       expect(clause).toContain('ENGINE_SIGN "sign_col"');
       expect(clause).toContain('ENGINE_VERSION "version_col"');
     });
+
+    it('generates Null engine without MergeTree directives', () => {
+      const clause = getEngineClause(engine.null());
+      expect(clause).toBe('ENGINE Null');
+      expect(clause).not.toContain('ENGINE_SORTING_KEY');
+    });
   });
 
   describe('Helper functions', () => {

package/src/schema/engines.ts

@@ -79,10 +79,18 @@ export interface VersionedCollapsingMergeTreeConfig extends BaseMergeTreeConfig
   version: string;
 }
 
+/**
+ * Null engine configuration
+ * Discards inserted rows and returns an empty response when read
+ */
+export interface NullEngineConfig {
+  type: "Null";
+}
+
 /**
  * Union type of all engine configurations
  */
-export type EngineConfig =
+export type MergeTreeEngineConfig =
   | MergeTreeConfig
   | ReplacingMergeTreeConfig
   | SummingMergeTreeConfig
@@ -90,6 +98,8 @@ export type EngineConfig =
   | CollapsingMergeTreeConfig
   | VersionedCollapsingMergeTreeConfig;
 
+export type EngineConfig = MergeTreeEngineConfig | NullEngineConfig;
+
 /**
  * Helper to normalize sorting key to array format
  */
@@ -121,6 +131,9 @@ function normalizeSortingKey(key: string | readonly string[]): readonly string[]
  *   sortingKey: ['date', 'metric_name'],
  *   columns: ['value'],
  * });
+ *
+ * // Null engine for materialized view source tables
+ * engine.null();
  * ```
  */
 export const engine = {
@@ -196,19 +209,27 @@ export const engine = {
     type: "VersionedCollapsingMergeTree",
     ...config,
   }),
+
+  /**
+   * Null - Discards inserted rows and returns no rows when read
+   * Best for: Materialized view source tables that transform and discard raw input
+   */
+  null: (): NullEngineConfig => ({
+    type: "Null",
+  }),
 } as const;
 
 /**
  * Get the sorting key as an array
  */
-export function getSortingKey(config: EngineConfig): readonly string[] {
+export function getSortingKey(config: MergeTreeEngineConfig): readonly string[] {
   return normalizeSortingKey(config.sortingKey);
 }
 
 /**
  * Get the primary key as an array (defaults to sorting key)
  */
-export function getPrimaryKey(config: EngineConfig): readonly string[] {
+export function getPrimaryKey(config: MergeTreeEngineConfig): readonly string[] {
   if (config.primaryKey) {
     return normalizeSortingKey(config.primaryKey);
   }
@@ -219,6 +240,10 @@ export function getPrimaryKey(config: EngineConfig): readonly string[] {
  * Generate the engine clause for a datasource file
  */
 export function getEngineClause(config: EngineConfig): string {
+  if (config.type === "Null") {
+    return "ENGINE Null";
+  }
+
   const parts: string[] = [`ENGINE "${config.type}"`];
 
   if (config.partitionKey) {