@kaelio/ktx 0.5.0 → 0.7.0

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

@@ -1,213 +0,0 @@
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { chunkLookmlProject } from './chunk.js';
-import { parseLookmlStagedDir } from './parse.js';
-const FIXTURE_ROOT = join(__dirname, '../../../../test/fixtures/lookml');
-describe('chunkLookmlProject — first run', () => {
-    it('single-model bundle → 1 WU with model + all views in rawFiles', async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'single-model');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const result = chunkLookmlProject(project);
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('lookml-orders');
-        expect(wu.rawFiles.sort()).toEqual(['orders.model.lkml', 'views/customers.view.lkml', 'views/orders.view.lkml']);
-        expect(wu.peerFileIndex).toEqual([]);
-        expect(wu.dependencyPaths).toEqual([]);
-        expect(result.eviction).toBeUndefined();
-    });
-    it('multi-model bundle → 1 WU per model; shared view owned by lex-first model; others see it in dependencyPaths + peerFileIndex is pathless-index', async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const result = chunkLookmlProject(project);
-        expect(result.workUnits).toHaveLength(2);
-        const marketing = result.workUnits.find((wu) => wu.unitKey === 'lookml-marketing');
-        const orders = result.workUnits.find((wu) => wu.unitKey === 'lookml-orders');
-        expect(marketing).toBeDefined();
-        expect(orders).toBeDefined();
-        if (!marketing || !orders) {
-            throw new Error('expected marketing and orders work units');
-        }
-        // marketing sorts before orders → marketing owns shared_dims
-        expect(marketing.rawFiles).toContain('views/shared_dims.view.lkml');
-        expect(marketing.rawFiles).toContain('views/campaigns.view.lkml');
-        expect(marketing.rawFiles).toContain('marketing.model.lkml');
-        expect(marketing.rawFiles).not.toContain('views/orders.view.lkml');
-        expect(marketing.dependencyPaths).toEqual([]);
-        // orders does NOT own shared_dims — it's in dependencyPaths (read-only upstream).
-        expect(orders.rawFiles).not.toContain('views/shared_dims.view.lkml');
-        expect(orders.dependencyPaths).toEqual(['views/shared_dims.view.lkml']);
-        expect(orders.rawFiles).toContain('views/orders.view.lkml');
-        expect(orders.rawFiles).toContain('orders.model.lkml');
-        // Each WU's peerFileIndex lists the OTHER model's files (paths-only index).
-        expect(orders.peerFileIndex).toContain('marketing.model.lkml');
-        expect(orders.peerFileIndex).toContain('views/campaigns.view.lkml');
-        // Dependency paths should not be duplicated into peerFileIndex.
-        expect(orders.peerFileIndex).not.toContain('views/shared_dims.view.lkml');
-    });
-    it('extends-chain fixture: single WU contains base + orders + orders_ext; chain order visible via graph', async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'extends-chain');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const result = chunkLookmlProject(project);
-        // One model ("orders") includes views/*.view.lkml — so all three views land in its WU.
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('lookml-orders');
-        expect(wu.rawFiles.sort()).toEqual([
-            'orders.model.lkml',
-            'views/base.view.lkml',
-            'views/orders.view.lkml',
-            'views/orders_ext.view.lkml',
-        ]);
-        expect(wu.dependencyPaths).toEqual([]); // all ancestors already in rawFiles on first run
-        expect(wu.notes).toMatch(/orders/);
-    });
-    it('is deterministic: two calls on the same project return structurally identical WorkUnits', async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const r1 = chunkLookmlProject(project);
-        const r2 = chunkLookmlProject(project);
-        expect(r1.workUnits).toEqual(r2.workUnits);
-    });
-    it('unitKey is model-name-derived (stable across parse+chunk cycles and across re-syncs)', async () => {
-        const project = await parseLookmlStagedDir(join(FIXTURE_ROOT, 'multi-model'));
-        const { workUnits } = chunkLookmlProject(project);
-        expect(workUnits.map((wu) => wu.unitKey).sort()).toEqual(['lookml-marketing', 'lookml-orders']);
-    });
-    it('marks mismatched model WorkUnits as SL-disallowed and keeps wiki ingest enabled', () => {
-        const project = {
-            models: [
-                {
-                    path: 'b2b.model.lkml',
-                    name: 'b2b',
-                    includes: ['views/orders.view.lkml'],
-                    explores: ['orders'],
-                    connectionName: 'wrong_connection',
-                },
-            ],
-            views: [{ path: 'views/orders.view.lkml', name: 'orders', extendsFrom: [], rawSqlTableName: 'public.orders' }],
-            dashboards: [],
-            allPaths: ['b2b.model.lkml', 'views/orders.view.lkml'],
-        };
-        const result = chunkLookmlProject(project, { mismatchedModelNames: new Set(['b2b']) });
-        const wu = result.workUnits[0];
-        expect(wu.unitKey).toBe('lookml-b2b');
-        expect(wu.rawFiles).toEqual(['b2b.model.lkml', 'views/orders.view.lkml']);
-        expect(wu.slDisallowed).toBe(true);
-        expect(wu.slDisallowedReason).toBe('lookml_connection_mismatch');
-        expect(wu.notes).toContain('[LOOKML SL WRITES DISALLOWED]');
-        expect(wu.notes).toContain('reason: lookml_connection_mismatch');
-        expect(wu.notes).toContain('Do not call sl_write_source or sl_edit_source for this WorkUnit.');
-    });
-});
-describe('chunkLookmlProject — re-sync', () => {
-    it("modified file in one model only emits that model's WU", async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const result = chunkLookmlProject(project, {
-            diffSet: {
-                added: [],
-                modified: ['views/campaigns.view.lkml'],
-                deleted: [],
-                unchanged: [
-                    'marketing.model.lkml',
-                    'orders.model.lkml',
-                    'views/orders.view.lkml',
-                    'views/shared_dims.view.lkml',
-                ],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].unitKey).toBe('lookml-marketing');
-    });
-    it("added file under a model emits that model's WU with the new path in rawFiles", async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'single-model');
-        const project = await parseLookmlStagedDir(stagedDir);
-        const result = chunkLookmlProject(project, {
-            diffSet: {
-                added: ['views/customers.view.lkml'],
-                modified: [],
-                deleted: [],
-                unchanged: ['orders.model.lkml', 'views/orders.view.lkml'],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].rawFiles).toContain('views/customers.view.lkml');
-    });
-    it('widens dependencyPaths with transitive extends ancestors on re-sync', async () => {
-        const stagedDir = join(FIXTURE_ROOT, 'extends-chain');
-        const project = await parseLookmlStagedDir(stagedDir);
-        // Only orders_ext is touched; base and orders are upstream ancestors.
-        // Because the single-model WU's rawFiles ALREADY include all three on first run,
-        // they remain in rawFiles — dependencyPaths stays empty. Widening matters when
-        // re-sync drops some files from rawFiles, which doesn't apply for a monolithic
-        // single-model WU. Assert the baseline invariant.
-        const result = chunkLookmlProject(project, {
-            diffSet: {
-                added: [],
-                modified: ['views/orders_ext.view.lkml'],
-                deleted: [],
-                unchanged: ['orders.model.lkml', 'views/base.view.lkml', 'views/orders.view.lkml'],
-            },
-        });
-        expect(result.workUnits).toHaveLength(1);
-        const wu = result.workUnits[0];
-        expect(wu.rawFiles).toContain('views/orders_ext.view.lkml');
-        // Ancestors already in rawFiles → not duplicated into dependencyPaths.
-        expect(wu.dependencyPaths).toEqual([]);
-    });
-    it('widens dependencyPaths when an ancestor is OUTSIDE the WU (synthesized cross-model case)', () => {
-        // Synthesize a scenario in-memory: two models, "a" owns base.view.lkml,
-        // "b" owns derived.view.lkml which extends base. A diff that only touches
-        // derived.view.lkml should widen b's WU with base.view.lkml in dependencyPaths
-        // if base lives outside b's rawFiles. In practice with the current emit rules,
-        // base.view.lkml would already be in dependencyPaths because model b lists
-        // base.view.lkml under its `include:`. Here we confirm the widening is idempotent.
-        const project = {
-            models: [
-                { path: 'a.model.lkml', name: 'a', includes: ['views/base.view.lkml'], explores: [], connectionName: null },
-                {
-                    path: 'b.model.lkml',
-                    name: 'b',
-                    includes: ['views/base.view.lkml', 'views/derived.view.lkml'],
-                    explores: [],
-                    connectionName: null,
-                },
-            ],
-            views: [
-                { path: 'views/base.view.lkml', name: 'base', extendsFrom: [], rawSqlTableName: null },
-                { path: 'views/derived.view.lkml', name: 'derived', extendsFrom: ['base'], rawSqlTableName: null },
-            ],
-            dashboards: [],
-            allPaths: ['a.model.lkml', 'b.model.lkml', 'views/base.view.lkml', 'views/derived.view.lkml'],
-        };
-        const result = chunkLookmlProject(project, {
-            diffSet: {
-                added: [],
-                modified: ['views/derived.view.lkml'],
-                deleted: [],
-                unchanged: ['a.model.lkml', 'b.model.lkml', 'views/base.view.lkml'],
-            },
-        });
-        const b = result.workUnits.find((wu) => wu.unitKey === 'lookml-b');
-        expect(b).toBeDefined();
-        if (!b) {
-            throw new Error('expected lookml-b work unit');
-        }
-        expect(b.dependencyPaths).toContain('views/base.view.lkml');
-    });
-    it('passes through diffSet.deleted as an EvictionUnit', async () => {
-        const project = await parseLookmlStagedDir(join(FIXTURE_ROOT, 'single-model'));
-        const result = chunkLookmlProject(project, {
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: ['views/zombie.view.lkml'],
-                unchanged: ['orders.model.lkml', 'views/customers.view.lkml', 'views/orders.view.lkml'],
-            },
-        });
-        expect(result.eviction).toEqual({ deletedRawPaths: ['views/zombie.view.lkml'] });
-        // No WU emitted because no current files are touched.
-        expect(result.workUnits).toEqual([]);
-    });
-});

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

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

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

@@ -1,37 +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 { detectLookmlStagedDir } from './detect.js';
-describe('detectLookmlStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'lkml-detect-'));
-    });
-    afterEach(async () => rm(stagedDir, { recursive: true, force: true }));
-    it('returns true when a .model.lkml is present at root', async () => {
-        await writeFile(join(stagedDir, 'orders.model.lkml'), 'include: "views/*"\n', 'utf-8');
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns true when only a .view.lkml is present (no model)', async () => {
-        await writeFile(join(stagedDir, 'x.view.lkml'), 'view: x {}\n', 'utf-8');
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns true when .lkml files are nested under any subdirectory', async () => {
-        await mkdir(join(stagedDir, 'nested', 'deeper'), { recursive: true });
-        await writeFile(join(stagedDir, 'nested', 'deeper', 'x.view.lkml'), 'view: x {}\n', 'utf-8');
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(true);
-    });
-    it('accepts the .lookml extension as well as .lkml', async () => {
-        await writeFile(join(stagedDir, 'x.view.lookml'), 'view: x {}\n', 'utf-8');
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns false for a bundle with no .lkml files at all', async () => {
-        await writeFile(join(stagedDir, 'README.md'), '# hi\n', 'utf-8');
-        await writeFile(join(stagedDir, 'config.yaml'), 'a: 1\n', 'utf-8');
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false for an empty directory', async () => {
-        expect(await detectLookmlStagedDir(stagedDir)).toBe(false);
-    });
-});

package/dist/context/ingest/adapters/lookml/fetch-report.test.d.ts

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

package/dist/context/ingest/adapters/lookml/fetch-report.test.js

@@ -1,82 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LOOKML_FETCH_REPORT_FILE, LOOKML_MISMATCHED_MODELS_FILE, buildLookmlValidationArtifacts, readLookmlFetchReport, readLookmlMismatchedModelNames, writeLookmlValidationArtifacts, } from './fetch-report.js';
-function project(models) {
-    return { models, views: [], dashboards: [], allPaths: models.map((m) => m.path) };
-}
-describe('LookML validation fetch report', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'lookml-report-'));
-    });
-    afterEach(async () => rm(stagedDir, { recursive: true, force: true }));
-    it('emits partial warning artifacts for mismatched model connection names', async () => {
-        const artifacts = buildLookmlValidationArtifacts(project([
-            {
-                path: 'b2b.model.lkml',
-                name: 'b2b',
-                includes: [],
-                explores: ['orders'],
-                connectionName: 'staging_pg',
-            },
-            {
-                path: 'finance.model.lkml',
-                name: 'finance',
-                includes: [],
-                explores: ['revenue'],
-                connectionName: 'b2b_sandbox_bq',
-            },
-        ]), { expectedLookerConnectionName: 'b2b_sandbox_bq' });
-        expect(artifacts.mismatchedModelNames).toEqual(['b2b']);
-        expect(artifacts.report.status).toBe('partial');
-        expect(artifacts.report.warnings).toEqual([
-            {
-                rawPath: 'b2b.model.lkml',
-                entityType: 'lookml_models',
-                entityId: 'b2b',
-                severity: 'warning',
-                statusCode: null,
-                message: 'LookML model b2b declares connection staging_pg but this warehouse expects b2b_sandbox_bq; SL writes are disabled for this model.',
-                retryRecommended: false,
-                kind: 'lookml_connection_mismatch',
-                details: { model: 'b2b', declared: 'staging_pg', expected: 'b2b_sandbox_bq' },
-            },
-        ]);
-    });
-    it('emits success when no expected connection is configured', () => {
-        const artifacts = buildLookmlValidationArtifacts(project([
-            {
-                path: 'b2b.model.lkml',
-                name: 'b2b',
-                includes: [],
-                explores: [],
-                connectionName: 'staging_pg',
-            },
-        ]), { expectedLookerConnectionName: null });
-        expect(artifacts.mismatchedModelNames).toEqual([]);
-        expect(artifacts.report).toEqual({
-            status: 'success',
-            retryRecommended: false,
-            skipped: [],
-            warnings: [],
-        });
-    });
-    it('round-trips the fetch report and mismatched model sidecar', async () => {
-        const artifacts = buildLookmlValidationArtifacts(project([
-            {
-                path: 'orders.model.lkml',
-                name: 'orders',
-                includes: [],
-                explores: [],
-                connectionName: 'wrong',
-            },
-        ]), { expectedLookerConnectionName: 'expected' });
-        await writeLookmlValidationArtifacts(stagedDir, artifacts);
-        await expect(readFile(join(stagedDir, LOOKML_FETCH_REPORT_FILE), 'utf-8')).resolves.toContain('lookml_connection_mismatch');
-        await expect(readFile(join(stagedDir, LOOKML_MISMATCHED_MODELS_FILE), 'utf-8')).resolves.toContain('orders');
-        await expect(readLookmlFetchReport(stagedDir)).resolves.toEqual(artifacts.report);
-        await expect(readLookmlMismatchedModelNames(stagedDir)).resolves.toEqual(new Set(['orders']));
-    });
-});

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

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

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

@@ -1,121 +0,0 @@
-import { 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 { fetchLookmlRepo } from './fetch.js';
-const FIXTURE_ROOT = join(__dirname, '../../../../test/fixtures/lookml');
-function pullConfig(overrides) {
-    return {
-        branch: 'main',
-        path: null,
-        authToken: null,
-        expectedLookerConnectionName: null,
-        parsedTargetTables: {},
-        ...overrides,
-    };
-}
-describe('fetchLookmlRepo', () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await mkdtemp(join(tmpdir(), 'fetch-lookml-'));
-    });
-    afterEach(async () => rm(tmpRoot, { recursive: true, force: true }));
-    it('clones a local file:// repo and materializes only .lkml/.lookml files into stagedDir', async () => {
-        const repo = await makeLocalGitRepo(join(FIXTURE_ROOT, 'single-model'), join(tmpRoot, 'origin'));
-        // Add a non-LookML file to prove we filter it out.
-        await repo.writeFile('README.md', '# readme\n');
-        await repo.commit('add readme');
-        const stagedDir = join(tmpRoot, 'staged');
-        const cacheDir = join(tmpRoot, 'cache', 'conn-1');
-        await mkdir(stagedDir, { recursive: true });
-        const result = await fetchLookmlRepo({
-            config: pullConfig({ repoUrl: repo.repoUrl }),
-            cacheDir,
-            stagedDir,
-        });
-        expect(result.filesCopied).toBe(3); // orders.model.lkml + 2 views
-        expect(result.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(stagedDir, 'orders.model.lkml'), 'utf-8')).resolves.toMatch(/connection:/);
-        await expect(readFile(join(stagedDir, 'views', 'orders.view.lkml'), 'utf-8')).resolves.toMatch(/view: orders/);
-        // README.md is present in the cache but NOT in stagedDir.
-        await expect(readFile(join(stagedDir, 'README.md'), 'utf-8')).rejects.toThrow();
-        await expect(readFile(join(cacheDir, 'README.md'), 'utf-8')).resolves.toMatch(/readme/);
-    });
-    it('pulls an existing cache dir (second call) and surfaces the new commit', async () => {
-        const repo = await makeLocalGitRepo(join(FIXTURE_ROOT, 'single-model'), join(tmpRoot, 'origin'));
-        const stagedDir1 = join(tmpRoot, 'staged-1');
-        const stagedDir2 = join(tmpRoot, 'staged-2');
-        const cacheDir = join(tmpRoot, 'cache', 'conn-1');
-        await mkdir(stagedDir1, { recursive: true });
-        await mkdir(stagedDir2, { recursive: true });
-        const r1 = await fetchLookmlRepo({
-            config: pullConfig({ repoUrl: repo.repoUrl }),
-            cacheDir,
-            stagedDir: stagedDir1,
-        });
-        // Commit a new revision in the origin — a modified view.
-        await repo.writeFile('views/orders.view.lkml', 'view: orders { sql_table_name: public.orders_v2 ;; }\n');
-        await repo.commit('bump');
-        const r2 = await fetchLookmlRepo({
-            config: pullConfig({ repoUrl: repo.repoUrl }),
-            cacheDir,
-            stagedDir: stagedDir2,
-        });
-        expect(r2.commitHash).not.toBe(r1.commitHash);
-        await expect(readFile(join(stagedDir2, 'views', 'orders.view.lkml'), 'utf-8')).resolves.toMatch(/orders_v2/);
-    });
-    it('respects config.path — only files under that subtree land in stagedDir', async () => {
-        // Build a multi-subdir repo: models/... + views/...
-        const originRoot = join(tmpRoot, 'origin');
-        await mkdir(originRoot, { recursive: true });
-        await mkdir(join(originRoot, 'fixture-src', 'models'), { recursive: true });
-        await mkdir(join(originRoot, 'fixture-src', 'views'), { recursive: true });
-        await writeFile(join(originRoot, 'fixture-src', 'models', 'orders.model.lkml'), 'connection: "c"\n', 'utf-8');
-        await writeFile(join(originRoot, 'fixture-src', 'views', 'orders.view.lkml'), 'view: orders {}\n', 'utf-8');
-        const repo = await makeLocalGitRepo(join(originRoot, 'fixture-src'), join(originRoot, 'git'));
-        const stagedDir = join(tmpRoot, 'staged');
-        const cacheDir = join(tmpRoot, 'cache', 'conn-path');
-        await mkdir(stagedDir, { recursive: true });
-        const result = await fetchLookmlRepo({
-            config: pullConfig({ repoUrl: repo.repoUrl, path: 'views' }),
-            cacheDir,
-            stagedDir,
-        });
-        expect(result.filesCopied).toBe(1);
-        await expect(readFile(join(stagedDir, 'orders.view.lkml'), 'utf-8')).resolves.toMatch(/view: orders/);
-        // The model under `models/` is NOT copied because we scoped to `views/`.
-        await expect(readFile(join(stagedDir, 'orders.model.lkml'), 'utf-8')).rejects.toThrow();
-    });
-    it('falls back to fresh clone when the cache dir is corrupt', async () => {
-        const repo = await makeLocalGitRepo(join(FIXTURE_ROOT, 'single-model'), join(tmpRoot, 'origin'));
-        const stagedDir = join(tmpRoot, 'staged');
-        const cacheDir = join(tmpRoot, 'cache', 'conn-bad');
-        await mkdir(stagedDir, { recursive: true });
-        // Pre-create a cacheDir that looks like a git repo but is corrupt.
-        await mkdir(join(cacheDir, '.git'), { recursive: true });
-        await writeFile(join(cacheDir, '.git', 'HEAD'), 'garbage\n', 'utf-8');
-        const result = await fetchLookmlRepo({
-            config: pullConfig({ repoUrl: repo.repoUrl }),
-            cacheDir,
-            stagedDir,
-        });
-        expect(result.filesCopied).toBeGreaterThan(0);
-    });
-    it('sanitizes auth tokens out of error messages when clone fails', async () => {
-        const stagedDir = join(tmpRoot, 'staged');
-        const cacheDir = join(tmpRoot, 'cache', 'conn-bad-url');
-        await mkdir(stagedDir, { recursive: true });
-        await expect(fetchLookmlRepo({
-            config: pullConfig({
-                repoUrl: 'http://definitely-not-a-real-host.test/r.git',
-                authToken: 'supersecret-token',
-            }),
-            cacheDir,
-            stagedDir,
-        })).rejects.toThrow(
-        // Error is thrown with sanitized message — the token is replaced by '***'.
-        // The exact message depends on simple-git's failure mode; we assert the token does NOT appear.
-        expect.objectContaining({ message: expect.not.stringContaining('supersecret-token') }));
-    });
-});

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

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

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

@@ -1,105 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildLookmlGraph } from './graph.js';
-const mkProject = (overrides) => ({
-    dashboards: [],
-    allPaths: [],
-    ...overrides,
-    models: (overrides.models ?? []).map((model) => ({ connectionName: null, ...model })),
-    views: (overrides.views ?? []).map((view) => ({ rawSqlTableName: null, ...view })),
-});
-describe('buildLookmlGraph', () => {
-    it('assigns a single model as owner of all its included views', () => {
-        const project = mkProject({
-            models: [{ path: 'orders.model.lkml', name: 'orders', includes: ['views/*.view.lkml'], explores: ['orders'] }],
-            views: [
-                { path: 'views/orders.view.lkml', name: 'orders', extendsFrom: [] },
-                { path: 'views/customers.view.lkml', name: 'customers', extendsFrom: [] },
-            ],
-            allPaths: ['orders.model.lkml', 'views/customers.view.lkml', 'views/orders.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        expect(graph.ownerByViewPath.get('views/orders.view.lkml')).toBe('orders');
-        expect(graph.ownerByViewPath.get('views/customers.view.lkml')).toBe('orders');
-        expect(graph.viewsIncludedByModel.get('orders')?.sort()).toEqual([
-            'views/customers.view.lkml',
-            'views/orders.view.lkml',
-        ]);
-    });
-    it('assigns shared views to the lexicographically-first model that includes them', () => {
-        const project = mkProject({
-            models: [
-                { path: 'marketing.model.lkml', name: 'marketing', includes: ['views/shared.view.lkml'], explores: [] },
-                {
-                    path: 'orders.model.lkml',
-                    name: 'orders',
-                    includes: ['views/shared.view.lkml', 'views/orders.view.lkml'],
-                    explores: [],
-                },
-            ],
-            views: [
-                { path: 'views/shared.view.lkml', name: 'shared', extendsFrom: [] },
-                { path: 'views/orders.view.lkml', name: 'orders', extendsFrom: [] },
-            ],
-            allPaths: ['marketing.model.lkml', 'orders.model.lkml', 'views/orders.view.lkml', 'views/shared.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        // "marketing" sorts before "orders", so marketing owns the shared view.
-        expect(graph.ownerByViewPath.get('views/shared.view.lkml')).toBe('marketing');
-        expect(graph.ownerByViewPath.get('views/orders.view.lkml')).toBe('orders');
-        // Both models list the shared view in their include set:
-        expect(graph.includersByViewPath.get('views/shared.view.lkml')?.sort()).toEqual(['marketing', 'orders']);
-    });
-    it('resolves transitive extends chains into dependency paths', () => {
-        const project = mkProject({
-            models: [{ path: 'orders.model.lkml', name: 'orders', includes: ['views/*.view.lkml'], explores: [] }],
-            views: [
-                { path: 'views/base.view.lkml', name: 'base', extendsFrom: [] },
-                { path: 'views/orders.view.lkml', name: 'orders', extendsFrom: ['base'] },
-                { path: 'views/orders_ext.view.lkml', name: 'orders_ext', extendsFrom: ['orders'] },
-            ],
-            allPaths: ['orders.model.lkml', 'views/base.view.lkml', 'views/orders.view.lkml', 'views/orders_ext.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        expect(graph.extendsAncestorsByViewName.get('orders_ext')?.sort()).toEqual(['base', 'orders']);
-        expect(graph.extendsAncestorsByViewName.get('orders')?.sort()).toEqual(['base']);
-        expect(graph.extendsAncestorsByViewName.get('base')?.sort()).toEqual([]);
-    });
-    it('resolves glob-style include patterns (views/*.view.lkml) against allPaths', () => {
-        const project = mkProject({
-            models: [{ path: 'orders.model.lkml', name: 'orders', includes: ['views/*.view.lkml'], explores: [] }],
-            views: [
-                { path: 'views/a.view.lkml', name: 'a', extendsFrom: [] },
-                { path: 'views/sub/b.view.lkml', name: 'b', extendsFrom: [] },
-            ],
-            allPaths: ['orders.model.lkml', 'views/a.view.lkml', 'views/sub/b.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        // Single-star glob matches one path segment — "views/sub/b.view.lkml" is NOT matched.
-        expect(graph.viewsIncludedByModel.get('orders')?.sort()).toEqual(['views/a.view.lkml']);
-    });
-    it('resolves double-star include patterns (views/**/*.view.lkml) recursively', () => {
-        const project = mkProject({
-            models: [{ path: 'orders.model.lkml', name: 'orders', includes: ['views/**/*.view.lkml'], explores: [] }],
-            views: [
-                { path: 'views/a.view.lkml', name: 'a', extendsFrom: [] },
-                { path: 'views/sub/b.view.lkml', name: 'b', extendsFrom: [] },
-            ],
-            allPaths: ['orders.model.lkml', 'views/a.view.lkml', 'views/sub/b.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        expect(graph.viewsIncludedByModel.get('orders')?.sort()).toEqual(['views/a.view.lkml', 'views/sub/b.view.lkml']);
-    });
-    it('leaves a view ownerless when no model includes it', () => {
-        const project = mkProject({
-            models: [{ path: 'other.model.lkml', name: 'other', includes: ['views/included.view.lkml'], explores: [] }],
-            views: [
-                { path: 'views/included.view.lkml', name: 'included', extendsFrom: [] },
-                { path: 'views/orphan.view.lkml', name: 'orphan', extendsFrom: [] },
-            ],
-            allPaths: ['other.model.lkml', 'views/included.view.lkml', 'views/orphan.view.lkml'],
-        });
-        const graph = buildLookmlGraph(project);
-        expect(graph.ownerByViewPath.has('views/orphan.view.lkml')).toBe(false);
-        expect(graph.ownerByViewPath.get('views/included.view.lkml')).toBe('other');
-    });
-});

package/dist/context/ingest/adapters/lookml/lookml.adapter.test.d.ts

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

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

@@ -1,49 +0,0 @@
-import { 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 { LOOKML_FETCH_REPORT_FILE } from './fetch-report.js';
-import { LookmlSourceAdapter } from './lookml.adapter.js';
-describe('LookmlSourceAdapter validation sidecars', () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await mkdtemp(join(tmpdir(), 'lookml-adapter-'));
-    });
-    afterEach(async () => rm(tmpRoot, { recursive: true, force: true }));
-    it('returns configured target warehouse connection ids', async () => {
-        const adapter = new LookmlSourceAdapter({
-            homeDir: join(tmpRoot, 'home'),
-            targetConnectionIds: ['warehouse', 'analytics', 'warehouse'],
-        });
-        await expect(adapter.listTargetConnectionIds?.(join(tmpRoot, 'staged'))).resolves.toEqual([
-            'analytics',
-            'warehouse',
-        ]);
-    });
-    it('writes a partial fetch report and marks mismatched chunks as SL-disallowed', async () => {
-        const originRoot = join(tmpRoot, 'origin-src');
-        await mkdir(join(originRoot, 'views'), { recursive: true });
-        await writeFile(join(originRoot, 'b2b.model.lkml'), 'connection: "wrong_connection"\ninclude: "views/*.view.lkml"\nexplore: orders {}\n', 'utf-8');
-        await writeFile(join(originRoot, 'views', 'orders.view.lkml'), 'view: orders { sql_table_name: public.orders ;; }\n', 'utf-8');
-        const repo = await makeLocalGitRepo(originRoot, join(tmpRoot, 'origin'));
-        const stagedDir = join(tmpRoot, 'staged');
-        await mkdir(stagedDir, { recursive: true });
-        const adapter = new LookmlSourceAdapter({ homeDir: join(tmpRoot, 'home') });
-        await adapter.fetch({
-            repoUrl: repo.repoUrl,
-            branch: 'main',
-            path: null,
-            authToken: null,
-            expectedLookerConnectionName: 'expected_connection',
-        }, stagedDir, { connectionId: '11111111-1111-4111-8111-111111111111', sourceKey: 'lookml' });
-        await expect(readFile(join(stagedDir, LOOKML_FETCH_REPORT_FILE), 'utf-8')).resolves.toContain('lookml_connection_mismatch');
-        await expect(adapter.readFetchReport(stagedDir)).resolves.toMatchObject({ status: 'partial' });
-        const chunks = await adapter.chunk(stagedDir);
-        expect(chunks.workUnits[0]).toMatchObject({
-            unitKey: 'lookml-b2b',
-            slDisallowed: true,
-            slDisallowedReason: 'lookml_connection_mismatch',
-        });
-    });
-});

package/dist/context/ingest/adapters/lookml/parse.test.d.ts

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