@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/adapters/metabase/local-metabase.adapter.test.js

@@ -1,56 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { metabaseRuntimeConfigFromLocalConnection } from './local-metabase.adapter.js';
-describe('metabaseRuntimeConfigFromLocalConnection', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-metabase-runtime-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('resolves api_url and env-backed api_key_ref from a flat ktx.yaml connection', () => {
-        const connection = {
-            driver: 'metabase',
-            api_url: 'https://metabase.example.com',
-            api_key_ref: 'env:METABASE_API_KEY', // pragma: allowlist secret
-        };
-        expect(metabaseRuntimeConfigFromLocalConnection('prod-metabase', connection, {
-            METABASE_API_KEY: 'mb_key', // pragma: allowlist secret
-        })).toEqual({
-            apiUrl: 'https://metabase.example.com',
-            apiKey: 'mb_key', // pragma: allowlist secret
-        });
-    });
-    it('resolves file-backed api_key_ref from pasted setup secrets', async () => {
-        const keyPath = join(tempDir, 'metabase-main-api-key');
-        await writeFile(keyPath, 'mb_file_key\n', 'utf-8'); // pragma: allowlist secret
-        const connection = {
-            driver: 'metabase',
-            api_url: 'https://metabase.example.com',
-            api_key_ref: `file:${keyPath}`, // pragma: allowlist secret
-        };
-        expect(metabaseRuntimeConfigFromLocalConnection('prod-metabase', connection)).toEqual({
-            apiUrl: 'https://metabase.example.com',
-            apiKey: 'mb_file_key', // pragma: allowlist secret
-        });
-    });
-    it('rejects proxy-bearing local Metabase connections', () => {
-        const connection = {
-            driver: 'metabase',
-            api_url: 'https://metabase.example.com',
-            api_key: 'literal-test-key', // pragma: allowlist secret
-            networkProxy: { type: 'ssh' },
-        };
-        expect(() => metabaseRuntimeConfigFromLocalConnection('prod-metabase', connection)).toThrow('Standalone KTX does not support proxy-bearing Metabase connections yet');
-    });
-    it('rejects non-Metabase source connections', () => {
-        const connection = {
-            driver: 'postgres',
-            url: 'postgres://localhost/db',
-        };
-        expect(() => metabaseRuntimeConfigFromLocalConnection('warehouse', connection)).toThrow('Connection "warehouse" is not a Metabase connection');
-    });
-});

package/dist/context/ingest/adapters/metabase/local-source-state-store.test.d.ts

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

package/dist/context/ingest/adapters/metabase/local-source-state-store.test.js

@@ -1,99 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { buildDefaultKtxProjectConfig } from '../../../../context/project/config.js';
-import { connectionConfigSchema } from '../../../project/driver-schemas.js';
-import { KtxYamlMetabaseSourceStateReader, LocalMetabaseDiscoveryCache } from './local-source-state-store.js';
-describe('Metabase YAML source state and discovery cache', () => {
-    let tempDir;
-    let discoveryCache;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-metabase-cache-'));
-        discoveryCache = new LocalMetabaseDiscoveryCache({ dbPath: join(tempDir, '.ktx', 'db.sqlite') });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    function projectWithMetabaseMappings(mappings) {
-        return {
-            config: {
-                ...buildDefaultKtxProjectConfig(),
-                connections: {
-                    'prod-metabase': connectionConfigSchema.parse({
-                        driver: 'metabase',
-                        api_url: 'https://metabase.example.com',
-                        mappings,
-                    }),
-                },
-            },
-        };
-    }
-    it('reads Metabase mapping intent from ktx.yaml config', async () => {
-        const reader = new KtxYamlMetabaseSourceStateReader(projectWithMetabaseMappings({
-            databaseMappings: { '2': 'warehouse' },
-            syncEnabled: { '2': true },
-            syncMode: 'ONLY',
-            selections: { collections: [12], items: [99] },
-            defaultTagNames: ['analytics'],
-        }), { discoveryCache });
-        await expect(reader.getSourceState('prod-metabase')).resolves.toEqual({
-            syncMode: 'ONLY',
-            defaultTagNames: ['analytics'],
-            selections: [
-                { selectionType: 'collection', metabaseObjectId: 12 },
-                { selectionType: 'item', metabaseObjectId: 99 },
-            ],
-            mappings: [
-                {
-                    metabaseDatabaseId: 2,
-                    metabaseDatabaseName: null,
-                    metabaseEngine: null,
-                    metabaseHost: null,
-                    metabaseDbName: null,
-                    targetConnectionId: 'warehouse',
-                    syncEnabled: true,
-                },
-            ],
-        });
-    });
-    it('enriches YAML mapping rows with recreatable discovery metadata', async () => {
-        await discoveryCache.refreshDiscoveredDatabases({
-            connectionId: 'prod-metabase',
-            discovered: [{ id: 2, name: 'Analytics', engine: 'postgres', host: 'pg.internal', dbName: 'analytics' }],
-        });
-        const reader = new KtxYamlMetabaseSourceStateReader(projectWithMetabaseMappings({
-            databaseMappings: { '2': 'warehouse' },
-            syncEnabled: { '2': true },
-        }), { discoveryCache });
-        await expect(reader.listDatabaseMappings('prod-metabase')).resolves.toMatchObject([
-            {
-                metabaseDatabaseId: 2,
-                metabaseDatabaseName: 'Analytics',
-                metabaseEngine: 'postgres',
-                metabaseHost: 'pg.internal',
-                metabaseDbName: 'analytics',
-                targetConnectionId: 'warehouse',
-                syncEnabled: true,
-                source: 'ktx.yaml',
-            },
-        ]);
-    });
-    it('lists discovered-only rows as refresh cache data without turning them into config state', async () => {
-        await discoveryCache.refreshDiscoveredDatabases({
-            connectionId: 'prod-metabase',
-            discovered: [{ id: 7, name: 'Unmapped', engine: 'mysql', host: 'mysql.internal', dbName: 'sales' }],
-        });
-        const reader = new KtxYamlMetabaseSourceStateReader(projectWithMetabaseMappings({}), { discoveryCache });
-        await expect(reader.getSourceState('prod-metabase')).resolves.toMatchObject({ mappings: [] });
-        await expect(reader.listDatabaseMappings('prod-metabase')).resolves.toMatchObject([
-            {
-                metabaseDatabaseId: 7,
-                metabaseDatabaseName: 'Unmapped',
-                targetConnectionId: null,
-                syncEnabled: false,
-                source: 'refresh',
-            },
-        ]);
-    });
-});

package/dist/context/ingest/adapters/metabase/mapping.test.d.ts

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

package/dist/context/ingest/adapters/metabase/mapping.test.js

@@ -1,215 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { METABASE_ENGINE_TO_CONNECTION_TYPE, computeMetabaseMappingDrift, computeMetabaseMappingPhysicalMismatches, discoverMetabaseDatabases, findBestMatch, refreshMetabaseMapping, validateMappingPhysicalMatch, validateMetabaseMappings, } from './mapping.js';
-describe('discoverMetabaseDatabases', () => {
-    it('filters sample databases and extracts host plus database names from Metabase details', async () => {
-        const client = {
-            getDatabases: vi.fn().mockResolvedValue([
-                {
-                    id: 1,
-                    name: 'Sample',
-                    engine: 'postgres',
-                    details: { host: 'sample.internal', dbname: 'sample' },
-                    is_sample: true,
-                },
-                {
-                    id: 2,
-                    name: 'Analytics',
-                    engine: 'postgres',
-                    details: { host: 'pg.internal:5432', dbname: 'analytics' },
-                    is_sample: false,
-                },
-                {
-                    id: 3,
-                    name: 'Warehouse',
-                    engine: 'mysql',
-                    details: { host: 'mysql.internal', db: 'warehouse' },
-                    is_sample: false,
-                },
-            ]),
-        };
-        await expect(discoverMetabaseDatabases(client)).resolves.toEqual([
-            { id: 2, name: 'Analytics', engine: 'postgres', host: 'pg.internal:5432', dbName: 'analytics' },
-            { id: 3, name: 'Warehouse', engine: 'mysql', host: 'mysql.internal', dbName: 'warehouse' },
-        ]);
-    });
-});
-describe('computeMetabaseMappingDrift', () => {
-    it('reports unmapped discovered databases, stale mappings, and in-sync mappings', () => {
-        const drift = computeMetabaseMappingDrift({
-            currentMappings: {
-                '2': 'target-postgres',
-                '9': 'target-stale',
-            },
-            discovered: [
-                { id: 2, name: 'Analytics', engine: 'postgres', host: 'pg.internal', dbName: 'analytics' },
-                { id: 3, name: 'Warehouse', engine: 'mysql', host: 'mysql.internal', dbName: 'warehouse' },
-            ],
-        });
-        expect(drift).toEqual({
-            unmappedDiscovered: [
-                { id: 3, name: 'Warehouse', engine: 'mysql', host: 'mysql.internal', dbName: 'warehouse' },
-            ],
-            staleMappings: [{ id: '9', reason: 'database_not_found' }],
-            inSync: [{ id: 2, ktxConnectionId: 'target-postgres' }],
-        });
-    });
-});
-describe('validateMetabaseMappings', () => {
-    it('accepts mappings whose target connection ids exist', () => {
-        expect(validateMetabaseMappings({
-            mappings: { '2': 'target-postgres' },
-            knownKtxConnectionIds: new Set(['target-postgres']),
-        })).toEqual({ ok: true });
-    });
-    it('returns one error per missing target connection id', () => {
-        expect(validateMetabaseMappings({
-            mappings: { '2': 'missing-target', '3': 'target-mysql' },
-            knownKtxConnectionIds: new Set(['target-mysql']),
-        })).toEqual({
-            ok: false,
-            errors: [{ key: '2', reason: 'KTX connection missing-target does not exist' }],
-        });
-    });
-});
-describe('validateMappingPhysicalMatch', () => {
-    it('returns null when Snowflake mapping points at the same database', () => {
-        expect(validateMappingPhysicalMatch({ metabaseEngine: 'snowflake', metabaseDbName: 'ANALYTICS', metabaseHost: null }, { connection_type: 'SNOWFLAKE', database: 'ANALYTICS', account: 'EMOVRJS-CZ07756' })).toBeNull();
-    });
-    it('returns a reason when Snowflake mapping points at a different database', () => {
-        const reason = validateMappingPhysicalMatch({ metabaseEngine: 'snowflake', metabaseDbName: 'SNAPSHOTS', metabaseHost: null }, { connection_type: 'SNOWFLAKE', database: 'ANALYTICS', account: 'EMOVRJS-CZ07756' });
-        expect(reason).toContain('SNAPSHOTS');
-        expect(reason).toContain('ANALYTICS');
-    });
-    it('returns a reason when engine type mismatches', () => {
-        const reason = validateMappingPhysicalMatch({ metabaseEngine: 'snowflake', metabaseDbName: 'ANALYTICS', metabaseHost: null }, { connection_type: 'POSTGRESQL', database: 'ANALYTICS', host: 'pg.internal' });
-        expect(reason).toContain('engine');
-    });
-    it('returns null when Postgres host and database both match after normalization', () => {
-        expect(validateMappingPhysicalMatch({ metabaseEngine: 'postgres', metabaseDbName: 'app', metabaseHost: 'PG.INTERNAL:5432' }, { connection_type: 'POSTGRESQL', host: 'pg.internal', database: 'APP' })).toBeNull();
-    });
-    it('returns a reason when Postgres host matches but database differs', () => {
-        const reason = validateMappingPhysicalMatch({ metabaseEngine: 'postgres', metabaseDbName: 'app', metabaseHost: 'pg.internal' }, { connection_type: 'POSTGRESQL', host: 'pg.internal', database: 'other_app' });
-        expect(reason).toContain('app');
-        expect(reason).toContain('other_app');
-    });
-    it('uses BigQuery dataset_id before project_id when comparing database names', () => {
-        expect(validateMappingPhysicalMatch({ metabaseEngine: 'bigquery', metabaseDbName: 'analytics_dataset', metabaseHost: null }, { connection_type: 'BIGQUERY', dataset_id: 'analytics_dataset', project_id: 'warehouse-project' })).toBeNull();
-    });
-    it('returns null for unknown engines because KTX cannot validate them', () => {
-        expect(validateMappingPhysicalMatch({ metabaseEngine: 'unknown-engine', metabaseDbName: 'X', metabaseHost: 'host' }, { connection_type: 'OTHER' })).toBeNull();
-    });
-});
-describe('computeMetabaseMappingPhysicalMismatches', () => {
-    it('returns only mismatched physical mappings', () => {
-        expect(computeMetabaseMappingPhysicalMismatches([
-            {
-                mappingId: 'mapping-ok',
-                metabase: { metabaseEngine: 'postgres', metabaseHost: 'pg.internal', metabaseDbName: 'app' },
-                target: { connection_type: 'POSTGRESQL', host: 'pg.internal', database: 'app' },
-            },
-            {
-                mappingId: 'mapping-bad',
-                metabase: { metabaseEngine: 'postgres', metabaseHost: 'pg.internal', metabaseDbName: 'app' },
-                target: { connection_type: 'POSTGRESQL', host: 'pg.internal', database: 'other_app' },
-            },
-        ])).toEqual([
-            {
-                mappingId: 'mapping-bad',
-                reason: "Metabase database 'app' does not match KTX connection database 'other_app'",
-            },
-        ]);
-    });
-});
-describe('refreshMetabaseMapping', () => {
-    it('combines discovery drift and physical validation through a caller-provided target resolver', async () => {
-        const client = {
-            getDatabases: vi.fn().mockResolvedValue([
-                {
-                    id: 2,
-                    name: 'Analytics',
-                    engine: 'postgres',
-                    details: { host: 'pg.internal', dbname: 'analytics' },
-                    is_sample: false,
-                },
-            ]),
-        };
-        await expect(refreshMetabaseMapping({
-            client,
-            currentMappings: { '2': 'target-postgres' },
-            resolveKtxConnectionPhysicalInfo: vi.fn().mockResolvedValue({
-                connection_type: 'POSTGRESQL',
-                host: 'pg.internal',
-                database: 'wrong_database',
-            }),
-        })).resolves.toEqual({
-            drift: {
-                unmappedDiscovered: [],
-                staleMappings: [],
-                inSync: [{ id: 2, ktxConnectionId: 'target-postgres' }],
-            },
-            physicalMismatches: [
-                {
-                    mappingId: '2',
-                    reason: "Metabase database 'analytics' does not match KTX connection database 'wrong_database'",
-                },
-            ],
-        });
-    });
-});
-describe('findBestMatch', () => {
-    const candidates = [
-        {
-            id: 'snowflake-target',
-            name: 'Warehouse Snowflake',
-            connection_type: 'SNOWFLAKE',
-            connection_params: { account: 'EMOVRJS-CZ07756', database: 'ANALYTICS' },
-        },
-        {
-            id: 'postgres-host-only',
-            name: 'Host Only Postgres',
-            connection_type: 'POSTGRESQL',
-            connection_params: { host: 'pg.internal', database: 'other_app' },
-        },
-        {
-            id: 'postgres-db-only',
-            name: 'Database Only Postgres',
-            connection_type: 'POSTGRESQL',
-            connection_params: { host: 'other.internal', database: 'app' },
-        },
-        {
-            id: 'postgres-full',
-            name: 'Full Postgres',
-            connection_type: 'POSTGRESQL',
-            connection_params: { host: 'pg.internal', database: 'app' },
-        },
-    ];
-    it('chooses a host-and-database match over weaker matches', () => {
-        expect(findBestMatch({ metabaseEngine: 'postgres', metabaseHost: 'pg.internal:5432', metabaseDbName: 'APP' }, candidates)).toEqual({
-            connectionId: 'postgres-full',
-            connectionName: 'Full Postgres',
-            reason: 'host_and_database',
-        });
-    });
-    it('falls back to database-only matching when host does not match', () => {
-        expect(findBestMatch({ metabaseEngine: 'postgres', metabaseHost: 'unknown.internal', metabaseDbName: 'app' }, candidates)).toEqual({
-            connectionId: 'postgres-db-only',
-            connectionName: 'Database Only Postgres',
-            reason: 'database_only',
-        });
-    });
-    it('returns null for unsupported Metabase engines', () => {
-        expect(findBestMatch({ metabaseEngine: 'unknown-engine', metabaseHost: 'pg.internal', metabaseDbName: 'app' }, candidates)).toBeNull();
-    });
-});
-describe('METABASE_ENGINE_TO_CONNECTION_TYPE', () => {
-    it('keeps the server-supported Metabase engine table in KTX', () => {
-        expect(METABASE_ENGINE_TO_CONNECTION_TYPE).toMatchObject({
-            postgres: 'POSTGRESQL',
-            bigquery: 'BIGQUERY',
-            'bigquery-cloud-sdk': 'BIGQUERY',
-            snowflake: 'SNOWFLAKE',
-            sqlserver: 'SQLSERVER',
-            mysql: 'MYSQL',
-        });
-    });
-});

package/dist/context/ingest/adapters/metabase/metabase.adapter.test.d.ts

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

package/dist/context/ingest/adapters/metabase/metabase.adapter.test.js

@@ -1,129 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { MetabaseSourceAdapter } from './metabase.adapter.js';
-describe('MetabaseSourceAdapter', () => {
-    let stagedDir;
-    let adapter;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'mb-adapter-'));
-        adapter = new MetabaseSourceAdapter({});
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('declares the expected source key and skill list', () => {
-        expect(adapter.source).toBe('metabase');
-        expect(adapter.skillNames).toEqual(['metabase_ingest']);
-    });
-    it('detect: true for a valid staged dir', async () => {
-        await writeFile(join(stagedDir, 'sync-config.json'), '{}', 'utf-8');
-        await mkdir(join(stagedDir, 'cards'), { recursive: true });
-        await writeFile(join(stagedDir, 'cards/1.json'), '{}', 'utf-8');
-        expect(await adapter.detect(stagedDir)).toBe(true);
-    });
-    it('detect: false for a random empty dir', async () => {
-        expect(await adapter.detect(stagedDir)).toBe(false);
-    });
-    it('exposes a fetch() method (network-bound — real calls covered by fetch.spec.ts)', () => {
-        expect(typeof adapter.fetch).toBe('function');
-    });
-    it('forwards fetch dependencies using the source-state reader port', async () => {
-        const client = {
-            getAllCards: vi.fn().mockResolvedValue([]),
-            getCollectionTree: vi.fn().mockResolvedValue([]),
-            getCollectionItems: vi.fn().mockResolvedValue([]),
-            cleanup: vi.fn().mockResolvedValue(undefined),
-        };
-        const clientFactory = {
-            createClient: vi.fn().mockResolvedValue(client),
-        };
-        const sourceStateReader = {
-            getSourceState: vi.fn().mockResolvedValue({
-                syncMode: 'ALL',
-                selections: [],
-                defaultTagNames: [],
-                mappings: [
-                    {
-                        metabaseDatabaseId: 42,
-                        metabaseDatabaseName: 'Analytics',
-                        metabaseEngine: 'postgres',
-                        targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-                        syncEnabled: true,
-                    },
-                ],
-            }),
-        };
-        const forwardingAdapter = new MetabaseSourceAdapter({ clientFactory, sourceStateReader });
-        await forwardingAdapter.fetch({
-            metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-            metabaseDatabaseId: 42,
-        }, stagedDir, { connectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789', sourceKey: 'metabase' });
-        expect(sourceStateReader.getSourceState).toHaveBeenCalledWith('a1b2c3d4-e5f6-4789-9abc-def012345678');
-        expect(clientFactory.createClient).toHaveBeenCalledWith({
-            metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-            metabaseDatabaseId: 42,
-        }, { connectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789', sourceKey: 'metabase' });
-    });
-});
-describe('MetabaseSourceAdapter.describeScope', () => {
-    const adapter = new MetabaseSourceAdapter({});
-    let dir;
-    beforeEach(async () => {
-        dir = await mkdtemp(join(tmpdir(), 'mb-scope-'));
-    });
-    afterEach(async () => {
-        await rm(dir, { recursive: true, force: true });
-    });
-    async function writeSyncConfig(cfg) {
-        await writeFile(join(dir, 'sync-config.json'), JSON.stringify(cfg), 'utf-8');
-    }
-    const BASE = {
-        metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-        metabaseDatabaseId: 42,
-        defaultTagNames: [],
-        mapping: {
-            metabaseDatabaseId: 42,
-            metabaseDatabaseName: 'Analytics',
-            metabaseEngine: 'postgres',
-            targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-        },
-    };
-    it('returns a fingerprint + predicate for ONLY-scope staged dir', async () => {
-        await writeSyncConfig({
-            ...BASE,
-            syncMode: 'ONLY',
-            selections: [{ selectionType: 'item', metabaseObjectId: 5 }],
-        });
-        const scope = await adapter.describeScope(dir);
-        expect(scope.fingerprint).toMatch(/^[0-9a-f]{64}$/);
-        expect(scope.isPathInScope('cards/5.json')).toBe(true);
-        expect(scope.isPathInScope('cards/99.json')).toBe(false);
-        expect(scope.isPathInScope('sync-config.json')).toBe(true);
-    });
-    it('fingerprint is stable across invocations', async () => {
-        await writeSyncConfig({
-            ...BASE,
-            syncMode: 'ONLY',
-            selections: [
-                { selectionType: 'item', metabaseObjectId: 1 },
-                { selectionType: 'item', metabaseObjectId: 2 },
-            ],
-        });
-        const a = await adapter.describeScope(dir);
-        const b = await adapter.describeScope(dir);
-        expect(a.fingerprint).toBe(b.fingerprint);
-    });
-    it('different syncMode produces different fingerprint', async () => {
-        await writeSyncConfig({ ...BASE, syncMode: 'ALL', selections: [] });
-        const all = await adapter.describeScope(dir);
-        await writeSyncConfig({
-            ...BASE,
-            syncMode: 'ONLY',
-            selections: [{ selectionType: 'item', metabaseObjectId: 1 }],
-        });
-        const only = await adapter.describeScope(dir);
-        expect(all.fingerprint).not.toBe(only.fingerprint);
-    });
-});

package/dist/context/ingest/adapters/metabase/serialize-card.test.d.ts

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