@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/structural-sync.test.js

@@ -1,416 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { planLiveDatabaseStructuralSync } from './structural-sync.js';
-function idFactory() {
-    let next = 1;
-    return () => `id-${next++}`;
-}
-describe('planLiveDatabaseStructuralSync', () => {
-    it('plans table and column creates, updates, deletes, and metadata invalidation', () => {
-        const current = {
-            connectionId: 'conn-1',
-            tables: [
-                {
-                    id: 'tbl-orders',
-                    name: 'orders',
-                    catalog: null,
-                    db: 'public',
-                    enabled: true,
-                    descriptions: { ai: 'Old AI order text', db: 'Old DB order text' },
-                    columns: [
-                        {
-                            id: 'col-order-id',
-                            name: 'id',
-                            type: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            parentColumnId: null,
-                            descriptions: { db: 'Order id' },
-                            embedding: [1, 2, 3],
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                        {
-                            id: 'col-order-total',
-                            name: 'total',
-                            type: 'number',
-                            nullable: true,
-                            primaryKey: false,
-                            parentColumnId: null,
-                            descriptions: { ai: 'Old AI total text', db: 'Old total text' },
-                            embedding: [4, 5, 6],
-                            sampleValues: ['10'],
-                            cardinality: 12,
-                        },
-                        {
-                            id: 'col-order-removed',
-                            name: 'removed',
-                            type: 'string',
-                            nullable: true,
-                            primaryKey: false,
-                            parentColumnId: null,
-                            descriptions: {},
-                            embedding: null,
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                    ],
-                },
-                {
-                    id: 'tbl-removed',
-                    name: 'removed_table',
-                    catalog: null,
-                    db: 'public',
-                    enabled: true,
-                    descriptions: {},
-                    columns: [
-                        {
-                            id: 'col-removed-id',
-                            name: 'id',
-                            type: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            parentColumnId: null,
-                            descriptions: {},
-                            embedding: null,
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                    ],
-                },
-            ],
-            links: [
-                {
-                    id: 'inferred-total-link',
-                    fromTableId: 'tbl-orders',
-                    fromColumnId: 'col-order-total',
-                    toTableId: 'tbl-orders',
-                    toColumnId: 'col-order-id',
-                    source: 'inferred',
-                    confidence: 0.7,
-                    relationshipType: 'MANY_TO_ONE',
-                    isPrimaryKeyReference: true,
-                },
-            ],
-        };
-        const plan = planLiveDatabaseStructuralSync({
-            connectionId: 'conn-1',
-            current,
-            extracted: {
-                connectionId: 'conn-1',
-                tables: [
-                    {
-                        name: 'orders',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: 'Fresh DB order text',
-                        columns: [
-                            {
-                                name: 'id',
-                                type: 'number',
-                                nullable: false,
-                                primaryKey: true,
-                                dbComment: 'Order id',
-                            },
-                            {
-                                name: 'total',
-                                type: 'string',
-                                nullable: false,
-                                primaryKey: false,
-                                dbComment: 'Fresh total text',
-                            },
-                            {
-                                name: 'created_at',
-                                type: 'time',
-                                nullable: false,
-                                primaryKey: false,
-                                dbComment: 'Creation timestamp',
-                            },
-                        ],
-                        foreignKeys: [],
-                    },
-                    {
-                        name: 'customers',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: 'Customer table',
-                        columns: [
-                            {
-                                name: 'id',
-                                type: 'number',
-                                nullable: false,
-                                primaryKey: true,
-                                dbComment: null,
-                            },
-                        ],
-                        foreignKeys: [],
-                    },
-                ],
-            },
-            idFactory: idFactory(),
-        });
-        expect(plan.stats).toEqual({
-            tablesCreated: 1,
-            tablesDeleted: 1,
-            columnsCreated: 2,
-            columnsDeleted: 2,
-            columnsModified: 1,
-            formalLinksCreated: 0,
-            formalLinksDeleted: 0,
-        });
-        expect(plan.operations.deleteTableIds).toEqual(['tbl-removed']);
-        expect(plan.operations.deleteColumnIds).toEqual(['col-order-removed']);
-        expect(plan.operations.insertTables).toEqual([
-            {
-                id: 'id-2',
-                connectionId: 'conn-1',
-                name: 'customers',
-                catalog: null,
-                db: 'public',
-                enabled: true,
-            },
-        ]);
-        expect(plan.operations.insertColumns).toEqual([
-            {
-                id: 'id-1',
-                tableId: 'tbl-orders',
-                name: 'created_at',
-                parentColumnId: null,
-            },
-            {
-                id: 'id-3',
-                tableId: 'id-2',
-                name: 'id',
-                parentColumnId: null,
-            },
-        ]);
-        expect(plan.operations.touchColumnIds).toEqual(['col-order-total']);
-        expect(plan.operations.invalidateColumnEmbeddingIds).toEqual(['col-order-total']);
-        expect(plan.inferredLinksToValidate).toEqual(['inferred-total-link']);
-        expect(plan.changes).toEqual({
-            newTableIds: ['id-2'],
-            newColumnIds: ['id-1', 'id-3'],
-            tablesWithStructuralChanges: ['tbl-orders', 'id-2'],
-            columnsWithTypeChange: ['col-order-total'],
-            columnsWithDescriptionChange: ['col-order-total'],
-            tablesWithDescriptionChange: ['tbl-orders'],
-        });
-        const orders = plan.schema.tables.find((table) => table.name === 'orders');
-        expect(orders?.descriptions).toEqual({ db: 'Fresh DB order text' });
-        expect(orders?.columns.map((column) => column.name)).toEqual(['id', 'total', 'created_at']);
-        expect(orders?.columns.find((column) => column.name === 'total')).toMatchObject({
-            id: 'col-order-total',
-            type: 'string',
-            nullable: false,
-            primaryKey: false,
-            descriptions: { db: 'Fresh total text' },
-            embedding: null,
-            sampleValues: ['10'],
-            cardinality: 12,
-        });
-    });
-    it('builds formal links from extracted foreign keys and preserves valid inferred links', () => {
-        const current = {
-            connectionId: 'conn-1',
-            tables: [
-                {
-                    id: 'tbl-orders',
-                    name: 'orders',
-                    catalog: null,
-                    db: 'public',
-                    enabled: true,
-                    descriptions: {},
-                    columns: [
-                        {
-                            id: 'col-orders-id',
-                            name: 'id',
-                            type: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            parentColumnId: null,
-                            descriptions: {},
-                            embedding: null,
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                        {
-                            id: 'col-orders-customer',
-                            name: 'customer_id',
-                            type: 'number',
-                            nullable: false,
-                            primaryKey: false,
-                            parentColumnId: null,
-                            descriptions: {},
-                            embedding: null,
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                    ],
-                },
-                {
-                    id: 'tbl-customers',
-                    name: 'customers',
-                    catalog: null,
-                    db: 'public',
-                    enabled: true,
-                    descriptions: {},
-                    columns: [
-                        {
-                            id: 'col-customers-id',
-                            name: 'id',
-                            type: 'number',
-                            nullable: false,
-                            primaryKey: true,
-                            parentColumnId: null,
-                            descriptions: {},
-                            embedding: null,
-                            sampleValues: null,
-                            cardinality: null,
-                        },
-                    ],
-                },
-            ],
-            links: [
-                {
-                    id: 'formal-existing',
-                    fromTableId: 'tbl-orders',
-                    fromColumnId: 'col-orders-customer',
-                    toTableId: 'tbl-customers',
-                    toColumnId: 'col-customers-id',
-                    source: 'formal',
-                    confidence: 1,
-                    relationshipType: 'MANY_TO_ONE',
-                    isPrimaryKeyReference: true,
-                },
-                {
-                    id: 'inferred-existing',
-                    fromTableId: 'tbl-orders',
-                    fromColumnId: 'col-orders-id',
-                    toTableId: 'tbl-customers',
-                    toColumnId: 'col-customers-id',
-                    source: 'inferred',
-                    confidence: 0.6,
-                    relationshipType: 'MANY_TO_ONE',
-                    isPrimaryKeyReference: true,
-                },
-            ],
-        };
-        const plan = planLiveDatabaseStructuralSync({
-            connectionId: 'conn-1',
-            current,
-            extracted: {
-                connectionId: 'conn-1',
-                tables: [
-                    {
-                        name: 'orders',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [
-                            { name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null },
-                            { name: 'customer_id', type: 'number', nullable: false, primaryKey: false, dbComment: null },
-                        ],
-                        foreignKeys: [
-                            {
-                                fromTable: 'orders',
-                                fromColumn: 'customer_id',
-                                toTable: 'customers',
-                                toColumn: 'id',
-                            },
-                        ],
-                    },
-                    {
-                        name: 'customers',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [{ name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null }],
-                        foreignKeys: [],
-                    },
-                ],
-            },
-            idFactory: idFactory(),
-        });
-        expect(plan.stats.formalLinksCreated).toBe(0);
-        expect(plan.stats.formalLinksDeleted).toBe(0);
-        expect(plan.schema.links.map((link) => link.id)).toEqual(['formal-existing', 'inferred-existing']);
-        const planAfterForeignKeyRemoval = planLiveDatabaseStructuralSync({
-            connectionId: 'conn-1',
-            current,
-            extracted: {
-                connectionId: 'conn-1',
-                tables: [
-                    {
-                        name: 'orders',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [
-                            { name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null },
-                            { name: 'customer_id', type: 'number', nullable: false, primaryKey: false, dbComment: null },
-                        ],
-                        foreignKeys: [],
-                    },
-                    {
-                        name: 'customers',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [{ name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null }],
-                        foreignKeys: [],
-                    },
-                ],
-            },
-            idFactory: idFactory(),
-        });
-        expect(planAfterForeignKeyRemoval.stats.formalLinksDeleted).toBe(1);
-        expect(planAfterForeignKeyRemoval.schema.links.map((link) => link.id)).toEqual(['inferred-existing']);
-        const planAfterForeignKeyCreation = planLiveDatabaseStructuralSync({
-            connectionId: 'conn-1',
-            current: { ...current, links: [current.links[1]] },
-            extracted: {
-                connectionId: 'conn-1',
-                tables: [
-                    {
-                        name: 'orders',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [
-                            { name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null },
-                            { name: 'customer_id', type: 'number', nullable: false, primaryKey: false, dbComment: null },
-                        ],
-                        foreignKeys: [
-                            {
-                                fromTable: 'orders',
-                                fromColumn: 'customer_id',
-                                toTable: 'customers',
-                                toColumn: 'id',
-                            },
-                        ],
-                    },
-                    {
-                        name: 'customers',
-                        catalog: null,
-                        db: 'public',
-                        dbComment: null,
-                        columns: [{ name: 'id', type: 'number', nullable: false, primaryKey: true, dbComment: null }],
-                        foreignKeys: [],
-                    },
-                ],
-            },
-            idFactory: idFactory(),
-        });
-        expect(planAfterForeignKeyCreation.stats.formalLinksCreated).toBe(1);
-        expect(planAfterForeignKeyCreation.schema.links[0]).toMatchObject({
-            id: 'id-1',
-            fromTableId: 'tbl-orders',
-            fromColumnId: 'col-orders-customer',
-            toTableId: 'tbl-customers',
-            toColumnId: 'col-customers-id',
-            source: 'formal',
-            confidence: 1,
-            relationshipType: 'MANY_TO_ONE',
-            isPrimaryKeyReference: true,
-        });
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/live-database/types.d.ts

@@ -1,8 +0,0 @@
-import type { KtxSchemaSnapshot } from '../../../scan/types.js';
-export interface LiveDatabaseIntrospectionPort {
-    extractSchema(connectionId: string): Promise<KtxSchemaSnapshot>;
-}
-export interface LiveDatabaseSourceAdapterDeps {
-    introspection: LiveDatabaseIntrospectionPort;
-    now?: () => Date;
-}

package/node_modules/@ktx/context/dist/ingest/adapters/looker/factory.d.ts

@@ -1,21 +0,0 @@
-import type { FetchContext } from '../../types.js';
-import { type LookerClientDeps, type LookerConnectionParams } from './client.js';
-import type { LookerClientFactory, LookerRuntimeClient } from './fetch.js';
-import type { LookerPullConfig } from './types.js';
-export interface LookerCredentialResolver {
-    resolve(lookerConnectionId: string): Promise<LookerConnectionParams>;
-}
-export interface LookerConnectionClientFactory {
-    createClient(lookerConnectionId: string): Promise<LookerRuntimeClient>;
-}
-export declare class DefaultLookerConnectionClientFactory implements LookerConnectionClientFactory {
-    private readonly resolver;
-    private readonly deps;
-    constructor(resolver: LookerCredentialResolver, deps?: LookerClientDeps);
-    createClient(lookerConnectionId: string): Promise<LookerRuntimeClient>;
-}
-export declare class DefaultLookerClientFactory implements LookerClientFactory {
-    private readonly inner;
-    constructor(inner: LookerConnectionClientFactory);
-    createClient(config: LookerPullConfig, ctx: FetchContext): Promise<LookerRuntimeClient>;
-}

package/node_modules/@ktx/context/dist/ingest/adapters/looker/factory.js

@@ -1,22 +0,0 @@
-import { LookerClient } from './client.js';
-export class DefaultLookerConnectionClientFactory {
-    resolver;
-    deps;
-    constructor(resolver, deps = {}) {
-        this.resolver = resolver;
-        this.deps = deps;
-    }
-    async createClient(lookerConnectionId) {
-        const credentials = await this.resolver.resolve(lookerConnectionId);
-        return new LookerClient(credentials, this.deps);
-    }
-}
-export class DefaultLookerClientFactory {
-    inner;
-    constructor(inner) {
-        this.inner = inner;
-    }
-    async createClient(config, ctx) {
-        return this.inner.createClient(config.lookerConnectionId ?? ctx.connectionId);
-    }
-}

package/node_modules/@ktx/context/dist/ingest/adapters/looker/fetch.d.ts

@@ -1,31 +0,0 @@
-import type { FetchContext } from '../../types.js';
-import { type LookerPullConfig, type StagedDashboardFile, type StagedExploreFile, type StagedFoldersTreeFile, type StagedGroupFile, type StagedLookerSignalsFile, type StagedLookFile, type StagedLookmlModelsFile, type StagedUserFile } from './types.js';
-export interface LookerEntityRef {
-    id: string;
-    updatedAt?: string | null;
-}
-export interface LookerRuntimeClient {
-    listDashboards(): Promise<LookerEntityRef[]>;
-    getDashboard(id: string): Promise<StagedDashboardFile>;
-    listLooks(): Promise<LookerEntityRef[]>;
-    getLook(id: string): Promise<StagedLookFile>;
-    listFolders(): Promise<StagedFoldersTreeFile>;
-    listUsers(): Promise<StagedUserFile[]>;
-    listGroups(): Promise<StagedGroupFile[]>;
-    listLookmlModels(): Promise<StagedLookmlModelsFile>;
-    getExplore(modelName: string, exploreName: string): Promise<StagedExploreFile>;
-    getSignals?(): Promise<StagedLookerSignalsFile>;
-    cleanup?(): Promise<void>;
-}
-export interface LookerClientFactory {
-    createClient(config: LookerPullConfig, ctx: FetchContext): Promise<LookerRuntimeClient> | LookerRuntimeClient;
-}
-interface FetchLookerRuntimeBundleParams {
-    pullConfig: unknown;
-    stagedDir: string;
-    ctx: FetchContext;
-    clientFactory: LookerClientFactory;
-    now?: () => Date;
-}
-export declare function fetchLookerRuntimeBundle(params: FetchLookerRuntimeBundleParams): Promise<void>;
-export {};

package/node_modules/@ktx/context/dist/ingest/adapters/looker/local-looker.adapter.d.ts

@@ -1,11 +0,0 @@
-import type { KtxLocalProject, KtxProjectConnectionConfig } from '../../../project/index.js';
-import type { LookerClientLogger } from './client.js';
-import { type LookerCredentialResolver } from './factory.js';
-import { LookerSourceAdapter } from './looker.adapter.js';
-export declare function lookerCredentialsFromLocalConnection(connectionId: string, connection: KtxProjectConnectionConfig | undefined, env?: NodeJS.ProcessEnv): {
-    base_url: string;
-    client_id: string;
-    client_secret: string;
-};
-export declare function createLocalLookerCredentialResolver(project: KtxLocalProject, env?: NodeJS.ProcessEnv): LookerCredentialResolver;
-export declare function createLocalLookerSourceAdapter(project: KtxLocalProject, env?: NodeJS.ProcessEnv, logger?: LookerClientLogger): LookerSourceAdapter;

package/node_modules/@ktx/context/dist/ingest/adapters/looker/local-looker.adapter.js

@@ -1,45 +0,0 @@
-import { DefaultLookerClientFactory, DefaultLookerConnectionClientFactory, } from './factory.js';
-import { LookerSourceAdapter } from './looker.adapter.js';
-function stringField(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}
-function resolveEnvReference(ref, env) {
-    if (!ref.startsWith('env:')) {
-        return null;
-    }
-    return stringField(env[ref.slice('env:'.length)]);
-}
-export function lookerCredentialsFromLocalConnection(connectionId, connection, env = process.env) {
-    if (!connection || String(connection.driver).toLowerCase() !== 'looker') {
-        throw new Error(`Connection "${connectionId}" is not a Looker connection`);
-    }
-    const baseUrl = stringField(connection.base_url);
-    const clientId = stringField(connection.client_id);
-    const clientSecret = stringField(connection.client_secret) ??
-        (stringField(connection.client_secret_ref) ? resolveEnvReference(String(connection.client_secret_ref), env) : null);
-    if (!baseUrl) {
-        throw new Error(`Connection "${connectionId}" is missing Looker base_url`);
-    }
-    if (!clientId) {
-        throw new Error(`Connection "${connectionId}" is missing Looker client_id`);
-    }
-    if (!clientSecret) {
-        throw new Error(`Connection "${connectionId}" is missing Looker client_secret or client_secret_ref`);
-    }
-    return { base_url: baseUrl, client_id: clientId, client_secret: clientSecret };
-}
-export function createLocalLookerCredentialResolver(project, env = process.env) {
-    return {
-        async resolve(lookerConnectionId) {
-            return lookerCredentialsFromLocalConnection(lookerConnectionId, project.config.connections[lookerConnectionId], env);
-        },
-    };
-}
-export function createLocalLookerSourceAdapter(project, env = process.env, logger) {
-    const connectionFactory = new DefaultLookerConnectionClientFactory(createLocalLookerCredentialResolver(project, env), {
-        ...(logger ? { logger } : {}),
-    });
-    return new LookerSourceAdapter({
-        clientFactory: new DefaultLookerClientFactory(connectionFactory),
-    });
-}

package/node_modules/@ktx/context/dist/ingest/adapters/looker/local-runtime-store.d.ts

@@ -1,50 +0,0 @@
-import type { LookerWarehouseConnectionInfo } from './client.js';
-import type { LookerConnectionMapping } from './mapping.js';
-import type { LookerRuntimeCursors } from './types.js';
-export type LocalLookerMappingSource = 'ktx.yaml' | 'cli' | 'refresh';
-interface LocalLookerRuntimeStoreOptions {
-    dbPath: string;
-    now?: () => Date;
-}
-export interface LocalLookerConnectionMappingListRow extends LookerConnectionMapping {
-    source: LocalLookerMappingSource;
-}
-export interface UpsertLocalLookerConnectionMappingInput {
-    lookerConnectionId: string;
-    lookerConnectionName: string;
-    ktxConnectionId: string | null;
-    source: LocalLookerMappingSource;
-}
-interface ApplyLocalLookerYamlBootstrapInput {
-    lookerConnectionId: string;
-    mappings: Array<{
-        lookerConnectionName: string;
-        ktxConnectionId: string | null;
-    }>;
-}
-export interface RefreshLocalLookerDiscoveredConnectionsInput {
-    lookerConnectionId: string;
-    discovered: LookerWarehouseConnectionInfo[];
-}
-export interface ClearLocalLookerMappingsInput {
-    lookerConnectionId: string;
-    lookerConnectionName?: string;
-}
-export interface LookerSourceStateReader {
-    readMappings(lookerConnectionId: string): Promise<LookerConnectionMapping[]>;
-    readCursors(lookerConnectionId: string): Promise<LookerRuntimeCursors>;
-}
-export declare class LocalLookerRuntimeStore implements LookerSourceStateReader {
-    private readonly db;
-    private readonly now;
-    constructor(options: LocalLookerRuntimeStoreOptions);
-    applyYamlBootstrap(input: ApplyLocalLookerYamlBootstrapInput): Promise<void>;
-    readCursors(lookerConnectionId: string): Promise<LookerRuntimeCursors>;
-    setCursors(lookerConnectionId: string, cursors: LookerRuntimeCursors): Promise<void>;
-    readMappings(lookerConnectionId: string): Promise<LookerConnectionMapping[]>;
-    listConnectionMappings(lookerConnectionId: string): Promise<LocalLookerConnectionMappingListRow[]>;
-    upsertConnectionMapping(input: UpsertLocalLookerConnectionMappingInput): Promise<void>;
-    refreshDiscoveredConnections(input: RefreshLocalLookerDiscoveredConnectionsInput): Promise<void>;
-    clearConnectionMappings(input: ClearLocalLookerMappingsInput): Promise<void>;
-}
-export {};