norn-cli 1.3.16 → 1.3.18

package/out/environmentProvider.js

@@ -0,0 +1,373 @@
+"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.findEnvFile = findEnvFile;
+exports.findEnvFileFromPath = findEnvFileFromPath;
+exports.parseEnvFile = parseEnvFile;
+exports.loadEnvironmentConfig = loadEnvironmentConfig;
+exports.getActiveEnvironment = getActiveEnvironment;
+exports.setActiveEnvironment = setActiveEnvironment;
+exports.getEnvironmentVariables = getEnvironmentVariables;
+exports.getAvailableEnvironments = getAvailableEnvironments;
+exports.createStatusBarItem = createStatusBarItem;
+exports.showEnvironmentPicker = showEnvironmentPicker;
+exports.disposeStatusBar = disposeStatusBar;
+exports.createCoverageStatusBarItem = createCoverageStatusBarItem;
+exports.updateCoverageStatusBar = updateCoverageStatusBar;
+exports.getCoverageStatusBarItem = getCoverageStatusBarItem;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ENV_FILENAME = '.nornenv';
+// Current active environment (stored globally)
+let activeEnvironment;
+let statusBarItem;
+let coverageStatusBarItem;
+/**
+ * Finds the .nornenv file in the workspace
+ */
+function findEnvFile() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return undefined;
+    }
+    for (const folder of workspaceFolders) {
+        const envPath = path.join(folder.uri.fsPath, ENV_FILENAME);
+        if (fs.existsSync(envPath)) {
+            return envPath;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds .nornenv file relative to a specific file path (for CLI usage)
+ */
+function findEnvFileFromPath(filePath) {
+    let dir = path.dirname(filePath);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const envPath = path.join(dir, ENV_FILENAME);
+        if (fs.existsSync(envPath)) {
+            return envPath;
+        }
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
+/**
+ * Parses the .nornenv file content
+ */
+function parseEnvFile(content) {
+    const lines = content.split('\n');
+    const config = {
+        common: {},
+        environments: [],
+        secretNames: new Set(),
+        secretValues: new Map()
+    };
+    let currentEnv = null;
+    const envRegex = /^\[env:([a-zA-Z_][a-zA-Z0-9_-]*)\]$/;
+    const varRegex = /^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
+    const secretRegex = /^secret\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Check for environment section
+        const envMatch = trimmed.match(envRegex);
+        if (envMatch) {
+            currentEnv = {
+                name: envMatch[1],
+                variables: {}
+            };
+            config.environments.push(currentEnv);
+            continue;
+        }
+        // Check for secret declaration (treated like var but marked for redaction)
+        const secretMatch = trimmed.match(secretRegex);
+        if (secretMatch) {
+            const varName = secretMatch[1];
+            const varValue = secretMatch[2].trim();
+            // Track as secret
+            config.secretNames.add(varName);
+            config.secretValues.set(varName, varValue);
+            // Also add to variables so it can be used
+            if (currentEnv) {
+                currentEnv.variables[varName] = varValue;
+            }
+            else {
+                config.common[varName] = varValue;
+            }
+            continue;
+        }
+        // Check for variable declaration
+        const varMatch = trimmed.match(varRegex);
+        if (varMatch) {
+            const varName = varMatch[1];
+            const varValue = varMatch[2].trim();
+            if (currentEnv) {
+                currentEnv.variables[varName] = varValue;
+            }
+            else {
+                config.common[varName] = varValue;
+            }
+        }
+    }
+    return config;
+}
+/**
+ * Reads and parses the .nornenv file
+ */
+function loadEnvironmentConfig(envFilePath) {
+    const filePath = envFilePath || findEnvFile();
+    if (!filePath || !fs.existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return parseEnvFile(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Gets the currently active environment name
+ */
+function getActiveEnvironment() {
+    return activeEnvironment;
+}
+/**
+ * Sets the active environment
+ */
+function setActiveEnvironment(envName) {
+    activeEnvironment = envName;
+    updateStatusBar();
+}
+/**
+ * Gets all variables for the current environment (common + environment-specific)
+ */
+function getEnvironmentVariables(envFilePath) {
+    const config = loadEnvironmentConfig(envFilePath);
+    if (!config) {
+        return {};
+    }
+    // Start with common variables
+    const variables = { ...config.common };
+    // Override with environment-specific variables if an environment is active
+    if (activeEnvironment) {
+        const env = config.environments.find(e => e.name === activeEnvironment);
+        if (env) {
+            Object.assign(variables, env.variables);
+        }
+    }
+    return variables;
+}
+/**
+ * Gets available environment names
+ */
+function getAvailableEnvironments(envFilePath) {
+    const config = loadEnvironmentConfig(envFilePath);
+    if (!config) {
+        return [];
+    }
+    return config.environments.map(e => e.name);
+}
+/**
+ * Creates and shows the status bar item
+ */
+function createStatusBarItem() {
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.command = 'norn.selectEnvironment';
+    updateStatusBar();
+    statusBarItem.show();
+    return statusBarItem;
+}
+/**
+ * Updates the status bar item text
+ */
+function updateStatusBar() {
+    if (!statusBarItem) {
+        return;
+    }
+    const envFile = findEnvFile();
+    if (!envFile) {
+        statusBarItem.text = '$(globe) Norn: No Env';
+        statusBarItem.tooltip = 'No .nornenv file found';
+        return;
+    }
+    if (activeEnvironment) {
+        statusBarItem.text = `$(globe) Norn: ${activeEnvironment}`;
+        statusBarItem.tooltip = `Active environment: ${activeEnvironment}\nClick to change`;
+    }
+    else {
+        statusBarItem.text = '$(globe) Norn: Select Env';
+        statusBarItem.tooltip = 'Click to select an environment';
+    }
+}
+/**
+ * Shows the environment picker
+ */
+async function showEnvironmentPicker() {
+    const environments = getAvailableEnvironments();
+    if (environments.length === 0) {
+        const createFile = await vscode.window.showInformationMessage('No .nornenv file found. Would you like to create one?', 'Create .nornenv', 'Cancel');
+        if (createFile === 'Create .nornenv') {
+            await createEnvFileTemplate();
+        }
+        return;
+    }
+    const items = [
+        {
+            label: '$(circle-slash) None',
+            description: 'Use only common variables',
+            picked: !activeEnvironment
+        },
+        ...environments.map(env => ({
+            label: `$(server-environment) ${env}`,
+            description: env === activeEnvironment ? '(active)' : '',
+            picked: env === activeEnvironment
+        }))
+    ];
+    const selected = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select environment',
+        title: 'Norn Environment'
+    });
+    if (selected) {
+        if (selected.label.includes('None')) {
+            setActiveEnvironment(undefined);
+            vscode.window.showInformationMessage('Norn: Environment cleared');
+        }
+        else {
+            const envName = selected.label.replace('$(server-environment) ', '');
+            setActiveEnvironment(envName);
+            vscode.window.showInformationMessage(`Norn: Switched to "${envName}" environment`);
+        }
+    }
+}
+/**
+ * Creates a template .nornenv file
+ */
+async function createEnvFileTemplate() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        vscode.window.showErrorMessage('No workspace folder open');
+        return;
+    }
+    const template = `# Norn Environment Configuration
+# Common variables are available in all environments
+
+var timeout = 30000
+var version = v1
+
+# Development environment
+[env:dev]
+var baseUrl = http://localhost:3000
+var apiKey = dev-key-123
+
+# Staging environment
+[env:staging]
+var baseUrl = https://staging.api.example.com
+var apiKey = staging-key-456
+
+# Production environment
+[env:prod]
+var baseUrl = https://api.example.com
+var apiKey = prod-key-789
+`;
+    const envPath = path.join(workspaceFolders[0].uri.fsPath, ENV_FILENAME);
+    fs.writeFileSync(envPath, template, 'utf-8');
+    const doc = await vscode.workspace.openTextDocument(envPath);
+    await vscode.window.showTextDocument(doc);
+    updateStatusBar();
+    vscode.window.showInformationMessage('Created .nornenv file');
+}
+/**
+ * Disposes the status bar item
+ */
+function disposeStatusBar() {
+    if (statusBarItem) {
+        statusBarItem.dispose();
+        statusBarItem = undefined;
+    }
+    if (coverageStatusBarItem) {
+        coverageStatusBarItem.dispose();
+        coverageStatusBarItem = undefined;
+    }
+}
+/**
+ * Creates the coverage status bar item
+ */
+function createCoverageStatusBarItem() {
+    coverageStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 99);
+    coverageStatusBarItem.command = 'norn.showCoverage';
+    coverageStatusBarItem.hide(); // Hidden until we know there's swagger
+    return coverageStatusBarItem;
+}
+/**
+ * Updates the coverage status bar display
+ */
+function updateCoverageStatusBar(hasSwagger, percentage, total, covered) {
+    if (!coverageStatusBarItem) {
+        return;
+    }
+    if (!hasSwagger) {
+        coverageStatusBarItem.hide();
+        return;
+    }
+    // Choose icon based on coverage level
+    let icon = '$(graph)';
+    if (percentage >= 80) {
+        icon = '$(pass)';
+    }
+    else if (percentage >= 50) {
+        icon = '$(warning)';
+    }
+    else if (percentage > 0) {
+        icon = '$(error)';
+    }
+    coverageStatusBarItem.text = `${icon} ${percentage}%`;
+    coverageStatusBarItem.tooltip = `API Coverage: ${covered}/${total} response codes tested\nClick to view details`;
+    coverageStatusBarItem.show();
+}
+/**
+ * Get the coverage status bar item (for external updates)
+ */
+function getCoverageStatusBarItem() {
+    return coverageStatusBarItem;
+}
+//# sourceMappingURL=environmentProvider.js.map