@scalar/openapi-parser 0.28.16 → 0.29.0

package/dist/utils/transform-errors.js

@@ -1,65 +0,0 @@
-import { betterAjvErrors } from './betterAjvErrors/index.js';
-/**
- * Transforms ajv errors, finds the positions in the schema and returns an enriched format.
- */
-export function transformErrors(specification, errors) {
-    // TODO: This should work with multiple files
-    if (typeof errors === 'string') {
-        return [
-            {
-                message: errors,
-            },
-        ];
-    }
-    // If specification is null or invalid, betterAjvErrors cannot process it
-    // This can happen when reference resolution fails
-    if (!specification || typeof specification !== 'object') {
-        return [
-            {
-                message: 'Invalid specification',
-            },
-        ];
-    }
-    // Wrap betterAjvErrors in a try-catch since it can fail with malformed schemas
-    let processedErrors;
-    try {
-        processedErrors = betterAjvErrors(specification, null, errors, {
-            indent: 2,
-        }).map((error) => {
-            error.message = error.message.trim();
-            return error;
-        });
-    }
-    catch (error) {
-        console.error(error);
-        // If betterAjvErrors fails, fall back to raw AJV errors
-        if (Array.isArray(errors)) {
-            return errors.map((err) => {
-                let message = err.message || 'Validation error';
-                // For additionalProperties errors, include the property name
-                if (err.keyword === 'additionalProperties' && err.params?.additionalProperty) {
-                    message = `Property ${err.params.additionalProperty} is not expected to be here`;
-                }
-                return {
-                    message,
-                    path: err.dataPath || err.instancePath,
-                };
-            });
-        }
-        return [
-            {
-                message: 'Validation failed',
-            },
-        ];
-    }
-    // Deduplicate errors with the same message and path
-    const seen = new Set();
-    return processedErrors.filter((error) => {
-        const key = `${error.message}||${error.path}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}

package/dist/utils/validate-path-parameters.d.ts

@@ -1,6 +0,0 @@
-import type { AnyObject, ErrorObject } from '../types/index.js';
-/**
- * Validates path-template semantics that are not enforced by the JSON schema.
- */
-export declare function validatePathParameters(specification: AnyObject): ErrorObject[];
-//# sourceMappingURL=validate-path-parameters.d.ts.map

package/dist/utils/validate-path-parameters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate-path-parameters.d.ts","sourceRoot":"","sources":["../../src/utils/validate-path-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAU3D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,SAAS,GAAG,WAAW,EAAE,CAoE9E"}

package/dist/utils/validate-path-parameters.js

@@ -1,94 +0,0 @@
-const OPERATION_KEYS = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace']);
-const PATH_PARAMETER_PATTERN = /{([^}]+)}/g;
-/**
- * Validates path-template semantics that are not enforced by the JSON schema.
- */
-export function validatePathParameters(specification) {
-    const paths = specification?.paths;
-    if (!paths || typeof paths !== 'object') {
-        return [];
-    }
-    const errors = [];
-    for (const [pathName, pathItem] of Object.entries(paths)) {
-        if (!isRecord(pathItem)) {
-            continue;
-        }
-        const operations = Object.entries(pathItem).filter(([key, value]) => OPERATION_KEYS.has(key) && isRecord(value));
-        // Preserve the repo's current behaviour for empty path items.
-        if (operations.length === 0) {
-            continue;
-        }
-        const templateParameters = new Set(getTemplateParameterNames(pathName));
-        const pathLevelParameters = getPathParameters(pathItem.parameters, ['paths', pathName, 'parameters']);
-        for (const parameter of pathLevelParameters) {
-            if (!templateParameters.has(parameter.name)) {
-                errors.push({
-                    path: parameter.path,
-                    message: `Path parameter "${parameter.name}" must have the corresponding {${parameter.name}} segment in the "${pathName}" path`,
-                });
-            }
-        }
-        for (const [operationKey, operation] of operations) {
-            const operationParameters = getPathParameters(operation.parameters, [
-                'paths',
-                pathName,
-                operationKey,
-                'parameters',
-            ]);
-            for (const parameter of operationParameters) {
-                if (!templateParameters.has(parameter.name)) {
-                    errors.push({
-                        path: parameter.path,
-                        message: `Path parameter "${parameter.name}" must have the corresponding {${parameter.name}} segment in the "${pathName}" path`,
-                    });
-                }
-            }
-            const effectiveParameters = new Set([...pathLevelParameters, ...operationParameters].map((parameter) => parameter.name));
-            for (const templateParameter of templateParameters) {
-                if (!effectiveParameters.has(templateParameter)) {
-                    errors.push({
-                        path: ['paths', pathName, operationKey],
-                        message: `Declared path parameter "${templateParameter}" needs to be defined as a path parameter at either the path or operation level`,
-                    });
-                }
-            }
-        }
-    }
-    return deduplicateErrors(errors);
-}
-function getTemplateParameterNames(pathName) {
-    return [...pathName.matchAll(PATH_PARAMETER_PATTERN)].map((match) => normalizeTemplateParameterName(match[1]));
-}
-function normalizeTemplateParameterName(name) {
-    return name.endsWith('+') ? name.slice(0, -1) : name;
-}
-function getPathParameters(parameters, pathPrefix) {
-    if (!Array.isArray(parameters)) {
-        return [];
-    }
-    return parameters.flatMap((parameter, index) => {
-        if (!isRecord(parameter) || parameter.in !== 'path' || typeof parameter.name !== 'string') {
-            return [];
-        }
-        return [
-            {
-                name: parameter.name,
-                path: [...pathPrefix, String(index), 'name'],
-            },
-        ];
-    });
-}
-function deduplicateErrors(errors) {
-    const seen = new Set();
-    return errors.filter((error) => {
-        const key = `${error.message}||${error.path?.join('.') ?? ''}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}