@kaelio/ktx 0.5.0 → 0.6.0

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

@@ -1,118 +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 { parseLookmlStagedDir } from './parse.js';
-describe('parseLookmlStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'lkml-parse-'));
-    });
-    afterEach(async () => rm(stagedDir, { recursive: true, force: true }));
-    it('parses a single view file and reports it under views with a relative path', async () => {
-        await writeFile(join(stagedDir, 'customers.view.lkml'), `view: customers {
-  dimension: id {
-    type: number
-    primary_key: yes
-    sql: \${TABLE}.id ;;
-  }
-}
-`, 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        expect(result.views.map((v) => v.path)).toEqual(['customers.view.lkml']);
-        expect(result.views[0].name).toBe('customers');
-        expect(result.models).toEqual([]);
-        expect(result.dashboards).toEqual([]);
-    });
-    it('parses a model file and extracts include globs', async () => {
-        await mkdir(join(stagedDir, 'views'), { recursive: true });
-        await writeFile(join(stagedDir, 'orders.model.lkml'), `connection: "my_bq"
-
-include: "views/*.view.lkml"
-
-explore: orders {}
-`, 'utf-8');
-        await writeFile(join(stagedDir, 'views', 'orders.view.lkml'), `view: orders {
-  sql_table_name: public.orders ;;
-}
-`, 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        expect(result.models.map((m) => m.path)).toEqual(['orders.model.lkml']);
-        expect(result.models[0].name).toBe('orders');
-        expect(result.models[0].includes).toEqual(['views/*.view.lkml']);
-        expect(result.models[0].explores).toEqual(['orders']);
-        expect(result.views.map((v) => v.path)).toEqual(['views/orders.view.lkml']);
-    });
-    it('extracts model connection names and raw view sql_table_name declarations', async () => {
-        await mkdir(join(stagedDir, 'views'), { recursive: true });
-        await writeFile(join(stagedDir, 'b2b.model.lkml'), `connection: "b2b_sandbox_bq"
-
-include: "views/*.view.lkml"
-
-explore: orders {}
-`, 'utf-8');
-        await writeFile(join(stagedDir, 'views', 'orders.view.lkml'), `view: orders {
-  sql_table_name: analytics.orders AS o ;;
-}
-`, 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        expect(result.models[0]).toMatchObject({
-            path: 'b2b.model.lkml',
-            name: 'b2b',
-            connectionName: 'b2b_sandbox_bq',
-        });
-        expect(result.views[0]).toMatchObject({
-            path: 'views/orders.view.lkml',
-            name: 'orders',
-            rawSqlTableName: 'analytics.orders AS o',
-        });
-    });
-    it('captures extends declarations on views', async () => {
-        await writeFile(join(stagedDir, 'base.view.lkml'), `view: base {
-  dimension: id {
-    type: number
-    primary_key: yes
-    sql: \${TABLE}.id ;;
-  }
-}
-`, 'utf-8');
-        await writeFile(join(stagedDir, 'orders.view.lkml'), `view: orders {
-  extends: [base]
-  sql_table_name: public.orders ;;
-}
-`, 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        const orders = result.views.find((v) => v.name === 'orders');
-        expect(orders).toBeDefined();
-        if (!orders) {
-            throw new Error('expected orders view');
-        }
-        expect(orders.extendsFrom).toEqual(['base']);
-    });
-    it('collects .dashboard.lkml files structurally (no deep parsing)', async () => {
-        await writeFile(join(stagedDir, 'overview.dashboard.lkml'), '- dashboard: overview\n  title: Overview\n', 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        expect(result.dashboards.map((d) => d.path)).toEqual(['overview.dashboard.lkml']);
-        expect(result.dashboards[0].name).toBe('overview');
-    });
-    it('ignores non-.lkml files', async () => {
-        await writeFile(join(stagedDir, 'README.md'), '# readme\n', 'utf-8');
-        await writeFile(join(stagedDir, 'notes.txt'), 'note\n', 'utf-8');
-        const result = await parseLookmlStagedDir(stagedDir);
-        expect(result.models).toEqual([]);
-        expect(result.views).toEqual([]);
-        expect(result.dashboards).toEqual([]);
-    });
-    it('returns a sorted deterministic order across runs', async () => {
-        await writeFile(join(stagedDir, 'zeta.view.lkml'), `view: zeta {
-}
-`, 'utf-8');
-        await writeFile(join(stagedDir, 'alpha.view.lkml'), `view: alpha {
-}
-`, 'utf-8');
-        const r1 = await parseLookmlStagedDir(stagedDir);
-        const r2 = await parseLookmlStagedDir(stagedDir);
-        expect(r1.views.map((v) => v.path)).toEqual(['alpha.view.lkml', 'zeta.view.lkml']);
-        expect(r2.views.map((v) => v.path)).toEqual(r1.views.map((v) => v.path));
-    });
-});

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

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

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

@@ -1,128 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseLookmlPullConfig, pullConfigFromIntegrationConfig } from './pull-config.js';
-describe('lookml pull config', () => {
-    it('parses a minimal valid config with defaulted branch', () => {
-        const config = parseLookmlPullConfig({ repoUrl: 'https://github.com/acme/r.git' });
-        expect(config.repoUrl).toBe('https://github.com/acme/r.git');
-        expect(config.branch).toBe('main');
-        expect(config.path).toBeNull();
-        expect(config.authToken).toBeNull();
-        expect(config.expectedLookerConnectionName).toBeNull();
-        expect(config.parsedTargetTables).toEqual({});
-    });
-    it('defaults expectedLookerConnectionName and parsedTargetTables for LookML pulls', () => {
-        const config = parseLookmlPullConfig({ repoUrl: 'https://github.com/acme/r.git' });
-        expect(config.expectedLookerConnectionName).toBeNull();
-        expect(config.parsedTargetTables).toEqual({});
-    });
-    it('parses a fully specified config', () => {
-        const config = parseLookmlPullConfig({
-            repoUrl: 'https://gitlab.com/team/proj.git',
-            branch: 'develop',
-            path: 'views',
-            authToken: 'glpat-xyz',
-        });
-        expect(config).toEqual({
-            repoUrl: 'https://gitlab.com/team/proj.git',
-            branch: 'develop',
-            path: 'views',
-            authToken: 'glpat-xyz',
-            expectedLookerConnectionName: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('parses the validation-only expected connection and parsed target table map', () => {
-        const config = parseLookmlPullConfig({
-            repoUrl: 'https://github.com/acme/r.git',
-            expectedLookerConnectionName: 'b2b_sandbox_bq',
-            parsedTargetTables: {
-                'b2b.orders': {
-                    ok: true,
-                    catalog: 'proj',
-                    schema: 'analytics',
-                    name: 'orders',
-                    canonicalTable: 'proj.analytics.orders',
-                },
-                'b2b.derived': {
-                    ok: false,
-                    reason: 'derived_table_not_supported',
-                },
-            },
-        });
-        expect(config.expectedLookerConnectionName).toBe('b2b_sandbox_bq');
-        expect(config.parsedTargetTables['b2b.orders']).toEqual({
-            ok: true,
-            catalog: 'proj',
-            schema: 'analytics',
-            name: 'orders',
-            canonicalTable: 'proj.analytics.orders',
-        });
-        expect(config.parsedTargetTables['b2b.derived']).toEqual({
-            ok: false,
-            reason: 'derived_table_not_supported',
-        });
-    });
-    it('rejects a non-URL repoUrl', () => {
-        expect(() => parseLookmlPullConfig({ repoUrl: 'not-a-url' })).toThrow();
-    });
-    it('rejects a missing repoUrl', () => {
-        expect(() => parseLookmlPullConfig({ branch: 'main' })).toThrow();
-    });
-    it('pullConfigFromIntegrationConfig extracts the adapter-visible fields', () => {
-        const integration = {
-            pullEnabled: true,
-            repoUrl: 'https://github.com/acme/r.git',
-            branch: 'main',
-            path: 'models',
-            authToken: 'ghp_x',
-            pullSchedule: 'daily',
-            nextPullAt: '2026-05-01T00:00:00.000Z',
-            lastPulledAt: null,
-            lastCommitHash: null,
-        };
-        expect(pullConfigFromIntegrationConfig(integration)).toEqual({
-            repoUrl: 'https://github.com/acme/r.git',
-            branch: 'main',
-            path: 'models',
-            authToken: 'ghp_x',
-            expectedLookerConnectionName: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('pullConfigFromIntegrationConfig forwards the expected connection name', () => {
-        const integration = {
-            pullEnabled: true,
-            repoUrl: 'https://github.com/acme/r.git',
-            branch: 'main',
-            path: 'models',
-            authToken: 'ghp_x',
-            pullSchedule: 'daily',
-            nextPullAt: '2026-05-01T00:00:00.000Z',
-            lastPulledAt: null,
-            lastCommitHash: null,
-            expectedLookerConnectionName: 'warehouse_bq',
-        };
-        expect(pullConfigFromIntegrationConfig(integration)).toEqual({
-            repoUrl: 'https://github.com/acme/r.git',
-            branch: 'main',
-            path: 'models',
-            authToken: 'ghp_x',
-            expectedLookerConnectionName: 'warehouse_bq',
-            parsedTargetTables: {},
-        });
-    });
-    it('pullConfigFromIntegrationConfig throws when repoUrl is null', () => {
-        const integration = {
-            pullEnabled: false,
-            repoUrl: null,
-            branch: null,
-            path: null,
-            authToken: null,
-            pullSchedule: null,
-            nextPullAt: null,
-            lastPulledAt: null,
-            lastCommitHash: null,
-        };
-        expect(() => pullConfigFromIntegrationConfig(integration)).toThrow(/repoUrl/);
-    });
-});

package/dist/context/ingest/adapters/metabase/card-references.test.d.ts

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

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

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CardReferenceCycleError, expandCardReferences } from './card-references.js';
-describe('expandCardReferences', () => {
-    const fetchCard = (id) => {
-        const cards = {
-            100: 'SELECT id FROM base_table',
-            101: 'SELECT * FROM {{#100}}',
-            102: 'SELECT * FROM {{#101}} WHERE x = 1',
-            200: 'SELECT * FROM {{#201}}',
-            201: 'SELECT * FROM {{#200}}',
-        };
-        if (!(id in cards)) {
-            return Promise.reject(new Error(`no card ${id}`));
-        }
-        return Promise.resolve({ native_query: cards[id] });
-    };
-    it('returns SQL unchanged when there are no references', async () => {
-        const result = await expandCardReferences('SELECT 1', { fetchCard });
-        expect(result).toBe('SELECT 1');
-    });
-    it('inlines a single card reference as a subquery', async () => {
-        const result = await expandCardReferences('SELECT * FROM {{#100}}', { fetchCard });
-        expect(result).toBe('SELECT * FROM (SELECT id FROM base_table)');
-    });
-    it('handles slugged references like {{#100-pretty-slug}}', async () => {
-        const result = await expandCardReferences('SELECT * FROM {{#100-pretty-slug}}', { fetchCard });
-        expect(result).toBe('SELECT * FROM (SELECT id FROM base_table)');
-    });
-    it('recursively resolves nested references', async () => {
-        const result = await expandCardReferences('SELECT * FROM {{#102}}', { fetchCard });
-        expect(result).toBe('SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT id FROM base_table)) WHERE x = 1)');
-    });
-    it('detects cycles and throws CardReferenceCycleError', async () => {
-        await expect(expandCardReferences('SELECT * FROM {{#200}}', { fetchCard })).rejects.toBeInstanceOf(CardReferenceCycleError);
-    });
-});

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

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

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

@@ -1,299 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { chunkMetabaseStagedDir } from './chunk.js';
-import { stagedSyncConfigSchema } from './types.js';
-const FIXTURES = resolve(__dirname, '../../../../test/fixtures/metabase');
-const SIMPLE = join(FIXTURES, 'simple');
-const MULTI = join(FIXTURES, 'multi-collection');
-const CARD_REF = join(FIXTURES, 'card-ref');
-describe('chunkMetabaseStagedDir — first run', () => {
-    it('simple fixture emits one WU for collection 5 containing cards + collection file; shared control files in dependencyPaths', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE);
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('metabase-col-5');
-        expect(wu.rawFiles.sort()).toEqual(['cards/1.json', 'cards/2.json', 'collections/5.json']);
-        expect(wu.dependencyPaths.sort()).toEqual(['databases/42.json', 'sync-config.json']);
-        expect(wu.peerFileIndex).toEqual([]);
-        expect(wu.notes).toContain('collection 5');
-        expect(wu.notes).toContain('2 cards');
-    });
-    it('multi-collection fixture emits two WUs — one per collection — deterministic by id', async () => {
-        const result = await chunkMetabaseStagedDir(MULTI);
-        expect(result.workUnits).toHaveLength(2);
-        expect(result.workUnits.map((wu) => wu.unitKey)).toEqual(['metabase-col-5', 'metabase-col-6']);
-        expect(result.workUnits[0].rawFiles).toContain('cards/1.json');
-        expect(result.workUnits[0].rawFiles).toContain('cards/2.json');
-        expect(result.workUnits[0].rawFiles).not.toContain('cards/3.json');
-        expect(result.workUnits[1].rawFiles).toContain('cards/3.json');
-        expect(result.workUnits[1].rawFiles).not.toContain('cards/1.json');
-        // Each WU's peerFileIndex contains the OTHER collection's card files.
-        expect(result.workUnits[0].peerFileIndex).toContain('cards/3.json');
-        expect(result.workUnits[1].peerFileIndex).toContain('cards/1.json');
-    });
-    it('card-ref fixture: cross-card reference inside the same collection lands in rawFiles, NOT dependencyPaths', async () => {
-        const result = await chunkMetabaseStagedDir(CARD_REF);
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.rawFiles).toContain('cards/10.json');
-        expect(wu.rawFiles).toContain('cards/11.json');
-        expect(wu.dependencyPaths).not.toContain('cards/10.json');
-        expect(wu.dependencyPaths).not.toContain('cards/11.json');
-    });
-    it('is deterministic: two identical invocations return structurally-equal WUs', async () => {
-        const r1 = await chunkMetabaseStagedDir(SIMPLE);
-        const r2 = await chunkMetabaseStagedDir(SIMPLE);
-        expect(JSON.stringify(r1)).toBe(JSON.stringify(r2));
-    });
-    it('DiffSet re-sync keeps only WUs with a changed card; unchanged siblings land in dependencyPaths', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE, {
-            diffSet: {
-                added: [],
-                modified: ['cards/1.json'],
-                deleted: [],
-                unchanged: ['cards/2.json', 'collections/5.json', 'databases/42.json', 'sync-config.json'],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.rawFiles).toEqual(['cards/1.json']);
-        expect(wu.dependencyPaths.sort()).toEqual([
-            'cards/2.json',
-            'collections/5.json',
-            'databases/42.json',
-            'sync-config.json',
-        ]);
-    });
-    it('DiffSet re-sync: all-unchanged yields zero WUs and no eviction', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE, {
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: [],
-                unchanged: ['cards/1.json', 'cards/2.json', 'collections/5.json', 'databases/42.json', 'sync-config.json'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toBeUndefined();
-    });
-    it('DiffSet re-sync: deleted card emits an EvictionUnit', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE, {
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: ['cards/1.json'],
-                unchanged: ['cards/2.json', 'collections/5.json', 'databases/42.json', 'sync-config.json'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toEqual({ deletedRawPaths: ['cards/1.json'] });
-    });
-    it('DiffSet re-sync: sync-config.json change alone does NOT trigger any WU', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE, {
-            diffSet: {
-                added: [],
-                modified: ['sync-config.json'],
-                deleted: [],
-                unchanged: ['cards/1.json', 'cards/2.json', 'collections/5.json', 'databases/42.json'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toBeUndefined();
-    });
-    it('DiffSet re-sync: databases/{id}.json change alone does NOT trigger any WU', async () => {
-        const result = await chunkMetabaseStagedDir(SIMPLE, {
-            diffSet: {
-                added: [],
-                modified: ['databases/42.json'],
-                deleted: [],
-                unchanged: ['cards/1.json', 'cards/2.json', 'collections/5.json', 'sync-config.json'],
-            },
-        });
-        expect(result.workUnits).toEqual([]);
-        expect(result.eviction).toBeUndefined();
-    });
-});
-async function writeInline(stagedDir, rel, body) {
-    const abs = join(stagedDir, rel);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, JSON.stringify(body), 'utf-8');
-}
-describe('chunkMetabaseStagedDir — selected mode filters non-matching cards', () => {
-    let dir;
-    beforeEach(async () => {
-        dir = await mkdtemp(join(tmpdir(), 'mb-chunk-select-'));
-    });
-    afterEach(async () => {
-        await rm(dir, { recursive: true, force: true });
-    });
-    it('cards outside selected collections are NOT in any WU', async () => {
-        await writeInline(dir, 'sync-config.json', {
-            metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-            metabaseDatabaseId: 42,
-            syncMode: 'ONLY',
-            selections: [{ selectionType: 'collection', metabaseObjectId: 5 }],
-            defaultTagNames: [],
-            mapping: {
-                metabaseDatabaseId: 42,
-                metabaseDatabaseName: 'Analytics',
-                metabaseEngine: 'postgres',
-                targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-            },
-        });
-        await writeInline(dir, 'databases/42.json', {
-            metabaseDatabaseId: 42,
-            metabaseDatabaseName: 'Analytics',
-            metabaseEngine: 'postgres',
-            targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-        });
-        await writeInline(dir, 'collections/5.json', { metabaseId: 5, name: 'A', parentId: 'root' });
-        await writeInline(dir, 'collections/6.json', { metabaseId: 6, name: 'B', parentId: 'root' });
-        await writeInline(dir, 'cards/100.json', {
-            metabaseId: 100,
-            name: 'In',
-            description: null,
-            type: 'model',
-            databaseId: 42,
-            collectionId: 5,
-            archived: false,
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            resultMetadata: [],
-            collectionPath: ['A'],
-            referencedCardIds: [],
-            resolutionStatus: 'resolved',
-        });
-        await writeInline(dir, 'cards/200.json', {
-            metabaseId: 200,
-            name: 'Out',
-            description: null,
-            type: 'model',
-            databaseId: 42,
-            collectionId: 6,
-            archived: false,
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            resultMetadata: [],
-            collectionPath: ['B'],
-            referencedCardIds: [],
-            resolutionStatus: 'resolved',
-        });
-        const result = await chunkMetabaseStagedDir(dir);
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].unitKey).toBe('metabase-col-5');
-        expect(result.workUnits[0].rawFiles).toContain('cards/100.json');
-        expect(result.workUnits[0].rawFiles).not.toContain('cards/200.json');
-    });
-});
-describe('chunkMetabaseStagedDir — syncMode enum coverage', () => {
-    let dir;
-    beforeEach(async () => {
-        dir = await mkdtemp(join(tmpdir(), 'mb-chunk-enum-'));
-        await writeInline(dir, 'databases/42.json', {
-            metabaseDatabaseId: 42,
-            metabaseDatabaseName: 'Analytics',
-            metabaseEngine: 'postgres',
-            targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-        });
-        await writeInline(dir, 'collections/5.json', { metabaseId: 5, name: 'A', parentId: 'root' });
-        await writeInline(dir, 'collections/6.json', { metabaseId: 6, name: 'B', parentId: 'root' });
-        await writeInline(dir, 'cards/100.json', {
-            metabaseId: 100,
-            name: 'In',
-            description: null,
-            type: 'model',
-            databaseId: 42,
-            collectionId: 5,
-            archived: false,
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            resultMetadata: [],
-            collectionPath: ['A'],
-            referencedCardIds: [],
-            resolutionStatus: 'resolved',
-        });
-        await writeInline(dir, 'cards/200.json', {
-            metabaseId: 200,
-            name: 'Out',
-            description: null,
-            type: 'model',
-            databaseId: 42,
-            collectionId: 6,
-            archived: false,
-            resolvedSql: 'SELECT 1',
-            templateTags: [],
-            resultMetadata: [],
-            collectionPath: ['B'],
-            referencedCardIds: [],
-            resolutionStatus: 'resolved',
-        });
-    });
-    afterEach(async () => {
-        await rm(dir, { recursive: true, force: true });
-    });
-    const BASE_SYNC = {
-        metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-        metabaseDatabaseId: 42,
-        defaultTagNames: [],
-        mapping: {
-            metabaseDatabaseId: 42,
-            metabaseDatabaseName: 'Analytics',
-            metabaseEngine: 'postgres',
-            targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-        },
-    };
-    it('ALL includes every non-archived card on the matching database', async () => {
-        await writeInline(dir, 'sync-config.json', {
-            ...BASE_SYNC,
-            syncMode: 'ALL',
-            selections: [],
-        });
-        const result = await chunkMetabaseStagedDir(dir);
-        const allRawFiles = result.workUnits.flatMap((wu) => wu.rawFiles);
-        expect(allRawFiles).toContain('cards/100.json');
-        expect(allRawFiles).toContain('cards/200.json');
-    });
-    it('ONLY includes cards in selected collections; excludes the rest', async () => {
-        await writeInline(dir, 'sync-config.json', {
-            ...BASE_SYNC,
-            syncMode: 'ONLY',
-            selections: [{ selectionType: 'collection', metabaseObjectId: 5 }],
-        });
-        const result = await chunkMetabaseStagedDir(dir);
-        const allRawFiles = result.workUnits.flatMap((wu) => wu.rawFiles);
-        expect(allRawFiles).toContain('cards/100.json');
-        expect(allRawFiles).not.toContain('cards/200.json');
-    });
-    it('ONLY with no selections includes every matching card for old generated configs', async () => {
-        await writeInline(dir, 'sync-config.json', {
-            ...BASE_SYNC,
-            syncMode: 'ONLY',
-            selections: [],
-        });
-        const result = await chunkMetabaseStagedDir(dir);
-        const allRawFiles = result.workUnits.flatMap((wu) => wu.rawFiles);
-        expect(allRawFiles).toContain('cards/100.json');
-        expect(allRawFiles).toContain('cards/200.json');
-    });
-    it('EXCEPT excludes cards in selected collections; includes the rest', async () => {
-        await writeInline(dir, 'sync-config.json', {
-            ...BASE_SYNC,
-            syncMode: 'EXCEPT',
-            selections: [{ selectionType: 'collection', metabaseObjectId: 5 }],
-        });
-        const result = await chunkMetabaseStagedDir(dir);
-        const allRawFiles = result.workUnits.flatMap((wu) => wu.rawFiles);
-        expect(allRawFiles).not.toContain('cards/100.json');
-        expect(allRawFiles).toContain('cards/200.json');
-    });
-    it('lowercase syncMode is rejected at parse time', () => {
-        const parsed = stagedSyncConfigSchema.safeParse({
-            ...BASE_SYNC,
-            syncMode: 'all',
-            selections: [],
-        });
-        expect(parsed.success).toBe(false);
-    });
-});

package/dist/context/ingest/adapters/metabase/client-boundary.test.d.ts

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

package/dist/context/ingest/adapters/metabase/client-boundary.test.js

@@ -1,38 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-const metabaseDir = dirname(fileURLToPath(import.meta.url));
-async function readMetabaseFile(name) {
-    return readFile(join(metabaseDir, name), 'utf-8');
-}
-describe('KTX Metabase client boundary', () => {
-    it('keeps NestJS, server data-source base classes, and server-relative imports out of the KTX client', async () => {
-        const client = await readMetabaseFile('client.ts');
-        expect(client).not.toContain(`@${'nestjs'}`);
-        expect(client).not.toContain(`DataSource${'Client'}`);
-        expect(client).not.toContain(`../base/data-source-${'client'}`);
-        expect(client).not.toContain('../types');
-        expect(client).not.toContain('../../types/brand');
-    });
-    it('keeps proxy implementation code out of the KTX v1 client', async () => {
-        const client = await readMetabaseFile('client.ts');
-        expect(client).not.toContain(`network-${'proxy'}`);
-        expect(client).not.toContain(`ssh${'2'}`);
-        expect(client).not.toContain(`tail${'scale'}`);
-        expect(client).not.toContain('resolveNetworkProxy');
-        expect(client).not.toContain('establishProxy');
-        expect(client).not.toContain('executeProxiedRequest');
-        expect(client).not.toContain('originalHost');
-        expect(client).not.toContain('originalHostname');
-        expect(client).not.toContain('servername');
-    });
-    it('keeps the runtime config proxy-free in v1', async () => {
-        const port = await readMetabaseFile('client-port.ts');
-        const runtimeConfigBlock = port.match(/export interface MetabaseClientRuntimeConfig \{[\s\S]*?\n\}/)?.[0] ?? '';
-        expect(runtimeConfigBlock).toContain('apiUrl: string');
-        expect(runtimeConfigBlock).toContain('apiKey: string');
-        expect(runtimeConfigBlock).not.toContain('proxy');
-        expect(runtimeConfigBlock).not.toContain('networkProxy');
-    });
-});

package/dist/context/ingest/adapters/metabase/client-port.test.d.ts

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