norn-cli 2.4.0 → 2.6.0

package/out/requestPreparation.js

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

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