@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/ingest/adapters/metabase/serialize-card.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { extractReferencedCardIds, serializeCard } from './serialize-card.js';
-describe('extractReferencedCardIds', () => {
-    it('pulls ids out of template tags with type=card', () => {
-        const tags = [
-            { name: 'orders', type: 'card', cardReference: 42 },
-            { name: 'param', type: 'text' },
-        ];
-        expect(extractReferencedCardIds(tags, '')).toEqual([42]);
-    });
-    it('finds `{{#N}}` references in the SQL body even when the tag list lacks cardReference', () => {
-        const tags = [{ name: 'orders_ref', type: 'card' }];
-        const sql = 'SELECT * FROM ({{#42}}) UNION ALL (SELECT * FROM {{#101}})';
-        expect(extractReferencedCardIds(tags, sql).sort((a, b) => a - b)).toEqual([42, 101]);
-    });
-    it('dedupes card ids across tags and SQL body', () => {
-        const tags = [{ name: 'a', type: 'card', cardReference: 42 }];
-        const sql = 'SELECT * FROM {{#42}}';
-        expect(extractReferencedCardIds(tags, sql)).toEqual([42]);
-    });
-    it('returns [] when no references exist', () => {
-        expect(extractReferencedCardIds([], 'SELECT 1')).toEqual([]);
-    });
-});
-describe('serializeCard', () => {
-    const baseCard = {
-        id: 7,
-        name: 'Daily orders',
-        description: 'Orders by day',
-        type: 'model',
-        database_id: 42,
-        collection_id: 5,
-        archived: false,
-        result_metadata: [
-            {
-                name: 'order_count',
-                display_name: 'Count',
-                base_type: 'type/Integer',
-                semantic_type: null,
-                description: null,
-                fk_target_field_id: null,
-            },
-        ],
-    };
-    it('returns a valid StagedCardFile with resolved SQL and template tags', () => {
-        const staged = serializeCard({
-            card: baseCard,
-            resolvedSql: 'SELECT COUNT(*) AS order_count FROM orders',
-            templateTags: [],
-            collectionPath: ['Data', 'Orders'],
-            resolutionStatus: 'resolved',
-        });
-        expect(staged.metabaseId).toBe(7);
-        expect(staged.name).toBe('Daily orders');
-        expect(staged.collectionPath).toEqual(['Data', 'Orders']);
-        expect(staged.resolvedSql).toBe('SELECT COUNT(*) AS order_count FROM orders');
-        expect(staged.referencedCardIds).toEqual([]);
-        expect(staged.resultMetadata).toHaveLength(1);
-        expect(staged.resultMetadata[0].name).toBe('order_count');
-    });
-    it('persists resolutionStatus="resolved" when caller passes it', () => {
-        const staged = serializeCard({
-            card: baseCard,
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(staged.resolutionStatus).toBe('resolved');
-    });
-    it('persists resolutionStatus="fallback" when caller passes it', () => {
-        const staged = serializeCard({
-            card: baseCard,
-            resolvedSql: 'SELECT * FROM {{#101}}',
-            templateTags: [{ name: 'ref', type: 'card', cardReference: 101 }],
-            collectionPath: [],
-            resolutionStatus: 'fallback',
-        });
-        expect(staged.resolutionStatus).toBe('fallback');
-    });
-    it('extracts referencedCardIds from template tags + SQL body', () => {
-        const staged = serializeCard({
-            card: baseCard,
-            resolvedSql: 'SELECT * FROM {{#101}}',
-            templateTags: [{ name: 'ref', type: 'card', cardReference: 101 }],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(staged.referencedCardIds).toEqual([101]);
-    });
-    it('null description passes through as null, not empty string', () => {
-        const staged = serializeCard({
-            card: { ...baseCard, description: null },
-            resolvedSql: '',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(staged.description).toBeNull();
-    });
-    it('collectionId=`root` stays as the string literal "root"', () => {
-        const staged = serializeCard({
-            card: { ...baseCard, collection_id: 'root' },
-            resolvedSql: '',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(staged.collectionId).toBe('root');
-    });
-    it('persists parameters[] from the input card', () => {
-        const out = serializeCard({
-            card: {
-                id: 1,
-                name: 'X',
-                description: null,
-                type: 'question',
-                database_id: 6,
-                collection_id: null,
-                archived: false,
-                result_metadata: [],
-                parameters: [
-                    { id: 'p1', name: 'auction_end', type: 'date/range', slug: 'auction_end', default: null, sectionId: 'date' },
-                    { id: 'p2', name: 'status', type: 'category', slug: 'status', default: 'active', sectionId: 'string' },
-                ],
-            },
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(out.parameters).toHaveLength(2);
-        expect(out.parameters?.[0]).toMatchObject({ id: 'p1', name: 'auction_end', type: 'date/range' });
-    });
-    it('persists field_ref on each result-metadata column', () => {
-        const out = serializeCard({
-            card: {
-                id: 1,
-                name: 'X',
-                description: null,
-                type: 'question',
-                database_id: 6,
-                collection_id: null,
-                archived: false,
-                result_metadata: [
-                    {
-                        name: 'customer_id',
-                        base_type: 'type/Integer',
-                        semantic_type: 'type/FK',
-                        fk_target_field_id: 42,
-                        field_ref: ['field', 99, null],
-                    },
-                ],
-            },
-            resolvedSql: 'SELECT customer_id FROM x',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(out.resultMetadata[0].field_ref).toEqual(['field', 99, null]);
-    });
-    it('persists lastRunAt and dashboardCount when present on the card', () => {
-        const out = serializeCard({
-            card: {
-                id: 1,
-                name: 'X',
-                description: null,
-                type: 'question',
-                database_id: 6,
-                collection_id: null,
-                archived: false,
-                result_metadata: [],
-                last_run_at: '2026-04-27T10:00:00Z',
-                dashboard_count: 3,
-            },
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(out.lastRunAt).toBe('2026-04-27T10:00:00Z');
-        expect(out.dashboardCount).toBe(3);
-    });
-    it('omits the new fields gracefully when the card lacks them', () => {
-        const out = serializeCard({
-            card: {
-                id: 1,
-                name: 'X',
-                description: null,
-                type: 'question',
-                database_id: 6,
-                collection_id: null,
-                archived: false,
-                result_metadata: [],
-            },
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            collectionPath: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(out.parameters).toEqual([]);
-        expect(out.lastRunAt).toBeNull();
-        expect(out.dashboardCount).toBeNull();
-    });
-});

package/dist/context/ingest/adapters/metabase/types.test.d.ts

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

package/dist/context/ingest/adapters/metabase/types.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { metabasePullConfigSchema, parseMetabasePullConfig, stagedCardFileSchema, stagedSyncConfigSchema, } from './types.js';
-describe('metabase adapter types', () => {
-    it('parses a valid MetabasePullConfig', () => {
-        const parsed = parseMetabasePullConfig({
-            metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-            metabaseDatabaseId: 42,
-        });
-        expect(parsed.metabaseConnectionId).toBe('a1b2c3d4-e5f6-4789-9abc-def012345678');
-        expect(parsed.metabaseDatabaseId).toBe(42);
-    });
-    it('parses local-safe Metabase connection IDs for standalone projects', () => {
-        const parsed = parseMetabasePullConfig({ metabaseConnectionId: 'prod-metabase', metabaseDatabaseId: 42 });
-        expect(parsed.metabaseConnectionId).toBe('prod-metabase');
-    });
-    it('rejects unsafe metabaseConnectionId values', () => {
-        expect(() => parseMetabasePullConfig({ metabaseConnectionId: '../prod', metabaseDatabaseId: 42 })).toThrow();
-    });
-    it('rejects missing metabaseDatabaseId', () => {
-        const parsed = metabasePullConfigSchema.safeParse({ metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678' });
-        expect(parsed.success).toBe(false);
-    });
-    it('stagedCardFileSchema accepts a minimal card', () => {
-        const parsed = stagedCardFileSchema.parse({
-            metabaseId: 1,
-            name: 'Orders',
-            description: null,
-            type: 'model',
-            databaseId: 42,
-            collectionId: 5,
-            archived: false,
-            resolvedSql: 'SELECT * FROM orders',
-            templateTags: [],
-            resultMetadata: [],
-            collectionPath: ['Data', 'Orders'],
-            referencedCardIds: [],
-            resolutionStatus: 'resolved',
-        });
-        expect(parsed.metabaseId).toBe(1);
-        expect(parsed.collectionPath).toEqual(['Data', 'Orders']);
-    });
-    it('stagedSyncConfigSchema accepts selections + mappings snapshot', () => {
-        const parsed = stagedSyncConfigSchema.parse({
-            metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-            metabaseDatabaseId: 42,
-            syncMode: 'ALL',
-            selections: [],
-            defaultTagNames: [],
-            mapping: {
-                metabaseDatabaseId: 42,
-                metabaseDatabaseName: 'Analytics',
-                metabaseEngine: 'postgres',
-                targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-            },
-        });
-        expect(parsed.syncMode).toBe('ALL');
-    });
-    it('stagedSyncConfigSchema accepts local-safe connection IDs', () => {
-        const parsed = stagedSyncConfigSchema.parse({
-            metabaseConnectionId: 'prod-metabase',
-            metabaseDatabaseId: 42,
-            syncMode: 'ALL',
-            selections: [],
-            defaultTagNames: [],
-            mapping: {
-                metabaseDatabaseId: 42,
-                metabaseDatabaseName: 'Analytics',
-                metabaseEngine: 'postgres',
-                targetConnectionId: 'warehouse_a',
-            },
-        });
-        expect(parsed.metabaseConnectionId).toBe('prod-metabase');
-        expect(parsed.mapping.targetConnectionId).toBe('warehouse_a');
-    });
-});

package/dist/context/ingest/adapters/metricflow/chunk.test.d.ts

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

package/dist/context/ingest/adapters/metricflow/chunk.test.js

@@ -1,114 +0,0 @@
-import { join, resolve } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { chunkMetricFlowProject } from './chunk.js';
-import { parseMetricFlowStagedDir } from './parse.js';
-const FIXTURES = resolve(__dirname, '../../../../test/fixtures/metricflow');
-const SINGLE = join(FIXTURES, 'single-model');
-const EXTENDS_CHAIN = join(FIXTURES, 'extends-chain');
-const MULTI = join(FIXTURES, 'multi-component');
-const DBT_MIXED = join(FIXTURES, 'dbt-mixed');
-describe('chunkMetricFlowProject — first run', () => {
-    it('single-model fixture emits one WU with the orders model + its metric file (collapsed via metric refs)', async () => {
-        const project = await parseMetricFlowStagedDir(SINGLE);
-        const result = chunkMetricFlowProject(project);
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('metricflow-orders');
-        expect(wu.rawFiles).toEqual(['models/orders.yml']);
-        expect(wu.dependencyPaths).toEqual([]);
-        expect(wu.peerFileIndex).toEqual([]);
-    });
-    it('extends-chain fixture collapses orders + orders_ext + metrics/orders_final into ONE WU', async () => {
-        const project = await parseMetricFlowStagedDir(EXTENDS_CHAIN);
-        const result = chunkMetricFlowProject(project);
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('metricflow-orders');
-        expect(wu.rawFiles.sort()).toEqual(['metrics/orders_final.yml', 'models/orders.yml', 'models/orders_ext.yml']);
-        expect(wu.notes).toContain('orders');
-        expect(wu.notes).toContain('orders_ext');
-        expect(wu.notes).toContain('revenue');
-    });
-    it('multi-component fixture emits two disjoint WUs ordered by leadName', async () => {
-        const project = await parseMetricFlowStagedDir(MULTI);
-        const result = chunkMetricFlowProject(project);
-        expect(result.workUnits).toHaveLength(2);
-        expect(result.workUnits.map((wu) => wu.unitKey)).toEqual(['metricflow-campaigns', 'metricflow-orders']);
-        expect(result.workUnits[0].rawFiles).toEqual(['models/marketing/campaigns.yml']);
-        expect(result.workUnits[0].peerFileIndex).toEqual(['models/sales/orders.yml']);
-        expect(result.workUnits[1].rawFiles).toEqual(['models/sales/orders.yml']);
-        expect(result.workUnits[1].peerFileIndex).toEqual(['models/marketing/campaigns.yml']);
-    });
-    it('dbt-mixed fixture: non-MetricFlow YAML (dbt_project.yml) lands in peerFileIndex, not in any WU', async () => {
-        const project = await parseMetricFlowStagedDir(DBT_MIXED);
-        const result = chunkMetricFlowProject(project);
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].rawFiles).toEqual(['models/orders.yml']);
-        expect(result.workUnits[0].peerFileIndex).toEqual(['dbt_project.yml']);
-    });
-    it('chunk is deterministic: two identical invocations return structurally-equal WUs', async () => {
-        const p1 = await parseMetricFlowStagedDir(EXTENDS_CHAIN);
-        const p2 = await parseMetricFlowStagedDir(EXTENDS_CHAIN);
-        const r1 = chunkMetricFlowProject(p1);
-        const r2 = chunkMetricFlowProject(p2);
-        expect(JSON.stringify(r1)).toBe(JSON.stringify(r2));
-    });
-    it('DiffSet re-sync: only WUs with a touched rawFile are kept', async () => {
-        const project = await parseMetricFlowStagedDir(MULTI);
-        const result = chunkMetricFlowProject(project, {
-            diffSet: {
-                added: [],
-                modified: ['models/sales/orders.yml'],
-                deleted: [],
-                unchanged: ['models/marketing/campaigns.yml'],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].unitKey).toBe('metricflow-orders');
-        expect(result.workUnits[0].rawFiles).toEqual(['models/sales/orders.yml']);
-        expect(result.workUnits[0].dependencyPaths).toEqual([]); // no unchanged sibling in this component
-    });
-    it('DiffSet re-sync: unchanged component siblings move from rawFiles into dependencyPaths', async () => {
-        const project = await parseMetricFlowStagedDir(EXTENDS_CHAIN);
-        const result = chunkMetricFlowProject(project, {
-            diffSet: {
-                added: [],
-                modified: ['models/orders_ext.yml'], // only the extension file changed
-                deleted: [],
-                unchanged: ['models/orders.yml', 'metrics/orders_final.yml'],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.rawFiles).toEqual(['models/orders_ext.yml']);
-        expect(wu.dependencyPaths.sort()).toEqual(['metrics/orders_final.yml', 'models/orders.yml']);
-    });
-    it('DiffSet re-sync: all-unchanged yields zero WUs', async () => {
-        const project = await parseMetricFlowStagedDir(EXTENDS_CHAIN);
-        const result = chunkMetricFlowProject(project, {
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: [],
-                unchanged: ['models/orders.yml', 'models/orders_ext.yml', 'metrics/orders_final.yml'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toBeUndefined();
-    });
-    it('DiffSet re-sync: deleted files produce an EvictionUnit', async () => {
-        const project = await parseMetricFlowStagedDir(MULTI);
-        const result = chunkMetricFlowProject(project, {
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: ['models/marketing/campaigns.yml'],
-                unchanged: ['models/sales/orders.yml'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toEqual({
-            deletedRawPaths: ['models/marketing/campaigns.yml'],
-        });
-    });
-});

package/dist/context/ingest/adapters/metricflow/deep-parse.test.d.ts

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