norn-cli 2.3.0 → 2.4.0

package/out/requestPreparation.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBareVariableRequestBody = resolveBareVariableRequestBody;
+exports.applyHeaderGroupsToRequest = applyHeaderGroupsToRequest;
+exports.prepareRequestFromContent = prepareRequestFromContent;
+const parser_1 = require("./parser");
+const nornapiParser_1 = require("./nornapiParser");
+const pathAccess_1 = require("./pathAccess");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function stringifyRequestValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'object' && value !== null) {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function shouldResolveBareRequestValue(value, variables) {
+    if (!Object.prototype.hasOwnProperty.call(variables, value)) {
+        return false;
+    }
+    const envScope = variables['$env'];
+    const isEnvOnlyValue = envScope
+        && typeof envScope === 'object'
+        && Object.prototype.hasOwnProperty.call(envScope, value)
+        && variables[value] === envScope[value];
+    return !isEnvOnlyValue;
+}
+function resolveRequestValueExpression(value, variables) {
+    if (shouldResolveBareRequestValue(value, variables)) {
+        return stringifyRequestValue(variables[value]);
+    }
+    const pathMatch = value.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(\.\w[\w-]*(?:\.\w[\w-]*|\[\d+\])*|\[\d+\](?:\.\w[\w-]*|\[\d+\])*)$/);
+    if (pathMatch && shouldResolveBareRequestValue(pathMatch[1], variables)) {
+        const nestedValue = (0, pathAccess_1.getNestedPathValue)(variables[pathMatch[1]], pathMatch[2].replace(/^\./, ''));
+        if (nestedValue !== undefined) {
+            return stringifyRequestValue(nestedValue);
+        }
+    }
+    return (0, parser_1.substituteVariables)(value, variables);
+}
+function resolveBareVariableRequestBody(request, variables) {
+    if (!request.body) {
+        return request;
+    }
+    const bareVariableMatch = request.body.trim().match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
+    if (!bareVariableMatch || !(bareVariableMatch[1] in variables)) {
+        return request;
+    }
+    return {
+        ...request,
+        body: stringifyRequestValue(variables[bareVariableMatch[1]])
+    };
+}
+function applyHeaderGroupsToRequest(parsed, requestText, headerGroups, variables) {
+    const lines = requestText.split('\n');
+    const headerGroupNames = headerGroups.map(hg => hg.name);
+    const headerGroupHeaders = {};
+    const foundGroups = [];
+    const cleanedBodyLines = [];
+    let sawRequestLine = false;
+    let inBodySection = false;
+    let sawBlankLineAfterRequest = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#') || trimmed.startsWith('var ')) {
+            continue;
+        }
+        if (!trimmed) {
+            if (sawRequestLine && !inBodySection) {
+                sawBlankLineAfterRequest = true;
+            }
+            continue;
+        }
+        const methodMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+        if (!sawRequestLine && methodMatch) {
+            sawRequestLine = true;
+            const afterMethod = methodMatch[2];
+            const tokens = afterMethod.split(/\s+/);
+            for (let index = tokens.length - 1; index >= 0; index--) {
+                if (headerGroupNames.includes(tokens[index])) {
+                    foundGroups.push(tokens[index]);
+                }
+                else {
+                    break;
+                }
+            }
+            continue;
+        }
+        if (!sawRequestLine) {
+            continue;
+        }
+        if (sawBlankLineAfterRequest) {
+            inBodySection = true;
+        }
+        if (!inBodySection) {
+            if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed)) {
+                continue;
+            }
+            const potentialGroups = trimmed.split(/\s+/).filter(Boolean);
+            const matchingGroups = potentialGroups.filter(groupName => headerGroupNames.includes(groupName));
+            if (matchingGroups.length > 0 && matchingGroups.length === potentialGroups.length) {
+                foundGroups.push(...matchingGroups);
+                continue;
+            }
+            inBodySection = true;
+        }
+        cleanedBodyLines.push(trimmed);
+    }
+    for (const groupName of foundGroups) {
+        const group = headerGroups.find(hg => hg.name === groupName);
+        if (group) {
+            Object.assign(headerGroupHeaders, (0, nornapiParser_1.resolveHeaderValues)(group, variables));
+        }
+    }
+    let modifiedUrl = parsed.url;
+    for (const groupName of foundGroups) {
+        const endPattern = new RegExp(`\\s+${escapeRegExp(groupName)}$`);
+        modifiedUrl = modifiedUrl.replace(endPattern, '');
+    }
+    modifiedUrl = modifiedUrl.trim();
+    const result = {
+        ...parsed,
+        url: modifiedUrl,
+        body: cleanedBodyLines.length > 0 ? (0, parser_1.substituteVariables)(cleanedBodyLines.join('\n'), variables) : undefined
+    };
+    if (Object.keys(headerGroupHeaders).length > 0) {
+        result.headers = { ...headerGroupHeaders, ...parsed.headers };
+    }
+    return result;
+}
+function prepareRequestFromContent(requestContent, variables, apiDefinitions) {
+    if (apiDefinitions && apiDefinitions.endpoints.length > 0 && (0, nornapiParser_1.isApiRequestLine)(requestContent, apiDefinitions.endpoints)) {
+        const apiRequest = (0, nornapiParser_1.parseApiRequest)(requestContent, apiDefinitions.endpoints, apiDefinitions.headerGroups);
+        if (apiRequest) {
+            const endpoint = (0, nornapiParser_1.getEndpoint)(apiDefinitions, apiRequest.endpointName);
+            if (!endpoint) {
+                throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
+            }
+            const resolvedParams = {};
+            for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
+                resolvedParams[paramName] = resolveRequestValueExpression(paramValue, variables);
+            }
+            const resolvedPath = (0, parser_1.substituteVariables)((0, nornapiParser_1.resolveEndpointPath)(endpoint, resolvedParams), variables);
+            const combinedHeaders = {};
+            for (const groupName of apiRequest.headerGroupNames) {
+                const group = (0, nornapiParser_1.getHeaderGroup)(apiDefinitions, groupName);
+                if (group) {
+                    Object.assign(combinedHeaders, (0, nornapiParser_1.resolveHeaderValues)(group, variables));
+                }
+            }
+            for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
+                combinedHeaders[headerName] = (0, parser_1.substituteVariables)(headerValue, variables);
+            }
+            const request = {
+                method: apiRequest.method,
+                url: resolvedPath,
+                headers: combinedHeaders,
+                body: apiRequest.body ? (0, parser_1.substituteVariables)(apiRequest.body, variables) : undefined
+            };
+            return {
+                request,
+                description: `${apiRequest.endpointName}(${Object.values(resolvedParams).join(', ')}) -> ${request.method} ${request.url}`
+            };
+        }
+    }
+    let request = (0, parser_1.parserHttpRequest)(requestContent, variables);
+    if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
+        request = applyHeaderGroupsToRequest(request, requestContent, apiDefinitions.headerGroups, variables);
+    }
+    return {
+        request,
+        description: `${request.method} ${request.url}`
+    };
+}
+//# sourceMappingURL=requestPreparation.js.map

package/out/requestValidation.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPlaceholderReferences = findPlaceholderReferences;
+exports.validatePreparedRequest = validatePreparedRequest;
+const nornError_1 = require("./errors/nornError");
+const formUrlEncoded_1 = require("./formUrlEncoded");
+const PLACEHOLDER_REGEX = /\{\{(\$env|\$[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*)\}\}/g;
+function findPlaceholderReferences(text) {
+    if (!text) {
+        return [];
+    }
+    const references = [];
+    let match;
+    PLACEHOLDER_REGEX.lastIndex = 0;
+    while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
+        references.push({
+            text: match[0],
+            name: match[1],
+            pathPart: match[2] || '',
+            index: match.index
+        });
+    }
+    return references;
+}
+function collectUnresolvedPlaceholders(text) {
+    if (!text) {
+        return [];
+    }
+    const names = new Set();
+    for (const reference of findPlaceholderReferences(text)) {
+        names.add(reference.text);
+    }
+    return [...names];
+}
+function extractEnvScopedNames(placeholders) {
+    return placeholders
+        .filter(value => value.startsWith('{{$env.'))
+        .map(value => value.slice('{{$env.'.length, -2).split(/[.[\]]/)[0])
+        .filter(Boolean);
+}
+function buildMissingVariableHint(missingVars, context) {
+    const env = context?.environment;
+    const envScopedNames = extractEnvScopedNames(missingVars);
+    const unscopedVars = missingVars.filter(value => !value.startsWith('{{$env.'));
+    if (env?.hasEnvFile && env.availableEnvironments && env.availableEnvironments.length > 0 && !env.activeEnvironment) {
+        return `A .nornenv file was found but no environment is selected. Select one of: ${env.availableEnvironments.join(', ')}.`;
+    }
+    if (env?.hasEnvFile && env.activeEnvironment && envScopedNames.length > 0 && unscopedVars.length === 0) {
+        return `Check that ${envScopedNames.map(v => `'${v}'`).join(', ')} exist in the active environment '${env.activeEnvironment}'.`;
+    }
+    if (env?.hasEnvFile && env.activeEnvironment) {
+        return `Check that ${missingVars.map(v => `'${v}'`).join(', ')} exist in the active environment '${env.activeEnvironment}' or as file-level variables.`;
+    }
+    return `Define ${missingVars.length === 1 ? 'the variable' : 'the variables'} ${missingVars.map(v => `'${v}'`).join(', ')} before sending the request.`;
+}
+function buildRequestContext(parsed, context) {
+    return {
+        ...context,
+        method: context?.method || parsed.method,
+        url: context?.url || parsed.url,
+        environment: context?.environment
+    };
+}
+function getHeaderValueCaseInsensitive(headers, headerName) {
+    const targetName = headerName.toLowerCase();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === targetName) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function describeUnresolvedLocation(label, vars) {
+    if (vars.length === 0) {
+        return undefined;
+    }
+    return `${label}: unresolved ${vars.length === 1 ? 'variable' : 'variables'} ${vars.join(', ')}`;
+}
+function shouldValidateBodyPlaceholders(parsed) {
+    const method = String(parsed.method || '').toUpperCase();
+    // Be conservative: GET/HEAD commonly ignore bodies and legacy Norn tests may contain
+    // body-like trailing text that should not block execution for these methods.
+    return method !== 'GET' && method !== 'HEAD';
+}
+function validatePreparedRequest(parsed, context) {
+    const urlVars = collectUnresolvedPlaceholders(parsed.url);
+    const headerVars = [...new Set(Object.values(parsed.headers).flatMap(value => collectUnresolvedPlaceholders(value)))];
+    const bodyVars = shouldValidateBodyPlaceholders(parsed) ? collectUnresolvedPlaceholders(parsed.body) : [];
+    const missingVars = [...new Set([...urlVars, ...headerVars, ...bodyVars])];
+    if (missingVars.length > 0) {
+        const details = [
+            describeUnresolvedLocation('URL', urlVars),
+            describeUnresolvedLocation('Headers', headerVars),
+            describeUnresolvedLocation('Body', bodyVars)
+        ].filter((d) => Boolean(d));
+        throw new nornError_1.NornError({
+            category: 'variable-resolution',
+            code: 'unresolved-request-variables',
+            message: `Request could not be prepared: unresolved ${missingVars.length === 1 ? 'variable' : 'variables'} ${missingVars.join(', ')}.`,
+            details,
+            hint: buildMissingVariableHint(missingVars, context),
+            context: {
+                ...buildRequestContext(parsed, context),
+                unresolvedVariables: missingVars
+            }
+        });
+    }
+    if (!parsed.url || !parsed.url.trim()) {
+        throw new nornError_1.NornError({
+            category: 'url',
+            code: 'missing-request-url',
+            message: 'Request URL is missing.',
+            hint: 'Add a URL after the HTTP method (for example: GET https://api.example.com/path).',
+            context: buildRequestContext(parsed, context)
+        });
+    }
+    try {
+        new URL(parsed.url);
+    }
+    catch (error) {
+        throw new nornError_1.NornError({
+            category: 'url',
+            code: 'invalid-request-url',
+            message: `Invalid request URL: ${parsed.url}`,
+            details: error instanceof Error ? error.message : String(error),
+            hint: 'Check the URL format and any variables used to build it.',
+            context: buildRequestContext(parsed, context),
+            cause: error
+        });
+    }
+    const contentType = getHeaderValueCaseInsensitive(parsed.headers, 'Content-Type');
+    if ((0, formUrlEncoded_1.isFormUrlEncodedContentType)(contentType)) {
+        const { errors } = (0, formUrlEncoded_1.parseFormUrlEncodedBody)(parsed.body);
+        if (errors.length > 0) {
+            throw new nornError_1.NornError({
+                category: 'syntax',
+                code: 'invalid-form-urlencoded-body',
+                message: 'Request could not be prepared: invalid application/x-www-form-urlencoded body syntax.',
+                details: errors.map(error => `Body line ${error.lineIndex + 1}: ${error.message} (${error.line})`),
+                hint: 'Use key=value, key: value, or a single line like key1=value1&key2=value2.',
+                context: buildRequestContext(parsed, context)
+            });
+        }
+    }
+}
+//# sourceMappingURL=requestValidation.js.map