@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/connector-sqlite/dist/connector.test.js

@@ -1,196 +0,0 @@
-import Database from 'better-sqlite3';
-import { writeFileSync } from 'node:fs';
-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 { createSqliteLiveDatabaseIntrospection, isKtxSqliteConnectionConfig, KtxSqliteScanConnector, sqliteDatabasePathFromConfig, } from './index.js';
-describe('KtxSqliteScanConnector', () => {
-    let tempDir;
-    let dbPath;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-connector-sqlite-'));
-        dbPath = join(tempDir, 'warehouse.db');
-        const db = new Database(dbPath);
-        db.exec(`
-      PRAGMA foreign_keys = ON;
-      CREATE TABLE customers (
-        id INTEGER PRIMARY KEY,
-        name TEXT NOT NULL,
-        tier TEXT
-      );
-      CREATE TABLE orders (
-        id INTEGER PRIMARY KEY,
-        customer_id INTEGER NOT NULL,
-        status TEXT,
-        total NUMERIC,
-        created_at TEXT,
-        FOREIGN KEY(customer_id) REFERENCES customers(id)
-      );
-      CREATE VIEW recent_orders AS SELECT id, customer_id, status FROM orders;
-      INSERT INTO customers (id, name, tier) VALUES (1, 'Ada', 'enterprise'), (2, 'Grace', 'growth');
-      INSERT INTO orders (id, customer_id, status, total, created_at)
-        VALUES (10, 1, 'paid', 42.5, '2026-04-28'), (11, 2, 'open', 9.5, '2026-04-29');
-    `);
-        db.close();
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('resolves SQLite path configuration safely', () => {
-        const originalDatabaseUrl = process.env.KTX_SQLITE_TEST_URL;
-        const pointerPath = join(tempDir, 'sqlite-path.txt');
-        process.env.KTX_SQLITE_TEST_URL = `sqlite:${dbPath}`;
-        writeFileSync(pointerPath, dbPath, 'utf-8');
-        try {
-            expect(isKtxSqliteConnectionConfig({ driver: 'sqlite', path: 'warehouse.db' })).toBe(true);
-            expect(isKtxSqliteConnectionConfig({ driver: 'postgres', url: 'env:DATABASE_URL' })).toBe(false);
-            expect(sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', path: 'warehouse.db' },
-            })).toBe(dbPath);
-            expect(sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', url: 'env:KTX_SQLITE_TEST_URL' },
-            })).toBe(dbPath);
-            expect(sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', url: `file://${dbPath}` },
-            })).toBe(dbPath);
-            expect(sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', path: `file:${pointerPath}` },
-            })).toBe(dbPath);
-            expect(sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', path: 'warehouse.db' },
-            })).toBe(dbPath);
-            expect(() => sqliteDatabasePathFromConfig({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', file_path: 'warehouse.db' },
-            })).toThrow('Native SQLite connector requires connections.warehouse.path or url');
-        }
-        finally {
-            if (originalDatabaseUrl === undefined) {
-                delete process.env.KTX_SQLITE_TEST_URL;
-            }
-            else {
-                process.env.KTX_SQLITE_TEST_URL = originalDatabaseUrl;
-            }
-        }
-    });
-    it('introspects schema, primary keys, row counts, views, and foreign keys', async () => {
-        const connector = new KtxSqliteScanConnector({
-            connectionId: 'warehouse',
-            connection: { driver: 'sqlite', path: dbPath },
-            now: () => new Date('2026-04-29T10:00:00.000Z'),
-        });
-        const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'sqlite' }, { runId: 'scan-run-1' });
-        expect(snapshot).toMatchObject({
-            connectionId: 'warehouse',
-            driver: 'sqlite',
-            extractedAt: '2026-04-29T10:00:00.000Z',
-            metadata: {
-                file_path: dbPath,
-                table_count: 3,
-                total_columns: 11,
-            },
-        });
-        expect(snapshot.tables.map((table) => [table.name, table.kind, table.estimatedRows])).toEqual([
-            ['customers', 'table', 2],
-            ['orders', 'table', 2],
-            ['recent_orders', 'view', null],
-        ]);
-        expect(snapshot.tables.find((table) => table.name === 'customers')?.columns[0]).toMatchObject({
-            name: 'id',
-            nativeType: 'INTEGER',
-            normalizedType: 'INTEGER',
-            dimensionType: 'number',
-            nullable: false,
-            primaryKey: true,
-        });
-        expect(snapshot.tables.find((table) => table.name === 'orders')?.foreignKeys).toEqual([
-            {
-                fromColumn: 'customer_id',
-                toCatalog: null,
-                toDb: null,
-                toTable: 'customers',
-                toColumn: 'id',
-                constraintName: null,
-            },
-        ]);
-    });
-    it('runs samples, distinct values, statistics, and read-only SQL', async () => {
-        const connector = new KtxSqliteScanConnector({
-            connectionId: 'warehouse',
-            connection: { driver: 'sqlite', path: dbPath },
-        });
-        await expect(connector.sampleTable({ connectionId: 'warehouse', table: { catalog: null, db: null, name: 'orders' }, columns: ['id'], limit: 1 }, { runId: 'scan-run-1' })).resolves.toEqual({ headers: ['id'], rows: [[10]], totalRows: 1 });
-        await expect(connector.sampleColumn({ connectionId: 'warehouse', table: { catalog: null, db: null, name: 'orders' }, column: 'status', limit: 5 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ values: ['paid', 'open'], nullCount: null, distinctCount: null });
-        await expect(connector.getColumnDistinctValues({ catalog: null, db: null, name: 'orders' }, 'status', { maxCardinality: 5, limit: 10, sampleSize: 100 })).resolves.toEqual({ values: ['open', 'paid'], cardinality: 2 });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select id, status from orders order by id', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toEqual({ headers: ['id', 'status'], rows: [[10, 'paid']], totalRows: 1, rowCount: 1 });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'delete from orders' }, { runId: 'scan-run-1' })).rejects.toThrow('Only read-only SELECT/WITH queries can be executed locally');
-        await expect(connector.columnStats({ connectionId: 'warehouse', table: { catalog: null, db: null, name: 'orders' }, column: 'status' }, { runId: 'scan-run-1' })).resolves.toBeNull();
-    });
-    it('adapts native SQLite snapshots to live-database introspection for local ingest', async () => {
-        const introspection = createSqliteLiveDatabaseIntrospection({
-            projectDir: tempDir,
-            connections: {
-                warehouse: { driver: 'sqlite', path: 'warehouse.db' },
-            },
-            now: () => new Date('2026-04-29T10:00:00.000Z'),
-        });
-        const snapshot = await introspection.extractSchema('warehouse');
-        expect(snapshot).toMatchObject({
-            connectionId: 'warehouse',
-            extractedAt: '2026-04-29T10:00:00.000Z',
-        });
-        expect(snapshot.tables.find((table) => table.name === 'customers')).toMatchObject({
-            name: 'customers',
-            catalog: null,
-            db: null,
-            columns: [
-                {
-                    name: 'id',
-                    nativeType: 'INTEGER',
-                    normalizedType: 'INTEGER',
-                    dimensionType: 'number',
-                    nullable: false,
-                    primaryKey: true,
-                    comment: null,
-                },
-                {
-                    name: 'name',
-                    nativeType: 'TEXT',
-                    normalizedType: 'TEXT',
-                    dimensionType: 'string',
-                    nullable: false,
-                    primaryKey: false,
-                    comment: null,
-                },
-                {
-                    name: 'tier',
-                    nativeType: 'TEXT',
-                    normalizedType: 'TEXT',
-                    dimensionType: 'string',
-                    nullable: true,
-                    primaryKey: false,
-                    comment: null,
-                },
-            ],
-            foreignKeys: [],
-        });
-        expect(snapshot.tables.find((table) => table.name === 'orders')).toMatchObject({
-            name: 'orders',
-            catalog: null,
-            db: null,
-            foreignKeys: [{ fromColumn: 'customer_id', toTable: 'customers', toColumn: 'id' }],
-        });
-    });
-});

package/node_modules/@ktx/connector-sqlite/dist/dialect.d.ts

@@ -1,29 +0,0 @@
-import type { KtxSchemaDimensionType, KtxTableRef } from '@ktx/context/scan';
-type SqliteTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxSqliteDialect {
-    readonly type = "sqlite";
-    private readonly typeMappings;
-    quoteIdentifier(identifier: string): string;
-    formatTableName(table: SqliteTableNameRef): string;
-    mapDataType(nativeType: string): string;
-    mapToDimensionType(nativeType: string): KtxSchemaDimensionType;
-    generateSampleQuery(tableName: string, limit: number, columns?: string[]): string;
-    generateColumnSampleQuery(tableName: string, columnName: string, limit: number): string;
-    prepareQuery(sql: string, params?: Record<string, unknown>): {
-        sql: string;
-        params?: unknown;
-    };
-    getRandomSampleFilter(samplePct: number): string;
-    getTableSampleClause(_samplePct: number): string;
-    getLimitOffsetClause(limit: number, offset?: number): string;
-    getNullCountExpression(column: string): string;
-    getDistinctCountExpression(column: string): string;
-    generateCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
-    generateDistinctValuesQuery(tableName: string, columnName: string, limit: number): string;
-    generateColumnStatisticsQuery(_schemaName: string, _tableName: string): string | null;
-    generateRandomizedCardinalitySampleQuery(tableName: string, columnName: string, sampleSize: number): string;
-    getTimeTruncExpression(column: string, granularity: 'day' | 'week' | 'month' | 'quarter' | 'year', _timezone?: string): string;
-    getCustomTimeTruncExpression(column: string, interval: string, origin?: string, _timezone?: string): string;
-    parseIntervalToSql(interval: string): string;
-}
-export {};

package/node_modules/@ktx/connector-sqlite/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { KtxSqliteDialect } from './dialect.js';
-export { isKtxSqliteConnectionConfig, KtxSqliteScanConnector, sqliteDatabasePathFromConfig, type KtxSqliteColumnDistinctValuesOptions, type KtxSqliteColumnDistinctValuesResult, type KtxSqliteConnectionConfig, type KtxSqliteReadOnlyQueryInput, type KtxSqliteScanConnectorOptions, type SqliteDatabasePathInput, } from './connector.js';
-export { createSqliteLiveDatabaseIntrospection, type CreateSqliteLiveDatabaseIntrospectionOptions, } from './live-database-introspection.js';

package/node_modules/@ktx/connector-sqlite/dist/index.js

@@ -1,3 +0,0 @@
-export { KtxSqliteDialect } from './dialect.js';
-export { isKtxSqliteConnectionConfig, KtxSqliteScanConnector, sqliteDatabasePathFromConfig, } from './connector.js';
-export { createSqliteLiveDatabaseIntrospection, } from './live-database-introspection.js';

package/node_modules/@ktx/connector-sqlite/dist/live-database-introspection.d.ts

@@ -1,8 +0,0 @@
-import type { LiveDatabaseIntrospectionPort } from '@ktx/context/ingest';
-import type { KtxProjectConnectionConfig } from '@ktx/context/project';
-export interface CreateSqliteLiveDatabaseIntrospectionOptions {
-    projectDir?: string;
-    connections: Record<string, KtxProjectConnectionConfig>;
-    now?: () => Date;
-}
-export declare function createSqliteLiveDatabaseIntrospection(options: CreateSqliteLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;

package/node_modules/@ktx/connector-sqlite/dist/live-database-introspection.js

@@ -1,20 +0,0 @@
-import { KtxSqliteScanConnector } from './connector.js';
-export function createSqliteLiveDatabaseIntrospection(options) {
-    return {
-        async extractSchema(connectionId) {
-            const connection = options.connections[connectionId];
-            const connector = new KtxSqliteScanConnector({
-                connectionId,
-                connection,
-                projectDir: options.projectDir,
-                now: options.now,
-            });
-            try {
-                return await connector.introspect({ connectionId, driver: 'sqlite' }, { runId: `sqlite-${connectionId}` });
-            }
-            finally {
-                await connector.cleanup();
-            }
-        },
-    };
-}

package/node_modules/@ktx/connector-sqlite/dist/package-exports.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-describe('@ktx/connector-sqlite package exports', () => {
-    it('exports the native SQLite scan connector surface', async () => {
-        const connector = await import('./index.js');
-        expect(connector.KtxSqliteDialect).toBeTypeOf('function');
-        expect(connector.KtxSqliteScanConnector).toBeTypeOf('function');
-        expect(connector.createSqliteLiveDatabaseIntrospection).toBeTypeOf('function');
-        expect(connector.isKtxSqliteConnectionConfig).toBeTypeOf('function');
-        expect(connector.sqliteDatabasePathFromConfig).toBeTypeOf('function');
-    });
-});

package/node_modules/@ktx/connector-sqlite/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@ktx/connector-sqlite",
-  "version": "0.0.0-private",
-  "private": true,
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
-  ],
-  "license": "Apache-2.0"
-}

package/node_modules/@ktx/connector-sqlserver/dist/connector.d.ts

@@ -1,137 +0,0 @@
-import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '@ktx/context/scan';
-export interface KtxSqlServerConnectionConfig {
-    driver?: string;
-    host?: string;
-    port?: number;
-    database?: string;
-    username?: string;
-    user?: string;
-    password?: string;
-    url?: string;
-    schema?: string;
-    schemas?: string[];
-    trustServerCertificate?: boolean;
-    [key: string]: unknown;
-}
-export interface KtxSqlServerPoolConfig {
-    server: string;
-    port: number;
-    database: string;
-    user: string;
-    password?: string;
-    options: {
-        encrypt: true;
-        trustServerCertificate: boolean;
-    };
-    pool: {
-        max: number;
-        min: number;
-        idleTimeoutMillis: number;
-    };
-}
-export interface KtxSqlServerQueryResult {
-    recordset?: Array<Record<string, unknown>> & {
-        columns?: Record<string, {
-            type?: {
-                declaration?: string;
-            };
-        }>;
-    };
-}
-interface KtxSqlServerRequest {
-    input(name: string, value: unknown): KtxSqlServerRequest;
-    query(query: string): Promise<KtxSqlServerQueryResult>;
-}
-export interface KtxSqlServerPool {
-    request(): KtxSqlServerRequest;
-    close(): Promise<void>;
-}
-export interface KtxSqlServerPoolFactory {
-    createPool(config: KtxSqlServerPoolConfig): Promise<KtxSqlServerPool>;
-}
-interface KtxSqlServerResolvedEndpoint {
-    host: string;
-    port: number;
-    close?: () => Promise<void>;
-}
-export interface KtxSqlServerEndpointResolver {
-    resolve(input: {
-        host: string;
-        port: number;
-        connection: KtxSqlServerConnectionConfig;
-    }): Promise<KtxSqlServerResolvedEndpoint>;
-}
-export interface KtxSqlServerScanConnectorOptions {
-    connectionId: string;
-    connection: KtxSqlServerConnectionConfig | undefined;
-    poolFactory?: KtxSqlServerPoolFactory;
-    endpointResolver?: KtxSqlServerEndpointResolver;
-    env?: NodeJS.ProcessEnv;
-    now?: () => Date;
-}
-export interface KtxSqlServerReadOnlyQueryInput extends KtxReadOnlyQueryInput {
-    params?: Record<string, unknown>;
-}
-export interface KtxSqlServerColumnDistinctValuesOptions {
-    maxCardinality: number;
-    limit: number;
-    sampleSize?: number;
-}
-export interface KtxSqlServerColumnDistinctValuesResult {
-    values: string[] | null;
-    cardinality: number;
-}
-interface KtxSqlServerTableSampleResult extends KtxTableSampleResult {
-    headerTypes?: string[];
-}
-export declare function isKtxSqlServerConnectionConfig(connection: KtxSqlServerConnectionConfig | undefined): connection is KtxSqlServerConnectionConfig;
-export declare function sqlServerConnectionPoolConfigFromConfig(input: {
-    connectionId: string;
-    connection: KtxSqlServerConnectionConfig | undefined;
-    env?: NodeJS.ProcessEnv;
-}): KtxSqlServerPoolConfig;
-export declare class KtxSqlServerScanConnector implements KtxScanConnector {
-    readonly id: string;
-    readonly driver: "sqlserver";
-    readonly capabilities: import("@ktx/context/scan").KtxConnectorCapabilities;
-    private readonly connectionId;
-    private readonly connection;
-    private readonly poolConfig;
-    private readonly schemas;
-    private readonly poolFactory;
-    private readonly endpointResolver?;
-    private readonly now;
-    private readonly dialect;
-    private pool;
-    private resolvedEndpoint;
-    constructor(options: KtxSqlServerScanConnectorOptions);
-    testConnection(): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
-    sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxSqlServerTableSampleResult>;
-    sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
-    columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
-    executeReadOnly(input: KtxSqlServerReadOnlyQueryInput, _ctx: KtxScanContext): Promise<KtxQueryResult>;
-    getColumnDistinctValues(table: KtxTableRef, columnName: string, options: KtxSqlServerColumnDistinctValuesOptions): Promise<KtxSqlServerColumnDistinctValuesResult | null>;
-    getTableRowCount(tableName: string, schemaName?: string): Promise<number>;
-    qTableName(table: Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>): string;
-    quoteIdentifier(identifier: string): string;
-    listSchemas(): Promise<string[]>;
-    listTables(schemas?: string[]): Promise<KtxTableListEntry[]>;
-    cleanup(): Promise<void>;
-    private introspectSchema;
-    private tableComments;
-    private columnComments;
-    private primaryKeys;
-    private foreignKeys;
-    private rowCounts;
-    private toSchemaColumn;
-    private toSchemaForeignKey;
-    private poolForQuery;
-    private queryRaw;
-    private query;
-    private assertConnection;
-}
-export {};