@kaelio/ktx 0.5.0 → 0.6.0

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

@@ -1,171 +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 { parseMetricFlowStagedDir } from './parse.js';
-async function writeFixture(stagedDir, relPath, body) {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, body, 'utf-8');
-}
-describe('parseMetricFlowStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'mf-parse-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('extracts one semantic_model with its measures + dimensions + entities', async () => {
-        await writeFixture(stagedDir, 'models/orders.yml', [
-            'semantic_models:',
-            '  - name: orders',
-            '    description: Order fact table.',
-            "    model: ref('orders')",
-            '    entities:',
-            '      - name: order_id',
-            '        type: primary',
-            '      - name: customer_id',
-            '        type: foreign',
-            '    dimensions:',
-            '      - name: ordered_at',
-            '        type: time',
-            '        type_params:',
-            '          time_granularity: day',
-            '    measures:',
-            '      - name: order_count',
-            '        agg: count',
-            '        expr: order_id',
-            '      - name: gross_amount',
-            '        agg: sum',
-            '        expr: amount',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toHaveLength(1);
-        const sm = project.semanticModels[0];
-        expect(sm.path).toBe('models/orders.yml');
-        expect(sm.name).toBe('orders');
-        expect(sm.modelRef).toBe('orders');
-        expect(sm.measureNames).toEqual(['gross_amount', 'order_count']);
-        expect(sm.dimensionNames).toEqual(['ordered_at']);
-        expect(sm.entityNames).toEqual(['customer_id', 'order_id']);
-        expect(sm.primaryEntities).toEqual(['order_id']);
-        expect(sm.foreignEntities).toEqual(['customer_id']);
-        expect(sm.extendsFrom).toEqual([]);
-        expect(project.files).toEqual([
-            {
-                path: 'models/orders.yml',
-                content: expect.stringContaining('semantic_models:'),
-            },
-        ]);
-    });
-    it('captures `extends:` as a string OR a list', async () => {
-        await writeFixture(stagedDir, 'models/orders.yml', [
-            'semantic_models:',
-            '  - name: orders',
-            "    model: ref('orders')",
-            '    measures:',
-            '      - {name: order_count, agg: count, expr: order_id}',
-            '',
-        ].join('\n'));
-        await writeFixture(stagedDir, 'models/orders_ext_list.yml', [
-            'semantic_models:',
-            '  - name: orders_ext_list',
-            "    model: ref('orders_ext')",
-            '    extends: [orders]',
-            '    measures:',
-            '      - {name: refund_amount, agg: sum, expr: refund_amt}',
-            '',
-        ].join('\n'));
-        await writeFixture(stagedDir, 'models/orders_ext_str.yml', [
-            'semantic_models:',
-            '  - name: orders_ext_str',
-            "    model: ref('orders_ext')",
-            '    extends: orders',
-            '    measures:',
-            '      - {name: refund_amount2, agg: sum, expr: refund_amt2}',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        const list = project.semanticModels.find((sm) => sm.name === 'orders_ext_list');
-        const str = project.semanticModels.find((sm) => sm.name === 'orders_ext_str');
-        expect(list?.extendsFrom).toEqual(['orders']);
-        expect(str?.extendsFrom).toEqual(['orders']);
-    });
-    it('extracts metrics with referenced measures for simple + derived + ratio + cumulative', async () => {
-        await writeFixture(stagedDir, 'metrics/core.yml', [
-            'metrics:',
-            '  - name: total_orders',
-            '    type: simple',
-            '    type_params:',
-            '      measure: order_count',
-            '  - name: revenue',
-            '    type: derived',
-            '    type_params:',
-            '      expr: gross_amount - refund_amount',
-            '      metrics:',
-            '        - name: gross_amount',
-            '        - name: refund_amount',
-            '  - name: refund_rate',
-            '    type: ratio',
-            '    type_params:',
-            '      numerator: refund_amount',
-            '      denominator: gross_amount',
-            '  - name: cum_revenue',
-            '    type: cumulative',
-            '    type_params:',
-            '      measure: gross_amount',
-            '      window: 7 days',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.metrics).toHaveLength(4);
-        const byName = new Map(project.metrics.map((m) => [m.name, m]));
-        expect(byName.get('total_orders')?.type).toBe('simple');
-        expect(byName.get('total_orders')?.measureRef).toBe('order_count');
-        expect(byName.get('revenue')?.type).toBe('derived');
-        expect(byName.get('revenue')?.dependsOn.sort()).toEqual(['gross_amount', 'refund_amount']);
-        expect(byName.get('refund_rate')?.type).toBe('ratio');
-        expect(byName.get('refund_rate')?.dependsOn.sort()).toEqual(['gross_amount', 'refund_amount']);
-        expect(byName.get('cum_revenue')?.type).toBe('cumulative');
-        expect(byName.get('cum_revenue')?.measureRef).toBe('gross_amount');
-    });
-    it('returns empty arrays for a non-MetricFlow YAML (e.g. dbt_project.yml)', async () => {
-        await writeFixture(stagedDir, 'dbt_project.yml', 'name: my_proj\nversion: "1.0.0"\n');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toEqual([]);
-        expect(project.metrics).toEqual([]);
-        expect(project.allPaths).toEqual(['dbt_project.yml']);
-    });
-    it('skips files that are not YAML (or fail to parse) without throwing', async () => {
-        await writeFixture(stagedDir, 'broken.yml', '{ this is: not valid YAML :::');
-        await writeFixture(stagedDir, 'other.txt', 'ignore me');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toEqual([]);
-        expect(project.metrics).toEqual([]);
-        // allPaths includes `.yml` / `.yaml` only, even when unparseable:
-        expect(project.allPaths).toEqual(['broken.yml']);
-    });
-    it('allPaths is sorted deterministically', async () => {
-        await writeFixture(stagedDir, 'models/z.yml', 'semantic_models: []\n');
-        await writeFixture(stagedDir, 'models/a.yml', 'semantic_models: []\n');
-        await writeFixture(stagedDir, 'metrics/b.yaml', 'metrics: []\n');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.allPaths).toEqual(['metrics/b.yaml', 'models/a.yml', 'models/z.yml']);
-    });
-    it("extracts modelRef from ref('name') and source('src','table') and literal strings", async () => {
-        await writeFixture(stagedDir, 'models/a.yml', [
-            'semantic_models:',
-            '  - {name: a, model: "ref(\'orders\')", measures: [{name: c, agg: count, expr: id}]}',
-            "  - {name: b, model: \"source('raw','orders_raw')\", measures: [{name: c, agg: count, expr: id}]}",
-            '  - {name: c, model: plain_table, measures: [{name: c, agg: count, expr: id}]}',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        const byName = new Map(project.semanticModels.map((s) => [s.name, s]));
-        expect(byName.get('a')?.modelRef).toBe('orders');
-        expect(byName.get('b')?.modelRef).toBe('orders_raw');
-        expect(byName.get('c')?.modelRef).toBe('plain_table');
-    });
-});

package/dist/context/ingest/adapters/metricflow/pull-config.test.d.ts

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

package/dist/context/ingest/adapters/metricflow/pull-config.test.js

@@ -1,57 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMetricflowPullConfig, pullConfigFromMetricflowIntegration } from './pull-config.js';
-describe('metricflow pull config', () => {
-    it('applies defaults for optional git fields', () => {
-        const parsed = parseMetricflowPullConfig({
-            repoUrl: 'https://github.com/acme/analytics.git',
-        });
-        expect(parsed).toEqual({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'main',
-            path: null,
-            authToken: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('preserves provided branch, path, token, and parsed target tables', () => {
-        const parsed = parseMetricflowPullConfig({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'release',
-            path: 'dbt',
-            authToken: 'secret-token',
-            parsedTargetTables: {
-                orders: {
-                    catalog: 'warehouse',
-                    schema: 'marts',
-                    name: 'orders',
-                    ok: true,
-                    canonicalTable: 'analytics.marts.orders',
-                },
-            },
-        });
-        expect(parsed.branch).toBe('release');
-        expect(parsed.path).toBe('dbt');
-        expect(parsed.authToken).toBe('secret-token');
-        expect(parsed.parsedTargetTables.orders).toMatchObject({ ok: true, name: 'orders' });
-    });
-    it('rejects missing repoUrl', () => {
-        expect(() => parseMetricflowPullConfig({})).toThrow();
-    });
-    it('builds pull config from a local metricflow integration block', () => {
-        expect(pullConfigFromMetricflowIntegration({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: null,
-            path: null,
-            authToken: null,
-        })).toEqual({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'main',
-            path: null,
-            authToken: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('throws a clear error when the integration block has no repo URL', () => {
-        expect(() => pullConfigFromMetricflowIntegration({ repoUrl: null })).toThrow('metricflow integration config missing repoUrl');
-    });
-});

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

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

package/dist/context/ingest/adapters/metricflow/semantic-models.test.js

@@ -1,204 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { composeOverlay } from '../../../../context/sl/semantic-layer.service.js';
-import { buildMetricflowColumns, buildMetricflowJoinsForModel, buildMetricflowSemanticModelSource, countImportableMetricflowRelationships, findMatchingMetricflowTable, mapCrossModelMetricToSource, mapSemanticModelToSource, resolveMetricflowSemanticModelSourceName, rewriteMetricflowManifestJoins, toKebabCaseMetricflowName, } from './semantic-models.js';
-const ordersModel = {
-    name: 'orders',
-    description: 'Order facts',
-    modelRef: 'fct_orders',
-    dimensions: [
-        { name: 'status', column: 'status', type: 'string', label: 'Status', description: 'Order status' },
-        { name: 'ordered_at', column: 'ordered_at', type: 'time', label: 'Ordered At' },
-    ],
-    measures: [
-        {
-            type: 'simple',
-            name: 'total_revenue',
-            column: 'amount',
-            aggregation: 'sum',
-            label: 'Total Revenue',
-            description: 'Revenue',
-            filter: "status = 'completed'",
-        },
-        {
-            type: 'derived',
-            name: 'average_revenue',
-            expr: 'total_revenue / NULLIF(order_count, 0)',
-            dependsOn: ['total_revenue', 'order_count'],
-        },
-    ],
-    entities: [],
-    defaultTimeDimension: 'ordered_at',
-};
-describe('metricflow semantic model mapping', () => {
-    it('normalizes source names the same way the server importer did', () => {
-        expect(toKebabCaseMetricflowName('Fct Orders!')).toBe('fct-orders');
-    });
-    it('maps a parsed semantic model to a SemanticLayerSource', () => {
-        expect(mapSemanticModelToSource(ordersModel, 'analytics.orders')).toEqual({
-            name: 'fct-orders',
-            table: 'analytics.orders',
-            grain: ['status', 'ordered_at'],
-            columns: [
-                { name: 'status', type: 'string', description: 'Order status' },
-                { name: 'ordered_at', type: 'time' },
-            ],
-            measures: [
-                {
-                    name: 'total_revenue',
-                    expr: 'sum(amount)',
-                    description: 'Revenue',
-                    filter: "status = 'completed'",
-                },
-                {
-                    name: 'average_revenue',
-                    expr: 'total_revenue / NULLIF(order_count, 0)',
-                },
-            ],
-            joins: [],
-            descriptions: { dbt: 'Order facts' },
-        });
-    });
-    it('maps a cross-model metric to a SQL standalone source', () => {
-        const metric = {
-            name: 'roas',
-            label: 'ROAS',
-            description: 'Return on ad spend',
-            type: 'derived',
-            expr: 'revenue / spend',
-            dependsOn: [
-                { metricName: 'orders', alias: 'revenue' },
-                { metricName: 'campaigns', alias: 'spend' },
-            ],
-            filter: "channel = 'paid'",
-        };
-        expect(mapCrossModelMetricToSource(metric)).toEqual({
-            name: 'roas',
-            sql: 'revenue / spend',
-            descriptions: { dbt: 'Return on ad spend' },
-            grain: [],
-            columns: [],
-            measures: [
-                {
-                    name: 'roas',
-                    expr: 'revenue / spend',
-                    description: 'Return on ad spend',
-                    filter: "channel = 'paid'",
-                },
-            ],
-            joins: [],
-        });
-    });
-    it('finds matching tables using target schema, exact name, dotted suffix, and underscore suffix', () => {
-        const tables = [
-            { id: '1', name: 'fct_orders', catalog: null, db: 'analytics', columns: [] },
-            { id: '2', name: 'warehouse.marts.fct_orders', catalog: null, db: 'marts', columns: [] },
-            { id: '3', name: 'warehouse_fct_customers', catalog: null, db: null, columns: [] },
-        ];
-        expect(findMatchingMetricflowTable('fct_orders', tables, 'analytics')?.id).toBe('1');
-        expect(findMatchingMetricflowTable('fct_orders', [tables[1]], null)?.id).toBe('2');
-        expect(findMatchingMetricflowTable('fct_customers', [tables[2]], null)?.id).toBe('3');
-        expect(findMatchingMetricflowTable('missing', tables, null)).toBeUndefined();
-    });
-    it('counts only relationships whose tables and columns exist', () => {
-        const relationships = [
-            { fromTable: 'orders', fromColumn: 'customer_id', toTable: 'customers', toColumn: 'id' },
-            { fromTable: 'orders', fromColumn: 'missing', toTable: 'customers', toColumn: 'id' },
-            { fromTable: 'orders', fromColumn: 'customer_id', toTable: 'missing_table', toColumn: 'id' },
-        ];
-        const tables = [
-            { id: '1', name: 'orders', catalog: null, db: null, columns: [{ id: 'c1', name: 'customer_id' }] },
-            { id: '2', name: 'customers', catalog: null, db: null, columns: [{ id: 'c2', name: 'id' }] },
-        ];
-        expect(countImportableMetricflowRelationships(relationships, tables)).toBe(1);
-    });
-    it('resolves semantic-model source names to lowercase snake_case identifiers', () => {
-        expect(resolveMetricflowSemanticModelSourceName(ordersModel, {
-            id: '1',
-            name: 'ANALYTICS.Fct Orders',
-            catalog: null,
-            db: 'analytics',
-            columns: [],
-        })).toBe('fct_orders');
-        expect(resolveMetricflowSemanticModelSourceName({ ...ordersModel, modelRef: 'fallback_model' }, undefined)).toBe('fallback_model');
-    });
-    it('materializes entity join keys as hidden standalone columns', () => {
-        expect(buildMetricflowColumns({
-            ...ordersModel,
-            entities: [{ name: 'customer', type: 'foreign', expr: 'customer_id', description: 'FK to customers' }],
-        })).toContainEqual({ name: 'customer_id', type: 'string', visibility: 'hidden', description: 'FK to customers' });
-    });
-    it('builds standalone sources with semantic-model joins', () => {
-        const orders = {
-            ...ordersModel,
-            modelRef: 'orders',
-            entities: [{ name: 'customer', type: 'foreign', expr: 'customer_id' }],
-        };
-        const customers = {
-            ...ordersModel,
-            name: 'customers',
-            modelRef: 'customers',
-            dimensions: [{ name: 'id', column: 'id', type: 'string' }],
-            measures: [],
-            entities: [],
-        };
-        const sourceNameByModelRef = new Map([
-            [orders.modelRef, 'orders'],
-            [customers.modelRef, 'customers'],
-        ]);
-        const joins = buildMetricflowJoinsForModel(orders, [{ fromTable: 'orders', fromColumn: 'customer_id', toTable: 'customers', toColumn: 'id' }], sourceNameByModelRef);
-        expect(buildMetricflowSemanticModelSource({
-            model: orders,
-            matchedTable: undefined,
-            sourceName: 'orders',
-            manifestSource: null,
-        }, joins, new Map())).toMatchObject({
-            name: 'orders',
-            table: 'orders',
-            joins: [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }],
-        });
-    });
-    it('builds overlays for exact manifest matches so scanned columns remain manifest-owned', () => {
-        const manifestSource = {
-            name: 'orders',
-            table: 'analytics.orders',
-            grain: ['id'],
-            columns: [
-                { name: 'id', type: 'string' },
-                { name: 'customer_id', type: 'string' },
-            ],
-            joins: [],
-            measures: [],
-            descriptions: { db: 'Orders table from scan' },
-        };
-        const overlay = buildMetricflowSemanticModelSource({
-            model: { ...ordersModel, modelRef: 'orders', description: 'dbt-described orders' },
-            matchedTable: undefined,
-            sourceName: 'orders',
-            manifestSource,
-        }, [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }], new Map());
-        expect(overlay).not.toHaveProperty('table');
-        expect(overlay).not.toHaveProperty('grain');
-        expect(overlay).not.toHaveProperty('columns');
-        expect(overlay).toMatchObject({
-            name: 'orders',
-            joins: [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }],
-            descriptions: { dbt: 'dbt-described orders' },
-        });
-        const composed = composeOverlay(manifestSource, overlay);
-        expect(composed.columns.map((column) => column.name)).toEqual(['id', 'customer_id']);
-        expect(composed.joins).toHaveLength(1);
-        expect(composed.descriptions).toEqual({ db: 'Orders table from scan', dbt: 'dbt-described orders' });
-    });
-    it('rewrites preserved manifest joins to synced bare source names', () => {
-        expect(rewriteMetricflowManifestJoins([
-            {
-                to: 'analytics.customers',
-                on: 'analytics.orders.customer_id = analytics.customers.id',
-                relationship: 'many_to_one',
-            },
-        ], new Map([
-            ['analytics.orders', 'orders'],
-            ['analytics.customers', 'customers'],
-        ]))).toEqual([{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }]);
-    });
-});

package/dist/context/ingest/adapters/notion/cluster.test.d.ts

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

package/dist/context/ingest/adapters/notion/cluster.test.js

@@ -1,123 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, test } from 'vitest';
-import { clusterNotionWorkUnits, MIN_PAGES_TO_CLUSTER } from './cluster.js';
-function fakeEmbedding(text) {
-    const v = [0, 0, 0, 0];
-    for (const ch of text) {
-        v[ch.charCodeAt(0) % 4] += 1;
-    }
-    return v;
-}
-const mockEmbed = {
-    maxBatchSize: 100,
-    computeEmbedding: async (t) => fakeEmbedding(t),
-    computeEmbeddingsBulk: async (texts) => texts.map(fakeEmbedding),
-};
-async function makeStaged(pages) {
-    const dir = await mkdtemp(join(tmpdir(), 'notion-cluster-'));
-    for (const p of pages) {
-        const pageDir = join(dir, 'pages', p.id);
-        await mkdir(pageDir, { recursive: true });
-        await writeFile(join(pageDir, 'page.md'), p.body);
-        await writeFile(join(pageDir, 'metadata.json'), JSON.stringify({
-            id: p.id,
-            title: p.title,
-            path: p.title,
-            objectType: 'page',
-            properties: {},
-        }));
-    }
-    return dir;
-}
-function makeWorkUnits(pages) {
-    return pages.map((p) => ({
-        unitKey: `notion-${p.id}`,
-        rawFiles: [`pages/${p.id}/page.md`, `pages/${p.id}/metadata.json`],
-        peerFileIndex: [],
-        dependencyPaths: ['manifest.json'],
-    }));
-}
-describe('clusterNotionWorkUnits', () => {
-    test('returns input unchanged when below threshold', async () => {
-        const pages = Array.from({ length: 3 }, (_, i) => ({
-            id: `p${i}`,
-            title: `Page ${i}`,
-            body: 'short body',
-        }));
-        const stagedDir = await makeStaged(pages);
-        const wus = makeWorkUnits(pages);
-        const out = await clusterNotionWorkUnits({ workUnits: wus, stagedDir, embedding: mockEmbed });
-        expect(out).toHaveLength(3);
-        expect(out[0].unitKey).toBe('notion-p0');
-    });
-    test('groups pages into k=ceil(N/8) clusters when above threshold', async () => {
-        const n = MIN_PAGES_TO_CLUSTER + 4;
-        const pages = Array.from({ length: n }, (_, i) => ({
-            id: `p${i}`,
-            title: `Topic ${i % 2 === 0 ? 'alpha' : 'beta'} ${i}`,
-            body: `Body for page ${i}`.repeat(20),
-        }));
-        const stagedDir = await makeStaged(pages);
-        const wus = makeWorkUnits(pages);
-        const out = await clusterNotionWorkUnits({ workUnits: wus, stagedDir, embedding: mockEmbed });
-        expect(out.length).toBeLessThanOrEqual(wus.length);
-        expect(out.length).toBe(Math.ceil(wus.length / 8));
-        for (const wu of out) {
-            expect(wu.unitKey).toMatch(/^notion-cluster-\d+$/);
-            expect(wu.rawFiles.length).toBeGreaterThan(0);
-            expect(wu.notes).toMatch(/Synthesize/);
-            expect(wu.notes).toContain('emit_unmapped_fallback');
-            expect(wu.notes).toContain('Do not create SL sources under the Notion connection');
-        }
-    });
-    test('merges pages into one synthesis unit at the clustering threshold', async () => {
-        const pages = Array.from({ length: MIN_PAGES_TO_CLUSTER }, (_, i) => ({
-            id: `p${i}`,
-            title: `Customer source reference ${i}`,
-            body: `Customer source reference maps to orbit_analytics.customer ${i}`.repeat(10),
-        }));
-        const stagedDir = await makeStaged(pages);
-        const wus = makeWorkUnits(pages);
-        const out = await clusterNotionWorkUnits({ workUnits: wus, stagedDir, embedding: mockEmbed });
-        expect(out).toHaveLength(1);
-        expect(out[0].unitKey).toBe('notion-cluster-1');
-        expect(new Set(out[0].rawFiles)).toEqual(new Set(wus.flatMap((wu) => wu.rawFiles)));
-        expect(out[0].notes).toContain('emit_unmapped_fallback');
-        expect(out[0].notes).toContain('Do not create SL sources under the Notion connection');
-    });
-    test('preserves coverage: every input rawFile appears in some cluster', async () => {
-        const pages = Array.from({ length: 12 }, (_, i) => ({
-            id: `p${i}`,
-            title: `Page ${i}`,
-            body: 'body content',
-        }));
-        const stagedDir = await makeStaged(pages);
-        const wus = makeWorkUnits(pages);
-        const inputFiles = new Set(wus.flatMap((wu) => wu.rawFiles));
-        const out = await clusterNotionWorkUnits({ workUnits: wus, stagedDir, embedding: mockEmbed });
-        const outFiles = new Set(out.flatMap((wu) => wu.rawFiles));
-        expect(outFiles).toEqual(inputFiles);
-    });
-    test('falls back to input when embedding fails', async () => {
-        const pages = Array.from({ length: 10 }, (_, i) => ({
-            id: `p${i}`,
-            title: `Page ${i}`,
-            body: 'b',
-        }));
-        const stagedDir = await makeStaged(pages);
-        const wus = makeWorkUnits(pages);
-        const failingEmbed = {
-            maxBatchSize: 100,
-            computeEmbedding: async () => {
-                throw new Error('embedding down');
-            },
-            computeEmbeddingsBulk: async () => {
-                throw new Error('embedding down');
-            },
-        };
-        const out = await clusterNotionWorkUnits({ workUnits: wus, stagedDir, embedding: failingEmbed });
-        expect(out).toEqual(wus);
-    });
-});

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

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