@duckcodeailabs/dql-cli 1.0.2 → 1.0.4

package/dist/local-runtime.js

@@ -1,8 +1,9 @@
+import { execSync } from 'node:child_process';
 import { createServer } from 'node:http';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
 import { dirname, extname, join, normalize, relative, resolve } from 'node:path';
 import { buildExecutionPlan, createWelcomeNotebook, deserializeNotebook, getConnectorFormSchemas, hasSemanticRefs, resolveSemanticRefs, } from '@duckcodeailabs/dql-notebook';
-import { loadSemanticLayerFromDir, resolveSemanticLayerAsync, Parser, buildLineageGraph, buildManifest, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryCompleteLineagePaths, LineageGraph, canonicalize, } from '@duckcodeailabs/dql-core';
+import { loadSemanticLayerFromDir, resolveSemanticLayerAsync, Parser, buildLineageGraph, buildManifest, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, } from '@duckcodeailabs/dql-core';
 import { listBlockTemplates } from './block-templates.js';
 import { buildSemanticObjectDetail, buildSemanticTree, computeSyncDiff, loadSemanticImportManifest, performSemanticImport, previewSemanticImport, syncSemanticImport, } from './semantic-import.js';
 export async function startLocalServer(opts) {
@@ -219,7 +220,11 @@ export async function startLocalServer(opts) {
                     return;
                 }
                 mkdirSync(dirname(absPath), { recursive: true });
-                const toWrite = absPath.endsWith('.dql') ? canonicalizeSafe(content) : content;
+                const toWrite = absPath.endsWith('.dql')
+                    ? canonicalizeSafe(content)
+                    : absPath.endsWith('.dqlnb')
+                        ? canonicalizeNotebookSafe(content)
+                        : content;
                 writeFileSync(absPath, toWrite, 'utf-8');
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(serializeJSON({ ok: true }));
@@ -339,20 +344,37 @@ export async function startLocalServer(opts) {
         if (req.method === 'POST' && path === '/api/blocks/save-from-cell') {
             try {
                 const body = await readJSON(req);
-                const { name, domain, content, description, tags, metricRefs, template, } = body;
+                const { name, domain, owner, content, description, tags, metricRefs, template, } = body;
                 if (!name || typeof name !== 'string' || !content || typeof content !== 'string') {
                     res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({ error: 'name and content are required' }));
                     return;
                 }
+                const missing = [];
+                if (!owner || !owner.trim())
+                    missing.push('owner');
+                if (!domain || !domain.trim())
+                    missing.push('domain');
+                if (!description || !description.trim())
+                    missing.push('description');
+                if (missing.length > 0) {
+                    res.writeHead(422, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({
+                        error: `Block is missing required governance fields: ${missing.join(', ')}`,
+                        missing,
+                    }));
+                    return;
+                }
                 const created = createBlockArtifacts(projectRoot, {
                     name,
                     domain,
+                    owner,
                     content,
                     description,
                     tags,
                     metricRefs,
                     template,
+                    gitMetadata: readGitMetadata(projectRoot),
                 });
                 res.writeHead(201, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(serializeJSON(created));
@@ -1279,9 +1301,21 @@ export async function startLocalServer(opts) {
                     res.end(serializeJSON({ columns: [], rows: [], error: 'Missing SQL in request body.' }));
                     return;
                 }
-                const prepared = prepareLocalExecution(typeof body.sql === 'string' ? body.sql : '', isConnectionConfig(body.connection) ? body.connection : connection, projectRoot, projectConfig);
+                const semantic = prepareSemanticSql(body.sql, semanticLayer);
+                if (semantic.unresolvedRefs.length > 0) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({
+                        columns: [],
+                        rows: [],
+                        error: `Unknown semantic reference${semantic.unresolvedRefs.length > 1 ? 's' : ''}: ${semantic.unresolvedRefs.join(', ')}`,
+                        code: 'semantic_ref',
+                        unresolvedRefs: semantic.unresolvedRefs,
+                    }));
+                    return;
+                }
+                const prepared = prepareLocalExecution(semantic.sql, isConnectionConfig(body.connection) ? body.connection : connection, projectRoot, projectConfig);
                 const result = await executor.executeQuery(prepared.sql, Array.isArray(body.sqlParams) ? body.sqlParams : [], body.variables && typeof body.variables === 'object' ? body.variables : {}, prepared.connection);
-                const payload = serializeJSON(normalizeQueryResult(result));
+                const payload = serializeJSON(normalizeQueryResult(result, semantic.semanticRefs));
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(payload);
             }
@@ -1848,9 +1882,10 @@ export function formatLocalQueryRuntimeError(connection, error) {
  * Connector returns columns as ColumnMeta[] ({name,type,driverType}).
  * The notebook SPA expects columns as string[] (just names).
  */
-function normalizeQueryResult(result) {
+function normalizeQueryResult(result, semanticRefs) {
     const rawCols = Array.isArray(result?.columns) ? result.columns : [];
     const columns = rawCols.map((c) => typeof c === 'string' ? c : typeof c?.name === 'string' ? c.name : String(c));
+    const hasRefs = semanticRefs && (semanticRefs.metrics.length > 0 || semanticRefs.dimensions.length > 0);
     return {
         columns,
         rows: Array.isArray(result?.rows) ? result.rows : [],
@@ -1860,6 +1895,7 @@ function normalizeQueryResult(result) {
             : typeof result?.executionTime === 'number'
                 ? result.executionTime
                 : 0,
+        ...(hasRefs ? { semanticRefs } : {}),
     };
 }
 export function serializeJSON(value) {
@@ -1941,6 +1977,25 @@ export function prepareLocalExecution(sql, connection, projectRoot, projectConfi
         connection: normalizedConnection,
     };
 }
+/**
+ * Shared resolver for `@metric(name)` / `@dim(name)` refs in raw SQL.
+ * Used by notebook SQL execution and Block Studio validation so both paths
+ * behave identically. If the SQL has no refs, returns it unchanged.
+ */
+export function prepareSemanticSql(sql, semanticLayer) {
+    if (!hasSemanticRefs(sql)) {
+        return { sql, semanticRefs: { metrics: [], dimensions: [] }, unresolvedRefs: [] };
+    }
+    const resolution = resolveSemanticRefs(sql, semanticLayer);
+    return {
+        sql: resolution.resolvedSql,
+        semanticRefs: {
+            metrics: resolution.resolvedMetrics,
+            dimensions: resolution.resolvedDimensions,
+        },
+        unresolvedRefs: resolution.unresolvedRefs,
+    };
+}
 export function normalizeProjectConnection(connection, projectRoot) {
     const normalized = { ...connection };
     if ((normalized.driver === 'file' || normalized.driver === 'duckdb') && normalized.filepath && normalized.filepath !== ':memory:' && !isAbsoluteLikePath(normalized.filepath)) {
@@ -2720,6 +2775,34 @@ function canonicalizeSafe(source) {
         return source;
     }
 }
+function canonicalizeNotebookSafe(source) {
+    try {
+        return canonicalizeNotebook(source);
+    }
+    catch {
+        return source;
+    }
+}
+export function readGitMetadata(projectRoot) {
+    const run = (cmd) => execSync(cmd, { cwd: projectRoot, encoding: 'utf-8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    try {
+        const commitSha = run('git rev-parse HEAD');
+        let repo = null;
+        let branch = null;
+        try {
+            repo = run('git config --get remote.origin.url') || null;
+        }
+        catch { /* no remote */ }
+        try {
+            branch = run('git rev-parse --abbrev-ref HEAD') || null;
+        }
+        catch { /* detached */ }
+        return { commitSha, repo, branch };
+    }
+    catch {
+        return null;
+    }
+}
 export function createBlockArtifacts(projectRoot, options) {
     const slug = options.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'block';
     const safeDomain = (options.domain ?? '')
@@ -2736,23 +2819,27 @@ export function createBlockArtifacts(projectRoot, options) {
     const templateContent = options.template
         ? listBlockTemplates().find((template) => template.id === options.template)?.content
         : undefined;
+    const relativePath = safeDomain ? `blocks/${safeDomain}/${slug}.dql` : `blocks/${slug}.dql`;
     const fileContent = canonicalizeSafe(normalizeBlockStudioContent({
         name: options.name,
         domain: safeDomain || 'uncategorized',
+        owner: options.owner,
         description: options.description,
         tags: options.tags,
         content: options.content?.trim() || templateContent,
     }));
     writeFileSync(blockPath, fileContent, 'utf-8');
-    const relativePath = safeDomain ? `blocks/${safeDomain}/${slug}.dql` : `blocks/${slug}.dql`;
     const companionPath = writeBlockCompanionFile(projectRoot, {
         slug,
         name: options.name,
         domain: safeDomain || 'uncategorized',
+        owner: options.owner,
         description: options.description,
         tags: options.tags,
         provider: 'dql',
         content: fileContent,
+        gitMetadata: options.gitMetadata,
+        gitPath: relativePath,
     });
     return {
         path: relativePath,
@@ -2928,6 +3015,17 @@ function writeBlockCompanionFile(projectRoot, options) {
         for (const table of options.lineage)
             lines.push(`  - ${yamlScalar(table)}`);
     }
+    if (options.gitMetadata || options.gitPath) {
+        lines.push('git:');
+        if (options.gitMetadata?.commitSha)
+            lines.push(`  commitSha: ${yamlScalar(options.gitMetadata.commitSha)}`);
+        if (options.gitMetadata?.repo)
+            lines.push(`  repo: ${yamlScalar(options.gitMetadata.repo)}`);
+        if (options.gitMetadata?.branch)
+            lines.push(`  branch: ${yamlScalar(options.gitMetadata.branch)}`);
+        if (options.gitPath)
+            lines.push(`  path: ${yamlScalar(options.gitPath)}`);
+    }
     lines.push('reviewStatus: draft');
     writeFileSync(companionPath, lines.join('\n') + '\n', 'utf-8');
     return relative(projectRoot, companionPath).replaceAll('\\', '/');
@@ -2968,6 +3066,7 @@ function normalizeBlockStudioContent(options) {
     return buildBlankBlockContent({
         name: options.name,
         domain: options.domain,
+        owner: options.owner,
         description: options.description,
         tags: options.tags,
         sql: content || 'SELECT 1 AS value',
@@ -2979,7 +3078,7 @@ function buildBlankBlockContent(options) {
         `    domain = "${escapeDqlString(options.domain)}"`,
         '    type = "custom"',
         `    description = "${escapeDqlString(options.description?.trim() || options.name)}"`,
-        '    owner = ""',
+        `    owner = "${escapeDqlString(options.owner?.trim() ?? '')}"`,
     ];
     lines.push(`    tags = [${(options.tags ?? []).map((tag) => `"${escapeDqlString(tag)}"`).join(', ')}]`);
     lines.push('');
@@ -3255,13 +3354,49 @@ function ensureGitignoreEntry(projectRoot, pattern) {
 }
 async function readGitDiff(cwd, filePath) {
     const isRepo = await execGit(cwd, ['rev-parse', '--is-inside-work-tree']);
-    if (isRepo.code !== 0)
-        return { inRepo: false, diff: '' };
+    if (isRepo.code !== 0) {
+        return { inRepo: false, diff: '', before: null, after: null, diffReport: null };
+    }
     if (!filePath) {
         const res = await execGit(cwd, ['diff', '--no-color']);
-        return { inRepo: true, diff: res.stdout };
+        return { inRepo: true, diff: res.stdout, before: null, after: null, diffReport: null };
+    }
+    const isSemantic = filePath.endsWith('.dql') || filePath.endsWith('.dqlnb');
+    const [diffRes, before, after] = await Promise.all([
+        execGit(cwd, ['diff', '--no-color', '--', filePath]),
+        isSemantic ? readHeadBlob(cwd, filePath) : Promise.resolve(null),
+        isSemantic ? readWorkingCopy(join(cwd, filePath)) : Promise.resolve(null),
+    ]);
+    const diffReport = isSemantic ? computeSemanticDiff(filePath, before, after) : null;
+    return { inRepo: true, diff: diffRes.stdout, before, after, diffReport };
+}
+async function readHeadBlob(cwd, filePath) {
+    try {
+        const res = await execGit(cwd, ['show', `HEAD:${filePath}`]);
+        return res.code === 0 ? res.stdout : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readWorkingCopy(absPath) {
+    try {
+        return readFileSync(absPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function computeSemanticDiff(filePath, before, after) {
+    if (before === after)
+        return null;
+    try {
+        return filePath.endsWith('.dqlnb')
+            ? diffNotebook(before, after)
+            : diffDQL(before ?? '', after ?? '');
+    }
+    catch {
+        return null;
     }
-    const res = await execGit(cwd, ['diff', '--no-color', '--', filePath]);
-    return { inRepo: true, diff: res.stdout };
 }
 //# sourceMappingURL=local-runtime.js.map