@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/client.test.js

@@ -1,377 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { DEFAULT_METABASE_CLIENT_CONFIG, DefaultMetabaseConnectionClientFactory, getDummyValueForWidgetType, MetabaseClient, stripOptionalClauses, } from './client.js';
-const runtime = {
-    apiUrl: 'https://metabase.example.test/api',
-    apiKey: 'test-key-1234', // pragma: allowlist secret
-};
-const fastRetryConfig = {
-    maxRetries: 2,
-    baseDelayMs: 1,
-    maxDelayMs: 1,
-    timeoutMs: 5000,
-    jitter: false,
-    retryableStatuses: [429, 500, 502, 503, 504],
-};
-function nativeCard(query, templateTags = {}) {
-    return {
-        id: 1,
-        name: 'Native card',
-        type: 'model',
-        query_type: 'native',
-        database_id: 6,
-        dataset_query: {
-            type: 'native',
-            database: 6,
-            stages: [{ 'lib/type': 'mbql.stage/native', native: query, 'template-tags': templateTags }],
-        },
-    };
-}
-function legacyNativeCard(query, templateTags = {}) {
-    return {
-        id: 1,
-        name: 'Legacy native card',
-        type: 'model',
-        query_type: 'native',
-        database_id: 6,
-        dataset_query: {
-            type: 'native',
-            database: 6,
-            native: { query, 'template-tags': templateTags },
-        },
-    };
-}
-describe('DefaultMetabaseConnectionClientFactory', () => {
-    it('resolves runtime credentials by the explicit Metabase source connection id and merges overrides', async () => {
-        const resolveCredentials = vi.fn().mockResolvedValue(runtime);
-        const factory = new DefaultMetabaseConnectionClientFactory(resolveCredentials, {
-            ...DEFAULT_METABASE_CLIENT_CONFIG,
-            timeoutMs: 60000,
-            maxRetries: 4,
-        });
-        const client = await factory.createClient('metabase-source-1', { timeoutMs: 1000 });
-        expect(resolveCredentials).toHaveBeenCalledWith('metabase-source-1');
-        expect(client).toBeInstanceOf(MetabaseClient);
-        expect(Reflect.get(client, 'baseUrl')).toBe('https://metabase.example.test/api');
-        expect(Reflect.get(client, 'runtime').apiKey).toBe('test-key-1234');
-        expect(Reflect.get(client, 'config').timeoutMs).toBe(1000);
-        expect(Reflect.get(client, 'config').maxRetries).toBe(4);
-    });
-});
-describe('MetabaseClient retry exhaustion', () => {
-    let originalFetch;
-    beforeEach(() => {
-        originalFetch = globalThis.fetch;
-    });
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-        vi.restoreAllMocks();
-    });
-    it('does not warn to console when retrying by default', async () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-        globalThis.fetch = vi
-            .fn()
-            .mockRejectedValueOnce(Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' }))
-            .mockResolvedValueOnce(new Response(JSON.stringify([]), { status: 200 }));
-        const client = new MetabaseClient({ apiUrl: 'https://metabase.example.test', apiKey: 'key' }, // pragma: allowlist secret
-        {
-            ...DEFAULT_METABASE_CLIENT_CONFIG,
-            baseDelayMs: 0,
-            maxRetries: 1,
-        });
-        await client.getDatabases();
-        expect(warn).not.toHaveBeenCalled();
-    });
-    it('wraps an exhausted ECONNRESET retry chain with method, path, attempt count, and original cause', async () => {
-        const sysErr = Object.assign(new Error('read ECONNRESET'), {
-            code: 'ECONNRESET',
-            errno: -104,
-            syscall: 'read',
-        });
-        const fetchMock = vi.fn().mockRejectedValue(sysErr);
-        globalThis.fetch = fetchMock;
-        const client = new MetabaseClient(runtime, fastRetryConfig);
-        let caught;
-        try {
-            await client.getDatabases();
-        }
-        catch (err) {
-            caught = err;
-        }
-        expect(caught).toBeInstanceOf(Error);
-        const e = caught;
-        expect(e.message).toContain('Metabase request failed (3 attempts)');
-        expect(e.message).toContain('GET /api/database/');
-        expect(e.message).toContain('ECONNRESET');
-        expect(e.cause).toBe(sysErr);
-        expect(e.code).toBe('ECONNRESET');
-        expect(fetchMock).toHaveBeenCalledTimes(3);
-    });
-    it('classifies undici mid-TLS-handshake error as TLS-handshake failure', async () => {
-        const undiciTlsErr = new Error('Client network socket disconnected before secure TLS connection was established');
-        const fetchMock = vi.fn().mockRejectedValue(undiciTlsErr);
-        globalThis.fetch = fetchMock;
-        const client = new MetabaseClient(runtime, { ...fastRetryConfig, maxRetries: 0 });
-        let caught;
-        try {
-            await client.getDatabases();
-        }
-        catch (err) {
-            caught = err;
-        }
-        expect(caught).toBeInstanceOf(Error);
-        const e = caught;
-        expect(e.message).toMatch(/^Metabase request failed:/);
-        expect(e.message).not.toContain('attempts');
-        expect(e.message).toContain('TLS handshake to metabase.example.test did not complete');
-        expect(e.message).toContain('before secure TLS connection was established');
-        expect(e.cause).toBeInstanceOf(Error);
-        expect(e.cause.cause?.message).toContain('before secure TLS connection was established');
-    });
-    it('does not wrap when a non-retryable error short-circuits the loop', async () => {
-        const fetchMock = vi
-            .fn()
-            .mockResolvedValue(new Response('{"message":"unauthorized"}', { status: 401, headers: { 'content-type': 'application/json' } }));
-        globalThis.fetch = fetchMock;
-        const client = new MetabaseClient(runtime, fastRetryConfig);
-        let caught;
-        try {
-            await client.getDatabases();
-        }
-        catch (err) {
-            caught = err;
-        }
-        expect(caught).toBeInstanceOf(Error);
-        const e = caught;
-        expect(e.message).not.toContain('after 3 attempts');
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-});
-describe('MetabaseClient admin auth helpers', () => {
-    let originalFetch;
-    beforeEach(() => {
-        originalFetch = globalThis.fetch;
-    });
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-        vi.restoreAllMocks();
-    });
-    it('creates a session without sending an auth header', async () => {
-        const sessionFixture = 'session-fixture';
-        const adminCredentialFixture = 'admin-fixture';
-        const fetchMock = vi
-            .fn()
-            .mockResolvedValue(new Response(JSON.stringify({ id: sessionFixture }), { status: 200 }));
-        globalThis.fetch = fetchMock;
-        const client = new MetabaseClient({ apiUrl: 'https://metabase.example.test', apiKey: '' }, fastRetryConfig);
-        await expect(client.createSession('admin@example.test', adminCredentialFixture)).resolves.toBe(sessionFixture);
-        expect(fetchMock).toHaveBeenCalledWith('https://metabase.example.test/api/session', expect.objectContaining({
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ username: 'admin@example.test', password: adminCredentialFixture }),
-        }));
-    });
-    it('uses the configured auth header for permission groups and API-key creation', async () => {
-        const mintedMetabaseCredential = 'mb_generated';
-        const sessionFixture = 'session-fixture';
-        const fetchMock = vi
-            .fn()
-            .mockResolvedValueOnce(new Response(JSON.stringify([{ id: 2, name: 'Administrators' }]), { status: 200 }))
-            .mockResolvedValueOnce(new Response(JSON.stringify({ unmasked_key: mintedMetabaseCredential }), { status: 200 }));
-        globalThis.fetch = fetchMock;
-        const client = new MetabaseClient({ apiUrl: 'https://metabase.example.test', apiKey: sessionFixture, authHeaderName: 'X-Metabase-Session' }, fastRetryConfig);
-        await expect(client.getPermissionGroups()).resolves.toEqual([{ id: 2, name: 'Administrators' }]);
-        await expect(client.createApiKey({ name: 'KTX CLI test', groupId: 2 })).resolves.toBe(mintedMetabaseCredential);
-        expect(fetchMock).toHaveBeenNthCalledWith(1, 'https://metabase.example.test/api/permissions/group', expect.objectContaining({
-            method: 'GET',
-            headers: { 'Content-Type': 'application/json', 'X-Metabase-Session': sessionFixture },
-        }));
-        expect(fetchMock).toHaveBeenNthCalledWith(2, 'https://metabase.example.test/api/api-key', expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify({ name: 'KTX CLI test', group_id: 2 }),
-        }));
-    });
-});
-describe('stripOptionalClauses', () => {
-    it('drops optional blocks that contain Metabase template variables', () => {
-        const input = 'SELECT * FROM x WHERE 1=1 [[AND a = {{ a }} ]] [[AND b = {{ b }} ]]';
-        expect(stripOptionalClauses(input)).toBe('SELECT * FROM x WHERE 1=1  ');
-    });
-    it('preserves bracket sequences that contain no template variables', () => {
-        const input = "SELECT * FROM x WHERE col LIKE '[[abc]]'";
-        expect(stripOptionalClauses(input)).toBe(input);
-    });
-    it('leaves naked template variables intact', () => {
-        const input = 'SELECT * FROM x WHERE id = {{ id }}';
-        expect(stripOptionalClauses(input)).toBe(input);
-    });
-});
-describe('getDummyValueForWidgetType', () => {
-    it('returns widget-specific date and number values', () => {
-        expect(getDummyValueForWidgetType('date/range')).toBe('2020-01-01~2020-12-31');
-        expect(getDummyValueForWidgetType('date/all-options')).toBe('2020-01-01~2020-12-31');
-        expect(getDummyValueForWidgetType('date/single')).toBe('2020-01-01');
-        expect(getDummyValueForWidgetType('date/relative')).toBe('past30days');
-        expect(getDummyValueForWidgetType('date/month-year')).toBe('2020-01');
-        expect(getDummyValueForWidgetType('date/quarter-year')).toBe('Q1-2020');
-        expect(getDummyValueForWidgetType('number/=')).toBe('1');
-        expect(getDummyValueForWidgetType('number/between')).toBe('1');
-    });
-    it('falls back to an array placeholder for string, identifier, and unknown widgets', () => {
-        expect(getDummyValueForWidgetType('string/=')).toEqual(['placeholder']);
-        expect(getDummyValueForWidgetType('category')).toEqual(['placeholder']);
-        expect(getDummyValueForWidgetType(undefined)).toEqual(['placeholder']);
-    });
-});
-describe('MetabaseClient legacy native dataset query support', () => {
-    it('reads SQL and template tags from dataset_query.native', async () => {
-        const client = new MetabaseClient(runtime, fastRetryConfig);
-        const card = legacyNativeCard('SELECT * FROM orders WHERE status = {{ status }}', {
-            status: {
-                name: 'status',
-                type: 'text',
-                default: 'paid',
-            },
-        });
-        expect(client.getNativeSql(card)).toBe('SELECT * FROM orders WHERE status = {{ status }}');
-        expect(client.getTemplateTags(card)).toEqual({
-            status: expect.objectContaining({ name: 'status', type: 'text' }),
-        });
-        await expect(client.getCardSql(card)).resolves.toBe('SELECT * FROM orders WHERE status = {{ status }}');
-    });
-});
-describe('MetabaseClient.getResolvedSql', () => {
-    function makeClient(setup) {
-        const client = new MetabaseClient({ apiUrl: 'http://test', apiKey: 'k' });
-        setup?.(client);
-        return client;
-    }
-    it('strips optional clauses locally and skips /api/dataset/native when no naked variables remain', async () => {
-        const requestSpy = vi.fn();
-        const client = makeClient((client) => {
-            Reflect.set(client, 'requestWithCustomRetry', requestSpy);
-        });
-        const card = nativeCard('SELECT * FROM x WHERE 1=1 [[AND end > {{ auction_end }} ]]', {
-            auction_end: {
-                id: 'tag-1',
-                name: 'auction_end',
-                type: 'dimension',
-                'widget-type': 'date/all-options',
-                'display-name': 'Auction End',
-            },
-        });
-        const result = await client.getResolvedSql(card);
-        expect(requestSpy).not.toHaveBeenCalled();
-        expect(result?.resolutionStatus).toBe('resolved');
-        expect(result?.resolvedSql).toBe('SELECT * FROM x WHERE 1=1 ');
-        expect(result?.templateTags[0]).toMatchObject({ name: 'auction_end', type: 'dimension' });
-    });
-    it('inlines saved-question references locally and skips /api/dataset/native when no other variables remain', async () => {
-        const requestSpy = vi.fn();
-        const getCardSpy = vi.fn().mockResolvedValue({
-            id: 5996,
-            name: 'Base card',
-            type: 'model',
-            query_type: 'native',
-            database_id: 6,
-            dataset_query: {
-                type: 'native',
-                database: 6,
-                stages: [{ 'lib/type': 'mbql.stage/native', native: 'SELECT a, b FROM base' }],
-            },
-        });
-        const client = makeClient((client) => {
-            Reflect.set(client, 'requestWithCustomRetry', requestSpy);
-            Reflect.set(client, 'getCard', getCardSpy);
-        });
-        const card = nativeCard('SELECT * FROM {{#5996-base}} t [[WHERE end > {{ end }}]]', {
-            '#5996-base': {
-                id: 't1',
-                name: '#5996-base',
-                type: 'card',
-                'card-id': 5996,
-            },
-            end: {
-                id: 't2',
-                name: 'end',
-                type: 'dimension',
-                'widget-type': 'date/range',
-            },
-        });
-        const result = await client.getResolvedSql(card);
-        expect(requestSpy).not.toHaveBeenCalled();
-        expect(getCardSpy).toHaveBeenCalledWith(5996);
-        expect(result?.resolutionStatus).toBe('resolved');
-        expect(result?.resolvedSql).toBe('SELECT * FROM (SELECT a, b FROM base) t ');
-    });
-    it('inlines native-query snippets before checking for remaining variables', async () => {
-        const requestSpy = vi.fn().mockResolvedValue([
-            {
-                id: 1,
-                name: 'account_join',
-                content: 'LEFT JOIN accounts a ON a.account_id = mart.account_id',
-            },
-        ]);
-        const requestWithCustomRetrySpy = vi.fn();
-        const client = makeClient((client) => {
-            Reflect.set(client, 'request', requestSpy);
-            Reflect.set(client, 'requestWithCustomRetry', requestWithCustomRetrySpy);
-        });
-        const card = nativeCard('SELECT a.account_name FROM mart {{snippet: account_join}}', {
-            'snippet: account_join': {
-                id: 'snippet-tag',
-                name: 'snippet: account_join',
-                type: 'snippet',
-                'snippet-name': 'account_join',
-                'snippet-id': 1,
-            },
-        });
-        const result = await client.getResolvedSql(card);
-        expect(requestSpy).toHaveBeenCalledWith('GET', '/api/native-query-snippet');
-        expect(requestWithCustomRetrySpy).not.toHaveBeenCalled();
-        expect(result?.resolutionStatus).toBe('resolved');
-        expect(result?.resolvedSql).toBe('SELECT a.account_name FROM mart LEFT JOIN accounts a ON a.account_id = mart.account_id');
-        expect(result?.resolvedSql).not.toContain('{{snippet:');
-    });
-    it('uses /api/dataset/native for naked variables and prepends a warning comment', async () => {
-        const requestSpy = vi.fn().mockResolvedValue({ query: "SELECT * WHERE id = 'placeholder' AND n = 1" });
-        const client = makeClient((client) => {
-            Reflect.set(client, 'requestWithCustomRetry', requestSpy);
-        });
-        const card = nativeCard('SELECT * WHERE id = {{ id }} AND n = {{ n }}', {
-            id: { id: 't1', name: 'id', type: 'text' },
-            n: { id: 't2', name: 'n', type: 'number' },
-        });
-        const result = await client.getResolvedSql(card);
-        expect(requestSpy).toHaveBeenCalledTimes(1);
-        expect(result?.resolutionStatus).toBe('resolved');
-        const sql = result?.resolvedSql ?? '';
-        expect(sql.startsWith('--')).toBe(true);
-        expect(sql).toMatch(/KTX_PLACEHOLDER_WARNING/);
-        expect(sql).toMatch(/\bid\b/);
-        expect(sql).toMatch(/\bn\b/);
-    });
-    it('falls back to raw native SQL with truthful template tags when /api/dataset/native errors', async () => {
-        const requestSpy = vi.fn().mockRejectedValue(new Error('Metabase 500'));
-        const client = makeClient((client) => {
-            Reflect.set(client, 'requestWithCustomRetry', requestSpy);
-        });
-        const card = nativeCard('SELECT * FROM x WHERE end > {{ auction_end }}', {
-            auction_end: {
-                id: 'tag-id',
-                name: 'auction_end',
-                type: 'dimension',
-                'widget-type': 'date/range',
-                'display-name': 'Auction End',
-            },
-        });
-        const result = await client.getResolvedSql(card);
-        expect(result?.resolutionStatus).toBe('fallback');
-        expect(result?.resolvedSql).toContain('{{ auction_end }}');
-        expect(result?.templateTags).toHaveLength(1);
-        expect(result?.templateTags[0]).toMatchObject({
-            name: 'auction_end',
-            type: 'dimension',
-            displayName: 'Auction End',
-        });
-    });
-});

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

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

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/detect.test.js

@@ -1,42 +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 { detectMetabaseStagedDir } from './detect.js';
-async function touch(stagedDir, relPath, body) {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, body, 'utf-8');
-}
-describe('detectMetabaseStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'mb-detect-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('returns true when sync-config.json + cards/*.json are present', async () => {
-        await touch(stagedDir, 'sync-config.json', '{}');
-        await touch(stagedDir, 'cards/1.json', '{}');
-        expect(await detectMetabaseStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns false when sync-config.json is missing', async () => {
-        await touch(stagedDir, 'cards/1.json', '{}');
-        expect(await detectMetabaseStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false when cards/ is empty', async () => {
-        await touch(stagedDir, 'sync-config.json', '{}');
-        await mkdir(join(stagedDir, 'cards'), { recursive: true });
-        expect(await detectMetabaseStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false for an empty staged dir', async () => {
-        expect(await detectMetabaseStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns true even when the cards dir has one file and extra non-JSON siblings', async () => {
-        await touch(stagedDir, 'sync-config.json', '{}');
-        await touch(stagedDir, 'cards/1.json', '{}');
-        await touch(stagedDir, 'README.md', '# readme');
-        expect(await detectMetabaseStagedDir(stagedDir)).toBe(true);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fanout-planner.d.ts

@@ -1,17 +0,0 @@
-import { type MetabasePullConfig } from './types.js';
-export interface MetabaseFanoutMappingInput {
-    metabaseDatabaseId: number;
-    targetConnectionId: string | null;
-    syncEnabled: boolean;
-}
-export interface MetabaseFanoutChildPlan {
-    metabaseConnectionId: string;
-    metabaseDatabaseId: number;
-    targetConnectionId: string;
-    pullConfig: MetabasePullConfig;
-}
-export interface PlanMetabaseFanoutChildrenInput {
-    metabaseConnectionId: string;
-    mappings: MetabaseFanoutMappingInput[];
-}
-export declare function planMetabaseFanoutChildren(input: PlanMetabaseFanoutChildrenInput): MetabaseFanoutChildPlan[];

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fanout-planner.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fanout-planner.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { planMetabaseFanoutChildren } from './fanout-planner.js';
-describe('planMetabaseFanoutChildren', () => {
-    it('builds ordered child plans for sync-enabled mapped Metabase databases', () => {
-        const plans = planMetabaseFanoutChildren({
-            metabaseConnectionId: 'prod-metabase',
-            mappings: [
-                { metabaseDatabaseId: 1, targetConnectionId: 'warehouse_a', syncEnabled: true },
-                { metabaseDatabaseId: 2, targetConnectionId: null, syncEnabled: true },
-                { metabaseDatabaseId: 3, targetConnectionId: 'warehouse_c', syncEnabled: false },
-                { metabaseDatabaseId: 4, targetConnectionId: 'warehouse_b', syncEnabled: true },
-            ],
-        });
-        expect(plans).toEqual([
-            {
-                metabaseConnectionId: 'prod-metabase',
-                metabaseDatabaseId: 1,
-                targetConnectionId: 'warehouse_a',
-                pullConfig: { metabaseConnectionId: 'prod-metabase', metabaseDatabaseId: 1 },
-            },
-            {
-                metabaseConnectionId: 'prod-metabase',
-                metabaseDatabaseId: 4,
-                targetConnectionId: 'warehouse_b',
-                pullConfig: { metabaseConnectionId: 'prod-metabase', metabaseDatabaseId: 4 },
-            },
-        ]);
-    });
-    it('rejects invalid generated pull configs before any host enqueues work', () => {
-        expect(() => planMetabaseFanoutChildren({
-            metabaseConnectionId: 'prod-metabase',
-            mappings: [{ metabaseDatabaseId: 0, targetConnectionId: 'warehouse_a', syncEnabled: true }],
-        })).toThrow(/metabaseDatabaseId/);
-    });
-    it('rejects source states with no sync-enabled target mappings', () => {
-        expect(() => planMetabaseFanoutChildren({
-            metabaseConnectionId: 'prod-metabase',
-            mappings: [
-                { metabaseDatabaseId: 1, targetConnectionId: null, syncEnabled: true },
-                { metabaseDatabaseId: 2, targetConnectionId: 'warehouse_b', syncEnabled: false },
-            ],
-        })).toThrow('no sync-enabled mappings with a target connection for Metabase connection prod-metabase');
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fetch-scope.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fetch-scope.test.js

@@ -1,124 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { computeFetchScope, hashScope, isPathInMetabaseScope } from './fetch-scope.js';
-const BASE_CONFIG = {
-    metabaseConnectionId: 'a1b2c3d4-e5f6-4789-9abc-def012345678',
-    metabaseDatabaseId: 42,
-    defaultTagNames: [],
-    mapping: {
-        metabaseDatabaseId: 42,
-        metabaseDatabaseName: 'Analytics',
-        metabaseEngine: 'postgres',
-        targetConnectionId: 'b2c3d4e5-f6a7-4890-abcd-ef0123456789',
-    },
-};
-describe('computeFetchScope', () => {
-    it('returns { kind: "all" } for syncMode ALL', () => {
-        const scope = computeFetchScope({
-            ...BASE_CONFIG,
-            syncMode: 'ALL',
-            selections: [{ selectionType: 'item', metabaseObjectId: 5 }],
-        });
-        expect(scope).toEqual({ kind: 'all' });
-    });
-    it('returns { kind: "all-except", ... } for syncMode EXCEPT', () => {
-        const scope = computeFetchScope({
-            ...BASE_CONFIG,
-            syncMode: 'EXCEPT',
-            selections: [
-                { selectionType: 'item', metabaseObjectId: 5 },
-                { selectionType: 'collection', metabaseObjectId: 7 },
-            ],
-        });
-        expect(scope).toEqual({
-            kind: 'all-except',
-            excludeCardIds: new Set([5]),
-            excludeCollectionIds: new Set([7]),
-        });
-    });
-    it('returns { kind: "explicit", ... } for syncMode ONLY', () => {
-        const scope = computeFetchScope({
-            ...BASE_CONFIG,
-            syncMode: 'ONLY',
-            selections: [
-                { selectionType: 'item', metabaseObjectId: 5 },
-                { selectionType: 'item', metabaseObjectId: 11 },
-                { selectionType: 'collection', metabaseObjectId: 7 },
-            ],
-        });
-        expect(scope).toEqual({
-            kind: 'explicit',
-            includeCardIds: new Set([5, 11]),
-            includeCollectionIds: new Set([7]),
-        });
-    });
-    it('treats generated ONLY with no selections as all', () => {
-        const scope = computeFetchScope({ ...BASE_CONFIG, syncMode: 'ONLY', selections: [] });
-        expect(scope).toEqual({ kind: 'all' });
-    });
-});
-describe('hashScope', () => {
-    it('produces the same hash for identical inputs', () => {
-        const a = hashScope({
-            kind: 'explicit',
-            includeCardIds: new Set([1, 2, 3]),
-            includeCollectionIds: new Set([7]),
-        });
-        const b = hashScope({
-            kind: 'explicit',
-            includeCardIds: new Set([3, 2, 1]),
-            includeCollectionIds: new Set([7]),
-        });
-        expect(a).toBe(b);
-    });
-    it('produces different hashes for different scopes', () => {
-        const a = hashScope({ kind: 'all' });
-        const b = hashScope({
-            kind: 'explicit',
-            includeCardIds: new Set([1]),
-            includeCollectionIds: new Set(),
-        });
-        expect(a).not.toBe(b);
-    });
-    it('produces a 64-char hex string', () => {
-        const fp = hashScope({ kind: 'all' });
-        expect(fp).toMatch(/^[0-9a-f]{64}$/);
-    });
-});
-describe('isPathInMetabaseScope', () => {
-    const allScope = { kind: 'all' };
-    const exceptScope = {
-        kind: 'all-except',
-        excludeCardIds: new Set([100]),
-        excludeCollectionIds: new Set([5]),
-    };
-    const explicitScope = {
-        kind: 'explicit',
-        includeCardIds: new Set([1, 2]),
-        includeCollectionIds: new Set([7]),
-    };
-    it('always includes sync-config.json', () => {
-        expect(isPathInMetabaseScope('sync-config.json', allScope)).toBe(true);
-        expect(isPathInMetabaseScope('sync-config.json', exceptScope)).toBe(true);
-        expect(isPathInMetabaseScope('sync-config.json', explicitScope)).toBe(true);
-    });
-    it('always includes collections/* and databases/*', () => {
-        expect(isPathInMetabaseScope('collections/5.json', explicitScope)).toBe(true);
-        expect(isPathInMetabaseScope('databases/42.json', explicitScope)).toBe(true);
-    });
-    it('for `all` scope, every cards/<id>.json is in scope', () => {
-        expect(isPathInMetabaseScope('cards/1.json', allScope)).toBe(true);
-        expect(isPathInMetabaseScope('cards/999.json', allScope)).toBe(true);
-    });
-    it('for `all-except` scope, excluded card ids are out of scope', () => {
-        expect(isPathInMetabaseScope('cards/100.json', exceptScope)).toBe(false);
-        expect(isPathInMetabaseScope('cards/101.json', exceptScope)).toBe(true);
-    });
-    it('for `explicit` scope, only include-set card ids are in scope', () => {
-        expect(isPathInMetabaseScope('cards/1.json', explicitScope)).toBe(true);
-        expect(isPathInMetabaseScope('cards/2.json', explicitScope)).toBe(true);
-        expect(isPathInMetabaseScope('cards/3.json', explicitScope)).toBe(false);
-    });
-    it('unknown path shapes default to in-scope (conservative)', () => {
-        expect(isPathInMetabaseScope('some-new-dir/whatever.json', explicitScope)).toBe(true);
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/fetch.test.d.ts

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