norn-cli 2.3.0 → 2.4.0

package/out/nornSqlParser.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNornSqlFile = parseNornSqlFile;
+const CONNECTION_REGEX = /^connection\s+([A-Za-z_][A-Za-z0-9_-]*)\s*$/i;
+const OPERATION_REGEX = /^(query|command)\s+([A-Za-z_][A-Za-z0-9_-]*)(?:\s*\((.*)\))?\s*$/i;
+const PARAMETER_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function splitCommaSeparated(value) {
+    const parts = [];
+    let current = '';
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (char === ',') {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current.trim());
+    return parts;
+}
+function parseParameterList(rawParams) {
+    if (rawParams === undefined) {
+        return { parameters: [] };
+    }
+    const trimmed = rawParams.trim();
+    if (!trimmed) {
+        return { parameters: [] };
+    }
+    const parts = splitCommaSeparated(trimmed);
+    const parameters = [];
+    const seen = new Set();
+    for (const part of parts) {
+        if (!part) {
+            return {
+                parameters: [],
+                error: 'Invalid parameter list syntax. Use query Name(param1, param2) or command Name(param1, param2).'
+            };
+        }
+        if (!PARAMETER_NAME_REGEX.test(part)) {
+            return {
+                parameters: [],
+                error: 'Invalid parameter list syntax. Use query Name(param1, param2) or command Name(param1, param2).'
+            };
+        }
+        const lower = part.toLowerCase();
+        if (seen.has(lower)) {
+            return {
+                parameters: [],
+                error: `Duplicate parameter name '${part}' in operation declaration.`
+            };
+        }
+        seen.add(lower);
+        parameters.push(part);
+    }
+    return { parameters };
+}
+function collectSqlPlaceholders(sql) {
+    const placeholders = new Set();
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql[i];
+        const next = i + 1 < sql.length ? sql[i + 1] : '';
+        const prev = i > 0 ? sql[i - 1] : '';
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inSingleQuote) {
+            if (char === "'" && next === "'") {
+                i++;
+                continue;
+            }
+            if (char === "'") {
+                inSingleQuote = false;
+            }
+            continue;
+        }
+        if (inDoubleQuote) {
+            if (char === '"' && next === '"') {
+                i++;
+                continue;
+            }
+            if (char === '"') {
+                inDoubleQuote = false;
+            }
+            continue;
+        }
+        if (char === '-' && next === '-') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (char === "'") {
+            inSingleQuote = true;
+            continue;
+        }
+        if (char === '"') {
+            inDoubleQuote = true;
+            continue;
+        }
+        if (char !== ':' || next === ':' || prev === ':') {
+            continue;
+        }
+        if (/[A-Za-z0-9_]/.test(prev)) {
+            continue;
+        }
+        const match = sql.slice(i + 1).match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+        if (!match) {
+            continue;
+        }
+        placeholders.add(match[1]);
+        i += match[1].length;
+    }
+    return Array.from(placeholders.values());
+}
+function validatePlaceholders(operation, errors, endLine) {
+    const declared = new Set(operation.parameters.map(param => param.toLowerCase()));
+    const placeholders = collectSqlPlaceholders(operation.bodyLines.join('\n'));
+    for (const placeholder of placeholders) {
+        if (!declared.has(placeholder.toLowerCase())) {
+            errors.push({
+                message: `Obvious SQL placeholder ':${placeholder}' does not match a declared parameter.`,
+                lineNumber: endLine,
+                blocking: true
+            });
+        }
+    }
+}
+function parseNornSqlFile(text, sourcePath) {
+    const lines = text.split('\n');
+    const operations = [];
+    const errors = [];
+    let connectionName;
+    let connectionLine = -1;
+    let currentBlock;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const rawLine = lines[lineIndex];
+        const trimmed = rawLine.trim();
+        if (currentBlock) {
+            if (trimmed.toLowerCase() === `end ${currentBlock.type}`) {
+                validatePlaceholders(currentBlock, errors, lineIndex);
+                operations.push({
+                    type: currentBlock.type,
+                    name: currentBlock.name,
+                    parameters: currentBlock.parameters,
+                    sql: currentBlock.bodyLines.join('\n'),
+                    connectionName: connectionName || '',
+                    sourcePath,
+                    startLine: currentBlock.startLine,
+                    endLine: lineIndex
+                });
+                currentBlock = undefined;
+                continue;
+            }
+            if (trimmed.toLowerCase() === 'end query' || trimmed.toLowerCase() === 'end command') {
+                errors.push({
+                    message: `${trimmed.toLowerCase()} without a matching ${trimmed.toLowerCase() === 'end query' ? 'query' : 'command'}.`,
+                    lineNumber: lineIndex,
+                    blocking: true
+                });
+                continue;
+            }
+            currentBlock.bodyLines.push(rawLine);
+            continue;
+        }
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        if (/^import\b/i.test(trimmed)) {
+            errors.push({
+                message: '`import` is not supported in `.nornsql`. Import SQL files from a `.norn` file instead.',
+                lineNumber: lineIndex,
+                blocking: true
+            });
+            continue;
+        }
+        if (/^end\s+query$/i.test(trimmed)) {
+            errors.push({
+                message: '`end query` without a matching `query`.',
+                lineNumber: lineIndex,
+                blocking: true
+            });
+            continue;
+        }
+        if (/^end\s+command$/i.test(trimmed)) {
+            errors.push({
+                message: '`end command` without a matching `command`.',
+                lineNumber: lineIndex,
+                blocking: true
+            });
+            continue;
+        }
+        const connectionMatch = trimmed.match(CONNECTION_REGEX);
+        if (connectionMatch) {
+            if (connectionName) {
+                errors.push({
+                    message: 'Duplicate `connection` declaration. Each `.nornsql` file can declare only one `connection`.',
+                    lineNumber: lineIndex,
+                    blocking: true
+                });
+                continue;
+            }
+            connectionName = connectionMatch[1];
+            connectionLine = lineIndex;
+            continue;
+        }
+        if (/^(query|command)\b/i.test(trimmed)) {
+            const operationMatch = trimmed.match(OPERATION_REGEX);
+            if (!operationMatch) {
+                errors.push({
+                    message: 'Invalid parameter list syntax. Use query Name(param1, param2) or command Name(param1, param2).',
+                    lineNumber: lineIndex,
+                    blocking: true
+                });
+                continue;
+            }
+            const type = operationMatch[1].toLowerCase();
+            const name = operationMatch[2];
+            const paramResult = parseParameterList(operationMatch[3]);
+            if (paramResult.error) {
+                errors.push({
+                    message: paramResult.error,
+                    lineNumber: lineIndex,
+                    blocking: true
+                });
+                continue;
+            }
+            currentBlock = {
+                type,
+                name,
+                parameters: paramResult.parameters,
+                startLine: lineIndex,
+                bodyLines: []
+            };
+            continue;
+        }
+        errors.push({
+            message: 'Unknown top-level statement. Supported statements are: `connection`, `query`, `command`, `end query`, `end command`.',
+            lineNumber: lineIndex,
+            blocking: true
+        });
+    }
+    if (currentBlock) {
+        errors.push({
+            message: `Unterminated \`${currentBlock.type}\` block. Add \`end ${currentBlock.type}\`.`,
+            lineNumber: currentBlock.startLine,
+            blocking: true
+        });
+    }
+    if (!connectionName) {
+        errors.push({
+            message: 'Missing `connection` declaration. Each `.nornsql` file must declare exactly one `connection`.',
+            lineNumber: connectionLine >= 0 ? connectionLine : 0,
+            blocking: true
+        });
+    }
+    if (connectionName) {
+        for (const operation of operations) {
+            operation.connectionName = connectionName;
+        }
+    }
+    return {
+        connectionName,
+        operations,
+        errors
+    };
+}
+//# sourceMappingURL=nornSqlParser.js.map

package/out/nornapiHoverProvider.js

@@ -0,0 +1,135 @@
+"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.NornapiHoverProvider = void 0;
+exports.findTemplateTokenAt = findTemplateTokenAt;
+exports.renderTemplateReferenceHover = renderTemplateReferenceHover;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const environmentParser_1 = require("./environmentParser");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const TEMPLATE_TOKEN_REGEX = /\{\{([^{}]+)\}\}/g;
+/**
+ * Hover over a `{{name}}` / `{{$env.name}}` token in a `.nornapi` file shows the
+ * resolution chain: where the variable is defined in `.nornenv`, the current resolved
+ * value under the active env, and a secret flag if applicable.
+ */
+class NornapiHoverProvider {
+    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 tokenMatch = findTemplateTokenAt(lineText, position.character);
+            if (!tokenMatch) {
+                return undefined;
+            }
+            const parsed = (0, inlayHintResolver_1.parseInlayReference)(tokenMatch.referenceRaw);
+            if (!parsed) {
+                return undefined;
+            }
+            const config = (0, environmentProvider_1.loadEnvironmentConfig)(filePath);
+            if (!config) {
+                return undefined;
+            }
+            const activeEnvironment = (0, environmentProvider_1.getActiveEnvironment)(filePath);
+            const markdown = 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;
+        }
+    }
+}
+exports.NornapiHoverProvider = NornapiHoverProvider;
+function findTemplateTokenAt(lineText, character) {
+    TEMPLATE_TOKEN_REGEX.lastIndex = 0;
+    for (const match of lineText.matchAll(TEMPLATE_TOKEN_REGEX)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        if (character < start || character > end) {
+            continue;
+        }
+        return { referenceRaw: match[1], tokenStart: start, tokenEnd: end };
+    }
+    return undefined;
+}
+/**
+ * Builds a Markdown hover block for a `{{ref}}` resolving from the nearest `.nornenv`'s
+ * active environment. Shared between `.nornapi`, `.nornsql`, and `.norn` hover providers
+ * for the env-scope case.
+ */
+function renderTemplateReferenceHover(name, config, activeEnvironment) {
+    const lines = [`**\`${name}\`**`];
+    if (!config) {
+        lines.push(`No \`.nornenv\` file found in scope.`);
+        return new vscode.MarkdownString(lines.join('\n\n'));
+    }
+    const secret = config.secretNames.has(name);
+    if (!activeEnvironment) {
+        if (Object.prototype.hasOwnProperty.call(config.common, name)) {
+            lines.push('Defined in `common`.');
+            lines.push(secret
+                ? 'No active env. Common value is a secret.'
+                : `No active env. Common value: \`${config.common[name]}\`.`);
+        }
+        else {
+            lines.push('Not defined in `common`. (No active env selected — only common vars are in scope.)');
+        }
+        return new vscode.MarkdownString(lines.join('\n\n'));
+    }
+    const details = (0, environmentParser_1.resolveEffectiveEnvVariableDetails)(activeEnvironment, config);
+    const detail = details.get(name);
+    if (!detail) {
+        lines.push(`Not defined in the active env \`${activeEnvironment}\` or its ancestor templates.`);
+        return new vscode.MarkdownString(lines.join('\n\n'));
+    }
+    const sourceLabel = detail.sourceKind === 'common'
+        ? 'common'
+        : `${detail.sourceKind}:${detail.sourceName ?? ''}`;
+    lines.push(`Defined in \`${sourceLabel}\`.`);
+    lines.push(secret
+        ? `Active env \`${activeEnvironment}\` resolves to a secret value.`
+        : `Active env \`${activeEnvironment}\` resolves to \`${detail.value}\`.`);
+    if (detail.inherited) {
+        lines.push(`Inherited by \`env:${activeEnvironment}\`.`);
+    }
+    const markdown = new vscode.MarkdownString(lines.join('\n\n'));
+    markdown.isTrusted = false;
+    return markdown;
+}
+//# sourceMappingURL=nornapiHoverProvider.js.map

package/out/nornapiInlayHintsProvider.js

@@ -0,0 +1,94 @@
+"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.NornapiInlayHintsProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const TEMPLATE_TOKEN_REGEX = /\{\{([^{}]+)\}\}/g;
+/**
+ * Inlay hints for `.nornapi` files — resolves every `{{...}}` token in the file
+ * against the nearest `.nornenv`'s active environment. No local-var scope.
+ */
+class NornapiInlayHintsProvider {
+    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;
+                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.NornapiInlayHintsProvider = NornapiInlayHintsProvider;
+//# sourceMappingURL=nornapiInlayHintsProvider.js.map