@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/node_modules/@ktx/context/dist/ingest/adapters/looker/types.d.ts

@@ -13,13 +13,13 @@ export declare const lookerPullConfigSchema: z.ZodObject<{
     lookUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     connectionTypes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        SNOWFLAKE: "SNOWFLAKE";
+        POSTGRESQL: "POSTGRESQL";
         BIGQUERY: "BIGQUERY";
+        SNOWFLAKE: "SNOWFLAKE";
         MYSQL: "MYSQL";
-        CLICKHOUSE: "CLICKHOUSE";
-        POSTGRESQL: "POSTGRESQL";
-        SQLITE: "SQLITE";
         SQLSERVER: "SQLSERVER";
+        SQLITE: "SQLITE";
+        CLICKHOUSE: "CLICKHOUSE";
         CENTRALREACH: "CENTRALREACH";
         EPIC: "EPIC";
         CERNER: "CERNER";
@@ -44,9 +44,9 @@ export declare const lookerPullConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
-            no_connection_mapping: "no_connection_mapping";
             no_physical_table: "no_physical_table";
             multiple_table_references: "multiple_table_references";
             unsupported_dialect: "unsupported_dialect";
@@ -89,9 +89,9 @@ export declare const stagedLookerQuerySchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
-            no_connection_mapping: "no_connection_mapping";
             no_physical_table: "no_physical_table";
             multiple_table_references: "multiple_table_references";
             unsupported_dialect: "unsupported_dialect";
@@ -131,9 +131,9 @@ export declare const stagedDashboardFileSchema: z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 ok: z.ZodLiteral<false>;
                 reason: z.ZodEnum<{
+                    no_connection_mapping: "no_connection_mapping";
                     looker_template_unresolved: "looker_template_unresolved";
                     derived_table_not_supported: "derived_table_not_supported";
-                    no_connection_mapping: "no_connection_mapping";
                     no_physical_table: "no_physical_table";
                     multiple_table_references: "multiple_table_references";
                     unsupported_dialect: "unsupported_dialect";
@@ -171,9 +171,9 @@ export declare const stagedLookFileSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             ok: z.ZodLiteral<false>;
             reason: z.ZodEnum<{
+                no_connection_mapping: "no_connection_mapping";
                 looker_template_unresolved: "looker_template_unresolved";
                 derived_table_not_supported: "derived_table_not_supported";
-                no_connection_mapping: "no_connection_mapping";
                 no_physical_table: "no_physical_table";
                 multiple_table_references: "multiple_table_references";
                 unsupported_dialect: "unsupported_dialect";
@@ -255,9 +255,9 @@ export declare const stagedExploreFileSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             ok: z.ZodLiteral<false>;
             reason: z.ZodEnum<{
+                no_connection_mapping: "no_connection_mapping";
                 looker_template_unresolved: "looker_template_unresolved";
                 derived_table_not_supported: "derived_table_not_supported";
-                no_connection_mapping: "no_connection_mapping";
                 no_physical_table: "no_physical_table";
                 multiple_table_references: "multiple_table_references";
                 unsupported_dialect: "unsupported_dialect";
@@ -276,9 +276,9 @@ export declare const stagedExploreFileSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
-            no_connection_mapping: "no_connection_mapping";
             no_physical_table: "no_physical_table";
             multiple_table_references: "multiple_table_references";
             unsupported_dialect: "unsupported_dialect";
@@ -352,10 +352,10 @@ export declare const stagedLookerFetchIssueSchema: z.ZodObject<{
     retryRecommended: z.ZodDefault<z.ZodBoolean>;
     kind: z.ZodOptional<z.ZodEnum<{
         lookml_connection_mismatch: "lookml_connection_mismatch";
-        unmapped_looker_connection: "unmapped_looker_connection";
-        unparseable_sql_table_name: "unparseable_sql_table_name";
         looker_template_unresolved: "looker_template_unresolved";
         derived_table_not_supported: "derived_table_not_supported";
+        unmapped_looker_connection: "unmapped_looker_connection";
+        unparseable_sql_table_name: "unparseable_sql_table_name";
     }>>;
     details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
@@ -386,10 +386,10 @@ export declare const stagedLookerFetchReportSchema: z.ZodObject<{
         retryRecommended: z.ZodDefault<z.ZodBoolean>;
         kind: z.ZodOptional<z.ZodEnum<{
             lookml_connection_mismatch: "lookml_connection_mismatch";
-            unmapped_looker_connection: "unmapped_looker_connection";
-            unparseable_sql_table_name: "unparseable_sql_table_name";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
+            unmapped_looker_connection: "unmapped_looker_connection";
+            unparseable_sql_table_name: "unparseable_sql_table_name";
         }>>;
         details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
@@ -413,10 +413,10 @@ export declare const stagedLookerFetchReportSchema: z.ZodObject<{
         retryRecommended: z.ZodDefault<z.ZodBoolean>;
         kind: z.ZodOptional<z.ZodEnum<{
             lookml_connection_mismatch: "lookml_connection_mismatch";
-            unmapped_looker_connection: "unmapped_looker_connection";
-            unparseable_sql_table_name: "unparseable_sql_table_name";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
+            unmapped_looker_connection: "unmapped_looker_connection";
+            unparseable_sql_table_name: "unparseable_sql_table_name";
         }>>;
         details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/pull-config.d.ts

@@ -14,9 +14,9 @@ export declare const lookmlPullConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
-            no_connection_mapping: "no_connection_mapping";
             no_physical_table: "no_physical_table";
             multiple_table_references: "multiple_table_references";
             unsupported_dialect: "unsupported_dialect";

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

@@ -46,6 +46,15 @@ function resolvePath(index, collectionId) {
 export async function fetchMetabaseBundle(params) {
     const pullConfig = parseMetabasePullConfig(params.pullConfig);
     const logger = params.logger ?? noopMetabaseFetchLogger;
+    const emitFetchProgress = (percent, message, transient = false) => {
+        params.ctx.memoryFlow?.emit({
+            type: 'stage_progress',
+            stage: 'source',
+            percent,
+            message,
+            ...(transient ? { transient } : {}),
+        });
+    };
     const syncState = await params.sourceStateReader.getSourceState(pullConfig.metabaseConnectionId);
     const mapping = syncState.mappings.find((m) => m.metabaseDatabaseId === pullConfig.metabaseDatabaseId && m.syncEnabled);
     if (!mapping?.targetConnectionId) {
@@ -56,6 +65,7 @@ export async function fetchMetabaseBundle(params) {
     }
     const client = await params.clientFactory.createClient(pullConfig, params.ctx);
     try {
+        emitFetchProgress(26, `Fetching Metabase database ${pullConfig.metabaseDatabaseId} metadata`);
         let mappingDatabaseName = mapping.metabaseDatabaseName;
         let mappingEngine = mapping.metabaseEngine;
         if (mappingDatabaseName === null) {
@@ -86,6 +96,7 @@ export async function fetchMetabaseBundle(params) {
         await mkdir(join(params.stagedDir, STAGED_FILES.collectionsDir), { recursive: true });
         await mkdir(join(params.stagedDir, STAGED_FILES.databasesDir), { recursive: true });
         const cardIdsToFetch = await resolveCardIdsToFetch(client, scope, pullConfig.metabaseDatabaseId, logger);
+        emitFetchProgress(28, `Fetching ${cardIdsToFetch.length} Metabase card${cardIdsToFetch.length === 1 ? '' : 's'} for database ${pullConfig.metabaseDatabaseId}`);
         const referencedCollectionIds = new Set();
         let writtenCards = 0;
         const fetched = new Set();
@@ -154,7 +165,12 @@ export async function fetchMetabaseBundle(params) {
                     }
                 }
             }
+            const knownTotal = Math.max(cardIdsToFetch.length, fetched.size + queue.length);
+            if (fetched.size === 1 || fetched.size % 10 === 0 || queue.length === 0) {
+                emitFetchProgress(30, `Checked ${fetched.size}/${knownTotal} Metabase cards for database ${pullConfig.metabaseDatabaseId}; wrote ${writtenCards}`, true);
+            }
         }
+        emitFetchProgress(32, `Fetched Metabase database ${pullConfig.metabaseDatabaseId}: ${writtenCards} cards, ${unresolvedCards.length} unresolved`);
         for (const colId of referencedCollectionIds) {
             const node = collectionIndex.get(colId);
             if (!node) {

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

@@ -119,6 +119,47 @@ describe('fetchMetabaseBundle', () => {
         expect(log).not.toHaveBeenCalled();
         expect(warn).not.toHaveBeenCalled();
     });
+    it('emits memory-flow progress while fetching Metabase cards', async () => {
+        const events = [];
+        await fetchMetabaseBundle({
+            pullConfig: { metabaseConnectionId, metabaseDatabaseId: 42 },
+            stagedDir,
+            ctx: {
+                ...makeFetchContext(),
+                memoryFlow: {
+                    emit: (event) => events.push(event),
+                    update: vi.fn(),
+                    finish: vi.fn(),
+                    snapshot: vi.fn(),
+                },
+            },
+            clientFactory,
+            sourceStateReader,
+        });
+        expect(events).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'stage_progress',
+                stage: 'source',
+                message: 'Fetching Metabase database 42 metadata',
+            }),
+            expect.objectContaining({
+                type: 'stage_progress',
+                stage: 'source',
+                message: 'Fetching 1 Metabase card for database 42',
+            }),
+            expect.objectContaining({
+                type: 'stage_progress',
+                stage: 'source',
+                message: 'Checked 1/1 Metabase cards for database 42; wrote 1',
+                transient: true,
+            }),
+            expect.objectContaining({
+                type: 'stage_progress',
+                stage: 'source',
+                message: 'Fetched Metabase database 42: 1 cards, 0 unresolved',
+            }),
+        ]));
+    });
     it('routes Metabase fetch warnings through the injected logger', async () => {
         const logger = {
             log: vi.fn(),

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/metricflow.adapter.d.ts

@@ -1,4 +1,4 @@
-import type { ChunkResult, DiffSet, FetchContext, SourceAdapter } from '../../types.js';
+import type { ChunkResult, DeterministicProjectionContext, DiffSet, FetchContext, ProjectionResult, SourceAdapter } from '../../types.js';
 export interface MetricflowSourceAdapterDeps {
     homeDir: string;
     targetConnectionIds?: string[];
@@ -12,5 +12,6 @@ export declare class MetricflowSourceAdapter implements SourceAdapter {
     fetch(pullConfig: unknown, stagedDir: string, ctx: FetchContext): Promise<void>;
     listTargetConnectionIds(_stagedDir: string): Promise<string[]>;
     chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
+    project(ctx: DeterministicProjectionContext): Promise<ProjectionResult>;
     private resolveCacheDir;
 }

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/metricflow.adapter.js

@@ -3,7 +3,9 @@ import { chunkMetricFlowProject } from './chunk.js';
 import { detectMetricFlowStagedDir } from './detect.js';
 import { parseMetricflowFiles } from './deep-parse.js';
 import { fetchMetricflowRepo } from './fetch.js';
+import { importMetricflowSemanticModels } from './import-semantic-models.js';
 import { parseMetricFlowStagedDir } from './parse.js';
+import { metricflowHostTablesFromParsedTargets, readMetricflowProjectionConfig, writeMetricflowProjectionConfig, } from './projection-config.js';
 import { parseMetricflowPullConfig } from './pull-config.js';
 function uniqueSorted(values) {
     return [...new Set(values ?? [])].sort((left, right) => left.localeCompare(right));
@@ -25,6 +27,9 @@ export class MetricflowSourceAdapter {
             cacheDir: this.resolveCacheDir(ctx.connectionId),
             stagedDir,
         });
+        await writeMetricflowProjectionConfig(stagedDir, {
+            parsedTargetTables: config.parsedTargetTables,
+        });
     }
     async listTargetConnectionIds(_stagedDir) {
         return uniqueSorted(this.deps.targetConnectionIds);
@@ -35,6 +40,31 @@ export class MetricflowSourceAdapter {
         const parseArtifacts = parseMetricflowStagedDirForImport(project);
         return { ...chunk, parseArtifacts };
     }
+    async project(ctx) {
+        if (!isMetricFlowParseResult(ctx.parseArtifacts)) {
+            return {
+                warnings: [],
+                errors: ['MetricFlow deterministic projection requires parseArtifacts from chunk()'],
+                touchedSources: [],
+                changedWikiPageKeys: [],
+            };
+        }
+        const projectionConfig = await readMetricflowProjectionConfig(ctx.stagedDir);
+        const result = await importMetricflowSemanticModels({ semanticLayerService: ctx.semanticLayerService }, {
+            connectionId: ctx.connectionId,
+            parseResult: ctx.parseArtifacts,
+            targetSchema: null,
+            hostTables: metricflowHostTablesFromParsedTargets(projectionConfig.parsedTargetTables),
+            workdir: ctx.workdir,
+        });
+        return {
+            result,
+            warnings: result.warnings,
+            errors: result.errors,
+            touchedSources: result.touchedSources,
+            changedWikiPageKeys: [],
+        };
+    }
     resolveCacheDir(connectionId) {
         return join(this.deps.homeDir, 'ingest-metricflow-repos', connectionId);
     }
@@ -42,3 +72,13 @@ export class MetricflowSourceAdapter {
 function parseMetricflowStagedDirForImport(project) {
     return parseMetricflowFiles(project.files);
 }
+function isMetricFlowParseResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (Array.isArray(candidate.semanticModels) &&
+        Array.isArray(candidate.crossModelMetrics) &&
+        Array.isArray(candidate.relationships) &&
+        Array.isArray(candidate.warnings));
+}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/metricflow.adapter.test.js

@@ -1,9 +1,10 @@
 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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { makeLocalGitRepo } from '../../../test/make-local-git-repo.js';
 import { MetricflowSourceAdapter } from './metricflow.adapter.js';
+import { readMetricflowProjectionConfig, writeMetricflowProjectionConfig } from './projection-config.js';
 function compileOnlyRequiredDepsCheck() {
     // @ts-expect-error MetricflowSourceAdapter requires an explicit cache home.
     new MetricflowSourceAdapter();
@@ -18,6 +19,24 @@ async function makeRepo(tmpRoot, files) {
     }
     return makeLocalGitRepo(fixtureDir, join(tmpRoot, 'origin'));
 }
+function metricflowParseResult() {
+    return {
+        semanticModels: [
+            {
+                name: 'orders',
+                description: 'Orders',
+                modelRef: 'orders',
+                dimensions: [{ name: 'status', column: 'status', type: 'string', label: 'Status' }],
+                measures: [{ type: 'simple', name: 'order_count', column: 'id', aggregation: 'count' }],
+                entities: [{ name: 'customer', type: 'foreign', expr: 'customer_id' }],
+                defaultTimeDimension: null,
+            },
+        ],
+        crossModelMetrics: [],
+        relationships: [],
+        warnings: ['parser warning'],
+    };
+}
 describe('MetricflowSourceAdapter', () => {
     let tmpRoot;
     let stagedDir;
@@ -94,4 +113,100 @@ describe('MetricflowSourceAdapter', () => {
         await expect(readFile(join(stagedDir, 'models/orders.yml'), 'utf-8')).resolves.toContain('semantic_models');
         expect(await adapter.detect(stagedDir)).toBe(true);
     });
+    it('persists parsed target tables for deterministic projection during fetch', async () => {
+        const repo = await makeRepo(tmpRoot, {
+            'dbt_project.yml': 'name: analytics\n',
+            'models/orders.yml': 'semantic_models:\n  - name: orders\n    model: ref("orders")\n',
+        });
+        await adapter.fetch?.({
+            repoUrl: repo.repoUrl,
+            branch: 'main',
+            path: null,
+            authToken: null,
+            parsedTargetTables: {
+                orders: {
+                    ok: true,
+                    catalog: null,
+                    schema: 'analytics',
+                    name: 'orders',
+                    canonicalTable: 'analytics.orders',
+                },
+            },
+        }, stagedDir, { connectionId: 'warehouse-1', sourceKey: 'metricflow' });
+        await expect(readMetricflowProjectionConfig(stagedDir)).resolves.toMatchObject({
+            parsedTargetTables: {
+                orders: {
+                    ok: true,
+                    schema: 'analytics',
+                    name: 'orders',
+                },
+            },
+        });
+    });
+    it('projects parsed MetricFlow semantic models in the integration worktree', async () => {
+        await writeMetricflowProjectionConfig(stagedDir, {
+            parsedTargetTables: {
+                orders: {
+                    ok: true,
+                    catalog: null,
+                    schema: 'analytics',
+                    name: 'orders',
+                    canonicalTable: 'analytics.orders',
+                },
+            },
+        });
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue(null),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi.fn().mockResolvedValue({ warnings: [] }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await adapter.project?.({
+            connectionId: 'warehouse-1',
+            sourceKey: 'metricflow',
+            syncId: 'sync-1',
+            jobId: 'job-1',
+            runId: 'run-1',
+            stagedDir,
+            workdir: '/tmp/metricflow-integration',
+            parseArtifacts: metricflowParseResult(),
+            semanticLayerService: semanticLayerService,
+        });
+        expect(semanticLayerService.forWorktree).toHaveBeenCalledWith('/tmp/metricflow-integration');
+        expect(scoped.writeSource).toHaveBeenCalledWith('warehouse-1', expect.objectContaining({ name: 'orders' }), 'dbt MetricFlow', expect.any(String), 'dbt MetricFlow sync: create source orders', { skipValidation: true });
+        expect(result).toMatchObject({
+            warnings: ['parser warning'],
+            errors: [],
+            touchedSources: [{ connectionId: 'warehouse-1', sourceName: 'orders' }],
+            changedWikiPageKeys: [],
+        });
+    });
+    it('returns a projection error when parse artifacts are missing', async () => {
+        const result = await adapter.project?.({
+            connectionId: 'warehouse-1',
+            sourceKey: 'metricflow',
+            syncId: 'sync-1',
+            jobId: 'job-1',
+            runId: 'run-1',
+            stagedDir,
+            workdir: '/tmp/metricflow-integration',
+            parseArtifacts: undefined,
+            semanticLayerService: {},
+        });
+        expect(result).toMatchObject({
+            warnings: [],
+            errors: ['MetricFlow deterministic projection requires parseArtifacts from chunk()'],
+            touchedSources: [],
+            changedWikiPageKeys: [],
+        });
+    });
 });

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/projection-config.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { type ParsedTargetTable } from '../../parsed-target-table.js';
+import type { MetricflowHostTable } from './semantic-models.js';
+declare const metricflowProjectionConfigSchema: z.ZodObject<{
+    parsedTargetTables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        catalog: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        canonicalTable: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            no_physical_table: "no_physical_table";
+            multiple_table_references: "multiple_table_references";
+            unsupported_dialect: "unsupported_dialect";
+            parse_error: "parse_error";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "ok">>>;
+}, z.core.$strip>;
+export type MetricflowProjectionConfig = z.infer<typeof metricflowProjectionConfigSchema>;
+export declare function writeMetricflowProjectionConfig(stagedDir: string, config: MetricflowProjectionConfig): Promise<void>;
+export declare function readMetricflowProjectionConfig(stagedDir: string): Promise<MetricflowProjectionConfig>;
+export declare function metricflowHostTablesFromParsedTargets(parsedTargetTables: Record<string, ParsedTargetTable>): MetricflowHostTable[];
+export {};

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/projection-config.js

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { parsedTargetTableSchema } from '../../parsed-target-table.js';
+const METRICFLOW_PROJECTION_CONFIG_FILE = 'sync-config.json';
+const metricflowProjectionConfigSchema = z.object({
+    parsedTargetTables: z.record(z.string(), parsedTargetTableSchema).default({}),
+});
+export async function writeMetricflowProjectionConfig(stagedDir, config) {
+    const parsed = metricflowProjectionConfigSchema.parse(config);
+    await mkdir(stagedDir, { recursive: true });
+    await writeFile(join(stagedDir, METRICFLOW_PROJECTION_CONFIG_FILE), `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8');
+}
+export async function readMetricflowProjectionConfig(stagedDir) {
+    const path = join(stagedDir, METRICFLOW_PROJECTION_CONFIG_FILE);
+    try {
+        return metricflowProjectionConfigSchema.parse(JSON.parse(await readFile(path, 'utf-8')));
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return { parsedTargetTables: {} };
+        }
+        throw error;
+    }
+}
+export function metricflowHostTablesFromParsedTargets(parsedTargetTables) {
+    return Object.entries(parsedTargetTables)
+        .flatMap(([id, table]) => table.ok
+        ? [
+            {
+                id,
+                name: table.name,
+                catalog: table.catalog,
+                db: table.schema,
+                columns: [],
+            },
+        ]
+        : [])
+        .sort((left, right) => left.id.localeCompare(right.id));
+}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/pull-config.d.ts

@@ -14,9 +14,9 @@ export declare const metricflowPullConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
             looker_template_unresolved: "looker_template_unresolved";
             derived_table_not_supported: "derived_table_not_supported";
-            no_connection_mapping: "no_connection_mapping";
             no_physical_table: "no_physical_table";
             multiple_table_references: "multiple_table_references";
             unsupported_dialect: "unsupported_dialect";

package/node_modules/@ktx/context/dist/ingest/artifact-gates.d.ts

@@ -0,0 +1,25 @@
+import type { SemanticLayerService } from '../sl/index.js';
+import type { TouchedSlSource } from '../tools/index.js';
+import type { KnowledgeWikiService } from '../wiki/index.js';
+export interface TouchedValidationResult {
+    invalidSources: string[];
+    validSources: string[];
+}
+export interface FinalArtifactGateInput {
+    connectionIds: string[];
+    changedWikiPageKeys: string[];
+    touchedSlSources: TouchedSlSource[];
+    wikiService: KnowledgeWikiService;
+    semanticLayerService: SemanticLayerService;
+    validateTouchedSources(touched: TouchedSlSource[]): Promise<TouchedValidationResult>;
+    tableExists(connectionId: string, tableRef: string): Promise<boolean>;
+}
+export interface ProvenanceRawPathValidationInput {
+    rows: Array<{
+        rawPath: string;
+    }>;
+    currentRawPaths: Set<string>;
+    deletedRawPaths: Set<string>;
+}
+export declare function validateFinalIngestArtifacts(input: FinalArtifactGateInput): Promise<void>;
+export declare function validateProvenanceRawPaths(input: ProvenanceRawPathValidationInput): void;