@lightdash/warehouses 1.75.1 → 1.76.1

package/dist/warehouseClients/DuckdbWarehouseClient.test.js

@@ -1,46 +1,11 @@
 "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;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@lightdash/common");
-const crypto_1 = require("crypto");
 const promises_1 = __importDefault(require("fs/promises"));
 const DuckdbWarehouseClient_1 = require("./DuckdbWarehouseClient");
-const MotherduckInstanceCache = __importStar(require("./MotherduckInstanceCache"));
 const createInstanceMock = vi.fn();
 const duckdbS3Credentials = {
     type: 'duckdb_s3',
@@ -193,12 +158,6 @@ describe('DuckdbWarehouseClient', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         DuckdbWarehouseClient_1.DuckdbWarehouseClient.resetSharedDuckdbStateForTesting();
-        MotherduckInstanceCache.resetForTesting();
-        MotherduckInstanceCache.configure({
-            idleTtlMs: 60000,
-            maxAgeMs: 60000,
-            maxEntries: 8,
-        });
     });
     it('should return query rows and mapped fields', async () => {
         const rows = [
@@ -294,272 +253,6 @@ describe('DuckdbWarehouseClient', () => {
         await client.runQuery('SELECT 1 AS val', undefined, 'Europe/London');
         expect(logger.info).toHaveBeenCalledWith(expect.stringMatching(/Europe\/London.*MotherDuck.*saas_mode.*server default zone.*configured zone/));
     });
-    describe('MotherDuck instance caching', () => {
-        const credentials = {
-            type: common_1.WarehouseTypes.DUCKDB,
-            connectionType: common_1.DuckdbConnectionType.MOTHERDUCK,
-            database: 'analytics',
-            schema: 'main',
-            token: 'token-a',
-        };
-        it('reuses an instance without issuing SET or PRAGMA statements and reports connect timing', async () => {
-            const runMock = vi.fn();
-            const streamMock = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
-            const onPhaseTiming = vi.fn();
-            const events = [];
-            MotherduckInstanceCache.setObserver((event) => events.push(event));
-            createInstanceMock.mockResolvedValue(createMockConnection(streamMock, runMock));
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-            });
-            await client.streamQuery('SELECT 1 AS val', vi.fn(), {
-                onPhaseTiming,
-            });
-            await client.streamQuery('SELECT 1 AS val', vi.fn(), {
-                onPhaseTiming,
-            });
-            expect(createInstanceMock).toHaveBeenCalledOnce();
-            expect(runMock).not.toHaveBeenCalledWith(expect.stringMatching(/^(?:SET|PRAGMA)\b/i));
-            const acquisitions = events.filter((event) => event.type === 'acquire');
-            expect(acquisitions).toHaveLength(2);
-            acquisitions.forEach((event) => {
-                expect(onPhaseTiming).toHaveBeenCalledWith('connect', event.waitMs + event.instanceCreateMs + event.connectMs);
-            });
-        });
-        it('reports instance creation and connection as direct connect timing', async () => {
-            const streamMock = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
-            const onPhaseTiming = vi.fn();
-            const performanceNow = vi
-                .spyOn(performance, 'now')
-                .mockReturnValueOnce(0)
-                .mockReturnValueOnce(10)
-                .mockReturnValueOnce(30)
-                .mockReturnValueOnce(40)
-                .mockReturnValueOnce(45)
-                .mockReturnValue(45);
-            createInstanceMock.mockResolvedValue(createMockConnection(streamMock));
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials);
-            try {
-                await client.streamQuery('SELECT 1 AS val', vi.fn(), {
-                    onPhaseTiming,
-                });
-            }
-            finally {
-                performanceNow.mockRestore();
-            }
-            expect(onPhaseTiming).toHaveBeenCalledWith('connect', 25);
-        });
-        it('falls back to direct sessions when user credentials are required', async () => {
-            const streamMock = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
-            createInstanceMock.mockImplementation(async () => createMockConnection(streamMock));
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient({ ...credentials, requireUserCredentials: true }, { enableInstanceCache: true, projectUuid: 'project-a' });
-            await client.runQuery('SELECT 1 AS val');
-            await client.runQuery('SELECT 1 AS val');
-            expect(createInstanceMock).toHaveBeenCalledTimes(2);
-        });
-        it('retries one stale failure before rows are emitted and replaces only the failed entry', async () => {
-            const events = [];
-            MotherduckInstanceCache.setObserver((event) => events.push(event));
-            const staleError = new Error('Connection Error: Connection has already been closed');
-            const firstStream = vi.fn().mockRejectedValue(staleError);
-            const recoveredStream = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
-            const firstInstance = createMockConnection(firstStream);
-            const recoveredInstance = createMockConnection(recoveredStream);
-            createInstanceMock
-                .mockResolvedValueOnce(firstInstance)
-                .mockResolvedValueOnce(recoveredInstance);
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-            });
-            await expect(client.runQuery('SELECT 1 AS val')).resolves.toEqual(expect.objectContaining({ rows: [{ val: 1 }] }));
-            expect(createInstanceMock).toHaveBeenCalledTimes(2);
-            expect(firstInstance.closeSync).toHaveBeenCalledOnce();
-            expect(events).toContainEqual(expect.objectContaining({
-                type: 'evict',
-                reason: 'stale',
-            }));
-            expect(events).toContainEqual(expect.objectContaining({
-                type: 'retry',
-                outcome: 'recovered',
-            }));
-        });
-        it('reports a failed retry and does not loop on a second stale failure', async () => {
-            const events = [];
-            MotherduckInstanceCache.setObserver((event) => events.push(event));
-            const staleError = new Error('Connection Error: Connection has already been closed');
-            const firstInstance = createMockConnection(vi.fn().mockRejectedValue(staleError));
-            const secondInstance = createMockConnection(vi.fn().mockRejectedValue(staleError));
-            createInstanceMock
-                .mockResolvedValueOnce(firstInstance)
-                .mockResolvedValueOnce(secondInstance);
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-            });
-            await expect(client.runQuery('SELECT 1 AS val')).rejects.toThrow(staleError);
-            expect(createInstanceMock).toHaveBeenCalledTimes(2);
-            expect(firstInstance.closeSync).toHaveBeenCalledOnce();
-            expect(secondInstance.closeSync).toHaveBeenCalledOnce();
-            expect(events).toContainEqual(expect.objectContaining({
-                type: 'retry',
-                outcome: 'failed',
-            }));
-        });
-        it('does not retry a stale failure after rows reached the consumer', async () => {
-            const events = [];
-            MotherduckInstanceCache.setObserver((event) => events.push(event));
-            const staleError = new Error('Invalid Input Error: Cannot execute statement of closed connection');
-            const streamMock = vi.fn(async () => {
-                let hasYielded = false;
-                const iterator = {
-                    next: async () => {
-                        if (!hasYielded) {
-                            hasYielded = true;
-                            return { done: false, value: [{ val: 1 }] };
-                        }
-                        throw staleError;
-                    },
-                    [Symbol.asyncIterator]() {
-                        return this;
-                    },
-                };
-                return {
-                    columnCount: 1,
-                    columnNames: () => ['val'],
-                    columnTypeId: () => DUCKDB_TYPE_IDS.INTEGER,
-                    yieldRowObjectJson: () => iterator,
-                };
-            });
-            const instance = createMockConnection(streamMock);
-            createInstanceMock.mockResolvedValue(instance);
-            const streamCallback = vi.fn();
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-            });
-            await expect(client.streamQuery('SELECT 1 AS val', streamCallback)).rejects.toThrow(staleError);
-            expect(streamCallback).toHaveBeenCalledOnce();
-            expect(createInstanceMock).toHaveBeenCalledOnce();
-            expect(instance.closeSync).toHaveBeenCalledOnce();
-            expect(events).toContainEqual(expect.objectContaining({
-                type: 'evict',
-                reason: 'stale',
-            }));
-            expect(events).not.toContainEqual(expect.objectContaining({ type: 'retry' }));
-        });
-        it('invalidates authentication failures without retrying', async () => {
-            const events = [];
-            MotherduckInstanceCache.setObserver((event) => events.push(event));
-            const authError = new Error('Invalid Input Error: MD Authentication Error: Invalid token');
-            const streamMock = vi.fn().mockRejectedValue(authError);
-            const instance = createMockConnection(streamMock);
-            createInstanceMock.mockResolvedValue(instance);
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-            });
-            await expect(client.runQuery('SELECT 1 AS val')).rejects.toThrow(authError);
-            expect(createInstanceMock).toHaveBeenCalledOnce();
-            expect(instance.closeSync).toHaveBeenCalledOnce();
-            expect(events).toContainEqual(expect.objectContaining({
-                type: 'evict',
-                reason: 'auth',
-            }));
-            expect(events).not.toContainEqual(expect.objectContaining({ type: 'retry' }));
-        });
-        it('never includes the cache digest in cached-instance log lines or metadata', async () => {
-            const streamMock = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));
-            const logger = { info: vi.fn() };
-            createInstanceMock.mockResolvedValue(createMockConnection(streamMock));
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(credentials, {
-                enableInstanceCache: true,
-                projectUuid: 'project-a',
-                logger,
-            });
-            await client.runQuery('SELECT 1 AS val');
-            const connectionString = createInstanceMock.mock.calls[0][0];
-            if (typeof connectionString !== 'string') {
-                throw new Error('Expected a MotherDuck connection string');
-            }
-            const digest = (0, crypto_1.createHash)('sha256')
-                .update(JSON.stringify({ connectionString, v: 1 }))
-                .digest('hex');
-            expect(JSON.stringify(logger.info.mock.calls)).not.toContain(digest);
-        });
-    });
-    describe('session strategy routing', () => {
-        const createSuccessfulInstance = () => createMockConnection(vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER])), vi.fn());
-        it('keeps embedded playground databases on direct read-only sessions', async () => {
-            createInstanceMock.mockResolvedValue(createSuccessfulInstance());
-            const onPhaseTiming = vi.fn();
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient({
-                type: common_1.WarehouseTypes.DUCKDB,
-                connectionType: common_1.DuckdbConnectionType.EMBEDDED,
-                dataset: 'jaffle_shop',
-            });
-            await client.streamQuery('SELECT 1 AS val', vi.fn(), {
-                onPhaseTiming,
-            });
-            expect(createInstanceMock).toHaveBeenCalledWith(expect.stringContaining('jaffle_shop.duckdb'), expect.objectContaining({ access_mode: 'READ_ONLY' }));
-            expect(onPhaseTiming).toHaveBeenCalledWith('connect', expect.any(Number));
-        });
-        it('routes resource-limited in-memory clients to isolated sessions', async () => {
-            createInstanceMock.mockResolvedValue(createSuccessfulInstance());
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(undefined, {
-                resourceLimits: { memoryLimit: '64MB', threads: 1 },
-            });
-            await client.runQuery('SELECT 1 AS val');
-            await client.runQuery('SELECT 1 AS val');
-            expect(createInstanceMock).toHaveBeenCalledTimes(2);
-            expect(createInstanceMock).toHaveBeenNthCalledWith(1, ':memory:');
-            expect(createInstanceMock).toHaveBeenNthCalledWith(2, ':memory:');
-        });
-        it('routes explicit cache keys to shared sessions', async () => {
-            createInstanceMock.mockResolvedValue(createSuccessfulInstance());
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient(undefined, {
-                instanceCacheKey: 'routing-shared-instance',
-            });
-            await client.runQuery('SELECT 1 AS val');
-            await client.runQuery('SELECT 1 AS val');
-            expect(createInstanceMock).toHaveBeenCalledExactlyOnceWith(':memory:');
-        });
-        it('keeps DuckLake on its existing shared session strategy', async () => {
-            createInstanceMock.mockResolvedValue(createSuccessfulInstance());
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient({
-                type: common_1.WarehouseTypes.DUCKDB,
-                connectionType: common_1.DuckdbConnectionType.DUCKLAKE,
-                schema: 'main',
-                catalogAlias: 'ducklake',
-                catalog: {
-                    type: common_1.DucklakeCatalogType.POSTGRES,
-                    host: 'pg.example.com',
-                    port: 5432,
-                    database: 'catalog',
-                    user: 'ducklake_user',
-                    password: 'password',
-                },
-                dataPath: {
-                    type: common_1.DucklakeDataPathType.S3,
-                    url: 's3://bucket/path/',
-                    region: 'us-east-1',
-                },
-            });
-            await client.runQuery('SELECT 1 AS val');
-            await client.runQuery('SELECT 1 AS val');
-            expect(createInstanceMock).toHaveBeenCalledExactlyOnceWith(':memory:');
-        });
-        it('keeps default in-memory clients on ephemeral sessions', async () => {
-            createInstanceMock.mockResolvedValue(createSuccessfulInstance());
-            const client = new DuckdbWarehouseClient_1.DuckdbWarehouseClient();
-            await client.runQuery('SELECT 1 AS val');
-            await client.runQuery('SELECT 1 AS val');
-            expect(createInstanceMock).toHaveBeenCalledTimes(2);
-            expect(createInstanceMock).toHaveBeenNthCalledWith(1, ':memory:');
-            expect(createInstanceMock).toHaveBeenNthCalledWith(2, ':memory:');
-        });
-    });
     it('sets timezone for in-memory and embedded DuckDB queries', async () => {
         const runMock = vi.fn();
         const streamMock = vi.fn(async () => getMockStreamResult([[{ val: 1 }]], [DUCKDB_TYPE_IDS.INTEGER]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/warehouses",
-  "version": "1.75.1",
+  "version": "1.76.1",
   "description": "Warehouse connectors for Lightdash",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,7 @@
     "snowflake-sdk": "2.3.4",
     "ssh2": "1.14.0",
     "trino-client": "0.2.9",
-    "@lightdash/common": "1.75.1"
+    "@lightdash/common": "1.76.1"
   },
   "devDependencies": {
     "@types/big.js": "6.2.2",

package/dist/warehouseClients/MotherduckErrorClassifier.d.ts

@@ -1,3 +0,0 @@
-export type MotherduckErrorClass = 'auth' | 'stale' | 'other';
-export declare const classifyMotherduckError: (error: unknown) => MotherduckErrorClass;
-//# sourceMappingURL=MotherduckErrorClassifier.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"MotherduckErrorClassifier.d.ts","sourceRoot":"","sources":["../../src/warehouseClients/MotherduckErrorClassifier.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAuB9D,eAAO,MAAM,uBAAuB,UACzB,OAAO,KACf,oBASF,CAAC"}

package/dist/warehouseClients/MotherduckErrorClassifier.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classifyMotherduckError = void 0;
-const common_1 = require("@lightdash/common");
-const AUTH_ERROR_PATTERNS = [
-    /authentication failed/i,
-    /authentication error.*invalid token/i,
-    /invalid motherduck token/i,
-    /motherduck token.*(?:expired|invalid|rejected)/i,
-    /not authenticated/i,
-    /check your motherduck token/i,
-    /unauthorized/i,
-    /permission_denied/i,
-    /could not connect to motherduck/i,
-];
-const STALE_ERROR_PATTERNS = [
-    /connection.*(?:already )?closed/i,
-    /closed.*connection/i,
-    /database.*detached/i,
-    /detached.*database/i,
-    /instance.*closed/i,
-    /invalidated.*database/i,
-];
-const classifyMotherduckError = (error) => {
-    const message = (0, common_1.getErrorMessage)(error);
-    if (AUTH_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
-        return 'auth';
-    }
-    if (STALE_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
-        return 'stale';
-    }
-    return 'other';
-};
-exports.classifyMotherduckError = classifyMotherduckError;

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.d.ts

@@ -1,58 +0,0 @@
-import { DuckDBInstance } from '@duckdb/node-api';
-export type DuckdbInstance = Awaited<ReturnType<typeof DuckDBInstance.create>>;
-export type EvictionReason = 'idle_ttl' | 'max_age' | 'lru' | 'stale' | 'auth' | 'failures' | 'credentials_updated' | 'shutdown';
-export type MotherduckCacheEvent = {
-    type: 'acquire';
-    result: 'hit' | 'miss';
-    entryId: string;
-    projectUuid?: string;
-    waitMs: number;
-    instanceCreateMs: number;
-    connectMs: number;
-} | {
-    type: 'evict';
-    entryId: string;
-    projectUuid?: string;
-    reason: EvictionReason;
-    ageMs: number;
-} | {
-    type: 'retry';
-    entryId: string;
-    outcome: 'recovered' | 'failed';
-} | {
-    type: 'size';
-    entries: number;
-};
-type CacheOptions = {
-    idleTtlMs: number;
-    maxAgeMs: number;
-    maxEntries: number;
-    maxConsecutiveFailures?: number;
-};
-export type MotherduckCacheAcquisitionTiming = {
-    waitMs: number;
-    instanceCreateMs: number;
-    connectMs: number;
-};
-export declare const configure: (nextOptions: CacheOptions) => void;
-export declare const setObserver: (nextObserver: (event: MotherduckCacheEvent) => void) => void;
-export declare const withInstance: <T>(connectionString: string, ctx: {
-    projectUuid?: string;
-}, fn: (instance: DuckdbInstance, entryId: string, timing: MotherduckCacheAcquisitionTiming) => Promise<T>) => Promise<T>;
-export declare const invalidate: (entryId: string, reason: EvictionReason) => Promise<void>;
-export declare const invalidateByConnectionString: (connectionString: string, reason: EvictionReason) => void;
-export declare const closeAll: (reason: EvictionReason) => Promise<void>;
-export declare const recordRetry: (entryId: string, outcome: 'recovered' | 'failed') => void;
-export declare const resetForTesting: () => void;
-export declare const MotherduckInstanceCache: {
-    configure: typeof configure;
-    setObserver: typeof setObserver;
-    withInstance: typeof withInstance;
-    invalidate: typeof invalidate;
-    invalidateByConnectionString: typeof invalidateByConnectionString;
-    recordRetry: typeof recordRetry;
-    closeAll: typeof closeAll;
-    resetForTesting: typeof resetForTesting;
-};
-export {};
-//# sourceMappingURL=MotherduckInstanceCache.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"MotherduckInstanceCache.d.ts","sourceRoot":"","sources":["../../src/warehouseClients/MotherduckInstanceCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;AAE/E,MAAM,MAAM,cAAc,GACpB,UAAU,GACV,SAAS,GACT,KAAK,GACL,OAAO,GACP,MAAM,GACN,UAAU,GACV,qBAAqB,GACrB,UAAU,CAAC;AAEjB,MAAM,MAAM,oBAAoB,GAC1B;IACI,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACrB,GACD;IACI,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACjB,GACD;IACI,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,KAAK,YAAY,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAkRF,eAAO,MAAM,SAAS,gBAAiB,YAAY,KAAG,IAQrD,CAAC;AAEF,eAAO,MAAM,WAAW,iBACN,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,KACpD,IAGF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,CAAC,oBACd,MAAM,OACnB;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,MACzB,CACA,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gCAAgC,KACvC,OAAO,CAAC,CAAC,CAAC,KAChB,OAAO,CAAC,CAAC,CAsDX,CAAC;AAEF,eAAO,MAAM,UAAU,YACV,MAAM,UACP,cAAc,KACvB,OAAO,CAAC,IAAI,CAOd,CAAC;AAEF,eAAO,MAAM,4BAA4B,qBACnB,MAAM,UAChB,cAAc,KACvB,IAWF,CAAC;AAEF,eAAO,MAAM,QAAQ,WAAkB,cAAc,KAAG,OAAO,CAAC,IAAI,CAQnE,CAAC;AAEF,eAAO,MAAM,WAAW,YACX,MAAM,WACN,WAAW,GAAG,QAAQ,KAChC,IAEF,CAAC;AAEF,eAAO,MAAM,eAAe,QAAO,IAelC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;CASnC,CAAC"}

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":""}