@tinybirdco/sdk 0.0.46 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinybirdco/sdk",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "TypeScript SDK for Tinybird Forward - define datasources and pipes as TypeScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,7 +42,8 @@
   "files": [
     "dist",
     "bin",
-    "src"
+    "src",
+    "extension/*.vsix"
   ],
   "keywords": [
     "tinybird",

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, findExistingDatafiles } from "./init.js";
+import { runInit, findExistingDatafiles, findSyntaxHighlightingVsix } from "./init.js";
 
 // Mock the auth module to avoid browser login
 vi.mock("../auth.js", () => ({
@@ -17,11 +17,23 @@ vi.mock("../region-selector.js", () => ({
   }),
 }));
 
+import { browserLogin } from "../auth.js";
+import { selectRegion } from "../region-selector.js";
+
+const mockedBrowserLogin = vi.mocked(browserLogin);
+const mockedSelectRegion = vi.mocked(selectRegion);
+
 describe("Init Command", () => {
   let tempDir: string;
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-init-test-"));
+    vi.clearAllMocks();
+    mockedSelectRegion.mockResolvedValue({
+      success: true,
+      apiHost: "https://api.tinybird.co",
+    });
+    mockedBrowserLogin.mockResolvedValue({ success: false });
   });
 
   afterEach(() => {
@@ -532,4 +544,80 @@ describe("Init Command", () => {
       expect(result.installedTools).toBeUndefined();
     });
   });
+
+  describe("syntax highlighting VSIX lookup", () => {
+    it("finds the packaged VSIX when cwd is outside a git repo", () => {
+      const originalCwd = process.cwd();
+      const externalCwd = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-init-cwd-"));
+
+      try {
+        process.chdir(externalCwd);
+        const vsixPath = findSyntaxHighlightingVsix(externalCwd);
+
+        expect(vsixPath).toBeDefined();
+        expect(path.basename(vsixPath ?? "")).toMatch(
+          /^tinybird-ts-sdk-extension.*\.vsix$/
+        );
+      } finally {
+        process.chdir(originalCwd);
+        fs.rmSync(externalCwd, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("login flow", () => {
+    it("saves TINYBIRD_URL during init login", async () => {
+      mockedBrowserLogin.mockResolvedValue({
+        success: true,
+        token: "new-token-123",
+        baseUrl: "https://api.us-east.tinybird.co",
+        workspaceName: "test-workspace",
+      });
+
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: false,
+        devMode: "branch",
+        clientPath: "lib/tinybird.ts",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.loggedIn).toBe(true);
+
+      const envContent = fs.readFileSync(
+        path.join(tempDir, ".env.local"),
+        "utf-8"
+      );
+      expect(envContent).toContain("TINYBIRD_TOKEN=new-token-123");
+      expect(envContent).toContain("TINYBIRD_URL=https://api.us-east.tinybird.co");
+    });
+
+    it("uses selected region as TINYBIRD_URL when auth response has no baseUrl", async () => {
+      mockedSelectRegion.mockResolvedValue({
+        success: true,
+        apiHost: "https://api.eu-west.tinybird.co",
+      });
+      mockedBrowserLogin.mockResolvedValue({
+        success: true,
+        token: "new-token-456",
+        workspaceName: "test-workspace",
+      });
+
+      const result = await runInit({
+        cwd: tempDir,
+        skipLogin: false,
+        devMode: "branch",
+        clientPath: "lib/tinybird.ts",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.loggedIn).toBe(true);
+
+      const envContent = fs.readFileSync(
+        path.join(tempDir, ".env.local"),
+        "utf-8"
+      );
+      expect(envContent).toContain("TINYBIRD_URL=https://api.eu-west.tinybird.co");
+    });
+  });
 });

package/src/cli/commands/init.ts

@@ -6,6 +6,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
+import { fileURLToPath } from "url";
 import {
   hasValidToken,
   getRelativeTinybirdDir,
@@ -16,7 +17,7 @@ import {
   type DevMode,
 } from "../config.js";
 import { browserLogin } from "../auth.js";
-import { saveTinybirdToken } from "../env.js";
+import { saveTinybirdBaseUrl, saveTinybirdToken } from "../env.js";
 import { selectRegion } from "../region-selector.js";
 import { getGitRoot } from "../git.js";
 import { fetchAllResources } from "../../api/resources.js";
@@ -999,6 +1000,7 @@ export async function runInit(options: InitOptions = {}): Promise<InitResult> {
 
         // Update config with selected region's baseUrl
         const baseUrl = authResult.baseUrl ?? regionResult.apiHost;
+        saveTinybirdBaseUrl(cwd, baseUrl);
         const currentConfigPath = findExistingConfigPath(cwd);
         if (currentConfigPath && currentConfigPath.endsWith(".json")) {
           updateConfig(currentConfigPath, { baseUrl });
@@ -1133,6 +1135,10 @@ const SKILLS_INSTALL_ARGS = [
 ];
 const SYNTAX_EXTENSION_DIR = path.join("extension");
 const SYNTAX_EXTENSION_PREFIX = "tinybird-ts-sdk-extension";
+const SDK_MODULE_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../../.."
+);
 
 async function installSelectedTools(
   cwd: string,
@@ -1294,8 +1300,10 @@ function isCommandAvailable(command: string): boolean {
   }
 }
 
-function findSyntaxHighlightingVsix(cwd: string): string | undefined {
+export function findSyntaxHighlightingVsix(cwd: string): string | undefined {
   const searchRoots = new Set<string>();
+  searchRoots.add(SDK_MODULE_ROOT);
+
   const gitRoot = getGitRoot();
   if (gitRoot) {
     searchRoots.add(gitRoot);

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

@@ -161,7 +161,7 @@ describe("Login Command", () => {
       );
     });
 
-    it("creates .env.local with token", async () => {
+    it("creates .env.local with token and base URL", async () => {
       mockedBrowserLogin.mockResolvedValue({
         success: true,
         token: "new-token-123",
@@ -178,19 +178,20 @@ describe("Login Command", () => {
         "utf-8"
       );
       expect(envContent).toContain("TINYBIRD_TOKEN=new-token-123");
+      expect(envContent).toContain("TINYBIRD_URL=https://api.tinybird.co");
     });
 
     it("updates existing token in .env.local", async () => {
       // Create existing .env.local with old token
       fs.writeFileSync(
         path.join(tempDir, ".env.local"),
-        "TINYBIRD_TOKEN=old-token\nOTHER_VAR=value\n"
+        "TINYBIRD_TOKEN=old-token\nTINYBIRD_URL=https://old.tinybird.co\nOTHER_VAR=value\n"
       );
 
       mockedBrowserLogin.mockResolvedValue({
         success: true,
         token: "new-token-456",
-        baseUrl: "https://api.tinybird.co",
+        baseUrl: "https://api.us-east.tinybird.co",
         workspaceName: "test-workspace",
       });
 
@@ -203,8 +204,10 @@ describe("Login Command", () => {
         "utf-8"
       );
       expect(envContent).toContain("TINYBIRD_TOKEN=new-token-456");
+      expect(envContent).toContain("TINYBIRD_URL=https://api.us-east.tinybird.co");
       expect(envContent).toContain("OTHER_VAR=value");
       expect(envContent).not.toContain("old-token");
+      expect(envContent).not.toContain("https://old.tinybird.co");
     });
 
     it("appends token to existing .env.local without TINYBIRD_TOKEN", async () => {
@@ -231,6 +234,7 @@ describe("Login Command", () => {
       );
       expect(envContent).toContain("OTHER_VAR=value");
       expect(envContent).toContain("TINYBIRD_TOKEN=new-token-789");
+      expect(envContent).toContain("TINYBIRD_URL=https://api.tinybird.co");
     });
 
     it("saves .env.local in same directory as tinybird.json (monorepo)", async () => {
@@ -312,6 +316,12 @@ describe("Login Command", () => {
       );
       // Original baseUrl preserved
       expect(config.baseUrl).toBe("https://api.tinybird.co");
+
+      const envContent = fs.readFileSync(
+        path.join(tempDir, ".env.local"),
+        "utf-8"
+      );
+      expect(envContent).toContain("TINYBIRD_URL=https://api.tinybird.co");
     });
   });
 

package/src/cli/commands/login.ts

@@ -5,7 +5,7 @@
 import * as path from "path";
 import { browserLogin, type LoginOptions, type AuthResult } from "../auth.js";
 import { updateConfig, findConfigFile } from "../config.js";
-import { saveTinybirdToken } from "../env.js";
+import { saveTinybirdBaseUrl, saveTinybirdToken } from "../env.js";
 import { getApiHostWithRegionSelection } from "../region-selector.js";
 
 /**
@@ -87,6 +87,8 @@ export async function runLogin(options: RunLoginOptions = {}): Promise<LoginResu
   // Save token to .env.local (in same directory as config file)
   try {
     saveTinybirdToken(configDir, authResult.token);
+    const baseUrl = authResult.baseUrl ?? apiHost;
+    saveTinybirdBaseUrl(configDir, baseUrl);
 
     // Update baseUrl in config file if it changed (only for JSON configs)
     if (authResult.baseUrl && configPath.endsWith(".json")) {

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

@@ -15,7 +15,7 @@ const EXPECTED_COMPLEX_OUTPUT = `/**
  * Review endpoint output schemas and any defaults before production use.
  */
 
-import { defineKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, column, p } from "@tinybirdco/sdk";
+import { defineKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, p } from "@tinybirdco/sdk";
 
 // Connections
 
@@ -36,12 +36,12 @@ export const stream = defineKafkaConnection("stream", {
 export const events = defineDatasource("events", {
   description: "Events from Kafka stream",
   schema: {
-    event_id: column(t.string(), { jsonPath: "$.event_id" }),
-    user_id: column(t.uint64(), { jsonPath: "$.user.id" }),
-    env: column(t.string().default("prod"), { jsonPath: "$.env" }),
-    is_test: column(t.bool().default(false), { jsonPath: "$.meta.is_test" }),
-    updated_at: column(t.dateTime(), { jsonPath: "$.updated_at" }),
-    payload: column(t.string().default("{}").codec("ZSTD(1)"), { jsonPath: "$.payload" }),
+    event_id: t.string().jsonPath("$.event_id"),
+    user_id: t.uint64().jsonPath("$.user.id"),
+    env: t.string().default("prod").jsonPath("$.env"),
+    is_test: t.bool().default(false).jsonPath("$.meta.is_test"),
+    updated_at: t.dateTime().jsonPath("$.updated_at"),
+    payload: t.string().default("{}").codec("ZSTD(1)").jsonPath("$.payload"),
   },
   engine: engine.replacingMergeTree({ sortingKey: ["event_id", "user_id"], partitionKey: "toYYYYMM(updated_at)", primaryKey: "event_id", ttl: "updated_at + toIntervalDay(30)", ver: "updated_at", settings: { "index_granularity": 8192, "enable_mixed_granularity_parts": true } }),
   kafka: {
@@ -615,4 +615,276 @@ IMPORT_FROM_TIMESTAMP 2024-01-01T00:00:00Z
     expect(output).toContain('schedule: "@auto"');
     expect(output).toContain('fromTimestamp: "2024-01-01T00:00:00Z"');
   });
+
+  it("migrates KAFKA_STORE_RAW_VALUE datasource directive", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "stream.connection",
+      `TYPE kafka
+KAFKA_BOOTSTRAP_SERVERS localhost:9092
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events.datasource",
+      `SCHEMA >
+    event_id String
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "event_id"
+KAFKA_CONNECTION_NAME stream
+KAFKA_TOPIC events_topic
+KAFKA_STORE_RAW_VALUE True
+`
+    );
+
+    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("kafka: {");
+    expect(output).toContain("connection: stream");
+    expect(output).toContain('topic: "events_topic"');
+    expect(output).toContain("storeRawValue: true");
+  });
+
+  it("migrates kafka schema registry and engine is deleted directives", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "stream.connection",
+      `TYPE kafka
+KAFKA_BOOTSTRAP_SERVERS kafka.example.com:9092
+KAFKA_SCHEMA_REGISTRY_URL https://registry-user:registry-pass@registry.example.com
+# Optional registry auth details
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events.datasource",
+      `SCHEMA >
+    event_id String
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "event_id"
+KAFKA_CONNECTION_NAME stream
+KAFKA_TOPIC events_topic
+KAFKA_STORE_RAW_VALUE True
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events_state.datasource",
+      `SCHEMA >
+    # logical delete marker
+    _is_deleted UInt8,
+    event_id String,
+    version_ts DateTime
+
+ENGINE "ReplacingMergeTree"
+ENGINE_SORTING_KEY "event_id"
+ENGINE_VER "version_ts"
+ENGINE_IS_DELETED "_is_deleted"
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events_state_mv.pipe",
+      `NODE latest
+SQL >
+    SELECT
+      toUInt8(0) AS _is_deleted,
+      event_id,
+      now() AS version_ts
+    FROM events
+# materialized definition
+TYPE MATERIALIZED
+DATASOURCE events_state
+`
+    );
+
+    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(
+      'schemaRegistryUrl: "https://registry-user:registry-pass@registry.example.com"'
+    );
+    expect(output).toContain("storeRawValue: true");
+    expect(output).toContain(
+      'engine: engine.replacingMergeTree({ sortingKey: "event_id", ver: "version_ts", isDeleted: "_is_deleted" })'
+    );
+  });
+
+  it("migrates datasource with mixed explicit and default json paths", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "mixed_paths.datasource",
+      `SCHEMA >
+    event_id String \`json:$.payload.id\`,
+    event_type String
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "event_id"
+`
+    );
+
+    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('event_id: t.string().jsonPath("$.payload.id")');
+    expect(output).toContain("event_type: t.string()");
+    expect(output).not.toContain("jsonPaths: false");
+  });
+
+  it("normalizes backticked schema column names to valid object keys", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "backticked.datasource",
+      `SCHEMA >
+    \`_is_deleted\` UInt8 \`json:$._is_deleted\`,
+    \`id\` UUID \`json:$.id\`
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "id"
+`
+    );
+
+    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('_is_deleted: t.uint8().jsonPath("$._is_deleted")');
+    expect(output).toContain('id: t.uuid().jsonPath("$.id")');
+    expect(output).not.toContain("`_is_deleted`:");
+    expect(output).not.toContain("`id`:");
+  });
+
+  it("emits secret helper for tb_secret template values", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "stream.connection",
+      `TYPE kafka
+KAFKA_BOOTSTRAP_SERVERS localhost:9092
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events.datasource",
+      `SCHEMA >
+    id UUID
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "id"
+KAFKA_CONNECTION_NAME stream
+KAFKA_TOPIC events_topic
+KAFKA_GROUP_ID {{ tb_secret("KAFKA_GROUP_ID_LOCAL_ds_accounts", "accounts_1737295200") }}
+`
+    );
+
+    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('import {');
+    expect(output).toContain('secret } from "@tinybirdco/sdk";');
+    expect(output).not.toContain("const secret = (name: string, defaultValue?: string) =>");
+    expect(output).toContain(
+      'groupId: secret("KAFKA_GROUP_ID_LOCAL_ds_accounts", "accounts_1737295200"),'
+    );
+    expect(output).not.toContain(
+      'groupId: "{{ tb_secret(\\"KAFKA_GROUP_ID_LOCAL_ds_accounts\\", \\"accounts_1737295200\\") }}",'
+    );
+  });
+
+  it("does not emit secret helper when no tb_secret template values are present", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "stream.connection",
+      `TYPE kafka
+KAFKA_BOOTSTRAP_SERVERS localhost:9092
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events.datasource",
+      `SCHEMA >
+    id UUID
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "id"
+KAFKA_CONNECTION_NAME stream
+KAFKA_TOPIC events_topic
+KAFKA_GROUP_ID events-group
+`
+    );
+
+    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).not.toContain(", secret,");
+    expect(output).not.toContain("const secret = (name: string, defaultValue?: string) =>");
+    expect(output).toContain('groupId: "events-group",');
+  });
 });

package/src/generator/connection.test.ts

@@ -51,6 +51,19 @@ describe("Connection Generator", () => {
       expect(result.content).toContain('KAFKA_SECRET {{ tb_secret("KAFKA_SECRET") }}');
     });
 
+    it("includes schema registry URL when provided", () => {
+      const conn = defineKafkaConnection("my_kafka", {
+        bootstrapServers: "kafka.example.com:9092",
+        schemaRegistryUrl: "https://registry-user:registry-pass@registry.example.com",
+      });
+
+      const result = generateConnection(conn);
+
+      expect(result.content).toContain(
+        "KAFKA_SCHEMA_REGISTRY_URL https://registry-user:registry-pass@registry.example.com"
+      );
+    });
+
     it("includes SSL CA PEM when provided", () => {
       const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",

package/src/generator/connection.ts

@@ -42,6 +42,10 @@ function generateKafkaConnection(connection: KafkaConnectionDefinition): string
     parts.push(`KAFKA_SECRET ${options.secret}`);
   }
 
+  if (options.schemaRegistryUrl) {
+    parts.push(`KAFKA_SCHEMA_REGISTRY_URL ${options.schemaRegistryUrl}`);
+  }
+
   if (options.sslCaPem) {
     parts.push(`KAFKA_SSL_CA_PEM ${options.sslCaPem}`);
   }

package/src/generator/datasource.test.ts

@@ -263,6 +263,43 @@ describe('Datasource Generator', () => {
       expect(schemaLines[1]).toContain(',');
       expect(schemaLines[2]).not.toContain(',');
     });
+
+    it('autogenerates jsonPath when jsonPaths is enabled and no explicit path is set', () => {
+      const ds = defineDatasource('test_ds', {
+        schema: {
+          event_id: t.string().nullable(),
+        },
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain('event_id Nullable(String) `json:$.event_id`');
+    });
+
+    it('uses explicit jsonPath from validator modifier when jsonPaths is enabled', () => {
+      const ds = defineDatasource('test_ds', {
+        schema: {
+          event_id: t.string().nullable().jsonPath('$.explicit_path'),
+        },
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain('event_id Nullable(String) `json:$.explicit_path`');
+      expect(result.content).not.toContain('`json:$.event_id`');
+    });
+
+    it('omits json paths when jsonPaths is false even if column has explicit jsonPath modifier', () => {
+      const ds = defineDatasource('test_ds', {
+        jsonPaths: false,
+        schema: {
+          event_id: t.string().nullable().jsonPath('$.explicit_path'),
+        },
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain('event_id Nullable(String)');
+      expect(result.content).not.toContain('`json:$.explicit_path`');
+      expect(result.content).not.toContain('`json:$.event_id`');
+    });
   });
 
   describe('generateAllDatasources', () => {
@@ -380,6 +417,29 @@ describe('Datasource Generator', () => {
       expect(result.content).toContain('KAFKA_AUTO_OFFSET_RESET earliest');
     });
 
+    it('includes store raw value when provided', () => {
+      const kafkaConn = defineKafkaConnection('my_kafka', {
+        bootstrapServers: 'kafka.example.com:9092',
+      });
+
+      const ds = defineDatasource('kafka_events', {
+        schema: {
+          timestamp: t.dateTime(),
+          event: t.string(),
+        },
+        engine: engine.mergeTree({ sortingKey: ['timestamp'] }),
+        kafka: {
+          connection: kafkaConn,
+          topic: 'events',
+          storeRawValue: true,
+        },
+      });
+
+      const result = generateDatasource(ds);
+
+      expect(result.content).toContain('KAFKA_STORE_RAW_VALUE True');
+    });
+
     it('generates complete Kafka datasource with all options', () => {
       const kafkaConn = defineKafkaConnection('my_kafka', {
         bootstrapServers: 'kafka.example.com:9092',

package/src/generator/datasource.ts

@@ -166,6 +166,9 @@ function generateKafkaConfig(kafka: KafkaConfig): string {
   if (kafka.autoOffsetReset) {
     parts.push(`KAFKA_AUTO_OFFSET_RESET ${kafka.autoOffsetReset}`);
   }
+  if (kafka.storeRawValue !== undefined) {
+    parts.push(`KAFKA_STORE_RAW_VALUE ${kafka.storeRawValue ? "True" : "False"}`);
+  }
 
   return parts.join("\n");
 }

package/src/index.test.ts

@@ -10,4 +10,8 @@ describe("root public exports", () => {
     expect(typeof sdk.defineProject).toBe("function");
     expect(typeof sdk.Tinybird).toBe("function");
   });
+
+  it("exports secret utility", () => {
+    expect(typeof sdk.secret).toBe("function");
+  });
 });