@lightdash/warehouses 0.2532.1 → 0.2533.0

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './warehouseClientFromCredentials';
 export * from './warehouseClients/AthenaWarehouseClient';
 export * from './warehouseClients/BigqueryWarehouseClient';
 export * from './warehouseClients/DatabricksWarehouseClient';
+export * from './warehouseClients/DuckdbWarehouseClient';
 export * from './warehouseClients/PostgresWarehouseClient';
 export * from './warehouseClients/RedshiftWarehouseClient';
 export * from './warehouseClients/SnowflakeWarehouseClient';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,kCAAkC,CAAC;AACjD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,kCAAkC,CAAC;AACjD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC"}

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./warehouseClientFromCredentials"), exports);
 __exportStar(require("./warehouseClients/AthenaWarehouseClient"), exports);
 __exportStar(require("./warehouseClients/BigqueryWarehouseClient"), exports);
 __exportStar(require("./warehouseClients/DatabricksWarehouseClient"), exports);
+__exportStar(require("./warehouseClients/DuckdbWarehouseClient"), exports);
 __exportStar(require("./warehouseClients/PostgresWarehouseClient"), exports);
 __exportStar(require("./warehouseClients/RedshiftWarehouseClient"), exports);
 __exportStar(require("./warehouseClients/SnowflakeWarehouseClient"), exports);

package/dist/warehouseClients/DuckdbWarehouseClient.d.ts

@@ -0,0 +1,58 @@
+import { AnyType, CreatePostgresCredentials, DimensionType, Metric, SupportedDbtAdapter, WarehouseCatalog, WarehouseResults } from '@lightdash/common';
+import WarehouseBaseClient from './WarehouseBaseClient';
+import WarehouseBaseSqlBuilder from './WarehouseBaseSqlBuilder';
+export type DuckdbS3SessionConfig = {
+    endpoint: string;
+    region?: string;
+    accessKey?: string;
+    secretKey?: string;
+    forcePathStyle: boolean;
+    useSsl: boolean;
+};
+export type DuckdbWarehouseClientArgs = {
+    databasePath?: string;
+    s3Config?: DuckdbS3SessionConfig;
+};
+export declare const mapFieldTypeFromTypeId: (typeId: number) => DimensionType;
+export declare class DuckdbSqlBuilder extends WarehouseBaseSqlBuilder {
+    getAdapterType(): SupportedDbtAdapter;
+    getFloatingType(): string;
+    getMetricSql(sql: string, metric: Metric): string;
+    concatString(...args: string[]): string;
+}
+export declare class DuckdbWarehouseClient extends WarehouseBaseClient<CreatePostgresCredentials> {
+    private readonly databasePath;
+    private readonly s3Config?;
+    constructor(args?: DuckdbWarehouseClientArgs);
+    private getSQLWithMetadata;
+    private withSession;
+    private bootstrapSession;
+    private getBindValues;
+    private static getFieldsFromStreamResult;
+    streamQuery(sql: string, streamCallback: (data: WarehouseResults) => void | Promise<void>, options?: {
+        values?: AnyType[];
+        queryParams?: Record<string, AnyType>;
+        tags?: Record<string, string>;
+        timezone?: string;
+    }): Promise<void>;
+    executeAsyncQuery(...args: Parameters<WarehouseBaseClient<CreatePostgresCredentials>['executeAsyncQuery']>): Promise<import("@lightdash/common").WarehouseExecuteAsyncQuery>;
+    runQuery(...args: Parameters<WarehouseBaseClient<CreatePostgresCredentials>['runQuery']>): Promise<{
+        fields: Record<string, {
+            type: DimensionType;
+        }>;
+        rows: Record<string, any>[];
+    }>;
+    test(): Promise<void>;
+    getCatalog(_config: {
+        database: string;
+        schema: string;
+        table: string;
+    }[]): Promise<WarehouseCatalog>;
+    getAllTables(_schema?: string, _tags?: Record<string, string>): Promise<{
+        database: string;
+        schema: string;
+        table: string;
+    }[]>;
+    getFields(_tableName: string, _schema?: string, _database?: string, _tags?: Record<string, string>): Promise<WarehouseCatalog>;
+}
+//# sourceMappingURL=DuckdbWarehouseClient.d.ts.map

package/dist/warehouseClients/DuckdbWarehouseClient.d.ts.map

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

package/dist/warehouseClients/DuckdbWarehouseClient.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckdbWarehouseClient = exports.DuckdbSqlBuilder = exports.mapFieldTypeFromTypeId = void 0;
+const node_api_1 = require("@duckdb/node-api");
+const common_1 = require("@lightdash/common");
+const WarehouseBaseClient_1 = __importDefault(require("./WarehouseBaseClient"));
+const WarehouseBaseSqlBuilder_1 = __importDefault(require("./WarehouseBaseSqlBuilder"));
+const DUCKDB_INTERNAL_CREDENTIALS = {
+    type: common_1.WarehouseTypes.POSTGRES,
+    host: 'localhost',
+    port: 5432,
+    dbname: 'duckdb',
+    schema: 'main',
+    user: 'duckdb',
+    password: 'duckdb',
+};
+const mapFieldTypeFromTypeId = (typeId) => {
+    switch (typeId) {
+        case node_api_1.DuckDBTypeId.DATE:
+            return common_1.DimensionType.DATE;
+        case node_api_1.DuckDBTypeId.TIME:
+        case node_api_1.DuckDBTypeId.TIME_TZ:
+        case node_api_1.DuckDBTypeId.TIMESTAMP:
+        case node_api_1.DuckDBTypeId.TIMESTAMP_S:
+        case node_api_1.DuckDBTypeId.TIMESTAMP_MS:
+        case node_api_1.DuckDBTypeId.TIMESTAMP_NS:
+        case node_api_1.DuckDBTypeId.TIMESTAMP_TZ:
+            return common_1.DimensionType.TIMESTAMP;
+        case node_api_1.DuckDBTypeId.BOOLEAN:
+            return common_1.DimensionType.BOOLEAN;
+        case node_api_1.DuckDBTypeId.TINYINT:
+        case node_api_1.DuckDBTypeId.SMALLINT:
+        case node_api_1.DuckDBTypeId.INTEGER:
+        case node_api_1.DuckDBTypeId.BIGINT:
+        case node_api_1.DuckDBTypeId.HUGEINT:
+        case node_api_1.DuckDBTypeId.UTINYINT:
+        case node_api_1.DuckDBTypeId.USMALLINT:
+        case node_api_1.DuckDBTypeId.UINTEGER:
+        case node_api_1.DuckDBTypeId.UBIGINT:
+        case node_api_1.DuckDBTypeId.UHUGEINT:
+        case node_api_1.DuckDBTypeId.FLOAT:
+        case node_api_1.DuckDBTypeId.DOUBLE:
+        case node_api_1.DuckDBTypeId.DECIMAL:
+            return common_1.DimensionType.NUMBER;
+        default:
+            return common_1.DimensionType.STRING;
+    }
+};
+exports.mapFieldTypeFromTypeId = mapFieldTypeFromTypeId;
+class DuckdbSqlBuilder extends WarehouseBaseSqlBuilder_1.default {
+    getAdapterType() {
+        return common_1.SupportedDbtAdapter.DUCKDB;
+    }
+    getFloatingType() {
+        return 'DOUBLE';
+    }
+    getMetricSql(sql, metric) {
+        switch (metric.type) {
+            case common_1.MetricType.PERCENTILE:
+                return `QUANTILE_CONT(${sql}, ${(metric.percentile ?? 50) / 100})`;
+            case common_1.MetricType.MEDIAN:
+                return `MEDIAN(${sql})`;
+            default:
+                return super.getMetricSql(sql, metric);
+        }
+    }
+    concatString(...args) {
+        return `(${args.join(' || ')})`;
+    }
+}
+exports.DuckdbSqlBuilder = DuckdbSqlBuilder;
+class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
+    constructor(args = {}) {
+        super(DUCKDB_INTERNAL_CREDENTIALS, new DuckdbSqlBuilder());
+        this.databasePath = args.databasePath ?? ':memory:';
+        this.s3Config = args.s3Config;
+    }
+    getSQLWithMetadata(sql, tags) {
+        if (!tags) {
+            return sql;
+        }
+        return `${sql}\n-- ${JSON.stringify(tags)}`;
+    }
+    async withSession(callback) {
+        const instance = (await node_api_1.DuckDBInstance.create(this.databasePath));
+        const connection = await instance.connect();
+        try {
+            await this.bootstrapSession(connection);
+            return await callback(connection);
+        }
+        finally {
+            connection.closeSync?.();
+            connection.disconnectSync?.();
+            instance.closeSync?.();
+        }
+    }
+    async bootstrapSession(db) {
+        await db.run('LOAD httpfs;');
+        if (!this.s3Config) {
+            return;
+        }
+        await db.run(`SET s3_endpoint = '${this.escapeString(this.s3Config.endpoint)}';`);
+        if (this.s3Config.region) {
+            await db.run(`SET s3_region = '${this.escapeString(this.s3Config.region)}';`);
+        }
+        if (this.s3Config.accessKey) {
+            await db.run(`SET s3_access_key_id = '${this.escapeString(this.s3Config.accessKey)}';`);
+        }
+        if (this.s3Config.secretKey) {
+            await db.run(`SET s3_secret_access_key = '${this.escapeString(this.s3Config.secretKey)}';`);
+        }
+        await db.run(`SET s3_use_ssl = ${this.s3Config.useSsl};`);
+        await db.run(`SET s3_url_style = '${this.s3Config.forcePathStyle ? 'path' : 'vhost'}';`);
+    }
+    getBindValues(options) {
+        const hasValues = !!options?.values && options.values.length > 0;
+        const hasQueryParams = !!options?.queryParams &&
+            Object.keys(options.queryParams).length > 0;
+        if (hasValues && hasQueryParams) {
+            throw new common_1.NotImplementedError('DuckDB streamQuery does not support using values and queryParams together');
+        }
+        if (hasValues) {
+            return options?.values;
+        }
+        if (hasQueryParams) {
+            return options?.queryParams;
+        }
+        return undefined;
+    }
+    static getFieldsFromStreamResult(result) {
+        const columnNames = result.columnNames();
+        const fields = {};
+        for (let i = 0; i < result.columnCount; i += 1) {
+            fields[columnNames[i]] = {
+                type: (0, exports.mapFieldTypeFromTypeId)(result.columnTypeId(i)),
+            };
+        }
+        return fields;
+    }
+    async streamQuery(sql, streamCallback, options) {
+        await this.withSession(async (db) => {
+            if (options?.timezone) {
+                await db.run(`SET TimeZone = '${this.escapeString(options.timezone)}';`);
+            }
+            const result = await db.stream(this.getSQLWithMetadata(sql, options?.tags), this.getBindValues(options));
+            const fields = DuckdbWarehouseClient.getFieldsFromStreamResult(result);
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const rows of result.yieldRowObjectJson()) {
+                await streamCallback({ fields, rows });
+            }
+        });
+    }
+    async executeAsyncQuery(...args) {
+        return super.executeAsyncQuery(...args);
+    }
+    async runQuery(...args) {
+        return super.runQuery(...args);
+    }
+    async test() {
+        await super.test();
+    }
+    async getCatalog(_config) {
+        throw new common_1.NotImplementedError('DuckDB catalog discovery is not implemented yet');
+    }
+    async getAllTables(_schema, _tags) {
+        throw new common_1.NotImplementedError('DuckDB table discovery is not implemented yet');
+    }
+    async getFields(_tableName, _schema, _database, _tags) {
+        throw new common_1.NotImplementedError('DuckDB field discovery is not implemented yet');
+    }
+}
+exports.DuckdbWarehouseClient = DuckdbWarehouseClient;

package/dist/warehouseClients/DuckdbWarehouseClient.test.d.ts

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

package/dist/warehouseClients/DuckdbWarehouseClient.test.d.ts.map

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

package/dist/warehouseClients/DuckdbWarehouseClient.test.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@lightdash/common");
+const DuckdbWarehouseClient_1 = require("./DuckdbWarehouseClient");
+const createInstanceMock = jest.fn();
+// Must provide DuckDBTypeId since mapFieldTypeFromTypeId references it at runtime
+const DUCKDB_TYPE_IDS = {
+    BOOLEAN: 1,
+    TINYINT: 2,
+    SMALLINT: 3,
+    INTEGER: 4,
+    BIGINT: 5,
+    UTINYINT: 6,
+    USMALLINT: 7,
+    UINTEGER: 8,
+    UBIGINT: 9,
+    FLOAT: 10,
+    DOUBLE: 11,
+    TIMESTAMP: 12,
+    DATE: 13,
+    TIME: 14,
+    DECIMAL: 19,
+    HUGEINT: 25,
+    TIMESTAMP_S: 27,
+    TIMESTAMP_MS: 28,
+    TIMESTAMP_NS: 29,
+    TIMESTAMP_TZ: 31,
+    TIME_TZ: 32,
+    UHUGEINT: 49,
+    // Not referenced in switch — used to test default→STRING
+    VARCHAR: 17,
+    BLOB: 18,
+};
+jest.mock('@duckdb/node-api', () => ({
+    DuckDBTypeId: {
+        BOOLEAN: 1,
+        TINYINT: 2,
+        SMALLINT: 3,
+        INTEGER: 4,
+        BIGINT: 5,
+        UTINYINT: 6,
+        USMALLINT: 7,
+        UINTEGER: 8,
+        UBIGINT: 9,
+        FLOAT: 10,
+        DOUBLE: 11,
+        TIMESTAMP: 12,
+        DATE: 13,
+        TIME: 14,
+        DECIMAL: 19,
+        HUGEINT: 25,
+        TIMESTAMP_S: 27,
+        TIMESTAMP_MS: 28,
+        TIMESTAMP_NS: 29,
+        TIMESTAMP_TZ: 31,
+        TIME_TZ: 32,
+        UHUGEINT: 49,
+    },
+    DuckDBInstance: {
+        create: (...args) => createInstanceMock(...args),
+    },
+}), { virtual: true });
+const getMockStreamResult = (chunks, columnTypeIds) => {
+    const columnNames = Object.keys(chunks[0]?.[0] || {});
+    return {
+        columnCount: columnNames.length,
+        columnNames: () => columnNames,
+        columnTypeId: (i) => columnTypeIds[i] ?? 0,
+        // eslint-disable-next-line object-shorthand, func-names, no-restricted-syntax
+        yieldRowObjectJson: async function* () {
+            // eslint-disable-next-line no-restricted-syntax
+            for (const chunk of chunks) {
+                yield chunk;
+            }
+        },
+    };
+};
+const createMockConnection = (streamMock, runMock = jest.fn()) => ({
+    connect: async () => ({
+        run: runMock,
+        stream: streamMock,
+        closeSync: jest.fn(),
+        disconnectSync: jest.fn(),
+    }),
+    closeSync: jest.fn(),
+});
+describe('mapFieldTypeFromTypeId', () => {
+    it('should map date types', () => {
+        expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(DUCKDB_TYPE_IDS.DATE)).toBe(common_1.DimensionType.DATE);
+    });
+    it('should map timestamp types', () => {
+        const timestampIds = [
+            DUCKDB_TYPE_IDS.TIMESTAMP,
+            DUCKDB_TYPE_IDS.TIMESTAMP_S,
+            DUCKDB_TYPE_IDS.TIMESTAMP_MS,
+            DUCKDB_TYPE_IDS.TIMESTAMP_NS,
+            DUCKDB_TYPE_IDS.TIMESTAMP_TZ,
+            DUCKDB_TYPE_IDS.TIME,
+            DUCKDB_TYPE_IDS.TIME_TZ,
+        ];
+        timestampIds.forEach((id) => {
+            expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(id)).toBe(common_1.DimensionType.TIMESTAMP);
+        });
+    });
+    it('should map boolean type', () => {
+        expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(DUCKDB_TYPE_IDS.BOOLEAN)).toBe(common_1.DimensionType.BOOLEAN);
+    });
+    it('should map numeric types', () => {
+        const numericIds = [
+            DUCKDB_TYPE_IDS.TINYINT,
+            DUCKDB_TYPE_IDS.SMALLINT,
+            DUCKDB_TYPE_IDS.INTEGER,
+            DUCKDB_TYPE_IDS.BIGINT,
+            DUCKDB_TYPE_IDS.UTINYINT,
+            DUCKDB_TYPE_IDS.USMALLINT,
+            DUCKDB_TYPE_IDS.UINTEGER,
+            DUCKDB_TYPE_IDS.UBIGINT,
+            DUCKDB_TYPE_IDS.HUGEINT,
+            DUCKDB_TYPE_IDS.UHUGEINT,
+            DUCKDB_TYPE_IDS.FLOAT,
+            DUCKDB_TYPE_IDS.DOUBLE,
+            DUCKDB_TYPE_IDS.DECIMAL,
+        ];
+        numericIds.forEach((id) => {
+            expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(id)).toBe(common_1.DimensionType.NUMBER);
+        });
+    });
+    it('should default to string for unknown types', () => {
+        expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(DUCKDB_TYPE_IDS.VARCHAR)).toBe(common_1.DimensionType.STRING);
+        expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(DUCKDB_TYPE_IDS.BLOB)).toBe(common_1.DimensionType.STRING);
+        expect((0, DuckdbWarehouseClient_1.mapFieldTypeFromTypeId)(9999)).toBe(common_1.DimensionType.STRING);
+    });
+});
+describe('DuckdbWarehouseClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return query rows and mapped fields', async () => {
+        const rows = [
+            {
+                customer_name: 'Alice',
+                order_count: 2,
+                last_order_at: '2026-02-22 12:00:00',
+            },
+        ];
+        const streamMock = jest.fn(async () => getMockStreamResult([rows], [
+            DUCKDB_TYPE_IDS.VARCHAR,
+            DUCKDB_TYPE_IDS.INTEGER,
+            DUCKDB_TYPE_IDS.TIMESTAMP,
+        ]));
+        createInstanceMock.mockResolvedValue(createMockConnection(streamMock));
+        const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient({
+            s3Config: {
+                endpoint: 'localhost:9000',
+                region: 'us-east-1',
+                forcePathStyle: true,
+                useSsl: false,
+            },
+        });
+        const result = await client.runQuery('SELECT * FROM customers');
+        expect(result.rows).toEqual(rows);
+        expect(result.fields).toEqual({
+            customer_name: { type: common_1.DimensionType.STRING },
+            order_count: { type: common_1.DimensionType.NUMBER },
+            last_order_at: { type: common_1.DimensionType.TIMESTAMP },
+        });
+    });
+    it('should stream results in multiple chunks', async () => {
+        const chunk1 = [{ id: 1 }, { id: 2 }];
+        const chunk2 = [{ id: 3 }];
+        const streamMock = jest.fn(async () => getMockStreamResult([chunk1, chunk2], [DUCKDB_TYPE_IDS.INTEGER]));
+        createInstanceMock.mockResolvedValue(createMockConnection(streamMock));
+        const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient();
+        const streamCallback = jest.fn();
+        const result = await client.executeAsyncQuery({
+            sql: 'SELECT id FROM t',
+            tags: { project_uuid: 'proj-1' },
+        }, streamCallback);
+        expect(streamCallback).toHaveBeenCalledTimes(2);
+        expect(streamCallback).toHaveBeenNthCalledWith(1, chunk1, {
+            id: { type: common_1.DimensionType.NUMBER },
+        });
+        expect(streamCallback).toHaveBeenNthCalledWith(2, chunk2, {
+            id: { type: common_1.DimensionType.NUMBER },
+        });
+        expect(result.totalRows).toBe(3);
+    });
+    it('should handle empty result set', async () => {
+        const streamMock = jest.fn(async () => getMockStreamResult([], [DUCKDB_TYPE_IDS.INTEGER]));
+        createInstanceMock.mockResolvedValue(createMockConnection(streamMock));
+        const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient();
+        const result = await client.runQuery('SELECT id FROM empty_table');
+        expect(result.rows).toEqual([]);
+        expect(result.fields).toEqual({});
+    });
+    it('should set timezone and S3 config before streaming', async () => {
+        const runMock = jest.fn();
+        const streamMock = jest.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
+        createInstanceMock.mockResolvedValue(createMockConnection(streamMock, runMock));
+        const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient({
+            s3Config: {
+                endpoint: 'localhost:9000',
+                region: 'us-east-1',
+                accessKey: 'key',
+                secretKey: 'secret',
+                forcePathStyle: true,
+                useSsl: false,
+            },
+        });
+        await client.runQuery('SELECT 1 AS val', undefined, 'UTC');
+        const runCalls = runMock.mock.calls.map((call) => call[0]);
+        expect(runCalls).toContain('LOAD httpfs;');
+        expect(runCalls).toContain("SET s3_endpoint = 'localhost:9000';");
+        expect(runCalls).toContain("SET s3_region = 'us-east-1';");
+        expect(runCalls).toContain("SET TimeZone = 'UTC';");
+        expect(streamMock).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/warehouseSqlBuilderFromType.d.ts

@@ -3,8 +3,9 @@ import { AthenaSqlBuilder } from './warehouseClients/AthenaWarehouseClient';
 import { BigquerySqlBuilder } from './warehouseClients/BigqueryWarehouseClient';
 import { ClickhouseSqlBuilder } from './warehouseClients/ClickhouseWarehouseClient';
 import { DatabricksSqlBuilder } from './warehouseClients/DatabricksWarehouseClient';
+import { DuckdbSqlBuilder } from './warehouseClients/DuckdbWarehouseClient';
 import { PostgresSqlBuilder } from './warehouseClients/PostgresWarehouseClient';
 import { SnowflakeSqlBuilder } from './warehouseClients/SnowflakeWarehouseClient';
 import { TrinoSqlBuilder } from './warehouseClients/TrinoWarehouseClient';
-export declare const warehouseSqlBuilderFromType: (adapterType: string | SupportedDbtAdapter, startOfWeek?: import("@lightdash/common").WeekDay | null | undefined) => AthenaSqlBuilder | BigquerySqlBuilder | ClickhouseSqlBuilder | DatabricksSqlBuilder | PostgresSqlBuilder | SnowflakeSqlBuilder | TrinoSqlBuilder;
+export declare const warehouseSqlBuilderFromType: (adapterType: string | SupportedDbtAdapter, startOfWeek?: import("@lightdash/common").WeekDay | null | undefined) => AthenaSqlBuilder | BigquerySqlBuilder | ClickhouseSqlBuilder | DatabricksSqlBuilder | PostgresSqlBuilder | SnowflakeSqlBuilder | TrinoSqlBuilder | DuckdbSqlBuilder;
 //# sourceMappingURL=warehouseSqlBuilderFromType.d.ts.map

package/dist/warehouseSqlBuilderFromType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"warehouseSqlBuilderFromType.d.ts","sourceRoot":"","sources":["../src/warehouseSqlBuilderFromType.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,mBAAmB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAG1E,eAAO,MAAM,2BAA2B,gBACvB,MAAM,GAAG,mBAAmB,2NAgC5C,CAAC"}
+{"version":3,"file":"warehouseSqlBuilderFromType.d.ts","sourceRoot":"","sources":["../src/warehouseSqlBuilderFromType.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,mBAAmB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAG1E,eAAO,MAAM,2BAA2B,gBACvB,MAAM,GAAG,mBAAmB,8OAkC5C,CAAC"}

package/dist/warehouseSqlBuilderFromType.js

@@ -6,6 +6,7 @@ const AthenaWarehouseClient_1 = require("./warehouseClients/AthenaWarehouseClien
 const BigqueryWarehouseClient_1 = require("./warehouseClients/BigqueryWarehouseClient");
 const ClickhouseWarehouseClient_1 = require("./warehouseClients/ClickhouseWarehouseClient");
 const DatabricksWarehouseClient_1 = require("./warehouseClients/DatabricksWarehouseClient");
+const DuckdbWarehouseClient_1 = require("./warehouseClients/DuckdbWarehouseClient");
 const PostgresWarehouseClient_1 = require("./warehouseClients/PostgresWarehouseClient");
 const RedshiftWarehouseClient_1 = require("./warehouseClients/RedshiftWarehouseClient");
 const SnowflakeWarehouseClient_1 = require("./warehouseClients/SnowflakeWarehouseClient");
@@ -21,6 +22,8 @@ const warehouseSqlBuilderFromType = (adapterType, ...args) => {
             return new ClickhouseWarehouseClient_1.ClickhouseSqlBuilder(...args);
         case common_1.SupportedDbtAdapter.DATABRICKS:
             return new DatabricksWarehouseClient_1.DatabricksSqlBuilder(...args);
+        case common_1.SupportedDbtAdapter.DUCKDB:
+            return new DuckdbWarehouseClient_1.DuckdbSqlBuilder(...args);
         case common_1.SupportedDbtAdapter.POSTGRES:
             return new PostgresWarehouseClient_1.PostgresSqlBuilder(...args);
         case common_1.SupportedDbtAdapter.REDSHIFT:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/warehouses",
-  "version": "0.2532.1",
+  "version": "0.2533.0",
   "description": "Warehouse connectors for Lightdash",
   "license": "MIT",
   "repository": {
@@ -16,6 +16,7 @@
     "@aws-sdk/client-athena": "^3.972.0",
     "@clickhouse/client": "^1.12.1",
     "@databricks/sql": "1.8.4",
+    "@duckdb/node-api": "^1.4.4-r.1",
     "@google-cloud/bigquery": "^7.9.2",
     "lodash": "^4.17.23",
     "node-fetch": "^2.7.0",
@@ -24,7 +25,7 @@
     "snowflake-sdk": "~2.3.4",
     "ssh2": "^1.14.0",
     "trino-client": "0.2.9",
-    "@lightdash/common": "0.2532.1"
+    "@lightdash/common": "0.2533.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.13",