@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/adapters/looker/local-runtime-store.test.js

@@ -1,106 +0,0 @@
-import { mkdtemp } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { LocalLookerRuntimeStore } from './local-runtime-store.js';
-describe('LocalLookerRuntimeStore', () => {
-    async function store() {
-        const dir = await mkdtemp(join(tmpdir(), 'ktx-looker-store-'));
-        return new LocalLookerRuntimeStore({
-            dbPath: join(dir, 'db.sqlite'),
-            now: () => new Date('2026-05-05T12:00:00.000Z'),
-        });
-    }
-    it('stores cursors and connection mappings', async () => {
-        const local = await store();
-        await local.setCursors('prod-looker', {
-            dashboardsLastSyncedAt: '2026-05-01T00:00:00.000Z',
-            looksLastSyncedAt: null,
-        });
-        await local.upsertConnectionMapping({
-            lookerConnectionId: 'prod-looker',
-            lookerConnectionName: 'bq_reporting',
-            ktxConnectionId: 'prod-warehouse',
-            source: 'cli',
-        });
-        await expect(local.readCursors('prod-looker')).resolves.toEqual({
-            dashboardsLastSyncedAt: '2026-05-01T00:00:00.000Z',
-            looksLastSyncedAt: null,
-        });
-        await expect(local.readMappings('prod-looker')).resolves.toEqual([
-            {
-                lookerConnectionName: 'bq_reporting',
-                ktxConnectionId: 'prod-warehouse',
-                lookerHost: null,
-                lookerDatabase: null,
-                lookerDialect: null,
-            },
-        ]);
-    });
-    it('refreshes discovered metadata without dropping local targets', async () => {
-        const local = await store();
-        await local.upsertConnectionMapping({
-            lookerConnectionId: 'prod-looker',
-            lookerConnectionName: 'bq_reporting',
-            ktxConnectionId: 'prod-warehouse',
-            source: 'cli',
-        });
-        await local.refreshDiscoveredConnections({
-            lookerConnectionId: 'prod-looker',
-            discovered: [
-                {
-                    name: 'bq_reporting',
-                    host: 'bigquery.googleapis.com',
-                    database: 'analytics',
-                    schema: null,
-                    dialect: 'bigquery_standard_sql',
-                },
-            ],
-        });
-        await expect(local.listConnectionMappings('prod-looker')).resolves.toEqual([
-            {
-                lookerConnectionName: 'bq_reporting',
-                ktxConnectionId: 'prod-warehouse',
-                lookerHost: 'bigquery.googleapis.com',
-                lookerDatabase: 'analytics',
-                lookerDialect: 'bigquery_standard_sql',
-                source: 'refresh',
-            },
-        ]);
-    });
-    it('applies yaml mapping intent while preserving refresh metadata and cli overrides', async () => {
-        const local = await store();
-        await local.refreshDiscoveredConnections({
-            lookerConnectionId: 'prod-looker',
-            discovered: [{ name: 'analytics', host: 'looker-db.test', database: 'warehouse', schema: null, dialect: 'postgres' }],
-        });
-        await local.upsertConnectionMapping({
-            lookerConnectionId: 'prod-looker',
-            lookerConnectionName: 'manual',
-            ktxConnectionId: 'cli-warehouse',
-            source: 'cli',
-        });
-        await local.applyYamlBootstrap({
-            lookerConnectionId: 'prod-looker',
-            mappings: [
-                { lookerConnectionName: 'analytics', ktxConnectionId: 'yaml-warehouse' },
-                { lookerConnectionName: 'manual', ktxConnectionId: 'yaml-warehouse' },
-            ],
-        });
-        await expect(local.listConnectionMappings('prod-looker')).resolves.toMatchObject([
-            {
-                lookerConnectionName: 'analytics',
-                ktxConnectionId: 'yaml-warehouse',
-                lookerHost: 'looker-db.test',
-                lookerDatabase: 'warehouse',
-                lookerDialect: 'postgres',
-                source: 'ktx.yaml',
-            },
-            {
-                lookerConnectionName: 'manual',
-                ktxConnectionId: 'cli-warehouse',
-                source: 'cli',
-            },
-        ]);
-    });
-});

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

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

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

@@ -1,99 +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, vi } from 'vitest';
-import { LookerSourceAdapter } from './looker.adapter.js';
-const connectionId = '11111111-1111-4111-8111-111111111111';
-function makeClient() {
-    return {
-        listDashboards: vi.fn().mockResolvedValue([]),
-        getDashboard: vi.fn(),
-        listLooks: vi.fn().mockResolvedValue([]),
-        getLook: vi.fn(),
-        listFolders: vi.fn().mockResolvedValue({ folders: [] }),
-        listUsers: vi.fn().mockResolvedValue([]),
-        listGroups: vi.fn().mockResolvedValue([]),
-        listLookmlModels: vi.fn().mockResolvedValue({
-            models: [{ name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] }],
-        }),
-        getExplore: vi.fn().mockResolvedValue({
-            modelName: 'b2b',
-            exploreName: 'sales_pipeline',
-            label: 'Sales Pipeline',
-            description: null,
-            fields: { dimensions: [], measures: [] },
-            joins: [],
-        }),
-    };
-}
-describe('LookerSourceAdapter', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'looker-adapter-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('exposes source="looker" and skillNames=["looker_ingest"]', () => {
-        const adapter = new LookerSourceAdapter({ clientFactory: { createClient: () => makeClient() } });
-        expect(adapter.source).toBe('looker');
-        expect(adapter.skillNames).toEqual(['looker_ingest']);
-    });
-    it('enables context evidence indexing and delegates triage signals', async () => {
-        const adapter = new LookerSourceAdapter({ clientFactory: { createClient: () => makeClient() } });
-        expect(adapter.evidenceIndexing).toBe('documents');
-        expect(adapter.triageSupported).toBe(true);
-        await expect(adapter.getTriageSignals?.(stagedDir, 'looker:dashboard:10')).resolves.toMatchObject({
-            objectType: 'looker_dashboard',
-        });
-    });
-    it('fetches, detects, and chunks a runtime bundle through the composed adapter', async () => {
-        const adapter = new LookerSourceAdapter({
-            clientFactory: { createClient: vi.fn().mockResolvedValue(makeClient()) },
-            now: () => new Date('2026-04-30T12:30:00.000Z'),
-        });
-        await mkdir(stagedDir, { recursive: true });
-        await adapter.fetch({ lookerConnectionId: connectionId }, stagedDir, { connectionId, sourceKey: 'looker' });
-        expect(await adapter.detect(stagedDir)).toBe(true);
-        expect(await readFile(join(stagedDir, 'explores/b2b/sales_pipeline.json'), 'utf-8')).toContain('sales_pipeline');
-        const result = await adapter.chunk(stagedDir);
-        expect(result.workUnits.map((wu) => wu.unitKey)).toEqual(['looker-explore-b2b-sales_pipeline']);
-    });
-    it('passes pull success notifications to the server callback', async () => {
-        const onPullSucceeded = vi.fn().mockResolvedValue(undefined);
-        const adapter = new LookerSourceAdapter({
-            clientFactory: { createClient: () => makeClient() },
-            onPullSucceeded,
-        });
-        const completedAt = new Date('2026-04-30T12:00:00.000Z');
-        await adapter.onPullSucceeded({
-            connectionId,
-            sourceKey: 'looker',
-            syncId: 'sync-1',
-            trigger: 'scheduled_pull',
-            completedAt,
-            stagedDir: '/tmp/staged',
-        });
-        expect(onPullSucceeded).toHaveBeenCalledWith({
-            connectionId,
-            sourceKey: 'looker',
-            syncId: 'sync-1',
-            trigger: 'scheduled_pull',
-            completedAt,
-            stagedDir: '/tmp/staged',
-        });
-    });
-    it('describes incremental fetch scope from the staged scope file', async () => {
-        await mkdir(join(stagedDir, 'dashboards'), { recursive: true });
-        await writeFile(join(stagedDir, 'looker-scope.json'), JSON.stringify({
-            mode: 'incremental',
-            knownCurrentRawPaths: ['dashboards/10.json', 'dashboards/11.json'],
-            fetchedRawPaths: ['dashboards/11.json'],
-        }, null, 2));
-        const adapter = new LookerSourceAdapter({ clientFactory: { createClient: () => makeClient() } });
-        const scope = await adapter.describeScope(stagedDir);
-        expect(scope.isPathInScope('dashboards/10.json')).toBe(false);
-        expect(scope.isPathInScope('dashboards/11.json')).toBe(true);
-        expect(scope.isPathInScope('dashboards/12.json')).toBe(true);
-    });
-});

package/dist/context/ingest/adapters/looker/mapping.test.d.ts

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

package/dist/context/ingest/adapters/looker/mapping.test.js

@@ -1,334 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { buildLookerPullConfigFromInputs, collectExploreParseItems, computeLookerMappingDrift, discoverLookerConnections, lookerDialectToConnectionType, projectParsedIdentifier, refreshLookerMappingPlaceholders, sqlglotDialectForConnectionType, suggestKtxConnectionForLookerConnection, validateLookerMappings, validateLookerWarehouseTarget, } from './mapping.js';
-const liveConnections = [
-    {
-        name: 'b2b_sandbox_bq',
-        host: 'warehouse.example.com',
-        database: 'analytics',
-        schema: null,
-        dialect: 'bigquery_standard_sql',
-    },
-    {
-        name: 'pg_runtime',
-        host: 'pg.internal:5432',
-        database: 'app',
-        schema: 'public',
-        dialect: 'postgres',
-    },
-];
-const mappedExplore = {
-    modelName: 'b2b',
-    exploreName: 'sales_pipeline',
-    label: 'Sales Pipeline',
-    description: null,
-    rawSqlTableName: 'proj.analytics.opportunities AS opportunities',
-    connectionName: 'b2b_sandbox_bq',
-    viewName: 'opportunities',
-    fields: { dimensions: [], measures: [] },
-    joins: [
-        {
-            name: 'accounts',
-            type: 'left_outer',
-            relationship: 'many_to_one',
-            rawSqlTableName: 'proj.analytics.accounts',
-            sqlOn: null,
-            from: null,
-            targetTable: null,
-        },
-    ],
-    targetWarehouseConnectionId: null,
-    targetTable: null,
-};
-const models = {
-    models: [{ name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] }],
-};
-describe('discoverLookerConnections', () => {
-    it('delegates to the runtime client connection discovery method', async () => {
-        const client = { listLookerConnections: vi.fn().mockResolvedValue(liveConnections) };
-        await expect(discoverLookerConnections(client)).resolves.toEqual(liveConnections);
-        expect(client.listLookerConnections).toHaveBeenCalledTimes(1);
-    });
-});
-describe('looker dialect and target validation helpers', () => {
-    it('maps Looker dialect names to KTX connection types', () => {
-        expect(lookerDialectToConnectionType('bigquery_standard_sql')).toBe('BIGQUERY');
-        expect(lookerDialectToConnectionType('postgres')).toBe('POSTGRESQL');
-        expect(lookerDialectToConnectionType('mssql')).toBe('SQLSERVER');
-        expect(lookerDialectToConnectionType('unknown')).toBeNull();
-    });
-    it('maps supported warehouse connection types to sqlglot dialects', () => {
-        expect(sqlglotDialectForConnectionType('BIGQUERY')).toBe('bigquery');
-        expect(sqlglotDialectForConnectionType('POSTGRESQL')).toBe('postgres');
-        expect(sqlglotDialectForConnectionType('LOOKER')).toBeNull();
-    });
-    it('returns a structured failure for unsupported Looker warehouse targets', () => {
-        expect(validateLookerWarehouseTarget('LOOKER')).toEqual({
-            ok: false,
-            reason: 'Connection type LOOKER cannot be used as a Looker warehouse mapping target',
-        });
-    });
-});
-describe('suggestKtxConnectionForLookerConnection', () => {
-    it('returns the single deterministic target with matching type, host, and database', () => {
-        expect(suggestKtxConnectionForLookerConnection({
-            lookerConnection: liveConnections[1],
-            candidateConnections: [
-                {
-                    id: 'wrong-type',
-                    connection_type: 'MYSQL',
-                    connection_params: { host: 'pg.internal', database: 'app' },
-                },
-                {
-                    id: 'pg-target',
-                    connection_type: 'POSTGRESQL',
-                    connection_params: { host: 'PG.INTERNAL', database: 'APP' },
-                },
-            ],
-        })).toBe('pg-target');
-    });
-    it('returns null when more than one target matches', () => {
-        expect(suggestKtxConnectionForLookerConnection({
-            lookerConnection: liveConnections[1],
-            candidateConnections: [
-                {
-                    id: 'first',
-                    connection_type: 'POSTGRESQL',
-                    connection_params: { host: 'pg.internal', database: 'app' },
-                },
-                {
-                    id: 'second',
-                    connection_type: 'POSTGRESQL',
-                    connection_params: { host: 'pg.internal:5432', database: 'APP' },
-                },
-            ],
-        })).toBeNull();
-    });
-});
-describe('refreshLookerMappingPlaceholders', () => {
-    it('adds newly discovered placeholders and refreshes live metadata without dropping saved targets', () => {
-        expect(refreshLookerMappingPlaceholders({
-            stored: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-            ],
-            live: liveConnections,
-        })).toEqual({
-            changed: true,
-            mappings: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: 'warehouse.example.com',
-                    lookerDatabase: 'analytics',
-                    lookerDialect: 'bigquery_standard_sql',
-                },
-                {
-                    lookerConnectionName: 'pg_runtime',
-                    ktxConnectionId: null,
-                    lookerHost: 'pg.internal:5432',
-                    lookerDatabase: 'app',
-                    lookerDialect: 'postgres',
-                },
-            ],
-        });
-    });
-});
-describe('computeLookerMappingDrift and validateLookerMappings', () => {
-    it('reports unmapped live connections, stale stored mappings, and in-sync mappings', () => {
-        expect(computeLookerMappingDrift({
-            storedMappings: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-                {
-                    lookerConnectionName: 'stale_runtime',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-            ],
-            discovered: liveConnections,
-        })).toEqual({
-            unmappedDiscovered: [liveConnections[1]],
-            staleMappings: [{ lookerConnectionName: 'stale_runtime', reason: 'looker_connection_not_found' }],
-            inSync: [{ lookerConnectionName: 'b2b_sandbox_bq', ktxConnectionId: 'warehouse' }],
-        });
-    });
-    it('validates missing and unsupported target connection ids', () => {
-        expect(validateLookerMappings({
-            mappings: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'missing',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-                {
-                    lookerConnectionName: 'pg_runtime',
-                    ktxConnectionId: 'looker-target',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-            ],
-            knownKtxConnectionIds: new Set(['looker-target']),
-            knownConnectionTypes: new Map([['looker-target', 'LOOKER']]),
-        })).toEqual({
-            ok: false,
-            errors: [
-                { key: 'b2b_sandbox_bq', reason: 'KTX connection missing does not exist' },
-                {
-                    key: 'pg_runtime',
-                    reason: 'Connection type LOOKER cannot be used as a Looker warehouse mapping target',
-                },
-            ],
-        });
-    });
-});
-describe('collectExploreParseItems and projectParsedIdentifier', () => {
-    it('collects base explore and join parser inputs for mapped explores', () => {
-        expect(collectExploreParseItems({
-            explore: mappedExplore,
-            connectionMappings: { b2b_sandbox_bq: 'warehouse' },
-            targetConnections: new Map([['warehouse', { id: 'warehouse', connection_type: 'BIGQUERY' }]]),
-        })).toEqual({
-            parsedTargetTables: {},
-            parseItems: [
-                {
-                    key: 'b2b.sales_pipeline',
-                    sql_table_name: 'proj.analytics.opportunities AS opportunities',
-                    dialect: 'bigquery',
-                },
-                {
-                    key: 'b2b.sales_pipeline.accounts',
-                    sql_table_name: 'proj.analytics.accounts',
-                    dialect: 'bigquery',
-                },
-            ],
-        });
-    });
-    it('projects successful and failed parser rows into KTX parsed target tables', () => {
-        expect(projectParsedIdentifier({
-            ok: true,
-            catalog: 'proj',
-            schema: 'analytics',
-            name: 'accounts',
-            canonical_table: 'proj.analytics.accounts',
-        })).toEqual({
-            ok: true,
-            catalog: 'proj',
-            schema: 'analytics',
-            name: 'accounts',
-            canonicalTable: 'proj.analytics.accounts',
-        });
-        expect(projectParsedIdentifier({ ok: false, reason: 'derived_table_not_supported' })).toEqual({
-            ok: false,
-            reason: 'derived_table_not_supported',
-        });
-    });
-});
-describe('buildLookerPullConfigFromInputs', () => {
-    it('builds the hosted-equivalent Looker pull config from caller-loaded inputs', async () => {
-        const parser = {
-            parse: vi.fn().mockResolvedValue({
-                'b2b.sales_pipeline': {
-                    ok: true,
-                    catalog: 'proj',
-                    schema: 'analytics',
-                    name: 'opportunities',
-                    canonical_table: 'proj.analytics.opportunities',
-                },
-                'b2b.sales_pipeline.accounts': {
-                    ok: true,
-                    catalog: 'proj',
-                    schema: 'analytics',
-                    name: 'accounts',
-                    canonical_table: 'proj.analytics.accounts',
-                },
-            }),
-        };
-        const client = {
-            listLookmlModels: vi.fn().mockResolvedValue(models),
-            getExplore: vi.fn().mockResolvedValue(mappedExplore),
-        };
-        await expect(buildLookerPullConfigFromInputs({
-            lookerConnectionId: 'prod-looker',
-            cursors: {
-                dashboardsLastSyncedAt: '2026-05-01T00:00:00.000Z',
-                looksLastSyncedAt: null,
-            },
-            refreshedMappings: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: 'warehouse.example.com',
-                    lookerDatabase: 'analytics',
-                    lookerDialect: 'bigquery_standard_sql',
-                },
-            ],
-            targetConnections: new Map([['warehouse', { id: 'warehouse', connection_type: 'BIGQUERY' }]]),
-            client,
-            parser,
-        })).resolves.toEqual({
-            lookerConnectionId: 'prod-looker',
-            dashboardUpdatedSince: '2026-05-01T00:00:00.000Z',
-            lookUpdatedSince: null,
-            connectionMappings: { b2b_sandbox_bq: 'warehouse' },
-            connectionTypes: { b2b_sandbox_bq: 'BIGQUERY' },
-            parsedTargetTables: {
-                'b2b.sales_pipeline': {
-                    ok: true,
-                    catalog: 'proj',
-                    schema: 'analytics',
-                    name: 'opportunities',
-                    canonicalTable: 'proj.analytics.opportunities',
-                },
-                'b2b.sales_pipeline.accounts': {
-                    ok: true,
-                    catalog: 'proj',
-                    schema: 'analytics',
-                    name: 'accounts',
-                    canonicalTable: 'proj.analytics.accounts',
-                },
-            },
-        });
-    });
-    it('marks parser failures as parse_error without blocking pull-config construction', async () => {
-        const parser = { parse: vi.fn().mockRejectedValue(new Error('python unavailable')) };
-        const client = {
-            listLookmlModels: vi.fn().mockResolvedValue(models),
-            getExplore: vi.fn().mockResolvedValue(mappedExplore),
-        };
-        const config = await buildLookerPullConfigFromInputs({
-            lookerConnectionId: 'prod-looker',
-            cursors: { dashboardsLastSyncedAt: null, looksLastSyncedAt: null },
-            refreshedMappings: [
-                {
-                    lookerConnectionName: 'b2b_sandbox_bq',
-                    ktxConnectionId: 'warehouse',
-                    lookerHost: null,
-                    lookerDatabase: null,
-                    lookerDialect: null,
-                },
-            ],
-            targetConnections: new Map([['warehouse', { id: 'warehouse', connection_type: 'BIGQUERY' }]]),
-            client,
-            parser,
-        });
-        expect(config.parsedTargetTables).toMatchObject({
-            'b2b.sales_pipeline': { ok: false, reason: 'parse_error' },
-            'b2b.sales_pipeline.accounts': { ok: false, reason: 'parse_error' },
-        });
-    });
-});

package/dist/context/ingest/adapters/looker/reconcile.test.d.ts

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

package/dist/context/ingest/adapters/looker/reconcile.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildLookerReconcileNotes } from './reconcile.js';
-describe('buildLookerReconcileNotes', () => {
-    it('instructs reconciliation to record subsumed provenance', () => {
-        expect(buildLookerReconcileNotes()).toEqual([
-            [
-                'Looker runtime API-derived SL sources use looker__<model>__<explore>.',
-                'If the unprefixed file-adapter source <model>__<explore> exists, prefer it in wiki sl_refs, delete or avoid the API-derived source, and call emit_artifact_resolution with actionType="subsumed" for the API raw explore path.',
-            ].join(' '),
-        ]);
-    });
-});

package/dist/context/ingest/adapters/looker/scope.test.d.ts

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

package/dist/context/ingest/adapters/looker/scope.test.js

@@ -1,84 +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 { describeLookerScope, hashLookerScope, isPathInLookerScope } from './scope.js';
-async function writeJson(stagedDir, relPath, value) {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-describe('Looker runtime fetch scope', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'looker-scope-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('keeps omitted known-current entity files out of the deletion baseline', () => {
-        const scope = {
-            mode: 'incremental',
-            knownCurrentRawPaths: ['dashboards/10.json', 'dashboards/11.json', 'looks/20.json'],
-            fetchedRawPaths: ['dashboards/11.json'],
-        };
-        expect(isPathInLookerScope('dashboards/10.json', scope)).toBe(false);
-        expect(isPathInLookerScope('looks/20.json', scope)).toBe(false);
-        expect(isPathInLookerScope('dashboards/11.json', scope)).toBe(true);
-        expect(isPathInLookerScope('looks/21.json', scope)).toBe(true);
-        expect(isPathInLookerScope('signals/dashboard_usage.json', scope)).toBe(true);
-        expect(isPathInLookerScope('explores/b2b/sales_pipeline.json', scope)).toBe(true);
-    });
-    it('keeps omitted unchanged evidence documents out of incremental delete scope', () => {
-        const scope = {
-            mode: 'incremental',
-            knownCurrentRawPaths: ['dashboards/10.json', 'looks/20.json'],
-            fetchedRawPaths: ['dashboards/10.json'],
-        };
-        expect(isPathInLookerScope('evidence/dashboards/10/page.md', scope)).toBe(true);
-        expect(isPathInLookerScope('evidence/dashboards/10/metadata.json', scope)).toBe(true);
-        expect(isPathInLookerScope('evidence/looks/20/page.md', scope)).toBe(false);
-        expect(isPathInLookerScope('evidence/looks/20/metadata.json', scope)).toBe(false);
-    });
-    it('treats full scope as all raw paths in scope', () => {
-        const scope = {
-            mode: 'full',
-            knownCurrentRawPaths: ['dashboards/10.json'],
-            fetchedRawPaths: ['dashboards/10.json'],
-        };
-        expect(isPathInLookerScope('dashboards/10.json', scope)).toBe(true);
-        expect(isPathInLookerScope('dashboards/99.json', scope)).toBe(true);
-        expect(isPathInLookerScope('looks/20.json', scope)).toBe(true);
-    });
-    it('hashes scope order-insensitively', () => {
-        const a = hashLookerScope({
-            mode: 'incremental',
-            knownCurrentRawPaths: ['looks/20.json', 'dashboards/10.json'],
-            fetchedRawPaths: ['dashboards/10.json'],
-        });
-        const b = hashLookerScope({
-            mode: 'incremental',
-            knownCurrentRawPaths: ['dashboards/10.json', 'looks/20.json'],
-            fetchedRawPaths: ['dashboards/10.json'],
-        });
-        expect(a).toBe(b);
-        expect(a).toMatch(/^[0-9a-f]{64}$/);
-    });
-    it('reads staged scope and returns a SourceAdapter ScopeDescriptor', async () => {
-        await writeJson(stagedDir, 'looker-scope.json', {
-            mode: 'incremental',
-            knownCurrentRawPaths: ['dashboards/10.json', 'looks/20.json'],
-            fetchedRawPaths: ['dashboards/10.json'],
-        });
-        const descriptor = await describeLookerScope(stagedDir);
-        expect(descriptor.fingerprint).toMatch(/^[0-9a-f]{64}$/);
-        expect(descriptor.isPathInScope('dashboards/10.json')).toBe(true);
-        expect(descriptor.isPathInScope('looks/20.json')).toBe(false);
-        expect(descriptor.isPathInScope('looks/99.json')).toBe(true);
-    });
-    it('falls back to full scope when old fixtures do not have a scope file', async () => {
-        const descriptor = await describeLookerScope(stagedDir);
-        expect(descriptor.isPathInScope('dashboards/10.json')).toBe(true);
-        expect(descriptor.isPathInScope('looks/20.json')).toBe(true);
-    });
-});

package/dist/context/ingest/adapters/looker/target-connections.test.d.ts

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