norn-cli 1.4.0 → 1.4.2

package/out/swaggerBodyIntellisenseCache.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Swagger Body IntelliSense Cache
+ *
+ * Persists request-body schemas extracted from Swagger/OpenAPI specs.
+ * The cache is used by completionProvider to provide endpoint request-body
+ * templates and inline key suggestions without fetching remote specs.
+ */
+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.loadSwaggerBodyCache = loadSwaggerBodyCache;
+exports.getCachedRequestBodySchemasForUrl = getCachedRequestBodySchemasForUrl;
+exports.saveRequestBodySchemasForUrl = saveRequestBodySchemasForUrl;
+exports.invalidateSwaggerBodyCache = invalidateSwaggerBodyCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const CACHE_VERSION = 1;
+const CACHE_FOLDER = '.norn-cache';
+const CACHE_FILE = 'swagger-body-intellisense.json';
+function getWorkspaceRoot() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (workspaceFolders && workspaceFolders.length > 0) {
+        return workspaceFolders[0].uri.fsPath;
+    }
+    return undefined;
+}
+function getCachePath() {
+    const root = getWorkspaceRoot();
+    if (!root) {
+        return undefined;
+    }
+    return path.join(root, CACHE_FOLDER, CACHE_FILE);
+}
+function ensureCacheDir() {
+    const root = getWorkspaceRoot();
+    if (!root) {
+        return false;
+    }
+    const cacheDir = path.join(root, CACHE_FOLDER);
+    if (!fs.existsSync(cacheDir)) {
+        try {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+function loadSwaggerBodyCache() {
+    const cachePath = getCachePath();
+    if (!cachePath || !fs.existsSync(cachePath)) {
+        return { version: CACHE_VERSION, urls: {} };
+    }
+    try {
+        const content = fs.readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (parsed.version !== CACHE_VERSION || !parsed.urls || typeof parsed.urls !== 'object') {
+            return { version: CACHE_VERSION, urls: {} };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: CACHE_VERSION, urls: {} };
+    }
+}
+function saveSwaggerBodyCache(cache) {
+    if (!ensureCacheDir()) {
+        return false;
+    }
+    const cachePath = getCachePath();
+    if (!cachePath) {
+        return false;
+    }
+    try {
+        fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getCachedRequestBodySchemasForUrl(url) {
+    const cache = loadSwaggerBodyCache();
+    return cache.urls[url];
+}
+function saveRequestBodySchemasForUrl(url, baseUrl, schemas) {
+    const cache = loadSwaggerBodyCache();
+    cache.urls[url] = {
+        baseUrl,
+        fetchedAt: new Date().toISOString(),
+        schemas: schemas.map(schema => ({
+            operationId: schema.operationId,
+            method: schema.method.toUpperCase(),
+            path: schema.path,
+            required: Array.isArray(schema.required) ? schema.required : [],
+            schema: schema.schema
+        }))
+    };
+    saveSwaggerBodyCache(cache);
+}
+function invalidateSwaggerBodyCache(url) {
+    if (url) {
+        const cache = loadSwaggerBodyCache();
+        delete cache.urls[url];
+        saveSwaggerBodyCache(cache);
+        return;
+    }
+    saveSwaggerBodyCache({
+        version: CACHE_VERSION,
+        urls: {}
+    });
+}
+//# sourceMappingURL=swaggerBodyIntellisenseCache.js.map

package/out/swaggerParser.js

@@ -9,12 +9,98 @@ exports.invalidateSwaggerCache = invalidateSwaggerCache;
 exports.parseSwaggerSpec = parseSwaggerSpec;
 exports.generateNornapiContent = generateNornapiContent;
 exports.extractResponseSchemas = extractResponseSchemas;
+exports.extractRequestBodySchemas = extractRequestBodySchemas;
 exports.generateSchemaFilename = generateSchemaFilename;
 const axios_1 = __importDefault(require("axios"));
 /**
  * Cache for parsed swagger specs (cleared when extension deactivates)
  */
 const swaggerCache = new Map();
+const rawSwaggerSpecCache = new Map();
+async function getRawSwaggerSpec(url) {
+    if (rawSwaggerSpecCache.has(url)) {
+        return rawSwaggerSpecCache.get(url);
+    }
+    const response = await axios_1.default.get(url, {
+        headers: {
+            'Accept': 'application/json'
+        },
+        timeout: 30000
+    });
+    rawSwaggerSpecCache.set(url, response.data);
+    return response.data;
+}
+function isOpenApi3Spec(spec) {
+    return typeof spec?.openapi === 'string' && spec.openapi.startsWith('3.');
+}
+function resolveRef(ref, root) {
+    if (!ref.startsWith('#/')) {
+        return undefined;
+    }
+    const parts = ref.slice(2).split('/');
+    let current = root;
+    for (const part of parts) {
+        if (current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function resolveSchemaRefs(schema, root, visited = new Set()) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    if (schema.$ref && typeof schema.$ref === 'string') {
+        if (visited.has(schema.$ref)) {
+            return { type: 'object' };
+        }
+        visited.add(schema.$ref);
+        const resolved = resolveRef(schema.$ref, root);
+        if (resolved) {
+            return resolveSchemaRefs(resolved, root, visited);
+        }
+        return schema;
+    }
+    const result = Array.isArray(schema) ? [] : {};
+    for (const key of Object.keys(schema)) {
+        if (key === '$ref') {
+            continue;
+        }
+        const value = schema[key];
+        if (typeof value === 'object' && value !== null) {
+            result[key] = resolveSchemaRefs(value, root, new Set(visited));
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function getPreferredJsonSchema(content) {
+    if (!content) {
+        return undefined;
+    }
+    if (content['application/json']?.schema) {
+        return content['application/json'].schema;
+    }
+    const jsonKey = Object.keys(content).find(key => key.toLowerCase().includes('json') && content[key]?.schema);
+    if (jsonKey) {
+        return content[jsonKey].schema;
+    }
+    if (content['*/*']?.schema) {
+        return content['*/*'].schema;
+    }
+    const firstSchemaKey = Object.keys(content).find(key => content[key]?.schema);
+    return firstSchemaKey ? content[firstSchemaKey].schema : undefined;
+}
+function addJsonSchemaMeta(schema, title) {
+    return {
+        '$schema': 'http://json-schema.org/draft-07/schema#',
+        title,
+        ...schema
+    };
+}
 /**
  * Get a cached swagger spec, or fetch and parse if not cached
  */
@@ -31,6 +117,7 @@ async function getCachedSwaggerSpec(url) {
  */
 function clearSwaggerCache() {
     swaggerCache.clear();
+    rawSwaggerSpecCache.clear();
 }
 /**
  * Invalidate a specific URL from the cache (for manual refresh)
@@ -38,25 +125,20 @@ function clearSwaggerCache() {
 function invalidateSwaggerCache(url) {
     if (url) {
         swaggerCache.delete(url);
+        rawSwaggerSpecCache.delete(url);
     }
     else {
         swaggerCache.clear();
+        rawSwaggerSpecCache.clear();
     }
 }
 /**
  * Fetches and parses an OpenAPI/Swagger specification from a URL.
  */
 async function parseSwaggerSpec(url) {
-    // Fetch the spec
-    const response = await axios_1.default.get(url, {
-        headers: {
-            'Accept': 'application/json'
-        },
-        timeout: 30000
-    });
-    const spec = response.data;
+    const spec = await getRawSwaggerSpec(url);
     // Determine if it's OpenAPI 3.x or Swagger 2.0
-    const isOpenAPI3 = spec.openapi && spec.openapi.startsWith('3.');
+    const isOpenAPI3 = isOpenApi3Spec(spec);
     // Extract base URL
     let baseUrl = '';
     if (isOpenAPI3) {
@@ -220,61 +302,9 @@ function generateNornapiContent(spec, selectedSections, customBaseUrl) {
  * @returns Array of response schemas
  */
 async function extractResponseSchemas(url) {
-    const response = await axios_1.default.get(url, {
-        headers: { 'Accept': 'application/json' },
-        timeout: 30000
-    });
-    const spec = response.data;
+    const spec = await getRawSwaggerSpec(url);
     const schemas = [];
-    const isOpenAPI3 = spec.openapi && spec.openapi.startsWith('3.');
-    // Helper to resolve $ref references
-    const resolveRef = (ref, root) => {
-        // $ref format: "#/components/schemas/Pet" or "#/definitions/Pet"
-        if (!ref.startsWith('#/')) {
-            return undefined;
-        }
-        const parts = ref.slice(2).split('/');
-        let current = root;
-        for (const part of parts) {
-            if (current === undefined)
-                return undefined;
-            current = current[part];
-        }
-        return current;
-    };
-    // Recursively resolve all $ref in a schema
-    const resolveSchemaRefs = (schema, root, visited = new Set()) => {
-        if (!schema || typeof schema !== 'object') {
-            return schema;
-        }
-        // Handle $ref
-        if (schema.$ref && typeof schema.$ref === 'string') {
-            if (visited.has(schema.$ref)) {
-                // Circular reference - return simple object type
-                return { type: 'object' };
-            }
-            visited.add(schema.$ref);
-            const resolved = resolveRef(schema.$ref, root);
-            if (resolved) {
-                return resolveSchemaRefs(resolved, root, visited);
-            }
-            return schema;
-        }
-        // Recursively resolve properties, items, etc.
-        const result = Array.isArray(schema) ? [] : {};
-        for (const key of Object.keys(schema)) {
-            if (key === '$ref')
-                continue;
-            const value = schema[key];
-            if (typeof value === 'object' && value !== null) {
-                result[key] = resolveSchemaRefs(value, root, new Set(visited));
-            }
-            else {
-                result[key] = value;
-            }
-        }
-        return result;
-    };
+    const isOpenAPI3 = isOpenApi3Spec(spec);
     // Parse paths
     const paths = spec.paths || {};
     for (const [pathStr, pathItem] of Object.entries(paths)) {
@@ -295,12 +325,7 @@ async function extractResponseSchemas(url) {
                 if (isOpenAPI3) {
                     // OpenAPI 3.x: responses[code].content["application/json"].schema
                     const content = responseObj.content;
-                    if (content) {
-                        const jsonContent = content['application/json'] || content['*/*'];
-                        if (jsonContent?.schema) {
-                            schema = jsonContent.schema;
-                        }
-                    }
+                    schema = getPreferredJsonSchema(content);
                 }
                 else {
                     // Swagger 2.0: responses[code].schema
@@ -312,11 +337,7 @@ async function extractResponseSchemas(url) {
                     // Resolve all $ref references
                     const resolvedSchema = resolveSchemaRefs(schema, spec);
                     // Add JSON Schema meta properties
-                    const jsonSchema = {
-                        '$schema': 'http://json-schema.org/draft-07/schema#',
-                        title: `${sanitizeOperationId(operationId)} ${statusCode} Response`,
-                        ...resolvedSchema
-                    };
+                    const jsonSchema = addJsonSchemaMeta(resolvedSchema, `${sanitizeOperationId(operationId)} ${statusCode} Response`);
                     schemas.push({
                         operationId: sanitizeOperationId(operationId),
                         method: method.toUpperCase(),
@@ -330,6 +351,65 @@ async function extractResponseSchemas(url) {
     }
     return schemas;
 }
+/**
+ * Extract request body schemas from an OpenAPI/Swagger spec
+ * Resolves $ref references to inline schemas
+ * @param url URL of the OpenAPI spec
+ * @returns Array of request body schemas
+ */
+async function extractRequestBodySchemas(url) {
+    const spec = await getRawSwaggerSpec(url);
+    const schemas = [];
+    const isOpenAPI3 = isOpenApi3Spec(spec);
+    const paths = spec.paths || {};
+    for (const [pathStr, pathItem] of Object.entries(paths)) {
+        const pathObj = pathItem;
+        for (const method of ['get', 'post', 'put', 'delete', 'patch', 'head', 'options']) {
+            const operation = pathObj[method];
+            if (!operation) {
+                continue;
+            }
+            let schema = null;
+            if (isOpenAPI3) {
+                // OpenAPI 3.x request body:
+                // operation.requestBody.content["application/json"].schema
+                let requestBody = operation.requestBody;
+                if (requestBody && typeof requestBody.$ref === 'string') {
+                    requestBody = resolveRef(requestBody.$ref, spec);
+                }
+                const content = requestBody?.content;
+                schema = getPreferredJsonSchema(content);
+            }
+            else {
+                // Swagger 2.0 request body:
+                // operation.parameters[] with in: "body"
+                const pathParameters = Array.isArray(pathObj.parameters) ? pathObj.parameters : [];
+                const operationParameters = Array.isArray(operation.parameters) ? operation.parameters : [];
+                const allParameters = [...pathParameters, ...operationParameters];
+                const bodyParameter = allParameters.find((param) => param?.in === 'body' && param?.schema);
+                if (bodyParameter?.schema) {
+                    schema = bodyParameter.schema;
+                }
+            }
+            if (!schema) {
+                continue;
+            }
+            const operationId = sanitizeOperationId(operation.operationId || generateOperationId(method, pathStr));
+            const resolvedSchema = resolveSchemaRefs(schema, spec);
+            const required = Array.isArray(resolvedSchema?.required)
+                ? resolvedSchema.required.filter((name) => typeof name === 'string')
+                : [];
+            schemas.push({
+                operationId,
+                method: method.toUpperCase(),
+                path: pathStr,
+                required,
+                schema: addJsonSchemaMeta(resolvedSchema, `${operationId} Request`)
+            });
+        }
+    }
+    return schemas;
+}
 /**
  * Generate schema filename from operation details
  */

package/out/test/coverageCalculator.test.js

@@ -0,0 +1,100 @@
+"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 });
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const coverageCalculator_1 = require("../coverageCalculator");
+const swaggerParser = __importStar(require("../swaggerParser"));
+suite('Coverage Calculator Regression', () => {
+    test('maps {{baseUrl}}/{{version}} endpoint paths to swagger paths', async () => {
+        const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+        assert.ok(workspaceRoot, 'Workspace root is required for this test');
+        const tempRoot = fs.mkdtempSync(path.join(workspaceRoot, '.coverage-template-regression-'));
+        const nornapiPath = path.join(tempRoot, 'pet.nornapi');
+        const nornPath = path.join(tempRoot, 'pet.norn');
+        const nornapiContent = `swagger "https://petstore.swagger.io/v2/swagger.json"
+
+endpoints
+    GetPetById: GET {{baseUrl}}/{{version}}/pet/{petId}
+end endpoints
+`;
+        const nornContent = `test sequence GetPet
+    GET GetPetById(1)
+    assert $1.status == 200
+end sequence
+`;
+        fs.writeFileSync(nornapiPath, nornapiContent, 'utf-8');
+        fs.writeFileSync(nornPath, nornContent, 'utf-8');
+        const originalGetCachedSwaggerSpec = swaggerParser.getCachedSwaggerSpec;
+        try {
+            swaggerParser.getCachedSwaggerSpec = async () => ({
+                title: 'Petstore',
+                version: '1.0.0',
+                baseUrl: 'https://petstore.swagger.io/v2',
+                sections: [
+                    {
+                        name: 'pet',
+                        endpoints: [
+                            {
+                                name: 'getPetById',
+                                method: 'GET',
+                                path: '/pet/{petId}',
+                                parameters: ['petId'],
+                                tag: 'pet',
+                                responseCodes: ['200', '404']
+                            }
+                        ]
+                    }
+                ]
+            });
+            (0, coverageCalculator_1.clearCoverageCache)();
+            const coverage = await (0, coverageCalculator_1.getCoverageForNornapiFile)(nornapiPath);
+            assert.strictEqual(coverage.hasSwagger, true);
+            assert.strictEqual(coverage.total, 2);
+            assert.strictEqual(coverage.covered, 1);
+            const endpoint = coverage.specs[0]?.endpoints.find(e => e.method === 'GET' && e.path === '/pet/{petId}');
+            assert.ok(endpoint, 'Expected /pet/{petId} endpoint to be present');
+            const status200 = endpoint.responseCodes.find(code => code.code === '200');
+            assert.ok(status200?.covered, 'Expected 200 status code to be covered');
+        }
+        finally {
+            swaggerParser.getCachedSwaggerSpec = originalGetCachedSwaggerSpec;
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=coverageCalculator.test.js.map

package/out/testProvider.js

@@ -395,7 +395,7 @@ class NornTestController {
             const content = await fs.readFile(data.uri.fsPath, 'utf-8');
             const fileVariables = (0, parser_1.extractVariables)(content);
             // Get environment variables
-            const envVars = (0, environmentProvider_1.getEnvironmentVariables)();
+            const envVars = (0, environmentProvider_1.getEnvironmentVariables)(data.uri.fsPath);
             // Merge variables (env vars take precedence)
             const mergedVariables = { ...fileVariables, ...envVars };
             // If this is a theory case, add case params

package/package.json

@@ -2,7 +2,7 @@
   "name": "norn-cli",
   "displayName": "Norn - REST Client",
   "description": "A powerful REST client for making HTTP requests with sequences, variables, scripts, and cookie support",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"