@lightdash/warehouses 1.79.1 → 1.80.0

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

@@ -0,0 +1,172 @@
+"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.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotherduckInstanceCache = exports.resetForTesting = exports.recordRetry = exports.closeAll = exports.invalidateByConnectionString = exports.invalidate = exports.withInstance = exports.setObserver = exports.configure = void 0;
+const node_api_1 = require("@duckdb/node-api");
+const crypto_1 = require("crypto");
+const holdEntry = (entry) => {
+    const heldEntry = entry;
+    heldEntry.refCount += 1;
+    heldEntry.lastUsedAt = performance.now();
+    return heldEntry;
+};
+const DEFAULT_OPTIONS = {
+    idleTtlMs: 10 * 60000,
+    maxAgeMs: 60 * 60000,
+    maxEntries: 8,
+    maxConsecutiveFailures: 3,
+};
+let options = DEFAULT_OPTIONS;
+let observer = () => undefined;
+let sweepTimer;
+const entries = new Map();
+const pendingCreations = new Map();
+const creationGenerations = new Map();
+const emit = (event) => {
+    try {
+        observer(event);
+    }
+    catch {
+        return;
+    }
+};
+const cacheKeyFor = (connectionString) => (0, crypto_1.createHash)('sha256')
+    .update(JSON.stringify({ connectionString, v: 1 }))
+    .digest('hex');
+const closeInstance = (instance) => {
+    try {
+        instance.closeSync?.();
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const closeEntry = (entry) => {
+    if (entry.closed || entry.refCount > 0) {
+        return;
+    }
+    const closingEntry = entry;
+    closingEntry.closed = true;
+    closeInstance(closingEntry.instance);
+    closingEntry.resolveClose();
+};
+const unlinkEntry = (key, entry, reason) => {
+    if (entries.get(key) !== entry) {
+        return entry.closePromise;
+    }
+    entries.delete(key);
+    const drainingEntry = entry;
+    drainingEntry.draining = true;
+    emit({
+        type: 'evict',
+        entryId: entry.entryId,
+        projectUuid: entry.projectUuid,
+        reason,
+        ageMs: performance.now() - entry.createdAt,
+    });
+    emit({ type: 'size', entries: entries.size });
+    closeEntry(entry);
+    return entry.closePromise;
+};
+const sweep = () => {
+    const now = performance.now();
+    entries.forEach((entry, key) => {
+        const ageMs = now - entry.createdAt;
+        const idleMs = now - entry.lastUsedAt;
+        if (ageMs >= options.maxAgeMs) {
+            void unlinkEntry(key, entry, 'max_age');
+        }
+        else if (entry.refCount === 0 && idleMs >= options.idleTtlMs) {
+            void unlinkEntry(key, entry, 'idle_ttl');
+        }
+    });
+};
+const scheduleSweep = () => {
+    if (sweepTimer) {
+        clearInterval(sweepTimer);
+    }
+    const intervalMs = Math.max(1, Math.min(options.idleTtlMs, options.maxAgeMs, 60000));
+    sweepTimer = setInterval(() => {
+        sweep();
+    }, intervalMs);
+    sweepTimer.unref();
+};
+const createEntry = async (key, connectionString, generation, projectUuid) => {
+    const createStart = performance.now();
+    // Deliberately bypass fromCache(): mixing its unbounded singleton with this cache would create conflicting lifecycles.
+    // Revisit on @duckdb/node-api upgrades if the binding cache gains eviction bounds.
+    const instance = await node_api_1.DuckDBInstance.create(connectionString);
+    const instanceCreateMs = performance.now() - createStart;
+    if ((creationGenerations.get(key) ?? 0) !== generation) {
+        closeInstance(instance);
+        return undefined;
+    }
+    let resolveClose = () => undefined;
+    const closePromise = new Promise((resolve) => {
+        resolveClose = resolve;
+    });
+    const now = performance.now();
+    const entry = {
+        instance,
+        entryId: (0, crypto_1.randomUUID)(),
+        projectUuid,
+        createdAt: now,
+        lastUsedAt: now,
+        refCount: 1,
+        consecutiveFailures: 0,
+        draining: false,
+        closed: false,
+        closePromise,
+        resolveClose,
+    };
+    entries.set(key, entry);
+    emit({ type: 'size', entries: entries.size });
+    if (entries.size > options.maxEntries) {
+        const lru = [...entries.entries()]
+            .filter(([, candidate]) => candidate !== entry)
+            .sort(([, left], [, right]) => left.lastUsedAt - right.lastUsedAt)
+            .at(0);
+        if (lru) {
+            void unlinkEntry(lru[0], lru[1], 'lru');
+        }
+    }
+    return { entry, instanceCreateMs };
+};
+const resolveCreation = async (key, pending, result, getWaitMs, retry) => {
+    let created;
+    try {
+        created = await pending.promise;
+    }
+    finally {
+        if (pendingCreations.get(key) === pending) {
+            pendingCreations.delete(key);
+            if ((creationGenerations.get(key) ?? 0) === pending.generation) {
+                creationGenerations.delete(key);
+            }
+        }
+    }
+    if (!created || pending.invalidated) {
+        if (created && result === 'miss') {
+            created.entry.refCount -= 1;
+            closeEntry(created.entry);
+        }
+        return retry();
+    }
+    return {
+        entry: result === 'hit' ? holdEntry(created.entry) : created.entry,
+        result,
+        waitMs: getWaitMs(),
+        instanceCreateMs: result === 'miss' ? created.instanceCreateMs : 0,
+    };
+};
+const acquire = async (connectionString, projectUuid) => {
+    const waitStart = performance.now();
+    sweep();
+    const key = cacheKeyFor(connectionString);
+    const existing = entries.get(key);
+    if (existing) {
+        return {
+            entry: holdEntry(existing),
+            result: 'hit',
+            waitMs: performance.now() - waitStart,
+            instanceCreateMs: 0,
+        };
+    }
+    const pending = pendingCreations.get(key);
+    if (pending) {
+        return resolveCreation(key, pending, 'hit', () => performance.now() - waitStart, () => acquire(connectionString, projectUuid));
+    }
+    const generation = creationGenerations.get(key) ?? 0;
+    const waitMs = performance.now() - waitStart;
+    const creation = {
+        generation,
+        invalidated: false,
+        promise: createEntry(key, connectionString, generation, projectUuid),
+    };
+    pendingCreations.set(key, creation);
+    return resolveCreation(key, creation, 'miss', () => waitMs, () => acquire(connectionString, projectUuid));
+};
+const configure = (nextOptions) => {
+    options = {
+        ...nextOptions,
+        maxConsecutiveFailures: nextOptions.maxConsecutiveFailures ??
+            DEFAULT_OPTIONS.maxConsecutiveFailures,
+    };
+    scheduleSweep();
+};
+exports.configure = configure;
+const setObserver = (nextObserver) => {
+    observer = nextObserver;
+    emit({ type: 'size', entries: entries.size });
+};
+exports.setObserver = setObserver;
+const withInstance = async (connectionString, ctx, fn) => {
+    const acquisition = await acquire(connectionString, ctx.projectUuid);
+    const { entry } = acquisition;
+    const timing = {
+        waitMs: acquisition.waitMs,
+        instanceCreateMs: acquisition.instanceCreateMs,
+        connectMs: 0,
+    };
+    const observedInstance = new Proxy(entry.instance, {
+        get: (target, property) => {
+            if (property === 'connect') {
+                return async () => {
+                    const connectStart = performance.now();
+                    try {
+                        return await target.connect();
+                    }
+                    finally {
+                        timing.connectMs += performance.now() - connectStart;
+                    }
+                };
+            }
+            const value = Reflect.get(target, property, target);
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+    });
+    try {
+        const result = await fn(observedInstance, entry.entryId, timing);
+        entry.consecutiveFailures = 0;
+        return result;
+    }
+    catch (error) {
+        entry.consecutiveFailures += 1;
+        if (entry.consecutiveFailures >= options.maxConsecutiveFailures &&
+            !entry.draining) {
+            void unlinkEntry(cacheKeyFor(connectionString), entry, 'failures');
+        }
+        throw error;
+    }
+    finally {
+        entry.refCount -= 1;
+        entry.lastUsedAt = performance.now();
+        emit({
+            type: 'acquire',
+            result: acquisition.result,
+            entryId: entry.entryId,
+            projectUuid: ctx.projectUuid,
+            waitMs: timing.waitMs,
+            instanceCreateMs: timing.instanceCreateMs,
+            connectMs: timing.connectMs,
+        });
+        if (entry.draining) {
+            closeEntry(entry);
+        }
+    }
+};
+exports.withInstance = withInstance;
+const invalidate = async (entryId, reason) => {
+    const match = [...entries.entries()].find(([, entry]) => entry.entryId === entryId);
+    if (match) {
+        await unlinkEntry(match[0], match[1], reason);
+    }
+};
+exports.invalidate = invalidate;
+const invalidateByConnectionString = (connectionString, reason) => {
+    const key = cacheKeyFor(connectionString);
+    const pending = pendingCreations.get(key);
+    if (pending) {
+        pending.invalidated = true;
+        creationGenerations.set(key, (creationGenerations.get(key) ?? 0) + 1);
+    }
+    const entry = entries.get(key);
+    if (entry) {
+        void unlinkEntry(key, entry, reason);
+    }
+};
+exports.invalidateByConnectionString = invalidateByConnectionString;
+const closeAll = async (reason) => {
+    await Promise.allSettled([...pendingCreations.values()].map(({ promise }) => promise));
+    const draining = [...entries.entries()].map(([key, entry]) => unlinkEntry(key, entry, reason));
+    await Promise.all(draining);
+};
+exports.closeAll = closeAll;
+const recordRetry = (entryId, outcome) => {
+    emit({ type: 'retry', entryId, outcome });
+};
+exports.recordRetry = recordRetry;
+const resetForTesting = () => {
+    if (sweepTimer) {
+        clearInterval(sweepTimer);
+    }
+    entries.forEach((entry) => {
+        const drainingEntry = entry;
+        drainingEntry.draining = true;
+        closeEntry(drainingEntry);
+    });
+    entries.clear();
+    pendingCreations.clear();
+    creationGenerations.clear();
+    options = DEFAULT_OPTIONS;
+    observer = () => undefined;
+    scheduleSweep();
+};
+exports.resetForTesting = resetForTesting;
+exports.MotherduckInstanceCache = {
+    configure: exports.configure,
+    setObserver: exports.setObserver,
+    withInstance: exports.withInstance,
+    invalidate: exports.invalidate,
+    invalidateByConnectionString: exports.invalidateByConnectionString,
+    recordRetry: exports.recordRetry,
+    closeAll: exports.closeAll,
+    resetForTesting: exports.resetForTesting,
+};
+scheduleSweep();

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,192 @@
+"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'],
+    columnTypeId: () => 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

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

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

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