@kaelio/ktx 0.4.1 → 0.6.0

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

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/lookml/fetch-report.d.ts

@@ -1,15 +0,0 @@
-import type { SourceFetchReport } from '../../types.js';
-import type { ParsedLookmlProject } from './parse.js';
-export declare const LOOKML_FETCH_REPORT_FILE = "lookml-fetch-report.json";
-export declare const LOOKML_MISMATCHED_MODELS_FILE = "lookml-mismatched-models.json";
-interface LookmlValidationArtifacts {
-    report: SourceFetchReport;
-    mismatchedModelNames: string[];
-}
-export declare function buildLookmlValidationArtifacts(project: ParsedLookmlProject, config: {
-    expectedLookerConnectionName: string | null;
-}): LookmlValidationArtifacts;
-export declare function writeLookmlValidationArtifacts(stagedDir: string, artifacts: LookmlValidationArtifacts): Promise<void>;
-export declare function readLookmlFetchReport(stagedDir: string): Promise<SourceFetchReport | null>;
-export declare function readLookmlMismatchedModelNames(stagedDir: string): Promise<Set<string>>;
-export {};

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/fetch-report.js

@@ -1,98 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import * as z from 'zod';
-export const LOOKML_FETCH_REPORT_FILE = 'lookml-fetch-report.json';
-export const LOOKML_MISMATCHED_MODELS_FILE = 'lookml-mismatched-models.json';
-const fetchIssueKindSchema = z.enum([
-    'unmapped_looker_connection',
-    'unparseable_sql_table_name',
-    'looker_template_unresolved',
-    'derived_table_not_supported',
-    'lookml_connection_mismatch',
-]);
-const fetchIssueSchema = z.object({
-    rawPath: z.string().min(1),
-    entityType: z.string().min(1),
-    entityId: z.string().nullable(),
-    severity: z.enum(['warning', 'error']),
-    statusCode: z.number().int().nullable(),
-    message: z.string().min(1),
-    retryRecommended: z.boolean(),
-    kind: fetchIssueKindSchema.optional(),
-    details: z.record(z.string(), z.unknown()).optional(),
-});
-const fetchReportSchema = z.object({
-    status: z.enum(['success', 'partial']),
-    retryRecommended: z.boolean(),
-    skipped: z.array(fetchIssueSchema),
-    warnings: z.array(fetchIssueSchema),
-});
-const mismatchedModelsSchema = z.object({
-    modelNames: z.array(z.string().min(1)).default([]),
-});
-export function buildLookmlValidationArtifacts(project, config) {
-    const expected = config.expectedLookerConnectionName;
-    if (!expected) {
-        return {
-            report: { status: 'success', retryRecommended: false, skipped: [], warnings: [] },
-            mismatchedModelNames: [],
-        };
-    }
-    const mismatched = project.models
-        .filter((model) => model.connectionName !== null && model.connectionName !== expected)
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const warnings = mismatched.map((model) => {
-        const declared = model.connectionName ?? '(none)';
-        return {
-            rawPath: model.path,
-            entityType: 'lookml_models',
-            entityId: model.name,
-            severity: 'warning',
-            statusCode: null,
-            message: `LookML model ${model.name} declares connection ${declared} but this warehouse expects ${expected}; SL writes are disabled for this model.`,
-            retryRecommended: false,
-            kind: 'lookml_connection_mismatch',
-            details: { model: model.name, declared, expected },
-        };
-    });
-    return {
-        report: {
-            status: warnings.length > 0 ? 'partial' : 'success',
-            retryRecommended: false,
-            skipped: [],
-            warnings,
-        },
-        mismatchedModelNames: mismatched.map((model) => model.name),
-    };
-}
-export async function writeLookmlValidationArtifacts(stagedDir, artifacts) {
-    const reportPath = join(stagedDir, LOOKML_FETCH_REPORT_FILE);
-    await mkdir(dirname(reportPath), { recursive: true });
-    await writeFile(reportPath, `${JSON.stringify(fetchReportSchema.parse(artifacts.report), null, 2)}\n`, 'utf-8');
-    await writeFile(join(stagedDir, LOOKML_MISMATCHED_MODELS_FILE), `${JSON.stringify({ modelNames: artifacts.mismatchedModelNames }, null, 2)}\n`, 'utf-8');
-}
-export async function readLookmlFetchReport(stagedDir) {
-    try {
-        const raw = await readFile(join(stagedDir, LOOKML_FETCH_REPORT_FILE), 'utf-8');
-        return fetchReportSchema.parse(JSON.parse(raw));
-    }
-    catch (error) {
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-            return null;
-        }
-        throw error;
-    }
-}
-export async function readLookmlMismatchedModelNames(stagedDir) {
-    try {
-        const raw = await readFile(join(stagedDir, LOOKML_MISMATCHED_MODELS_FILE), 'utf-8');
-        const parsed = mismatchedModelsSchema.parse(JSON.parse(raw));
-        return new Set(parsed.modelNames);
-    }
-    catch (error) {
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-            return new Set();
-        }
-        throw error;
-    }
-}

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

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/lookml/fetch.test.d.ts

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/lookml/graph.test.d.ts

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/lookml/lookml.adapter.test.d.ts

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/lookml/parse.test.d.ts

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

package/node_modules/@ktx/context/dist/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));
-    });
-});