@lightdash/warehouses 2.228.1 → 2.229.1

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

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

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

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

package/dist/warehouseClients/MotherduckErrorClassifier.test.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MotherduckErrorClassifier_1 = require("./MotherduckErrorClassifier");
-describe('classifyMotherduckError', () => {
-    it.each([
-        'Connection Error: Connection has already been closed',
-        'Invalid Input Error: Cannot execute statement of closed connection',
-        'Catalog Error: Database analytics was detached',
-        'Invalid Input Error: database was invalidated because the instance was closed',
-    ])('classifies stale DuckDB handles: %s', (message) => {
-        expect((0, MotherduckErrorClassifier_1.classifyMotherduckError)(new Error(message))).toBe('stale');
-    });
-    it.each([
-        'MotherDuck Authentication failed: token rejected',
-        'Invalid Input Error: MD Authentication Error: Invalid token',
-        'Your request is not authenticated. Please check your MotherDuck token...',
-        'HTTP Error: Unauthorized',
-        "Could not connect to MotherDuck... (PERMISSION_DENIED, RPC 'CREATE_SLT')",
-        'RPC failed with PeRmIsSiOn_DeNiEd',
-        'COULD NOT CONNECT TO MOTHERDUCK',
-    ])('classifies MotherDuck authentication failures: %s', (message) => {
-        expect((0, MotherduckErrorClassifier_1.classifyMotherduckError)(new Error(message))).toBe('auth');
-    });
-    it.each([
-        'Binder Error: Referenced column missing_column not found',
-        'Catalog Error: Table with name missing_table does not exist',
-        'Invalid Input Error: configuration has been locked',
-    ])('leaves SQL and configuration errors untouched: %s', (message) => {
-        expect((0, MotherduckErrorClassifier_1.classifyMotherduckError)(new Error(message))).toBe('other');
-    });
-});

package/dist/warehouseClients/MotherduckInstanceCache.catalog.test.d.ts

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

package/dist/warehouseClients/MotherduckInstanceCache.catalog.test.d.ts.map

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

package/dist/warehouseClients/MotherduckInstanceCache.catalog.test.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MotherduckInstanceCache_1 = require("./MotherduckInstanceCache");
-describe('MotherduckInstanceCache catalog freshness regression', () => {
-    beforeEach(() => {
-        (0, MotherduckInstanceCache_1.resetForTesting)();
-        (0, MotherduckInstanceCache_1.configure)({
-            idleTtlMs: 60000,
-            maxAgeMs: 60000,
-            maxEntries: 1,
-        });
-    });
-    afterEach(async () => {
-        await (0, MotherduckInstanceCache_1.closeAll)('shutdown');
-    });
-    it('serves a new table and column through both an already-warm connection and a fresh connection on the held instance', async () => {
-        let entryId = '';
-        await (0, MotherduckInstanceCache_1.withInstance)(':memory:', {}, async (instance, acquiredEntryId) => {
-            entryId = acquiredEntryId;
-            const warmConnection = await instance.connect();
-            const ddlConnection = await instance.connect();
-            try {
-                await warmConnection.run('SELECT * FROM information_schema.columns');
-                await ddlConnection.run('CREATE TABLE catalog_freshness (initial_column INTEGER)');
-                await ddlConnection.run('ALTER TABLE catalog_freshness ADD COLUMN added_column VARCHAR');
-                const warmResult = await warmConnection.run("SELECT column_name FROM information_schema.columns WHERE table_name = 'catalog_freshness' ORDER BY ordinal_position");
-                await expect(warmResult.getRowObjects()).resolves.toEqual([
-                    { column_name: 'initial_column' },
-                    { column_name: 'added_column' },
-                ]);
-            }
-            finally {
-                ddlConnection.closeSync();
-                warmConnection.closeSync();
-            }
-        });
-        await (0, MotherduckInstanceCache_1.withInstance)(':memory:', {}, async (instance, acquiredEntryId) => {
-            expect(acquiredEntryId).toBe(entryId);
-            const freshConnection = await instance.connect();
-            try {
-                const freshResult = await freshConnection.run("SELECT column_name FROM information_schema.columns WHERE table_name = 'catalog_freshness' ORDER BY ordinal_position");
-                await expect(freshResult.getRowObjects()).resolves.toEqual([
-                    { column_name: 'initial_column' },
-                    { column_name: 'added_column' },
-                ]);
-            }
-            finally {
-                freshConnection.closeSync();
-            }
-        });
-    });
-});

package/dist/warehouseClients/MotherduckInstanceCache.integration.test.d.ts

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

package/dist/warehouseClients/MotherduckInstanceCache.integration.test.d.ts.map

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

package/dist/warehouseClients/MotherduckInstanceCache.integration.test.js

@@ -1,172 +0,0 @@
-"use strict";
-// Run: set -a; source .motherduck.env; set +a; pnpm -F warehouses exec vitest run src/warehouseClients/MotherduckInstanceCache.integration.test.ts
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_api_1 = require("@duckdb/node-api");
-const crypto_1 = require("crypto");
-const MotherduckInstanceCache = __importStar(require("./MotherduckInstanceCache"));
-const motherduckToken = process.env.MOTHERDUCK_TOKEN?.trim();
-const database = 'jaffle_shop';
-const query = 'SELECT * FROM jaffle_shop.jaffle.orders LIMIT 10';
-const tablePrefix = 'ld_spk822_catalog_freshness_';
-const ownedTablePattern = /^ld_spk822_catalog_freshness_[0-9a-f]{8}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{12}$/;
-const getConnectionString = () => {
-    if (!motherduckToken) {
-        throw new Error('MOTHERDUCK_TOKEN is required');
-    }
-    return `md:${database}?${new URLSearchParams({
-        motherduck_token: motherduckToken,
-        saas_mode: 'true',
-    }).toString()}`;
-};
-const closeConnection = (connection) => {
-    connection.closeSync?.();
-    connection.disconnectSync?.();
-};
-const consumeQuery = async (connection, sql) => {
-    const result = await connection.stream(sql);
-    const rows = [];
-    for await (const chunk of result.yieldRowObjectJson()) {
-        rows.push(...chunk);
-    }
-    return rows;
-};
-const withFreshInstance = async (callback) => {
-    const instance = await node_api_1.DuckDBInstance.create(getConnectionString());
-    const connection = await instance.connect();
-    try {
-        return await callback(connection);
-    }
-    finally {
-        closeConnection(connection);
-        instance.closeSync?.();
-    }
-};
-const measureFreshInstance = async () => {
-    const startedAt = performance.now();
-    await withFreshInstance(async (connection) => consumeQuery(connection, query));
-    return performance.now() - startedAt;
-};
-const measureHeldInstance = async (instance) => {
-    const startedAt = performance.now();
-    const connection = await instance.connect();
-    try {
-        await consumeQuery(connection, query);
-        return performance.now() - startedAt;
-    }
-    finally {
-        closeConnection(connection);
-    }
-};
-const median = (values) => {
-    const sorted = [...values].sort((left, right) => left - right);
-    const middle = sorted[Math.floor(sorted.length / 2)];
-    if (middle === undefined) {
-        throw new Error('Cannot calculate the median of an empty set');
-    }
-    return middle;
-};
-describe.skipIf(!motherduckToken)('MotherDuck instance cache live integration', () => {
-    let createdTableName;
-    beforeEach(() => {
-        MotherduckInstanceCache.resetForTesting();
-        MotherduckInstanceCache.configure({
-            idleTtlMs: 60000,
-            maxAgeMs: 60000,
-            maxEntries: 1,
-        });
-    });
-    afterEach(async () => {
-        await MotherduckInstanceCache.closeAll('shutdown');
-        if (createdTableName) {
-            if (!ownedTablePattern.test(createdTableName)) {
-                throw new Error('Refusing to clean up an unowned table');
-            }
-            await withFreshInstance(async (connection) => {
-                await connection.run(`DROP TABLE main."${createdTableName}"`);
-            });
-            createdTableName = undefined;
-        }
-    });
-    it('keeps a held instance fresh for a table and column created after warmup', async () => {
-        const tableName = `${tablePrefix}${(0, crypto_1.randomUUID)().replaceAll('-', '_')}`;
-        await MotherduckInstanceCache.withInstance(getConnectionString(), {}, async (instance) => {
-            const warmConnection = await instance.connect();
-            try {
-                await consumeQuery(warmConnection, 'SELECT * FROM information_schema.columns LIMIT 1');
-                await withFreshInstance(async (connection) => {
-                    await connection.run(`CREATE TABLE main."${tableName}" (initial_column INTEGER)`);
-                    createdTableName = tableName;
-                    await connection.run(`ALTER TABLE main."${tableName}" ADD COLUMN added_column VARCHAR`);
-                });
-                const columnsSql = `SELECT column_name FROM information_schema.columns WHERE table_catalog = '${database}' AND table_schema = 'main' AND table_name = '${tableName}' ORDER BY ordinal_position`;
-                const warmRows = await consumeQuery(warmConnection, columnsSql);
-                const freshConnection = await instance.connect();
-                try {
-                    const freshRows = await consumeQuery(freshConnection, columnsSql);
-                    expect(warmRows).toEqual([
-                        { column_name: 'initial_column' },
-                        { column_name: 'added_column' },
-                    ]);
-                    expect(freshRows).toEqual(warmRows);
-                }
-                finally {
-                    closeConnection(freshConnection);
-                }
-            }
-            finally {
-                closeConnection(warmConnection);
-            }
-        });
-    }, 60000);
-    it('keeps held-instance query cost several times below fresh-instance cost', async () => {
-        const freshInstanceMs = [];
-        const heldInstanceMs = [];
-        await MotherduckInstanceCache.withInstance(getConnectionString(), {}, async (instance) => {
-            await measureHeldInstance(instance);
-            const collectMeasurements = async (remaining) => {
-                if (remaining === 0) {
-                    return;
-                }
-                freshInstanceMs.push(await measureFreshInstance());
-                heldInstanceMs.push(await measureHeldInstance(instance));
-                await collectMeasurements(remaining - 1);
-            };
-            await collectMeasurements(3);
-        });
-        // A 3x threshold catches loss of instance reuse while leaving headroom for observed cross-run variance.
-        expect(median(freshInstanceMs) / median(heldInstanceMs)).toBeGreaterThanOrEqual(3);
-    }, 60000);
-});

package/dist/warehouseClients/MotherduckInstanceCache.security.test.d.ts

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

package/dist/warehouseClients/MotherduckInstanceCache.security.test.d.ts.map

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

package/dist/warehouseClients/MotherduckInstanceCache.security.test.js

@@ -1,192 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const DuckdbWarehouseClient_1 = require("./DuckdbWarehouseClient");
-const MotherduckInstanceCache = __importStar(require("./MotherduckInstanceCache"));
-const createInstanceMock = vi.fn();
-vi.mock('@duckdb/node-api', () => ({
-    DuckDBTypeId: { INTEGER: 4, VARCHAR: 17 },
-    DuckDBInstance: {
-        create: (...args) => createInstanceMock(...args),
-    },
-    version: () => 'v1.5.2',
-}));
-const getMockStreamResult = (marker) => ({
-    columnCount: 1,
-    columnNames: () => ['marker'],
-    columnType: () => ({ typeId: 17 }),
-    yieldRowObjectJson: async function* yieldRows() {
-        yield [{ marker }];
-    },
-});
-const createMockInstance = (streamMock) => ({
-    connect: async () => ({
-        run: vi.fn(),
-        stream: streamMock,
-        extractStatements: vi.fn(async () => ({
-            count: 1,
-            prepare: async () => ({
-                statementType: 1,
-                destroySync: vi.fn(),
-            }),
-        })),
-        interrupt: vi.fn(),
-        closeSync: vi.fn(),
-        disconnectSync: vi.fn(),
-    }),
-    closeSync: vi.fn(),
-});
-const motherduckCredentials = (database, token) => ({
-    type: common_1.WarehouseTypes.DUCKDB,
-    connectionType: common_1.DuckdbConnectionType.MOTHERDUCK,
-    database,
-    schema: 'main',
-    token,
-});
-const cachedOptions = (projectUuid) => ({
-    enableInstanceCache: true,
-    projectUuid,
-});
-const successStream = (marker) => vi.fn(async () => getMockStreamResult(marker));
-describe('MotherDuck instance cache security boundaries', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.clearAllMocks();
-        MotherduckInstanceCache.resetForTesting();
-        MotherduckInstanceCache.configure({
-            idleTtlMs: 60000,
-            maxAgeMs: 3600000,
-            maxEntries: 64,
-        });
-        DuckdbWarehouseClient_1.DuckdbWarehouseClient.resetSharedDuckdbStateForTesting();
-    });
-    afterEach(async () => {
-        await MotherduckInstanceCache.closeAll('shutdown');
-        vi.useRealTimers();
-    });
-    it('isolates concurrent clients with different tokens for one database', async () => {
-        const streamA = successStream('token-a-rows');
-        const streamB = successStream('token-b-rows');
-        const instanceA = createMockInstance(streamA);
-        const instanceB = createMockInstance(streamB);
-        createInstanceMock.mockImplementation(async (connectionString) => String(connectionString).includes('token-a')
-            ? instanceA
-            : instanceB);
-        const clientA = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials('analytics', 'token-a'), cachedOptions('project-a'));
-        const clientB = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials('analytics', 'token-b'), cachedOptions('project-b'));
-        const [resultA, resultB] = await Promise.all([
-            clientA.runQuery('SELECT 1'),
-            clientB.runQuery('SELECT 1'),
-        ]);
-        expect(createInstanceMock).toHaveBeenCalledTimes(2);
-        expect(resultA.rows).toEqual([{ marker: 'token-a-rows' }]);
-        expect(resultB.rows).toEqual([{ marker: 'token-b-rows' }]);
-    });
-    it('isolates clients with one token across different databases', async () => {
-        createInstanceMock.mockImplementation(async (connectionString) => createMockInstance(successStream(String(connectionString).startsWith('md:first')
-            ? 'first-rows'
-            : 'second-rows')));
-        const firstClient = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials('first', 'shared-token'), cachedOptions('project-a'));
-        const secondClient = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials('second', 'shared-token'), cachedOptions('project-b'));
-        const [firstResult, secondResult] = await Promise.all([
-            firstClient.runQuery('SELECT 1'),
-            secondClient.runQuery('SELECT 1'),
-        ]);
-        expect(createInstanceMock).toHaveBeenCalledTimes(2);
-        expect(firstResult.rows).toEqual([{ marker: 'first-rows' }]);
-        expect(secondResult.rows).toEqual([{ marker: 'second-rows' }]);
-    });
-    it('never maps adversarial database names onto another credential entry', async () => {
-        const victimConnectionString = `md:analytics?${new URLSearchParams({
-            motherduck_token: 'victim-token',
-            saas_mode: 'true',
-        }).toString()}`;
-        const adversarialNames = [
-            'analytics?motherduck_token=victim-token',
-            'analytics?motherduck_token=victim-token&saas_mode=true',
-            'analytics&saas_mode=false',
-            'analytics%3Fmotherduck_token%3Dvictim-token',
-            'analytics/../analytics',
-            'analytics#',
-            'analytics/',
-            'analytics ',
-            'ANALYTICS',
-            'café',
-            'café',
-            'analytics%00',
-            '',
-            '�',
-        ];
-        createInstanceMock.mockImplementation(async () => createMockInstance(successStream('rows')));
-        await Promise.all(adversarialNames.map((database, index) => {
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials(database, 'attacker-token'), cachedOptions(`attacker-project-${index}`));
-            return client.runQuery('SELECT 1');
-        }));
-        const adversarialConnectionStrings = createInstanceMock.mock.calls.map(([connectionString]) => String(connectionString));
-        expect(adversarialConnectionStrings).not.toContain(victimConnectionString);
-        expect(new Set(adversarialConnectionStrings).size).toBe(adversarialNames.length);
-        const victimClient = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(motherduckCredentials('analytics', 'victim-token'), cachedOptions('victim-project'));
-        await victimClient.runQuery('SELECT 1');
-        expect(createInstanceMock).toHaveBeenLastCalledWith(victimConnectionString);
-    });
-    it('does not close an in-flight instance when max age evicts it', async () => {
-        MotherduckInstanceCache.configure({
-            idleTtlMs: 60000,
-            maxAgeMs: 1000,
-            maxEntries: 8,
-        });
-        const instance = createMockInstance(successStream('rows'));
-        createInstanceMock
-            .mockResolvedValueOnce(instance)
-            .mockResolvedValue(createMockInstance(successStream('other')));
-        let releaseQuery = () => undefined;
-        const queryGate = new Promise((resolve) => {
-            releaseQuery = resolve;
-        });
-        let entryId = '';
-        const inFlight = MotherduckInstanceCache.withInstance('md:analytics?motherduck_token=token-a', {}, async (_instance, acquiredEntryId) => {
-            entryId = acquiredEntryId;
-            await queryGate;
-        });
-        await vi.waitFor(() => expect(entryId).not.toBe(''));
-        await vi.advanceTimersByTimeAsync(1500);
-        await MotherduckInstanceCache.withInstance('md:other?motherduck_token=token-b', {}, async () => undefined);
-        expect(instance.closeSync).not.toHaveBeenCalled();
-        releaseQuery();
-        await inFlight;
-        expect(instance.closeSync).toHaveBeenCalledOnce();
-    });
-});

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

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

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

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