@tinybirdco/sdk 0.0.44 → 0.0.45

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

@@ -15,11 +15,11 @@ const EXPECTED_COMPLEX_OUTPUT = `/**
  * Review endpoint output schemas and any defaults before production use.
  */
 
-import { createKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, column, p } from "@tinybirdco/sdk";
+import { defineKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, column, p } from "@tinybirdco/sdk";
 
 // Connections
 
-export const stream = createKafkaConnection("stream", {
+export const stream = defineKafkaConnection("stream", {
   bootstrapServers: "localhost:9092",
   securityProtocol: "SASL_SSL",
   saslMechanism: "PLAIN",
@@ -183,11 +183,11 @@ const EXPECTED_PARTIAL_OUTPUT = `/**
  * Review endpoint output schemas and any defaults before production use.
  */
 
-import { createKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, p } from "@tinybirdco/sdk";
+import { defineKafkaConnection, defineDatasource, definePipe, defineMaterializedView, defineCopyPipe, node, t, engine, p } from "@tinybirdco/sdk";
 
 // Connections
 
-export const stream = createKafkaConnection("stream", {
+export const stream = defineKafkaConnection("stream", {
   bootstrapServers: "localhost:9092",
 });
 
@@ -561,4 +561,58 @@ TOKEN endpoint_token READ
     expect(result.outputContent).toBe(EXPECTED_PARTIAL_OUTPUT);
     expect(fs.existsSync(result.outputPath)).toBe(false);
   });
+
+  it("migrates s3 connection and import datasource directives", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tinybird-migrate-"));
+    tempDirs.push(tempDir);
+
+    writeFile(
+      tempDir,
+      "s3sample.connection",
+      `TYPE s3
+S3_REGION "us-east-1"
+S3_ARN "arn:aws:iam::123456789012:role/tinybird-s3-access"
+`
+    );
+
+    writeFile(
+      tempDir,
+      "events_landing.datasource",
+      `SCHEMA >
+    timestamp DateTime,
+    session_id String
+
+ENGINE "MergeTree"
+ENGINE_SORTING_KEY "timestamp"
+IMPORT_CONNECTION_NAME s3sample
+IMPORT_BUCKET_URI s3://my-bucket/events/*.csv
+IMPORT_SCHEDULE @auto
+IMPORT_FROM_TIMESTAMP 2024-01-01T00:00:00Z
+`
+    );
+
+    const result = await runMigrate({
+      cwd: tempDir,
+      patterns: ["."],
+      strict: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.migrated.filter((resource) => resource.kind === "connection")).toHaveLength(1);
+    expect(result.migrated.filter((resource) => resource.kind === "datasource")).toHaveLength(1);
+
+    const output = fs.readFileSync(result.outputPath, "utf-8");
+    expect(output).toContain("defineS3Connection");
+    expect(output).toContain('export const s3sample = defineS3Connection("s3sample", {');
+    expect(output).toContain('region: "us-east-1"');
+    expect(output).toContain(
+      'arn: "arn:aws:iam::123456789012:role/tinybird-s3-access"'
+    );
+    expect(output).toContain("s3: {");
+    expect(output).toContain("connection: s3sample");
+    expect(output).toContain('bucketUri: "s3://my-bucket/events/*.csv"');
+    expect(output).toContain('schedule: "@auto"');
+    expect(output).toContain('fromTimestamp: "2024-01-01T00:00:00Z"');
+  });
 });

package/src/cli/commands/migrate.ts

@@ -129,15 +129,18 @@ export async function runMigrate(
   }
 
   for (const datasource of parsedDatasources) {
+    const referencedConnectionName =
+      datasource.kafka?.connectionName ?? datasource.s3?.connectionName;
+
     if (
-      datasource.kafka &&
-      !migratedConnectionNames.has(datasource.kafka.connectionName)
+      referencedConnectionName &&
+      !migratedConnectionNames.has(referencedConnectionName)
     ) {
       errors.push({
         filePath: datasource.filePath,
         resourceName: datasource.name,
         resourceKind: datasource.kind,
-        message: `Datasource references missing/unmigrated connection "${datasource.kafka.connectionName}".`,
+        message: `Datasource references missing/unmigrated connection "${referencedConnectionName}".`,
       });
       continue;
     }
@@ -237,4 +240,3 @@ export async function runMigrate(
     outputContent,
   };
 }
-

package/src/generator/connection.test.ts

@@ -1,11 +1,11 @@
 import { describe, it, expect } from "vitest";
 import { generateConnection, generateAllConnections } from "./connection.js";
-import { createKafkaConnection } from "../schema/connection.js";
+import { defineKafkaConnection, defineS3Connection } from "../schema/connection.js";
 
 describe("Connection Generator", () => {
   describe("generateConnection", () => {
     it("generates basic Kafka connection with required fields", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
       });
 
@@ -17,7 +17,7 @@ describe("Connection Generator", () => {
     });
 
     it("includes security protocol when provided", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
         securityProtocol: "SASL_SSL",
       });
@@ -28,7 +28,7 @@ describe("Connection Generator", () => {
     });
 
     it("includes SASL mechanism when provided", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
         saslMechanism: "PLAIN",
       });
@@ -39,7 +39,7 @@ describe("Connection Generator", () => {
     });
 
     it("includes key and secret when provided", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
         key: '{{ tb_secret("KAFKA_KEY") }}',
         secret: '{{ tb_secret("KAFKA_SECRET") }}',
@@ -52,7 +52,7 @@ describe("Connection Generator", () => {
     });
 
     it("includes SSL CA PEM when provided", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
         sslCaPem: '{{ tb_secret("KAFKA_CA_CERT") }}',
       });
@@ -63,7 +63,7 @@ describe("Connection Generator", () => {
     });
 
     it("generates full Kafka connection with all options", () => {
-      const conn = createKafkaConnection("my_kafka", {
+      const conn = defineKafkaConnection("my_kafka", {
         bootstrapServers: "kafka.example.com:9092",
         securityProtocol: "SASL_SSL",
         saslMechanism: "SCRAM-SHA-256",
@@ -85,7 +85,7 @@ describe("Connection Generator", () => {
     });
 
     it("supports PLAINTEXT security protocol", () => {
-      const conn = createKafkaConnection("local_kafka", {
+      const conn = defineKafkaConnection("local_kafka", {
         bootstrapServers: "localhost:9092",
         securityProtocol: "PLAINTEXT",
       });
@@ -99,7 +99,7 @@ describe("Connection Generator", () => {
       const mechanisms = ["PLAIN", "SCRAM-SHA-256", "SCRAM-SHA-512", "OAUTHBEARER"] as const;
 
       mechanisms.forEach((mechanism) => {
-        const conn = createKafkaConnection("my_kafka", {
+        const conn = defineKafkaConnection("my_kafka", {
           bootstrapServers: "kafka.example.com:9092",
           saslMechanism: mechanism,
         });
@@ -109,21 +109,52 @@ describe("Connection Generator", () => {
         expect(result.content).toContain(`KAFKA_SASL_MECHANISM ${mechanism}`);
       });
     });
+
+    it("generates basic S3 connection with IAM role auth", () => {
+      const conn = defineS3Connection("my_s3", {
+        region: "us-east-1",
+        arn: "arn:aws:iam::123456789012:role/tinybird-s3-access",
+      });
+
+      const result = generateConnection(conn);
+
+      expect(result.name).toBe("my_s3");
+      expect(result.content).toContain("TYPE s3");
+      expect(result.content).toContain("S3_REGION us-east-1");
+      expect(result.content).toContain(
+        "S3_ARN arn:aws:iam::123456789012:role/tinybird-s3-access"
+      );
+    });
+
+    it("generates S3 connection with access key auth", () => {
+      const conn = defineS3Connection("my_s3", {
+        region: "us-east-1",
+        accessKey: '{{ tb_secret("S3_ACCESS_KEY") }}',
+        secret: '{{ tb_secret("S3_SECRET") }}',
+      });
+
+      const result = generateConnection(conn);
+
+      expect(result.content).toContain("TYPE s3");
+      expect(result.content).toContain('S3_ACCESS_KEY {{ tb_secret("S3_ACCESS_KEY") }}');
+      expect(result.content).toContain('S3_SECRET {{ tb_secret("S3_SECRET") }}');
+    });
   });
 
   describe("generateAllConnections", () => {
     it("generates all connections", () => {
-      const conn1 = createKafkaConnection("kafka1", {
+      const conn1 = defineKafkaConnection("kafka1", {
         bootstrapServers: "kafka1.example.com:9092",
       });
-      const conn2 = createKafkaConnection("kafka2", {
-        bootstrapServers: "kafka2.example.com:9092",
+      const conn2 = defineS3Connection("s3_logs", {
+        region: "us-east-1",
+        arn: "arn:aws:iam::123456789012:role/tinybird-s3-access",
       });
 
-      const results = generateAllConnections({ kafka1: conn1, kafka2: conn2 });
+      const results = generateAllConnections({ kafka1: conn1, s3_logs: conn2 });
 
       expect(results).toHaveLength(2);
-      expect(results.map((r) => r.name).sort()).toEqual(["kafka1", "kafka2"]);
+      expect(results.map((r) => r.name).sort()).toEqual(["kafka1", "s3_logs"]);
     });
 
     it("returns empty array for empty connections", () => {

package/src/generator/connection.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ConnectionDefinition, KafkaConnectionDefinition } from "../schema/connection.js";
+import { isS3ConnectionDefinition, type S3ConnectionDefinition } from "../schema/connection.js";
 
 /**
  * Generated connection content
@@ -48,6 +49,31 @@ function generateKafkaConnection(connection: KafkaConnectionDefinition): string
   return parts.join("\n");
 }
 
+/**
+ * Generate an S3 connection content
+ */
+function generateS3Connection(connection: S3ConnectionDefinition): string {
+  const parts: string[] = [];
+  const options = connection.options;
+
+  parts.push("TYPE s3");
+  parts.push(`S3_REGION ${options.region}`);
+
+  if (options.arn) {
+    parts.push(`S3_ARN ${options.arn}`);
+  }
+
+  if (options.accessKey) {
+    parts.push(`S3_ACCESS_KEY ${options.accessKey}`);
+  }
+
+  if (options.secret) {
+    parts.push(`S3_SECRET ${options.secret}`);
+  }
+
+  return parts.join("\n");
+}
+
 /**
  * Generate a .connection file content from a ConnectionDefinition
  *
@@ -56,7 +82,7 @@ function generateKafkaConnection(connection: KafkaConnectionDefinition): string
  *
  * @example
  * ```ts
- * const myKafka = createKafkaConnection('my_kafka', {
+ * const myKafka = defineKafkaConnection('my_kafka', {
  *   bootstrapServers: 'kafka.example.com:9092',
  *   securityProtocol: 'SASL_SSL',
  *   saslMechanism: 'PLAIN',
@@ -81,8 +107,10 @@ export function generateConnection(
 
   if (connection._connectionType === "kafka") {
     content = generateKafkaConnection(connection as KafkaConnectionDefinition);
+  } else if (isS3ConnectionDefinition(connection)) {
+    content = generateS3Connection(connection);
   } else {
-    throw new Error(`Unsupported connection type: ${connection._connectionType}`);
+    throw new Error("Unsupported connection type.");
   }
 
   return {

package/src/generator/datasource.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { generateDatasource, generateAllDatasources } from './datasource.js';
 import { defineDatasource } from '../schema/datasource.js';
-import { createKafkaConnection } from '../schema/connection.js';
+import { defineKafkaConnection, defineS3Connection } from '../schema/connection.js';
 import { defineToken } from '../schema/token.js';
 import { t } from '../schema/types.js';
 import { engine } from '../schema/engines.js';
@@ -312,7 +312,7 @@ describe('Datasource Generator', () => {
 
   describe('Kafka configuration', () => {
     it('includes Kafka connection name and topic', () => {
-      const kafkaConn = createKafkaConnection('my_kafka', {
+      const kafkaConn = defineKafkaConnection('my_kafka', {
         bootstrapServers: 'kafka.example.com:9092',
       });
 
@@ -335,7 +335,7 @@ describe('Datasource Generator', () => {
     });
 
     it('includes Kafka group ID when provided', () => {
-      const kafkaConn = createKafkaConnection('my_kafka', {
+      const kafkaConn = defineKafkaConnection('my_kafka', {
         bootstrapServers: 'kafka.example.com:9092',
       });
 
@@ -358,7 +358,7 @@ describe('Datasource Generator', () => {
     });
 
     it('includes auto offset reset when provided', () => {
-      const kafkaConn = createKafkaConnection('my_kafka', {
+      const kafkaConn = defineKafkaConnection('my_kafka', {
         bootstrapServers: 'kafka.example.com:9092',
       });
 
@@ -381,7 +381,7 @@ describe('Datasource Generator', () => {
     });
 
     it('generates complete Kafka datasource with all options', () => {
-      const kafkaConn = createKafkaConnection('my_kafka', {
+      const kafkaConn = defineKafkaConnection('my_kafka', {
         bootstrapServers: 'kafka.example.com:9092',
         securityProtocol: 'SASL_SSL',
         saslMechanism: 'PLAIN',
@@ -417,6 +417,58 @@ describe('Datasource Generator', () => {
     });
   });
 
+  describe('S3 configuration', () => {
+    it('includes S3 connection name and bucket uri', () => {
+      const s3Conn = defineS3Connection('my_s3', {
+        region: 'us-east-1',
+        arn: 'arn:aws:iam::123456789012:role/tinybird-s3-access',
+      });
+
+      const ds = defineDatasource('s3_events', {
+        schema: {
+          timestamp: t.dateTime(),
+          event: t.string(),
+        },
+        engine: engine.mergeTree({ sortingKey: ['timestamp'] }),
+        s3: {
+          connection: s3Conn,
+          bucketUri: 's3://my-bucket/events/*.csv',
+        },
+      });
+
+      const result = generateDatasource(ds);
+
+      expect(result.content).toContain('IMPORT_CONNECTION_NAME my_s3');
+      expect(result.content).toContain('IMPORT_BUCKET_URI s3://my-bucket/events/*.csv');
+    });
+
+    it('includes optional S3 schedule and from timestamp', () => {
+      const s3Conn = defineS3Connection('my_s3', {
+        region: 'us-east-1',
+        arn: 'arn:aws:iam::123456789012:role/tinybird-s3-access',
+      });
+
+      const ds = defineDatasource('s3_events', {
+        schema: {
+          timestamp: t.dateTime(),
+          event: t.string(),
+        },
+        engine: engine.mergeTree({ sortingKey: ['timestamp'] }),
+        s3: {
+          connection: s3Conn,
+          bucketUri: 's3://my-bucket/events/*.csv',
+          schedule: '@auto',
+          fromTimestamp: '2024-01-01T00:00:00Z',
+        },
+      });
+
+      const result = generateDatasource(ds);
+
+      expect(result.content).toContain('IMPORT_SCHEDULE @auto');
+      expect(result.content).toContain('IMPORT_FROM_TIMESTAMP 2024-01-01T00:00:00Z');
+    });
+  });
+
   describe('Token generation', () => {
     it('generates TOKEN lines with inline config', () => {
       const ds = defineDatasource('test_ds', {

package/src/generator/datasource.ts

@@ -3,7 +3,14 @@
  * Converts DatasourceDefinition to native .datasource file format
  */
 
-import type { DatasourceDefinition, SchemaDefinition, ColumnDefinition, KafkaConfig, TokenConfig } from "../schema/datasource.js";
+import type {
+  DatasourceDefinition,
+  SchemaDefinition,
+  ColumnDefinition,
+  KafkaConfig,
+  S3Config,
+  TokenConfig,
+} from "../schema/datasource.js";
 import type { AnyTypeValidator, TypeModifiers } from "../schema/types.js";
 import { getColumnType, getColumnJsonPath } from "../schema/datasource.js";
 import { getEngineClause, type EngineConfig } from "../schema/engines.js";
@@ -163,6 +170,26 @@ function generateKafkaConfig(kafka: KafkaConfig): string {
   return parts.join("\n");
 }
 
+/**
+ * Generate S3 import configuration lines
+ */
+function generateS3Config(s3: S3Config): string {
+  const parts: string[] = [];
+
+  parts.push(`IMPORT_CONNECTION_NAME ${s3.connection._name}`);
+  parts.push(`IMPORT_BUCKET_URI ${s3.bucketUri}`);
+
+  if (s3.schedule) {
+    parts.push(`IMPORT_SCHEDULE ${s3.schedule}`);
+  }
+
+  if (s3.fromTimestamp) {
+    parts.push(`IMPORT_FROM_TIMESTAMP ${s3.fromTimestamp}`);
+  }
+
+  return parts.join("\n");
+}
+
 /**
  * Generate forward query section
  */
@@ -261,6 +288,10 @@ export function generateDatasource(
 ): GeneratedDatasource {
   const parts: string[] = [];
 
+  if (datasource.options.kafka && datasource.options.s3) {
+    throw new Error("Datasource cannot define both `kafka` and `s3` ingestion options.");
+  }
+
   // Add description if present
   if (datasource.options.description) {
     parts.push(`DESCRIPTION >\n    ${datasource.options.description}`);
@@ -283,6 +314,12 @@ export function generateDatasource(
     parts.push(generateKafkaConfig(datasource.options.kafka));
   }
 
+  // Add S3 configuration if present
+  if (datasource.options.s3) {
+    parts.push("");
+    parts.push(generateS3Config(datasource.options.s3));
+  }
+
   // Add forward query if present
   const forwardQuery = generateForwardQuery(datasource.options.forwardQuery);
   if (forwardQuery) {

package/src/index.ts

@@ -109,16 +109,27 @@ export type {
   DatasourceTokenReference,
   ExtractSchema,
   KafkaConfig,
+  S3Config,
 } from "./schema/datasource.js";
 
 // ============ Connection ============
-export { createKafkaConnection, isConnectionDefinition, isKafkaConnectionDefinition, getConnectionType } from "./schema/connection.js";
+export {
+  defineKafkaConnection,
+  createKafkaConnection,
+  defineS3Connection,
+  isConnectionDefinition,
+  isKafkaConnectionDefinition,
+  isS3ConnectionDefinition,
+  getConnectionType,
+} from "./schema/connection.js";
 export type {
   ConnectionDefinition,
   KafkaConnectionDefinition,
   KafkaConnectionOptions,
   KafkaSecurityProtocol,
   KafkaSaslMechanism,
+  S3ConnectionDefinition,
+  S3ConnectionOptions,
 } from "./schema/connection.js";
 
 // ============ Token ============

package/src/migrate/emit-ts.ts

@@ -6,6 +6,7 @@ import type {
   KafkaConnectionModel,
   ParsedResource,
   PipeModel,
+  S3ConnectionModel,
 } from "./types.js";
 
 function escapeString(value: string): string {
@@ -243,6 +244,20 @@ function emitDatasource(ds: DatasourceModel): string {
     lines.push("  },");
   }
 
+  if (ds.s3) {
+    const connectionVar = toCamelCase(ds.s3.connectionName);
+    lines.push("  s3: {");
+    lines.push(`    connection: ${connectionVar},`);
+    lines.push(`    bucketUri: ${escapeString(ds.s3.bucketUri)},`);
+    if (ds.s3.schedule) {
+      lines.push(`    schedule: ${escapeString(ds.s3.schedule)},`);
+    }
+    if (ds.s3.fromTimestamp) {
+      lines.push(`    fromTimestamp: ${escapeString(ds.s3.fromTimestamp)},`);
+    }
+    lines.push("  },");
+  }
+
   if (ds.forwardQuery) {
     lines.push("  forwardQuery: `");
     lines.push(ds.forwardQuery.replace(/`/g, "\\`").replace(/\${/g, "\\${"));
@@ -270,28 +285,48 @@ function emitDatasource(ds: DatasourceModel): string {
   return lines.join("\n");
 }
 
-function emitConnection(connection: KafkaConnectionModel): string {
+function emitConnection(connection: KafkaConnectionModel | S3ConnectionModel): string {
   const variableName = toCamelCase(connection.name);
   const lines: string[] = [];
+
+  if (connection.connectionType === "kafka") {
+    lines.push(
+      `export const ${variableName} = defineKafkaConnection(${escapeString(connection.name)}, {`
+    );
+    lines.push(`  bootstrapServers: ${escapeString(connection.bootstrapServers)},`);
+    if (connection.securityProtocol) {
+      lines.push(`  securityProtocol: ${escapeString(connection.securityProtocol)},`);
+    }
+    if (connection.saslMechanism) {
+      lines.push(`  saslMechanism: ${escapeString(connection.saslMechanism)},`);
+    }
+    if (connection.key) {
+      lines.push(`  key: ${escapeString(connection.key)},`);
+    }
+    if (connection.secret) {
+      lines.push(`  secret: ${escapeString(connection.secret)},`);
+    }
+    if (connection.sslCaPem) {
+      lines.push(`  sslCaPem: ${escapeString(connection.sslCaPem)},`);
+    }
+    lines.push("});");
+    lines.push("");
+    return lines.join("\n");
+  }
+
   lines.push(
-    `export const ${variableName} = createKafkaConnection(${escapeString(connection.name)}, {`
+    `export const ${variableName} = defineS3Connection(${escapeString(connection.name)}, {`
   );
-  lines.push(`  bootstrapServers: ${escapeString(connection.bootstrapServers)},`);
-  if (connection.securityProtocol) {
-    lines.push(`  securityProtocol: ${escapeString(connection.securityProtocol)},`);
-  }
-  if (connection.saslMechanism) {
-    lines.push(`  saslMechanism: ${escapeString(connection.saslMechanism)},`);
+  lines.push(`  region: ${escapeString(connection.region)},`);
+  if (connection.arn) {
+    lines.push(`  arn: ${escapeString(connection.arn)},`);
   }
-  if (connection.key) {
-    lines.push(`  key: ${escapeString(connection.key)},`);
+  if (connection.accessKey) {
+    lines.push(`  accessKey: ${escapeString(connection.accessKey)},`);
   }
   if (connection.secret) {
     lines.push(`  secret: ${escapeString(connection.secret)},`);
   }
-  if (connection.sslCaPem) {
-    lines.push(`  sslCaPem: ${escapeString(connection.sslCaPem)},`);
-  }
   lines.push("});");
   lines.push("");
   return lines.join("\n");
@@ -398,7 +433,8 @@ function emitPipe(pipe: PipeModel): string {
 
 export function emitMigrationFileContent(resources: ParsedResource[]): string {
   const connections = resources.filter(
-    (resource): resource is KafkaConnectionModel => resource.kind === "connection"
+    (resource): resource is KafkaConnectionModel | S3ConnectionModel =>
+      resource.kind === "connection"
   );
   const datasources = resources.filter(
     (resource): resource is DatasourceModel => resource.kind === "datasource"
@@ -412,7 +448,21 @@ export function emitMigrationFileContent(resources: ParsedResource[]): string {
   );
   const needsParams = pipes.some((pipe) => pipe.params.length > 0);
 
-  const imports = new Set<string>(["createKafkaConnection", "defineDatasource", "definePipe", "defineMaterializedView", "defineCopyPipe", "node", "t", "engine"]);
+  const imports = new Set<string>([
+    "defineDatasource",
+    "definePipe",
+    "defineMaterializedView",
+    "defineCopyPipe",
+    "node",
+    "t",
+    "engine",
+  ]);
+  if (connections.some((connection) => connection.connectionType === "kafka")) {
+    imports.add("defineKafkaConnection");
+  }
+  if (connections.some((connection) => connection.connectionType === "s3")) {
+    imports.add("defineS3Connection");
+  }
   if (needsColumn) {
     imports.add("column");
   }
@@ -420,13 +470,27 @@ export function emitMigrationFileContent(resources: ParsedResource[]): string {
     imports.add("p");
   }
 
+  const orderedImports = [
+    "defineKafkaConnection",
+    "defineS3Connection",
+    "defineDatasource",
+    "definePipe",
+    "defineMaterializedView",
+    "defineCopyPipe",
+    "node",
+    "t",
+    "engine",
+    "column",
+    "p",
+  ].filter((name) => imports.has(name));
+
   const lines: string[] = [];
   lines.push("/**");
   lines.push(" * Generated by tinybird migrate.");
   lines.push(" * Review endpoint output schemas and any defaults before production use.");
   lines.push(" */");
   lines.push("");
-  lines.push(`import { ${Array.from(imports).join(", ")} } from "@tinybirdco/sdk";`);
+  lines.push(`import { ${orderedImports.join(", ")} } from "@tinybirdco/sdk";`);
   lines.push("");
 
   if (connections.length > 0) {