@kaelio/ktx 0.0.0 → 0.1.0-rc.0

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

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { localConnectionInfoFromConfig, localConnectionToWarehouseDescriptor, localConnectionTypeForConfig, } from './local-warehouse-descriptor.js';
+describe('localConnectionToWarehouseDescriptor', () => {
+    it('maps local Postgres URLs to canonical warehouse descriptors', () => {
+        expect(localConnectionToWarehouseDescriptor('warehouse', {
+            driver: 'postgres',
+            url: 'postgresql://readonly@db.example.test/analytics',
+        })).toMatchObject({
+            id: 'warehouse',
+            connection_type: 'POSTGRESQL',
+            host: 'db.example.test',
+            database: 'analytics',
+        });
+    });
+    it('maps BigQuery project and dataset from explicit fields', () => {
+        expect(localConnectionToWarehouseDescriptor('bq', {
+            driver: 'bigquery',
+            project_id: 'acme',
+            dataset_id: 'warehouse',
+        })).toMatchObject({
+            id: 'bq',
+            connection_type: 'BIGQUERY',
+            project_id: 'acme',
+            dataset_id: 'warehouse',
+        });
+    });
+    it('returns null for non-warehouse adapters', () => {
+        expect(localConnectionToWarehouseDescriptor('looker', { driver: 'looker' })).toBeNull();
+    });
+});
+describe('local connection info helpers', () => {
+    it('returns canonical warehouse connection types for local catalogs', () => {
+        expect(localConnectionTypeForConfig('warehouse', { driver: 'postgres' })).toBe('POSTGRESQL');
+        expect(localConnectionTypeForConfig('bq', { driver: 'bigquery', project_id: 'acme' })).toBe('BIGQUERY');
+        expect(localConnectionTypeForConfig('snowflake', { driver: 'snowflake' })).toBe('SNOWFLAKE');
+    });
+    it('keeps non-warehouse adapter labels for display-only local connection surfaces', () => {
+        expect(localConnectionTypeForConfig('prod-metabase', { driver: 'metabase' })).toBe('metabase');
+        expect(localConnectionTypeForConfig('missing-driver', {})).toBe('unknown');
+    });
+    it('builds nullable local connection info records', () => {
+        expect(localConnectionInfoFromConfig('warehouse', { driver: 'postgres' })).toEqual({
+            id: 'warehouse',
+            name: 'warehouse',
+            connectionType: 'POSTGRESQL',
+        });
+        expect(localConnectionInfoFromConfig('missing', undefined)).toBeNull();
+    });
+});

package/node_modules/@ktx/context/dist/connections/notion-config.d.ts

@@ -0,0 +1,37 @@
+import { type NotionPullConfig } from '../ingest/adapters/notion/types.js';
+import type { KtxProjectConnectionConfig } from '../project/config.js';
+export declare const KTX_NOTION_ORG_KNOWLEDGE_WARNING = "Anything accessible to this Notion integration can become organization knowledge.";
+type KtxNotionCrawlMode = 'all_accessible' | 'selected_roots';
+export interface KtxNotionConnectionConfig extends KtxProjectConnectionConfig {
+    driver: 'notion';
+    auth_token_ref: string;
+    crawl_mode: KtxNotionCrawlMode;
+    root_page_ids: string[];
+    root_database_ids: string[];
+    root_data_source_ids: string[];
+    max_pages_per_run: number;
+    max_knowledge_creates_per_run: number;
+    max_knowledge_updates_per_run: number;
+    last_successful_cursor: string | null;
+}
+export interface RedactedKtxNotionConnectionConfig {
+    driver: 'notion';
+    hasAuthToken: boolean;
+    crawlMode: KtxNotionCrawlMode;
+    rootPageIds: string[];
+    rootDatabaseIds: string[];
+    rootDataSourceIds: string[];
+    maxPagesPerRun: number;
+    maxKnowledgeCreatesPerRun: number;
+    maxKnowledgeUpdatesPerRun: number;
+    warning: typeof KTX_NOTION_ORG_KNOWLEDGE_WARNING;
+}
+interface ResolveNotionTokenOptions {
+    env?: Record<string, string | undefined>;
+    readTextFile?: (path: string) => Promise<string>;
+}
+export declare function parseNotionConnectionConfig(raw: unknown): KtxNotionConnectionConfig;
+export declare function redactNotionConnectionConfig(config: KtxNotionConnectionConfig): RedactedKtxNotionConnectionConfig;
+export declare function resolveNotionAuthToken(authTokenRef: string, options?: ResolveNotionTokenOptions): Promise<string>;
+export declare function notionConnectionToPullConfig(config: KtxNotionConnectionConfig, options?: ResolveNotionTokenOptions): Promise<NotionPullConfig>;
+export {};

package/node_modules/@ktx/context/dist/connections/notion-config.js

@@ -0,0 +1,128 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { notionPullConfigSchema } from '../ingest/adapters/notion/types.js';
+export const KTX_NOTION_ORG_KNOWLEDGE_WARNING = 'Anything accessible to this Notion integration can become organization knowledge.';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function record(value) {
+    if (!isRecord(value)) {
+        throw new Error('Notion connection config must be an object');
+    }
+    return value;
+}
+function stringValue(value, fallback) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback;
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+}
+function integerWithFallback(value, fallback, name) {
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer`);
+    }
+    return value;
+}
+function boundedInteger(value, fallback, name, min, max) {
+    const parsed = integerWithFallback(value, fallback, name);
+    if (parsed < min || parsed > max) {
+        throw new Error(`${name} must be between ${min} and ${max}`);
+    }
+    return parsed;
+}
+export function parseNotionConnectionConfig(raw) {
+    const input = record(raw);
+    if (input.driver !== 'notion') {
+        throw new Error('Notion connection config requires driver: notion');
+    }
+    const authTokenRef = stringValue(input.auth_token_ref, '');
+    if (!authTokenRef) {
+        throw new Error('Notion connection config requires auth_token_ref');
+    }
+    if (!authTokenRef.startsWith('env:') && !authTokenRef.startsWith('file:')) {
+        throw new Error('Notion auth_token_ref must use env:NAME or file:/path');
+    }
+    const crawlMode = stringValue(input.crawl_mode, 'selected_roots');
+    if (crawlMode !== 'selected_roots' && crawlMode !== 'all_accessible') {
+        throw new Error(`Unsupported Notion crawl_mode: ${crawlMode}`);
+    }
+    const rootPageIds = stringArray(input.root_page_ids);
+    const rootDatabaseIds = stringArray(input.root_database_ids);
+    const rootDataSourceIds = stringArray(input.root_data_source_ids);
+    if (crawlMode === 'selected_roots' && rootPageIds.length + rootDatabaseIds.length + rootDataSourceIds.length === 0) {
+        throw new Error('selected_roots requires at least one root page, database, or data source id');
+    }
+    return {
+        ...input,
+        driver: 'notion',
+        auth_token_ref: authTokenRef,
+        crawl_mode: crawlMode,
+        root_page_ids: rootPageIds,
+        root_database_ids: rootDatabaseIds,
+        root_data_source_ids: rootDataSourceIds,
+        max_pages_per_run: boundedInteger(input.max_pages_per_run, 1000, 'max_pages_per_run', 1, 10_000),
+        max_knowledge_creates_per_run: boundedInteger(input.max_knowledge_creates_per_run, 5, 'max_knowledge_creates_per_run', 0, 25),
+        max_knowledge_updates_per_run: boundedInteger(input.max_knowledge_updates_per_run, 20, 'max_knowledge_updates_per_run', 0, 100),
+        last_successful_cursor: optionalString(input.last_successful_cursor),
+    };
+}
+export function redactNotionConnectionConfig(config) {
+    return {
+        driver: 'notion',
+        hasAuthToken: Boolean(config.auth_token_ref),
+        crawlMode: config.crawl_mode,
+        rootPageIds: config.root_page_ids,
+        rootDatabaseIds: config.root_database_ids,
+        rootDataSourceIds: config.root_data_source_ids,
+        maxPagesPerRun: config.max_pages_per_run,
+        maxKnowledgeCreatesPerRun: config.max_knowledge_creates_per_run,
+        maxKnowledgeUpdatesPerRun: config.max_knowledge_updates_per_run,
+        warning: KTX_NOTION_ORG_KNOWLEDGE_WARNING,
+    };
+}
+function expandHome(path) {
+    return path === '~' || path.startsWith('~/') ? resolve(homedir(), path.slice(2)) : path;
+}
+export async function resolveNotionAuthToken(authTokenRef, options = {}) {
+    if (authTokenRef.startsWith('env:')) {
+        const envName = authTokenRef.slice('env:'.length);
+        const value = (options.env ?? process.env)[envName];
+        if (!value) {
+            throw new Error(`Notion token environment variable ${envName} is not set`);
+        }
+        return value.trim();
+    }
+    if (authTokenRef.startsWith('file:')) {
+        const path = expandHome(authTokenRef.slice('file:'.length));
+        const readTextFile = options.readTextFile ?? ((filePath) => readFile(filePath, 'utf-8'));
+        const value = (await readTextFile(path)).trim();
+        if (!value) {
+            throw new Error(`Notion token file is empty: ${path}`);
+        }
+        return value;
+    }
+    throw new Error('Notion auth_token_ref must use env:NAME or file:/path');
+}
+export async function notionConnectionToPullConfig(config, options = {}) {
+    return notionPullConfigSchema.parse({
+        authToken: await resolveNotionAuthToken(config.auth_token_ref, options),
+        crawlMode: config.crawl_mode,
+        rootPageIds: config.root_page_ids,
+        rootDatabaseIds: config.root_database_ids,
+        rootDataSourceIds: config.root_data_source_ids,
+        maxPagesPerRun: config.max_pages_per_run,
+        maxKnowledgeCreatesPerRun: config.max_knowledge_creates_per_run,
+        maxKnowledgeUpdatesPerRun: config.max_knowledge_updates_per_run,
+        lastSuccessfulCursor: config.last_successful_cursor,
+    });
+}

package/node_modules/@ktx/context/dist/connections/notion-config.test.d.ts

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

package/node_modules/@ktx/context/dist/connections/notion-config.test.js

@@ -0,0 +1,91 @@
+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 { notionConnectionToPullConfig, parseNotionConnectionConfig, redactNotionConnectionConfig, resolveNotionAuthToken, } from './notion-config.js';
+describe('standalone Notion connection config', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-notion-config-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('parses selected-root Notion config with safe defaults', () => {
+        const parsed = parseNotionConnectionConfig({
+            driver: 'notion',
+            auth_token_ref: 'env:NOTION_AUTH_TOKEN',
+            crawl_mode: 'selected_roots',
+            root_page_ids: ['page-1'],
+        });
+        expect(parsed).toEqual({
+            driver: 'notion',
+            auth_token_ref: 'env:NOTION_AUTH_TOKEN',
+            crawl_mode: 'selected_roots',
+            root_page_ids: ['page-1'],
+            root_database_ids: [],
+            root_data_source_ids: [],
+            max_pages_per_run: 1000,
+            max_knowledge_creates_per_run: 5,
+            max_knowledge_updates_per_run: 20,
+            last_successful_cursor: null,
+        });
+    });
+    it('redacts token references from display output', () => {
+        expect(redactNotionConnectionConfig(parseNotionConnectionConfig({
+            driver: 'notion',
+            auth_token_ref: 'file:/Users/example/.config/notion-token',
+            crawl_mode: 'all_accessible',
+            max_pages_per_run: 80,
+        }))).toEqual({
+            driver: 'notion',
+            hasAuthToken: true,
+            crawlMode: 'all_accessible',
+            rootPageIds: [],
+            rootDatabaseIds: [],
+            rootDataSourceIds: [],
+            maxPagesPerRun: 80,
+            maxKnowledgeCreatesPerRun: 5,
+            maxKnowledgeUpdatesPerRun: 20,
+            warning: 'Anything accessible to this Notion integration can become organization knowledge.',
+        });
+    });
+    it('requires at least one selected root in selected_roots mode', () => {
+        expect(() => parseNotionConnectionConfig({
+            driver: 'notion',
+            auth_token_ref: 'env:NOTION_AUTH_TOKEN',
+            crawl_mode: 'selected_roots',
+        })).toThrow('selected_roots requires at least one root page, database, or data source id');
+    });
+    it('resolves env and file token references without exposing the reference in errors', async () => {
+        const tokenPath = join(tempDir, 'notion-token.txt');
+        await writeFile(tokenPath, 'ntn_file_token\n', 'utf-8');
+        await expect(resolveNotionAuthToken('env:NOTION_AUTH_TOKEN', {
+            env: { NOTION_AUTH_TOKEN: 'ntn_env_token' },
+        })).resolves.toBe('ntn_env_token');
+        await expect(resolveNotionAuthToken(`file:${tokenPath}`)).resolves.toBe('ntn_file_token');
+        await expect(resolveNotionAuthToken('env:MISSING_NOTION_TOKEN', { env: {} })).rejects.toThrow('Notion token environment variable MISSING_NOTION_TOKEN is not set');
+    });
+    it('converts standalone config into adapter pull config', async () => {
+        const pullConfig = await notionConnectionToPullConfig(parseNotionConnectionConfig({
+            driver: 'notion',
+            auth_token_ref: 'env:NOTION_AUTH_TOKEN',
+            crawl_mode: 'all_accessible',
+            max_pages_per_run: 12,
+            max_knowledge_creates_per_run: 2,
+            max_knowledge_updates_per_run: 7,
+            last_successful_cursor: '{"phase":"all_accessible_pages","cursor":"cursor-1"}',
+        }), { env: { NOTION_AUTH_TOKEN: 'ntn_env_token' } });
+        expect(pullConfig).toEqual({
+            authToken: 'ntn_env_token',
+            crawlMode: 'all_accessible',
+            rootPageIds: [],
+            rootDatabaseIds: [],
+            rootDataSourceIds: [],
+            maxPagesPerRun: 12,
+            maxKnowledgeCreatesPerRun: 2,
+            maxKnowledgeUpdatesPerRun: 7,
+            lastSuccessfulCursor: '{"phase":"all_accessible_pages","cursor":"cursor-1"}',
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+import { type ClientConfig } from 'pg';
+import type { KtxSqlQueryExecutorPort } from './query-executor.js';
+interface PgClientLike {
+    connect(): Promise<unknown>;
+    query(input: string | {
+        text: string;
+        rowMode: 'array';
+    }): Promise<{
+        fields: Array<{
+            name: string;
+        }>;
+        rows: unknown[][];
+        command: string;
+        rowCount: number | null;
+    }>;
+    end(): Promise<void>;
+}
+interface PostgresQueryExecutorOptions {
+    statementTimeoutMs?: number;
+    queryTimeoutMs?: number;
+    connectionTimeoutMs?: number;
+    clientFactory?: (config: ClientConfig) => PgClientLike;
+}
+export declare function createPostgresQueryExecutor(options?: PostgresQueryExecutorOptions): KtxSqlQueryExecutorPort;
+export {};

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

@@ -0,0 +1,55 @@
+import { Client } from 'pg';
+import { limitSqlForExecution } from './read-only-sql.js';
+function connectionDriver(input) {
+    return String(input.connection?.driver ?? '').toLowerCase();
+}
+function createDefaultClient(config) {
+    return new Client(config);
+}
+export function createPostgresQueryExecutor(options = {}) {
+    const clientFactory = options.clientFactory ?? createDefaultClient;
+    return {
+        async execute(input) {
+            const driver = connectionDriver(input);
+            if (driver !== 'postgres' && driver !== 'postgresql') {
+                throw new Error(`Local Postgres execution cannot run driver "${input.connection?.driver ?? 'unknown'}".`);
+            }
+            if (input.connection?.readonly !== true) {
+                throw new Error(`Local query execution requires connections.${input.connectionId}.readonly: true.`);
+            }
+            if (typeof input.connection.url !== 'string' || input.connection.url.trim().length === 0) {
+                throw new Error(`Local Postgres execution requires connections.${input.connectionId}.url.`);
+            }
+            const client = clientFactory({
+                connectionString: input.connection.url,
+                statement_timeout: options.statementTimeoutMs ?? 30_000,
+                query_timeout: options.queryTimeoutMs ?? 35_000,
+                connectionTimeoutMillis: options.connectionTimeoutMs ?? 5_000,
+                application_name: 'ktx-local-query',
+            });
+            await client.connect();
+            try {
+                await client.query('BEGIN READ ONLY');
+                const result = await client.query({
+                    text: limitSqlForExecution(input.sql, input.maxRows),
+                    rowMode: 'array',
+                });
+                await client.query('COMMIT');
+                return {
+                    headers: result.fields.map((field) => field.name),
+                    rows: result.rows,
+                    totalRows: result.rows.length,
+                    command: result.command,
+                    rowCount: result.rowCount,
+                };
+            }
+            catch (error) {
+                await client.query('ROLLBACK').catch(() => undefined);
+                throw error;
+            }
+            finally {
+                await client.end();
+            }
+        },
+    };
+}

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

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

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

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createPostgresQueryExecutor } from './postgres-query-executor.js';
+function makeClient() {
+    const calls = [];
+    const client = {
+        connect: vi.fn(async () => undefined),
+        query: vi.fn(async (input) => {
+            calls.push(input);
+            if (input === 'BEGIN READ ONLY') {
+                return { rows: [], fields: [], rowCount: null, command: 'BEGIN' };
+            }
+            if (input === 'COMMIT') {
+                return { rows: [], fields: [], rowCount: null, command: 'COMMIT' };
+            }
+            return {
+                rows: [
+                    ['paid', 2],
+                    ['open', 1],
+                ],
+                fields: [{ name: 'status' }, { name: 'order_count' }],
+                rowCount: 2,
+                command: 'SELECT',
+            };
+        }),
+        end: vi.fn(async () => undefined),
+    };
+    return { client, calls };
+}
+describe('createPostgresQueryExecutor', () => {
+    it('runs a read-only transaction in array row mode and closes the client', async () => {
+        const { client, calls } = makeClient();
+        const executor = createPostgresQueryExecutor({
+            clientFactory: vi.fn(() => client),
+        });
+        const result = await executor.execute({
+            connectionId: 'warehouse',
+            connection: { driver: 'postgres', url: 'postgres://example/db', readonly: true },
+            sql: 'select status, count(*) as order_count from public.orders group by status',
+            maxRows: 50,
+        });
+        expect(client.connect).toHaveBeenCalledTimes(1);
+        expect(calls[0]).toBe('BEGIN READ ONLY');
+        expect(calls[1]).toEqual({
+            text: 'select * from (select status, count(*) as order_count from public.orders group by status) as ktx_query_result limit 50',
+            rowMode: 'array',
+        });
+        expect(calls[2]).toBe('COMMIT');
+        expect(client.end).toHaveBeenCalledTimes(1);
+        expect(result).toEqual({
+            headers: ['status', 'order_count'],
+            rows: [
+                ['paid', 2],
+                ['open', 1],
+            ],
+            totalRows: 2,
+            command: 'SELECT',
+            rowCount: 2,
+        });
+    });
+    it('rolls back and closes the client when query execution fails', async () => {
+        const client = {
+            connect: vi.fn(async () => undefined),
+            query: vi.fn(async (input) => {
+                if (input === 'BEGIN READ ONLY' || input === 'ROLLBACK') {
+                    return { rows: [], fields: [], rowCount: null, command: String(input) };
+                }
+                throw new Error('syntax error');
+            }),
+            end: vi.fn(async () => undefined),
+        };
+        const executor = createPostgresQueryExecutor({
+            clientFactory: vi.fn(() => client),
+        });
+        await expect(executor.execute({
+            connectionId: 'warehouse',
+            connection: { driver: 'postgres', url: 'postgres://example/db', readonly: true },
+            sql: 'select * from broken',
+            maxRows: 10,
+        })).rejects.toThrow('syntax error');
+        expect(client.query).toHaveBeenCalledWith('ROLLBACK');
+        expect(client.end).toHaveBeenCalledTimes(1);
+    });
+    it('requires a Postgres url and read-only connection config', async () => {
+        const executor = createPostgresQueryExecutor({ clientFactory: vi.fn() });
+        await expect(executor.execute({
+            connectionId: 'warehouse',
+            connection: { driver: 'postgres', readonly: true },
+            sql: 'select 1',
+        })).rejects.toThrow('Local Postgres execution requires connections.warehouse.url');
+        await expect(executor.execute({
+            connectionId: 'warehouse',
+            connection: { driver: 'postgres', url: 'postgres://example/db', readonly: false },
+            sql: 'select 1',
+        })).rejects.toThrow('Local query execution requires connections.warehouse.readonly: true');
+    });
+});

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

@@ -0,0 +1,19 @@
+import type { KtxProjectConnectionConfig } from '../project/index.js';
+export interface KtxSqlQueryExecutionInput {
+    connectionId: string;
+    projectDir?: string;
+    connection: KtxProjectConnectionConfig | undefined;
+    sql: string;
+    maxRows?: number;
+}
+export interface KtxSqlQueryExecutionResult {
+    headers: string[];
+    rows: unknown[][];
+    totalRows: number;
+    command: string;
+    rowCount: number | null;
+}
+export interface KtxSqlQueryExecutorPort {
+    execute(input: KtxSqlQueryExecutionInput): Promise<KtxSqlQueryExecutionResult>;
+}
+export declare function normalizeQueryRows(rows: unknown[]): unknown[][];

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

@@ -0,0 +1,3 @@
+export function normalizeQueryRows(rows) {
+    return rows.map((row) => (Array.isArray(row) ? row : Object.values(row)));
+}

package/node_modules/@ktx/context/dist/connections/read-only-sql.d.ts

@@ -0,0 +1,2 @@
+export declare function assertReadOnlySql(sql: string): string;
+export declare function limitSqlForExecution(sql: string, maxRows: number | undefined): string;

package/node_modules/@ktx/context/dist/connections/read-only-sql.js

@@ -0,0 +1,19 @@
+const MUTATING_SQL = /^\s*(insert|update|delete|merge|alter|drop|create|truncate|grant|revoke|copy|call|do|vacuum|analyze|refresh)\b/i;
+const READ_SQL = /^\s*(select|with)\b/i;
+export function assertReadOnlySql(sql) {
+    const trimmed = sql.trim();
+    if (!READ_SQL.test(trimmed) || MUTATING_SQL.test(trimmed)) {
+        throw new Error('Only read-only SELECT/WITH queries can be executed locally.');
+    }
+    return trimmed;
+}
+export function limitSqlForExecution(sql, maxRows) {
+    const trimmed = assertReadOnlySql(sql).replace(/;+\s*$/, '');
+    if (!maxRows) {
+        return trimmed;
+    }
+    if (!Number.isInteger(maxRows) || maxRows <= 0) {
+        throw new Error('maxRows must be a positive integer.');
+    }
+    return `select * from (${trimmed}) as ktx_query_result limit ${maxRows}`;
+}

package/node_modules/@ktx/context/dist/connections/read-only-sql.test.d.ts

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

package/node_modules/@ktx/context/dist/connections/read-only-sql.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { assertReadOnlySql, limitSqlForExecution } from './read-only-sql.js';
+describe('assertReadOnlySql', () => {
+    it('allows select and with queries', () => {
+        expect(assertReadOnlySql('select * from orders')).toBe('select * from orders');
+        expect(assertReadOnlySql('with paid as (select * from orders) select * from paid')).toContain('with paid');
+    });
+    it('rejects mutating statements before opening a database connection', () => {
+        expect(() => assertReadOnlySql('delete from orders')).toThrow('Only read-only SELECT/WITH queries can be executed locally');
+        expect(() => assertReadOnlySql('create table x(id int)')).toThrow('Only read-only SELECT/WITH queries can be executed locally');
+    });
+});
+describe('limitSqlForExecution', () => {
+    it('wraps compiled SQL and strips trailing semicolons', () => {
+        expect(limitSqlForExecution('select * from public.orders; ', 25)).toBe('select * from (select * from public.orders) as ktx_query_result limit 25');
+    });
+    it('returns the trimmed SQL when no maxRows value is provided', () => {
+        expect(limitSqlForExecution('select * from orders; ', undefined)).toBe('select * from orders');
+    });
+});

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

@@ -0,0 +1,3 @@
+import type { KtxSqlQueryExecutionInput, KtxSqlQueryExecutorPort } from './query-executor.js';
+export declare function sqliteDatabasePathFromConnection(input: KtxSqlQueryExecutionInput): string;
+export declare function createSqliteQueryExecutor(): KtxSqlQueryExecutorPort;

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

@@ -0,0 +1,76 @@
+import { isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Database from 'better-sqlite3';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { normalizeQueryRows } from './query-executor.js';
+import { limitSqlForExecution } from './read-only-sql.js';
+function connectionDriver(input) {
+    return String(input.connection?.driver ?? '').toLowerCase();
+}
+function stringConfigValue(connection, key) {
+    const value = connection?.[key];
+    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(key, value.trim()) : undefined;
+}
+function resolveStringReference(key, value) {
+    if (value.startsWith('env:')) {
+        return process.env[value.slice('env:'.length)] ?? '';
+    }
+    if (key !== 'url' && value.startsWith('file:')) {
+        const rawPath = value.slice('file:'.length);
+        const path = rawPath.startsWith('~') ? resolve(homedir(), rawPath.slice(1)) : rawPath;
+        return readFileSync(path, 'utf-8').trim();
+    }
+    return value;
+}
+function sqlitePathFromUrl(url) {
+    if (url.startsWith('file:')) {
+        return fileURLToPath(url);
+    }
+    if (url.startsWith('sqlite:')) {
+        const parsed = new URL(url);
+        if (parsed.pathname.length > 0) {
+            return decodeURIComponent(parsed.pathname);
+        }
+    }
+    return url;
+}
+export function sqliteDatabasePathFromConnection(input) {
+    const driver = connectionDriver(input);
+    if (driver !== 'sqlite' && driver !== 'sqlite3') {
+        throw new Error(`Local SQLite execution cannot run driver "${input.connection?.driver ?? 'unknown'}".`);
+    }
+    if (input.connection?.readonly !== true) {
+        throw new Error(`Local query execution requires connections.${input.connectionId}.readonly: true.`);
+    }
+    const pathValue = stringConfigValue(input.connection, 'path');
+    const urlValue = stringConfigValue(input.connection, 'url');
+    if (!pathValue && !urlValue) {
+        throw new Error(`Local SQLite execution requires connections.${input.connectionId}.path or connections.${input.connectionId}.url.`);
+    }
+    const candidate = pathValue ?? sqlitePathFromUrl(urlValue);
+    return isAbsolute(candidate) ? candidate : resolve(input.projectDir ?? process.cwd(), candidate);
+}
+export function createSqliteQueryExecutor() {
+    return {
+        async execute(input) {
+            const sql = limitSqlForExecution(input.sql, input.maxRows);
+            const dbPath = sqliteDatabasePathFromConnection(input);
+            const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+            try {
+                const statement = db.prepare(sql);
+                const rows = statement.all();
+                return {
+                    headers: statement.columns().map((column) => column.name),
+                    rows: normalizeQueryRows(rows),
+                    totalRows: rows.length,
+                    command: 'SELECT',
+                    rowCount: rows.length,
+                };
+            }
+            finally {
+                db.close();
+            }
+        },
+    };
+}

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

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