@kaelio/ktx 0.5.0 → 0.7.0

package/dist/connectors/snowflake/connector.test.js

@@ -1,462 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-const createPool = vi.hoisted(() => vi.fn());
-vi.mock('snowflake-sdk', () => ({
-    default: { createPool },
-    createPool,
-}));
-import { createSnowflakeLiveDatabaseIntrospection } from '../../connectors/snowflake/live-database-introspection.js';
-import { isKtxSnowflakeConnectionConfig, KtxSnowflakeScanConnector, snowflakeConnectionConfigFromConfig } from '../../connectors/snowflake/connector.js';
-import { tableRefSet } from '../../context/scan/table-ref.js';
-function fakeDriverFactory() {
-    const driver = {
-        test: vi.fn(async () => ({ success: true })),
-        query: vi.fn(async (sql) => {
-            if (sql.includes('TABLE_CONSTRAINTS')) {
-                return { headers: ['TABLE_NAME', 'COLUMN_NAME'], rows: [['ORDERS', 'ID']], totalRows: 1, rowCount: 1 };
-            }
-            if (sql.includes('SELECT "ID", "STATUS" FROM "ANALYTICS"."PUBLIC"."ORDERS"')) {
-                return {
-                    headers: ['ID', 'STATUS'],
-                    headerTypes: ['NUMBER', 'VARCHAR'],
-                    rows: [[1, 'paid']],
-                    totalRows: 1,
-                    rowCount: 1,
-                };
-            }
-            if (sql.includes('select * from (select ID, STATUS from ORDERS) as ktx_query_result limit 1')) {
-                return { headers: ['ID', 'STATUS'], rows: [[1, 'paid']], totalRows: 1, rowCount: 1 };
-            }
-            if (sql.includes('SELECT "STATUS" FROM "ANALYTICS"."PUBLIC"."ORDERS"')) {
-                return { headers: ['STATUS'], rows: [['paid'], ['open']], totalRows: 2, rowCount: 2 };
-            }
-            if (sql.includes('COUNT(DISTINCT val)')) {
-                return { headers: ['CARDINALITY'], rows: [[2]], totalRows: 1, rowCount: 1 };
-            }
-            if (sql.includes('SELECT DISTINCT "STATUS"::VARCHAR AS val')) {
-                return { headers: ['VAL'], rows: [['open'], ['paid']], totalRows: 2, rowCount: 2 };
-            }
-            throw new Error(`Unexpected SQL: ${sql}`);
-        }),
-        getSchemaMetadata: vi.fn(async () => [
-            {
-                name: 'ORDERS',
-                catalog: 'ANALYTICS',
-                db: 'PUBLIC',
-                rowCount: 12,
-                comment: 'Orders',
-                columns: [
-                    { name: 'ID', type: 'NUMBER(38,0)', nullable: false, comment: 'Primary key' },
-                    { name: 'STATUS', type: 'VARCHAR', nullable: true, comment: null },
-                ],
-            },
-            {
-                name: 'ORDER_SUMMARY',
-                catalog: 'ANALYTICS',
-                db: 'PUBLIC',
-                rowCount: 3,
-                comment: null,
-                columns: [{ name: 'STATUS', type: 'VARCHAR', nullable: true, comment: null }],
-            },
-        ]),
-        listSchemas: vi.fn(async () => ['PUBLIC', 'MART']),
-        listTables: vi.fn(async () => [
-            { schema: 'PUBLIC', name: 'ORDERS', kind: 'table' },
-            { schema: 'PUBLIC', name: 'ORDER_SUMMARY', kind: 'view' },
-        ]),
-        cleanup: vi.fn(async () => undefined),
-    };
-    return { createDriver: vi.fn(() => driver) };
-}
-function fakeSnowflakeStatement(headers = ['ONE']) {
-    return {
-        getColumns: () => headers.map((header) => ({ getName: () => header, getType: () => 'TEXT' })),
-    };
-}
-function installSnowflakePoolMock() {
-    const executedSql = [];
-    const connection = {
-        execute: vi.fn((input) => {
-            executedSql.push(input.sqlText);
-            input.complete(null, fakeSnowflakeStatement(), [{ ONE: 1 }]);
-        }),
-    };
-    const pool = {
-        use: vi.fn(async (fn) => fn(connection)),
-        drain: vi.fn(async () => undefined),
-        clear: vi.fn(async () => undefined),
-    };
-    createPool.mockReturnValue(pool);
-    return { connection, pool, executedSql };
-}
-describe('KtxSnowflakeScanConnector', () => {
-    it('resolves Snowflake connection configuration safely', () => {
-        expect(isKtxSnowflakeConnectionConfig({
-            driver: 'snowflake',
-            account: 'acct',
-            warehouse: 'WH',
-            database: 'ANALYTICS',
-            username: 'reader',
-        })).toBe(true);
-        expect(isKtxSnowflakeConnectionConfig({ driver: 'bigquery' })).toBe(false);
-        expect(snowflakeConnectionConfigFromConfig({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-        })).toMatchObject({
-            account: 'acct',
-            warehouse: 'WH',
-            database: 'ANALYTICS',
-            schemas: ['PUBLIC'],
-            username: 'reader',
-            authMethod: 'password',
-        });
-    });
-    it('defaults and validates Snowflake maxSessions', () => {
-        const baseConnection = {
-            driver: 'snowflake',
-            authMethod: 'password',
-            account: 'acct',
-            warehouse: 'WH',
-            database: 'ANALYTICS',
-            schema_name: 'PUBLIC',
-            username: 'reader',
-            password: 'fixture-pass', // pragma: allowlist secret
-        };
-        expect(snowflakeConnectionConfigFromConfig({
-            connectionId: 'warehouse',
-            connection: baseConnection,
-        })).toMatchObject({ maxSessions: 4 });
-        expect(snowflakeConnectionConfigFromConfig({
-            connectionId: 'warehouse',
-            connection: { ...baseConnection, maxSessions: 8 },
-        })).toMatchObject({ maxSessions: 8 });
-        for (const maxSessions of [0, -1, 1.5, Number.NaN]) {
-            expect(() => snowflakeConnectionConfigFromConfig({
-                connectionId: 'warehouse',
-                connection: { ...baseConnection, maxSessions },
-            })).toThrow('connections.warehouse.maxSessions must be a positive integer');
-        }
-    });
-    it('uses one lazy Snowflake pool and drains it during cleanup', async () => {
-        const { pool, executedSql } = installSnowflakePoolMock();
-        const close = vi.fn(async () => undefined);
-        const connector = new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-                role: 'ANALYST',
-                maxSessions: 3,
-            },
-            sdkOptionsProvider: {
-                resolve: vi.fn(async () => ({ sdkOptions: { application: 'ktx-test' }, close })),
-            },
-        });
-        expect(createPool).not.toHaveBeenCalled();
-        await connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select 1', maxRows: 1 }, { runId: 'run-1' });
-        await connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select 1', maxRows: 1 }, { runId: 'run-1' });
-        expect(createPool).toHaveBeenCalledTimes(1);
-        expect(createPool).toHaveBeenCalledWith(expect.objectContaining({
-            account: 'acct',
-            username: 'reader',
-            warehouse: 'WH',
-            database: 'ANALYTICS',
-            schema: 'PUBLIC',
-            role: 'ANALYST',
-            password: 'fixture-pass', // pragma: allowlist secret
-            clientSessionKeepAlive: true,
-            clientSessionKeepAliveHeartbeatFrequency: 900,
-            application: 'ktx-test',
-        }), expect.objectContaining({
-            min: 0,
-            max: 3,
-            evictionRunIntervalMillis: 30_000,
-            acquireTimeoutMillis: 60_000,
-        }));
-        expect(pool.use).toHaveBeenCalledTimes(2);
-        expect(executedSql.some((sql) => /^USE\s+/i.test(sql.trim()))).toBe(false);
-        await connector.cleanup();
-        expect(pool.drain).toHaveBeenCalledBefore(pool.clear);
-        expect(pool.clear).toHaveBeenCalledTimes(1);
-        expect(close).toHaveBeenCalledTimes(1);
-    });
-    it('introspects schema, primary keys, comments, row counts, and dimensions', async () => {
-        const connector = new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-            driverFactory: fakeDriverFactory(),
-            now: () => new Date('2026-04-29T18:00:00.000Z'),
-        });
-        const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'snowflake' }, { runId: 'scan-run-1' });
-        expect(snapshot).toMatchObject({
-            connectionId: 'warehouse',
-            driver: 'snowflake',
-            extractedAt: '2026-04-29T18:00:00.000Z',
-            scope: { catalogs: ['ANALYTICS'], schemas: ['PUBLIC'] },
-            metadata: {
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schemas: ['PUBLIC'],
-                table_count: 2,
-                total_columns: 3,
-            },
-        });
-        expect(snapshot.tables.find((table) => table.name === 'ORDERS')?.columns).toEqual([
-            {
-                name: 'ID',
-                nativeType: 'NUMBER(38,0)',
-                normalizedType: 'NUMBER(38,0)',
-                dimensionType: 'number',
-                nullable: false,
-                primaryKey: true,
-                comment: 'Primary key',
-            },
-            {
-                name: 'STATUS',
-                nativeType: 'VARCHAR',
-                normalizedType: 'VARCHAR',
-                dimensionType: 'string',
-                nullable: true,
-                primaryKey: false,
-                comment: null,
-            },
-        ]);
-    });
-    it('continues introspection when primary-key discovery is not authorized', async () => {
-        const driverFactory = fakeDriverFactory();
-        const driver = driverFactory.createDriver.getMockImplementation();
-        if (!driver)
-            throw new Error('driver mock missing');
-        const built = driver();
-        built.query.mockImplementation(async (sql) => {
-            if (sql.includes('TABLE_CONSTRAINTS')) {
-                throw new Error("SQL compilation error: Object 'ANALYTICS.INFORMATION_SCHEMA.KEY_COLUMN_USAGE' does not exist or not authorized.");
-            }
-            throw new Error(`Unexpected SQL: ${sql}`);
-        });
-        driverFactory.createDriver.mockReturnValue(built);
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-        try {
-            const connector = new KtxSnowflakeScanConnector({
-                connectionId: 'warehouse',
-                connection: {
-                    driver: 'snowflake',
-                    authMethod: 'password',
-                    account: 'acct',
-                    warehouse: 'WH',
-                    database: 'ANALYTICS',
-                    schema_name: 'PUBLIC',
-                    username: 'reader',
-                    password: 'fixture-pass', // pragma: allowlist secret
-                },
-                driverFactory,
-            });
-            const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'snowflake' }, { runId: 'scan-run-pk-skip' });
-            expect(snapshot.tables.map((table) => table.name).sort()).toEqual(['ORDERS', 'ORDER_SUMMARY']);
-            expect(snapshot.tables.every((table) => table.columns.every((column) => column.primaryKey === false))).toBe(true);
-            expect(warn).not.toHaveBeenCalled();
-        }
-        finally {
-            warn.mockRestore();
-        }
-    });
-    it('limits introspection to tables in tableScope', async () => {
-        const queries = [];
-        const getSchemaMetadata = vi.fn(async (_schemaName, scopedNames) => scopedNames?.includes('ORDERS')
-            ? [
-                {
-                    name: 'ORDERS',
-                    catalog: 'ANALYTICS',
-                    db: 'MARTS',
-                    rowCount: 10,
-                    comment: null,
-                    columns: [{ name: 'ID', type: 'NUMBER', nullable: false, comment: null }],
-                },
-            ]
-            : []);
-        const driverFactory = {
-            createDriver: vi.fn(() => ({
-                test: vi.fn(async () => ({ success: true })),
-                query: vi.fn(async (sql, params) => {
-                    queries.push({ sql, params });
-                    return { headers: [], rows: [], totalRows: 0, rowCount: 0 };
-                }),
-                getSchemaMetadata,
-                listSchemas: vi.fn(async () => []),
-                listTables: vi.fn(async () => []),
-                cleanup: vi.fn(async () => undefined),
-            })),
-        };
-        const connector = new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'MARTS',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-            driverFactory,
-        });
-        const scope = tableRefSet([{ catalog: 'ANALYTICS', db: 'MARTS', name: 'ORDERS' }]);
-        const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'snowflake', tableScope: scope }, { runId: 'scope-test' });
-        expect(snapshot.tables.map((table) => table.name)).toEqual(['ORDERS']);
-        expect(getSchemaMetadata).toHaveBeenCalledWith('MARTS', ['ORDERS']);
-        const primaryKeysQuery = queries.find((query) => query.sql.includes('TABLE_CONSTRAINTS'));
-        expect(primaryKeysQuery?.sql).toMatch(/AND tc\.TABLE_NAME IN \(\?\)/);
-        expect(primaryKeysQuery?.params).toEqual(['MARTS', 'ANALYTICS', 'ORDERS']);
-    });
-    it('supports read-only query, sampling, distinct values, row counts, schema listing, and cleanup', async () => {
-        const driverFactory = fakeDriverFactory();
-        const connector = new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-            driverFactory,
-        });
-        await expect(connector.sampleTable({
-            connectionId: 'warehouse',
-            table: { catalog: 'ANALYTICS', db: 'PUBLIC', name: 'ORDERS' },
-            limit: 1,
-            columns: ['ID', 'STATUS'],
-        }, { runId: 'scan-run-1' })).resolves.toMatchObject({ headers: ['ID', 'STATUS'], rows: [[1, 'paid']], totalRows: 1 });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select ID, STATUS from ORDERS', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ headers: ['ID', 'STATUS'], rows: [[1, 'paid']], rowCount: 1 });
-        await expect(connector.sampleColumn({
-            connectionId: 'warehouse',
-            table: { catalog: 'ANALYTICS', db: 'PUBLIC', name: 'ORDERS' },
-            column: 'STATUS',
-            limit: 2,
-        }, { runId: 'scan-run-1' })).resolves.toEqual({ values: ['paid', 'open'], nullCount: null, distinctCount: null });
-        await expect(connector.getColumnDistinctValues({ catalog: 'ANALYTICS', db: 'PUBLIC', name: 'ORDERS' }, 'STATUS', {
-            maxCardinality: 10,
-            limit: 5,
-        })).resolves.toEqual({ values: ['open', 'paid'], cardinality: 2 });
-        await expect(connector.getTableRowCount('ORDERS')).resolves.toBe(12);
-        await expect(connector.listSchemas()).resolves.toEqual(['PUBLIC', 'MART']);
-        await connector.cleanup();
-        const driver = driverFactory.createDriver.mock.results[0]?.value;
-        expect(driver.cleanup).toHaveBeenCalledTimes(1);
-    });
-    it('lists tables across schemas with one information schema query', async () => {
-        const queries = [];
-        const driverFactory = {
-            createDriver: vi.fn(() => ({
-                test: vi.fn(async () => ({ success: true })),
-                query: vi.fn(async (sql, params) => {
-                    queries.push({ sql, params });
-                    return {
-                        headers: ['TABLE_SCHEMA', 'TABLE_NAME', 'TABLE_TYPE'],
-                        rows: [
-                            ['MART', 'ORDERS', 'BASE TABLE'],
-                            ['PUBLIC', 'ORDER_SUMMARY', 'VIEW'],
-                        ],
-                        totalRows: 2,
-                        rowCount: 2,
-                    };
-                }),
-                getSchemaMetadata: vi.fn(async () => []),
-                listSchemas: vi.fn(async () => []),
-                listTables: vi.fn(async () => []),
-                cleanup: vi.fn(async () => undefined),
-            })),
-        };
-        const connector = new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-            driverFactory,
-        });
-        await expect(connector.listTables(['MART', 'PUBLIC'])).resolves.toEqual([
-            { schema: 'MART', name: 'ORDERS', kind: 'table' },
-            { schema: 'PUBLIC', name: 'ORDER_SUMMARY', kind: 'view' },
-        ]);
-        expect(queries).toHaveLength(1);
-        expect(queries[0]?.sql).toContain('FROM "ANALYTICS".INFORMATION_SCHEMA.TABLES');
-        expect(queries[0]?.sql).toContain('AND TABLE_SCHEMA IN (?, ?)');
-        expect(queries[0]?.params).toEqual(['ANALYTICS', 'MART', 'PUBLIC']);
-    });
-    it('rejects unsafe Snowflake identifiers before driver creation', () => {
-        expect(() => new KtxSnowflakeScanConnector({
-            connectionId: 'warehouse',
-            connection: {
-                driver: 'snowflake',
-                authMethod: 'password',
-                account: 'acct',
-                warehouse: 'WH;DROP',
-                database: 'ANALYTICS',
-                schema_name: 'PUBLIC',
-                username: 'reader',
-                password: 'fixture-pass', // pragma: allowlist secret
-            },
-            driverFactory: fakeDriverFactory(),
-        })).toThrow('Invalid Snowflake warehouse identifier "WH;DROP"');
-    });
-    it('converts a native snapshot into a live-database introspection snapshot', async () => {
-        const introspection = createSnowflakeLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'snowflake',
-                    authMethod: 'password',
-                    account: 'acct',
-                    warehouse: 'WH',
-                    database: 'ANALYTICS',
-                    schema_name: 'PUBLIC',
-                    username: 'reader',
-                    password: 'fixture-pass', // pragma: allowlist secret
-                },
-            },
-            driverFactory: fakeDriverFactory(),
-            now: () => new Date('2026-04-29T18:00:00.000Z'),
-        });
-        await expect(introspection.extractSchema('warehouse')).resolves.toMatchObject({
-            connectionId: 'warehouse',
-            metadata: { database: 'ANALYTICS', schemas: ['PUBLIC'] },
-            tables: expect.arrayContaining([
-                expect.objectContaining({ catalog: 'ANALYTICS', db: 'PUBLIC', name: 'ORDERS' }),
-            ]),
-        });
-    });
-});

package/dist/connectors/snowflake/dialect.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/connectors/snowflake/dialect.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { KtxSnowflakeDialect } from './dialect.js';
-describe('KtxSnowflakeDialect', () => {
-    const dialect = new KtxSnowflakeDialect();
-    it('quotes identifiers and formats database.schema.table names', () => {
-        expect(dialect.quoteIdentifier('order"items')).toBe('"order""items"');
-        expect(dialect.formatTableName({ catalog: 'ANALYTICS', db: 'PUBLIC', name: 'ORDERS' })).toBe('"ANALYTICS"."PUBLIC"."ORDERS"');
-        expect(dialect.formatTableName({ db: 'PUBLIC', name: 'ORDERS' })).toBe('"PUBLIC"."ORDERS"');
-        expect(dialect.formatTableName({ name: 'ORDERS' })).toBe('"ORDERS"');
-    });
-    it('maps native Snowflake types to scan dimensions', () => {
-        expect(dialect.mapDataType('NUMBER(38,0)')).toBe('NUMBER(38,0)');
-        expect(dialect.mapToDimensionType('TIMESTAMP_NTZ')).toBe('time');
-        expect(dialect.mapToDimensionType('NUMBER(38,0)')).toBe('number');
-        expect(dialect.mapToDimensionType('BOOLEAN')).toBe('boolean');
-        expect(dialect.mapToDimensionType('VARIANT')).toBe('string');
-    });
-    it('generates sampling and dictionary SQL', () => {
-        expect(dialect.generateSampleQuery('"PUBLIC"."ORDERS"', 5, ['ID', 'STATUS'])).toBe('SELECT "ID", "STATUS" FROM "PUBLIC"."ORDERS" SAMPLE ROW (5 ROWS)');
-        expect(dialect.generateColumnSampleQuery('"PUBLIC"."ORDERS"', 'STATUS', 10)).toBe('SELECT "STATUS" FROM "PUBLIC"."ORDERS" WHERE "STATUS" IS NOT NULL AND TRIM(CAST("STATUS" AS STRING)) != \'\' LIMIT 10');
-        expect(dialect.generateCardinalitySampleQuery('"PUBLIC"."ORDERS"', '"STATUS"', 100)).toContain('SELECT COUNT(DISTINCT val) AS cardinality');
-        expect(dialect.generateDistinctValuesQuery('"PUBLIC"."ORDERS"', '"STATUS"', 20)).toContain('SELECT DISTINCT "STATUS"::VARCHAR AS val');
-    });
-    it('passes Snowflake positional parameters as bind arrays', () => {
-        expect(dialect.prepareQuery('SELECT * FROM ORDERS WHERE ID = ? AND STATUS = ?', { id: 1, status: 'paid' })).toEqual({
-            sql: 'SELECT * FROM ORDERS WHERE ID = ? AND STATUS = ?',
-            params: [1, 'paid'],
-        });
-        expect(dialect.prepareQuery('SELECT * FROM ORDERS')).toEqual({ sql: 'SELECT * FROM ORDERS', params: undefined });
-    });
-    it('keeps unsupported statistics explicit', () => {
-        expect(dialect.generateColumnStatisticsQuery('PUBLIC', 'ORDERS')).toBeNull();
-    });
-});

package/dist/connectors/snowflake/identifiers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/connectors/snowflake/identifiers.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { assertSafeSnowflakeIdentifier, quoteSnowflakeIdentifier } from './identifiers.js';
-describe('Snowflake identifier guards', () => {
-    it('quotes simple Snowflake identifiers', () => {
-        expect(quoteSnowflakeIdentifier('ANALYTICS_DB', 'database')).toBe('"ANALYTICS_DB"');
-        expect(quoteSnowflakeIdentifier('ROLE_1$', 'role')).toBe('"ROLE_1$"');
-    });
-    it('rejects configured identifiers with field and value in the error', () => {
-        expect(() => assertSafeSnowflakeIdentifier('bad.db', 'database')).toThrow('Invalid Snowflake database identifier "bad.db"; use a simple unquoted identifier matching /^[A-Za-z_][A-Za-z0-9_$]*$/');
-        expect(() => assertSafeSnowflakeIdentifier('WH"DROP', 'warehouse')).toThrow('Invalid Snowflake warehouse identifier "WH\\"DROP"; use a simple unquoted identifier matching /^[A-Za-z_][A-Za-z0-9_$]*$/');
-    });
-});

package/dist/connectors/snowflake/sdk-logger.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/connectors/snowflake/sdk-logger.test.js

@@ -1,47 +0,0 @@
-import { mkdtempSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const { configure } = vi.hoisted(() => ({ configure: vi.fn() }));
-vi.mock('snowflake-sdk', () => ({
-    default: { configure },
-}));
-import { configureSnowflakeSdkLogger, resetSnowflakeSdkLoggerConfigurationForTests, } from './sdk-logger.js';
-describe('configureSnowflakeSdkLogger', () => {
-    let projectDir;
-    beforeEach(() => {
-        configure.mockReset();
-        resetSnowflakeSdkLoggerConfigurationForTests();
-        projectDir = mkdtempSync(join(tmpdir(), 'ktx-snowflake-logger-'));
-    });
-    afterEach(() => {
-        rmSync(projectDir, { recursive: true, force: true });
-    });
-    it('routes logs to <projectDir>/.ktx/logs/snowflake.log with console output disabled', () => {
-        const expected = resolve(projectDir, '.ktx', 'logs', 'snowflake.log');
-        const returned = configureSnowflakeSdkLogger(projectDir);
-        expect(returned).toBe(expected);
-        expect(configure).toHaveBeenCalledTimes(1);
-        expect(configure).toHaveBeenCalledWith({
-            logFilePath: expected,
-            additionalLogToConsole: false,
-        });
-        expect(statSync(resolve(projectDir, '.ktx', 'logs')).isDirectory()).toBe(true);
-    });
-    it('is idempotent for the same projectDir', () => {
-        configureSnowflakeSdkLogger(projectDir);
-        configureSnowflakeSdkLogger(projectDir);
-        expect(configure).toHaveBeenCalledTimes(1);
-    });
-    it('reconfigures when projectDir changes', () => {
-        const other = mkdtempSync(join(tmpdir(), 'ktx-snowflake-logger-other-'));
-        try {
-            configureSnowflakeSdkLogger(projectDir);
-            configureSnowflakeSdkLogger(other);
-            expect(configure).toHaveBeenCalledTimes(2);
-        }
-        finally {
-            rmSync(other, { recursive: true, force: true });
-        }
-    });
-});

package/dist/connectors/sqlite/connector.test.d.ts

@@ -1 +0,0 @@
-export {};