@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/connector-postgres/dist/connector.js

@@ -1,497 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { assertReadOnlySql, limitSqlForExecution } from '@ktx/context/connections';
-import { createKtxConnectorCapabilities, } from '@ktx/context/scan';
-import { Pool } from 'pg';
-import { KtxPostgresDialect } from './dialect.js';
-const PG_OID_TYPE_MAP = {
-    16: 'boolean',
-    20: 'bigint',
-    21: 'smallint',
-    23: 'integer',
-    25: 'text',
-    700: 'real',
-    701: 'double precision',
-    1043: 'varchar',
-    1082: 'date',
-    1114: 'timestamp',
-    1184: 'timestamptz',
-    1700: 'numeric',
-    2950: 'uuid',
-    3802: 'jsonb',
-    114: 'json',
-    1009: 'text[]',
-    1007: 'integer[]',
-    1016: 'bigint[]',
-};
-class DefaultPostgresPoolFactory {
-    createPool(config) {
-        return new Pool(config);
-    }
-}
-function groupByTable(rows) {
-    const grouped = new Map();
-    for (const row of rows) {
-        const tableRows = grouped.get(row.table_name) ?? [];
-        tableRows.push(row);
-        grouped.set(row.table_name, tableRows);
-    }
-    return grouped;
-}
-function primaryKeyMap(rows) {
-    const grouped = new Map();
-    for (const row of rows) {
-        const columns = grouped.get(row.table_name) ?? new Set();
-        columns.add(row.column_name);
-        grouped.set(row.table_name, columns);
-    }
-    return grouped;
-}
-function queryRows(result) {
-    const headers = (result.fields ?? []).map((field) => field.name);
-    return result.rows.map((row) => headers.map((header) => row[header]));
-}
-function finiteNumber(value) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function stringConfigValue(connection, key, env) {
-    const value = connection?.[key];
-    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(value.trim(), env) : undefined;
-}
-function resolveStringReference(value, env) {
-    if (value.startsWith('env:')) {
-        return env[value.slice('env:'.length)] ?? '';
-    }
-    if (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 numberValue(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function parsePostgresUrl(url) {
-    const parsed = new URL(url);
-    const sslmode = parsed.searchParams.get('sslmode') ?? undefined;
-    return {
-        host: parsed.hostname,
-        port: parsed.port ? Number(parsed.port) : undefined,
-        database: parsed.pathname.replace(/^\/+/, '') || undefined,
-        username: parsed.username ? decodeURIComponent(parsed.username) : undefined,
-        password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
-        ...(sslmode ? { sslmode } : {}),
-    };
-}
-function normalizedSslMode(connection) {
-    const value = connection.sslmode ?? connection.sslMode;
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim().toLowerCase() : undefined;
-}
-function schemasFromConnection(connection) {
-    if (Array.isArray(connection.schemas) && connection.schemas.length > 0) {
-        return connection.schemas.filter((schema) => typeof schema === 'string' && schema.length > 0);
-    }
-    return typeof connection.schema === 'string' && connection.schema.length > 0 ? [connection.schema] : ['public'];
-}
-function searchPathSchemasFromConnection(connection) {
-    const schemas = schemasFromConnection(connection);
-    return schemas.includes('public') ? schemas : [...schemas, 'public'];
-}
-export function isKtxPostgresConnectionConfig(connection) {
-    const driver = String(connection?.driver ?? '').toLowerCase();
-    return driver === 'postgres' || driver === 'postgresql';
-}
-export function postgresPoolConfigFromConfig(input) {
-    const inputDriver = input.connection?.driver ?? 'unknown';
-    if (!isKtxPostgresConnectionConfig(input.connection)) {
-        throw new Error(`Native PostgreSQL connector cannot run driver "${inputDriver}"`);
-    }
-    const env = input.env ?? process.env;
-    const referencedUrl = stringConfigValue(input.connection, 'url', env);
-    const urlConfig = referencedUrl ? parsePostgresUrl(referencedUrl) : {};
-    const merged = { ...urlConfig, ...input.connection };
-    const host = stringConfigValue(merged, 'host', env);
-    const database = stringConfigValue(merged, 'database', env);
-    const user = stringConfigValue(merged, 'username', env) ?? stringConfigValue(merged, 'user', env);
-    const password = stringConfigValue(merged, 'password', env);
-    const sslmode = normalizedSslMode(merged);
-    if (!referencedUrl && !host) {
-        throw new Error(`Native PostgreSQL connector requires connections.${input.connectionId}.host or url`);
-    }
-    if (!database && !referencedUrl) {
-        throw new Error(`Native PostgreSQL connector requires connections.${input.connectionId}.database or url`);
-    }
-    if (!user && !referencedUrl) {
-        throw new Error(`Native PostgreSQL connector requires connections.${input.connectionId}.username, user, or url`);
-    }
-    const config = {
-        max: 10,
-        idleTimeoutMillis: 30_000,
-        connectionTimeoutMillis: 10_000,
-        ...(referencedUrl && sslmode !== 'prefer' && sslmode !== 'disable'
-            ? { connectionString: referencedUrl }
-            : { host, port: numberValue(merged.port) ?? 5432, database, user, password }),
-    };
-    const searchPathSchemas = searchPathSchemasFromConnection(merged);
-    if (searchPathSchemas.length > 0) {
-        config.options = `-c search_path=${searchPathSchemas.join(',')}`;
-    }
-    if (merged.ssl && sslmode !== 'prefer' && sslmode !== 'disable') {
-        config.ssl = { rejectUnauthorized: merged.rejectUnauthorized ?? true };
-    }
-    return config;
-}
-export class KtxPostgresScanConnector {
-    id;
-    driver = 'postgres';
-    capabilities = createKtxConnectorCapabilities({
-        tableSampling: true,
-        columnSampling: true,
-        columnStats: true,
-        readOnlySql: true,
-        nestedAnalysis: true,
-        formalForeignKeys: true,
-        estimatedRowCounts: true,
-    });
-    connectionId;
-    connection;
-    poolConfig;
-    poolFactory;
-    endpointResolver;
-    now;
-    dialect = new KtxPostgresDialect();
-    pool = null;
-    lastIdlePoolError = null;
-    resolvedEndpoint = null;
-    constructor(options) {
-        this.connectionId = options.connectionId;
-        this.connection = options.connection ?? {};
-        this.poolConfig = postgresPoolConfigFromConfig({
-            connectionId: options.connectionId,
-            connection: options.connection,
-            env: options.env,
-        });
-        this.poolFactory = options.poolFactory ?? new DefaultPostgresPoolFactory();
-        this.endpointResolver = options.endpointResolver;
-        this.now = options.now ?? (() => new Date());
-        this.id = `postgres:${options.connectionId}`;
-    }
-    async testConnection() {
-        try {
-            await this.query('SELECT 1');
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    async introspect(input, _ctx) {
-        this.assertConnection(input.connectionId);
-        const schemas = schemasFromConnection(this.connection);
-        const allTables = [];
-        for (const schema of schemas) {
-            const tables = await this.loadSchemaTables(schema);
-            allTables.push(...tables);
-        }
-        return {
-            connectionId: this.connectionId,
-            driver: 'postgres',
-            extractedAt: this.now().toISOString(),
-            scope: { schemas },
-            metadata: {
-                database: this.poolConfig.database ?? this.connection.database ?? null,
-                schemas,
-                host: this.poolConfig.host ?? this.connection.host ?? null,
-                table_count: allTables.length,
-                total_columns: allTables.reduce((sum, table) => sum + table.columns.length, 0),
-            },
-            tables: allTables,
-        };
-    }
-    async sampleTable(input, _ctx) {
-        this.assertConnection(input.connectionId);
-        const result = await this.query(this.dialect.generateSampleQuery(this.qTableName(input.table), input.limit, input.columns));
-        return {
-            headers: result.headers,
-            headerTypes: result.headerTypes,
-            rows: result.rows,
-            totalRows: result.totalRows,
-        };
-    }
-    async sampleColumn(input, _ctx) {
-        this.assertConnection(input.connectionId);
-        const result = await this.query(this.dialect.generateColumnSampleQuery(this.qTableName(input.table), input.column, input.limit));
-        const values = result.rows.filter((row) => row.length > 0 && row[0] !== null).map((row) => row[0]);
-        return { values, nullCount: null, distinctCount: null };
-    }
-    async columnStats(input, _ctx) {
-        const stats = await this.getColumnStatistics(input.table);
-        const value = stats?.cardinalityByColumn.get(input.column);
-        return value === undefined
-            ? null
-            : { min: null, max: null, average: null, nullCount: null, distinctCount: value };
-    }
-    async executeReadOnly(input, _ctx) {
-        this.assertConnection(input.connectionId);
-        const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
-        const prepared = Array.isArray(input.params)
-            ? { sql: limitedSql, params: input.params }
-            : this.dialect.prepareQuery(limitedSql, input.params);
-        const result = await this.query(prepared.sql, prepared.params);
-        return { ...result, rowCount: result.rows.length };
-    }
-    async getColumnDistinctValues(table, columnName, options) {
-        const sampleSize = options.sampleSize ?? 10000;
-        const tableName = this.qTableName(table);
-        const quotedColumn = this.dialect.quoteIdentifier(columnName);
-        const cardinalityRows = await this.queryRaw(this.dialect.generateCardinalitySampleQuery(tableName, quotedColumn, sampleSize));
-        const cardinality = finiteNumber(cardinalityRows[0]?.cardinality);
-        if (cardinality === null) {
-            return null;
-        }
-        if (cardinality === 0) {
-            return { values: [], cardinality: 0 };
-        }
-        if (cardinality > options.maxCardinality) {
-            return { values: null, cardinality };
-        }
-        const valuesRows = await this.queryRaw(this.dialect.generateDistinctValuesQuery(tableName, quotedColumn, options.limit));
-        return {
-            values: valuesRows.filter((row) => row.val !== null).map((row) => String(row.val)),
-            cardinality,
-        };
-    }
-    async getColumnStatistics(table) {
-        const schema = table.db ?? schemasFromConnection(this.connection)[0] ?? 'public';
-        const sql = this.dialect.generateColumnStatisticsQuery(schema, table.name);
-        if (!sql) {
-            return null;
-        }
-        const rows = await this.queryRaw(sql);
-        const cardinalityByColumn = new Map();
-        for (const row of rows) {
-            const cardinality = finiteNumber(row.estimated_cardinality);
-            if (cardinality !== null) {
-                cardinalityByColumn.set(row.column_name, cardinality);
-            }
-        }
-        return cardinalityByColumn.size > 0 ? { cardinalityByColumn } : null;
-    }
-    async getTableRowCount(table) {
-        const tableRef = typeof table === 'string'
-            ? { catalog: null, db: schemasFromConnection(this.connection)[0] ?? 'public', name: table }
-            : table;
-        const rows = await this.queryRaw(`SELECT COUNT(*) AS count FROM ${this.qTableName(tableRef)}`);
-        return finiteNumber(rows[0]?.count) ?? 0;
-    }
-    qTableName(table) {
-        return this.dialect.formatTableName(table);
-    }
-    quoteIdentifier(identifier) {
-        return this.dialect.quoteIdentifier(identifier);
-    }
-    async listSchemas() {
-        const rows = await this.queryRaw(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name <> 'information_schema'
-        AND schema_name NOT LIKE 'pg_%'
-      ORDER BY schema_name
-    `);
-        return rows.map((row) => row.schema_name);
-    }
-    async listTables(schemas) {
-        const filterSchemas = schemas ?? (await this.listSchemas());
-        if (filterSchemas.length === 0)
-            return [];
-        const rows = await this.queryRaw(`
-      SELECT n.nspname AS schema_name, c.relname AS table_name, c.relkind AS table_kind
-      FROM pg_catalog.pg_class c
-      JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
-      WHERE n.nspname = ANY($1)
-        AND c.relkind IN ('r', 'v')
-      ORDER BY n.nspname, c.relname
-      `, [filterSchemas]);
-        return rows.map((row) => ({
-            schema: row.schema_name,
-            name: row.table_name,
-            kind: row.table_kind === 'v' ? 'view' : 'table',
-        }));
-    }
-    async cleanup() {
-        if (this.pool) {
-            await this.pool.end();
-            this.pool = null;
-        }
-        if (this.resolvedEndpoint?.close) {
-            await this.resolvedEndpoint.close();
-            this.resolvedEndpoint = null;
-        }
-    }
-    async loadSchemaTables(schema) {
-        const tables = await this.queryRaw(`
-      SELECT
-        c.relname AS table_name,
-        c.relkind AS table_kind,
-        c.reltuples::bigint AS row_count,
-        d.description AS table_comment
-      FROM pg_catalog.pg_class c
-      JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
-      LEFT JOIN pg_catalog.pg_description d
-        ON d.objoid = c.oid AND d.objsubid = 0
-      WHERE n.nspname = $1
-        AND c.relkind IN ('r', 'v')
-      ORDER BY c.relname
-      `, [schema]);
-        const columns = await this.queryRaw(`
-      SELECT
-        c.relname AS table_name,
-        a.attname AS column_name,
-        format_type(a.atttypid, a.atttypmod) AS data_type,
-        NOT a.attnotnull AS is_nullable,
-        d.description AS column_comment
-      FROM pg_catalog.pg_attribute a
-      JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
-      JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
-      LEFT JOIN pg_catalog.pg_description d
-        ON d.objoid = c.oid AND d.objsubid = a.attnum
-      WHERE n.nspname = $1
-        AND c.relkind IN ('r', 'v')
-        AND a.attnum > 0
-        AND NOT a.attisdropped
-      ORDER BY c.relname, a.attnum
-      `, [schema]);
-        const primaryKeys = await this.queryRaw(`
-      SELECT tc.table_name, kcu.column_name
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      WHERE tc.constraint_type = 'PRIMARY KEY'
-        AND tc.table_schema = $1
-      ORDER BY tc.table_name, kcu.ordinal_position
-      `, [schema]);
-        const foreignKeys = await this.queryRaw(`
-      SELECT
-        tc.table_name,
-        kcu.column_name,
-        ccu.table_schema AS foreign_table_schema,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name,
-        tc.constraint_name
-      FROM information_schema.table_constraints AS tc
-      JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = $1
-      ORDER BY tc.table_name, kcu.column_name
-      `, [schema]);
-        const columnsByTable = groupByTable(columns);
-        const primaryKeysByTable = primaryKeyMap(primaryKeys);
-        const foreignKeysByTable = groupByTable(foreignKeys);
-        return tables.map((table) => this.toSchemaTable(schema, table, columnsByTable.get(table.table_name) ?? [], primaryKeysByTable.get(table.table_name) ?? new Set(), foreignKeysByTable.get(table.table_name) ?? []));
-    }
-    toSchemaTable(schema, table, columns, primaryKeys, foreignKeys) {
-        const kind = table.table_kind === 'v' ? 'view' : 'table';
-        return {
-            catalog: null,
-            db: schema,
-            name: table.table_name,
-            kind,
-            comment: table.table_comment || null,
-            estimatedRows: kind === 'view' ? null : finiteNumber(table.row_count),
-            columns: columns.map((column) => this.toSchemaColumn(column, primaryKeys)),
-            foreignKeys: foreignKeys.map((foreignKey) => this.toSchemaForeignKey(foreignKey)),
-        };
-    }
-    toSchemaColumn(column, primaryKeys) {
-        return {
-            name: column.column_name,
-            nativeType: column.data_type,
-            normalizedType: this.dialect.mapDataType(column.data_type),
-            dimensionType: this.dialect.mapToDimensionType(column.data_type),
-            nullable: column.is_nullable,
-            primaryKey: primaryKeys.has(column.column_name),
-            comment: column.column_comment || null,
-        };
-    }
-    toSchemaForeignKey(row) {
-        return {
-            fromColumn: row.column_name,
-            toCatalog: null,
-            toDb: row.foreign_table_schema,
-            toTable: row.foreign_table_name,
-            toColumn: row.foreign_column_name,
-            constraintName: row.constraint_name || null,
-        };
-    }
-    async getPool() {
-        if (!this.pool) {
-            let config = { ...this.poolConfig };
-            if (this.endpointResolver) {
-                const endpoint = await this.endpointResolver.resolve({
-                    host: config.host ?? this.connection.host ?? 'localhost',
-                    port: config.port ?? numberValue(this.connection.port) ?? 5432,
-                    connection: this.connection,
-                });
-                this.resolvedEndpoint = endpoint;
-                config = { ...config, host: endpoint.host, port: endpoint.port };
-            }
-            this.pool = this.poolFactory.createPool(config);
-            this.pool.on?.('error', (error) => {
-                this.lastIdlePoolError = error;
-            });
-        }
-        return this.pool;
-    }
-    async queryRaw(sql, params) {
-        this.throwIdlePoolErrorIfPresent();
-        const pool = await this.getPool();
-        const client = await pool.connect();
-        try {
-            const result = await client.query(sql, params);
-            return result.rows;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async query(sql, params) {
-        this.throwIdlePoolErrorIfPresent();
-        const pool = await this.getPool();
-        const client = await pool.connect();
-        try {
-            const result = await client.query(assertReadOnlySql(sql), Array.isArray(params) ? params : undefined);
-            return {
-                headers: (result.fields ?? []).map((field) => field.name),
-                headerTypes: (result.fields ?? []).map((field) => PG_OID_TYPE_MAP[field.dataTypeID] ?? `oid:${field.dataTypeID}`),
-                rows: queryRows(result),
-                totalRows: result.rows.length,
-                rowCount: result.rows.length,
-            };
-        }
-        finally {
-            client.release();
-        }
-    }
-    assertConnection(connectionId) {
-        if (connectionId !== this.connectionId) {
-            throw new Error(`PostgreSQL connector ${this.connectionId} cannot run scan for ${connectionId}`);
-        }
-    }
-    throwIdlePoolErrorIfPresent() {
-        if (!this.lastIdlePoolError) {
-            return;
-        }
-        const error = this.lastIdlePoolError;
-        this.lastIdlePoolError = null;
-        throw error;
-    }
-}

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

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