@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/connections/drivers.js

@@ -0,0 +1,171 @@
+function invalidConnectionConfig(driver) {
+    return new Error(`Connection config does not match warehouse driver "${driver}".`);
+}
+/** @internal */
+export const driverRegistrations = {
+    bigquery: {
+        driver: 'bigquery',
+        scopeConfigKey: 'dataset_ids',
+        hasHistoricSqlReader: true,
+        hasLocalQueryExecutor: false,
+        load: async () => {
+            const m = await import('../../connectors/bigquery/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxBigQueryConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxBigQueryConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('bigquery');
+                    }
+                    return new m.KtxBigQueryScanConnector({ connectionId, connection: typedConnection });
+                },
+            };
+        },
+    },
+    clickhouse: {
+        driver: 'clickhouse',
+        scopeConfigKey: 'databases',
+        hasHistoricSqlReader: false,
+        hasLocalQueryExecutor: false,
+        load: async () => {
+            const m = await import('../../connectors/clickhouse/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxClickHouseConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxClickHouseConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('clickhouse');
+                    }
+                    return new m.KtxClickHouseScanConnector({ connectionId, connection: typedConnection });
+                },
+            };
+        },
+    },
+    mysql: {
+        driver: 'mysql',
+        scopeConfigKey: 'schemas',
+        hasHistoricSqlReader: false,
+        hasLocalQueryExecutor: false,
+        load: async () => {
+            const m = await import('../../connectors/mysql/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxMysqlConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxMysqlConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('mysql');
+                    }
+                    return new m.KtxMysqlScanConnector({ connectionId, connection: typedConnection });
+                },
+            };
+        },
+    },
+    postgres: {
+        driver: 'postgres',
+        scopeConfigKey: 'schemas',
+        hasHistoricSqlReader: true,
+        hasLocalQueryExecutor: true,
+        load: async () => {
+            const m = await import('../../connectors/postgres/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxPostgresConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxPostgresConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('postgres');
+                    }
+                    return new m.KtxPostgresScanConnector({ connectionId, connection: typedConnection });
+                },
+            };
+        },
+    },
+    sqlite: {
+        driver: 'sqlite',
+        scopeConfigKey: null,
+        hasHistoricSqlReader: false,
+        hasLocalQueryExecutor: true,
+        load: async () => {
+            const m = await import('../../connectors/sqlite/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxSqliteConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection, projectDir }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxSqliteConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('sqlite');
+                    }
+                    return new m.KtxSqliteScanConnector({ connectionId, connection: typedConnection, projectDir });
+                },
+            };
+        },
+    },
+    snowflake: {
+        driver: 'snowflake',
+        scopeConfigKey: 'schema_names',
+        hasHistoricSqlReader: true,
+        hasLocalQueryExecutor: false,
+        load: async () => {
+            const m = await import('../../connectors/snowflake/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxSnowflakeConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection, projectDir }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxSnowflakeConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('snowflake');
+                    }
+                    return new m.KtxSnowflakeScanConnector({ connectionId, connection: typedConnection, projectDir });
+                },
+            };
+        },
+    },
+    sqlserver: {
+        driver: 'sqlserver',
+        scopeConfigKey: 'schemas',
+        hasHistoricSqlReader: false,
+        hasLocalQueryExecutor: false,
+        load: async () => {
+            const m = await import('../../connectors/sqlserver/connector.js');
+            return {
+                isConnectionConfig: (connection) => {
+                    const typedConnection = connection;
+                    return m.isKtxSqlServerConnectionConfig(typedConnection);
+                },
+                createScanConnector: ({ connectionId, connection }) => {
+                    const typedConnection = connection;
+                    if (!m.isKtxSqlServerConnectionConfig(typedConnection)) {
+                        throw invalidConnectionConfig('sqlserver');
+                    }
+                    return new m.KtxSqlServerScanConnector({ connectionId, connection: typedConnection });
+                },
+            };
+        },
+    },
+};
+const supportedDrivers = Object.keys(driverRegistrations).sort();
+function isRegisteredDriver(driver) {
+    return Object.prototype.hasOwnProperty.call(driverRegistrations, driver);
+}
+export function getDriverRegistration(driver) {
+    const normalized = driver.toLowerCase().trim();
+    return isRegisteredDriver(normalized) ? driverRegistrations[normalized] : undefined;
+}
+export function listSupportedDrivers() {
+    return [...supportedDrivers];
+}

package/dist/context/connections/local-query-executor.js

@@ -1,21 +1,39 @@
+import { driverRegistrations, getDriverRegistration } from './drivers.js';
 import { createPostgresQueryExecutor } from './postgres-query-executor.js';
 import { createSqliteQueryExecutor } from './sqlite-query-executor.js';
 function driverFor(input) {
     return String(input.connection?.driver ?? '').toLowerCase();
 }
+function localExecutorMap(options) {
+    const wiredExecutors = {
+        postgres: options.postgres ?? createPostgresQueryExecutor(),
+        sqlite: options.sqlite ?? createSqliteQueryExecutor(),
+    };
+    const executors = {};
+    for (const registration of Object.values(driverRegistrations)) {
+        if (!registration.hasLocalQueryExecutor)
+            continue;
+        const executor = wiredExecutors[registration.driver];
+        if (executor) {
+            executors[registration.driver] = executor;
+        }
+    }
+    return executors;
+}
 export function createDefaultLocalQueryExecutor(options = {}) {
-    const postgres = options.postgres ?? createPostgresQueryExecutor();
-    const sqlite = options.sqlite ?? createSqliteQueryExecutor();
+    const executors = localExecutorMap(options);
     return {
         async execute(input) {
             const driver = driverFor(input);
-            if (driver === 'postgres' || driver === 'postgresql') {
-                return postgres.execute(input);
+            const registration = getDriverRegistration(driver);
+            if (!registration?.hasLocalQueryExecutor) {
+                throw new Error(`No local query executor is configured for driver "${input.connection?.driver ?? 'unknown'}".`);
             }
-            if (driver === 'sqlite' || driver === 'sqlite3') {
-                return sqlite.execute(input);
+            const executor = executors[registration.driver];
+            if (!executor) {
+                throw new Error(`Local query executor flag is enabled for driver "${registration.driver}", but no executor factory is wired.`);
             }
-            throw new Error(`No local query executor is configured for driver "${input.connection?.driver ?? 'unknown'}".`);
+            return executor.execute(input);
         },
     };
 }

package/dist/context/connections/local-warehouse-descriptor.js

@@ -1,9 +1,7 @@
 const DRIVER_TO_CONNECTION_TYPE = {
     postgres: 'POSTGRESQL',
-    postgresql: 'POSTGRESQL',
     sqlite: 'SQLITE',
     sqlserver: 'SQLSERVER',
-    mssql: 'SQLSERVER',
     mysql: 'MYSQL',
     clickhouse: 'CLICKHOUSE',
     snowflake: 'SNOWFLAKE',

package/dist/context/connections/postgres-query-executor.js

@@ -12,7 +12,7 @@ export function createPostgresQueryExecutor(options = {}) {
         async execute(input) {
             const driver = connectionDriver(input);
             const connection = input.connection;
-            if (driver !== 'postgres' && driver !== 'postgresql') {
+            if (driver !== 'postgres') {
                 throw new Error(`Local Postgres execution cannot run driver "${connection?.driver ?? 'unknown'}".`);
             }
             if (typeof connection?.url !== 'string' || connection.url.trim().length === 0) {

package/dist/context/connections/sqlite-query-executor.js

@@ -38,7 +38,7 @@ function sqlitePathFromUrl(url) {
 /** @internal */
 export function sqliteDatabasePathFromConnection(input) {
     const driver = connectionDriver(input);
-    if (driver !== 'sqlite' && driver !== 'sqlite3') {
+    if (driver !== 'sqlite') {
         throw new Error(`Local SQLite execution cannot run driver "${input.connection?.driver ?? 'unknown'}".`);
     }
     const pathValue = stringConfigValue(input.connection, 'path');

package/dist/context/ingest/adapters/historic-sql/chunk-unified.js

@@ -50,7 +50,7 @@ export async function chunkHistoricSqlUnifiedStagedDir(stagedDir, diffSet) {
             rawFiles: [path],
             dependencyPaths: ['manifest.json'],
             peerFileIndex: files.filter((file) => file !== path && file !== 'manifest.json').sort(),
-            notes: `Use historic_sql_patterns. Read ${path} and emit pattern objects with emit_historic_sql_evidence using rawPath "${path}". Do not call wiki_write or sl_write_source.`,
+            notes: `Use historic_sql_patterns. Read ${path} and emit pattern objects with emit_historic_sql_evidence. Do not call wiki_write or sl_write_source.`,
         });
     }
     const deleted = diffSet?.deleted

package/dist/context/ingest/adapters/historic-sql/connection-dialect.js

@@ -1,3 +1,5 @@
+import { getDriverRegistration } from '../../../connections/drivers.js';
+const historicSqlDialects = ['postgres', 'bigquery', 'snowflake'];
 function recordOrNull(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
@@ -6,6 +8,13 @@ function queryHistoryRecord(connection) {
     const context = conn ? recordOrNull(conn.context) : null;
     return context ? recordOrNull(context.queryHistory) : null;
 }
+function historicSqlDialectForDriver(driver) {
+    const dialect = historicSqlDialects.find((candidate) => candidate === driver);
+    if (!dialect) {
+        throw new Error(`Driver "${driver}" is marked as historic-SQL capable but has no HistoricSqlDialect mapping.`);
+    }
+    return dialect;
+}
 export function isQueryHistoryEnabled(connection) {
     return queryHistoryRecord(connection)?.enabled === true;
 }
@@ -20,11 +29,6 @@ export function queryHistoryDialectForConnection(connection) {
     }
     const conn = recordOrNull(connection);
     const driver = String(conn?.driver ?? '').toLowerCase();
-    if (driver === 'postgres' || driver === 'postgresql')
-        return 'postgres';
-    if (driver === 'bigquery')
-        return 'bigquery';
-    if (driver === 'snowflake')
-        return 'snowflake';
-    return null;
+    const registration = getDriverRegistration(driver);
+    return registration?.hasHistoricSqlReader ? historicSqlDialectForDriver(registration.driver) : null;
 }

package/dist/context/ingest/adapters/historic-sql/evidence-tool.d.ts

@@ -5,6 +5,7 @@ interface EmitHistoricSqlEvidenceToolContext {
             runId: string;
             sourceKey: string;
         };
+        allowedRawPaths?: ReadonlySet<string>;
         configService?: {
             writeFile(path: string, content: string, author: string, authorEmail: string, commitMessage: string, options?: {
                 skipLock?: boolean;
@@ -14,7 +15,6 @@ interface EmitHistoricSqlEvidenceToolContext {
 }
 export declare function createEmitHistoricSqlEvidenceTool(defaultContext?: EmitHistoricSqlEvidenceToolContext): import("ai").Tool<{
     kind: "pattern" | "table_usage";
-    rawPath: string;
     table?: string | undefined;
     usage?: {
         [x: string]: unknown;

package/dist/context/ingest/adapters/historic-sql/evidence-tool.js

@@ -8,7 +8,6 @@ const emitHistoricSqlEvidenceInputSchema = z
     .object({
     kind: z.enum(['table_usage', 'pattern']),
     table: z.string().min(1).optional(),
-    rawPath: z.string().min(1),
     usage: tableUsageOutputSchema.optional(),
     pattern: patternOutputSchema.optional(),
 })
@@ -43,7 +42,7 @@ function unitKeyForEvidence(input) {
     }
     return `historic-sql-pattern-${String(input.pattern?.slug).replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '')}`;
 }
-function evidenceEnvelope(input, connectionId) {
+function evidenceEnvelope(input, connectionId, rawPaths) {
     if (input.kind === 'table_usage') {
         if (!input.table || !input.usage) {
             throw new Error('Invalid historic-SQL table usage evidence input.');
@@ -52,7 +51,7 @@ function evidenceEnvelope(input, connectionId) {
             kind: 'table_usage',
             connectionId,
             table: input.table,
-            rawPath: input.rawPath,
+            rawPaths,
             usage: input.usage,
         };
     }
@@ -62,7 +61,7 @@ function evidenceEnvelope(input, connectionId) {
     return {
         kind: 'pattern',
         connectionId,
-        rawPath: input.rawPath,
+        rawPaths,
         pattern: input.pattern,
     };
 }
@@ -77,8 +76,12 @@ export function createEmitHistoricSqlEvidenceTool(defaultContext) {
             if (!ingest || ingest.sourceKey !== 'historic-sql' || !configService || !context?.connectionId) {
                 return 'Error: emit_historic_sql_evidence is only available during historic-sql ingest.';
             }
+            const rawPaths = context.session?.allowedRawPaths ? [...context.session.allowedRawPaths].sort() : [];
+            if (rawPaths.length === 0) {
+                return 'Error: emit_historic_sql_evidence requires a WorkUnit context with at least one raw file.';
+            }
             const unitKey = unitKeyForEvidence(input);
-            const evidence = evidenceEnvelope(input, context.connectionId);
+            const evidence = evidenceEnvelope(input, context.connectionId, rawPaths);
             const content = serializeHistoricSqlEvidence(evidence);
             await configService.writeFile(historicSqlEvidencePath(ingest.runId, unitKey), content, SYSTEM_AUTHOR, SYSTEM_EMAIL, `Record historic-SQL evidence: ${unitKey}`, { skipLock: true });
             const label = evidence.kind === 'table_usage' ? evidence.table : evidence.pattern.slug;

package/dist/context/ingest/adapters/historic-sql/evidence.d.ts

@@ -4,7 +4,7 @@ export declare const historicSqlTableUsageEvidenceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"table_usage">;
     connectionId: z.ZodString;
     table: z.ZodString;
-    rawPath: z.ZodString;
+    rawPaths: z.ZodArray<z.ZodString>;
     usage: z.ZodObject<{
         narrative: z.ZodString;
         frequencyTier: z.ZodEnum<{
@@ -26,7 +26,7 @@ export declare const historicSqlTableUsageEvidenceSchema: z.ZodObject<{
 export declare const historicSqlPatternEvidenceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"pattern">;
     connectionId: z.ZodString;
-    rawPath: z.ZodString;
+    rawPaths: z.ZodArray<z.ZodString>;
     pattern: z.ZodObject<{
         slug: z.ZodString;
         title: z.ZodString;
@@ -41,7 +41,7 @@ export declare const historicSqlEvidenceEnvelopeSchema: z.ZodDiscriminatedUnion<
     kind: z.ZodLiteral<"table_usage">;
     connectionId: z.ZodString;
     table: z.ZodString;
-    rawPath: z.ZodString;
+    rawPaths: z.ZodArray<z.ZodString>;
     usage: z.ZodObject<{
         narrative: z.ZodString;
         frequencyTier: z.ZodEnum<{
@@ -61,7 +61,7 @@ export declare const historicSqlEvidenceEnvelopeSchema: z.ZodDiscriminatedUnion<
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"pattern">;
     connectionId: z.ZodString;
-    rawPath: z.ZodString;
+    rawPaths: z.ZodArray<z.ZodString>;
     pattern: z.ZodObject<{
         slug: z.ZodString;
         title: z.ZodString;

package/dist/context/ingest/adapters/historic-sql/evidence.js

@@ -12,14 +12,14 @@ export const historicSqlTableUsageEvidenceSchema = z.object({
     kind: z.literal('table_usage'),
     connectionId: z.string().min(1),
     table: z.string().min(1),
-    rawPath: z.string().min(1),
+    rawPaths: z.array(z.string().min(1)).min(1),
     usage: tableUsageOutputSchema,
 });
 /** @internal */
 export const historicSqlPatternEvidenceSchema = z.object({
     kind: z.literal('pattern'),
     connectionId: z.string().min(1),
-    rawPath: z.string().min(1),
+    rawPaths: z.array(z.string().min(1)).min(1),
     pattern: patternOutputSchema,
 });
 export const historicSqlEvidenceEnvelopeSchema = z.discriminatedUnion('kind', [

package/dist/context/ingest/adapters/historic-sql/projection.js

@@ -223,7 +223,7 @@ export async function projectHistoricSqlEvidence(input) {
                         key: sourceName,
                         targetConnectionId: input.connectionId,
                         detail: `Merged historic-SQL usage for ${matchingEvidence.table}`,
-                        rawPaths: [matchingEvidence.rawPath],
+                        rawPaths: matchingEvidence.rawPaths,
                     });
                 }
             }
@@ -244,6 +244,7 @@ export async function projectHistoricSqlEvidence(input) {
                         key: sourceName,
                         targetConnectionId: input.connectionId,
                         detail: `Marked historic-SQL usage stale for ${tableRef}`,
+                        rawPaths: ['manifest.json'],
                     });
                 }
             }
@@ -285,7 +286,7 @@ export async function projectHistoricSqlEvidence(input) {
             type: reusable ? 'updated' : 'created',
             key,
             detail: `Projected historic-SQL pattern ${pattern.pattern.title}`,
-            rawPaths: [pattern.rawPath],
+            rawPaths: pattern.rawPaths,
         });
     }
     for (const page of patternPages) {
@@ -301,6 +302,7 @@ export async function projectHistoricSqlEvidence(input) {
                 type: 'updated',
                 key: page.key,
                 detail: `Archived stale historic-SQL pattern page ${page.key}`,
+                rawPaths: ['manifest.json'],
             });
             continue;
         }
@@ -313,6 +315,7 @@ export async function projectHistoricSqlEvidence(input) {
             type: 'updated',
             key: page.key,
             detail: `Marked historic-SQL pattern page ${page.key} stale`,
+            rawPaths: ['manifest.json'],
         });
     }
     result.changedWikiPageKeys = [...new Set(result.changedWikiPageKeys)].sort();

package/dist/context/ingest/adapters/live-database/daemon-introspection.js

@@ -100,7 +100,7 @@ function optionalString(value) {
 }
 function normalizeDriver(driver) {
     const normalized = String(driver ?? '').trim().toLowerCase();
-    return normalized === 'postgresql' ? 'postgres' : normalized;
+    return normalized;
 }
 function requirePostgresConnection(connections, connectionId) {
     const connection = connections[connectionId];

package/dist/context/ingest/adapters/live-database/stage.d.ts

@@ -1,6 +1,8 @@
 import type { KtxSchemaSnapshot, KtxSchemaTable, KtxTableRef } from '../../../scan/types.js';
 export declare const LIVE_DATABASE_META_FILE = "connection.json";
 export declare const LIVE_DATABASE_FOREIGN_KEYS_FILE = "foreign-keys.json";
+/** @internal */
+export declare const LIVE_DATABASE_WARNINGS_FILE = "warnings.json";
 interface LiveDatabaseTableFile {
     path: string;
     table: KtxSchemaTable;

package/dist/context/ingest/adapters/live-database/stage.js

@@ -4,6 +4,8 @@ import { join, relative } from 'node:path';
 import { redactKtxSensitiveMetadata } from '../../../core/redaction.js';
 export const LIVE_DATABASE_META_FILE = 'connection.json';
 export const LIVE_DATABASE_FOREIGN_KEYS_FILE = 'foreign-keys.json';
+/** @internal */
+export const LIVE_DATABASE_WARNINGS_FILE = 'warnings.json';
 const LIVE_DATABASE_TABLES_DIR = 'tables';
 function encodePathPart(value) {
     return Buffer.from(value ?? '_', 'utf8').toString('base64url');
@@ -60,6 +62,12 @@ function foreignKeyIndex(snapshot) {
         a.toColumn.localeCompare(b.toColumn));
     return entries;
 }
+function warningArtifact(snapshot) {
+    const redacted = redactKtxSensitiveMetadata({ warnings: snapshot.warnings ?? [] });
+    return {
+        warnings: Array.isArray(redacted.warnings) ? redacted.warnings : [],
+    };
+}
 export async function writeLiveDatabaseSnapshot(stagedDir, snapshot) {
     await mkdir(join(stagedDir, LIVE_DATABASE_TABLES_DIR), { recursive: true });
     const sortedTables = [...snapshot.tables].sort((a, b) => tableSortKey(a).localeCompare(tableSortKey(b)));
@@ -73,6 +81,7 @@ export async function writeLiveDatabaseSnapshot(stagedDir, snapshot) {
     };
     await writeFile(join(stagedDir, LIVE_DATABASE_META_FILE), stableJson(metadata));
     await writeFile(join(stagedDir, LIVE_DATABASE_FOREIGN_KEYS_FILE), stableJson({ foreignKeys: foreignKeyIndex(snapshot) }));
+    await writeFile(join(stagedDir, LIVE_DATABASE_WARNINGS_FILE), stableJson(warningArtifact(snapshot)));
     for (const table of sortedTables) {
         await writeFile(join(stagedDir, liveDatabaseTablePath(table)), stableJson(table));
     }

package/dist/context/ingest/adapters/looker/mapping.d.ts

@@ -6,12 +6,9 @@ declare const LOOKER_DIALECT_TO_CONNECTION_TYPE: {
     readonly bigquery_standard_sql: "BIGQUERY";
     readonly snowflake: "SNOWFLAKE";
     readonly postgres: "POSTGRESQL";
-    readonly postgresql: "POSTGRESQL";
     readonly mysql: "MYSQL";
     readonly sqlite: "SQLITE";
     readonly sqlserver: "SQLSERVER";
-    readonly mssql: "SQLSERVER";
-    readonly tsql: "SQLSERVER";
     readonly clickhouse: "CLICKHOUSE";
 };
 /** @internal */

package/dist/context/ingest/adapters/looker/mapping.js

@@ -3,12 +3,9 @@ const LOOKER_DIALECT_TO_CONNECTION_TYPE = {
     bigquery_standard_sql: 'BIGQUERY',
     snowflake: 'SNOWFLAKE',
     postgres: 'POSTGRESQL',
-    postgresql: 'POSTGRESQL',
     mysql: 'MYSQL',
     sqlite: 'SQLITE',
     sqlserver: 'SQLSERVER',
-    mssql: 'SQLSERVER',
-    tsql: 'SQLSERVER',
     clickhouse: 'CLICKHOUSE',
 };
 const SQLGLOT_DIALECT_BY_CONNECTION_TYPE = {

package/dist/context/ingest/adapters/looker/types.d.ts

@@ -12,13 +12,13 @@ export declare const lookerPullConfigSchema: z.ZodObject<{
     lookUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     connectionTypes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        POSTGRESQL: "POSTGRESQL";
         BIGQUERY: "BIGQUERY";
         SNOWFLAKE: "SNOWFLAKE";
         MYSQL: "MYSQL";
         SQLSERVER: "SQLSERVER";
         SQLITE: "SQLITE";
         CLICKHOUSE: "CLICKHOUSE";
+        POSTGRESQL: "POSTGRESQL";
         CENTRALREACH: "CENTRALREACH";
         EPIC: "EPIC";
         CERNER: "CERNER";

package/dist/context/ingest/historic-sql-probes/bigquery-runner.d.ts

@@ -0,0 +1,34 @@
+import { type HistoricSqlFixAdvice, type HistoricSqlProbeInput, type HistoricSqlProbeRunner, type HistoricSqlSuccessDetail } from '../historic-sql-probes.js';
+import { type KtxBigQueryConnectionConfig } from '../../../connectors/bigquery/connector.js';
+interface GenericProbeResult {
+    warnings: string[];
+    info?: string[];
+}
+interface ClientHandle {
+    client: unknown;
+    cleanup(): Promise<void>;
+}
+interface BigQueryJobsByProjectProbeRunnerOptions {
+    createReader?: (options: {
+        projectId: string;
+        region: string;
+    }) => {
+        probe(client: unknown): Promise<GenericProbeResult>;
+    };
+    createClient?: (input: HistoricSqlProbeInput & {
+        connection: KtxBigQueryConnectionConfig;
+    }) => ClientHandle;
+    resolveReference?: (value: string | undefined, env: NodeJS.ProcessEnv) => string | undefined;
+}
+export declare class BigQueryJobsByProjectProbeRunner implements HistoricSqlProbeRunner {
+    readonly dialect: "bigquery";
+    readonly catalogName = "INFORMATION_SCHEMA.JOBS_BY_PROJECT";
+    private readonly createReader;
+    private readonly createClient;
+    private readonly resolveReference;
+    constructor(options?: BigQueryJobsByProjectProbeRunnerOptions);
+    run(input: HistoricSqlProbeInput): Promise<GenericProbeResult>;
+    formatSuccessDetail(result: unknown): HistoricSqlSuccessDetail;
+    fixAdvice(error: unknown): HistoricSqlFixAdvice;
+}
+export {};