@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/scan/relationship-validation.test.d.ts

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

package/node_modules/@ktx/context/dist/scan/relationship-validation.test.js

@@ -0,0 +1,450 @@
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+import { generateKtxRelationshipDiscoveryCandidates } from './relationship-candidates.js';
+import { profileKtxRelationshipSchema } from './relationship-profiling.js';
+import { validateKtxRelationshipDiscoveryCandidates } from './relationship-validation.js';
+class InMemorySqliteExecutor {
+    db = new Database(':memory:');
+    queryCount = 0;
+    executeReadOnly(input, _ctx) {
+        this.queryCount += 1;
+        const rows = this.db.prepare(input.sql).all();
+        const headers = Object.keys(rows[0] ?? {});
+        return Promise.resolve({
+            headers,
+            rows: rows.map((row) => headers.map((header) => row[header])),
+            totalRows: rows.length,
+            rowCount: rows.length,
+        });
+    }
+    close() {
+        this.db.close();
+    }
+}
+function column(tableId, name, overrides = {}) {
+    const tableRef = overrides.tableRef ?? { catalog: null, db: null, name: tableId };
+    return {
+        id: `${tableId}.${name}`,
+        tableId,
+        tableRef,
+        name,
+        nativeType: overrides.nativeType ?? 'INTEGER',
+        normalizedType: overrides.normalizedType ?? 'integer',
+        dimensionType: overrides.dimensionType ?? 'number',
+        nullable: overrides.nullable ?? true,
+        primaryKey: overrides.primaryKey ?? false,
+        parentColumnId: null,
+        descriptions: {},
+        embedding: null,
+        sampleValues: null,
+        cardinality: null,
+        ...overrides,
+    };
+}
+function table(name, columns) {
+    const ref = { catalog: null, db: null, name };
+    return {
+        id: name,
+        ref,
+        enabled: true,
+        descriptions: {},
+        columns: columns.map((item) => ({ ...item, tableId: name, tableRef: ref })),
+    };
+}
+function schema(tables) {
+    return {
+        connectionId: 'warehouse',
+        tables: tables ?? [
+            table('accounts', [
+                column('accounts', 'id', { nullable: false }),
+                column('accounts', 'name', { nativeType: 'TEXT', normalizedType: 'text', dimensionType: 'string' }),
+            ]),
+            table('users', [column('users', 'id', { nullable: false }), column('users', 'account_id', { nullable: false })]),
+            table('invoices', [
+                column('invoices', 'id', { nullable: false }),
+                column('invoices', 'account_id', { nullable: false }),
+            ]),
+        ],
+        relationships: [],
+    };
+}
+describe('relationship validation', () => {
+    let executor = null;
+    afterEach(() => {
+        executor?.close();
+        executor = null;
+    });
+    it('accepts a relationship-discovery candidate with unique parent values and full source coverage', async () => {
+        executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE accounts (id INTEGER, name TEXT);
+      CREATE TABLE users (id INTEGER, account_id INTEGER);
+      CREATE TABLE invoices (id INTEGER, account_id INTEGER);
+      INSERT INTO accounts (id, name) VALUES (1, 'Acme'), (2, 'Globex'), (3, 'Initech');
+      INSERT INTO users (id, account_id) VALUES (10, 1), (11, 2), (12, 3);
+      INSERT INTO invoices (id, account_id) VALUES (20, 1), (21, 2), (22, 999);
+    `);
+        const testSchema = schema();
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'validate-test' },
+        });
+        const candidates = generateKtxRelationshipDiscoveryCandidates(testSchema).filter((candidate) => candidate.from.table.name === 'users');
+        const validated = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates,
+            profiles,
+            executor,
+            ctx: { runId: 'validate-test' },
+        });
+        expect(validated).toHaveLength(1);
+        expect(validated[0]).toMatchObject({
+            from: { table: { name: 'users' }, columns: ['account_id'] },
+            to: { table: { name: 'accounts' }, columns: ['id'] },
+            status: 'accepted',
+            score: expect.any(Number),
+            validation: {
+                targetUniqueness: 1,
+                sourceCoverage: 1,
+                violationCount: 0,
+                violationRatio: 0,
+                reasons: expect.arrayContaining(['validation_passed']),
+            },
+        });
+        expect(validated[0]?.score).toBeGreaterThanOrEqual(0.85);
+    });
+    it('rejects a candidate with missing parent values and records the deterministic reason', async () => {
+        executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE accounts (id INTEGER, name TEXT);
+      CREATE TABLE users (id INTEGER, account_id INTEGER);
+      CREATE TABLE invoices (id INTEGER, account_id INTEGER);
+      INSERT INTO accounts (id, name) VALUES (1, 'Acme'), (2, 'Globex');
+      INSERT INTO users (id, account_id) VALUES (10, 1), (11, 2);
+      INSERT INTO invoices (id, account_id) VALUES (20, 1), (21, 999), (22, 1000);
+    `);
+        const testSchema = schema();
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'validate-test' },
+        });
+        const candidates = generateKtxRelationshipDiscoveryCandidates(testSchema).filter((candidate) => candidate.from.table.name === 'invoices');
+        const validated = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates,
+            profiles,
+            executor,
+            ctx: { runId: 'validate-test' },
+            settings: {
+                minSourceCoverage: 0.9,
+                maxViolationRatio: 0.01,
+            },
+        });
+        expect(validated).toHaveLength(1);
+        expect(validated[0]).toMatchObject({
+            from: { table: { name: 'invoices' }, columns: ['account_id'] },
+            to: { table: { name: 'accounts' }, columns: ['id'] },
+            status: 'rejected',
+            validation: {
+                sourceCoverage: 1 / 3,
+                violationCount: 2,
+                violationRatio: 2 / 3,
+                reasons: expect.arrayContaining(['low_source_coverage', 'excessive_violations']),
+            },
+        });
+    });
+    it('keeps over-budget candidates review-only without executing coverage SQL for them', async () => {
+        executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE accounts (id INTEGER, name TEXT);
+      CREATE TABLE users (id INTEGER, account_id INTEGER);
+      CREATE TABLE invoices (id INTEGER, account_id INTEGER);
+      INSERT INTO accounts (id, name) VALUES (1, 'Acme'), (2, 'Globex'), (3, 'Initech');
+      INSERT INTO users (id, account_id) VALUES (10, 1), (11, 2), (12, 3);
+      INSERT INTO invoices (id, account_id) VALUES (20, 1), (21, 2), (22, 3);
+    `);
+        const testSchema = schema();
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'validate-budget-profile' },
+        });
+        executor.queryCount = 0;
+        const candidates = generateKtxRelationshipDiscoveryCandidates(testSchema).map((candidate) => ({
+            ...candidate,
+            confidence: candidate.from.table.name === 'users' ? 0.99 : 0.5,
+        }));
+        const validated = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates,
+            profiles,
+            executor,
+            ctx: { runId: 'validate-budget' },
+            tableCount: testSchema.tables.length,
+            settings: {
+                validationBudget: 1,
+            },
+        });
+        expect(executor.queryCount).toBe(1);
+        expect(validated).toHaveLength(2);
+        expect(validated.find((candidate) => candidate.from.table.name === 'users')).toMatchObject({
+            status: 'accepted',
+            validation: { reasons: expect.arrayContaining(['validation_passed']) },
+        });
+        expect(validated.find((candidate) => candidate.from.table.name === 'invoices')).toMatchObject({
+            status: 'review',
+            validation: {
+                reasons: ['validation_unattempted'],
+            },
+        });
+    });
+    it('treats validation budget zero as review-only validation without coverage SQL', async () => {
+        executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE accounts (id INTEGER, name TEXT);
+      CREATE TABLE users (id INTEGER, account_id INTEGER);
+      INSERT INTO accounts (id, name) VALUES (1, 'Acme'), (2, 'Globex');
+      INSERT INTO users (id, account_id) VALUES (10, 1), (11, 2);
+    `);
+        const testSchema = schema([
+            table('accounts', [
+                column('accounts', 'id', { nullable: false }),
+                column('accounts', 'name', { nativeType: 'TEXT', normalizedType: 'text', dimensionType: 'string' }),
+            ]),
+            table('users', [column('users', 'id', { nullable: false }), column('users', 'account_id', { nullable: false })]),
+        ]);
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'validate-zero-budget-profile' },
+        });
+        executor.queryCount = 0;
+        const candidates = generateKtxRelationshipDiscoveryCandidates(testSchema);
+        const validated = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates,
+            profiles,
+            executor,
+            ctx: { runId: 'validate-zero-budget' },
+            tableCount: testSchema.tables.length,
+            settings: {
+                validationBudget: 0,
+            },
+        });
+        expect(executor.queryCount).toBe(0);
+        expect(validated).toHaveLength(1);
+        expect(validated[0]).toMatchObject({
+            status: 'review',
+            score: expect.any(Number),
+            validation: {
+                checkedValues: 0,
+                reasons: ['validation_unattempted'],
+            },
+        });
+    });
+    it('marks rejected LLM proposals with the spec rejection reason', async () => {
+        executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE customers (id INTEGER);
+      CREATE TABLE orders (buyer_ref INTEGER);
+      INSERT INTO customers (id) VALUES (1), (2);
+      INSERT INTO orders (buyer_ref) VALUES (98), (99);
+    `);
+        const testSchema = schema([
+            table('customers', [column('customers', 'id', { nullable: false })]),
+            table('orders', [column('orders', 'buyer_ref')]),
+        ]);
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'llm-rejected-validation' },
+        });
+        const [candidate] = generateKtxRelationshipDiscoveryCandidates(schema([
+            table('customers', [column('customers', 'id', { nullable: false })]),
+            table('orders', [column('orders', 'customer_id')]),
+        ]));
+        if (!candidate) {
+            throw new Error('Expected base candidate');
+        }
+        const llmCandidate = {
+            ...candidate,
+            id: 'orders:(orders.buyer_ref)->customers:(customers.id)',
+            from: { ...candidate.from, columnIds: ['orders.buyer_ref'], columns: ['buyer_ref'] },
+            source: 'llm_proposal',
+            evidence: {
+                ...candidate.evidence,
+                reasons: ['llm_proposal'],
+                llmConfidence: 0.84,
+                llmRationale: 'Buyer references should map to customers.',
+            },
+        };
+        const [validated] = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates: [llmCandidate],
+            profiles,
+            executor,
+            ctx: { runId: 'llm-rejected-validation' },
+        });
+        expect(validated?.status).toBe('rejected');
+        expect(validated?.validation.reasons).toEqual(expect.arrayContaining(['low_source_coverage', 'llm_proposed_but_validation_failed']));
+    });
+    it('limits validation query concurrency', async () => {
+        const executor = new InMemorySqliteExecutor();
+        executor.db.exec(`
+      CREATE TABLE accounts (id INTEGER NOT NULL);
+      CREATE TABLE orders (id INTEGER NOT NULL, account_id INTEGER NOT NULL);
+      CREATE TABLE invoices (id INTEGER NOT NULL, account_id INTEGER NOT NULL);
+      INSERT INTO accounts VALUES (1), (2);
+      INSERT INTO orders VALUES (10, 1), (11, 2);
+      INSERT INTO invoices VALUES (20, 1), (21, 2);
+    `);
+        let active = 0;
+        let maxActive = 0;
+        const throttled = {
+            executeReadOnly: async (input, ctx) => {
+                active += 1;
+                maxActive = Math.max(maxActive, active);
+                await new Promise((resolve) => setTimeout(resolve, input.sql.includes('WITH child_values') ? 10 : 0));
+                const result = await executor.executeReadOnly(input, ctx);
+                active -= 1;
+                return result;
+            },
+        };
+        const testSchema = schema([
+            table('accounts', [column('accounts', 'id', { nullable: false })]),
+            table('orders', [column('orders', 'id', { nullable: false }), column('orders', 'account_id')]),
+            table('invoices', [column('invoices', 'id', { nullable: false }), column('invoices', 'account_id')]),
+        ]);
+        const profiles = await profileKtxRelationshipSchema({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            schema: testSchema,
+            executor,
+            ctx: { runId: 'validation-concurrency-profile' },
+        });
+        const candidates = generateKtxRelationshipDiscoveryCandidates(testSchema);
+        await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates,
+            profiles,
+            executor: throttled,
+            ctx: { runId: 'validation-concurrency' },
+            settings: { concurrency: 1 },
+        });
+        expect(maxActive).toBe(1);
+        executor.close();
+    });
+    it('pins column_suffix_match validation scoring for plan-code suffix candidates', async () => {
+        const candidate = {
+            id: 'mart:(current_plan_code)->plans:(plan_code)',
+            from: {
+                tableId: 'mart-account-segments-id',
+                columnIds: ['current-plan-code-col'],
+                table: { catalog: null, db: null, name: 'mart_account_segments' },
+                columns: ['current_plan_code'],
+            },
+            to: {
+                tableId: 'plans-id',
+                columnIds: ['plan-code-col'],
+                table: { catalog: null, db: null, name: 'stg_plans' },
+                columns: ['plan_code'],
+            },
+            relationshipType: 'many_to_one',
+            confidence: 0.902,
+            source: 'column_suffix_match',
+            status: 'review',
+            evidence: {
+                sourceColumnBase: 'current_plan',
+                targetTableBase: 'plan',
+                targetColumnBase: 'plan_code',
+                targetKeyScore: 0.86,
+                nameScore: 0.78,
+                reasons: ['column_suffix_match', 'profile_unique_target'],
+            },
+        };
+        const profiles = {
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            sqlAvailable: true,
+            queryCount: 0,
+            tables: [],
+            warnings: [],
+            columns: {
+                'mart_account_segments.current_plan_code': {
+                    table: { catalog: null, db: null, name: 'mart_account_segments' },
+                    column: 'current_plan_code',
+                    nativeType: 'TEXT',
+                    normalizedType: 'text',
+                    rowCount: 4,
+                    nullCount: 0,
+                    distinctCount: 4,
+                    uniquenessRatio: 1,
+                    nullRate: 0,
+                    sampleValues: ['basic', 'enterprise', 'free', 'pro'],
+                    minTextLength: 4,
+                    maxTextLength: 10,
+                },
+                'stg_plans.plan_code': {
+                    table: { catalog: null, db: null, name: 'stg_plans' },
+                    column: 'plan_code',
+                    nativeType: 'TEXT',
+                    normalizedType: 'text',
+                    rowCount: 4,
+                    nullCount: 0,
+                    distinctCount: 4,
+                    uniquenessRatio: 1,
+                    nullRate: 0,
+                    sampleValues: ['basic', 'enterprise', 'free', 'pro'],
+                    minTextLength: 4,
+                    maxTextLength: 10,
+                },
+            },
+        };
+        const executor = {
+            async executeReadOnly() {
+                return {
+                    headers: ['child_distinct', 'parent_distinct', 'overlap', 'violation_count'],
+                    rows: [[4, 4, 4, 0]],
+                    rowCount: 1,
+                    totalRows: 1,
+                };
+            },
+        };
+        const [validated] = await validateKtxRelationshipDiscoveryCandidates({
+            connectionId: 'warehouse',
+            driver: 'sqlite',
+            candidates: [candidate],
+            profiles,
+            executor,
+            ctx: { runId: 'rule-b-validation-score' },
+        });
+        expect(validated).toMatchObject({
+            status: 'accepted',
+            score: 0.98,
+            validation: {
+                targetUniqueness: 1,
+                sourceCoverage: 1,
+                violationRatio: 0,
+                reasons: ['validation_passed'],
+            },
+        });
+    });
+});

package/node_modules/@ktx/context/dist/scan/sqlite-local-enrichment-state-store.d.ts

@@ -0,0 +1,12 @@
+import type { KtxScanEnrichmentCompletedStage, KtxScanEnrichmentFailedStage, KtxScanEnrichmentStageLookup, KtxScanEnrichmentStageRecord, KtxScanEnrichmentStateStore } from './enrichment-state.js';
+export interface SqliteLocalScanEnrichmentStateStoreOptions {
+    dbPath: string;
+}
+export declare class SqliteLocalScanEnrichmentStateStore implements KtxScanEnrichmentStateStore {
+    private readonly db;
+    constructor(options: SqliteLocalScanEnrichmentStateStoreOptions);
+    findCompletedStage<TOutput = unknown>(input: KtxScanEnrichmentStageLookup): Promise<KtxScanEnrichmentCompletedStage<TOutput> | null>;
+    saveCompletedStage<TOutput = unknown>(input: Omit<KtxScanEnrichmentCompletedStage<TOutput>, 'status' | 'errorMessage'>): Promise<void>;
+    saveFailedStage(input: Omit<KtxScanEnrichmentFailedStage, 'status' | 'output'>): Promise<void>;
+    listRunStages(runId: string): Promise<KtxScanEnrichmentStageRecord[]>;
+}

package/node_modules/@ktx/context/dist/scan/sqlite-local-enrichment-state-store.js

@@ -0,0 +1,190 @@
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import Database from 'better-sqlite3';
+function parseStageRow(row) {
+    if (row.status === 'completed') {
+        return {
+            runId: row.run_id,
+            connectionId: row.connection_id,
+            syncId: row.sync_id,
+            mode: row.mode,
+            stage: row.stage,
+            inputHash: row.input_hash,
+            status: 'completed',
+            output: JSON.parse(row.output_json ?? 'null'),
+            errorMessage: null,
+            updatedAt: row.updated_at,
+        };
+    }
+    return {
+        runId: row.run_id,
+        connectionId: row.connection_id,
+        syncId: row.sync_id,
+        mode: row.mode,
+        stage: row.stage,
+        inputHash: row.input_hash,
+        status: 'failed',
+        output: null,
+        errorMessage: row.error_message ?? 'Unknown enrichment stage failure',
+        updatedAt: row.updated_at,
+    };
+}
+function isSafeRunId(runId) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(runId);
+}
+export class SqliteLocalScanEnrichmentStateStore {
+    db;
+    constructor(options) {
+        mkdirSync(dirname(options.dbPath), { recursive: true });
+        this.db = new Database(options.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS local_scan_enrichment_stages (
+        run_id TEXT NOT NULL,
+        stage TEXT NOT NULL,
+        input_hash TEXT NOT NULL,
+        connection_id TEXT NOT NULL,
+        sync_id TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL,
+        output_json TEXT,
+        error_message TEXT,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (run_id, stage)
+      );
+
+      CREATE INDEX IF NOT EXISTS local_scan_enrichment_stages_run_idx
+        ON local_scan_enrichment_stages (run_id, updated_at, stage);
+    `);
+    }
+    async findCompletedStage(input) {
+        if (!isSafeRunId(input.runId)) {
+            return null;
+        }
+        const row = this.db
+            .prepare(`
+        SELECT *
+        FROM local_scan_enrichment_stages
+        WHERE run_id = ?
+          AND stage = ?
+          AND input_hash = ?
+          AND status = 'completed'
+      `)
+            .get(input.runId, input.stage, input.inputHash);
+        if (!row) {
+            return null;
+        }
+        const parsed = parseStageRow(row);
+        return parsed.status === 'completed' ? parsed : null;
+    }
+    async saveCompletedStage(input) {
+        this.db
+            .prepare(`
+        INSERT INTO local_scan_enrichment_stages (
+          run_id,
+          stage,
+          input_hash,
+          connection_id,
+          sync_id,
+          mode,
+          status,
+          output_json,
+          error_message,
+          updated_at
+        )
+        VALUES (
+          @runId,
+          @stage,
+          @inputHash,
+          @connectionId,
+          @syncId,
+          @mode,
+          'completed',
+          @outputJson,
+          NULL,
+          @updatedAt
+        )
+        ON CONFLICT(run_id, stage) DO UPDATE SET
+          input_hash = excluded.input_hash,
+          connection_id = excluded.connection_id,
+          sync_id = excluded.sync_id,
+          mode = excluded.mode,
+          status = excluded.status,
+          output_json = excluded.output_json,
+          error_message = excluded.error_message,
+          updated_at = excluded.updated_at
+      `)
+            .run({
+            runId: input.runId,
+            stage: input.stage,
+            inputHash: input.inputHash,
+            connectionId: input.connectionId,
+            syncId: input.syncId,
+            mode: input.mode,
+            outputJson: JSON.stringify(input.output),
+            updatedAt: input.updatedAt,
+        });
+    }
+    async saveFailedStage(input) {
+        this.db
+            .prepare(`
+        INSERT INTO local_scan_enrichment_stages (
+          run_id,
+          stage,
+          input_hash,
+          connection_id,
+          sync_id,
+          mode,
+          status,
+          output_json,
+          error_message,
+          updated_at
+        )
+        VALUES (
+          @runId,
+          @stage,
+          @inputHash,
+          @connectionId,
+          @syncId,
+          @mode,
+          'failed',
+          NULL,
+          @errorMessage,
+          @updatedAt
+        )
+        ON CONFLICT(run_id, stage) DO UPDATE SET
+          input_hash = excluded.input_hash,
+          connection_id = excluded.connection_id,
+          sync_id = excluded.sync_id,
+          mode = excluded.mode,
+          status = excluded.status,
+          output_json = excluded.output_json,
+          error_message = excluded.error_message,
+          updated_at = excluded.updated_at
+      `)
+            .run({
+            runId: input.runId,
+            stage: input.stage,
+            inputHash: input.inputHash,
+            connectionId: input.connectionId,
+            syncId: input.syncId,
+            mode: input.mode,
+            errorMessage: input.errorMessage,
+            updatedAt: input.updatedAt,
+        });
+    }
+    async listRunStages(runId) {
+        if (!isSafeRunId(runId)) {
+            return [];
+        }
+        const rows = this.db
+            .prepare(`
+        SELECT *
+        FROM local_scan_enrichment_stages
+        WHERE run_id = ?
+        ORDER BY updated_at ASC, stage ASC
+      `)
+            .all(runId);
+        return rows.map((row) => parseStageRow(row));
+    }
+}

package/node_modules/@ktx/context/dist/scan/type-normalization.d.ts

@@ -0,0 +1,8 @@
+import type { KtxSchemaDimensionType } from './types.js';
+export interface KtxColumnTypeMapping {
+    normalizedType: string;
+    dimensionType: KtxSchemaDimensionType;
+}
+export declare function normalizeKtxNativeType(nativeType: string): string;
+export declare function inferKtxDimensionType(nativeType: string): KtxSchemaDimensionType;
+export declare function ktxColumnTypeMappingFromNative(nativeType: string): KtxColumnTypeMapping;

package/node_modules/@ktx/context/dist/scan/type-normalization.js

@@ -0,0 +1,23 @@
+export function normalizeKtxNativeType(nativeType) {
+    const normalized = nativeType.toLowerCase().replace(/\([^)]*\)/g, '').replace(/\s+/g, ' ').trim();
+    return normalized.length > 0 ? normalized : 'unknown';
+}
+export function inferKtxDimensionType(nativeType) {
+    const normalized = normalizeKtxNativeType(nativeType);
+    if (/\b(bool|boolean)\b/.test(normalized)) {
+        return 'boolean';
+    }
+    if (/\b(date|datetime|time|timestamp)\b/.test(normalized)) {
+        return 'time';
+    }
+    if (/\b(int|integer|bigint|smallint|decimal|numeric|number|float|double|real)\b/.test(normalized)) {
+        return 'number';
+    }
+    return 'string';
+}
+export function ktxColumnTypeMappingFromNative(nativeType) {
+    return {
+        normalizedType: normalizeKtxNativeType(nativeType),
+        dimensionType: inferKtxDimensionType(nativeType),
+    };
+}

package/node_modules/@ktx/context/dist/scan/type-normalization.test.d.ts

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