norn-cli 1.3.17 → 1.3.19

package/out/nornapiParser.js

@@ -0,0 +1,326 @@
+"use strict";
+/**
+ * Parser for .nornapi files
+ *
+ * Parses header groups and endpoint definitions from .nornapi files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNornApiFile = parseNornApiFile;
+exports.getHeaderGroup = getHeaderGroup;
+exports.getEndpoint = getEndpoint;
+exports.resolveEndpointPath = resolveEndpointPath;
+exports.resolveHeaderValues = resolveHeaderValues;
+exports.isApiRequestLine = isApiRequestLine;
+exports.parseApiRequest = parseApiRequest;
+/**
+ * Extracts parameter names from an endpoint path
+ * e.g., /users/{id}/orders/{orderId} -> ['id', 'orderId']
+ *
+ * Note: Does NOT extract {{variable}} references (double braces) - only {param} (single braces)
+ */
+function extractPathParameters(path) {
+    const params = [];
+    // Match {param} but NOT {{variable}}
+    // Use negative lookbehind (?<!{) and negative lookahead (?!})
+    const regex = /(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})/g;
+    let match;
+    while ((match = regex.exec(path)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}
+/**
+ * Parses a .nornapi file and returns header groups and endpoint definitions
+ */
+function parseNornApiFile(content) {
+    const lines = content.split('\n');
+    const headerGroups = [];
+    const endpoints = [];
+    let currentHeaderGroup = null;
+    let inEndpointsBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Check for headers block start: headers Name
+        const headersStartMatch = trimmed.match(/^headers\s+([a-zA-Z_][a-zA-Z0-9_]*)$/i);
+        if (headersStartMatch) {
+            currentHeaderGroup = {
+                name: headersStartMatch[1],
+                headers: {}
+            };
+            continue;
+        }
+        // Check for headers block end
+        if (/^end\s+headers$/i.test(trimmed)) {
+            if (currentHeaderGroup) {
+                headerGroups.push(currentHeaderGroup);
+                currentHeaderGroup = null;
+            }
+            continue;
+        }
+        // Inside headers block - parse header lines
+        if (currentHeaderGroup) {
+            const headerMatch = trimmed.match(/^([a-zA-Z][a-zA-Z0-9\-]*)\s*:\s*(.+)$/);
+            if (headerMatch) {
+                currentHeaderGroup.headers[headerMatch[1]] = headerMatch[2].trim();
+            }
+            continue;
+        }
+        // Check for endpoints block start
+        if (/^endpoints$/i.test(trimmed)) {
+            inEndpointsBlock = true;
+            continue;
+        }
+        // Check for endpoints block end
+        if (/^end\s+endpoints$/i.test(trimmed)) {
+            inEndpointsBlock = false;
+            continue;
+        }
+        // Inside endpoints block - parse endpoint lines
+        // Format: EndpointName: METHOD /path/{param}
+        if (inEndpointsBlock) {
+            const endpointMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+            if (endpointMatch) {
+                const path = endpointMatch[3].trim();
+                endpoints.push({
+                    name: endpointMatch[1],
+                    method: endpointMatch[2].toUpperCase(),
+                    path,
+                    parameters: extractPathParameters(path)
+                });
+            }
+            continue;
+        }
+    }
+    return { headerGroups, endpoints };
+}
+/**
+ * Gets a header group by name (case-sensitive)
+ */
+function getHeaderGroup(definition, name) {
+    return definition.headerGroups.find(hg => hg.name === name);
+}
+/**
+ * Gets an endpoint by name (case-sensitive)
+ */
+function getEndpoint(definition, name) {
+    return definition.endpoints.find(ep => ep.name === name);
+}
+/**
+ * Resolves an endpoint path with provided parameters
+ * e.g., path: /users/{id}/orders, params: { id: '123' } -> /users/123/orders
+ */
+function resolveEndpointPath(endpoint, params) {
+    let resolvedPath = endpoint.path;
+    for (const paramName of endpoint.parameters) {
+        const value = params[paramName];
+        if (value !== undefined) {
+            resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
+        }
+    }
+    return resolvedPath;
+}
+/**
+ * Applies variable substitution to header values
+ */
+function resolveHeaderValues(headerGroup, variables) {
+    const resolved = {};
+    for (const [name, value] of Object.entries(headerGroup.headers)) {
+        // Substitute {{variable}} references
+        resolved[name] = value.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
+            return variables[varName] ?? `{{${varName}}}`;
+        });
+    }
+    return resolved;
+}
+/**
+ * Checks if a request line uses endpoint syntax instead of a URL
+ * Endpoint syntax: METHOD EndpointName(param, ...) [HeaderGroups...]
+ * URL syntax: METHOD http://... or METHOD /path
+ *
+ * Returns true if the URL part starts with a word that matches an endpoint name
+ */
+function isApiRequestLine(requestContent, endpoints) {
+    const lines = requestContent.split('\n');
+    // Find the first non-empty, non-comment, non-import line
+    let firstLine = '';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('import ')) {
+            firstLine = trimmed;
+            break;
+        }
+    }
+    if (!firstLine) {
+        return false;
+    }
+    // Match METHOD followed by non-URL pattern
+    const match = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)/i);
+    if (!match) {
+        return false;
+    }
+    const potentialEndpointName = match[2];
+    // Check if this matches a known endpoint
+    return endpoints.some(ep => ep.name === potentialEndpointName);
+}
+/**
+ * Parses an API request block (endpoint-based syntax)
+ *
+ * Handles two syntax styles:
+ * 1. Single line: GET GetUser("123") Auth Json
+ * 2. Multi-line:
+ *    GET GetUser("123")
+ *    Auth
+ *    Json
+ *
+ * Returns parsed information or undefined if not an API request
+ */
+function parseApiRequest(requestContent, endpoints, headerGroups) {
+    const lines = requestContent.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#') && !l.startsWith('import '));
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const firstLine = lines[0];
+    // Parse: METHOD EndpointName(params...) [HeaderGroups...]
+    // Params can be: positional values or key=value pairs
+    const lineMatch = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]*)\))?\s*(.*)$/i);
+    if (!lineMatch) {
+        return undefined;
+    }
+    const methodFromLine = lineMatch[1].toUpperCase();
+    const endpointName = lineMatch[2];
+    const paramsStr = lineMatch[3] || '';
+    const headerGroupsOnLine = lineMatch[4]?.trim() || '';
+    // Find the endpoint
+    const endpoint = endpoints.find(ep => ep.name === endpointName);
+    if (!endpoint) {
+        return undefined;
+    }
+    // Verify the method matches (or allow method from line to override)
+    // Actually, the user might use a different method - we use the line's method
+    const method = methodFromLine;
+    // Parse parameters: positional or key=value
+    const params = {};
+    if (paramsStr) {
+        // Split by comma, respecting quotes
+        const paramTokens = parseParamTokens(paramsStr);
+        // Check if key=value or positional
+        if (paramTokens.length > 0 && paramTokens[0].includes(':')) {
+            // Key=value format: GetUser(id: "123")
+            for (const token of paramTokens) {
+                const kvMatch = token.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+                if (kvMatch) {
+                    params[kvMatch[1]] = unquote(kvMatch[2].trim());
+                }
+            }
+        }
+        else {
+            // Positional format: GetUser("123") -> map to endpoint parameters in order
+            for (let i = 0; i < paramTokens.length && i < endpoint.parameters.length; i++) {
+                params[endpoint.parameters[i]] = unquote(paramTokens[i].trim());
+            }
+        }
+    }
+    // Collect header group names and inline headers
+    const headerGroupNames = [];
+    const inlineHeaders = {};
+    // From same line
+    if (headerGroupsOnLine) {
+        const names = headerGroupsOnLine.split(/\s+/).filter(n => n);
+        for (const name of names) {
+            if (headerGroups.some(hg => hg.name === name)) {
+                headerGroupNames.push(name);
+            }
+        }
+    }
+    // From subsequent lines:
+    // - Header group names (single word matching a defined group)
+    // - Inline headers (HeaderName: value format)
+    // - Body content (everything else after headers section)
+    const bodyLines = [];
+    let inBodySection = false;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        // Once we start the body section, everything goes to body
+        if (inBodySection) {
+            bodyLines.push(line);
+            continue;
+        }
+        // Check if this line is a header group name
+        if (headerGroups.some(hg => hg.name === line)) {
+            headerGroupNames.push(line);
+            continue;
+        }
+        // Check if this is an inline header (HeaderName: value)
+        const headerMatch = line.match(/^([a-zA-Z][a-zA-Z0-9\-]*)\s*:\s*(.+)$/);
+        if (headerMatch) {
+            let headerValue = headerMatch[2].trim();
+            // Remove surrounding quotes if present
+            if ((headerValue.startsWith('"') && headerValue.endsWith('"')) ||
+                (headerValue.startsWith("'") && headerValue.endsWith("'"))) {
+                headerValue = headerValue.slice(1, -1);
+            }
+            inlineHeaders[headerMatch[1]] = headerValue;
+            continue;
+        }
+        // Not a header group or inline header - start of body section
+        inBodySection = true;
+        bodyLines.push(line);
+    }
+    const body = bodyLines.length > 0 ? bodyLines.join('\n') : undefined;
+    return {
+        method,
+        endpointName,
+        params,
+        headerGroupNames,
+        inlineHeaders,
+        body
+    };
+}
+/**
+ * Splits parameter string by commas, respecting quotes
+ */
+function parseParamTokens(paramsStr) {
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+    for (const char of paramsStr) {
+        if ((char === '"' || char === "'") && !inQuote) {
+            inQuote = true;
+            quoteChar = char;
+            current += char;
+        }
+        else if (char === quoteChar && inQuote) {
+            inQuote = false;
+            quoteChar = '';
+            current += char;
+        }
+        else if (char === ',' && !inQuote) {
+            tokens.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    return tokens;
+}
+/**
+ * Removes surrounding quotes from a string value
+ */
+function unquote(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+//# sourceMappingURL=nornapiParser.js.map