@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/adapters/historic-sql/projection.test.js

@@ -1,392 +0,0 @@
-import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import YAML from 'yaml';
-import { describe, expect, it } from 'vitest';
-import { projectHistoricSqlEvidence } from './projection.js';
-async function tempWorkdir() {
-    return mkdtemp(join(tmpdir(), 'historic-sql-projection-'));
-}
-async function writeText(root, relPath, content) {
-    const target = join(root, relPath);
-    await mkdir(join(target, '..'), { recursive: true });
-    await writeFile(target, content, 'utf-8');
-}
-async function writeJson(root, relPath, value) {
-    await writeText(root, relPath, `${JSON.stringify(value, null, 2)}\n`);
-}
-describe('projectHistoricSqlEvidence', () => {
-    it('merges table usage into matching _schema shards and preserves external usage keys', async () => {
-        const workdir = await tempWorkdir();
-        await writeText(workdir, 'semantic-layer/warehouse/_schema/public.yaml', YAML.stringify({
-            tables: {
-                orders: {
-                    table: 'public.orders',
-                    usage: {
-                        narrative: 'Old generated usage.',
-                        frequencyTier: 'low',
-                        commonFilters: ['old_status'],
-                        commonJoins: [],
-                        ownerNote: 'keep me',
-                    },
-                    columns: [{ name: 'id', type: 'string' }],
-                },
-            },
-        }));
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 1,
-            touchedTableCount: 1,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.orders.json', { table: 'public.orders' });
-        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/orders.json', {
-            kind: 'table_usage',
-            connectionId: 'warehouse',
-            table: 'public.orders',
-            rawPath: 'tables/public.orders.json',
-            usage: {
-                narrative: 'Orders are repeatedly queried for lifecycle analysis.',
-                frequencyTier: 'high',
-                commonFilters: ['status', 'created_at'],
-                commonGroupBys: ['status'],
-                commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-                staleSince: null,
-            },
-        });
-        const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
-        expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
-        expect(result.actions).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                target: 'sl',
-                key: 'orders',
-                rawPaths: ['tables/public.orders.json'],
-            }),
-        ]));
-        const shard = YAML.parse(await readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8'));
-        expect(shard.tables.orders.usage).toEqual({
-            ownerNote: 'keep me',
-            narrative: 'Orders are repeatedly queried for lifecycle analysis.',
-            frequencyTier: 'high',
-            commonFilters: ['status', 'created_at'],
-            commonGroupBys: ['status'],
-            commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-            staleSince: null,
-        });
-    });
-    it('writes pattern pages, reuses similar slugs, and marks missing old pattern pages stale', async () => {
-        const workdir = await tempWorkdir();
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 2,
-            touchedTableCount: 2,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.orders.json', { table: 'public.orders' });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.customers.json', { table: 'public.customers' });
-        await writeText(workdir, 'wiki/global/historic-sql-old-order-lifecycle.md', [
-            '---',
-            YAML.stringify({
-                summary: 'Old order lifecycle page',
-                tags: ['historic-sql', 'pattern'],
-                refs: [],
-                sl_refs: ['orders'],
-                usage_mode: 'auto',
-                source: 'historic-sql',
-                tables: ['public.orders', 'public.customers'],
-                fingerprints: ['pg:1'],
-            }).trimEnd(),
-            '---',
-            '',
-            'Old body',
-            '',
-        ].join('\n'));
-        await writeText(workdir, 'wiki/global/historic-sql-retired-pattern.md', [
-            '---',
-            YAML.stringify({
-                summary: 'Retired pattern',
-                tags: ['historic-sql', 'pattern'],
-                refs: [],
-                sl_refs: [],
-                usage_mode: 'auto',
-                source: 'historic-sql',
-                tables: ['public.tickets'],
-                fingerprints: ['pg:9'],
-            }).trimEnd(),
-            '---',
-            '',
-            'Retired body',
-            '',
-        ].join('\n'));
-        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/pattern.json', {
-            kind: 'pattern',
-            connectionId: 'warehouse',
-            rawPath: 'patterns-input.json',
-            pattern: {
-                slug: 'order-lifecycle-analysis',
-                title: 'Order Lifecycle Analysis',
-                narrative: 'Analysts compare order status with customer segment.',
-                definitionSql: 'select * from public.orders join public.customers on customers.id = orders.customer_id',
-                tablesInvolved: ['public.orders', 'public.customers'],
-                slRefs: ['orders', 'customers'],
-                constituentTemplateIds: ['pg:1', 'pg:2'],
-            },
-        });
-        const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
-        expect(result.patternPagesWritten).toBe(1);
-        expect(result.changedWikiPageKeys).toContain('historic-sql-old-order-lifecycle');
-        expect(result.actions).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                target: 'wiki',
-                key: 'historic-sql-old-order-lifecycle',
-                rawPaths: ['patterns-input.json'],
-            }),
-        ]));
-        await expect(readFile(join(workdir, 'wiki/global/historic-sql-old-order-lifecycle.md'), 'utf-8')).resolves.toContain('Order Lifecycle Analysis');
-        await expect(readFile(join(workdir, 'wiki/global/historic-sql-retired-pattern.md'), 'utf-8')).resolves.toContain('stale_since: "2026-05-11T00:00:00.000Z"');
-    });
-    it('rewrites a reappearing archived pattern at the flat slug', async () => {
-        const workdir = await tempWorkdir();
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 2,
-            touchedTableCount: 2,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 30,
-        });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.orders.json', { table: 'public.orders' });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.customers.json', { table: 'public.customers' });
-        await writeText(workdir, 'wiki/global/historic-sql-order-lifecycle-analysis.md', [
-            '---',
-            YAML.stringify({
-                summary: 'Archived order lifecycle page',
-                tags: ['historic-sql', 'pattern', 'archived'],
-                refs: [],
-                sl_refs: ['orders'],
-                usage_mode: 'auto',
-                source: 'historic-sql',
-                tables: ['public.orders', 'public.customers'],
-                fingerprints: ['pg:1'],
-                stale_since: '2026-01-01T00:00:00.000Z',
-            }).trimEnd(),
-            '---',
-            '',
-            'Archived body',
-            '',
-        ].join('\n'));
-        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/pattern.json', {
-            kind: 'pattern',
-            connectionId: 'warehouse',
-            rawPath: 'patterns-input.json',
-            pattern: {
-                slug: 'order-lifecycle-analysis',
-                title: 'Order Lifecycle Analysis',
-                narrative: 'Analysts compare order status with customer segment again.',
-                definitionSql: 'select * from public.orders join public.customers on customers.id = orders.customer_id',
-                tablesInvolved: ['public.orders', 'public.customers'],
-                slRefs: ['orders', 'customers'],
-                constituentTemplateIds: ['pg:1', 'pg:2'],
-            },
-        });
-        const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
-        expect(result.patternPagesWritten).toBe(1);
-        const page = await readFile(join(workdir, 'wiki/global/historic-sql-order-lifecycle-analysis.md'), 'utf-8');
-        expect(page).toContain('Analysts compare order status with customer segment again.');
-        expect(page).not.toContain('Archived body');
-        expect(page).not.toContain('archived');
-    });
-    it('leaves already archived pattern pages stable when they are still absent', async () => {
-        const workdir = await tempWorkdir();
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 0,
-            touchedTableCount: 0,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 30,
-        });
-        await writeText(workdir, 'wiki/global/historic-sql-retired-pattern.md', [
-            '---',
-            YAML.stringify({
-                summary: 'Retired pattern',
-                tags: ['historic-sql', 'pattern', 'archived'],
-                refs: [],
-                sl_refs: [],
-                usage_mode: 'auto',
-                source: 'historic-sql',
-                tables: ['public.tickets'],
-                fingerprints: ['pg:9'],
-                stale_since: '2026-01-01T00:00:00.000Z',
-            }).trimEnd(),
-            '---',
-            '',
-            'Archived retired body',
-            '',
-        ].join('\n'));
-        const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
-        expect(result.archivedPatternPages).toBe(0);
-        expect(result.stalePatternPagesMarked).toBe(0);
-        await expect(readFile(join(workdir, 'wiki/global/historic-sql-retired-pattern.md'), 'utf-8')).resolves.toContain('Archived retired body');
-    });
-    it('marks missing table usage stale without deleting old query pages', async () => {
-        const workdir = await tempWorkdir();
-        await writeText(workdir, 'semantic-layer/warehouse/_schema/public.yaml', YAML.stringify({
-            tables: {
-                orders: {
-                    table: 'public.orders',
-                    usage: {
-                        narrative: 'Orders were active before.',
-                        frequencyTier: 'high',
-                        commonFilters: ['status'],
-                        commonGroupBys: ['status'],
-                        commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-                        ownerNote: 'keep analyst annotation',
-                    },
-                    columns: [{ name: 'id', type: 'string' }],
-                },
-            },
-        }));
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 0,
-            touchedTableCount: 0,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        });
-        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/customers.json', {
-            kind: 'table_usage',
-            connectionId: 'warehouse',
-            table: 'public.customers',
-            rawPath: 'tables/public.customers.json',
-            usage: {
-                narrative: 'Customers were queried.',
-                frequencyTier: 'low',
-                commonFilters: [],
-                commonJoins: [],
-                staleSince: null,
-            },
-        });
-        await writeText(workdir, 'wiki/global/historic-sql-old-template.md', [
-            '---',
-            YAML.stringify({
-                summary: 'Old template page',
-                tags: ['historic-sql', 'query-pattern'],
-                refs: [],
-                sl_refs: ['orders'],
-                usage_mode: 'auto',
-                source: 'historic-sql',
-                tables: ['public.orders'],
-                fingerprints: ['old:1'],
-            }).trimEnd(),
-            '---',
-            '',
-            'Old body',
-            '',
-        ].join('\n'));
-        const result = await projectHistoricSqlEvidence({ workdir, connectionId: 'warehouse', syncId: 'sync-1', runId: 'run-1' });
-        expect(result.staleTablesMarked).toBe(1);
-        expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
-        const staleAction = result.actions.find((action) => action.target === 'sl' && action.key === 'orders');
-        expect(staleAction).toEqual(expect.objectContaining({ target: 'sl', key: 'orders' }));
-        expect(staleAction?.rawPaths).toBeUndefined();
-        const shard = YAML.parse(await readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8'));
-        expect(shard.tables.orders.usage).toEqual({
-            ownerNote: 'keep analyst annotation',
-            narrative: 'No recent historic SQL usage was observed in the latest snapshot.',
-            frequencyTier: 'unused',
-            commonFilters: [],
-            commonGroupBys: [],
-            commonJoins: [],
-            staleSince: '2026-05-11T00:00:00.000Z',
-        });
-        await expect(readFile(join(workdir, 'wiki/global/historic-sql-old-template.md'), 'utf-8')).resolves.toContain('Old body');
-    });
-    it('does not mark stale or archive pages when override replay has no current-run evidence', async () => {
-        const workdir = await tempWorkdir();
-        await writeText(workdir, 'semantic-layer/warehouse/_schema/public.yaml', YAML.stringify({
-            tables: {
-                orders: {
-                    table: 'public.orders',
-                    usage: {
-                        narrative: 'Orders were active before.',
-                        frequencyTier: 'high',
-                        commonFilters: ['status'],
-                        commonGroupBys: ['status'],
-                        commonJoins: [],
-                    },
-                    columns: [{ name: 'id', type: 'string' }],
-                },
-            },
-        }));
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/override-sync/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 0,
-            touchedTableCount: 0,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        });
-        const result = await projectHistoricSqlEvidence({
-            workdir,
-            connectionId: 'warehouse',
-            syncId: 'override-sync',
-            runId: 'override-run',
-            overrideReplay: {
-                priorJobId: 'prior-job',
-                priorRunId: 'prior-run',
-                priorSyncId: 'prior-sync',
-                evictionRawPaths: ['tables/public/orders.json'],
-            },
-        });
-        expect(result.tableUsageMerged).toBe(0);
-        expect(result.staleTablesMarked).toBe(0);
-        expect(result.patternPagesWritten).toBe(0);
-        expect(result.stalePatternPagesMarked).toBe(0);
-        expect(result.archivedPatternPages).toBe(0);
-        expect(result.touchedSources).toEqual([]);
-        expect(result.changedWikiPageKeys).toEqual([]);
-        expect(result.actions).toEqual([]);
-    });
-});

package/dist/context/ingest/adapters/historic-sql/redaction.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/redaction.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compileHistoricSqlRedactionPatterns, redactHistoricSqlText } from './redaction.js';
-describe('historic-SQL redaction', () => {
-    it('redacts regex matches and supports the (?i) case-insensitive prefix', () => {
-        const redactors = compileHistoricSqlRedactionPatterns([
-            'sk_live_[A-Za-z0-9]+',
-            '(?i)secret_token_[a-z0-9]+',
-        ]);
-        const sql = "select * from public.api_events where api_key = 'sk_live_abc123' and note = 'Secret_Token_9f'"; // pragma: allowlist secret
-        expect(redactHistoricSqlText(sql, redactors)).toBe("select * from public.api_events where api_key = '[REDACTED]' and note = '[REDACTED]'");
-    });
-    it('returns the original SQL text when no redaction patterns are configured', () => {
-        const sql = "select * from public.orders where status = 'paid'";
-        expect(redactHistoricSqlText(sql, compileHistoricSqlRedactionPatterns([]))).toBe(sql);
-    });
-    it('throws a config-focused error for invalid redaction regex patterns', () => {
-        expect(() => compileHistoricSqlRedactionPatterns(['[broken'])).toThrow('Invalid historicSql.redactionPatterns entry "[broken"');
-    });
-    it('throws a config-focused error for empty redaction regex patterns', () => {
-        expect(() => compileHistoricSqlRedactionPatterns(['   '])).toThrow('Invalid historicSql.redactionPatterns entry "   "');
-    });
-});

package/dist/context/ingest/adapters/historic-sql/skill-schemas.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/skill-schemas.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { patternOutputSchema, patternsArraySchema, tableUsageOutputSchema, } from './skill-schemas.js';
-describe('historic-sql skill schemas', () => {
-    it('accepts table usage output and preserves future keys', () => {
-        const parsed = tableUsageOutputSchema.parse({
-            narrative: 'Orders are queried for paid/refunded lifecycle analysis.',
-            frequencyTier: 'high',
-            commonFilters: ['status', 'created_at'],
-            commonGroupBys: ['status'],
-            commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-            staleSince: null,
-            analystNote: 'preserve me',
-        });
-        expect(parsed).toMatchObject({
-            narrative: 'Orders are queried for paid/refunded lifecycle analysis.',
-            frequencyTier: 'high',
-            commonFilters: ['status', 'created_at'],
-            commonGroupBys: ['status'],
-            commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-            staleSince: null,
-            analystNote: 'preserve me',
-        });
-    });
-    it('rejects invalid frequency tiers', () => {
-        const result = tableUsageOutputSchema.safeParse({
-            narrative: 'Orders are queried often.',
-            frequencyTier: 'sometimes',
-            commonFilters: [],
-            commonJoins: [],
-        });
-        expect(result.success).toBe(false);
-    });
-    it('accepts pattern outputs used for wiki projection', () => {
-        const parsed = patternsArraySchema.parse([
-            {
-                slug: 'order-lifecycle-analysis',
-                title: 'Order Lifecycle Analysis',
-                narrative: 'Teams inspect order status by customer and month.',
-                definitionSql: 'select status, count(*) from public.orders group by status',
-                tablesInvolved: ['public.orders', 'public.customers'],
-                slRefs: ['orders', 'customers'],
-                constituentTemplateIds: ['template_1', 'template_2'],
-            },
-        ]);
-        expect(parsed[0]).toEqual({
-            slug: 'order-lifecycle-analysis',
-            title: 'Order Lifecycle Analysis',
-            narrative: 'Teams inspect order status by customer and month.',
-            definitionSql: 'select status, count(*) from public.orders group by status',
-            tablesInvolved: ['public.orders', 'public.customers'],
-            slRefs: ['orders', 'customers'],
-            constituentTemplateIds: ['template_1', 'template_2'],
-        });
-    });
-    it('exports zod schemas that can produce JSON schema for prompt prefixes', () => {
-        const tableUsageJsonSchema = z.toJSONSchema(tableUsageOutputSchema);
-        const patternJsonSchema = z.toJSONSchema(patternOutputSchema);
-        expect(tableUsageJsonSchema).toMatchObject({ type: 'object' });
-        expect(patternJsonSchema).toMatchObject({ type: 'object' });
-    });
-});

package/dist/context/ingest/adapters/historic-sql/snowflake-query-history-reader.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/snowflake-query-history-reader.test.js

@@ -1,117 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { HistoricSqlGrantsMissingError } from './errors.js';
-import { SnowflakeHistoricSqlQueryHistoryReader } from './snowflake-query-history-reader.js';
-function queryClient(results) {
-    const executeQuery = vi.fn(async (_query) => {
-        const next = results.shift();
-        if (!next) {
-            throw new Error('unexpected query');
-        }
-        return next;
-    });
-    return { executeQuery };
-}
-function firstQuery(client) {
-    const call = client.executeQuery.mock.calls[0];
-    if (!call) {
-        throw new Error('expected query client to be called');
-    }
-    return call[0];
-}
-describe('SnowflakeHistoricSqlQueryHistoryReader', () => {
-    it('probes SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY', async () => {
-        const client = queryClient([{ headers: ['1'], rows: [[1]], totalRows: 1 }]);
-        const reader = new SnowflakeHistoricSqlQueryHistoryReader();
-        await expect(reader.probe(client)).resolves.toEqual({ warnings: [], info: [] });
-        expect(client.executeQuery).toHaveBeenCalledWith('SELECT 1 FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY LIMIT 1');
-    });
-    it('turns probe result errors into HistoricSqlGrantsMissingError', async () => {
-        const client = queryClient([{ headers: [], rows: [], totalRows: 0, error: 'Object does not exist or not authorized' }]);
-        const reader = new SnowflakeHistoricSqlQueryHistoryReader();
-        await expect(reader.probe(client)).rejects.toMatchObject({
-            name: 'HistoricSqlGrantsMissingError',
-            dialect: 'snowflake',
-            remediation: 'GRANT IMPORTED PRIVILEGES ON DATABASE SNOWFLAKE TO ROLE <connection role>;',
-        });
-    });
-    it('turns thrown probe failures into HistoricSqlGrantsMissingError', async () => {
-        const client = {
-            executeQuery: vi.fn(async () => {
-                throw new Error('permission denied');
-            }),
-        };
-        const reader = new SnowflakeHistoricSqlQueryHistoryReader();
-        await expect(reader.probe(client)).rejects.toBeInstanceOf(HistoricSqlGrantsMissingError);
-    });
-    it('fetches aggregated Snowflake query templates', async () => {
-        const client = queryClient([
-            {
-                headers: [
-                    'template_id',
-                    'canonical_sql',
-                    'executions',
-                    'distinct_users',
-                    'first_seen',
-                    'last_seen',
-                    'p50_ms',
-                    'p95_ms',
-                    'error_rate',
-                    'rows_produced',
-                    'top_users',
-                ],
-                rows: [
-                    [
-                        'hash-1',
-                        'select status from orders',
-                        42,
-                        3,
-                        '2026-05-01T00:00:00.000Z',
-                        '2026-05-11T00:00:00.000Z',
-                        12,
-                        40,
-                        0.05,
-                        100,
-                        JSON.stringify([{ user: 'ANALYST', executions: 1 }]),
-                    ],
-                ],
-                totalRows: 1,
-            },
-        ]);
-        const reader = new SnowflakeHistoricSqlQueryHistoryReader();
-        const rows = [];
-        for await (const row of reader.fetchAggregated(client, { start: new Date('2026-02-10T00:00:00.000Z'), end: new Date('2026-05-11T00:00:00.000Z') }, { dialect: 'snowflake', minExecutions: 5, windowDays: 90, enabledTables: [], filters: { dropTrivialProbes: true }, redactionPatterns: [], staleArchiveAfterDays: 90 })) {
-            rows.push(row);
-        }
-        const sql = firstQuery(client);
-        expect(sql).toContain('SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY');
-        expect(sql).toContain('COUNT(*) AS executions');
-        expect(sql).toContain('GROUP BY query_hash');
-        expect(sql).toContain('HAVING COUNT(*) >= 5');
-        expect(rows).toMatchObject([
-            {
-                templateId: 'hash-1',
-                stats: {
-                    executions: 42,
-                    errorRate: 0.05,
-                },
-                topUsers: [{ user: 'ANALYST', executions: 1 }],
-            },
-        ]);
-    });
-    it('throws a clear error when the query client cannot execute SQL', async () => {
-        const reader = new SnowflakeHistoricSqlQueryHistoryReader();
-        await expect(async () => {
-            for await (const _row of reader.fetchAggregated({}, { start: new Date(), end: new Date() }, {
-                dialect: 'snowflake',
-                minExecutions: 5,
-                windowDays: 90,
-                enabledTables: [],
-                filters: { dropTrivialProbes: true },
-                redactionPatterns: [],
-                staleArchiveAfterDays: 90,
-            })) {
-                throw new Error('unreachable');
-            }
-        }).rejects.toThrow('Historic SQL Snowflake reader requires a query client with executeQuery(query)');
-    });
-});

package/dist/context/ingest/adapters/historic-sql/stage-unified.test.d.ts

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