@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/scan/types.d.ts

@@ -1,309 +0,0 @@
-export type KtxConnectionDriver = 'sqlite' | 'postgres' | 'postgresql' | 'sqlserver' | 'bigquery' | 'snowflake' | 'mysql' | 'clickhouse';
-export type KtxScanMode = 'structural' | 'relationships' | 'enriched';
-export type KtxScanTrigger = 'cli' | 'mcp' | 'schema_scan' | 'scheduled' | 'manual';
-export interface KtxConnectorCapabilities {
-    structuralIntrospection: true;
-    tableSampling: boolean;
-    columnSampling: boolean;
-    columnStats: boolean;
-    readOnlySql: boolean;
-    nestedAnalysis: boolean;
-    eventStreamDiscovery: boolean;
-    formalForeignKeys: boolean;
-    estimatedRowCounts: boolean;
-}
-export type KtxOptionalConnectorCapabilities = Partial<Omit<KtxConnectorCapabilities, 'structuralIntrospection'>>;
-export declare function createKtxConnectorCapabilities(capabilities?: KtxOptionalConnectorCapabilities): KtxConnectorCapabilities;
-export interface KtxSchemaScope {
-    catalogs?: string[];
-    schemas?: string[];
-    datasets?: string[];
-}
-export type KtxSchemaTableKind = 'table' | 'view' | 'external' | 'event_stream';
-export type KtxSchemaDimensionType = 'time' | 'string' | 'number' | 'boolean';
-export interface KtxSchemaColumn {
-    name: string;
-    nativeType: string;
-    normalizedType: string;
-    dimensionType: KtxSchemaDimensionType;
-    nullable: boolean;
-    primaryKey: boolean;
-    comment: string | null;
-}
-export interface KtxSchemaForeignKey {
-    fromColumn: string;
-    toCatalog: string | null;
-    toDb: string | null;
-    toTable: string;
-    toColumn: string;
-    constraintName: string | null;
-}
-export interface KtxSchemaTable {
-    catalog: string | null;
-    db: string | null;
-    name: string;
-    kind: KtxSchemaTableKind;
-    comment: string | null;
-    estimatedRows: number | null;
-    columns: KtxSchemaColumn[];
-    foreignKeys: KtxSchemaForeignKey[];
-}
-export interface KtxSchemaSnapshot {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    extractedAt: string;
-    scope: KtxSchemaScope;
-    tables: KtxSchemaTable[];
-    metadata: Record<string, unknown>;
-}
-export interface KtxCredentialEnvReference {
-    kind: 'env';
-    name: string;
-}
-export interface KtxCredentialFileReference {
-    kind: 'file';
-    path: string;
-}
-export interface KtxResolvedCredentialEnvelope {
-    kind: 'resolved';
-    source: 'standalone' | 'host';
-    values: Record<string, unknown>;
-    redacted?: boolean;
-}
-export type KtxCredentialEnvelope = KtxCredentialEnvReference | KtxCredentialFileReference | KtxResolvedCredentialEnvelope;
-export interface KtxNetworkEndpoint {
-    host: string;
-    port: number;
-    close?: () => Promise<void>;
-}
-export interface KtxNetworkTunnelRequest<TConnection = Record<string, unknown>> {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    host: string;
-    port: number;
-    connection: TConnection;
-}
-export interface KtxNetworkTunnelPort<TConnection = Record<string, unknown>> {
-    resolveEndpoint(input: KtxNetworkTunnelRequest<TConnection>): Promise<KtxNetworkEndpoint | null>;
-}
-export interface KtxScanInput {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    scope?: KtxSchemaScope;
-    mode?: KtxScanMode;
-    dryRun?: boolean;
-    detectRelationships?: boolean;
-    credentials?: KtxCredentialEnvelope;
-    metadata?: Record<string, unknown>;
-}
-export interface KtxProgressUpdateOptions {
-    transient?: boolean;
-}
-export interface KtxProgressPort {
-    update(progress: number, message?: string, options?: KtxProgressUpdateOptions): Promise<void>;
-    startPhase(weight: number): KtxProgressPort;
-}
-export interface KtxScanLoggerPort {
-    debug(message: string, metadata?: Record<string, unknown>): void;
-    info(message: string, metadata?: Record<string, unknown>): void;
-    warn(message: string, metadata?: Record<string, unknown>): void;
-    error(message: string, metadata?: Record<string, unknown>): void;
-}
-export interface KtxScanContext {
-    runId: string;
-    signal?: AbortSignal;
-    progress?: KtxProgressPort;
-    logger?: KtxScanLoggerPort;
-}
-export interface KtxTableRef {
-    catalog: string | null;
-    db: string | null;
-    name: string;
-}
-export interface KtxTableSampleInput {
-    connectionId: string;
-    table: KtxTableRef;
-    columns?: string[];
-    limit: number;
-}
-export interface KtxTableSampleResult {
-    headers: string[];
-    rows: unknown[][];
-    totalRows: number;
-}
-export interface KtxColumnSampleInput {
-    connectionId: string;
-    table: KtxTableRef;
-    column: string;
-    limit: number;
-}
-export interface KtxColumnSampleResult {
-    values: unknown[];
-    nullCount: number | null;
-    distinctCount: number | null;
-}
-export interface KtxColumnStatsInput {
-    connectionId: string;
-    table: KtxTableRef;
-    column: string;
-}
-export interface KtxColumnStatsResult {
-    min: unknown;
-    max: unknown;
-    average: number | null;
-    nullCount: number | null;
-    distinctCount: number | null;
-}
-export interface KtxEventTypeDiscoveryInput {
-    connectionId: string;
-    table: KtxTableRef;
-    eventColumn: string;
-    limit: number;
-    minCount?: number;
-    lookbackDays?: number;
-}
-export interface KtxEventTypeDiscovery {
-    value: string;
-    count: number;
-}
-export interface KtxEventPropertyDiscoveryInput {
-    connectionId: string;
-    table: KtxTableRef;
-    jsonColumn: string;
-    sampleSize: number;
-    limit: number;
-    lookbackDays?: number;
-}
-export interface KtxEventPropertyDiscovery {
-    key: string;
-    count: number;
-}
-export interface KtxEventPropertyValuesInput {
-    connectionId: string;
-    table: KtxTableRef;
-    jsonColumn: string;
-    propertyKey: string;
-    limit: number;
-    maxCardinality?: number;
-    lookbackDays?: number;
-}
-export interface KtxEventPropertyValuesResult {
-    values: string[];
-    cardinality: number;
-}
-export interface KtxEventStreamDiscoveryPort {
-    listEventTypes(input: KtxEventTypeDiscoveryInput, ctx: KtxScanContext): Promise<KtxEventTypeDiscovery[]>;
-    listPropertyKeys(input: KtxEventPropertyDiscoveryInput, ctx: KtxScanContext): Promise<KtxEventPropertyDiscovery[]>;
-    listPropertyValues(input: KtxEventPropertyValuesInput, ctx: KtxScanContext): Promise<KtxEventPropertyValuesResult | null>;
-}
-export interface KtxReadOnlyQueryInput {
-    connectionId: string;
-    sql: string;
-    maxRows?: number;
-}
-export interface KtxQueryResult {
-    headers: string[];
-    headerTypes?: string[];
-    rows: unknown[][];
-    totalRows: number;
-    rowCount: number | null;
-}
-export interface KtxTableListEntry {
-    schema: string;
-    name: string;
-    kind: 'table' | 'view';
-}
-export interface KtxConnectorTestResult {
-    success: boolean;
-    error?: string;
-}
-export interface KtxScanConnector {
-    id: string;
-    driver: KtxConnectionDriver;
-    capabilities: KtxConnectorCapabilities;
-    eventStreamDiscovery?: KtxEventStreamDiscoveryPort;
-    introspect(input: KtxScanInput, ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
-    testConnection?(): Promise<KtxConnectorTestResult>;
-    sampleColumn?(input: KtxColumnSampleInput, ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
-    sampleTable?(input: KtxTableSampleInput, ctx: KtxScanContext): Promise<KtxTableSampleResult>;
-    columnStats?(input: KtxColumnStatsInput, ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
-    executeReadOnly?(input: KtxReadOnlyQueryInput, ctx: KtxScanContext): Promise<KtxQueryResult>;
-    cleanup?(): Promise<void>;
-}
-export interface KtxEmbeddingPort {
-    dimensions: number;
-    maxBatchSize: number;
-    embedBatch(texts: string[]): Promise<number[][]>;
-}
-export interface KtxStructuralSyncStats {
-    tablesCreated: number;
-    tablesUpdated: number;
-    tablesDeleted: number;
-    columnsCreated: number;
-    columnsUpdated: number;
-    columnsDeleted: number;
-}
-export interface KtxScanDiffSummary {
-    tablesAdded: number;
-    tablesModified: number;
-    tablesDeleted: number;
-    tablesUnchanged: number;
-    columnsAdded: number;
-    columnsModified: number;
-    columnsDeleted: number;
-}
-export interface KtxScanArtifactPaths {
-    rawSourcesDir: string | null;
-    reportPath: string | null;
-    manifestShards: string[];
-    enrichmentArtifacts: string[];
-}
-export type KtxScanWarningCode = 'connector_capability_missing' | 'sampling_failed' | 'statistics_failed' | 'llm_unavailable' | 'embedding_unavailable' | 'scan_enrichment_backend_not_configured' | 'relationship_validation_failed' | 'relationship_llm_invalid_reference' | 'relationship_llm_proposal_failed' | 'credential_redacted' | 'enrichment_failed' | 'description_fallback_used';
-export interface KtxScanWarning {
-    code: KtxScanWarningCode;
-    message: string;
-    table?: string;
-    column?: string;
-    recoverable: boolean;
-    metadata?: Record<string, unknown>;
-}
-export interface KtxScanEnrichmentSummary {
-    dataDictionary: 'skipped' | 'completed' | 'failed';
-    tableDescriptions: 'skipped' | 'completed' | 'failed';
-    columnDescriptions: 'skipped' | 'completed' | 'failed';
-    embeddings: 'skipped' | 'completed' | 'failed';
-    deterministicRelationships: 'skipped' | 'completed' | 'failed';
-    llmRelationshipValidation: 'skipped' | 'completed' | 'failed';
-    statisticalValidation: 'skipped' | 'completed' | 'failed';
-}
-export interface KtxScanRelationshipSummary {
-    accepted: number;
-    review: number;
-    rejected: number;
-    skipped: number;
-}
-export type KtxScanEnrichmentStage = 'descriptions' | 'embeddings' | 'relationships';
-export interface KtxScanEnrichmentStateSummary {
-    resumedStages: KtxScanEnrichmentStage[];
-    completedStages: KtxScanEnrichmentStage[];
-    failedStages: KtxScanEnrichmentStage[];
-}
-export interface KtxScanReport {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    syncId: string;
-    runId: string;
-    trigger: KtxScanTrigger;
-    mode: KtxScanMode;
-    dryRun: boolean;
-    artifactPaths: KtxScanArtifactPaths;
-    diffSummary: KtxScanDiffSummary;
-    manifestShardsWritten: number;
-    structuralSyncStats: KtxStructuralSyncStats;
-    enrichment: KtxScanEnrichmentSummary;
-    capabilityGaps: Array<keyof Omit<KtxConnectorCapabilities, 'structuralIntrospection'>>;
-    warnings: KtxScanWarning[];
-    relationships: KtxScanRelationshipSummary;
-    enrichmentState: KtxScanEnrichmentStateSummary;
-    createdAt: string;
-}

package/node_modules/@ktx/context/dist/scan/warehouse-catalog.d.ts

@@ -1,69 +0,0 @@
-import type { KtxFileStorePort } from '../core/index.js';
-import type { KtxSchemaColumn, KtxSchemaForeignKey, KtxTableRef } from './types.js';
-export interface WarehouseCatalogServiceDeps {
-    fileStore: KtxFileStorePort;
-}
-interface WarehouseColumnDetail extends KtxSchemaColumn {
-    descriptions: Record<string, string>;
-    rowCount: number | null;
-    nullCount: number | null;
-    distinctCount: number | null;
-    nullRate: number | null;
-    sampleValues: string[];
-}
-export interface TableDetail {
-    connectionId: string;
-    catalog: string | null;
-    db: string | null;
-    name: string;
-    display: string;
-    kind: string;
-    comment: string | null;
-    description: string | null;
-    rowCount: number | null;
-    columns: WarehouseColumnDetail[];
-    foreignKeys: KtxSchemaForeignKey[];
-}
-export type RawSchemaHit = {
-    kind: 'table';
-    connectionId: string;
-    ref: KtxTableRef;
-    display: string;
-    matchedOn: 'name' | 'db' | 'comment' | 'description';
-} | {
-    kind: 'column';
-    connectionId: string;
-    ref: KtxTableRef & {
-        column: string;
-    };
-    display: string;
-    matchedOn: 'name' | 'comment' | 'description';
-};
-export interface DisplayTargetResolution {
-    resolved: (KtxTableRef & {
-        column?: string;
-    }) | null;
-    candidates: KtxTableRef[];
-    dialect: string;
-}
-export declare class WarehouseCatalogService {
-    private readonly deps;
-    private readonly catalogs;
-    constructor(deps: WarehouseCatalogServiceDeps);
-    hasScan(connectionId: string): Promise<boolean>;
-    getLatestSyncId(connectionId: string): Promise<string | null>;
-    listTables(connectionId: string): Promise<KtxTableRef[]>;
-    getTable(ref: {
-        connectionId: string;
-    } & KtxTableRef): Promise<TableDetail | null>;
-    resolveDisplay(connectionId: string, display: string): Promise<{
-        resolved: KtxTableRef | null;
-        candidates: KtxTableRef[];
-        dialect: string;
-    }>;
-    resolveDisplayTarget(connectionId: string, display: string): Promise<DisplayTargetResolution>;
-    searchByName(connectionId: string, query: string, limit: number): Promise<RawSchemaHit[]>;
-    private loadCatalog;
-    private readCatalog;
-}
-export {};

package/node_modules/@ktx/context/dist/scan/warehouse-catalog.js

@@ -1,311 +0,0 @@
-import { getDialectForDriver } from '../connections/index.js';
-function normalize(value) {
-    return (value ?? '').toLowerCase();
-}
-function refsEqual(left, right) {
-    return (normalize(left.catalog) === normalize(right.catalog) &&
-        normalize(left.db) === normalize(right.db) &&
-        normalize(left.name) === normalize(right.name));
-}
-function refKey(ref) {
-    return [ref.catalog, ref.db, ref.name].map((part) => normalize(part)).join('.');
-}
-function columnKey(ref, column) {
-    return `${refKey(ref)}.${normalize(column)}`;
-}
-function readJson(content) {
-    return JSON.parse(content);
-}
-function cleanIdentifierPart(part) {
-    return part.trim().replace(/^["'`\[]|["'`\]]$/g, '');
-}
-function splitDisplay(display) {
-    return display
-        .trim()
-        .split('.')
-        .map(cleanIdentifierPart)
-        .filter(Boolean);
-}
-function formatDisplay(driver, table) {
-    if (driver === 'sqlite' || driver === 'sqlite3') {
-        return table.name;
-    }
-    return [table.catalog, table.db, table.name].filter((part) => Boolean(part)).join('.');
-}
-function parseDisplay(driver, display) {
-    const parts = splitDisplay(display);
-    if (driver === 'sqlite' || driver === 'sqlite3') {
-        return parts.length === 1 ? { catalog: null, db: null, name: parts[0] } : null;
-    }
-    if (driver === 'bigquery' || driver === 'snowflake' || driver === 'sqlserver') {
-        if (parts.length !== 3) {
-            return null;
-        }
-        return { catalog: parts[0], db: parts[1], name: parts[2] };
-    }
-    if (parts.length === 2) {
-        return { catalog: null, db: parts[0], name: parts[1] };
-    }
-    if (parts.length === 3) {
-        return { catalog: parts[0], db: parts[1], name: parts[2] };
-    }
-    return parts.length === 1 ? { catalog: null, db: null, name: parts[0] } : null;
-}
-function expectedDisplayPartCount(driver) {
-    if (driver === 'sqlite' || driver === 'sqlite3') {
-        return 1;
-    }
-    if (driver === 'bigquery' || driver === 'snowflake' || driver === 'sqlserver') {
-        return 3;
-    }
-    return 2;
-}
-function parseColumnDisplay(driver, display) {
-    const parts = splitDisplay(display);
-    const tablePartCount = expectedDisplayPartCount(driver);
-    if (parts.length !== tablePartCount + 1) {
-        return null;
-    }
-    const column = parts.at(-1);
-    if (!column) {
-        return null;
-    }
-    const table = parseDisplay(driver, parts.slice(0, -1).join('.'));
-    return table ? { ...table, column } : null;
-}
-function bestCandidates(tables, display, limit = 5) {
-    const needle = normalize(splitDisplay(display).at(-1) ?? display);
-    return tables
-        .map((table) => {
-        const name = normalize(table.name);
-        let score = 0;
-        if (name === needle) {
-            score = 100;
-        }
-        else if (name.includes(needle) || needle.includes(name)) {
-            score = 80;
-        }
-        else {
-            const samePrefix = [...name].filter((char, index) => needle[index] === char).length;
-            score = samePrefix / Math.max(name.length, needle.length, 1);
-        }
-        return { table, score };
-    })
-        .filter((entry) => entry.score > 0)
-        .sort((left, right) => right.score - left.score || left.table.name.localeCompare(right.table.name))
-        .slice(0, limit)
-        .map(({ table }) => ({ catalog: table.catalog, db: table.db, name: table.name }));
-}
-function firstDescription(descriptions) {
-    return Object.values(descriptions ?? {}).find((value) => value.trim().length > 0) ?? null;
-}
-function matchedOnTable(table, query) {
-    const q = normalize(query);
-    if (!q) {
-        return null;
-    }
-    if (normalize(table.name).includes(q)) {
-        return 'name';
-    }
-    if (normalize(table.db).includes(q)) {
-        return 'db';
-    }
-    if (normalize(table.comment).includes(q)) {
-        return 'comment';
-    }
-    if (normalize(firstDescription(table.descriptions)).includes(q)) {
-        return 'description';
-    }
-    return null;
-}
-function matchedOnColumn(column, query) {
-    const q = normalize(query);
-    if (!q) {
-        return null;
-    }
-    if (normalize(column.name).includes(q)) {
-        return 'name';
-    }
-    if (normalize(column.comment).includes(q)) {
-        return 'comment';
-    }
-    if (normalize(firstDescription(column.descriptions)).includes(q)) {
-        return 'description';
-    }
-    return null;
-}
-export class WarehouseCatalogService {
-    deps;
-    catalogs = new Map();
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async hasScan(connectionId) {
-        return (await this.loadCatalog(connectionId)) !== null;
-    }
-    async getLatestSyncId(connectionId) {
-        return (await this.loadCatalog(connectionId))?.syncId ?? null;
-    }
-    async listTables(connectionId) {
-        const catalog = await this.loadCatalog(connectionId);
-        return catalog?.tables.map((table) => ({ catalog: table.catalog, db: table.db, name: table.name })) ?? [];
-    }
-    async getTable(ref) {
-        const catalog = await this.loadCatalog(ref.connectionId);
-        if (!catalog) {
-            return null;
-        }
-        const table = catalog.tables.find((candidate) => refsEqual(candidate, ref));
-        if (!table) {
-            return null;
-        }
-        const profileTables = catalog.profile?.tables ?? [];
-        const profileTable = profileTables.find((candidate) => candidate.table && refsEqual(candidate.table, table));
-        const profileColumns = catalog.profile?.columns ?? {};
-        return {
-            connectionId: ref.connectionId,
-            catalog: table.catalog,
-            db: table.db,
-            name: table.name,
-            display: formatDisplay(catalog.driver, table),
-            kind: table.kind,
-            comment: table.comment,
-            description: firstDescription(table.descriptions),
-            rowCount: profileTable?.rowCount ?? table.estimatedRows ?? null,
-            columns: table.columns.map((rawColumn) => {
-                const column = rawColumn;
-                const profileColumn = profileColumns[columnKey(table, column.name)] ??
-                    Object.entries(profileColumns).find(([key, value]) => normalize(key) === `${normalize(table.name)}.${normalize(column.name)}` ||
-                        (value.table && refsEqual(value.table, table) && normalize(value.column) === normalize(column.name)))?.[1];
-                return {
-                    ...column,
-                    descriptions: column.descriptions ?? {},
-                    rowCount: profileColumn?.rowCount ?? null,
-                    nullCount: profileColumn?.nullCount ?? null,
-                    distinctCount: profileColumn?.distinctCount ?? null,
-                    nullRate: profileColumn?.nullRate ?? null,
-                    sampleValues: (profileColumn?.sampleValues ?? []).map((value) => String(value)),
-                };
-            }),
-            foreignKeys: table.foreignKeys,
-        };
-    }
-    async resolveDisplay(connectionId, display) {
-        const catalog = await this.loadCatalog(connectionId);
-        if (!catalog) {
-            return { resolved: null, candidates: [], dialect: 'unknown' };
-        }
-        const dialect = getDialectForDriver(catalog.driver).type;
-        const parsed = parseDisplay(catalog.driver, display);
-        if (!parsed) {
-            return { resolved: null, candidates: bestCandidates(catalog.tables, display), dialect };
-        }
-        const table = catalog.tables.find((candidate) => refsEqual(candidate, parsed));
-        if (!table) {
-            return { resolved: null, candidates: bestCandidates(catalog.tables, display), dialect };
-        }
-        return { resolved: { catalog: table.catalog, db: table.db, name: table.name }, candidates: [], dialect };
-    }
-    async resolveDisplayTarget(connectionId, display) {
-        const catalog = await this.loadCatalog(connectionId);
-        if (!catalog) {
-            return { resolved: null, candidates: [], dialect: 'unknown' };
-        }
-        const dialect = getDialectForDriver(catalog.driver).type;
-        const tableResolution = await this.resolveDisplay(connectionId, display);
-        if (tableResolution.resolved) {
-            return tableResolution;
-        }
-        const parsedColumn = parseColumnDisplay(catalog.driver, display);
-        if (!parsedColumn) {
-            return { resolved: null, candidates: bestCandidates(catalog.tables, display), dialect };
-        }
-        const table = catalog.tables.find((candidate) => refsEqual(candidate, parsedColumn));
-        if (!table) {
-            return { resolved: null, candidates: bestCandidates(catalog.tables, display), dialect };
-        }
-        return {
-            resolved: {
-                catalog: table.catalog,
-                db: table.db,
-                name: table.name,
-                column: parsedColumn.column,
-            },
-            candidates: [],
-            dialect,
-        };
-    }
-    async searchByName(connectionId, query, limit) {
-        const catalog = await this.loadCatalog(connectionId);
-        if (!catalog) {
-            return [];
-        }
-        const hits = [];
-        for (const table of catalog.tables) {
-            const tableMatch = matchedOnTable(table, query);
-            if (tableMatch) {
-                hits.push({
-                    kind: 'table',
-                    connectionId,
-                    ref: { catalog: table.catalog, db: table.db, name: table.name },
-                    display: formatDisplay(catalog.driver, table),
-                    matchedOn: tableMatch,
-                });
-            }
-            for (const column of table.columns) {
-                const columnMatch = matchedOnColumn(column, query);
-                if (!columnMatch) {
-                    continue;
-                }
-                hits.push({
-                    kind: 'column',
-                    connectionId,
-                    ref: { catalog: table.catalog, db: table.db, name: table.name, column: column.name },
-                    display: `${formatDisplay(catalog.driver, table)}.${column.name}`,
-                    matchedOn: columnMatch,
-                });
-            }
-        }
-        return hits.slice(0, Math.max(0, limit));
-    }
-    loadCatalog(connectionId) {
-        const existing = this.catalogs.get(connectionId);
-        if (existing) {
-            return existing;
-        }
-        const pending = this.readCatalog(connectionId);
-        this.catalogs.set(connectionId, pending);
-        return pending;
-    }
-    async readCatalog(connectionId) {
-        const root = `raw-sources/${connectionId}/live-database`;
-        const listed = await this.deps.fileStore.listFiles(root);
-        const connectionFiles = listed.files.filter((file) => file.endsWith('/connection.json')).sort();
-        const latestConnectionPath = connectionFiles.at(-1);
-        if (!latestConnectionPath) {
-            return null;
-        }
-        const latestRoot = latestConnectionPath.slice(0, -'/connection.json'.length);
-        const syncId = latestRoot.split('/').at(-1) ?? '';
-        const connection = readJson((await this.deps.fileStore.readFile(latestConnectionPath)).content);
-        const tablesListing = await this.deps.fileStore.listFiles(`${latestRoot}/tables`);
-        const tables = [];
-        for (const tablePath of tablesListing.files.filter((file) => file.endsWith('.json')).sort()) {
-            tables.push(readJson((await this.deps.fileStore.readFile(tablePath)).content));
-        }
-        let profile = null;
-        try {
-            profile = readJson((await this.deps.fileStore.readFile(`${latestRoot}/enrichment/relationship-profile.json`)).content);
-        }
-        catch {
-            profile = null;
-        }
-        return {
-            connectionId,
-            syncId,
-            driver: connection.driver ?? profile?.driver ?? 'postgres',
-            tables,
-            profile,
-        };
-    }
-}