@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/agent/agent-runner.service.test.js

@@ -1,308 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-vi.mock('ai', () => ({
-    generateText: vi.fn(),
-    stepCountIs: (n) => n,
-    tool: (def) => def,
-}));
-import { generateText } from 'ai';
-import { AgentRunnerService } from './agent-runner.service.js';
-describe('AgentRunnerService.runLoop', () => {
-    let runner;
-    const llmProvider = {
-        getModel: vi.fn().mockReturnValue({ modelId: 'claude-sonnet-4-6', provider: 'anthropic' }),
-        getModelByName: vi.fn(),
-        cacheMarker: vi.fn(),
-        repairToolCallHandler: vi.fn(),
-        thinkingProviderOptions: vi.fn(),
-        telemetryConfig: vi.fn(),
-        promptCachingConfig: vi.fn(() => ({
-            enabled: false,
-            systemTtl: '1h',
-            toolsTtl: '1h',
-            historyTtl: '5m',
-            cacheSystem: true,
-            cacheTools: true,
-            cacheHistory: true,
-            vertexFallbackTo5m: false,
-        })),
-        activeBackend: vi.fn(() => 'anthropic'),
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        runner = new AgentRunnerService({ llmProvider: llmProvider });
-    });
-    afterEach(() => vi.clearAllMocks());
-    it('passes systemPrompt, userPrompt, tools, and step budget through to generateText', async () => {
-        generateText.mockResolvedValue({ text: 'ok', toolCalls: [], steps: [] });
-        const repairHandler = vi.fn();
-        llmProvider.repairToolCallHandler.mockReturnValueOnce(repairHandler);
-        const tools = { noop: { description: 'noop', inputSchema: {}, execute: vi.fn() } };
-        await runner.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: 'SYS',
-            userPrompt: 'USR',
-            toolSet: tools,
-            stepBudget: 17,
-            telemetryTags: { source: 'test' },
-        });
-        const call = generateText.mock.calls[0][0];
-        expect(call.system).toEqual({ role: 'system', content: 'SYS' });
-        expect(call.messages).toEqual([{ role: 'user', content: 'USR' }]);
-        expect(call.prompt).toBeUndefined();
-        expect(call.tools.noop).toEqual(expect.objectContaining({
-            description: 'noop',
-            inputSchema: {},
-            execute: expect.any(Function),
-            toModelOutput: expect.any(Function),
-        }));
-        expect(call.stopWhen).toBe(17);
-        expect(call.temperature).toBe(0);
-        expect(call.experimental_repairToolCall).toBe(repairHandler);
-        expect(llmProvider.getModel).toHaveBeenCalledWith('candidateExtraction');
-        expect(llmProvider.repairToolCallHandler).toHaveBeenCalledWith({ source: 'ktx-agent-runner' });
-    });
-    it('returns stopReason=natural when the loop completes without error', async () => {
-        generateText.mockResolvedValue({ text: 'done', toolCalls: [], steps: [] });
-        const result = await runner.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: 'system',
-            userPrompt: 'user',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: {},
-        });
-        expect(result.stopReason).toBe('natural');
-        expect(result.error).toBeUndefined();
-        expect(llmProvider.getModel).toHaveBeenCalledWith('candidateExtraction');
-        expect(generateText).toHaveBeenCalledWith(expect.objectContaining({
-            system: { role: 'system', content: 'system' },
-            messages: [{ role: 'user', content: 'user' }],
-        }));
-    });
-    it('returns stopReason=error with the error on generateText failure', async () => {
-        const err = new Error('LLM unavailable');
-        generateText.mockRejectedValue(err);
-        const result = await runner.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: {},
-        });
-        expect(result.stopReason).toBe('error');
-        expect(result.error).toBe(err);
-    });
-    it('invokes caller onStepFinish with incrementing stepIndex and total budget', async () => {
-        const calls = [];
-        generateText.mockImplementation(async (opts) => {
-            for (let i = 0; i < 3; i++) {
-                await opts.onStepFinish({});
-            }
-            return { text: 'ok', toolCalls: [], steps: [] };
-        });
-        await runner.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: {},
-            onStepFinish: (info) => {
-                calls.push(info);
-            },
-        });
-        expect(calls).toEqual([
-            { stepIndex: 1, stepBudget: 10 },
-            { stepIndex: 2, stepBudget: 10 },
-            { stepIndex: 3, stepBudget: 10 },
-        ]);
-    });
-    it('swallows errors thrown from caller onStepFinish without aborting the loop', async () => {
-        generateText.mockImplementation(async (opts) => {
-            await opts.onStepFinish({});
-            return { text: 'ok', toolCalls: [], steps: [] };
-        });
-        const result = await runner.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: {},
-            onStepFinish: () => {
-                throw new Error('boom');
-            },
-        });
-        expect(result.stopReason).toBe('natural');
-    });
-    it('forwards telemetryTags.source through experimental_telemetry metadata', async () => {
-        generateText.mockResolvedValue({ text: 'ok', toolCalls: [], steps: [] });
-        const telemetryConfigEnabled = {
-            isEnabled: () => true,
-            devtoolsEnabled: false,
-            appSettingsService: {
-                settings: { telemetry: { recordInputs: false, recordOutputs: false } },
-            },
-            systemConfigService: {
-                config: { instance: { name: 'test-instance' } },
-            },
-        };
-        const runnerWithTelemetry = new AgentRunnerService({
-            llmProvider: llmProvider,
-            telemetry: {
-                createTelemetry: (tags) => ({
-                    isEnabled: telemetryConfigEnabled.isEnabled(),
-                    metadata: {
-                        source: tags.source ?? 'RESEARCH',
-                        jobId: tags.jobId,
-                        unitKey: tags.unitKey,
-                    },
-                }),
-            },
-        });
-        await runnerWithTelemetry.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: { source: 'metabase', jobId: 'job-123', unitKey: 'u/1' },
-        });
-        const call = generateText.mock.calls[0][0];
-        expect(call.experimental_telemetry.metadata.source).toBe('metabase');
-    });
-    it('defaults to source=RESEARCH when telemetryTags omits source', async () => {
-        generateText.mockResolvedValue({ text: 'ok', toolCalls: [], steps: [] });
-        const telemetryConfigEnabled = {
-            isEnabled: () => true,
-            devtoolsEnabled: false,
-            appSettingsService: {
-                settings: { telemetry: { recordInputs: false, recordOutputs: false } },
-            },
-            systemConfigService: {
-                config: { instance: { name: 'test-instance' } },
-            },
-        };
-        const runnerWithTelemetry = new AgentRunnerService({
-            llmProvider: llmProvider,
-            telemetry: {
-                createTelemetry: (tags) => ({
-                    isEnabled: telemetryConfigEnabled.isEnabled(),
-                    metadata: {
-                        source: tags.source ?? 'RESEARCH',
-                        jobId: tags.jobId,
-                        unitKey: tags.unitKey,
-                    },
-                }),
-            },
-        });
-        await runnerWithTelemetry.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: { operationName: 'memory-agent-ingest' },
-        });
-        const call = generateText.mock.calls[0][0];
-        expect(call.experimental_telemetry.metadata.source).toBe('RESEARCH');
-    });
-    it('forwards jobId and unitKey through experimental_telemetry metadata', async () => {
-        generateText.mockResolvedValue({ text: 'ok', toolCalls: [], steps: [] });
-        const telemetryConfigEnabled = {
-            isEnabled: () => true,
-            devtoolsEnabled: false,
-            appSettingsService: {
-                settings: { telemetry: { recordInputs: false, recordOutputs: false } },
-            },
-            systemConfigService: {
-                config: { instance: { name: 'test-instance' } },
-            },
-        };
-        const runnerWithTelemetry = new AgentRunnerService({
-            llmProvider: llmProvider,
-            telemetry: {
-                createTelemetry: (tags) => ({
-                    isEnabled: telemetryConfigEnabled.isEnabled(),
-                    metadata: {
-                        source: tags.source ?? 'RESEARCH',
-                        jobId: tags.jobId,
-                        unitKey: tags.unitKey,
-                    },
-                }),
-            },
-        });
-        await runnerWithTelemetry.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: '',
-            userPrompt: '',
-            toolSet: {},
-            stepBudget: 10,
-            telemetryTags: { source: 'metabase', jobId: 'job-777', unitKey: 'sources/users' },
-        });
-        const call = generateText.mock.calls[0][0];
-        expect(call.experimental_telemetry.metadata.jobId).toBe('job-777');
-        expect(call.experimental_telemetry.metadata.unitKey).toBe('sources/users');
-    });
-    it('records a sanitized LLM debug request when a recorder is injected', async () => {
-        generateText.mockResolvedValue({ text: 'ok', toolCalls: [], steps: [] });
-        const record = vi.fn();
-        const provider = {
-            ...llmProvider,
-            cacheMarker: vi.fn((ttl) => ({
-                anthropic: { cacheControl: { type: 'ephemeral', ttl } },
-            })),
-            promptCachingConfig: vi.fn(() => ({
-                enabled: true,
-                systemTtl: '1h',
-                toolsTtl: '1h',
-                historyTtl: '5m',
-                cacheSystem: true,
-                cacheTools: true,
-                cacheHistory: true,
-                vertexFallbackTo5m: false,
-            })),
-        };
-        const runnerWithDebug = new AgentRunnerService({
-            llmProvider: provider,
-            debugRequestRecorder: { record },
-        });
-        await runnerWithDebug.runLoop({
-            modelRole: 'candidateExtraction',
-            systemPrompt: 'SECRET SYSTEM PROMPT',
-            userPrompt: 'SECRET USER PROMPT',
-            toolSet: {
-                emit_candidate: {
-                    description: 'SECRET TOOL DESCRIPTION',
-                    inputSchema: {},
-                    execute: vi.fn(),
-                },
-            },
-            stepBudget: 10,
-            telemetryTags: { operationName: 'ingest-bundle-wu', source: 'metabase', jobId: 'job-1', unitKey: 'cards/1' },
-        });
-        expect(record).toHaveBeenCalledTimes(1);
-        expect(record).toHaveBeenCalledWith(expect.objectContaining({
-            operationName: 'ingest-bundle-wu',
-            source: 'metabase',
-            jobId: 'job-1',
-            unitKey: 'cards/1',
-            modelRole: 'candidateExtraction',
-            modelId: 'claude-sonnet-4-6',
-            messageCount: 2,
-            toolNames: ['emit_candidate'],
-        }));
-        const providerOptions = record.mock.calls[0][0].providerOptions;
-        expect(providerOptions).toEqual(expect.arrayContaining([
-            expect.objectContaining({ target: 'message', index: 0, role: 'system' }),
-            expect.objectContaining({ target: 'message-part', index: 1, role: 'user', partIndex: 0 }),
-            expect.objectContaining({ target: 'tool', name: 'emit_candidate' }),
-        ]));
-        expect(providerOptions).toHaveLength(3);
-        const serialized = JSON.stringify(record.mock.calls[0][0]);
-        expect(serialized).not.toContain('SECRET SYSTEM PROMPT');
-        expect(serialized).not.toContain('SECRET USER PROMPT');
-        expect(serialized).not.toContain('SECRET TOOL DESCRIPTION');
-    });
-});

package/node_modules/@ktx/context/dist/agent/index.d.ts

@@ -1,2 +0,0 @@
-export type { AgentRunnerServiceDeps, AgentTelemetryPort, RunLoopParams, RunLoopResult, RunLoopStepInfo, RunLoopStopReason, } from './agent-runner.service.js';
-export { AgentRunnerService } from './agent-runner.service.js';

package/node_modules/@ktx/context/dist/agent/index.js

@@ -1 +0,0 @@
-export { AgentRunnerService } from './agent-runner.service.js';

package/node_modules/@ktx/context/dist/connections/connection-type.d.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-export declare const connectionTypeSchema: z.ZodEnum<{
-    POSTGRESQL: "POSTGRESQL";
-    BIGQUERY: "BIGQUERY";
-    SNOWFLAKE: "SNOWFLAKE";
-    MYSQL: "MYSQL";
-    SQLSERVER: "SQLSERVER";
-    SQLITE: "SQLITE";
-    CLICKHOUSE: "CLICKHOUSE";
-    CENTRALREACH: "CENTRALREACH";
-    EPIC: "EPIC";
-    CERNER: "CERNER";
-    ATHENA: "ATHENA";
-    QUICKBOOKS: "QUICKBOOKS";
-    WORKDAY: "WORKDAY";
-    REST: "REST";
-    S3: "S3";
-    SLACK: "SLACK";
-    METABASE: "METABASE";
-    LOOKER: "LOOKER";
-    NOTION: "NOTION";
-    PLAIN: "PLAIN";
-    BETTERSTACK: "BETTERSTACK";
-}>;
-export type ConnectionType = z.infer<typeof connectionTypeSchema>;

package/node_modules/@ktx/context/dist/connections/dialects.d.ts

@@ -1,9 +0,0 @@
-import type { KtxSchemaDimensionType, KtxTableRef } from '../scan/types.js';
-export type SupportedDriver = 'postgres' | 'postgresql' | 'mysql' | 'sqlserver' | 'snowflake' | 'bigquery' | 'clickhouse' | 'sqlite' | 'sqlite3';
-export interface KtxDialect {
-    readonly type: SupportedDriver;
-    quoteIdentifier(identifier: string): string;
-    formatTableName(table: KtxTableRef): string;
-    mapToDimensionType(nativeType: string): KtxSchemaDimensionType;
-}
-export declare function getDialectForDriver(driver: string): KtxDialect;

package/node_modules/@ktx/context/dist/connections/dialects.js

@@ -1,71 +0,0 @@
-const supportedDrivers = [
-    'bigquery',
-    'clickhouse',
-    'mysql',
-    'postgres',
-    'postgresql',
-    'sqlite',
-    'sqlite3',
-    'snowflake',
-    'sqlserver',
-];
-function doubleQuoted(identifier) {
-    return `"${identifier.replace(/"/g, '""')}"`;
-}
-function backtickQuoted(identifier) {
-    return `\`${identifier.replace(/`/g, '``')}\``;
-}
-function bigQueryQuoted(identifier) {
-    return `\`${identifier.replace(/`/g, '\\`')}\``;
-}
-function bracketQuoted(identifier) {
-    return `[${identifier.replace(/\]/g, ']]')}]`;
-}
-function inferDimensionType(nativeType) {
-    const normalized = nativeType.toLowerCase().trim();
-    if (normalized.includes('date') || normalized.includes('time')) {
-        return 'time';
-    }
-    if (normalized.includes('int') ||
-        normalized.includes('num') ||
-        normalized.includes('dec') ||
-        normalized.includes('float') ||
-        normalized.includes('double') ||
-        normalized.includes('real')) {
-        return 'number';
-    }
-    if (normalized.includes('bool') || normalized === 'bit') {
-        return 'boolean';
-    }
-    return 'string';
-}
-function formatWithParts(table, quote, sqlite = false) {
-    const parts = sqlite ? [table.name] : [table.catalog, table.db, table.name].filter((part) => !!part);
-    return parts.map(quote).join('.');
-}
-function createDialect(type, quote, sqlite = false) {
-    return {
-        type,
-        quoteIdentifier: quote,
-        formatTableName: (table) => formatWithParts(table, quote, sqlite),
-        mapToDimensionType: inferDimensionType,
-    };
-}
-const dialects = {
-    postgres: createDialect('postgres', doubleQuoted),
-    postgresql: createDialect('postgresql', doubleQuoted),
-    mysql: createDialect('mysql', backtickQuoted),
-    clickhouse: createDialect('clickhouse', backtickQuoted),
-    sqlite: createDialect('sqlite', doubleQuoted, true),
-    sqlite3: createDialect('sqlite3', doubleQuoted, true),
-    snowflake: createDialect('snowflake', doubleQuoted),
-    bigquery: createDialect('bigquery', bigQueryQuoted),
-    sqlserver: createDialect('sqlserver', bracketQuoted),
-};
-export function getDialectForDriver(driver) {
-    const normalized = driver.toLowerCase().trim();
-    if (normalized in dialects) {
-        return dialects[normalized];
-    }
-    throw new Error(`Unsupported warehouse driver "${driver}". Supported drivers: ${supportedDrivers.join(', ')}`);
-}

package/node_modules/@ktx/context/dist/connections/dialects.test.d.ts

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

package/node_modules/@ktx/context/dist/connections/dialects.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getDialectForDriver } from './dialects.js';
-describe('getDialectForDriver', () => {
-    it.each([
-        ['postgres', '"public"."orders"'],
-        ['postgresql', '"public"."orders"'],
-        ['mysql', '`public`.`orders`'],
-        ['clickhouse', '`public`.`orders`'],
-        ['sqlite', '"orders"'],
-        ['snowflake', '"analytics"."public"."orders"'],
-        ['bigquery', '`analytics`.`public`.`orders`'],
-        ['sqlserver', '[analytics].[public].[orders]'],
-    ])('formats table names for %s', (driver, expected) => {
-        const dialect = getDialectForDriver(driver);
-        expect(dialect.formatTableName({
-            catalog: driver === 'snowflake' || driver === 'bigquery' || driver === 'sqlserver' ? 'analytics' : null,
-            db: driver === 'sqlite' ? null : 'public',
-            name: 'orders',
-        })).toBe(expected);
-    });
-    it('throws with a supported-driver list for unknown drivers', () => {
-        expect(() => getDialectForDriver('oracle')).toThrow('Unsupported warehouse driver "oracle". Supported drivers: bigquery, clickhouse, mysql, postgres, postgresql, sqlite, sqlite3, snowflake, sqlserver');
-    });
-});

package/node_modules/@ktx/context/dist/connections/index.d.ts

@@ -1,11 +0,0 @@
-export type { KtxSqlQueryExecutionInput, KtxSqlQueryExecutionResult, KtxSqlQueryExecutorPort, } from './query-executor.js';
-export type { KtxDialect, SupportedDriver } from './dialects.js';
-export { createDefaultLocalQueryExecutor, type DefaultLocalQueryExecutorOptions } from './local-query-executor.js';
-export { getDialectForDriver } from './dialects.js';
-export { normalizeQueryRows } from './query-executor.js';
-export { createPostgresQueryExecutor } from './postgres-query-executor.js';
-export { assertReadOnlySql, limitSqlForExecution } from './read-only-sql.js';
-export { createSqliteQueryExecutor, sqliteDatabasePathFromConnection } from './sqlite-query-executor.js';
-export { connectionTypeSchema, type ConnectionType } from './connection-type.js';
-export { localConnectionInfoFromConfig, localConnectionToWarehouseDescriptor, localConnectionTypeForConfig, type LocalConnectionInfo, type LocalWarehouseDescriptor, } from './local-warehouse-descriptor.js';
-export { KTX_NOTION_ORG_KNOWLEDGE_WARNING, notionConnectionToPullConfig, parseNotionConnectionConfig, redactNotionConnectionConfig, resolveNotionConnectionAuthToken, resolveNotionAuthToken, type KtxNotionConnectionConfig, type RedactedKtxNotionConnectionConfig, } from './notion-config.js';

package/node_modules/@ktx/context/dist/connections/index.js

@@ -1,9 +0,0 @@
-export { createDefaultLocalQueryExecutor } from './local-query-executor.js';
-export { getDialectForDriver } from './dialects.js';
-export { normalizeQueryRows } from './query-executor.js';
-export { createPostgresQueryExecutor } from './postgres-query-executor.js';
-export { assertReadOnlySql, limitSqlForExecution } from './read-only-sql.js';
-export { createSqliteQueryExecutor, sqliteDatabasePathFromConnection } from './sqlite-query-executor.js';
-export { connectionTypeSchema } from './connection-type.js';
-export { localConnectionInfoFromConfig, localConnectionToWarehouseDescriptor, localConnectionTypeForConfig, } from './local-warehouse-descriptor.js';
-export { KTX_NOTION_ORG_KNOWLEDGE_WARNING, notionConnectionToPullConfig, parseNotionConnectionConfig, redactNotionConnectionConfig, resolveNotionConnectionAuthToken, resolveNotionAuthToken, } from './notion-config.js';

package/node_modules/@ktx/context/dist/connections/local-query-executor.js

@@ -1,21 +0,0 @@
-import { createPostgresQueryExecutor } from './postgres-query-executor.js';
-import { createSqliteQueryExecutor } from './sqlite-query-executor.js';
-function driverFor(input) {
-    return String(input.connection?.driver ?? '').toLowerCase();
-}
-export function createDefaultLocalQueryExecutor(options = {}) {
-    const postgres = options.postgres ?? createPostgresQueryExecutor();
-    const sqlite = options.sqlite ?? createSqliteQueryExecutor();
-    return {
-        async execute(input) {
-            const driver = driverFor(input);
-            if (driver === 'postgres' || driver === 'postgresql') {
-                return postgres.execute(input);
-            }
-            if (driver === 'sqlite' || driver === 'sqlite3') {
-                return sqlite.execute(input);
-            }
-            throw new Error(`No local query executor is configured for driver "${input.connection?.driver ?? 'unknown'}".`);
-        },
-    };
-}

package/node_modules/@ktx/context/dist/connections/local-query-executor.test.d.ts

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

package/node_modules/@ktx/context/dist/connections/local-query-executor.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createDefaultLocalQueryExecutor } from './local-query-executor.js';
-describe('createDefaultLocalQueryExecutor', () => {
-    it('dispatches postgres and sqlite drivers to their executors', async () => {
-        const postgres = {
-            execute: vi.fn(async () => ({
-                headers: ['pg'],
-                rows: [[1]],
-                totalRows: 1,
-                command: 'SELECT',
-                rowCount: 1,
-            })),
-        };
-        const sqlite = {
-            execute: vi.fn(async () => ({
-                headers: ['sqlite'],
-                rows: [[2]],
-                totalRows: 1,
-                command: 'SELECT',
-                rowCount: 1,
-            })),
-        };
-        const executor = createDefaultLocalQueryExecutor({ postgres, sqlite });
-        await expect(executor.execute({
-            connectionId: 'pg',
-            connection: { driver: 'postgres' },
-            sql: 'select 1',
-        })).resolves.toMatchObject({ headers: ['pg'] });
-        await expect(executor.execute({
-            connectionId: 'local',
-            connection: { driver: 'sqlite' },
-            sql: 'select 1',
-        })).resolves.toMatchObject({ headers: ['sqlite'] });
-        expect(postgres.execute).toHaveBeenCalledTimes(1);
-        expect(sqlite.execute).toHaveBeenCalledTimes(1);
-    });
-    it('rejects unsupported local execution drivers', async () => {
-        const executor = createDefaultLocalQueryExecutor({
-            postgres: { execute: vi.fn() },
-            sqlite: { execute: vi.fn() },
-        });
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            connection: { driver: 'snowflake' },
-            sql: 'select 1',
-        })).rejects.toThrow('No local query executor is configured for driver "snowflake".');
-    });
-});

package/node_modules/@ktx/context/dist/connections/local-warehouse-descriptor.js

@@ -1,72 +0,0 @@
-const DRIVER_TO_CONNECTION_TYPE = {
-    postgres: 'POSTGRESQL',
-    postgresql: 'POSTGRESQL',
-    sqlite: 'SQLITE',
-    sqlserver: 'SQLSERVER',
-    mssql: 'SQLSERVER',
-    mysql: 'MYSQL',
-    clickhouse: 'CLICKHOUSE',
-    snowflake: 'SNOWFLAKE',
-    bigquery: 'BIGQUERY',
-};
-export function localConnectionToWarehouseDescriptor(id, connection) {
-    if (!connection) {
-        return null;
-    }
-    const connectionType = DRIVER_TO_CONNECTION_TYPE[String(connection.driver ?? '').toLowerCase()];
-    if (!connectionType) {
-        return null;
-    }
-    const info = {
-        id,
-        connection_type: connectionType,
-        connection_params: { ...connection },
-    };
-    const url = typeof connection.url === 'string' ? connection.url : null;
-    if (url && !url.startsWith('env:') && !url.startsWith('file:')) {
-        try {
-            const parsed = new URL(url);
-            info.host = parsed.hostname || null;
-            if (parsed.pathname.length > 1) {
-                const [first, second] = parsed.pathname.slice(1).split('/');
-                if (connectionType === 'BIGQUERY') {
-                    info.project_id = stringField(connection.project_id) ?? parsed.hostname ?? first ?? null;
-                    info.dataset_id = stringField(connection.dataset_id) ?? second ?? null;
-                }
-                else {
-                    info.database = first ?? null;
-                }
-            }
-        }
-        catch {
-            info.host = stringField(connection.host);
-        }
-    }
-    info.host = stringField(connection.host) ?? info.host ?? null;
-    info.database = stringField(connection.database) ?? info.database ?? null;
-    info.account = stringField(connection.account) ?? null;
-    info.project_id = stringField(connection.project_id) ?? info.project_id ?? null;
-    info.dataset_id = stringField(connection.dataset_id) ?? info.dataset_id ?? null;
-    return info;
-}
-export function localConnectionTypeForConfig(id, connection) {
-    const descriptor = localConnectionToWarehouseDescriptor(id, connection);
-    if (descriptor) {
-        return descriptor.connection_type;
-    }
-    const driver = typeof connection?.driver === 'string' ? connection.driver.trim() : '';
-    return driver.length > 0 ? driver : 'unknown';
-}
-export function localConnectionInfoFromConfig(id, connection) {
-    if (!connection) {
-        return null;
-    }
-    return {
-        id,
-        name: id,
-        connectionType: localConnectionTypeForConfig(id, connection),
-    };
-}
-function stringField(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}

package/node_modules/@ktx/context/dist/connections/local-warehouse-descriptor.test.d.ts

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