norn-cli 2.3.0 → 2.4.0

package/out/swaggerParser.js

@@ -0,0 +1,464 @@
+"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;
+    };
+})();
+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"));
+const https = __importStar(require("https"));
+const httpRuntimeOptions_1 = require("./httpRuntimeOptions");
+/**
+ * Cache for parsed swagger specs (cleared when extension deactivates)
+ */
+const swaggerCache = new Map();
+const rawSwaggerSpecCache = new Map();
+const insecureHttpsAgent = new https.Agent({ rejectUnauthorized: false });
+function getHttpsAgent() {
+    return (0, httpRuntimeOptions_1.getVerifyTlsCertificates)() ? undefined : insecureHttpsAgent;
+}
+async function getRawSwaggerSpec(url) {
+    if (rawSwaggerSpecCache.has(url)) {
+        return rawSwaggerSpecCache.get(url);
+    }
+    const response = await axios_1.default.get(url, {
+        adapter: 'http',
+        headers: {
+            'Accept': 'application/json'
+        },
+        timeout: 30000,
+        httpsAgent: getHttpsAgent()
+    });
+    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