@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/types.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { aggregatedTemplateSchema, historicSqlUnifiedPullConfigSchema, stagedManifestSchema, stagedPatternsInputSchema, stagedTableInputSchema, } from './types.js';
-describe('historic-sql unified contracts', () => {
-    it('parses minExecutions and service-account filters', () => {
-        expect(historicSqlUnifiedPullConfigSchema.parse({ dialect: 'postgres', minExecutions: 9 })).toMatchObject({
-            dialect: 'postgres',
-            minExecutions: 9,
-            redactionPatterns: [],
-            staleArchiveAfterDays: 90,
-        });
-        expect(historicSqlUnifiedPullConfigSchema.parse({ dialect: 'postgres', minExecutions: 9 })).not.toHaveProperty('windowDays');
-        expect(historicSqlUnifiedPullConfigSchema.parse({ dialect: 'postgres', minExecutions: 9 })).not.toHaveProperty('concurrency');
-        const parsed = historicSqlUnifiedPullConfigSchema.parse({
-            dialect: 'postgres',
-            minExecutions: 7,
-            filters: {
-                serviceAccounts: { patterns: ['^svc_'], mode: 'exclude' },
-            },
-        });
-        expect(parsed.minExecutions).toBe(7);
-        expect(parsed.filters.serviceAccounts).toEqual({ patterns: ['^svc_'], mode: 'exclude' });
-    });
-    it('validates aggregate templates from warehouse readers', () => {
-        const parsed = aggregatedTemplateSchema.parse({
-            templateId: 'pg:123',
-            canonicalSql: 'select status, count(*) from public.orders group by status',
-            dialect: 'postgres',
-            stats: {
-                executions: 42,
-                distinctUsers: 3,
-                firstSeen: '2026-05-01T00:00:00.000Z',
-                lastSeen: '2026-05-11T00:00:00.000Z',
-                p50RuntimeMs: 12.5,
-                p95RuntimeMs: 40,
-                errorRate: 0,
-                rowsProduced: 100,
-            },
-            topUsers: [{ user: 'analyst', executions: 40 }],
-        });
-        expect(parsed.templateId).toBe('pg:123');
-        expect(parsed.topUsers).toEqual([{ user: 'analyst', executions: 40 }]);
-    });
-    it('validates staged table, patterns, and manifest artifacts', () => {
-        expect(stagedTableInputSchema.parse({
-            table: 'public.orders',
-            stats: {
-                executionsBucket: '10-100',
-                distinctUsersBucket: '2-5',
-                errorRateBucket: 'none',
-                p95RuntimeBucket: '<100ms',
-                recencyBucket: 'current',
-            },
-            columnsByClause: {
-                select: [['status', 'high']],
-                where: [['created_at', 'mid']],
-            },
-            observedJoins: [{ withTable: 'public.customers', on: ['customer_id'], freq: 'high' }],
-            topTemplates: [{ id: 'pg:123', canonicalSql: 'select * from public.orders', topUsers: [{ user: 'analyst' }] }],
-        }).table).toBe('public.orders');
-        expect(stagedPatternsInputSchema.parse({
-            templates: [
-                {
-                    id: 'pg:123',
-                    canonicalSql: 'select * from public.orders',
-                    tablesTouched: ['public.orders'],
-                    executionsBucket: '10-100',
-                    distinctUsersBucket: '2-5',
-                    dialect: 'postgres',
-                },
-            ],
-        }).templates).toHaveLength(1);
-        expect(stagedManifestSchema.parse({
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 2,
-            touchedTableCount: 1,
-            parseFailures: 1,
-            warnings: ['parse_failed:bad'],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        }).staleArchiveAfterDays).toBe(90);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/chunk.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/chunk.test.js

@@ -1,95 +0,0 @@
-import { mkdtemp } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { chunkLiveDatabaseStagedDir } from './chunk.js';
-import { liveDatabaseTablePath, writeLiveDatabaseSnapshot } from './stage.js';
-function snapshot() {
-    return {
-        connectionId: 'conn-1',
-        driver: 'postgres',
-        extractedAt: '2026-04-27T00:00:00.000Z',
-        scope: { schemas: ['public'] },
-        metadata: {},
-        tables: [
-            {
-                name: 'orders',
-                catalog: null,
-                db: 'public',
-                kind: 'table',
-                comment: null,
-                estimatedRows: null,
-                columns: [
-                    {
-                        name: 'id',
-                        nativeType: 'integer',
-                        normalizedType: 'integer',
-                        dimensionType: 'number',
-                        nullable: false,
-                        primaryKey: true,
-                        comment: null,
-                    },
-                ],
-                foreignKeys: [],
-            },
-            {
-                name: 'customers',
-                catalog: null,
-                db: 'public',
-                kind: 'table',
-                comment: null,
-                estimatedRows: null,
-                columns: [
-                    {
-                        name: 'id',
-                        nativeType: 'integer',
-                        normalizedType: 'integer',
-                        dimensionType: 'number',
-                        nullable: false,
-                        primaryKey: true,
-                        comment: null,
-                    },
-                ],
-                foreignKeys: [],
-            },
-        ],
-    };
-}
-describe('chunkLiveDatabaseStagedDir', () => {
-    it('emits one work unit per table on the first run', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'ktx-live-db-chunk-'));
-        await writeLiveDatabaseSnapshot(dir, snapshot());
-        const result = await chunkLiveDatabaseStagedDir(dir);
-        expect(result.workUnits.map((wu) => wu.unitKey)).toEqual([
-            'live-database-public-customers',
-            'live-database-public-orders',
-        ]);
-        expect(result.workUnits[0]?.dependencyPaths).toEqual(['connection.json', 'foreign-keys.json']);
-        expect(result.workUnits[0]?.peerFileIndex).toContain(liveDatabaseTablePath({ catalog: null, db: 'public', name: 'orders' }));
-    });
-    it('keeps only changed tables during incremental syncs and records table evictions', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'ktx-live-db-diff-'));
-        await writeLiveDatabaseSnapshot(dir, snapshot());
-        const ordersPath = liveDatabaseTablePath({ catalog: null, db: 'public', name: 'orders' });
-        const customersPath = liveDatabaseTablePath({ catalog: null, db: 'public', name: 'customers' });
-        const result = await chunkLiveDatabaseStagedDir(dir, {
-            added: [],
-            modified: [ordersPath],
-            deleted: [customersPath],
-            unchanged: ['connection.json', 'foreign-keys.json'],
-        });
-        expect(result.workUnits.map((wu) => wu.unitKey)).toEqual(['live-database-public-orders']);
-        expect(result.eviction?.deletedRawPaths).toEqual([customersPath]);
-    });
-    it('fans out all table work units when the foreign-key index changes', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'ktx-live-db-fk-'));
-        await writeLiveDatabaseSnapshot(dir, snapshot());
-        const result = await chunkLiveDatabaseStagedDir(dir, {
-            added: [],
-            modified: ['foreign-keys.json'],
-            deleted: [],
-            unchanged: [],
-        });
-        expect(result.workUnits).toHaveLength(2);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.d.ts

@@ -1,20 +0,0 @@
-import type { KtxProjectConnectionConfig } from '../../../project/config.js';
-import type { LiveDatabaseIntrospectionPort } from './types.js';
-export type KtxDaemonDatabaseIntrospectionCommand = 'database-introspect';
-export type KtxDaemonDatabaseJsonRunner = (subcommand: KtxDaemonDatabaseIntrospectionCommand, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
-export type KtxDaemonDatabaseHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
-export interface DaemonLiveDatabaseIntrospectionOptions {
-    connections: Record<string, KtxProjectConnectionConfig>;
-    schemas?: string[];
-    statementTimeoutMs?: number;
-    connectionTimeoutSeconds?: number;
-    command?: string;
-    args?: string[];
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    baseUrl?: string;
-    runJson?: KtxDaemonDatabaseJsonRunner;
-    requestJson?: KtxDaemonDatabaseHttpJsonRunner;
-    now?: () => Date;
-}
-export declare function createDaemonLiveDatabaseIntrospection(options: DaemonLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.js

@@ -1,190 +0,0 @@
-import { spawn } from 'node:child_process';
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { URL } from 'node:url';
-import { filterSnapshotTables, resolveEnabledTables } from '../../../scan/enabled-tables.js';
-import { inferKtxDimensionType, normalizeKtxNativeType } from '../../../scan/type-normalization.js';
-const DEFAULT_SCHEMAS = ['public'];
-function parseJsonObject(raw, subcommand) {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`ktx-daemon ${subcommand} returned non-object JSON`);
-    }
-    return parsed;
-}
-function runProcessJson(options) {
-    return async (subcommand, payload) => new Promise((resolve, reject) => {
-        const child = spawn(options.command, [...options.args, subcommand], {
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const stdout = [];
-        const stderr = [];
-        child.stdout.on('data', (chunk) => stdout.push(chunk));
-        child.stderr.on('data', (chunk) => stderr.push(chunk));
-        child.on('error', reject);
-        child.on('close', (code) => {
-            const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
-            const stderrText = Buffer.concat(stderr).toString('utf8').trim();
-            if (code !== 0) {
-                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
-                return;
-            }
-            try {
-                resolve(parseJsonObject(stdoutText, subcommand));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        child.stdin.end(`${JSON.stringify(payload)}\n`);
-    });
-}
-function normalizedBaseUrl(baseUrl) {
-    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-}
-function postJson(baseUrl) {
-    return async (path, payload) => new Promise((resolve, reject) => {
-        const target = new URL(path.replace(/^\//, ''), normalizedBaseUrl(baseUrl));
-        const body = JSON.stringify(payload);
-        const client = target.protocol === 'https:' ? httpsRequest : httpRequest;
-        const request = client(target, {
-            method: 'POST',
-            headers: {
-                accept: 'application/json',
-                'content-type': 'application/json',
-                'content-length': Buffer.byteLength(body),
-            },
-        }, (response) => {
-            const chunks = [];
-            response.on('data', (chunk) => chunks.push(chunk));
-            response.on('end', () => {
-                const text = Buffer.concat(chunks).toString('utf8');
-                const statusCode = response.statusCode ?? 0;
-                if (statusCode < 200 || statusCode >= 300) {
-                    reject(new Error(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`));
-                    return;
-                }
-                try {
-                    resolve(parseJsonObject(text, path));
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
-        request.on('error', reject);
-        request.end(body);
-    });
-}
-function recordValue(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-function recordArray(value) {
-    return Array.isArray(value)
-        ? value.filter((item) => item !== null && typeof item === 'object' && !Array.isArray(item))
-        : [];
-}
-function requiredString(value, field) {
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`ktx-daemon database introspection response is missing string field ${field}`);
-    }
-    return value;
-}
-function nullableString(value) {
-    return typeof value === 'string' ? value : null;
-}
-function optionalString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function normalizeDriver(driver) {
-    const normalized = String(driver ?? '').trim().toLowerCase();
-    return normalized === 'postgresql' ? 'postgres' : normalized;
-}
-function requirePostgresConnection(connections, connectionId) {
-    const connection = connections[connectionId];
-    const driver = normalizeDriver(connection?.driver);
-    if (driver !== 'postgres') {
-        throw new Error(`Local live-database ingest cannot run driver "${connection?.driver ?? 'unknown'}".`);
-    }
-    if (typeof connection.url !== 'string' || connection.url.trim().length === 0) {
-        throw new Error(`Local live-database ingest requires connections.${connectionId}.url.`);
-    }
-    return connection;
-}
-function mapColumn(raw) {
-    const nativeType = requiredString(raw.type, 'tables[].columns[].type');
-    return {
-        name: requiredString(raw.name, 'tables[].columns[].name'),
-        nativeType,
-        normalizedType: normalizeKtxNativeType(nativeType),
-        dimensionType: inferKtxDimensionType(nativeType),
-        nullable: raw.nullable !== false ? true : false,
-        primaryKey: raw.primary_key === true,
-        comment: nullableString(raw.comment),
-    };
-}
-function mapForeignKey(raw) {
-    return {
-        fromColumn: requiredString(raw.from_column, 'tables[].foreign_keys[].from_column'),
-        toCatalog: null,
-        toDb: null,
-        toTable: requiredString(raw.to_table, 'tables[].foreign_keys[].to_table'),
-        toColumn: requiredString(raw.to_column, 'tables[].foreign_keys[].to_column'),
-        constraintName: nullableString(raw.constraint_name),
-    };
-}
-function mapTable(raw) {
-    return {
-        catalog: nullableString(raw.catalog),
-        db: nullableString(raw.db),
-        name: requiredString(raw.name, 'tables[].name'),
-        kind: 'table',
-        comment: nullableString(raw.comment),
-        estimatedRows: null,
-        columns: recordArray(raw.columns).map(mapColumn),
-        foreignKeys: recordArray(raw.foreign_keys).map(mapForeignKey),
-    };
-}
-function mapDaemonSnapshot(raw, input) {
-    return {
-        connectionId: requiredString(raw.connection_id, 'connection_id') || input.connectionId,
-        driver: 'postgres',
-        extractedAt: optionalString(raw.extracted_at) ?? input.extractedAt,
-        scope: { schemas: input.schemas },
-        metadata: recordValue(raw.metadata),
-        tables: recordArray(raw.tables).map(mapTable),
-    };
-}
-export function createDaemonLiveDatabaseIntrospection(options) {
-    const schemas = options.schemas ?? DEFAULT_SCHEMAS;
-    const command = options.command ?? 'python';
-    const args = options.args ?? ['-m', 'ktx_daemon'];
-    const runJson = options.runJson ?? runProcessJson({ command, args, cwd: options.cwd, env: options.env });
-    const requestJson = options.requestJson ?? (options.baseUrl ? postJson(options.baseUrl) : undefined);
-    const now = options.now ?? (() => new Date());
-    return {
-        async extractSchema(connectionId) {
-            const connection = requirePostgresConnection(options.connections, connectionId);
-            const payload = {
-                connection_id: connectionId,
-                driver: normalizeDriver(connection.driver),
-                url: connection.url,
-                schemas,
-                statement_timeout_ms: options.statementTimeoutMs ?? 30_000,
-                connection_timeout_seconds: options.connectionTimeoutSeconds ?? 5,
-            };
-            const raw = requestJson
-                ? await requestJson('/database/introspect', payload)
-                : await runJson('database-introspect', payload);
-            const snapshot = mapDaemonSnapshot(raw, {
-                connectionId,
-                extractedAt: now().toISOString(),
-                schemas,
-            });
-            const enabledTables = resolveEnabledTables(connection);
-            return enabledTables ? filterSnapshotTables(snapshot, enabledTables) : snapshot;
-        },
-    };
-}

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/daemon-introspection.test.js

@@ -1,236 +0,0 @@
-import { once } from 'node:events';
-import { createServer } from 'node:http';
-import { describe, expect, it, vi } from 'vitest';
-import { createDaemonLiveDatabaseIntrospection } from './daemon-introspection.js';
-const daemonResponse = {
-    connection_id: 'warehouse',
-    extracted_at: '2026-04-28T10:00:00+00:00',
-    metadata: { driver: 'postgres', schemas: ['public'] },
-    tables: [
-        {
-            catalog: 'warehouse',
-            db: 'public',
-            name: 'customers',
-            comment: null,
-            columns: [{ name: 'id', type: 'integer', nullable: false, primary_key: true, comment: null }],
-            foreign_keys: [],
-        },
-        {
-            catalog: 'warehouse',
-            db: 'public',
-            name: 'orders',
-            comment: 'Order facts',
-            columns: [
-                { name: 'id', type: 'integer', nullable: false, primary_key: true, comment: 'Order id' },
-                { name: 'customer_id', type: 'integer', nullable: false, primary_key: false, comment: null },
-            ],
-            foreign_keys: [
-                {
-                    from_column: 'customer_id',
-                    to_table: 'customers',
-                    to_column: 'id',
-                    constraint_name: 'orders_customer_id_fkey',
-                },
-            ],
-        },
-    ],
-};
-describe('createDaemonLiveDatabaseIntrospection', () => {
-    it('calls the database-introspect daemon command and maps the snapshot response', async () => {
-        const runJson = vi.fn(async () => daemonResponse);
-        const introspection = createDaemonLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'postgres',
-                    url: 'postgres://localhost:5432/warehouse',
-                },
-            },
-            schemas: ['public'],
-            runJson,
-        });
-        await expect(introspection.extractSchema('warehouse')).resolves.toEqual({
-            connectionId: 'warehouse',
-            driver: 'postgres',
-            extractedAt: '2026-04-28T10:00:00+00:00',
-            scope: { schemas: ['public'] },
-            metadata: { driver: 'postgres', schemas: ['public'] },
-            tables: [
-                {
-                    catalog: 'warehouse',
-                    db: 'public',
-                    name: 'customers',
-                    kind: 'table',
-                    comment: null,
-                    estimatedRows: null,
-                    columns: [
-                        {
-                            name: 'id',
-                            nativeType: 'integer',
-                            normalizedType: 'integer',
-                            dimensionType: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            comment: null,
-                        },
-                    ],
-                    foreignKeys: [],
-                },
-                {
-                    catalog: 'warehouse',
-                    db: 'public',
-                    name: 'orders',
-                    kind: 'table',
-                    comment: 'Order facts',
-                    estimatedRows: null,
-                    columns: [
-                        {
-                            name: 'id',
-                            nativeType: 'integer',
-                            normalizedType: 'integer',
-                            dimensionType: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            comment: 'Order id',
-                        },
-                        {
-                            name: 'customer_id',
-                            nativeType: 'integer',
-                            normalizedType: 'integer',
-                            dimensionType: 'number',
-                            nullable: false,
-                            primaryKey: false,
-                            comment: null,
-                        },
-                    ],
-                    foreignKeys: [
-                        {
-                            fromColumn: 'customer_id',
-                            toCatalog: null,
-                            toDb: null,
-                            toTable: 'customers',
-                            toColumn: 'id',
-                            constraintName: 'orders_customer_id_fkey',
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(runJson).toHaveBeenCalledWith('database-introspect', {
-            connection_id: 'warehouse',
-            driver: 'postgres',
-            url: 'postgres://localhost:5432/warehouse',
-            schemas: ['public'],
-            statement_timeout_ms: 30_000,
-            connection_timeout_seconds: 5,
-        });
-    });
-    it('calls a running daemon HTTP endpoint when baseUrl is configured', async () => {
-        const requests = [];
-        const server = createServer((request, response) => {
-            const chunks = [];
-            request.on('data', (chunk) => chunks.push(chunk));
-            request.on('end', () => {
-                requests.push({
-                    url: request.url,
-                    body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-                });
-                response.writeHead(200, { 'content-type': 'application/json' });
-                response.end(JSON.stringify(daemonResponse));
-            });
-        });
-        server.listen(0, '127.0.0.1');
-        await once(server, 'listening');
-        try {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                throw new Error('expected TCP server address');
-            }
-            const introspection = createDaemonLiveDatabaseIntrospection({
-                connections: {
-                    warehouse: {
-                        driver: 'postgresql',
-                        url: 'postgres://localhost:5432/warehouse',
-                    },
-                },
-                baseUrl: `http://127.0.0.1:${address.port}`,
-            });
-            await expect(introspection.extractSchema('warehouse')).resolves.toMatchObject({
-                connectionId: 'warehouse',
-                tables: [{ name: 'customers' }, { name: 'orders' }],
-            });
-            expect(requests).toEqual([
-                {
-                    url: '/database/introspect',
-                    body: {
-                        connection_id: 'warehouse',
-                        driver: 'postgres',
-                        url: 'postgres://localhost:5432/warehouse',
-                        schemas: ['public'],
-                        statement_timeout_ms: 30_000,
-                        connection_timeout_seconds: 5,
-                    },
-                },
-            ]);
-        }
-        finally {
-            server.close();
-        }
-    });
-    it('requires a configured postgres connection with a url', async () => {
-        const introspection = createDaemonLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'postgres',
-                },
-            },
-            runJson: vi.fn(async () => daemonResponse),
-        });
-        await expect(introspection.extractSchema('warehouse')).rejects.toThrow('Local live-database ingest requires connections.warehouse.url.');
-    });
-    it('rejects unsupported local connection drivers before calling the daemon', async () => {
-        const runJson = vi.fn(async () => daemonResponse);
-        const introspection = createDaemonLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'snowflake',
-                    url: 'snowflake://example',
-                },
-            },
-            runJson,
-        });
-        await expect(introspection.extractSchema('warehouse')).rejects.toThrow('Local live-database ingest cannot run driver "snowflake".');
-        expect(runJson).not.toHaveBeenCalled();
-    });
-    it('filters out tables not on the enabled_tables allowlist', async () => {
-        const runJson = vi.fn(async () => daemonResponse);
-        const introspection = createDaemonLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'postgres',
-                    url: 'postgres://localhost:5432/warehouse',
-                    enabled_tables: ['public.orders'],
-                },
-            },
-            schemas: ['public'],
-            runJson,
-        });
-        const snapshot = await introspection.extractSchema('warehouse');
-        expect(snapshot.tables.map((table) => `${table.db}.${table.name}`)).toEqual(['public.orders']);
-    });
-    it('passes through every table when enabled_tables is omitted or empty', async () => {
-        const runJson = vi.fn(async () => daemonResponse);
-        const introspection = createDaemonLiveDatabaseIntrospection({
-            connections: {
-                warehouse: {
-                    driver: 'postgres',
-                    url: 'postgres://localhost:5432/warehouse',
-                    enabled_tables: [],
-                },
-            },
-            schemas: ['public'],
-            runJson,
-        });
-        const snapshot = await introspection.extractSchema('warehouse');
-        expect(snapshot.tables.map((table) => table.name)).toEqual(['customers', 'orders']);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/extracted-schema.d.ts

@@ -1,29 +0,0 @@
-import type { KtxSchemaSnapshot, KtxSchemaTable } from '../../../scan/types.js';
-export interface LiveDatabaseExtractedForeignKey {
-    fromTable: string;
-    fromColumn: string;
-    toTable: string;
-    toColumn: string;
-    constraintName?: string;
-}
-export interface LiveDatabaseExtractedColumn {
-    name: string;
-    type: string;
-    nullable: boolean;
-    primaryKey: boolean;
-    dbComment: string | null;
-}
-export interface LiveDatabaseExtractedTable {
-    name: string;
-    catalog: string | null;
-    db: string | null;
-    dbComment: string | null;
-    columns: LiveDatabaseExtractedColumn[];
-    foreignKeys: LiveDatabaseExtractedForeignKey[];
-}
-export interface LiveDatabaseExtractedSchema {
-    connectionId?: string;
-    tables: LiveDatabaseExtractedTable[];
-}
-export declare function buildLiveDatabaseTableNaturalKey(table: Pick<KtxSchemaTable, 'catalog' | 'db' | 'name'>): string;
-export declare function ktxSchemaSnapshotToExtractedSchema(snapshot: KtxSchemaSnapshot): LiveDatabaseExtractedSchema;