@tinybirdco/sdk 0.0.77 → 0.0.79

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

@@ -1,7 +1,45 @@
-import { describe, it, expect } from "vitest";
-import { generatePreviewBranchName } from "./preview.js";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { generatePreviewBranchName, runPreview } from "./preview.js";
+
+vi.mock("../config.js", () => ({
+  loadConfigAsync: vi.fn(),
+  LOCAL_BASE_URL: "http://localhost:7181",
+}));
+
+vi.mock("../../generator/index.js", () => ({
+  buildFromInclude: vi.fn(),
+}));
+
+vi.mock("../../api/branches.js", () => ({
+  createBranch: vi.fn(),
+  deleteBranch: vi.fn(),
+  getBranch: vi.fn(),
+}));
+
+vi.mock("../../api/deploy.js", () => ({
+  deployToMain: vi.fn(),
+}));
+
+vi.mock("../../api/build.js", () => ({
+  buildToTinybird: vi.fn(),
+}));
+
+vi.mock("../../api/local.js", () => ({
+  getLocalTokens: vi.fn(),
+  getOrCreateLocalWorkspace: vi.fn(),
+  LocalNotRunningError: class LocalNotRunningError extends Error {},
+}));
+
+vi.mock("../git.js", () => ({
+  sanitizeBranchName: (value: string) => value.replace(/[^a-zA-Z0-9]/g, "_"),
+  getCurrentGitBranch: vi.fn(() => "feature/test"),
+}));
 
 describe("Preview command", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   describe("generatePreviewBranchName", () => {
     it("generates name with tmp_ci prefix", () => {
       const result = generatePreviewBranchName("feature-branch");
@@ -34,4 +72,97 @@ describe("Preview command", () => {
       expect(result1).toBe(result2);
     });
   });
+
+  describe("branch_data_mode wiring", () => {
+    it("uses config-only last_partition when creating cloud preview branch", async () => {
+      const { loadConfigAsync } = await import("../config.js");
+      const { buildFromInclude } = await import("../../generator/index.js");
+      const { getBranch, createBranch } = await import("../../api/branches.js");
+      const { deployToMain } = await import("../../api/deploy.js");
+
+      vi.mocked(loadConfigAsync).mockResolvedValue({
+        include: ["test.ts"],
+        token: "p.test-token",
+        baseUrl: "https://api.tinybird.co",
+        configPath: "/test/tinybird.config.json",
+        devMode: "branch",
+        cwd: "/test",
+        gitBranch: "feature-test",
+        tinybirdBranch: "feature_test",
+        isMainBranch: false,
+        branchDataMode: "last_partition",
+      });
+      vi.mocked(buildFromInclude).mockResolvedValue({
+        resources: { datasources: [], pipes: [], connections: [] },
+        entities: { datasources: {}, pipes: {}, connections: {}, rawDatasources: [], rawPipes: [], sourceFiles: [] },
+        stats: { datasourceCount: 0, pipeCount: 0, connectionCount: 0 },
+      });
+      vi.mocked(getBranch).mockRejectedValue(new Error("not found"));
+      vi.mocked(createBranch).mockResolvedValue({
+        id: "b1",
+        name: "tmp_ci_feature_test",
+        token: "p.branch",
+        created_at: "2024-01-01T00:00:00Z",
+      });
+      vi.mocked(deployToMain).mockResolvedValue({
+        success: true,
+        result: "success",
+        datasourceCount: 0,
+        pipeCount: 0,
+        connectionCount: 0,
+      });
+
+      await runPreview();
+      expect(createBranch).toHaveBeenCalledWith(
+        expect.any(Object),
+        "tmp_ci_feature_test",
+        { branch_data_mode: "last_partition" }
+      );
+    });
+
+    it("ignores config branch_data_mode in local mode", async () => {
+      const { loadConfigAsync } = await import("../config.js");
+      const { buildFromInclude } = await import("../../generator/index.js");
+      const { createBranch } = await import("../../api/branches.js");
+      const { getLocalTokens, getOrCreateLocalWorkspace } = await import("../../api/local.js");
+      const { buildToTinybird } = await import("../../api/build.js");
+
+      vi.mocked(loadConfigAsync).mockResolvedValue({
+        include: ["test.ts"],
+        token: "p.test-token",
+        baseUrl: "https://api.tinybird.co",
+        configPath: "/test/tinybird.config.json",
+        devMode: "local",
+        cwd: "/test",
+        gitBranch: "feature-test",
+        tinybirdBranch: "feature_test",
+        isMainBranch: false,
+        branchDataMode: "last_partition",
+      });
+      vi.mocked(buildFromInclude).mockResolvedValue({
+        resources: { datasources: [], pipes: [], connections: [] },
+        entities: { datasources: {}, pipes: {}, connections: {}, rawDatasources: [], rawPipes: [], sourceFiles: [] },
+        stats: { datasourceCount: 0, pipeCount: 0, connectionCount: 0 },
+      });
+      vi.mocked(getLocalTokens).mockResolvedValue({
+        admin_token: "admin-token",
+        user_token: "user-token",
+        workspace_admin_token: "workspace-admin-token",
+      });
+      vi.mocked(getOrCreateLocalWorkspace).mockResolvedValue({
+        workspace: { id: "lw1", name: "tmp_ci_feature_test", token: "local-token" },
+        wasCreated: true,
+      });
+      vi.mocked(buildToTinybird).mockResolvedValue({
+        success: true,
+        result: "success",
+        datasourceCount: 0,
+        pipeCount: 0,
+        connectionCount: 0,
+      });
+
+      await runPreview();
+      expect(createBranch).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/cli/commands/preview.ts

@@ -4,7 +4,7 @@
 
 import { loadConfigAsync, LOCAL_BASE_URL, type ResolvedConfig, type DevMode } from "../config.js";
 import { buildFromInclude, type BuildFromIncludeResult } from "../../generator/index.js";
-import { createBranch, deleteBranch, getBranch, type TinybirdBranch } from "../../api/branches.js";
+import { createBranch, deleteBranch, getBranch, type CreateBranchOptions, type TinybirdBranch } from "../../api/branches.js";
 import { deployToMain } from "../../api/deploy.js";
 import { buildToTinybird } from "../../api/build.js";
 import {
@@ -226,6 +226,10 @@ export async function runPreview(options: PreviewCommandOptions = {}): Promise<P
   let branch: TinybirdBranch;
   try {
     const apiConfig = { baseUrl: config.baseUrl, token: config.token };
+    const branchOptions: CreateBranchOptions | undefined =
+      config.branchDataMode === "last_partition"
+        ? { branch_data_mode: "last_partition" }
+        : undefined;
 
     // Check if branch already exists and delete it for a fresh start
     try {
@@ -250,7 +254,7 @@ export async function runPreview(options: PreviewCommandOptions = {}): Promise<P
       console.log(`[debug] Creating preview branch: ${previewBranchName}`);
     }
 
-    branch = await createBranch(apiConfig, previewBranchName);
+    branch = await createBranch(apiConfig, previewBranchName, branchOptions);
 
     if (debug) {
       console.log(`[debug] Branch created: ${branch.name} (${branch.id})`);

package/src/cli/config-types.ts

@@ -11,6 +11,8 @@
  * - "local": Use local Tinybird container at localhost:7181
  */
 export type DevMode = "branch" | "local";
+export type BranchDataMode = "last_partition";
+export const BRANCH_DATA_MODE_VALUES = ["last_partition"] as const satisfies readonly BranchDataMode[];
 
 /**
  * Tinybird configuration file structure
@@ -26,4 +28,6 @@ export interface TinybirdConfig {
   baseUrl?: string;
   /** Development mode: "branch" (default) or "local" */
   devMode?: DevMode;
+  /** Branch data mode applied on cloud branch creation (shared snake_case key) */
+  branch_data_mode?: BranchDataMode;
 }

package/src/cli/config.test.ts

@@ -327,6 +327,129 @@ describe("Config", () => {
 
       expect(result.devMode).toBe("local");
     });
+
+    it("resolves branch_data_mode as last_partition", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_mode: "last_partition",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+      expect(result.branchDataMode).toBe("last_partition");
+    });
+
+    it("defaults branch_data_mode to last_partition when missing", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+      expect(result.branchDataMode).toBe("last_partition");
+    });
+
+    it("defaults empty branch_data_mode to last_partition", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_mode: "   ",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      const result = loadConfig(tempDir);
+      expect(result.branchDataMode).toBe("last_partition");
+    });
+
+    it("throws when branch_data_mode is all_partitions", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_mode: "all_partitions",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow("Invalid branch_data_mode");
+    });
+
+    it("throws when branch_data_mode is invalid", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_mode: "invalid",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow("Invalid branch_data_mode");
+    });
+
+    it("warns when branch_data_mode is set with devMode local", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        devMode: "local",
+        branch_data_mode: "last_partition",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      loadConfig(tempDir);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("branch_data_mode is set")
+      );
+    });
+
+    it("does not warn when branch_data_mode is implicit in local mode", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        devMode: "local",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      loadConfig(tempDir);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it("throws when legacy branch_data_on_create key is used", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_on_create: "last_partition",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow("renamed to `branch_data_mode`");
+    });
   });
 
   describe("loadConfigAsync", () => {

package/src/cli/config.ts

@@ -7,9 +7,17 @@ import * as path from "path";
 import { config as loadDotenv } from "dotenv";
 import { getCurrentGitBranch, isMainBranch, getTinybirdBranchName } from "./git.js";
 
-// Re-export types from config-types.ts (separate file to avoid bundling esbuild)
-export type { DevMode, TinybirdConfig } from "./config-types.js";
-import type { DevMode, TinybirdConfig } from "./config-types.js";
+// Re-export config types/constants from config-types.ts (separate file to avoid bundling esbuild)
+export {
+  BRANCH_DATA_MODE_VALUES,
+  type BranchDataMode,
+  type DevMode,
+  type TinybirdConfig,
+} from "./config-types.js";
+import { BRANCH_DATA_MODE_VALUES } from "./config-types.js";
+import type { BranchDataMode, DevMode, TinybirdConfig } from "./config-types.js";
+
+const DEFAULT_BRANCH_DATA_MODE: BranchDataMode = "last_partition";
 
 /**
  * Resolved configuration with all values expanded
@@ -33,6 +41,8 @@ export interface ResolvedConfig {
   isMainBranch: boolean;
   /** Development mode: "branch" or "local" */
   devMode: DevMode;
+  /** Branch data mode configured in tinybird.config.json */
+  branchDataMode?: BranchDataMode | null;
 }
 
 /**
@@ -196,6 +206,24 @@ export function findConfigFile(startDir: string): ConfigFileResult | null {
 // Import the universal config loader
 import { loadConfigFile } from "./config-loader.js";
 
+function resolveBranchDataMode(raw: Record<string, unknown>): { mode: BranchDataMode | null; explicit: boolean } {
+  if (raw["branch_data_on_create"] !== undefined) {
+    throw new Error("`branch_data_on_create` has been renamed to `branch_data_mode`.");
+  }
+
+  const value = raw["branch_data_mode"];
+  if (value === undefined || value === null) return { mode: DEFAULT_BRANCH_DATA_MODE, explicit: false };
+  if (typeof value !== "string") throw new Error("branch_data_mode must be a string.");
+  const mode = value.trim().toLowerCase();
+  if (!mode) return { mode: DEFAULT_BRANCH_DATA_MODE, explicit: false };
+  if (!BRANCH_DATA_MODE_VALUES.includes(mode as BranchDataMode)) {
+    throw new Error(
+      `Invalid branch_data_mode '${value}'. Allowed values are: ${BRANCH_DATA_MODE_VALUES.join(", ")}.`
+    );
+  }
+  return { mode: mode as BranchDataMode, explicit: true };
+}
+
 /**
  * Resolve a TinybirdConfig to a ResolvedConfig
  */
@@ -255,6 +283,15 @@ function resolveConfig(config: TinybirdConfig, configPath: string): ResolvedConf
 
   // Resolve devMode (default to "branch")
   const devMode: DevMode = config.devMode ?? "branch";
+  const { mode: branchDataMode, explicit: branchDataModeExplicit } = resolveBranchDataMode(
+    config as unknown as Record<string, unknown>
+  );
+  if (branchDataModeExplicit && branchDataMode && devMode === "local") {
+    console.warn(
+      "branch_data_mode is set in tinybird.config.json but dev_mode='local'. " +
+      "Branch data settings only apply to cloud branches."
+    );
+  }
 
   return {
     include,
@@ -266,6 +303,7 @@ function resolveConfig(config: TinybirdConfig, configPath: string): ResolvedConf
     tinybirdBranch,
     isMainBranch: isMainBranch(),
     devMode,
+    branchDataMode,
   };
 }
 

package/src/cli/index.ts

@@ -270,7 +270,10 @@ function createCli(): Command {
     .option("--debug", "Show debug output including API requests/responses")
     .option("--local", "Use local Tinybird container")
     .option("--branch", "Use Tinybird cloud with branches")
-    .option("--last-partition", "Copy the last partition of production data when creating a branch")
+    .option(
+      "--last-partition",
+      '[DEPRECATED] Use `branch_data_mode: "last_partition"` in tinybird.config.json. Copy the last partition of production data when creating a cloud branch.'
+    )
     .action(async (options) => {
       if (options.debug) {
         process.env.TINYBIRD_DEBUG = "1";
@@ -679,7 +682,10 @@ function createCli(): Command {
     .description("Watch for changes and sync with Tinybird")
     .option("--local", "Use local Tinybird container")
     .option("--branch", "Use Tinybird cloud with branches")
-    .option("--last-partition", "Copy the last partition of production data when creating a branch")
+    .option(
+      "--last-partition",
+      '[DEPRECATED] Use `branch_data_mode: "last_partition"` in tinybird.config.json. Copy the last partition of production data when creating a cloud branch.'
+    )
     .action(async (options) => {
       // Determine devMode override
       let devModeOverride: DevMode | undefined;

package/src/client/base.test.ts

@@ -167,6 +167,7 @@ describe("TinybirdClient", () => {
         tinybirdBranch: "feature_add_fetch",
         isMainBranch: false,
         devMode: "branch",
+        branchDataMode: null,
       });
       mockedGetOrCreateBranch.mockResolvedValue({
         id: "branch-123",
@@ -192,7 +193,8 @@ describe("TinybirdClient", () => {
           token: "workspace-token",
           fetch: customFetch,
         },
-        "feature_add_fetch"
+        "feature_add_fetch",
+        undefined
       );
       expect(context.token).toBe("branch-token");
       expect(context.isBranchToken).toBe(true);

package/src/client/base.ts

@@ -19,6 +19,7 @@ import type {
 } from "./types.js";
 import { TinybirdError } from "./types.js";
 import { TinybirdApi, TinybirdApiError } from "../api/api.js";
+import type { CreateBranchOptions } from "../api/branches.js";
 import { TokensNamespace } from "./tokens.js";
 
 /**
@@ -340,6 +341,10 @@ export class TinybirdClient {
       }
 
       const branchName = config.tinybirdBranch;
+      const branchOptions: CreateBranchOptions | undefined =
+        config.devMode !== "local" && config.branchDataMode === "last_partition"
+          ? { branch_data_mode: "last_partition" }
+          : undefined;
 
       // Get or create branch (always fetch fresh to avoid stale cache issues)
       const branch = await getOrCreateBranch(
@@ -348,7 +353,8 @@ export class TinybirdClient {
           token: this.config.token,
           fetch: this.config.fetch,
         },
-        branchName
+        branchName,
+        branchOptions
       );
 
       if (!branch.token) {

package/src/generator/connection.test.ts

@@ -4,6 +4,7 @@ import {
   defineKafkaConnection,
   defineS3Connection,
   defineGCSConnection,
+  defineDynamoDBConnection,
 } from "../schema/connection.js";
 
 describe("Connection Generator", () => {
@@ -218,6 +219,22 @@ describe("Connection Generator", () => {
         'GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON {{ tb_secret("GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON") }}'
       );
     });
+
+    it("generates DynamoDB connection with arn and region", () => {
+      const conn = defineDynamoDBConnection("my_dynamo", {
+        region: "us-east-1",
+        arn: '{{ tb_secret("DYNAMODB_ROLE_ARN") }}',
+      });
+
+      const result = generateConnection(conn);
+
+      expect(result.name).toBe("my_dynamo");
+      expect(result.content).toBe(
+        ['TYPE dynamodb', 'DYNAMODB_ARN {{ tb_secret("DYNAMODB_ROLE_ARN") }}', "DYNAMODB_REGION us-east-1"].join(
+          "\n"
+        )
+      );
+    });
   });
 
   describe("generateAllConnections", () => {

package/src/generator/connection.ts

@@ -7,10 +7,12 @@ import type {
   ConnectionDefinition,
   KafkaConnectionDefinition,
   GCSConnectionDefinition,
+  DynamoDBConnectionDefinition,
 } from "../schema/connection.js";
 import {
   isS3ConnectionDefinition,
   isGCSConnectionDefinition,
+  isDynamoDBConnectionDefinition,
   type S3ConnectionDefinition,
 } from "../schema/connection.js";
 
@@ -123,6 +125,20 @@ function generateGCSConnection(connection: GCSConnectionDefinition): string {
   return parts.join("\n");
 }
 
+/**
+ * Generate a DynamoDB connection content
+ */
+function generateDynamoDBConnection(connection: DynamoDBConnectionDefinition): string {
+  const parts: string[] = [];
+  const options = connection.options;
+
+  parts.push("TYPE dynamodb");
+  parts.push(`DYNAMODB_ARN ${options.arn}`);
+  parts.push(`DYNAMODB_REGION ${options.region}`);
+
+  return parts.join("\n");
+}
+
 /**
  * Generate a .connection file content from a ConnectionDefinition
  *
@@ -160,6 +176,8 @@ export function generateConnection(
     content = generateS3Connection(connection);
   } else if (isGCSConnectionDefinition(connection)) {
     content = generateGCSConnection(connection);
+  } else if (isDynamoDBConnectionDefinition(connection)) {
+    content = generateDynamoDBConnection(connection);
   } else {
     throw new Error("Unsupported connection type.");
   }

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 { defineKafkaConnection, defineS3Connection, defineGCSConnection } from '../schema/connection.js';
+import { defineKafkaConnection, defineS3Connection, defineGCSConnection, defineDynamoDBConnection } from '../schema/connection.js';
 import { defineToken } from '../schema/token.js';
 import { t } from '../schema/types.js';
 import { engine } from '../schema/engines.js';
@@ -629,6 +629,59 @@ describe('Datasource Generator', () => {
     });
   });
 
+  describe('DynamoDB configuration', () => {
+    it('includes DynamoDB import directives', () => {
+      const dynamoConn = defineDynamoDBConnection('my_dynamo', {
+        region: 'us-east-1',
+        arn: '{{ tb_secret("DYNAMODB_ROLE_ARN") }}',
+      });
+
+      const ds = defineDatasource('dynamo_events', {
+        schema: {
+          id: t.string(),
+          _record: t.string(),
+        },
+        engine: engine.replacingMergeTree({ sortingKey: ['id'] }),
+        dynamodb: {
+          connection: dynamoConn,
+          tableArn: 'arn:aws:dynamodb:us-east-1:123456789012:table/events',
+          exportBucket: 's3://my-export-bucket',
+        },
+      });
+
+      const result = generateDatasource(ds);
+
+      expect(result.content).toContain('IMPORT_CONNECTION_NAME my_dynamo');
+      expect(result.content).toContain(
+        'IMPORT_TABLE_ARN arn:aws:dynamodb:us-east-1:123456789012:table/events'
+      );
+      expect(result.content).toContain('IMPORT_EXPORT_BUCKET s3://my-export-bucket');
+    });
+
+    it('rejects mixing DynamoDB with other ingestion options', () => {
+      const dynamoConn = defineDynamoDBConnection('my_dynamo', {
+        region: 'us-east-1',
+        arn: '{{ tb_secret("DYNAMODB_ROLE_ARN") }}',
+      });
+      const s3Conn = defineS3Connection('my_s3', {
+        region: 'us-east-1',
+        arn: 'arn:aws:iam::123456789012:role/x',
+      });
+
+      expect(() =>
+        defineDatasource('mixed', {
+          schema: { id: t.string() },
+          dynamodb: {
+            connection: dynamoConn,
+            tableArn: 'arn:aws:dynamodb:us-east-1:123456789012:table/events',
+            exportBucket: 's3://my-export-bucket',
+          },
+          s3: { connection: s3Conn, bucketUri: 's3://b/*.csv' },
+        })
+      ).toThrow('only define one ingestion option');
+    });
+  });
+
   describe('Token generation', () => {
     it('generates TOKEN lines with inline config', () => {
       const ds = defineDatasource('test_ds', {

package/src/generator/datasource.ts

@@ -10,6 +10,7 @@ import type {
   KafkaConfig,
   S3Config,
   GCSConfig,
+  DynamoDBConfig,
   TokenConfig,
   DatasourceIndex,
 } from "../schema/datasource.js";
@@ -199,6 +200,19 @@ function generateImportConfig(importConfig: S3Config | GCSConfig): string {
   return parts.join("\n");
 }
 
+/**
+ * Generate DynamoDB import configuration lines
+ */
+function generateDynamoDBConfig(dynamodb: DynamoDBConfig): string {
+  const parts: string[] = [];
+
+  parts.push(`IMPORT_CONNECTION_NAME ${dynamodb.connection._name}`);
+  parts.push(`IMPORT_TABLE_ARN ${dynamodb.tableArn}`);
+  parts.push(`IMPORT_EXPORT_BUCKET ${dynamodb.exportBucket}`);
+
+  return parts.join("\n");
+}
+
 /**
  * Generate forward query section
  */
@@ -318,9 +332,12 @@ export function generateDatasource(
     datasource.options.kafka,
     datasource.options.s3,
     datasource.options.gcs,
+    datasource.options.dynamodb,
   ].filter(Boolean).length;
   if (ingestionConfigCount > 1) {
-    throw new Error("Datasource can only define one ingestion option: `kafka`, `s3`, or `gcs`.");
+    throw new Error(
+      "Datasource can only define one ingestion option: `kafka`, `s3`, `gcs`, or `dynamodb`."
+    );
   }
 
   // Add description if present
@@ -369,6 +386,12 @@ export function generateDatasource(
     parts.push(generateImportConfig(datasource.options.gcs));
   }
 
+  // Add DynamoDB configuration if present
+  if (datasource.options.dynamodb) {
+    parts.push("");
+    parts.push(generateDynamoDBConfig(datasource.options.dynamodb));
+  }
+
   // Add forward query if present
   const forwardQuery = generateForwardQuery(datasource.options.forwardQuery);
   if (forwardQuery) {