norn-cli 1.6.0 → 1.6.2

package/out/swaggerBodyIntellisenseCache.js

@@ -1,147 +0,0 @@
-"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

@@ -1,419 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCachedSwaggerSpec = getCachedSwaggerSpec;
-exports.clearSwaggerCache = clearSwaggerCache;
-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
- */
-async function getCachedSwaggerSpec(url) {
-    if (swaggerCache.has(url)) {
-        return swaggerCache.get(url);
-    }
-    const spec = await parseSwaggerSpec(url);
-    swaggerCache.set(url, spec);
-    return spec;
-}
-/**
- * Clear the swagger cache (call on extension deactivation)
- */
-function clearSwaggerCache() {
-    swaggerCache.clear();
-    rawSwaggerSpecCache.clear();
-}
-/**
- * Invalidate a specific URL from the cache (for manual refresh)
- */
-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) {
-    const spec = await getRawSwaggerSpec(url);
-    // Determine if it's OpenAPI 3.x or Swagger 2.0
-    const isOpenAPI3 = isOpenApi3Spec(spec);
-    // Extract base URL
-    let baseUrl = '';
-    if (isOpenAPI3) {
-        // OpenAPI 3.x uses servers array
-        if (spec.servers && spec.servers.length > 0) {
-            baseUrl = spec.servers[0].url;
-        }
-    }
-    else {
-        // Swagger 2.0 uses host + basePath + schemes
-        const scheme = spec.schemes?.[0] || 'https';
-        const host = spec.host || '';
-        const basePath = spec.basePath || '';
-        if (host) {
-            baseUrl = `${scheme}://${host}${basePath}`;
-        }
-    }
-    // Extract title and version
-    const title = spec.info?.title || 'API';
-    const version = spec.info?.version || '1.0.0';
-    // Group endpoints by tag
-    const sectionMap = new Map();
-    // Parse paths
-    const paths = spec.paths || {};
-    for (const [path, 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;
-            // Get operation details
-            const operationId = operation.operationId || generateOperationId(method, path);
-            const tags = operation.tags || ['default'];
-            const summary = operation.summary;
-            // Extract path parameters
-            const parameters = [];
-            const pathParams = path.match(/\{([^}]+)\}/g);
-            if (pathParams) {
-                for (const param of pathParams) {
-                    parameters.push(param.replace(/[{}]/g, ''));
-                }
-            }
-            // Also check query parameters that are required
-            const paramDefs = operation.parameters;
-            if (paramDefs) {
-                for (const param of paramDefs) {
-                    if (param.in === 'query' && param.required) {
-                        parameters.push(param.name);
-                    }
-                }
-            }
-            // Extract response codes from operation.responses
-            const responseCodes = [];
-            const responses = operation.responses;
-            if (responses) {
-                for (const code of Object.keys(responses)) {
-                    // Include numeric status codes (skip 'default')
-                    if (/^\d{3}$/.test(code)) {
-                        responseCodes.push(code);
-                    }
-                }
-                // Sort numerically
-                responseCodes.sort((a, b) => parseInt(a) - parseInt(b));
-            }
-            const endpoint = {
-                name: sanitizeOperationId(operationId),
-                method: method.toUpperCase(),
-                path,
-                parameters,
-                tag: tags[0] || 'default',
-                summary,
-                responseCodes: responseCodes.length > 0 ? responseCodes : ['200'] // Default to 200 if no responses defined
-            };
-            // Add to section
-            const tag = endpoint.tag;
-            if (!sectionMap.has(tag)) {
-                sectionMap.set(tag, []);
-            }
-            sectionMap.get(tag).push(endpoint);
-        }
-    }
-    // Convert to sections array
-    const sections = [];
-    // Get tag descriptions if available
-    const tagDescriptions = new Map();
-    if (spec.tags) {
-        for (const tag of spec.tags) {
-            if (tag.description) {
-                tagDescriptions.set(tag.name, tag.description);
-            }
-        }
-    }
-    for (const [name, endpoints] of sectionMap) {
-        sections.push({
-            name,
-            description: tagDescriptions.get(name),
-            endpoints
-        });
-    }
-    // Sort sections alphabetically
-    sections.sort((a, b) => a.name.localeCompare(b.name));
-    return {
-        title,
-        version,
-        baseUrl,
-        sections
-    };
-}
-/**
- * Generate an operation ID from method and path if not provided
- */
-function generateOperationId(method, path) {
-    // Convert /pet/{petId} to getPetByPetId
-    const parts = path.split('/').filter(p => p && !p.startsWith('{'));
-    const pathName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
-    return method.toLowerCase() + pathName;
-}
-/**
- * Sanitize operation ID to be a valid identifier
- */
-function sanitizeOperationId(operationId) {
-    // Remove invalid characters and ensure it starts with a letter
-    let sanitized = operationId
-        .replace(/[^a-zA-Z0-9_]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    // Ensure it starts with a capital letter
-    if (sanitized && /^[a-z]/.test(sanitized)) {
-        sanitized = sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
-    }
-    return sanitized || 'Endpoint';
-}
-/**
- * Generate .nornapi content for selected sections
- */
-function generateNornapiContent(spec, selectedSections, customBaseUrl) {
-    const lines = [];
-    const baseUrl = customBaseUrl || spec.baseUrl;
-    // Add endpoints section
-    lines.push('endpoints');
-    const sectionsToInclude = selectedSections.includes('All')
-        ? spec.sections
-        : spec.sections.filter(s => selectedSections.includes(s.name));
-    for (const section of sectionsToInclude) {
-        // Add section comment
-        lines.push(`    # ${section.name}${section.description ? ` - ${section.description}` : ''}`);
-        for (const endpoint of section.endpoints) {
-            // Build the endpoint line with explicit method for full parser/editor support
-            const path = endpoint.path;
-            lines.push(`    ${endpoint.name}: ${endpoint.method} ${baseUrl}${path}`);
-        }
-        lines.push('');
-    }
-    lines.push('end endpoints');
-    return lines.join('\n');
-}
-/**
- * Extract response schemas from an OpenAPI/Swagger spec
- * Resolves $ref references to inline schemas
- * @param url URL of the OpenAPI spec
- * @returns Array of response schemas
- */
-async function extractResponseSchemas(url) {
-    const spec = await getRawSwaggerSpec(url);
-    const schemas = [];
-    const isOpenAPI3 = isOpenApi3Spec(spec);
-    // Parse paths
-    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;
-            const operationId = operation.operationId || generateOperationId(method, pathStr);
-            const responses = operation.responses;
-            if (!responses)
-                continue;
-            for (const [statusCode, responseObj] of Object.entries(responses)) {
-                // Skip non-numeric status codes like 'default'
-                if (!/^\d{3}$/.test(statusCode))
-                    continue;
-                let schema = null;
-                if (isOpenAPI3) {
-                    // OpenAPI 3.x: responses[code].content["application/json"].schema
-                    const content = responseObj.content;
-                    schema = getPreferredJsonSchema(content);
-                }
-                else {
-                    // Swagger 2.0: responses[code].schema
-                    if (responseObj.schema) {
-                        schema = responseObj.schema;
-                    }
-                }
-                if (schema) {
-                    // Resolve all $ref references
-                    const resolvedSchema = resolveSchemaRefs(schema, spec);
-                    // Add JSON Schema meta properties
-                    const jsonSchema = addJsonSchemaMeta(resolvedSchema, `${sanitizeOperationId(operationId)} ${statusCode} Response`);
-                    schemas.push({
-                        operationId: sanitizeOperationId(operationId),
-                        method: method.toUpperCase(),
-                        path: pathStr,
-                        statusCode,
-                        schema: jsonSchema
-                    });
-                }
-            }
-        }
-    }
-    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
- */
-function generateSchemaFilename(operationId, statusCode) {
-    return `${operationId}-${statusCode}.schema.json`;
-}
-//# sourceMappingURL=swaggerParser.js.map

package/out/test/coverageCalculator.test.js

@@ -1,100 +0,0 @@
-"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