@kaelio/ktx 0.4.1 → 0.6.0

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

@@ -1,171 +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 { parseMetricFlowStagedDir } from './parse.js';
-async function writeFixture(stagedDir, relPath, body) {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, body, 'utf-8');
-}
-describe('parseMetricFlowStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'mf-parse-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('extracts one semantic_model with its measures + dimensions + entities', async () => {
-        await writeFixture(stagedDir, 'models/orders.yml', [
-            'semantic_models:',
-            '  - name: orders',
-            '    description: Order fact table.',
-            "    model: ref('orders')",
-            '    entities:',
-            '      - name: order_id',
-            '        type: primary',
-            '      - name: customer_id',
-            '        type: foreign',
-            '    dimensions:',
-            '      - name: ordered_at',
-            '        type: time',
-            '        type_params:',
-            '          time_granularity: day',
-            '    measures:',
-            '      - name: order_count',
-            '        agg: count',
-            '        expr: order_id',
-            '      - name: gross_amount',
-            '        agg: sum',
-            '        expr: amount',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toHaveLength(1);
-        const sm = project.semanticModels[0];
-        expect(sm.path).toBe('models/orders.yml');
-        expect(sm.name).toBe('orders');
-        expect(sm.modelRef).toBe('orders');
-        expect(sm.measureNames).toEqual(['gross_amount', 'order_count']);
-        expect(sm.dimensionNames).toEqual(['ordered_at']);
-        expect(sm.entityNames).toEqual(['customer_id', 'order_id']);
-        expect(sm.primaryEntities).toEqual(['order_id']);
-        expect(sm.foreignEntities).toEqual(['customer_id']);
-        expect(sm.extendsFrom).toEqual([]);
-        expect(project.files).toEqual([
-            {
-                path: 'models/orders.yml',
-                content: expect.stringContaining('semantic_models:'),
-            },
-        ]);
-    });
-    it('captures `extends:` as a string OR a list', async () => {
-        await writeFixture(stagedDir, 'models/orders.yml', [
-            'semantic_models:',
-            '  - name: orders',
-            "    model: ref('orders')",
-            '    measures:',
-            '      - {name: order_count, agg: count, expr: order_id}',
-            '',
-        ].join('\n'));
-        await writeFixture(stagedDir, 'models/orders_ext_list.yml', [
-            'semantic_models:',
-            '  - name: orders_ext_list',
-            "    model: ref('orders_ext')",
-            '    extends: [orders]',
-            '    measures:',
-            '      - {name: refund_amount, agg: sum, expr: refund_amt}',
-            '',
-        ].join('\n'));
-        await writeFixture(stagedDir, 'models/orders_ext_str.yml', [
-            'semantic_models:',
-            '  - name: orders_ext_str',
-            "    model: ref('orders_ext')",
-            '    extends: orders',
-            '    measures:',
-            '      - {name: refund_amount2, agg: sum, expr: refund_amt2}',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        const list = project.semanticModels.find((sm) => sm.name === 'orders_ext_list');
-        const str = project.semanticModels.find((sm) => sm.name === 'orders_ext_str');
-        expect(list?.extendsFrom).toEqual(['orders']);
-        expect(str?.extendsFrom).toEqual(['orders']);
-    });
-    it('extracts metrics with referenced measures for simple + derived + ratio + cumulative', async () => {
-        await writeFixture(stagedDir, 'metrics/core.yml', [
-            'metrics:',
-            '  - name: total_orders',
-            '    type: simple',
-            '    type_params:',
-            '      measure: order_count',
-            '  - name: revenue',
-            '    type: derived',
-            '    type_params:',
-            '      expr: gross_amount - refund_amount',
-            '      metrics:',
-            '        - name: gross_amount',
-            '        - name: refund_amount',
-            '  - name: refund_rate',
-            '    type: ratio',
-            '    type_params:',
-            '      numerator: refund_amount',
-            '      denominator: gross_amount',
-            '  - name: cum_revenue',
-            '    type: cumulative',
-            '    type_params:',
-            '      measure: gross_amount',
-            '      window: 7 days',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.metrics).toHaveLength(4);
-        const byName = new Map(project.metrics.map((m) => [m.name, m]));
-        expect(byName.get('total_orders')?.type).toBe('simple');
-        expect(byName.get('total_orders')?.measureRef).toBe('order_count');
-        expect(byName.get('revenue')?.type).toBe('derived');
-        expect(byName.get('revenue')?.dependsOn.sort()).toEqual(['gross_amount', 'refund_amount']);
-        expect(byName.get('refund_rate')?.type).toBe('ratio');
-        expect(byName.get('refund_rate')?.dependsOn.sort()).toEqual(['gross_amount', 'refund_amount']);
-        expect(byName.get('cum_revenue')?.type).toBe('cumulative');
-        expect(byName.get('cum_revenue')?.measureRef).toBe('gross_amount');
-    });
-    it('returns empty arrays for a non-MetricFlow YAML (e.g. dbt_project.yml)', async () => {
-        await writeFixture(stagedDir, 'dbt_project.yml', 'name: my_proj\nversion: "1.0.0"\n');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toEqual([]);
-        expect(project.metrics).toEqual([]);
-        expect(project.allPaths).toEqual(['dbt_project.yml']);
-    });
-    it('skips files that are not YAML (or fail to parse) without throwing', async () => {
-        await writeFixture(stagedDir, 'broken.yml', '{ this is: not valid YAML :::');
-        await writeFixture(stagedDir, 'other.txt', 'ignore me');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.semanticModels).toEqual([]);
-        expect(project.metrics).toEqual([]);
-        // allPaths includes `.yml` / `.yaml` only, even when unparseable:
-        expect(project.allPaths).toEqual(['broken.yml']);
-    });
-    it('allPaths is sorted deterministically', async () => {
-        await writeFixture(stagedDir, 'models/z.yml', 'semantic_models: []\n');
-        await writeFixture(stagedDir, 'models/a.yml', 'semantic_models: []\n');
-        await writeFixture(stagedDir, 'metrics/b.yaml', 'metrics: []\n');
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        expect(project.allPaths).toEqual(['metrics/b.yaml', 'models/a.yml', 'models/z.yml']);
-    });
-    it("extracts modelRef from ref('name') and source('src','table') and literal strings", async () => {
-        await writeFixture(stagedDir, 'models/a.yml', [
-            'semantic_models:',
-            '  - {name: a, model: "ref(\'orders\')", measures: [{name: c, agg: count, expr: id}]}',
-            "  - {name: b, model: \"source('raw','orders_raw')\", measures: [{name: c, agg: count, expr: id}]}",
-            '  - {name: c, model: plain_table, measures: [{name: c, agg: count, expr: id}]}',
-            '',
-        ].join('\n'));
-        const project = await parseMetricFlowStagedDir(stagedDir);
-        const byName = new Map(project.semanticModels.map((s) => [s.name, s]));
-        expect(byName.get('a')?.modelRef).toBe('orders');
-        expect(byName.get('b')?.modelRef).toBe('orders_raw');
-        expect(byName.get('c')?.modelRef).toBe('plain_table');
-    });
-});

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

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { parsedTargetTableSchema } from '../../parsed-target-table.js';
-export declare const metricflowPullConfigSchema: z.ZodObject<{
-    repoUrl: z.ZodString;
-    branch: z.ZodDefault<z.ZodString>;
-    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    authToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    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 MetricflowPullConfig = z.infer<typeof metricflowPullConfigSchema>;
-export interface MetricflowIntegrationLike {
-    repoUrl: string | null;
-    branch?: string | null;
-    path?: string | null;
-    authToken?: string | null;
-    parsedTargetTables?: Record<string, z.infer<typeof parsedTargetTableSchema>>;
-}
-export declare function parseMetricflowPullConfig(raw: unknown): MetricflowPullConfig;
-export declare function pullConfigFromMetricflowIntegration(integration: MetricflowIntegrationLike): MetricflowPullConfig;

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

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { parsedTargetTableSchema } from '../../parsed-target-table.js';
-export const metricflowPullConfigSchema = z.object({
-    repoUrl: z.string().url(),
-    branch: z.string().default('main'),
-    path: z.string().nullable().default(null),
-    authToken: z.string().nullable().default(null),
-    parsedTargetTables: z.record(z.string(), parsedTargetTableSchema).default({}),
-});
-export function parseMetricflowPullConfig(raw) {
-    return metricflowPullConfigSchema.parse(raw);
-}
-export function pullConfigFromMetricflowIntegration(integration) {
-    if (!integration.repoUrl) {
-        throw new Error('metricflow integration config missing repoUrl');
-    }
-    return parseMetricflowPullConfig({
-        repoUrl: integration.repoUrl,
-        branch: integration.branch ?? 'main',
-        path: integration.path ?? null,
-        authToken: integration.authToken ?? null,
-        parsedTargetTables: integration.parsedTargetTables ?? {},
-    });
-}

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

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

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

@@ -1,57 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMetricflowPullConfig, pullConfigFromMetricflowIntegration } from './pull-config.js';
-describe('metricflow pull config', () => {
-    it('applies defaults for optional git fields', () => {
-        const parsed = parseMetricflowPullConfig({
-            repoUrl: 'https://github.com/acme/analytics.git',
-        });
-        expect(parsed).toEqual({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'main',
-            path: null,
-            authToken: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('preserves provided branch, path, token, and parsed target tables', () => {
-        const parsed = parseMetricflowPullConfig({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'release',
-            path: 'dbt',
-            authToken: 'secret-token',
-            parsedTargetTables: {
-                orders: {
-                    catalog: 'warehouse',
-                    schema: 'marts',
-                    name: 'orders',
-                    ok: true,
-                    canonicalTable: 'analytics.marts.orders',
-                },
-            },
-        });
-        expect(parsed.branch).toBe('release');
-        expect(parsed.path).toBe('dbt');
-        expect(parsed.authToken).toBe('secret-token');
-        expect(parsed.parsedTargetTables.orders).toMatchObject({ ok: true, name: 'orders' });
-    });
-    it('rejects missing repoUrl', () => {
-        expect(() => parseMetricflowPullConfig({})).toThrow();
-    });
-    it('builds pull config from a local metricflow integration block', () => {
-        expect(pullConfigFromMetricflowIntegration({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: null,
-            path: null,
-            authToken: null,
-        })).toEqual({
-            repoUrl: 'https://github.com/acme/analytics.git',
-            branch: 'main',
-            path: null,
-            authToken: null,
-            parsedTargetTables: {},
-        });
-    });
-    it('throws a clear error when the integration block has no repo URL', () => {
-        expect(() => pullConfigFromMetricflowIntegration({ repoUrl: null })).toThrow('metricflow integration config missing repoUrl');
-    });
-});

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/semantic-models.d.ts

@@ -1,39 +0,0 @@
-import type { SemanticLayerSource } from '../../../sl/index.js';
-import type { ParsedCrossModelMetric, ParsedMetricflowRelationship, ParsedSemanticModel } from './deep-parse.js';
-export interface MetricflowHostTable {
-    id: string;
-    name: string;
-    catalog: string | null;
-    db: string | null;
-    columns: Array<{
-        id: string;
-        name: string;
-    }>;
-}
-export interface MetricflowSemanticModelImportContext {
-    model: ParsedSemanticModel;
-    matchedTable: MetricflowHostTable | undefined;
-    sourceName: string;
-    manifestSource: SemanticLayerSource | null;
-}
-export type MetricflowSemanticModelJoin = SemanticLayerSource['joins'][number];
-export type MetricflowWritableSemanticLayerSource = Pick<SemanticLayerSource, 'name'> & Partial<Omit<SemanticLayerSource, 'name'>>;
-export declare function toKebabCaseMetricflowName(str: string): string;
-export declare function mapSemanticModelToSource(model: ParsedSemanticModel, tableRef?: string): SemanticLayerSource;
-export declare function mapCrossModelMetricToSource(metric: ParsedCrossModelMetric): SemanticLayerSource;
-export declare function findMatchingMetricflowTable(modelRef: string, hostTables: MetricflowHostTable[], targetSchema?: string | null): MetricflowHostTable | undefined;
-export declare function resolveMetricflowSemanticModelSourceName(model: ParsedSemanticModel, matchedTable: MetricflowHostTable | undefined): string;
-export declare function buildMetricflowJoinsForModel(model: ParsedSemanticModel, relationships: ParsedMetricflowRelationship[], sourceNameByModelRef: Map<string, string>, availableTargetModelRefs?: Set<string>): MetricflowSemanticModelJoin[];
-export declare function buildMetricflowSemanticModelSource(context: MetricflowSemanticModelImportContext, joins: MetricflowSemanticModelJoin[], sourceNameByManifestName: Map<string, string>): MetricflowWritableSemanticLayerSource;
-export declare function buildMetricflowMeasures(model: ParsedSemanticModel): SemanticLayerSource['measures'];
-export declare function buildMetricflowColumns(model: ParsedSemanticModel): SemanticLayerSource['columns'];
-export declare function filterValidMetricflowRelationships(relationships: ParsedMetricflowRelationship[], availableColumnNamesByModelRef: Map<string, Set<string>>): ParsedMetricflowRelationship[];
-export declare function getMetricflowAvailableColumnNames(context: MetricflowSemanticModelImportContext): Set<string>;
-export declare function countImportableMetricflowRelationships(relationships: ParsedMetricflowRelationship[], hostTables: MetricflowHostTable[]): number;
-export declare function normalizeMetricflowJoinOn(on: string): string;
-export declare function rewriteMetricflowManifestJoins(joins: SemanticLayerSource['joins'], sourceNameByManifestName: Map<string, string>): SemanticLayerSource['joins'];
-export declare function rewriteMetricflowJoinOn(on: string, sourceNameByManifestName: Map<string, string>): string;
-export declare function parseMetricflowJoinReference(ref: string): {
-    table: string;
-    column: string;
-} | null;

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/semantic-models.js

@@ -1,278 +0,0 @@
-export function toKebabCaseMetricflowName(str) {
-    return str
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-|-$/g, '');
-}
-export function mapSemanticModelToSource(model, tableRef) {
-    return {
-        name: toKebabCaseMetricflowName(model.modelRef),
-        table: tableRef ?? model.modelRef,
-        grain: model.dimensions.map((d) => d.column),
-        columns: model.dimensions.map((d) => ({
-            name: d.column,
-            type: d.type,
-            ...(d.description ? { description: d.description } : {}),
-        })),
-        measures: model.measures.map((m) => {
-            if (m.type === 'simple') {
-                return {
-                    name: m.name,
-                    expr: `${m.aggregation}(${m.column})`,
-                    ...(m.description ? { description: m.description } : {}),
-                    ...(m.filter ? { filter: m.filter } : {}),
-                };
-            }
-            return {
-                name: m.name,
-                expr: m.expr,
-                ...(m.description ? { description: m.description } : {}),
-            };
-        }),
-        joins: [],
-        descriptions: { dbt: model.description ?? model.modelRef },
-    };
-}
-export function mapCrossModelMetricToSource(metric) {
-    return {
-        name: toKebabCaseMetricflowName(metric.name),
-        sql: metric.expr,
-        descriptions: { dbt: metric.description ?? metric.name },
-        grain: [],
-        columns: [],
-        measures: [
-            {
-                name: metric.name,
-                expr: metric.expr,
-                ...(metric.description ? { description: metric.description } : {}),
-                ...(metric.filter ? { filter: metric.filter } : {}),
-            },
-        ],
-        joins: [],
-    };
-}
-export function findMatchingMetricflowTable(modelRef, hostTables, targetSchema) {
-    const ref = modelRef.toLowerCase();
-    if (targetSchema) {
-        const schemaMatch = hostTables.find((table) => table.name.toLowerCase() === ref && table.db?.toLowerCase() === targetSchema.toLowerCase());
-        if (schemaMatch) {
-            return schemaMatch;
-        }
-    }
-    const nameMatches = hostTables.filter((table) => table.name.toLowerCase() === ref);
-    if (nameMatches.length === 1) {
-        return nameMatches[0];
-    }
-    const byTablePart = hostTables.filter((table) => {
-        const parts = table.name.toLowerCase().split('.');
-        return parts[parts.length - 1] === ref;
-    });
-    if (byTablePart.length === 1) {
-        return byTablePart[0];
-    }
-    const suffixMatches = hostTables.filter((table) => table.name.toLowerCase().endsWith(`.${ref}`) || table.name.toLowerCase().endsWith(`_${ref}`));
-    if (suffixMatches.length === 1) {
-        return suffixMatches[0];
-    }
-    return undefined;
-}
-export function resolveMetricflowSemanticModelSourceName(model, matchedTable) {
-    const candidate = matchedTable?.name ?? model.modelRef;
-    const bare = candidate.includes('.') ? (candidate.split('.').pop() ?? candidate) : candidate;
-    return toSnakeCaseIdentifier(bare) || toSnakeCaseIdentifier(model.modelRef);
-}
-export function buildMetricflowJoinsForModel(model, relationships, sourceNameByModelRef, availableTargetModelRefs) {
-    const fromSourceName = sourceNameByModelRef.get(model.modelRef);
-    if (!fromSourceName) {
-        return [];
-    }
-    const joins = [];
-    for (const relationship of relationships) {
-        if (relationship.fromTable !== model.modelRef) {
-            continue;
-        }
-        if (availableTargetModelRefs && !availableTargetModelRefs.has(relationship.toTable)) {
-            continue;
-        }
-        const toSourceName = sourceNameByModelRef.get(relationship.toTable);
-        if (!toSourceName) {
-            continue;
-        }
-        joins.push({
-            to: toSourceName,
-            on: `${fromSourceName}.${relationship.fromColumn} = ${toSourceName}.${relationship.toColumn}`,
-            relationship: 'many_to_one',
-        });
-    }
-    return joins;
-}
-export function buildMetricflowSemanticModelSource(context, joins, sourceNameByManifestName) {
-    const { model, sourceName, manifestSource, matchedTable } = context;
-    if (manifestSource?.name === sourceName) {
-        return mapMetricflowSemanticModelToOverlay(model, sourceName, joins);
-    }
-    if (manifestSource) {
-        return mapMetricflowSemanticModelToMergedStandalone(model, sourceName, manifestSource, joins, sourceNameByManifestName);
-    }
-    return mapMetricflowSemanticModelToStandalone(model, sourceName, matchedTable?.name ?? model.modelRef, joins);
-}
-export function buildMetricflowMeasures(model) {
-    return model.measures.map((measure) => {
-        if (measure.type === 'simple') {
-            return {
-                name: measure.name,
-                expr: `${measure.aggregation}(${measure.column})`,
-                ...(measure.description ? { description: measure.description } : {}),
-                ...(measure.filter ? { filter: measure.filter } : {}),
-            };
-        }
-        return {
-            name: measure.name,
-            expr: measure.expr,
-            ...(measure.description ? { description: measure.description } : {}),
-        };
-    });
-}
-export function buildMetricflowColumns(model) {
-    const columns = model.dimensions.map((dimension) => ({
-        name: dimension.column,
-        type: dimension.type,
-        ...(dimension.description ? { description: dimension.description } : {}),
-    }));
-    const existingNames = new Set(columns.map((column) => column.name.toLowerCase()));
-    for (const entity of model.entities) {
-        const columnName = (entity.expr ?? entity.name)?.trim();
-        if (!columnName) {
-            continue;
-        }
-        const normalizedName = columnName.toLowerCase();
-        if (existingNames.has(normalizedName)) {
-            continue;
-        }
-        columns.push({
-            name: columnName,
-            type: 'string',
-            visibility: 'hidden',
-            ...(entity.description ? { description: entity.description } : {}),
-        });
-        existingNames.add(normalizedName);
-    }
-    return columns;
-}
-export function filterValidMetricflowRelationships(relationships, availableColumnNamesByModelRef) {
-    return relationships.filter((relationship) => {
-        const fromColumns = availableColumnNamesByModelRef.get(relationship.fromTable);
-        const toColumns = availableColumnNamesByModelRef.get(relationship.toTable);
-        if (!fromColumns || !toColumns) {
-            return false;
-        }
-        return fromColumns.has(relationship.fromColumn.toLowerCase()) && toColumns.has(relationship.toColumn.toLowerCase());
-    });
-}
-export function getMetricflowAvailableColumnNames(context) {
-    const columns = context.manifestSource?.columns ?? buildMetricflowColumns(context.model);
-    return new Set(columns.map((column) => column.name.toLowerCase()));
-}
-export function countImportableMetricflowRelationships(relationships, hostTables) {
-    const tablesByName = new Map();
-    for (const table of hostTables) {
-        tablesByName.set(table.name.toLowerCase(), table);
-    }
-    let validCount = 0;
-    for (const relationship of relationships) {
-        const fromTable = tablesByName.get(relationship.fromTable.toLowerCase());
-        const toTable = tablesByName.get(relationship.toTable.toLowerCase());
-        if (!fromTable || !toTable) {
-            continue;
-        }
-        const fromColumn = fromTable.columns.find((column) => column.name.toLowerCase() === relationship.fromColumn.toLowerCase());
-        const toColumn = toTable.columns.find((column) => column.name.toLowerCase() === relationship.toColumn.toLowerCase());
-        if (!fromColumn || !toColumn) {
-            continue;
-        }
-        validCount++;
-    }
-    return validCount;
-}
-function mapMetricflowSemanticModelToStandalone(model, sourceName, tableRef, joins) {
-    return {
-        name: sourceName,
-        table: tableRef,
-        grain: model.dimensions.map((dimension) => dimension.column),
-        columns: buildMetricflowColumns(model),
-        measures: buildMetricflowMeasures(model),
-        joins,
-        descriptions: { dbt: model.description ?? model.modelRef },
-    };
-}
-function mapMetricflowSemanticModelToMergedStandalone(model, sourceName, manifestSource, joins, sourceNameByManifestName) {
-    const rewrittenManifestJoins = rewriteMetricflowManifestJoins(manifestSource.joins, sourceNameByManifestName);
-    return {
-        ...manifestSource,
-        name: sourceName,
-        measures: buildMetricflowMeasures(model),
-        joins: mergeMetricflowJoins(rewrittenManifestJoins, joins),
-        descriptions: {
-            ...(manifestSource.descriptions ?? {}),
-            dbt: model.description ?? model.modelRef,
-        },
-    };
-}
-function mapMetricflowSemanticModelToOverlay(model, sourceName, joins) {
-    const overlay = {
-        name: sourceName,
-        descriptions: { dbt: model.description ?? model.modelRef },
-        measures: buildMetricflowMeasures(model),
-    };
-    if (joins.length > 0) {
-        overlay.joins = joins;
-    }
-    return overlay;
-}
-function mergeMetricflowJoins(baseJoins, overlayJoins) {
-    const existingKeys = new Set(baseJoins.map((join) => `${join.to}::${normalizeMetricflowJoinOn(join.on)}`));
-    const newJoins = overlayJoins.filter((join) => !existingKeys.has(`${join.to}::${normalizeMetricflowJoinOn(join.on)}`));
-    return [...baseJoins, ...newJoins];
-}
-export function normalizeMetricflowJoinOn(on) {
-    return on.replace(/\s+/g, ' ').trim();
-}
-export function rewriteMetricflowManifestJoins(joins, sourceNameByManifestName) {
-    return joins.map((join) => ({
-        ...join,
-        to: sourceNameByManifestName.get(join.to) ?? join.to,
-        on: rewriteMetricflowJoinOn(join.on, sourceNameByManifestName),
-    }));
-}
-export function rewriteMetricflowJoinOn(on, sourceNameByManifestName) {
-    const parts = on.split('=');
-    if (parts.length !== 2) {
-        return on;
-    }
-    const left = parseMetricflowJoinReference(parts[0].trim());
-    const right = parseMetricflowJoinReference(parts[1].trim());
-    if (!left || !right) {
-        return on;
-    }
-    const leftTable = sourceNameByManifestName.get(left.table) ?? left.table;
-    const rightTable = sourceNameByManifestName.get(right.table) ?? right.table;
-    return `${leftTable}.${left.column} = ${rightTable}.${right.column}`;
-}
-export function parseMetricflowJoinReference(ref) {
-    const lastDot = ref.lastIndexOf('.');
-    if (lastDot <= 0 || lastDot === ref.length - 1) {
-        return null;
-    }
-    return {
-        table: ref.slice(0, lastDot).trim(),
-        column: ref.slice(lastDot + 1).trim(),
-    };
-}
-function toSnakeCaseIdentifier(str) {
-    return str
-        .trim()
-        .replace(/[^a-zA-Z0-9_]+/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '')
-        .toLowerCase();
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/semantic-models.test.d.ts

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