@kaelio/ktx 0.0.0 → 0.1.0-rc.1

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

@@ -0,0 +1,269 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createSqlServerLiveDatabaseIntrospection, isKtxSqlServerConnectionConfig, KtxSqlServerScanConnector, sqlServerConnectionPoolConfigFromConfig, } from './index.js';
+function recordset(rows, columnNames) {
+    const withColumns = rows;
+    withColumns.columns = Object.fromEntries(columnNames.map((name) => [name, { type: { declaration: 'nvarchar' } }]));
+    return withColumns;
+}
+function result(rows, columnNames) {
+    return { recordset: recordset(rows, columnNames) };
+}
+function fakePoolFactory() {
+    const query = vi.fn(async (sql) => {
+        if (sql.includes('INFORMATION_SCHEMA.TABLES')) {
+            return result([
+                { table_name: 'customers', table_type: 'BASE TABLE' },
+                { table_name: 'orders', table_type: 'BASE TABLE' },
+                { table_name: 'order_summary', table_type: 'VIEW' },
+            ], ['table_name', 'table_type']);
+        }
+        if (sql.includes("ep.name = 'MS_Description'") && sql.includes('ep.minor_id = 0')) {
+            return result([{ table_name: 'customers', table_comment: 'Customer table' }], [
+                'table_name',
+                'table_comment',
+            ]);
+        }
+        if (sql.includes("ep.name = 'MS_Description'") && sql.includes('ep.minor_id = c.column_id')) {
+            return result([{ table_name: 'customers', column_name: 'id', column_comment: 'PK' }], [
+                'table_name',
+                'column_name',
+                'column_comment',
+            ]);
+        }
+        if (sql.includes('INFORMATION_SCHEMA.COLUMNS')) {
+            return result([
+                { table_name: 'customers', column_name: 'id', data_type: 'int', is_nullable: 'NO' },
+                { table_name: 'customers', column_name: 'name', data_type: 'nvarchar', is_nullable: 'NO' },
+                { table_name: 'orders', column_name: 'id', data_type: 'int', is_nullable: 'NO' },
+                { table_name: 'orders', column_name: 'customer_id', data_type: 'int', is_nullable: 'NO' },
+                { table_name: 'orders', column_name: 'status', data_type: 'nvarchar', is_nullable: 'YES' },
+                { table_name: 'order_summary', column_name: 'status', data_type: 'nvarchar', is_nullable: 'YES' },
+            ], ['table_name', 'column_name', 'data_type', 'is_nullable']);
+        }
+        if (sql.includes("CONSTRAINT_TYPE = 'PRIMARY KEY'")) {
+            return result([
+                { table_name: 'customers', column_name: 'id' },
+                { table_name: 'orders', column_name: 'id' },
+            ], ['table_name', 'column_name']);
+        }
+        if (sql.includes('REFERENTIAL_CONSTRAINTS')) {
+            return result([
+                {
+                    table_name: 'orders',
+                    column_name: 'customer_id',
+                    referenced_table_schema: 'dbo',
+                    referenced_table_name: 'customers',
+                    referenced_column_name: 'id',
+                    constraint_name: 'orders_customer_id_fk',
+                },
+            ], [
+                'table_name',
+                'column_name',
+                'referenced_table_schema',
+                'referenced_table_name',
+                'referenced_column_name',
+                'constraint_name',
+            ]);
+        }
+        if (sql.includes('sys.partitions') && sql.includes('GROUP BY t.name')) {
+            return result([
+                { table_name: 'customers', row_count: 2 },
+                { table_name: 'orders', row_count: 2 },
+            ], ['table_name', 'row_count']);
+        }
+        if (sql.includes('SELECT TOP 1 [id], [status] FROM [dbo].[orders]')) {
+            return result([{ id: 10, status: 'paid' }], ['id', 'status']);
+        }
+        if (sql.includes('SELECT TOP 1 * FROM (select id, status from dbo.orders) AS ktx_query_result')) {
+            return result([{ id: 10, status: 'paid' }], ['id', 'status']);
+        }
+        if (sql.includes('SELECT TOP 5 [status] FROM [dbo].[orders]')) {
+            return result([{ status: 'paid' }, { status: 'open' }], ['status']);
+        }
+        if (sql.includes('COUNT(DISTINCT val)')) {
+            return result([{ cardinality: 2 }], ['cardinality']);
+        }
+        if (sql.includes('SELECT TOP 10 val')) {
+            return result([{ val: 'open' }, { val: 'paid' }], ['val']);
+        }
+        if (sql.includes('SUM(p.rows) AS row_count') && sql.includes('t.name = @tableName')) {
+            return result([{ row_count: 2 }], ['row_count']);
+        }
+        if (sql.includes('SELECT s.name AS schema_name')) {
+            return result([{ schema_name: 'dbo' }, { schema_name: 'sales' }], ['schema_name']);
+        }
+        if (sql.trim() === 'SELECT 1') {
+            return result([{ ok: 1 }], ['ok']);
+        }
+        throw new Error(`Unexpected SQL: ${sql}`);
+    });
+    const request = {
+        input: vi.fn((_key, _value) => request),
+        query,
+    };
+    const close = vi.fn(async () => undefined);
+    return {
+        createPool: vi.fn(async () => ({
+            request: () => request,
+            close,
+        })),
+    };
+}
+describe('KtxSqlServerScanConnector', () => {
+    it('resolves SQL Server connection configuration safely', () => {
+        expect(isKtxSqlServerConnectionConfig({
+            driver: 'sqlserver',
+            host: 'localhost',
+            database: 'analytics',
+        })).toBe(true);
+        expect(isKtxSqlServerConnectionConfig({ driver: 'mysql', host: 'localhost', database: 'analytics' })).toBe(false);
+        expect(sqlServerConnectionPoolConfigFromConfig({
+            connectionId: 'warehouse',
+            connection: {
+                driver: 'sqlserver',
+                host: 'db.example.test',
+                port: 14330,
+                database: 'analytics',
+                username: 'reader',
+                trustServerCertificate: false,
+            },
+        })).toMatchObject({
+            server: 'db.example.test',
+            port: 14330,
+            database: 'analytics',
+            user: 'reader',
+            options: { encrypt: true, trustServerCertificate: false },
+        });
+    });
+    it('introspects schema, primary keys, comments, row counts, views, and foreign keys', async () => {
+        const connector = new KtxSqlServerScanConnector({
+            connectionId: 'warehouse',
+            connection: {
+                driver: 'sqlserver',
+                host: 'db.example.test',
+                database: 'analytics',
+                username: 'reader',
+                schema: 'dbo',
+            },
+            poolFactory: fakePoolFactory(),
+            now: () => new Date('2026-04-29T16:00:00.000Z'),
+        });
+        const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'sqlserver' }, { runId: 'scan-run-1' });
+        expect(snapshot).toMatchObject({
+            connectionId: 'warehouse',
+            driver: 'sqlserver',
+            extractedAt: '2026-04-29T16:00:00.000Z',
+            scope: { catalogs: ['analytics'], schemas: ['dbo'] },
+            metadata: {
+                database: 'analytics',
+                host: 'db.example.test',
+                schemas: ['dbo'],
+                table_count: 3,
+                total_columns: 6,
+            },
+        });
+        expect(snapshot.tables.map((table) => [table.name, table.kind, table.estimatedRows, table.comment])).toEqual([
+            ['customers', 'table', 2, 'Customer table'],
+            ['orders', 'table', 2, null],
+            ['order_summary', 'view', null, null],
+        ]);
+        expect(snapshot.tables.find((table) => table.name === 'customers')?.columns[0]).toMatchObject({
+            name: 'id',
+            nativeType: 'int',
+            normalizedType: 'int',
+            dimensionType: 'number',
+            nullable: false,
+            primaryKey: true,
+            comment: 'PK',
+        });
+        expect(snapshot.tables.find((table) => table.name === 'orders')?.foreignKeys).toEqual([
+            {
+                fromColumn: 'customer_id',
+                toCatalog: 'analytics',
+                toDb: 'dbo',
+                toTable: 'customers',
+                toColumn: 'id',
+                constraintName: 'orders_customer_id_fk',
+            },
+        ]);
+    });
+    it('runs samples, distinct values, read-only SQL, row count, schema list, and cleanup', async () => {
+        const poolFactory = fakePoolFactory();
+        const connector = new KtxSqlServerScanConnector({
+            connectionId: 'warehouse',
+            connection: {
+                driver: 'sqlserver',
+                host: 'db.example.test',
+                database: 'analytics',
+                username: 'reader',
+                schema: 'dbo',
+            },
+            poolFactory,
+        });
+        await expect(connector.sampleTable({
+            connectionId: 'warehouse',
+            table: { catalog: 'analytics', db: 'dbo', name: 'orders' },
+            columns: ['id', 'status'],
+            limit: 1,
+        }, { runId: 'scan-run-1' })).resolves.toEqual({
+            headers: ['id', 'status'],
+            headerTypes: ['nvarchar', 'nvarchar'],
+            rows: [[10, 'paid']],
+            totalRows: 1,
+        });
+        await expect(connector.sampleColumn({ connectionId: 'warehouse', table: { catalog: 'analytics', db: 'dbo', name: 'orders' }, column: 'status', limit: 5 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ values: ['paid', 'open'], nullCount: null, distinctCount: null });
+        await expect(connector.getColumnDistinctValues({ catalog: 'analytics', db: 'dbo', 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 dbo.orders', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ 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.getTableRowCount('orders')).resolves.toBe(2);
+        await expect(connector.listSchemas()).resolves.toEqual(['dbo', 'sales']);
+        await expect(connector.columnStats({ connectionId: 'warehouse', table: { catalog: 'analytics', db: 'dbo', name: 'orders' }, column: 'status' }, { runId: 'scan-run-1' })).resolves.toBeNull();
+        await connector.cleanup();
+    });
+    it('adapts native SQL Server snapshots to live-database introspection for local ingest', async () => {
+        const introspection = createSqlServerLiveDatabaseIntrospection({
+            connections: {
+                warehouse: {
+                    driver: 'sqlserver',
+                    host: 'db.example.test',
+                    database: 'analytics',
+                    username: 'reader',
+                    schema: 'dbo',
+                },
+            },
+            poolFactory: fakePoolFactory(),
+            now: () => new Date('2026-04-29T16:00:00.000Z'),
+        });
+        const snapshot = await introspection.extractSchema('warehouse');
+        expect(snapshot).toMatchObject({
+            connectionId: 'warehouse',
+            extractedAt: '2026-04-29T16:00:00.000Z',
+        });
+        expect(snapshot.tables.find((table) => table.name === 'customers')).toMatchObject({
+            name: 'customers',
+            catalog: 'analytics',
+            db: 'dbo',
+            columns: [
+                {
+                    name: 'id',
+                    nativeType: 'int',
+                    normalizedType: 'int',
+                    dimensionType: 'number',
+                    nullable: false,
+                    primaryKey: true,
+                    comment: 'PK',
+                },
+                {
+                    name: 'name',
+                    nativeType: 'nvarchar',
+                    normalizedType: 'nvarchar',
+                    dimensionType: 'string',
+                    nullable: false,
+                    primaryKey: false,
+                    comment: null,
+                },
+            ],
+            foreignKeys: [],
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import type { KtxSchemaDimensionType, KtxTableRef } from '@ktx/context/scan';
+type SqlServerTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
+export declare class KtxSqlServerDialect {
+    readonly type = "sqlserver";
+    private readonly typeMappings;
+    quoteIdentifier(identifier: string): string;
+    formatTableName(table: SqlServerTableNameRef): 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?: Record<string, unknown>;
+    };
+    getRandomSampleFilter(samplePct: number): string;
+    getTableSampleClause(samplePct: number): string;
+    getLimitOffsetClause(limit: number, offset?: number): string;
+    getTopClause(limit: 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-sqlserver/dist/dialect.js

@@ -0,0 +1,169 @@
+export class KtxSqlServerDialect {
+    type = 'sqlserver';
+    typeMappings = {
+        datetime: 'time',
+        datetime2: 'time',
+        date: 'time',
+        time: 'time',
+        datetimeoffset: 'time',
+        smalldatetime: 'time',
+        timestamp: 'time',
+        int: 'number',
+        bigint: 'number',
+        smallint: 'number',
+        tinyint: 'number',
+        decimal: 'number',
+        numeric: 'number',
+        float: 'number',
+        real: 'number',
+        money: 'number',
+        smallmoney: 'number',
+        varchar: 'string',
+        nvarchar: 'string',
+        char: 'string',
+        nchar: 'string',
+        text: 'string',
+        ntext: 'string',
+        uniqueidentifier: 'string',
+        xml: 'string',
+        bit: 'boolean',
+    };
+    quoteIdentifier(identifier) {
+        return `[${identifier.replace(/\]/g, ']]')}]`;
+    }
+    formatTableName(table) {
+        return table.db
+            ? `${this.quoteIdentifier(table.db)}.${this.quoteIdentifier(table.name)}`
+            : this.quoteIdentifier(table.name);
+    }
+    mapDataType(nativeType) {
+        return nativeType;
+    }
+    mapToDimensionType(nativeType) {
+        if (!nativeType) {
+            return 'string';
+        }
+        const lower = nativeType.toLowerCase().trim();
+        const normalized = lower.includes('(') ? lower.split('(')[0] : lower;
+        if (this.typeMappings[normalized]) {
+            return this.typeMappings[normalized];
+        }
+        if (normalized.includes('time') || normalized.includes('date')) {
+            return 'time';
+        }
+        if (normalized.includes('int') ||
+            normalized.includes('num') ||
+            normalized.includes('dec') ||
+            normalized.includes('float') ||
+            normalized.includes('money')) {
+            return 'number';
+        }
+        if (normalized.includes('bit')) {
+            return 'boolean';
+        }
+        return 'string';
+    }
+    generateSampleQuery(tableName, limit, columns) {
+        const columnList = columns && columns.length > 0 ? columns.map((column) => this.quoteIdentifier(column)).join(', ') : '*';
+        return `SELECT TOP ${limit} ${columnList} FROM ${tableName}`;
+    }
+    generateColumnSampleQuery(tableName, columnName, limit) {
+        const quotedColumn = this.quoteIdentifier(columnName);
+        return `SELECT TOP ${limit} ${quotedColumn} FROM ${tableName} WHERE ${quotedColumn} IS NOT NULL AND LTRIM(RTRIM(CAST(${quotedColumn} AS NVARCHAR(MAX)))) != ''`;
+    }
+    prepareQuery(sql, params) {
+        if (!params) {
+            return { sql, params: undefined };
+        }
+        let parameterizedQuery = sql;
+        for (const key of Object.keys(params)) {
+            parameterizedQuery = parameterizedQuery.replace(new RegExp(`:${key}\\b`, 'g'), `@${key}`);
+        }
+        return { sql: parameterizedQuery, params };
+    }
+    getRandomSampleFilter(samplePct) {
+        if (samplePct <= 0 || samplePct >= 1) {
+            return '';
+        }
+        return `ABS(CHECKSUM(NEWID())) % 100 < ${Math.round(samplePct * 100)}`;
+    }
+    getTableSampleClause(samplePct) {
+        if (samplePct <= 0 || samplePct >= 1) {
+            return '';
+        }
+        return `TABLESAMPLE (${samplePct * 100} PERCENT)`;
+    }
+    getLimitOffsetClause(limit, offset) {
+        return offset !== undefined && offset > 0 ? `OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY` : '';
+    }
+    getTopClause(limit) {
+        return `TOP ${limit}`;
+    }
+    getNullCountExpression(column) {
+        return `SUM(CASE WHEN ${column} IS NULL THEN 1 ELSE 0 END)`;
+    }
+    getDistinctCountExpression(column) {
+        return `COUNT(DISTINCT ${column})`;
+    }
+    generateCardinalitySampleQuery(tableName, columnName, sampleSize) {
+        return `
+      WITH sampled AS (
+        SELECT TOP ${sampleSize} ${columnName} AS val
+        FROM ${tableName}
+        WHERE ${columnName} IS NOT NULL
+      )
+      SELECT COUNT(DISTINCT val) AS cardinality
+      FROM sampled
+    `;
+    }
+    generateDistinctValuesQuery(tableName, columnName, limit) {
+        return `
+      SELECT TOP ${limit} val
+      FROM (
+        SELECT DISTINCT CAST(${columnName} AS NVARCHAR(MAX)) AS val
+        FROM ${tableName}
+        WHERE ${columnName} IS NOT NULL
+      ) AS distinct_vals
+      ORDER BY val
+    `;
+    }
+    generateColumnStatisticsQuery(_schemaName, _tableName) {
+        return null;
+    }
+    generateRandomizedCardinalitySampleQuery(tableName, columnName, sampleSize) {
+        return `
+      WITH sampled AS (
+        SELECT TOP ${sampleSize} ${columnName} AS val
+        FROM ${tableName}
+        WHERE ${columnName} IS NOT NULL
+        ORDER BY NEWID()
+      )
+      SELECT COUNT(DISTINCT val) AS cardinality
+      FROM sampled
+    `;
+    }
+    getTimeTruncExpression(column, granularity, timezone) {
+        const col = timezone ? `${column} AT TIME ZONE 'UTC' AT TIME ZONE '${timezone}'` : column;
+        switch (granularity) {
+            case 'day':
+                return `CAST(${col} AS DATE)`;
+            case 'week':
+                return `DATEADD(WEEK, DATEDIFF(WEEK, 0, ${col}), 0)`;
+            case 'month':
+                return `DATEFROMPARTS(YEAR(${col}), MONTH(${col}), 1)`;
+            case 'quarter':
+                return `DATEFROMPARTS(YEAR(${col}), (DATEPART(QUARTER, ${col}) - 1) * 3 + 1, 1)`;
+            case 'year':
+                return `DATEFROMPARTS(YEAR(${col}), 1, 1)`;
+        }
+    }
+    getCustomTimeTruncExpression(column, interval, origin, timezone) {
+        const col = timezone ? `${column} AT TIME ZONE 'UTC' AT TIME ZONE '${timezone}'` : column;
+        const [amount, unit] = interval.split(' ');
+        const originExpr = origin ? `'${origin}'` : `'1970-01-01'`;
+        return `DATEADD(${unit}, (DATEDIFF(${unit}, ${originExpr}, ${col}) / ${amount}) * ${amount}, ${originExpr})`;
+    }
+    parseIntervalToSql(interval) {
+        return `'${interval}'`;
+    }
+}

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

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

package/node_modules/@ktx/connector-sqlserver/dist/dialect.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { KtxSqlServerDialect } from './dialect.js';
+describe('KtxSqlServerDialect', () => {
+    const dialect = new KtxSqlServerDialect();
+    it('quotes identifiers and formats schema-qualified table names', () => {
+        expect(dialect.quoteIdentifier('events')).toBe('[events]');
+        expect(dialect.quoteIdentifier('odd]name')).toBe('[odd]]name]');
+        expect(dialect.formatTableName({ catalog: 'warehouse', db: 'dbo', name: 'events' })).toBe('[dbo].[events]');
+        expect(dialect.formatTableName({ catalog: null, db: null, name: 'events' })).toBe('[events]');
+    });
+    it('maps SQL Server types to KTX dimension types', () => {
+        expect(dialect.mapToDimensionType('datetime2')).toBe('time');
+        expect(dialect.mapToDimensionType('decimal(18, 2)')).toBe('number');
+        expect(dialect.mapToDimensionType('bigint')).toBe('number');
+        expect(dialect.mapToDimensionType('bit')).toBe('boolean');
+        expect(dialect.mapToDimensionType('uniqueidentifier')).toBe('string');
+        expect(dialect.mapToDimensionType('')).toBe('string');
+    });
+    it('builds sampling, distinct-value, pagination, and time SQL', () => {
+        expect(dialect.generateSampleQuery('[dbo].[events]', 25, ['id', 'event_name'])).toBe('SELECT TOP 25 [id], [event_name] FROM [dbo].[events]');
+        expect(dialect.generateColumnSampleQuery('[dbo].[events]', 'event_name', 10)).toBe("SELECT TOP 10 [event_name] FROM [dbo].[events] WHERE [event_name] IS NOT NULL AND LTRIM(RTRIM(CAST([event_name] AS NVARCHAR(MAX)))) != ''");
+        expect(dialect.generateDistinctValuesQuery('[dbo].[events]', '[event_name]', 5)).toContain('SELECT TOP 5 val');
+        expect(dialect.getTopClause(10)).toBe('TOP 10');
+        expect(dialect.getLimitOffsetClause(10, 20)).toBe('OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY');
+        expect(dialect.getTimeTruncExpression('created_at', 'month')).toBe('DATEFROMPARTS(YEAR(created_at), MONTH(created_at), 1)');
+    });
+    it('prepares named parameters using SQL Server @ parameters', () => {
+        expect(dialect.prepareQuery('select * from events where id = :id and name = :name', {
+            id: 10,
+            name: 'signup',
+        })).toEqual({
+            sql: 'select * from events where id = @id and name = @name',
+            params: { id: 10, name: 'signup' },
+        });
+    });
+});

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

@@ -0,0 +1,3 @@
+export { KtxSqlServerDialect } from './dialect.js';
+export { isKtxSqlServerConnectionConfig, KtxSqlServerScanConnector, sqlServerConnectionPoolConfigFromConfig, type KtxSqlServerColumnDistinctValuesOptions, type KtxSqlServerColumnDistinctValuesResult, type KtxSqlServerConnectionConfig, type KtxSqlServerEndpointResolver, type KtxSqlServerPool, type KtxSqlServerPoolConfig, type KtxSqlServerPoolFactory, type KtxSqlServerQueryResult, type KtxSqlServerReadOnlyQueryInput, type KtxSqlServerScanConnectorOptions, } from './connector.js';
+export { createSqlServerLiveDatabaseIntrospection } from './live-database-introspection.js';

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

@@ -0,0 +1,3 @@
+export { KtxSqlServerDialect } from './dialect.js';
+export { isKtxSqlServerConnectionConfig, KtxSqlServerScanConnector, sqlServerConnectionPoolConfigFromConfig, } from './connector.js';
+export { createSqlServerLiveDatabaseIntrospection } from './live-database-introspection.js';

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

@@ -0,0 +1,11 @@
+import type { LiveDatabaseIntrospectionPort } from '@ktx/context/ingest';
+import type { KtxProjectConnectionConfig } from '@ktx/context/project';
+import { type KtxSqlServerEndpointResolver, type KtxSqlServerPoolFactory } from './connector.js';
+interface CreateSqlServerLiveDatabaseIntrospectionOptions {
+    connections: Record<string, KtxProjectConnectionConfig>;
+    poolFactory?: KtxSqlServerPoolFactory;
+    endpointResolver?: KtxSqlServerEndpointResolver;
+    now?: () => Date;
+}
+export declare function createSqlServerLiveDatabaseIntrospection(options: CreateSqlServerLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;
+export {};

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

@@ -0,0 +1,21 @@
+import { KtxSqlServerScanConnector, } from './connector.js';
+export function createSqlServerLiveDatabaseIntrospection(options) {
+    return {
+        async extractSchema(connectionId) {
+            const connection = options.connections[connectionId];
+            const connector = new KtxSqlServerScanConnector({
+                connectionId,
+                connection,
+                poolFactory: options.poolFactory,
+                endpointResolver: options.endpointResolver,
+                now: options.now,
+            });
+            try {
+                return await connector.introspect({ connectionId, driver: 'sqlserver' }, { runId: `sqlserver-${connectionId}` });
+            }
+            finally {
+                await connector.cleanup();
+            }
+        },
+    };
+}

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

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

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

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+describe('@ktx/connector-sqlserver package exports', () => {
+    it('exports public connector APIs during package bootstrap', async () => {
+        const connector = await import('./index.js');
+        expect(connector.KtxSqlServerDialect).toBeTypeOf('function');
+        expect(connector.KtxSqlServerScanConnector).toBeTypeOf('function');
+        expect(connector.createSqlServerLiveDatabaseIntrospection).toBeTypeOf('function');
+        expect(connector.sqlServerConnectionPoolConfigFromConfig).toBeTypeOf('function');
+    });
+});

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

@@ -0,0 +1,20 @@
+{
+  "name": "@ktx/connector-sqlserver",
+  "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/context/dist/agent/agent-runner.service.d.ts

@@ -0,0 +1,18 @@
+import type { KtxLlmProvider } from '@ktx/llm';
+import type { KtxLogger } from '../core/index.js';
+import { type AgentTelemetryPort } from '../llm/ai-sdk-runtime.js';
+import type { KtxLlmDebugRequestRecorder } from '../llm/debug-request-recorder.js';
+import type { AgentRunnerPort, RunLoopParams, RunLoopResult } from '../llm/runtime-port.js';
+export type { RunLoopParams, RunLoopResult, RunLoopStepInfo, RunLoopStopReason, } from '../llm/runtime-port.js';
+export type { AgentTelemetryPort } from '../llm/ai-sdk-runtime.js';
+export interface AgentRunnerServiceDeps {
+    llmProvider: KtxLlmProvider;
+    telemetry?: AgentTelemetryPort;
+    debugRequestRecorder?: KtxLlmDebugRequestRecorder;
+    logger?: KtxLogger;
+}
+export declare class AgentRunnerService implements AgentRunnerPort {
+    private readonly runtime;
+    constructor(deps: AgentRunnerServiceDeps);
+    runLoop(params: RunLoopParams): Promise<RunLoopResult>;
+}

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

@@ -0,0 +1,10 @@
+import { AiSdkKtxLlmRuntime } from '../llm/ai-sdk-runtime.js';
+export class AgentRunnerService {
+    runtime;
+    constructor(deps) {
+        this.runtime = new AiSdkKtxLlmRuntime(deps);
+    }
+    runLoop(params) {
+        return this.runtime.runAgentLoop(params);
+    }
+}

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

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