norn-cli 2.2.2 → 2.4.0

package/out/nornenvRegionRefactor.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * Detects flat `[env:STAGE_REGION]` matrices and suggests a refactor to
+ * `[template:STAGE]` + `[template:REGION]` + `[env:STAGE_REGION extends STAGE, REGION]`.
+ *
+ * The detector is conservative — it only fires when:
+ *   - At least 2 stages × 2 regions
+ *   - At least 3 populated cells (so the matrix is big enough to be worth refactoring)
+ *   - All matrix envs are flat (no existing `extends` clause)
+ *
+ * For each variable across the matrix, the axis classifier picks one of:
+ *   - `stage`  : value is consistent within each stage, varies between stages
+ *   - `region` : value is consistent within each region, varies between regions
+ *   - `leaf`   : value varies across both axes — stays in the leaf env
+ *
+ * Connection-string vars (names ending in `_connectionString`) are intentionally
+ * skipped for lifting in v1 because their reverse-format
+ * (`connectionString name = ...`) is special. They are preserved in leaf envs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRegionPattern = detectRegionPattern;
+exports.generateRegionRefactor = generateRegionRefactor;
+exports.applyRegionRefactorToText = applyRegionRefactorToText;
+const nornenvLanguageModel_1 = require("./nornenvLanguageModel");
+const MATRIX_ENV_NAME_REGEX = /^([a-zA-Z][a-zA-Z0-9-]*)_([a-zA-Z][a-zA-Z0-9-]*)$/;
+const MIN_STAGES = 2;
+const MIN_REGIONS = 2;
+const MIN_CELLS = 3;
+function isConnectionStringVar(name) {
+    return name.endsWith('_connectionString');
+}
+function inferDeclarationKind(name) {
+    return isConnectionStringVar(name) ? 'connectionString' : 'var';
+}
+function inferDisplayName(name) {
+    return isConnectionStringVar(name)
+        ? name.slice(0, -'_connectionString'.length)
+        : name;
+}
+function declarationKind(declaration) {
+    return declaration.name.endsWith('_connectionString') && declaration.displayName !== declaration.name
+        ? 'connectionString'
+        : 'var';
+}
+function buildDeclarationMap(text) {
+    const model = (0, nornenvLanguageModel_1.parseNornenvDocumentModel)(text);
+    const byEnv = new Map();
+    for (const declaration of model.declarations) {
+        if (declaration.sectionKind !== 'env' || !declaration.sectionName) {
+            continue;
+        }
+        if (!byEnv.has(declaration.sectionName)) {
+            byEnv.set(declaration.sectionName, new Map());
+        }
+        byEnv.get(declaration.sectionName).set(declaration.name, declaration);
+    }
+    return byEnv;
+}
+function getCellValue(cell, name, declarationsByEnv, config) {
+    const value = cell.env.variables[name];
+    if (value === undefined) {
+        return undefined;
+    }
+    const declaration = declarationsByEnv.get(cell.envName)?.get(name);
+    return {
+        value,
+        secret: declaration?.secret ?? config.secretNames.has(name),
+        kind: declaration ? declarationKind(declaration) : inferDeclarationKind(name),
+        displayName: declaration?.displayName ?? inferDisplayName(name)
+    };
+}
+function classifyByAxis(name, cells, axisKeys, getAxisKey, declarationsByEnv, config) {
+    const byKey = new Map();
+    let presentCells = 0;
+    for (const key of axisKeys) {
+        const axisCells = cells.filter(cell => getAxisKey(cell) === key);
+        const presentValues = axisCells
+            .map(cell => getCellValue(cell, name, declarationsByEnv, config))
+            .filter((value) => value !== undefined);
+        if (presentValues.length === 0) {
+            continue;
+        }
+        presentCells += presentValues.length;
+        // Partial presence would add the value to cells that originally did not have it.
+        if (presentValues.length !== axisCells.length) {
+            return undefined;
+        }
+        const first = presentValues[0];
+        if (presentValues.some(value => value.value !== first.value)) {
+            return undefined;
+        }
+        byKey.set(key, {
+            value: first.value,
+            secret: presentValues.some(value => value.secret),
+            kind: first.kind,
+            displayName: first.displayName
+        });
+    }
+    // A single-cell value is not duplication; keep it leaf-specific.
+    return byKey.size > 0 && presentCells >= 2 ? byKey : undefined;
+}
+function detectRegionPattern(config, text) {
+    const cells = [];
+    for (const env of config.environments) {
+        const match = env.name.match(MATRIX_ENV_NAME_REGEX);
+        if (!match) {
+            continue;
+        }
+        // Flat-only — if any matrix-shaped env already extends, this file is already mixed.
+        if (env.parents.length > 0) {
+            return undefined;
+        }
+        cells.push({ stage: match[1], region: match[2], envName: env.name, env });
+    }
+    const stages = Array.from(new Set(cells.map(c => c.stage)));
+    const regions = Array.from(new Set(cells.map(c => c.region)));
+    if (stages.length < MIN_STAGES || regions.length < MIN_REGIONS || cells.length < MIN_CELLS) {
+        return undefined;
+    }
+    if (new Set([...stages, ...regions]).size !== stages.length + regions.length) {
+        return undefined;
+    }
+    const existingTemplates = new Set(config.templates.map(template => template.name));
+    if ([...stages, ...regions].some(name => existingTemplates.has(name))) {
+        return undefined;
+    }
+    // Collect every variable name that appears in any matrix cell.
+    const allVarNames = new Set();
+    for (const cell of cells) {
+        for (const name of Object.keys(cell.env.variables)) {
+            allVarNames.add(name);
+        }
+    }
+    let liftedToStage = 0;
+    let liftedToRegion = 0;
+    let leafSpecific = 0;
+    let skippedConnectionStrings = 0;
+    const assignments = [];
+    const declarationsByEnv = buildDeclarationMap(text);
+    for (const name of allVarNames) {
+        if (isConnectionStringVar(name)) {
+            skippedConnectionStrings++;
+        }
+        const stageValues = isConnectionStringVar(name)
+            ? undefined
+            : classifyByAxis(name, cells, stages, cell => cell.stage, declarationsByEnv, config);
+        const regionValues = isConnectionStringVar(name)
+            ? undefined
+            : classifyByAxis(name, cells, regions, cell => cell.region, declarationsByEnv, config);
+        if (stageValues) {
+            assignments.push({ name, axis: 'stage', byKey: stageValues });
+            liftedToStage++;
+        }
+        else if (regionValues) {
+            assignments.push({ name, axis: 'region', byKey: regionValues });
+            liftedToRegion++;
+        }
+        else {
+            const byKey = new Map();
+            for (const cell of cells) {
+                const value = getCellValue(cell, name, declarationsByEnv, config);
+                if (value !== undefined) {
+                    byKey.set(cell.envName, value);
+                }
+            }
+            if (byKey.size > 0) {
+                assignments.push({ name, axis: 'leaf', byKey });
+                leafSpecific++;
+            }
+        }
+    }
+    // Compute the line range to replace: from the first matrix env header to the line
+    // just before the next non-matrix section (or EOF).
+    const model = (0, nornenvLanguageModel_1.parseNornenvDocumentModel)(text);
+    const matrixNames = new Set(cells.map(c => c.envName));
+    const matrixSectionLines = model.sections
+        .filter(s => s.kind === 'env' && matrixNames.has(s.name))
+        .map(s => s.lineNumber)
+        .sort((a, b) => a - b);
+    if (matrixSectionLines.length === 0) {
+        return undefined;
+    }
+    const firstLine = matrixSectionLines[0];
+    const lastMatrixHeaderLine = matrixSectionLines[matrixSectionLines.length - 1];
+    const sectionsInReplacementRange = model.sections.filter(section => section.lineNumber >= firstLine && section.lineNumber <= lastMatrixHeaderLine);
+    if (sectionsInReplacementRange.some(section => section.kind !== 'env' || !matrixNames.has(section.name))) {
+        return undefined;
+    }
+    const lineCount = text.split('\n').length;
+    const sectionsAfter = model.sections
+        .filter(s => s.lineNumber > lastMatrixHeaderLine)
+        .map(s => s.lineNumber)
+        .sort((a, b) => a - b);
+    const lastLine = sectionsAfter.length > 0 ? sectionsAfter[0] - 1 : lineCount - 1;
+    return {
+        stages,
+        regions,
+        cells,
+        assignments,
+        replaceRange: { startLine: firstLine, endLine: lastLine },
+        summary: { liftedToStage, liftedToRegion, leafSpecific, skippedConnectionStrings }
+    };
+}
+/**
+ * Generates the refactored text block: stage templates, then region templates, then
+ * leaf envs that compose them. Caller replaces `pattern.replaceRange` with this text.
+ */
+function generateRegionRefactor(pattern) {
+    const blocks = [];
+    const fmtVar = (assignment, value) => {
+        if (value.kind === 'connectionString') {
+            const secretPrefix = value.secret ? 'secret ' : '';
+            return `    ${secretPrefix}connectionString ${value.displayName} = ${value.value}`;
+        }
+        const keyword = value.secret ? 'secret' : 'var';
+        return `    ${keyword} ${assignment.name} = ${value.value}`;
+    };
+    // Stage templates
+    for (const stage of pattern.stages) {
+        const stageVars = pattern.assignments.filter(a => a.axis === 'stage' && a.byKey.has(stage));
+        if (stageVars.length === 0) {
+            continue;
+        }
+        const lines = [`[template:${stage}]`];
+        for (const v of stageVars) {
+            lines.push(fmtVar(v, v.byKey.get(stage)));
+        }
+        blocks.push(lines.join('\n'));
+    }
+    // Region templates
+    for (const region of pattern.regions) {
+        const regionVars = pattern.assignments.filter(a => a.axis === 'region' && a.byKey.has(region));
+        if (regionVars.length === 0) {
+            continue;
+        }
+        const lines = [`[template:${region}]`];
+        for (const v of regionVars) {
+            lines.push(fmtVar(v, v.byKey.get(region)));
+        }
+        blocks.push(lines.join('\n'));
+    }
+    // Leaf envs
+    for (const cell of pattern.cells) {
+        const leafVars = pattern.assignments.filter(a => a.axis === 'leaf' && a.byKey.has(cell.envName));
+        const header = `[env:${cell.envName} extends ${cell.stage}, ${cell.region}]`;
+        if (leafVars.length === 0) {
+            blocks.push(header);
+            continue;
+        }
+        const lines = [header];
+        for (const v of leafVars) {
+            lines.push(fmtVar(v, v.byKey.get(cell.envName)));
+        }
+        blocks.push(lines.join('\n'));
+    }
+    return blocks.join('\n\n');
+}
+function applyRegionRefactorToText(text, pattern) {
+    const lines = text.split('\n');
+    const startLine = pattern.replaceRange.startLine;
+    const endLine = Math.min(pattern.replaceRange.endLine, lines.length - 1);
+    const replacementLines = generateRegionRefactor(pattern).split('\n');
+    lines.splice(startLine, endLine - startLine + 1, ...replacementLines);
+    const result = lines.join('\n');
+    return text.endsWith('\n') && !result.endsWith('\n') ? `${result}\n` : result;
+}
+//# sourceMappingURL=nornenvRegionRefactor.js.map

package/out/nornsqlHoverProvider.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NornsqlHoverProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const nornapiHoverProvider_1 = require("./nornapiHoverProvider");
+const CONNECTION_LINE_REGEX = /^(\s*)connection\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*$/;
+/**
+ * Hover for `.nornsql`. Two recognised cursors:
+ *  - On the connection identifier (in a `connection NAME` line) — shows the resolved
+ *    `NAME_connectionString` value from `.nornenv` and where it's defined.
+ *  - On any `{{...}}` token — same resolution-chain markdown the `.nornapi` hover
+ *    builds (env scope).
+ */
+class NornsqlHoverProvider {
+    provideHover(document, position) {
+        try {
+            const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+            if (!filePath) {
+                return undefined;
+            }
+            const lineText = document.lineAt(position.line).text;
+            const config = (0, environmentProvider_1.loadEnvironmentConfig)(filePath);
+            if (!config) {
+                return undefined;
+            }
+            const activeEnvironment = (0, environmentProvider_1.getActiveEnvironment)(filePath);
+            // Connection identifier hover.
+            const connectionMatch = lineText.match(CONNECTION_LINE_REGEX);
+            if (connectionMatch) {
+                const indent = connectionMatch[1].length;
+                const keywordEnd = indent + 'connection'.length;
+                // Identifier starts after the whitespace gap between `connection` and the name.
+                const identifierStart = lineText.indexOf(connectionMatch[2], keywordEnd);
+                if (identifierStart >= 0) {
+                    const identifierEnd = identifierStart + connectionMatch[2].length;
+                    if (position.character >= identifierStart && position.character <= identifierEnd) {
+                        const csName = `${connectionMatch[2]}_connectionString`;
+                        const markdown = (0, nornapiHoverProvider_1.renderTemplateReferenceHover)(csName, config, activeEnvironment);
+                        return new vscode.Hover(markdown, new vscode.Range(new vscode.Position(position.line, identifierStart), new vscode.Position(position.line, identifierEnd)));
+                    }
+                }
+            }
+            // {{...}} token hover.
+            const tokenMatch = (0, nornapiHoverProvider_1.findTemplateTokenAt)(lineText, position.character);
+            if (tokenMatch) {
+                const parsed = (0, inlayHintResolver_1.parseInlayReference)(tokenMatch.referenceRaw);
+                if (parsed) {
+                    const markdown = (0, nornapiHoverProvider_1.renderTemplateReferenceHover)(parsed.name, config, activeEnvironment);
+                    return new vscode.Hover(markdown, new vscode.Range(new vscode.Position(position.line, tokenMatch.tokenStart), new vscode.Position(position.line, tokenMatch.tokenEnd)));
+                }
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+}
+exports.NornsqlHoverProvider = NornsqlHoverProvider;
+//# sourceMappingURL=nornsqlHoverProvider.js.map

package/out/nornsqlInlayHintsProvider.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NornsqlInlayHintsProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const TEMPLATE_TOKEN_REGEX = /\{\{([^{}]+)\}\}/g;
+const CONNECTION_LINE_REGEX = /^(\s*)connection\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*$/;
+/**
+ * Inlay hints for `.nornsql` files. Two payoffs:
+ *  - `connection NAME` line: resolves `NAME_connectionString` from `.nornenv` and shows
+ *    the resolved value as an inlay after the identifier. Secret connection strings
+ *    are masked.
+ *  - Any `{{...}}` token in the file (rare in SQL bodies, but handled for consistency).
+ */
+class NornsqlInlayHintsProvider {
+    emitter = new vscode.EventEmitter();
+    environmentSubscription;
+    onDidChangeInlayHints = this.emitter.event;
+    constructor() {
+        this.environmentSubscription = (0, environmentProvider_1.onDidChangeActiveEnvironment)(() => {
+            this.emitter.fire();
+        });
+    }
+    provideInlayHints(document, range) {
+        const hints = [];
+        try {
+            const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+            if (!filePath) {
+                return [];
+            }
+            const config = (0, environmentProvider_1.loadEnvironmentConfig)(filePath);
+            if (!config) {
+                return [];
+            }
+            const variables = (0, environmentProvider_1.getEnvironmentVariables)(filePath);
+            for (let lineNumber = range.start.line; lineNumber <= range.end.line; lineNumber++) {
+                const line = document.lineAt(lineNumber).text;
+                // `connection NAME` — resolve NAME_connectionString from .nornenv.
+                const connectionMatch = line.match(CONNECTION_LINE_REGEX);
+                if (connectionMatch) {
+                    const name = connectionMatch[2];
+                    const csVarName = `${name}_connectionString`;
+                    const resolved = (0, inlayHintResolver_1.resolveInlayValueLabel)(csVarName, variables, config.secretNames);
+                    if (resolved) {
+                        const tokenEnd = line.length;
+                        const hint = new vscode.InlayHint(new vscode.Position(lineNumber, tokenEnd), resolved.label, vscode.InlayHintKind.Parameter);
+                        hint.tooltip = resolved.secret
+                            ? `'${name}_connectionString' resolves from a secret connection string.`
+                            : `'${name}_connectionString' resolves to '${resolved.value}'.`;
+                        hints.push(hint);
+                    }
+                }
+                // Generic `{{...}}` tokens (rare in SQL bodies but handled for parity).
+                TEMPLATE_TOKEN_REGEX.lastIndex = 0;
+                for (const match of line.matchAll(TEMPLATE_TOKEN_REGEX)) {
+                    const resolved = (0, inlayHintResolver_1.resolveInlayValueLabel)(match[1], variables, config.secretNames);
+                    if (!resolved) {
+                        continue;
+                    }
+                    const tokenEnd = (match.index ?? 0) + match[0].length;
+                    const hint = new vscode.InlayHint(new vscode.Position(lineNumber, tokenEnd), resolved.label, vscode.InlayHintKind.Parameter);
+                    hint.tooltip = resolved.secret
+                        ? `'${match[1].trim()}' resolves from a secret value.`
+                        : `'${match[1].trim()}' resolves to '${resolved.value}'.`;
+                    hints.push(hint);
+                }
+            }
+        }
+        catch {
+            return [];
+        }
+        return hints;
+    }
+    dispose() {
+        this.environmentSubscription.dispose();
+        this.emitter.dispose();
+    }
+}
+exports.NornsqlInlayHintsProvider = NornsqlInlayHintsProvider;
+//# sourceMappingURL=nornsqlInlayHintsProvider.js.map