@duckcodeailabs/dql-cli 0.8.5 → 0.8.7

package/dist/semantic-import.js

@@ -0,0 +1,713 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { CubejsProvider, DbtProvider, SnowflakeSemanticProvider, resolveRepoSource, } from '@duckcodeailabs/dql-core';
+const MANIFEST_RELATIVE_PATH = 'semantic-layer/imports/manifest.json';
+export async function performSemanticImport(opts) {
+    const targetProjectRoot = resolve(opts.targetProjectRoot);
+    const previousManifest = loadSemanticImportManifest(targetProjectRoot);
+    const previousManaged = new Set(previousManifest?.generatedFiles ?? []);
+    const source = resolveImportSource(opts.targetProjectRoot, opts.sourceConfig);
+    const layer = await loadLayerForImport(opts.provider, source.localPath, source.config, opts.executeQuery);
+    const warnings = [...source.warnings, ...collectImportWarnings(opts.provider, layer)];
+    const objects = collectObjects(layer);
+    const generatedFiles = [];
+    const manifestObjects = [];
+    for (const relPath of previousManaged) {
+        const absPath = join(targetProjectRoot, relPath);
+        if (existsSync(absPath)) {
+            rmSync(absPath, { force: true });
+        }
+    }
+    for (const object of objects) {
+        const normalizedDomain = normalizeDomain(object.domain);
+        const filePath = buildSemanticFilePath(object.kind, normalizedDomain, object.name);
+        const absPath = join(targetProjectRoot, filePath);
+        if (existsSync(absPath) && !previousManaged.has(filePath)) {
+            throw new Error(`Import conflict: ${filePath} already exists and is not managed by semantic import.`);
+        }
+        mkdirSync(dirname(absPath), { recursive: true });
+        writeFileSync(absPath, serializeSemanticObject(object), 'utf-8');
+        generatedFiles.push(filePath);
+        manifestObjects.push({
+            id: objectId(object.kind, object.name),
+            kind: object.kind,
+            name: object.name,
+            label: object.label,
+            domain: normalizedDomain,
+            cube: 'cube' in object ? object.cube : undefined,
+            filePath,
+            source: object.source,
+        });
+    }
+    const manifest = {
+        version: 1,
+        mode: 'imported',
+        provider: opts.provider,
+        importedAt: new Date().toISOString(),
+        source: {
+            projectPath: opts.sourceConfig.projectPath,
+            repoUrl: opts.sourceConfig.repoUrl,
+            branch: opts.sourceConfig.branch,
+            subPath: opts.sourceConfig.subPath,
+            connection: opts.sourceConfig.connection,
+        },
+        warnings,
+        generatedFiles: [...generatedFiles, MANIFEST_RELATIVE_PATH],
+        objects: manifestObjects,
+    };
+    const manifestPath = join(targetProjectRoot, MANIFEST_RELATIVE_PATH);
+    mkdirSync(dirname(manifestPath), { recursive: true });
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+    applyCanonicalSemanticConfig(targetProjectRoot);
+    return {
+        manifest,
+        counts: countObjects(manifestObjects),
+    };
+}
+export function syncSemanticImport(opts) {
+    const manifest = loadSemanticImportManifest(opts.targetProjectRoot);
+    if (!manifest) {
+        throw new Error('No semantic import manifest found. Run `dql semantic import <provider>` first.');
+    }
+    const sourceConfig = {
+        provider: manifest.provider,
+        projectPath: manifest.source.projectPath,
+        repoUrl: manifest.source.repoUrl,
+        branch: manifest.source.branch,
+        subPath: manifest.source.subPath,
+        connection: manifest.source.connection,
+    };
+    return performSemanticImport({
+        targetProjectRoot: opts.targetProjectRoot,
+        provider: manifest.provider,
+        sourceConfig,
+        executeQuery: opts.executeQuery,
+    });
+}
+export function loadSemanticImportManifest(projectRoot) {
+    const manifestPath = join(resolve(projectRoot), MANIFEST_RELATIVE_PATH);
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function buildSemanticTree(layer, manifest) {
+    const providerName = manifest?.provider ?? 'dql';
+    const domains = layer.listDomains();
+    const cubes = layer.listCubes();
+    const metrics = layer.listMetrics();
+    const dimensions = layer.listDimensions();
+    const hierarchies = layer.listHierarchies();
+    const segments = layer.listSegments();
+    const preAggregations = layer.listPreAggregations();
+    const domainNodes = domains.map((domain) => {
+        const domainCubes = cubes.filter((cube) => cube.domain === domain);
+        const looseMetrics = metrics.filter((metric) => metric.domain === domain && !metric.cube);
+        const looseDimensions = dimensions.filter((dimension) => dimension.domain === domain && !dimension.cube);
+        const domainHierarchies = hierarchies.filter((hierarchy) => hierarchy.domain === domain);
+        const cubeNodes = domainCubes.map((cube) => ({
+            id: objectId('cube', cube.name),
+            label: cube.label,
+            kind: 'cube',
+            count: cube.measures.length +
+                cube.dimensions.length +
+                cube.timeDimensions.length +
+                cube.segments.length +
+                cube.preAggregations.length,
+            meta: {
+                provider: cube.source?.provider ?? providerName,
+                domain: normalizeDomain(cube.domain),
+                cube: cube.name,
+                owner: cube.owner ?? null,
+                tags: (cube.tags ?? []).join(','),
+                table: cube.table,
+            },
+            children: [
+                buildGroupNode('metric', 'Measures', cube.measures.map((metric) => toLeaf('metric', metric.name, metric.label, {
+                    provider: metric.source?.provider ?? providerName,
+                    domain: normalizeDomain(metric.domain),
+                    cube: metric.cube ?? cube.name,
+                    owner: metric.owner ?? cube.owner ?? null,
+                    tags: (metric.tags ?? []).join(','),
+                    table: metric.table,
+                }))),
+                buildGroupNode('dimension', 'Dimensions', [...cube.dimensions, ...cube.timeDimensions].map((dimension) => toLeaf('dimension', dimension.name, dimension.label, {
+                    provider: dimension.source?.provider ?? providerName,
+                    domain: normalizeDomain(dimension.domain),
+                    cube: dimension.cube ?? cube.name,
+                    owner: dimension.owner ?? cube.owner ?? null,
+                    tags: (dimension.tags ?? []).join(','),
+                    table: dimension.table,
+                }))),
+                buildGroupNode('segment', 'Segments', cube.segments.map((segment) => toLeaf('segment', segment.name, segment.label, {
+                    provider: segment.source?.provider ?? providerName,
+                    domain: normalizeDomain(segment.domain),
+                    cube: segment.cube || cube.name,
+                    owner: segment.owner ?? cube.owner ?? null,
+                    tags: (segment.tags ?? []).join(','),
+                }))),
+                buildGroupNode('pre_aggregation', 'Pre-aggregations', cube.preAggregations.map((preAggregation) => toLeaf('pre_aggregation', preAggregation.name, preAggregation.label, {
+                    provider: preAggregation.source?.provider ?? providerName,
+                    domain: normalizeDomain(preAggregation.domain),
+                    cube: preAggregation.cube || cube.name,
+                    owner: preAggregation.owner ?? cube.owner ?? null,
+                    tags: (preAggregation.tags ?? []).join(','),
+                }))),
+            ].filter((node) => Boolean(node)),
+        }));
+        const children = [...cubeNodes];
+        const looseNodes = [
+            buildGroupNode('metric', 'Metrics', looseMetrics.map((metric) => toLeaf('metric', metric.name, metric.label, {
+                provider: metric.source?.provider ?? providerName,
+                domain: normalizeDomain(metric.domain),
+                cube: metric.cube ?? null,
+                owner: metric.owner ?? null,
+                tags: (metric.tags ?? []).join(','),
+                table: metric.table,
+            }))),
+            buildGroupNode('dimension', 'Dimensions', looseDimensions.map((dimension) => toLeaf('dimension', dimension.name, dimension.label, {
+                provider: dimension.source?.provider ?? providerName,
+                domain: normalizeDomain(dimension.domain),
+                cube: dimension.cube ?? null,
+                owner: dimension.owner ?? null,
+                tags: (dimension.tags ?? []).join(','),
+                table: dimension.table,
+            }))),
+            buildGroupNode('hierarchy', 'Hierarchies', domainHierarchies.map((hierarchy) => toLeaf('hierarchy', hierarchy.name, hierarchy.label, {
+                provider: hierarchy.source?.provider ?? providerName,
+                domain: normalizeDomain(hierarchy.domain),
+                owner: hierarchy.owner ?? null,
+                tags: (hierarchy.tags ?? []).join(','),
+            }))),
+            buildGroupNode('segment', 'Segments', segments.filter((segment) => segment.domain === domain && !segment.cube).map((segment) => toLeaf('segment', segment.name, segment.label, {
+                provider: segment.source?.provider ?? providerName,
+                domain: normalizeDomain(segment.domain),
+                cube: segment.cube || null,
+                owner: segment.owner ?? null,
+                tags: (segment.tags ?? []).join(','),
+            }))),
+            buildGroupNode('pre_aggregation', 'Pre-aggregations', preAggregations.filter((preAggregation) => preAggregation.domain === domain && !preAggregation.cube).map((preAggregation) => toLeaf('pre_aggregation', preAggregation.name, preAggregation.label, {
+                provider: preAggregation.source?.provider ?? providerName,
+                domain: normalizeDomain(preAggregation.domain),
+                cube: preAggregation.cube || null,
+                owner: preAggregation.owner ?? null,
+                tags: (preAggregation.tags ?? []).join(','),
+            }))),
+        ].filter((node) => Boolean(node));
+        children.push(...looseNodes);
+        return {
+            id: `domain:${domain}`,
+            label: domain,
+            kind: 'domain',
+            count: children.reduce((sum, node) => sum + (node.count ?? 0), 0),
+            meta: {
+                provider: providerName,
+                domain,
+            },
+            children,
+        };
+    });
+    return {
+        id: `provider:${manifest?.provider ?? 'dql'}`,
+        label: manifest?.provider ? `${manifest.provider} import` : 'semantic layer',
+        kind: 'provider',
+        count: domains.length,
+        meta: {
+            provider: providerName,
+            importedAt: manifest?.importedAt ?? null,
+            warnings: manifest?.warnings.length ?? 0,
+        },
+        children: domainNodes,
+    };
+}
+export function buildSemanticObjectDetail(layer, manifest, id) {
+    const [kind, ...rest] = id.split(':');
+    const name = rest.join(':');
+    const manifestObject = manifest?.objects.find((object) => object.id === id) ?? null;
+    const importedAt = manifest?.importedAt ?? null;
+    if (kind === 'cube') {
+        const cube = layer.getCube(name);
+        if (!cube)
+            return null;
+        return {
+            id,
+            kind: 'cube',
+            name: cube.name,
+            label: cube.label,
+            description: cube.description,
+            domain: cube.domain || normalizeDomain(undefined),
+            table: cube.table,
+            sql: cube.sql,
+            tags: cube.tags ?? [],
+            owner: cube.owner ?? null,
+            source: cube.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+            joins: cube.joins,
+        };
+    }
+    if (kind === 'metric') {
+        const metric = layer.getMetric(name);
+        if (!metric)
+            return null;
+        return {
+            id,
+            kind: 'metric',
+            name: metric.name,
+            label: metric.label,
+            description: metric.description,
+            domain: normalizeDomain(metric.domain),
+            cube: metric.cube,
+            table: metric.table,
+            sql: metric.sql,
+            type: metric.type,
+            tags: metric.tags ?? [],
+            owner: metric.owner ?? null,
+            source: metric.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+        };
+    }
+    if (kind === 'dimension') {
+        const dimension = layer.getDimension(name);
+        if (!dimension)
+            return null;
+        return {
+            id,
+            kind: 'dimension',
+            name: dimension.name,
+            label: dimension.label,
+            description: dimension.description,
+            domain: normalizeDomain(dimension.domain),
+            cube: dimension.cube,
+            table: dimension.table,
+            sql: dimension.sql,
+            type: dimension.type,
+            tags: dimension.tags ?? [],
+            owner: dimension.owner ?? null,
+            source: dimension.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+        };
+    }
+    if (kind === 'hierarchy') {
+        const hierarchy = layer.getHierarchy(name);
+        if (!hierarchy)
+            return null;
+        return {
+            id,
+            kind: 'hierarchy',
+            name: hierarchy.name,
+            label: hierarchy.label,
+            description: hierarchy.description,
+            domain: normalizeDomain(hierarchy.domain),
+            tags: hierarchy.tags ?? [],
+            owner: hierarchy.owner ?? null,
+            source: hierarchy.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+            levels: hierarchy.levels,
+        };
+    }
+    if (kind === 'segment') {
+        const segment = layer.getSegment(name);
+        if (!segment)
+            return null;
+        return {
+            id,
+            kind: 'segment',
+            name: segment.name,
+            label: segment.label,
+            description: segment.description,
+            domain: normalizeDomain(segment.domain),
+            cube: segment.cube,
+            sql: segment.sql,
+            tags: segment.tags ?? [],
+            owner: segment.owner ?? null,
+            source: segment.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+        };
+    }
+    if (kind === 'pre_aggregation') {
+        const preAggregation = layer.getPreAggregation(name);
+        if (!preAggregation)
+            return null;
+        return {
+            id,
+            kind: 'pre_aggregation',
+            name: preAggregation.name,
+            label: preAggregation.label,
+            description: preAggregation.description,
+            domain: normalizeDomain(preAggregation.domain),
+            cube: preAggregation.cube,
+            sql: preAggregation.sql,
+            tags: preAggregation.tags ?? [],
+            owner: preAggregation.owner ?? null,
+            source: preAggregation.source ?? manifestObject?.source ?? null,
+            filePath: manifestObject?.filePath ?? null,
+            importedAt,
+            measures: preAggregation.measures,
+            dimensions: preAggregation.dimensions,
+            timeDimension: preAggregation.timeDimension,
+            granularity: preAggregation.granularity,
+            refreshKey: preAggregation.refreshKey,
+        };
+    }
+    return null;
+}
+/**
+ * Preview a semantic import without writing any files.
+ * Returns counts, domains, warnings, and object summaries.
+ */
+export async function previewSemanticImport(opts) {
+    const targetProjectRoot = resolve(opts.targetProjectRoot);
+    const source = resolveImportSource(targetProjectRoot, opts.sourceConfig);
+    const layer = await loadLayerForImport(opts.provider, source.localPath, source.config, opts.executeQuery);
+    const warnings = [...source.warnings, ...collectImportWarnings(opts.provider, layer)];
+    const objects = collectObjects(layer);
+    const summaries = objects.map((obj) => ({
+        kind: obj.kind,
+        name: obj.name,
+        label: obj.label,
+        domain: normalizeDomain(obj.domain),
+    }));
+    const domains = [...new Set(summaries.map((o) => o.domain))].sort();
+    return {
+        provider: opts.provider,
+        counts: countObjects(summaries.map((o) => ({ ...o, id: objectId(o.kind, o.name), filePath: '' }))),
+        domains,
+        warnings,
+        objects: summaries,
+    };
+}
+/**
+ * Compute the diff between the current manifest and a fresh import, without applying changes.
+ */
+export async function computeSyncDiff(opts) {
+    const manifest = loadSemanticImportManifest(opts.targetProjectRoot);
+    if (!manifest) {
+        throw new Error('No semantic import manifest found. Run `dql semantic import <provider>` first.');
+    }
+    const sourceConfig = {
+        provider: manifest.provider,
+        projectPath: manifest.source.projectPath,
+        repoUrl: manifest.source.repoUrl,
+        branch: manifest.source.branch,
+        subPath: manifest.source.subPath,
+        connection: manifest.source.connection,
+    };
+    const targetProjectRoot = resolve(opts.targetProjectRoot);
+    const source = resolveImportSource(targetProjectRoot, sourceConfig);
+    const layer = await loadLayerForImport(manifest.provider, source.localPath, source.config, opts.executeQuery);
+    const newObjects = collectObjects(layer);
+    const newById = new Map(newObjects.map((obj) => [objectId(obj.kind, obj.name), obj]));
+    const oldById = new Map(manifest.objects.map((obj) => [obj.id, obj]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    let unchanged = 0;
+    for (const [id, obj] of newById) {
+        const old = oldById.get(id);
+        if (!old) {
+            added.push({ kind: obj.kind, name: obj.name, label: obj.label, domain: normalizeDomain(obj.domain) });
+        }
+        else {
+            // Compare domain and label to detect changes
+            const oldDomain = old.domain;
+            const newDomain = normalizeDomain(obj.domain);
+            if (old.label !== obj.label || oldDomain !== newDomain) {
+                changed.push({ kind: obj.kind, name: obj.name, label: obj.label, domain: newDomain });
+            }
+            else {
+                unchanged++;
+            }
+        }
+    }
+    for (const [id, old] of oldById) {
+        if (!newById.has(id)) {
+            removed.push({ kind: old.kind, name: old.name, label: old.label, domain: old.domain });
+        }
+    }
+    return { added, removed, changed, unchanged };
+}
+function resolveImportSource(targetProjectRoot, sourceConfig) {
+    const projectRoot = resolve(targetProjectRoot);
+    if (sourceConfig.provider === 'snowflake') {
+        return {
+            localPath: projectRoot,
+            config: sourceConfig,
+            warnings: [],
+        };
+    }
+    if (sourceConfig.projectPath && !sourceConfig.repoUrl && sourceConfig.source !== 'github' && sourceConfig.source !== 'gitlab') {
+        return {
+            localPath: resolve(projectRoot, sourceConfig.projectPath),
+            config: { ...sourceConfig, projectPath: undefined },
+            warnings: [],
+        };
+    }
+    const resolved = resolveRepoSource(sourceConfig, projectRoot);
+    return {
+        localPath: resolved.localPath,
+        config: { ...sourceConfig, projectPath: undefined, source: 'local' },
+        warnings: resolved.warnings,
+    };
+}
+async function loadLayerForImport(provider, sourceRoot, config, executeQuery) {
+    if (provider === 'dbt') {
+        return new DbtProvider().load({ ...config, provider }, sourceRoot);
+    }
+    if (provider === 'cubejs') {
+        return new CubejsProvider().load({ ...config, provider }, sourceRoot);
+    }
+    if (!executeQuery) {
+        throw new Error('Snowflake semantic import requires an active query executor.');
+    }
+    return new SnowflakeSemanticProvider(executeQuery).loadAsync({ ...config, provider }, sourceRoot);
+}
+function collectObjects(layer) {
+    return [
+        ...layer.listCubes().map((cube) => ({ ...cube, kind: 'cube' })),
+        ...layer.listMetrics().map((metric) => ({ ...metric, kind: 'metric' })),
+        ...layer.listDimensions().map((dimension) => ({ ...dimension, kind: 'dimension' })),
+        ...layer.listHierarchies().map((hierarchy) => ({ ...hierarchy, kind: 'hierarchy' })),
+        ...layer.listSegments().map((segment) => ({ ...segment, kind: 'segment' })),
+        ...layer.listPreAggregations().map((preAggregation) => ({ ...preAggregation, kind: 'pre_aggregation' })),
+    ];
+}
+function buildSemanticFilePath(kind, domain, name) {
+    const folder = kind === 'pre_aggregation' ? 'pre_aggregations' : `${kind}s`.replace('hierarchys', 'hierarchies');
+    return join('semantic-layer', folder, slugifyPathSegment(domain), `${slugifyPathSegment(name)}.yaml`);
+}
+function serializeSemanticObject(object) {
+    const lines = [
+        `name: ${yamlScalar(object.name)}`,
+        `label: ${yamlScalar(object.label)}`,
+        `description: ${yamlScalar(object.description)}`,
+        `domain: ${yamlScalar(object.domain || normalizeDomain(undefined))}`,
+    ];
+    if ('table' in object && object.table)
+        lines.push(`table: ${yamlScalar(object.table)}`);
+    if ('cube' in object && object.cube)
+        lines.push(`cube: ${yamlScalar(object.cube)}`);
+    if ('sql' in object && typeof object.sql === 'string')
+        lines.push(`sql: ${yamlBlockScalar(object.sql)}`);
+    if ('type' in object && typeof object.type === 'string')
+        lines.push(`type: ${yamlScalar(object.type)}`);
+    if ('aggregation' in object && object.aggregation)
+        lines.push(`aggregation: ${yamlScalar(object.aggregation)}`);
+    if ('owner' in object && object.owner)
+        lines.push(`owner: ${yamlScalar(object.owner)}`);
+    if ('tags' in object && object.tags && object.tags.length > 0) {
+        lines.push('tags:');
+        for (const tag of object.tags)
+            lines.push(`  - ${yamlScalar(tag)}`);
+    }
+    if (object.source) {
+        lines.push('source:');
+        lines.push(`  provider: ${yamlScalar(object.source.provider)}`);
+        lines.push(`  objectType: ${yamlScalar(object.source.objectType)}`);
+        lines.push(`  objectId: ${yamlScalar(object.source.objectId)}`);
+        if (object.source.objectName)
+            lines.push(`  objectName: ${yamlScalar(object.source.objectName)}`);
+        if (object.source.importedAt)
+            lines.push(`  importedAt: ${yamlScalar(object.source.importedAt)}`);
+        if (object.source.extra && Object.keys(object.source.extra).length > 0) {
+            lines.push('  extra:');
+            for (const [key, value] of Object.entries(object.source.extra)) {
+                lines.push(`    ${key}: ${yamlScalar(String(value))}`);
+            }
+        }
+    }
+    if (object.kind === 'hierarchy') {
+        lines.push('levels:');
+        for (const level of object.levels) {
+            lines.push(`  - name: ${yamlScalar(level.name)}`);
+            lines.push(`    label: ${yamlScalar(level.label)}`);
+            lines.push(`    description: ${yamlScalar(level.description)}`);
+            lines.push(`    dimension: ${yamlScalar(level.dimension)}`);
+            lines.push(`    order: ${level.order}`);
+        }
+    }
+    if (object.kind === 'cube') {
+        lines.push('measures:');
+        for (const measure of object.measures) {
+            lines.push(`  - name: ${yamlScalar(measure.name)}`);
+            lines.push(`    label: ${yamlScalar(measure.label)}`);
+            lines.push(`    description: ${yamlScalar(measure.description)}`);
+            lines.push(`    sql: ${yamlBlockScalar(measure.sql, 4)}`);
+            lines.push(`    type: ${yamlScalar(measure.type)}`);
+            if (measure.aggregation)
+                lines.push(`    aggregation: ${yamlScalar(measure.aggregation)}`);
+        }
+        lines.push('dimensions:');
+        for (const dimension of object.dimensions) {
+            lines.push(`  - name: ${yamlScalar(dimension.name)}`);
+            lines.push(`    label: ${yamlScalar(dimension.label)}`);
+            lines.push(`    description: ${yamlScalar(dimension.description)}`);
+            lines.push(`    sql: ${yamlBlockScalar(dimension.sql, 4)}`);
+            lines.push(`    type: ${yamlScalar(dimension.type)}`);
+        }
+        if (object.timeDimensions.length > 0) {
+            lines.push('time_dimensions:');
+            for (const dimension of object.timeDimensions) {
+                lines.push(`  - name: ${yamlScalar(dimension.name)}`);
+                lines.push(`    label: ${yamlScalar(dimension.label)}`);
+                lines.push(`    description: ${yamlScalar(dimension.description)}`);
+                lines.push(`    sql: ${yamlBlockScalar(dimension.sql, 4)}`);
+                lines.push('    granularities:');
+                for (const granularity of dimension.granularities) {
+                    lines.push(`      - ${yamlScalar(granularity)}`);
+                }
+                if (dimension.primaryTime)
+                    lines.push('    primary_time: true');
+            }
+        }
+        if (object.joins.length > 0) {
+            lines.push('joins:');
+            for (const joinDef of object.joins) {
+                lines.push(`  - name: ${yamlScalar(joinDef.name)}`);
+                lines.push(`    right: ${yamlScalar(joinDef.right)}`);
+                lines.push(`    type: ${yamlScalar(joinDef.type)}`);
+                lines.push(`    sql: ${yamlBlockScalar(joinDef.sql, 4)}`);
+            }
+        }
+        if (object.segments.length > 0) {
+            lines.push('segments:');
+            for (const segment of object.segments) {
+                lines.push(`  - name: ${yamlScalar(segment.name)}`);
+                lines.push(`    label: ${yamlScalar(segment.label)}`);
+                lines.push(`    description: ${yamlScalar(segment.description)}`);
+                lines.push(`    sql: ${yamlBlockScalar(segment.sql, 4)}`);
+            }
+        }
+        if (object.preAggregations.length > 0) {
+            lines.push('pre_aggregations:');
+            for (const preAggregation of object.preAggregations) {
+                lines.push(`  - name: ${yamlScalar(preAggregation.name)}`);
+                lines.push(`    label: ${yamlScalar(preAggregation.label)}`);
+                lines.push(`    description: ${yamlScalar(preAggregation.description)}`);
+                if (preAggregation.measures?.length) {
+                    lines.push('    measures:');
+                    for (const measure of preAggregation.measures)
+                        lines.push(`      - ${yamlScalar(measure)}`);
+                }
+                if (preAggregation.dimensions?.length) {
+                    lines.push('    dimensions:');
+                    for (const dimension of preAggregation.dimensions)
+                        lines.push(`      - ${yamlScalar(dimension)}`);
+                }
+                if (preAggregation.timeDimension)
+                    lines.push(`    timeDimension: ${yamlScalar(preAggregation.timeDimension)}`);
+                if (preAggregation.granularity)
+                    lines.push(`    granularity: ${yamlScalar(preAggregation.granularity)}`);
+                if (preAggregation.refreshKey)
+                    lines.push(`    refreshKey: ${yamlScalar(preAggregation.refreshKey)}`);
+            }
+        }
+    }
+    if (object.kind === 'pre_aggregation') {
+        if (object.measures?.length) {
+            lines.push('measures:');
+            for (const measure of object.measures)
+                lines.push(`  - ${yamlScalar(measure)}`);
+        }
+        if (object.dimensions?.length) {
+            lines.push('dimensions:');
+            for (const dimension of object.dimensions)
+                lines.push(`  - ${yamlScalar(dimension)}`);
+        }
+        if (object.timeDimension)
+            lines.push(`timeDimension: ${yamlScalar(object.timeDimension)}`);
+        if (object.granularity)
+            lines.push(`granularity: ${yamlScalar(object.granularity)}`);
+        if (object.refreshKey)
+            lines.push(`refreshKey: ${yamlScalar(object.refreshKey)}`);
+    }
+    return lines.join('\n') + '\n';
+}
+function applyCanonicalSemanticConfig(projectRoot) {
+    const configPath = join(projectRoot, 'dql.config.json');
+    const raw = existsSync(configPath)
+        ? JSON.parse(readFileSync(configPath, 'utf-8'))
+        : {};
+    raw.semanticLayer = {
+        provider: 'dql',
+        path: './semantic-layer',
+    };
+    writeFileSync(configPath, JSON.stringify(raw, null, 2) + '\n', 'utf-8');
+}
+function collectImportWarnings(provider, layer) {
+    const warnings = [];
+    if (provider === 'dbt') {
+        if (layer.listHierarchies().length === 0) {
+            warnings.push('No dbt hierarchies were imported; dbt semantic models were normalized into cubes, measures, dimensions, and joins.');
+        }
+    }
+    if (provider === 'snowflake' && layer.listCubes().length === 0) {
+        warnings.push('Snowflake semantic import returned no semantic views.');
+    }
+    return warnings;
+}
+function countObjects(objects) {
+    return {
+        cube: objects.filter((object) => object.kind === 'cube').length,
+        metric: objects.filter((object) => object.kind === 'metric').length,
+        dimension: objects.filter((object) => object.kind === 'dimension').length,
+        hierarchy: objects.filter((object) => object.kind === 'hierarchy').length,
+        segment: objects.filter((object) => object.kind === 'segment').length,
+        pre_aggregation: objects.filter((object) => object.kind === 'pre_aggregation').length,
+    };
+}
+function normalizeDomain(domain) {
+    return domain && domain.trim().length > 0 ? domain.trim() : 'uncategorized';
+}
+function slugifyPathSegment(value) {
+    return normalizeDomain(value)
+        .toLowerCase()
+        .replace(/[^a-z0-9/_-]+/g, '-')
+        .replace(/\/+/g, '/')
+        .replace(/^-+|-+$/g, '');
+}
+function objectId(kind, name) {
+    return `${kind}:${name}`;
+}
+function yamlScalar(value) {
+    if (/^[a-zA-Z0-9_.:/-]+$/.test(value))
+        return value;
+    return JSON.stringify(value);
+}
+function yamlBlockScalar(value, indent = 2) {
+    const indentText = ' '.repeat(indent);
+    if (!value.includes('\n'))
+        return yamlScalar(value);
+    return `|\n${value.split('\n').map((line) => `${indentText}${line}`).join('\n')}`;
+}
+function buildGroupNode(kind, label, children) {
+    if (children.length === 0)
+        return null;
+    return {
+        id: `group:${kind}:${label.toLowerCase()}`,
+        label,
+        kind: 'group',
+        count: children.length,
+        meta: {
+            objectKind: kind,
+        },
+        children,
+    };
+}
+function toLeaf(kind, name, label, meta) {
+    return {
+        id: objectId(kind, name),
+        label,
+        kind,
+        meta,
+    };
+}
+//# sourceMappingURL=semantic-import.js.map