norn-cli 1.3.16 → 1.3.18

package/out/swaggerParser.js

@@ -0,0 +1,339 @@
+"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.generateSchemaFilename = generateSchemaFilename;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Cache for parsed swagger specs (cleared when extension deactivates)
+ */
+const swaggerCache = new Map();
+/**
+ * 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();
+}
+/**
+ * Invalidate a specific URL from the cache (for manual refresh)
+ */
+function invalidateSwaggerCache(url) {
+    if (url) {
+        swaggerCache.delete(url);
+    }
+    else {
+        swaggerCache.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;
+    // Determine if it's OpenAPI 3.x or Swagger 2.0
+    const isOpenAPI3 = spec.openapi && spec.openapi.startsWith('3.');
+    // 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 response = await axios_1.default.get(url, {
+        headers: { 'Accept': 'application/json' },
+        timeout: 30000
+    });
+    const spec = response.data;
+    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;
+    };
+    // 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;
+                    if (content) {
+                        const jsonContent = content['application/json'] || content['*/*'];
+                        if (jsonContent?.schema) {
+                            schema = jsonContent.schema;
+                        }
+                    }
+                }
+                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 = {
+                        '$schema': 'http://json-schema.org/draft-07/schema#',
+                        title: `${sanitizeOperationId(operationId)} ${statusCode} Response`,
+                        ...resolvedSchema
+                    };
+                    schemas.push({
+                        operationId: sanitizeOperationId(operationId),
+                        method: method.toUpperCase(),
+                        path: pathStr,
+                        statusCode,
+                        schema: jsonSchema
+                    });
+                }
+            }
+        }
+    }
+    return schemas;
+}
+/**
+ * Generate schema filename from operation details
+ */
+function generateSchemaFilename(operationId, statusCode) {
+    return `${operationId}-${statusCode}.schema.json`;
+}
+//# sourceMappingURL=swaggerParser.js.map

package/out/test/extension.test.js

@@ -0,0 +1,48 @@
+"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"));
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+const vscode = __importStar(require("vscode"));
+// import * as myExtension from '../../extension';
+suite('Extension Test Suite', () => {
+    vscode.window.showInformationMessage('Start all tests.');
+    test('Sample test', () => {
+        assert.strictEqual(-1, [1, 2, 3].indexOf(5));
+        assert.strictEqual(-1, [1, 2, 3].indexOf(0));
+    });
+});
+//# sourceMappingURL=extension.test.js.map