@kaelio/ktx 0.5.0 → 0.7.0

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

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

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

@@ -1,43 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { detectMetricFlowStagedDir } from './detect.js';
-async function touch(stagedDir, relPath, body = '') {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, body, 'utf-8');
-}
-describe('detectMetricFlowStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'mf-detect-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('returns true when any YAML has top-level semantic_models:', async () => {
-        await touch(stagedDir, 'models/a.yml', 'semantic_models:\n  - {name: a, model: x, measures: []}\n');
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns true when any YAML has top-level metrics:', async () => {
-        await touch(stagedDir, 'metrics/m.yaml', 'metrics:\n  - {name: m, type: simple, type_params: {measure: x}}\n');
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns false for a directory with only dbt_project.yml', async () => {
-        await touch(stagedDir, 'dbt_project.yml', 'name: my_proj\nversion: "1.0.0"\n');
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false for an empty directory', async () => {
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false for only broken YAML', async () => {
-        await touch(stagedDir, 'broken.yml', '{ not: valid :::');
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(false);
-    });
-    it('ignores non-YAML files and returns false when no YAML qualifies', async () => {
-        await touch(stagedDir, 'readme.md', '# readme');
-        await touch(stagedDir, 'script.py', 'print("hi")');
-        expect(await detectMetricFlowStagedDir(stagedDir)).toBe(false);
-    });
-});

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

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

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

@@ -1,97 +0,0 @@
-import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { makeLocalGitRepo } from '../../../test/make-local-git-repo.js';
-import { fetchMetricflowRepo } from './fetch.js';
-async function exists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function makeRepo(tmpRoot, files) {
-    const fixtureDir = join(tmpRoot, 'fixture-src');
-    for (const [path, content] of Object.entries(files)) {
-        const dest = join(fixtureDir, path);
-        await mkdir(join(dest, '..'), { recursive: true });
-        await writeFile(dest, content, 'utf-8');
-    }
-    return makeLocalGitRepo(fixtureDir, join(tmpRoot, 'origin'));
-}
-describe('fetchMetricflowRepo', () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await mkdtemp(join(tmpdir(), 'metricflow-fetch-'));
-    });
-    afterEach(async () => {
-        await rm(tmpRoot, { recursive: true, force: true });
-    });
-    it('clones a dbt repo and stages only YAML files', async () => {
-        const repo = await makeRepo(tmpRoot, {
-            'dbt_project.yml': 'name: analytics\n',
-            'models/orders.yml': 'semantic_models:\n  - name: orders\n    model: ref("orders")\n',
-            'models/readme.md': '# not staged\n',
-            'macros/util.sql': 'select 1\n',
-        });
-        const result = await fetchMetricflowRepo({
-            config: {
-                repoUrl: repo.repoUrl,
-                branch: 'main',
-                path: null,
-                authToken: null,
-                parsedTargetTables: {},
-            },
-            cacheDir: join(tmpRoot, 'cache'),
-            stagedDir: join(tmpRoot, 'stage'),
-        });
-        expect(result.filesCopied).toBe(2);
-        expect(result.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(tmpRoot, 'stage/dbt_project.yml'), 'utf-8')).resolves.toContain('analytics');
-        await expect(readFile(join(tmpRoot, 'stage/models/orders.yml'), 'utf-8')).resolves.toContain('semantic_models');
-        expect(await exists(join(tmpRoot, 'stage/models/readme.md'))).toBe(false);
-        expect(await exists(join(tmpRoot, 'stage/macros/util.sql'))).toBe(false);
-    });
-    it('honors a configured repo subdirectory', async () => {
-        const repo = await makeRepo(tmpRoot, {
-            'warehouse/dbt_project.yml': 'name: warehouse\n',
-            'warehouse/models/orders.yaml': 'semantic_models:\n  - name: orders\n    model: ref("orders")\n',
-            'outside/ignored.yml': 'semantic_models:\n  - name: ignored\n    model: ref("ignored")\n',
-        });
-        const result = await fetchMetricflowRepo({
-            config: {
-                repoUrl: repo.repoUrl,
-                branch: 'main',
-                path: 'warehouse',
-                authToken: null,
-                parsedTargetTables: {},
-            },
-            cacheDir: join(tmpRoot, 'cache'),
-            stagedDir: join(tmpRoot, 'stage'),
-        });
-        expect(result.filesCopied).toBe(2);
-        await expect(readFile(join(tmpRoot, 'stage/models/orders.yaml'), 'utf-8')).resolves.toContain('orders');
-        expect(await exists(join(tmpRoot, 'stage/outside/ignored.yml'))).toBe(false);
-    });
-    it('returns zero files when the configured subdirectory is absent', async () => {
-        const repo = await makeRepo(tmpRoot, {
-            'dbt_project.yml': 'name: analytics\n',
-        });
-        await mkdir(join(tmpRoot, 'stage'), { recursive: true });
-        const result = await fetchMetricflowRepo({
-            config: {
-                repoUrl: repo.repoUrl,
-                branch: 'main',
-                path: 'missing',
-                authToken: null,
-                parsedTargetTables: {},
-            },
-            cacheDir: join(tmpRoot, 'cache'),
-            stagedDir: join(tmpRoot, 'stage'),
-        });
-        expect(result.filesCopied).toBe(0);
-    });
-});

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

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

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

@@ -1,245 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildMetricFlowGraph } from './graph.js';
-function project(parts) {
-    return {
-        semanticModels: parts.semanticModels ?? [],
-        metrics: parts.metrics ?? [],
-        allPaths: parts.allPaths ?? [],
-        files: parts.files ?? [],
-    };
-}
-describe('buildMetricFlowGraph', () => {
-    it('puts each standalone semantic_model in its own component', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'models/a.yml',
-                    name: 'a',
-                    modelRef: 'a',
-                    extendsFrom: [],
-                    measureNames: ['m1'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'models/b.yml',
-                    name: 'b',
-                    modelRef: 'b',
-                    extendsFrom: [],
-                    measureNames: ['m2'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            allPaths: ['models/a.yml', 'models/b.yml'],
-        }));
-        expect(graph.components).toHaveLength(2);
-        const byPath = new Map(graph.components.flatMap((c) => c.paths.map((p) => [p, c.id])));
-        expect(byPath.get('models/a.yml')).not.toBe(byPath.get('models/b.yml'));
-    });
-    it('unions two files when one semantic_model extends another', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'models/orders.yml',
-                    name: 'orders',
-                    modelRef: 'orders',
-                    extendsFrom: [],
-                    measureNames: ['gross_amount'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'models/orders_ext.yml',
-                    name: 'orders_ext',
-                    modelRef: 'orders_ext',
-                    extendsFrom: ['orders'],
-                    measureNames: ['refund_amount'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            allPaths: ['models/orders.yml', 'models/orders_ext.yml'],
-        }));
-        expect(graph.components).toHaveLength(1);
-        expect(graph.components[0].paths.sort()).toEqual(['models/orders.yml', 'models/orders_ext.yml']);
-    });
-    it('unions a metric-only file with the semantic_model files whose measures it references', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'models/orders.yml',
-                    name: 'orders',
-                    modelRef: 'orders',
-                    extendsFrom: [],
-                    measureNames: ['gross_amount'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'models/orders_ext.yml',
-                    name: 'orders_ext',
-                    modelRef: 'orders_ext',
-                    extendsFrom: ['orders'],
-                    measureNames: ['refund_amount'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            metrics: [
-                {
-                    path: 'metrics/orders_final.yml',
-                    name: 'revenue',
-                    type: 'derived',
-                    measureRef: null,
-                    dependsOn: ['gross_amount', 'refund_amount'],
-                },
-            ],
-            allPaths: ['metrics/orders_final.yml', 'models/orders.yml', 'models/orders_ext.yml'],
-        }));
-        expect(graph.components).toHaveLength(1);
-        expect(graph.components[0].paths.sort()).toEqual([
-            'metrics/orders_final.yml',
-            'models/orders.yml',
-            'models/orders_ext.yml',
-        ]);
-    });
-    it('leaves unrelated semantic_models in separate components (two disjoint groups)', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'models/sales/orders.yml',
-                    name: 'orders',
-                    modelRef: 'orders',
-                    extendsFrom: [],
-                    measureNames: ['order_count'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'models/marketing/campaigns.yml',
-                    name: 'campaigns',
-                    modelRef: 'campaigns',
-                    extendsFrom: [],
-                    measureNames: ['spend'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            allPaths: ['models/marketing/campaigns.yml', 'models/sales/orders.yml'],
-        }));
-        expect(graph.components).toHaveLength(2);
-    });
-    it('returns components ordered lexicographically by their first-name-member', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'models/z.yml',
-                    name: 'z_model',
-                    modelRef: 'z',
-                    extendsFrom: [],
-                    measureNames: ['m'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'models/a.yml',
-                    name: 'a_model',
-                    modelRef: 'a',
-                    extendsFrom: [],
-                    measureNames: ['m'],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            allPaths: ['models/a.yml', 'models/z.yml'],
-        }));
-        expect(graph.components.map((c) => c.leadName)).toEqual(['a_model', 'z_model']);
-    });
-    it('metric that references an unknown measure still anchors its own file as a singleton', () => {
-        const graph = buildMetricFlowGraph(project({
-            metrics: [
-                { path: 'metrics/dangling.yml', name: 'dangling', type: 'simple', measureRef: 'nowhere', dependsOn: [] },
-            ],
-            allPaths: ['metrics/dangling.yml'],
-        }));
-        expect(graph.components).toHaveLength(1);
-        expect(graph.components[0].paths).toEqual(['metrics/dangling.yml']);
-        expect(graph.components[0].leadName).toBe('dangling');
-    });
-    it('transitive extends forms one component across 3 files', () => {
-        const graph = buildMetricFlowGraph(project({
-            semanticModels: [
-                {
-                    path: 'a.yml',
-                    name: 'a',
-                    modelRef: 'a',
-                    extendsFrom: [],
-                    measureNames: [],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'b.yml',
-                    name: 'b',
-                    modelRef: 'b',
-                    extendsFrom: ['a'],
-                    measureNames: [],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-                {
-                    path: 'c.yml',
-                    name: 'c',
-                    modelRef: 'c',
-                    extendsFrom: ['b'],
-                    measureNames: [],
-                    dimensionNames: [],
-                    entityNames: [],
-                    primaryEntities: [],
-                    foreignEntities: [],
-                    defaultTimeDimension: null,
-                },
-            ],
-            allPaths: ['a.yml', 'b.yml', 'c.yml'],
-        }));
-        expect(graph.components).toHaveLength(1);
-        expect(graph.components[0].paths.sort()).toEqual(['a.yml', 'b.yml', 'c.yml']);
-    });
-});

package/dist/context/ingest/adapters/metricflow/import-semantic-models.test.d.ts

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