@kaelio/ktx 0.4.1 → 0.5.0

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

@@ -1,371 +0,0 @@
-import { BigQuery } from '@google-cloud/bigquery';
-import { assertReadOnlySql, limitSqlForExecution } from '@ktx/context/connections';
-import { createKtxConnectorCapabilities, } from '@ktx/context/scan';
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { KtxBigQueryDialect } from './dialect.js';
-class DefaultBigQueryClientFactory {
-    createClient(input) {
-        const client = new BigQuery(input);
-        return {
-            getDatasets: (options) => client.getDatasets(options),
-            dataset: (datasetId) => {
-                const dataset = client.dataset(datasetId);
-                return {
-                    get: () => dataset.get(),
-                    getTables: () => dataset.getTables(),
-                };
-            },
-            createQueryJob: (options) => client.createQueryJob(options),
-        };
-    }
-}
-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 stringConfigValue(connection, key, env) {
-    const value = connection?.[key];
-    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(value.trim(), env) : undefined;
-}
-function datasetIds(connection, env) {
-    if (Array.isArray(connection.dataset_ids) && connection.dataset_ids.length > 0) {
-        return connection.dataset_ids
-            .filter((dataset) => dataset.trim().length > 0)
-            .map((dataset) => resolveStringReference(dataset, env));
-    }
-    const datasetId = stringConfigValue(connection, 'dataset_id', env);
-    return datasetId ? [datasetId] : [];
-}
-function bigQueryMaxBytesBilledFromConnection(connection) {
-    const value = connection?.max_bytes_billed;
-    if (typeof value === 'number') {
-        return Number.isFinite(value) && value > 0 ? value : undefined;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
-    }
-    return undefined;
-}
-function bigQueryJobTimeoutMsFromConnection(connection) {
-    const value = connection?.job_timeout_ms;
-    if (typeof value !== 'number') {
-        return undefined;
-    }
-    return Number.isInteger(value) && value > 0 ? value : undefined;
-}
-function tableKind(metadataType) {
-    const type = String(metadataType ?? '').toUpperCase();
-    if (type === 'VIEW' || type === 'MATERIALIZED_VIEW') {
-        return 'view';
-    }
-    if (type === 'EXTERNAL' || type === 'EXTERNAL_TABLE') {
-        return 'external';
-    }
-    return 'table';
-}
-function firstNumber(value) {
-    const numberValue = Number(value);
-    return Number.isFinite(numberValue) ? numberValue : null;
-}
-function normalizeValue(value) {
-    if (value === null || value === undefined) {
-        return null;
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => String(item)).join(', ');
-    }
-    if (typeof value === 'object') {
-        if ('toNumber' in value && typeof value.toNumber === 'function' && 'toFixed' in value && typeof value.toFixed === 'function') {
-            return value.toNumber();
-        }
-        if ('value' in value && Object.keys(value).length === 1 && typeof value.value !== 'object') {
-            return value.value;
-        }
-        return JSON.stringify(value);
-    }
-    return value;
-}
-export function isKtxBigQueryConnectionConfig(connection) {
-    return String(connection?.driver ?? '').toLowerCase() === 'bigquery';
-}
-export function bigQueryConnectionConfigFromConfig(input) {
-    const inputDriver = input.connection?.driver ?? 'unknown';
-    if (!isKtxBigQueryConnectionConfig(input.connection)) {
-        throw new Error(`Native BigQuery connector cannot run driver "${inputDriver}"`);
-    }
-    const env = input.env ?? process.env;
-    const credentialsJson = stringConfigValue(input.connection, 'credentials_json', env);
-    if (!credentialsJson) {
-        throw new Error(`Native BigQuery connector requires connections.${input.connectionId}.credentials_json`);
-    }
-    const credentials = JSON.parse(credentialsJson);
-    const projectId = typeof credentials.project_id === 'string' ? credentials.project_id : undefined;
-    if (!projectId) {
-        throw new Error(`Native BigQuery connector requires credentials_json.project_id for connections.${input.connectionId}`);
-    }
-    const resolvedDatasetIds = datasetIds(input.connection, env);
-    if (resolvedDatasetIds.length === 0) {
-        throw new Error(`Native BigQuery connector requires connections.${input.connectionId}.dataset_id or dataset_ids`);
-    }
-    const location = stringConfigValue(input.connection, 'location', env);
-    return { projectId, credentials, datasetIds: resolvedDatasetIds, ...(location ? { location } : {}) };
-}
-export class KtxBigQueryScanConnector {
-    id;
-    driver = 'bigquery';
-    capabilities = createKtxConnectorCapabilities({
-        tableSampling: true,
-        columnSampling: true,
-        columnStats: false,
-        readOnlySql: true,
-        nestedAnalysis: true,
-        formalForeignKeys: false,
-        estimatedRowCounts: true,
-    });
-    connectionId;
-    resolved;
-    clientFactory;
-    now;
-    maxBytesBilled;
-    queryTimeoutMs;
-    dialect = new KtxBigQueryDialect();
-    client = null;
-    constructor(options) {
-        this.connectionId = options.connectionId;
-        this.resolved = bigQueryConnectionConfigFromConfig({
-            connectionId: options.connectionId,
-            connection: options.connection,
-            env: options.env,
-        });
-        this.clientFactory = options.clientFactory ?? new DefaultBigQueryClientFactory();
-        this.now = options.now ?? (() => new Date());
-        this.maxBytesBilled = options.maxBytesBilled ?? bigQueryMaxBytesBilledFromConnection(options.connection);
-        this.queryTimeoutMs = options.queryTimeoutMs ?? bigQueryJobTimeoutMsFromConnection(options.connection);
-        this.id = `bigquery:${options.connectionId}`;
-    }
-    async testConnection() {
-        try {
-            const client = this.getClient();
-            await client.getDatasets({ maxResults: 1 });
-            for (const datasetId of this.resolved.datasetIds) {
-                await client.dataset(datasetId).get();
-            }
-            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 tables = [];
-        for (const datasetId of this.resolved.datasetIds) {
-            tables.push(...(await this.introspectDataset(datasetId)));
-        }
-        return {
-            connectionId: this.connectionId,
-            driver: 'bigquery',
-            extractedAt: this.now().toISOString(),
-            scope: { catalogs: [this.resolved.projectId], datasets: this.resolved.datasetIds },
-            metadata: {
-                project_id: this.resolved.projectId,
-                datasets: this.resolved.datasetIds,
-                table_count: tables.length,
-                total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
-            },
-            tables,
-        };
-    }
-    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));
-        return { values: result.rows.filter((row) => row.length > 0 && row[0] !== null).map((row) => row[0]), nullCount: null, distinctCount: null };
-    }
-    async columnStats(_input, _ctx) {
-        return null;
-    }
-    async executeReadOnly(input, _ctx) {
-        this.assertConnection(input.connectionId);
-        const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
-        const prepared = 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 tableName = this.qTableName(table);
-        const quotedColumn = this.dialect.quoteIdentifier(columnName);
-        const cardinality = await this.singleNumber(this.dialect.generateCardinalitySampleQuery(tableName, quotedColumn, options.sampleSize ?? 10000), 'cardinality');
-        if (cardinality === null) {
-            return null;
-        }
-        if (cardinality === 0) {
-            return { values: [], cardinality: 0 };
-        }
-        if (cardinality > options.maxCardinality) {
-            return { values: null, cardinality };
-        }
-        const valueRows = await this.queryRaw(this.dialect.generateDistinctValuesQuery(tableName, quotedColumn, options.limit));
-        return { values: valueRows.filter((row) => row.val !== null).map((row) => String(row.val)), cardinality };
-    }
-    async getTableRowCount(tableName, datasetId = this.resolved.datasetIds[0]) {
-        if (!datasetId) {
-            return 0;
-        }
-        const tables = await this.introspectDataset(datasetId);
-        return tables.find((table) => table.name === tableName)?.estimatedRows ?? 0;
-    }
-    qTableName(table) {
-        return this.dialect.formatTableName(table);
-    }
-    quoteIdentifier(identifier) {
-        return this.dialect.quoteIdentifier(identifier);
-    }
-    async listDatasets() {
-        const [datasets] = await this.getClient().getDatasets();
-        return datasets.map((dataset) => dataset.id).filter((id) => Boolean(id));
-    }
-    async listTables(datasetIds) {
-        const filterDatasets = datasetIds ?? (await this.listDatasets());
-        const entries = [];
-        for (const datasetId of filterDatasets) {
-            const dataset = this.getClient().dataset(datasetId);
-            const [tables] = await dataset.getTables();
-            for (const table of tables) {
-                if (!table.id)
-                    continue;
-                entries.push({
-                    schema: datasetId,
-                    name: table.id,
-                    kind: table.metadata?.type === 'VIEW' ? 'view' : 'table',
-                });
-            }
-        }
-        entries.sort((a, b) => a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name));
-        return entries;
-    }
-    async cleanup() {
-        this.client = null;
-    }
-    getClient() {
-        if (!this.client) {
-            this.client = this.clientFactory.createClient({
-                projectId: this.resolved.projectId,
-                credentials: this.resolved.credentials,
-            });
-        }
-        return this.client;
-    }
-    async query(sql, params) {
-        const [job] = await this.getClient().createQueryJob({
-            query: sql,
-            ...(this.resolved.location ? { location: this.resolved.location } : {}),
-            ...(params && Object.keys(params).length > 0 ? { params } : {}),
-            ...(this.maxBytesBilled ? { maximumBytesBilled: String(this.maxBytesBilled) } : {}),
-            ...(this.queryTimeoutMs ? { jobTimeoutMs: this.queryTimeoutMs } : {}),
-        });
-        const [rows, , response] = await job.getQueryResults();
-        let headers = response?.schema?.fields?.map((field) => field.name || '') ?? [];
-        const headerTypes = response?.schema?.fields?.map((field) => String(field.type || 'STRING')) ?? [];
-        if (headers.length === 0 && rows.length > 0) {
-            headers = Object.keys(rows[0]);
-        }
-        return {
-            headers,
-            headerTypes: headerTypes.length > 0 ? headerTypes : undefined,
-            rows: rows.map((row) => headers.map((header) => normalizeValue(row[header]))),
-            totalRows: rows.length,
-            rowCount: rows.length,
-        };
-    }
-    async queryRaw(sql, params) {
-        const result = await this.query(sql, params);
-        return result.rows.map((row) => Object.fromEntries(result.headers.map((header, index) => [header, row[index]])));
-    }
-    async singleNumber(sql, header) {
-        const rows = await this.queryRaw(sql);
-        return firstNumber(rows[0]?.[header]);
-    }
-    async introspectDataset(datasetId) {
-        const dataset = this.getClient().dataset(datasetId);
-        const [tableRefs] = await dataset.getTables();
-        const primaryKeys = await this.primaryKeys(datasetId);
-        const tables = [];
-        for (const tableRef of tableRefs) {
-            const tableName = tableRef.id || '';
-            const [table] = await tableRef.get();
-            const fields = table.metadata.schema?.fields ?? [];
-            tables.push({
-                catalog: this.resolved.projectId,
-                db: datasetId,
-                name: tableName,
-                kind: tableKind(table.metadata.type),
-                comment: table.metadata.description || null,
-                estimatedRows: firstNumber(table.metadata.numRows) ?? 0,
-                columns: fields.map((field) => this.toSchemaColumn(tableName, field, primaryKeys)),
-                foreignKeys: [],
-            });
-        }
-        return tables;
-    }
-    async primaryKeys(datasetId) {
-        const rows = await this.queryRaw('SELECT tc.table_name, kcu.column_name ' +
-            'FROM `' +
-            this.resolved.projectId +
-            '.' +
-            datasetId +
-            '.INFORMATION_SCHEMA.TABLE_CONSTRAINTS` tc ' +
-            'JOIN `' +
-            this.resolved.projectId +
-            '.' +
-            datasetId +
-            '.INFORMATION_SCHEMA.KEY_COLUMN_USAGE` kcu ' +
-            'ON tc.constraint_name = kcu.constraint_name ' +
-            'AND tc.table_schema = kcu.table_schema ' +
-            'AND tc.table_name = kcu.table_name ' +
-            "WHERE tc.constraint_type = 'PRIMARY KEY' " +
-            "AND tc.table_schema = '" +
-            datasetId +
-            "' " +
-            "AND NOT REGEXP_CONTAINS(kcu.column_name, r'^(stacksync_record_id|sync_primary_key)_') " +
-            'ORDER BY tc.table_name, kcu.ordinal_position');
-        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;
-    }
-    toSchemaColumn(tableName, field, primaryKeys) {
-        const nativeType = String(field.type || 'STRING').toUpperCase();
-        return {
-            name: field.name || '',
-            nativeType,
-            normalizedType: this.dialect.mapDataType(nativeType),
-            dimensionType: this.dialect.mapToDimensionType(nativeType),
-            nullable: field.mode !== 'REQUIRED',
-            primaryKey: primaryKeys.get(tableName)?.has(field.name || '') ?? false,
-            comment: field.description || null,
-        };
-    }
-    assertConnection(connectionId) {
-        if (connectionId !== this.connectionId) {
-            throw new Error(`BigQuery connector ${this.connectionId} cannot scan connection ${connectionId}`);
-        }
-    }
-}

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

@@ -1,247 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { bigQueryConnectionConfigFromConfig, createBigQueryLiveDatabaseIntrospection, isKtxBigQueryConnectionConfig, KtxBigQueryScanConnector, } from './index.js';
-function fakeClientFactory() {
-    const queryResults = vi.fn(async () => [
-        [{ id: 1, status: 'paid' }],
-        undefined,
-        { schema: { fields: [{ name: 'id', type: 'INT64' }, { name: 'status', type: 'STRING' }] } },
-    ]);
-    const createQueryJob = vi.fn(async (input) => {
-        if (input.query.includes('INFORMATION_SCHEMA.TABLE_CONSTRAINTS')) {
-            return [
-                {
-                    getQueryResults: async () => [
-                        [{ table_name: 'orders', column_name: 'id' }],
-                        undefined,
-                        { schema: { fields: [{ name: 'table_name', type: 'STRING' }, { name: 'column_name', type: 'STRING' }] } },
-                    ],
-                },
-            ];
-        }
-        if (input.query.includes('APPROX_COUNT_DISTINCT')) {
-            return [
-                {
-                    getQueryResults: async () => [
-                        [{ cardinality: 2 }],
-                        undefined,
-                        { schema: { fields: [{ name: 'cardinality', type: 'INT64' }] } },
-                    ],
-                },
-            ];
-        }
-        if (input.query.includes('SELECT DISTINCT CAST')) {
-            return [
-                {
-                    getQueryResults: async () => [
-                        [{ val: 'open' }, { val: 'paid' }],
-                        undefined,
-                        { schema: { fields: [{ name: 'val', type: 'STRING' }] } },
-                    ],
-                },
-            ];
-        }
-        if (input.query.includes('SELECT `status`')) {
-            return [
-                {
-                    getQueryResults: async () => [
-                        [{ status: 'paid' }],
-                        undefined,
-                        { schema: { fields: [{ name: 'status', type: 'STRING' }] } },
-                    ],
-                },
-            ];
-        }
-        return [{ getQueryResults: queryResults }];
-    });
-    const getTable = vi.fn(async () => [
-        {
-            metadata: {
-                type: 'TABLE',
-                numRows: '12',
-                description: 'Orders table',
-                schema: {
-                    fields: [
-                        { name: 'id', type: 'INT64', mode: 'REQUIRED', description: 'Order id' },
-                        { name: 'status', type: 'STRING', mode: 'NULLABLE' },
-                        { name: 'payload', type: 'RECORD', mode: 'NULLABLE' },
-                    ],
-                },
-            },
-        },
-    ]);
-    const tableRef = { id: 'orders', get: getTable };
-    return {
-        createClient: vi.fn(() => ({
-            getDatasets: vi.fn(async () => [[{ id: 'analytics' }, { id: 'staging' }]]),
-            dataset: vi.fn((datasetId) => ({
-                get: vi.fn(async () => [{ id: datasetId }]),
-                getTables: vi.fn(async () => [[tableRef]]),
-            })),
-            createQueryJob,
-        })),
-    };
-}
-const connection = {
-    driver: 'bigquery',
-    dataset_id: 'analytics',
-    credentials_json: JSON.stringify({ project_id: 'project-1', client_email: 'reader@example.test' }),
-    location: 'US',
-};
-describe('KtxBigQueryScanConnector', () => {
-    it('resolves configuration safely', () => {
-        expect(isKtxBigQueryConnectionConfig(connection)).toBe(true);
-        expect(isKtxBigQueryConnectionConfig({ driver: 'mysql' })).toBe(false);
-        expect(bigQueryConnectionConfigFromConfig({ connectionId: 'warehouse', connection })).toMatchObject({
-            projectId: 'project-1',
-            datasetIds: ['analytics'],
-            location: 'US',
-        });
-    });
-    it('introspects datasets, table metadata, primary keys, and normalized types', async () => {
-        const connector = new KtxBigQueryScanConnector({
-            connectionId: 'warehouse',
-            connection,
-            clientFactory: fakeClientFactory(),
-            now: () => new Date('2026-04-29T17:00:00.000Z'),
-        });
-        const snapshot = await connector.introspect({ connectionId: 'warehouse', driver: 'bigquery' }, { runId: 'scan-run-1' });
-        expect(snapshot).toMatchObject({
-            connectionId: 'warehouse',
-            driver: 'bigquery',
-            extractedAt: '2026-04-29T17:00:00.000Z',
-            scope: { catalogs: ['project-1'], datasets: ['analytics'] },
-            metadata: {
-                project_id: 'project-1',
-                datasets: ['analytics'],
-                table_count: 1,
-                total_columns: 3,
-            },
-        });
-        expect(snapshot.tables[0]).toMatchObject({
-            catalog: 'project-1',
-            db: 'analytics',
-            name: 'orders',
-            kind: 'table',
-            comment: 'Orders table',
-            estimatedRows: 12,
-            foreignKeys: [],
-        });
-        expect(snapshot.tables[0]?.columns).toEqual([
-            {
-                name: 'id',
-                nativeType: 'INT64',
-                normalizedType: 'BIGINT',
-                dimensionType: 'number',
-                nullable: false,
-                primaryKey: true,
-                comment: 'Order id',
-            },
-            {
-                name: 'status',
-                nativeType: 'STRING',
-                normalizedType: 'VARCHAR',
-                dimensionType: 'string',
-                nullable: true,
-                primaryKey: false,
-                comment: null,
-            },
-            {
-                name: 'payload',
-                nativeType: 'RECORD',
-                normalizedType: 'JSON',
-                dimensionType: 'string',
-                nullable: true,
-                primaryKey: false,
-                comment: null,
-            },
-        ]);
-    });
-    it('runs samples, read-only SQL, distinct values, dataset listing, row counts, and cleanup', async () => {
-        const connector = new KtxBigQueryScanConnector({
-            connectionId: 'warehouse',
-            connection,
-            clientFactory: fakeClientFactory(),
-        });
-        await expect(connector.sampleTable({
-            connectionId: 'warehouse',
-            table: { catalog: 'project-1', db: 'analytics', name: 'orders' },
-            columns: ['id', 'status'],
-            limit: 1,
-        }, { runId: 'scan-run-1' })).resolves.toEqual({
-            headers: ['id', 'status'],
-            headerTypes: ['INT64', 'STRING'],
-            rows: [[1, 'paid']],
-            totalRows: 1,
-        });
-        await expect(connector.sampleColumn({
-            connectionId: 'warehouse',
-            table: { catalog: 'project-1', db: 'analytics', name: 'orders' },
-            column: 'status',
-            limit: 5,
-        }, { runId: 'scan-run-1' })).resolves.toMatchObject({ values: ['paid'], nullCount: null, distinctCount: null });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select id, status from `project-1`.`analytics`.`orders`', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ headers: ['id', 'status'], rows: [[1, '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.getColumnDistinctValues({ catalog: 'project-1', db: 'analytics', name: 'orders' }, 'status', { maxCardinality: 5, limit: 10, sampleSize: 100 })).resolves.toEqual({ values: ['open', 'paid'], cardinality: 2 });
-        await expect(connector.getTableRowCount('orders')).resolves.toBe(12);
-        await expect(connector.listDatasets()).resolves.toEqual(['analytics', 'staging']);
-        await expect(connector.columnStats({ connectionId: 'warehouse', table: { catalog: 'project-1', db: 'analytics', name: 'orders' }, column: 'status' }, { runId: 'scan-run-1' })).resolves.toBeNull();
-        await connector.cleanup();
-    });
-    it('applies maximumBytesBilled to read-only queries when configured', async () => {
-        const clientFactory = fakeClientFactory();
-        const connector = new KtxBigQueryScanConnector({
-            connectionId: 'warehouse',
-            connection,
-            clientFactory,
-            maxBytesBilled: 123456789,
-        });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select id, status from `project-1`.`analytics`.`orders`', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ rows: [[1, 'paid']], rowCount: 1 });
-        const client = vi.mocked(clientFactory.createClient).mock.results[0]?.value;
-        expect(client.createQueryJob).toHaveBeenLastCalledWith(expect.objectContaining({
-            maximumBytesBilled: '123456789',
-        }));
-    });
-    it('applies canonical BigQuery YAML scan limits to query jobs', async () => {
-        const clientFactory = fakeClientFactory();
-        const connector = new KtxBigQueryScanConnector({
-            connectionId: 'warehouse',
-            connection: { ...connection, max_bytes_billed: '987654321', job_timeout_ms: 30_000 },
-            clientFactory,
-        });
-        await expect(connector.executeReadOnly({ connectionId: 'warehouse', sql: 'select id, status from `project-1`.`analytics`.`orders`', maxRows: 1 }, { runId: 'scan-run-1' })).resolves.toMatchObject({ rows: [[1, 'paid']], rowCount: 1 });
-        const client = vi.mocked(clientFactory.createClient).mock.results[0]?.value;
-        expect(client.createQueryJob).toHaveBeenLastCalledWith(expect.objectContaining({
-            maximumBytesBilled: '987654321',
-            jobTimeoutMs: 30_000,
-        }));
-    });
-    it('adapts native snapshots to live-database introspection snapshots', async () => {
-        const introspection = createBigQueryLiveDatabaseIntrospection({
-            connections: { warehouse: connection },
-            clientFactory: fakeClientFactory(),
-            now: () => new Date('2026-04-29T17:00:00.000Z'),
-        });
-        await expect(introspection.extractSchema('warehouse')).resolves.toMatchObject({
-            connectionId: 'warehouse',
-            metadata: { project_id: 'project-1' },
-            tables: expect.arrayContaining([
-                expect.objectContaining({
-                    catalog: 'project-1',
-                    db: 'analytics',
-                    name: 'orders',
-                    columns: expect.arrayContaining([
-                        {
-                            name: 'id',
-                            nativeType: 'INT64',
-                            normalizedType: 'BIGINT',
-                            dimensionType: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            comment: 'Order id',
-                        },
-                    ]),
-                }),
-            ]),
-        });
-    });
-});

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

@@ -1,29 +0,0 @@
-import type { KtxSchemaDimensionType, KtxTableRef } from '@ktx/context/scan';
-type BigQueryTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
-export declare class KtxBigQueryDialect {
-    readonly type = "bigquery";
-    private readonly typeMappings;
-    quoteIdentifier(identifier: string): string;
-    formatTableName(table: BigQueryTableNameRef): 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;
-    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-bigquery/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { KtxBigQueryDialect } from './dialect.js';
-export { bigQueryConnectionConfigFromConfig, isKtxBigQueryConnectionConfig, KtxBigQueryScanConnector, type KtxBigQueryClient, type KtxBigQueryClientFactory, type KtxBigQueryColumnDistinctValuesOptions, type KtxBigQueryColumnDistinctValuesResult, type KtxBigQueryConnectionConfig, type KtxBigQueryDataset, type KtxBigQueryQueryJob, type KtxBigQueryReadOnlyQueryInput, type KtxBigQueryResolvedConnectionConfig, type KtxBigQueryScanConnectorOptions, type KtxBigQueryTableRef, } from './connector.js';
-export { createBigQueryLiveDatabaseIntrospection } from './live-database-introspection.js';

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

@@ -1,3 +0,0 @@
-export { KtxBigQueryDialect } from './dialect.js';
-export { bigQueryConnectionConfigFromConfig, isKtxBigQueryConnectionConfig, KtxBigQueryScanConnector, } from './connector.js';
-export { createBigQueryLiveDatabaseIntrospection } from './live-database-introspection.js';

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

@@ -1,10 +0,0 @@
-import type { LiveDatabaseIntrospectionPort } from '@ktx/context/ingest';
-import type { KtxProjectConnectionConfig } from '@ktx/context/project';
-import { type KtxBigQueryClientFactory } from './connector.js';
-interface CreateBigQueryLiveDatabaseIntrospectionOptions {
-    connections: Record<string, KtxProjectConnectionConfig>;
-    clientFactory?: KtxBigQueryClientFactory;
-    now?: () => Date;
-}
-export declare function createBigQueryLiveDatabaseIntrospection(options: CreateBigQueryLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;
-export {};