@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.39

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-params-defined.js

@@ -1,145 +0,0 @@
-import { isPlainObject } from '../../utils/is-plain-object.js';
-const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
-const MAX_DEPTH = 2; // Only first callback level is supported
-export const PathParamsDefined = () => {
-    const pathContext = { current: null };
-    const currentOperationParams = new Set();
-    return {
-        PathItem: {
-            enter(_, { key }) {
-                pathItemEnter(pathContext, key);
-            },
-            leave() {
-                pathItemLeave(pathContext);
-            },
-            Parameter(parameter, { report, location, rawLocation }) {
-                createPathItemParameterHandler({ parameter, pathContext, report, location, rawLocation });
-            },
-            Operation: createOperationHandlers(pathContext, currentOperationParams),
-        },
-    };
-};
-const pathItemEnter = (pathContext, key) => {
-    pathContext.current = {
-        path: key,
-        templateParams: extractTemplateParams(key),
-        definedParams: new Set(),
-    };
-};
-const pathItemLeave = (pathContext) => {
-    pathContext.current = null;
-};
-const createPathItemParameterHandler = ({ parameter, pathContext, report, location, rawLocation, }) => {
-    if (parameter.in === 'path' && parameter.name && pathContext.current) {
-        pathContext.current.definedParams.add(parameter.name);
-        validatePathParameter({
-            paramName: parameter.name,
-            templateParams: pathContext.current.templateParams,
-            path: pathContext.current.path,
-            report,
-            location,
-            rawLocation,
-        });
-    }
-};
-const createOperationHandlers = (pathContext, currentOperationParams, depth = 0) => {
-    const reportMaxDepthWarning = (report, location, depth) => {
-        report({
-            message: `Maximum callback nesting depth (${depth}) reached. Path parameter validation is limited beyond this depth to prevent infinite recursion.`,
-            location: location,
-        });
-    };
-    if (depth >= MAX_DEPTH) {
-        return {
-            enter: () => { },
-            leave: (_op, { report, location }) => {
-                reportMaxDepthWarning(report, location, depth);
-            },
-            Parameter: () => { },
-            Callback: undefined,
-        };
-    }
-    const createCallbackPathItem = () => {
-        let parentPathContext = null;
-        return {
-            enter(_, { key }) {
-                parentPathContext = pathContext.current;
-                pathItemEnter(pathContext, key);
-            },
-            leave() {
-                pathContext.current = parentPathContext;
-            },
-            Parameter(parameter, { report, location, rawLocation }) {
-                createPathItemParameterHandler({ parameter, pathContext, report, location, rawLocation });
-            },
-            get Operation() {
-                return createOperationHandlers(pathContext, currentOperationParams, depth + 1);
-            },
-        };
-    };
-    return {
-        enter() {
-            currentOperationParams = new Set();
-        },
-        leave(_operation, { report, location }) {
-            if (!pathContext.current || !currentOperationParams)
-                return;
-            validateRequiredPathParams({
-                templateParams: pathContext.current.templateParams,
-                definedOperationParams: currentOperationParams,
-                definedPathParams: pathContext.current.definedParams,
-                path: pathContext.current.path,
-                report,
-                location,
-            });
-        },
-        Parameter(parameter, { report, location, rawLocation }) {
-            collectPathParamsFromOperation(parameter, currentOperationParams);
-            if (parameter.in === 'path' && parameter.name && pathContext.current) {
-                currentOperationParams.add(parameter.name);
-                validatePathParameter({
-                    paramName: parameter.name,
-                    templateParams: pathContext.current.templateParams,
-                    path: pathContext.current.path,
-                    report,
-                    location,
-                    rawLocation,
-                });
-            }
-        },
-        Callback: {
-            get PathItem() {
-                return createCallbackPathItem();
-            },
-        },
-    };
-};
-const extractTemplateParams = (path) => {
-    return new Set(Array.from(path.matchAll(pathRegex)).map((m) => m[1]));
-};
-const collectPathParamsFromOperation = (parameter, targetSet) => {
-    if (isPlainObject(parameter) && 'in' in parameter && 'name' in parameter) {
-        if (parameter.in === 'path' && parameter.name) {
-            targetSet.add(parameter.name);
-        }
-    }
-};
-const validatePathParameter = ({ paramName, templateParams, path, report, location, rawLocation, }) => {
-    if (!templateParams.has(paramName)) {
-        const message = `Path parameter \`${paramName}\` is not used in the path \`${path}\`.`;
-        const from = rawLocation === location ? undefined : rawLocation;
-        report({ message, location: location.child(['name']), from });
-    }
-};
-const validateRequiredPathParams = ({ templateParams, definedOperationParams, definedPathParams, path, report, location, }) => {
-    const allDefinedParams = new Set([...definedOperationParams, ...definedPathParams]);
-    for (const templateParam of templateParams) {
-        if (!allDefinedParams.has(templateParam)) {
-            report({
-                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${path}\`.`,
-                location: location.child(['parameters']).key(),
-            });
-        }
-    }
-};
-//# sourceMappingURL=path-params-defined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-segment-plural.js

@@ -1,30 +0,0 @@
-import pluralize from 'pluralize';
-import { isPathParameter } from '../../utils/is-path-parameter.js';
-export const PathSegmentPlural = (opts) => {
-    const { ignoreLastPathSegment, exceptions } = opts;
-    return {
-        PathItem: {
-            leave(_path, { report, key, location }) {
-                const pathKey = key.toString();
-                if (pathKey.startsWith('/')) {
-                    const pathSegments = pathKey.split('/');
-                    pathSegments.shift();
-                    if (ignoreLastPathSegment && pathSegments.length > 0) {
-                        pathSegments.pop();
-                    }
-                    for (const pathSegment of pathSegments) {
-                        if (exceptions && exceptions.includes(pathSegment))
-                            continue;
-                        if (!isPathParameter(pathSegment) && pluralize.isSingular(pathSegment)) {
-                            report({
-                                message: `path segment \`${pathSegment}\` should be plural.`,
-                                location: location.key(),
-                            });
-                        }
-                    }
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=path-segment-plural.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/paths-kebab-case.js

@@ -1,17 +0,0 @@
-export const PathsKebabCase = () => {
-    return {
-        PathItem(_path, { report, key }) {
-            const segments = key
-                .substr(1)
-                .split('/')
-                .filter((s) => s !== ''); // filter out empty segments
-            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
-                report({
-                    message: `\`${key}\` does not use kebab-case.`,
-                    location: { reportOnKey: true },
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=paths-kebab-case.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/required-string-property-missing-min-length.js

@@ -1,34 +0,0 @@
-export const RequiredStringPropertyMissingMinLength = () => {
-    let skipSchemaProperties;
-    let requiredPropertiesSet;
-    return {
-        Schema: {
-            enter(schema) {
-                if (!schema?.required) {
-                    skipSchemaProperties = true;
-                    return;
-                }
-                requiredPropertiesSet = new Set(schema.required);
-                skipSchemaProperties = false;
-            },
-            SchemaProperties: {
-                skip() {
-                    return skipSchemaProperties;
-                },
-                Schema: {
-                    enter(schema, { key, location, report }) {
-                        if (requiredPropertiesSet.has(key) && schema.type === 'string') {
-                            if (!schema?.minLength) {
-                                report({
-                                    message: 'Property minLength is required.',
-                                    location: location.key(),
-                                });
-                            }
-                        }
-                    },
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=required-string-property-missing-min-length.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/response-contains-header.js

@@ -1,26 +0,0 @@
-import { getMatchingStatusCodeRange } from '../../utils/get-matching-status-code-range.js';
-export const ResponseContainsHeader = (options) => {
-    const names = options.names || {};
-    return {
-        Operation: {
-            Response: {
-                enter: (response, { report, location, key }) => {
-                    const expectedHeaders = names[key] ||
-                        names[getMatchingStatusCodeRange(key)] ||
-                        names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-                        [];
-                    for (const expectedHeader of expectedHeaders) {
-                        if (!response?.headers ||
-                            !Object.keys(response?.headers).some((header) => header.toLowerCase() === expectedHeader.toLowerCase())) {
-                            report({
-                                message: `Response object must contain a "${expectedHeader}" header.`,
-                                location: location.child('headers').key(),
-                            });
-                        }
-                    }
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=response-contains-header.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/scalar-property-missing-example.js

@@ -1,39 +0,0 @@
-import { getOwn } from '../../utils/get-own.js';
-const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
-export const ScalarPropertyMissingExample = () => {
-    return {
-        SchemaProperties(properties, { report, location, specVersion, resolve }) {
-            for (const propName of Object.keys(properties)) {
-                const propSchema = resolve(getOwn(properties, propName)).node;
-                if (!propSchema || !isScalarSchema(propSchema)) {
-                    continue;
-                }
-                if (propSchema.example === undefined &&
-                    propSchema.examples === undefined) {
-                    report({
-                        message: `Scalar property should have "example"${specVersion === 'oas3_1' || specVersion === 'oas3_2' ? ' or "examples"' : ''} defined.`,
-                        location: location.child(propName).key(),
-                    });
-                }
-            }
-        },
-    };
-};
-function isScalarSchema(schema) {
-    if (!schema.type) {
-        return false;
-    }
-    if (schema.allOf || schema.anyOf || schema.oneOf) {
-        // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
-        // We need core support for checking contrstrains through those keywords.
-        return false;
-    }
-    if (schema.format === 'binary') {
-        return false;
-    }
-    if (Array.isArray(schema.type)) {
-        return schema.type.every((t) => SCALAR_TYPES.includes(t));
-    }
-    return SCALAR_TYPES.includes(schema.type);
-}
-//# sourceMappingURL=scalar-property-missing-example.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/security-defined.js

@@ -1,62 +0,0 @@
-export const SecurityDefined = (opts) => {
-    const referencedSchemes = new Map();
-    const operationsWithoutSecurity = [];
-    let eachOperationHasSecurity = true;
-    let path;
-    return {
-        Root: {
-            leave(root, { report }) {
-                for (const [name, scheme] of referencedSchemes.entries()) {
-                    if (scheme.defined)
-                        continue;
-                    for (const reportedFromLocation of scheme.from) {
-                        report({
-                            message: `There is no \`${name}\` security scheme defined.`,
-                            location: reportedFromLocation.key(),
-                        });
-                    }
-                }
-                if (root.security || eachOperationHasSecurity) {
-                    return;
-                }
-                else {
-                    for (const operationLocation of operationsWithoutSecurity) {
-                        report({
-                            message: `Every operation should have security defined on it or on the root level.`,
-                            location: operationLocation.key(),
-                        });
-                    }
-                }
-            },
-        },
-        SecurityScheme(_securityScheme, { key }) {
-            referencedSchemes.set(key.toString(), { defined: true, from: [] });
-        },
-        SecurityRequirement(requirements, { location }) {
-            for (const requirement of Object.keys(requirements)) {
-                const authScheme = referencedSchemes.get(requirement);
-                const requirementLocation = location.child([requirement]);
-                if (!authScheme) {
-                    referencedSchemes.set(requirement, { from: [requirementLocation] });
-                }
-                else {
-                    authScheme.from.push(requirementLocation);
-                }
-            }
-        },
-        PathItem: {
-            enter(pathItem, { key }) {
-                path = key;
-            },
-            Operation(operation, { location, key }) {
-                const isException = opts.exceptions?.some((item) => item.path === path &&
-                    (!item.methods || item.methods?.some((method) => method.toLowerCase() === key)));
-                if (!operation?.security && !isException) {
-                    eachOperationHasSecurity = false;
-                    operationsWithoutSecurity.push(location);
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=security-defined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/spec-strict-refs.js

@@ -1,27 +0,0 @@
-import { isRef } from '../../ref-utils.js';
-export const SpecStrictRefs = () => {
-    const nodesToSkip = [
-        'Schema',
-        'Response',
-        'Parameter',
-        'RequestBody',
-        'Example',
-        'Header',
-        'SecurityScheme',
-        'Link',
-        'Callback',
-        'PathItem',
-    ];
-    return {
-        any(_node, { report, rawNode, rawLocation, type }) {
-            const shouldCheck = !nodesToSkip.includes(type.name);
-            if (shouldCheck && isRef(rawNode)) {
-                report({
-                    message: 'Field $ref is not expected here.',
-                    location: rawLocation.child('$ref').key(),
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=spec-strict-refs.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/struct.js

@@ -1,150 +0,0 @@
-import { isRef } from '../../ref-utils.js';
-import { isNamedType, SpecExtension } from '../../types/index.js';
-import { getOwn } from '../../utils/get-own.js';
-import { isPlainObject } from '../../utils/is-plain-object.js';
-import { oasTypeOf, matchesJsonSchemaType, getSuggest, validateSchemaEnumType } from '../utils.js';
-export const Struct = () => {
-    return {
-        any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
-            const nodeType = oasTypeOf(node);
-            const refLocation = rawLocation !== location ? rawLocation : undefined;
-            if (type.items) {
-                if (nodeType !== 'array') {
-                    report({
-                        message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
-                        from: refLocation,
-                    });
-                    ignoreNextVisitorsOnNode();
-                }
-                return;
-            }
-            else if (nodeType !== 'object') {
-                if (type !== SpecExtension) {
-                    // do not validate unknown extensions structure
-                    report({
-                        message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
-                        from: refLocation,
-                    });
-                }
-                ignoreNextVisitorsOnNode();
-                return;
-            }
-            const required = typeof type.required === 'function' ? type.required(node, key) : type.required;
-            for (const propName of required || []) {
-                if (!node.hasOwnProperty(propName)) {
-                    report({
-                        message: `The field \`${propName}\` must be present on this level.`,
-                        from: refLocation,
-                        location: [{ reportOnKey: true }],
-                    });
-                }
-            }
-            const allowed = type.allowed?.(node);
-            if (allowed && isPlainObject(node)) {
-                for (const propName in node) {
-                    if (allowed.includes(propName) ||
-                        (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
-                        !Object.keys(type.properties).includes(propName)) {
-                        continue;
-                    }
-                    report({
-                        message: `The field \`${propName}\` is not allowed here.`,
-                        from: refLocation,
-                        location: location.child([propName]).key(),
-                    });
-                }
-            }
-            const requiredOneOf = type.requiredOneOf || null;
-            if (requiredOneOf) {
-                let hasProperty = false;
-                for (const propName of requiredOneOf || []) {
-                    if (node.hasOwnProperty(propName)) {
-                        hasProperty = true;
-                    }
-                }
-                if (!hasProperty)
-                    report({
-                        message: `Must contain at least one of the following fields: ${type.requiredOneOf?.join(', ')}.`,
-                        from: refLocation,
-                        location: [{ reportOnKey: true }],
-                    });
-            }
-            for (const propName of Object.keys(node)) {
-                const propLocation = location.child([propName]);
-                let propValue = node[propName];
-                let propType = getOwn(type.properties, propName);
-                if (propType === undefined)
-                    propType = type.additionalProperties;
-                if (typeof propType === 'function')
-                    propType = propType(propValue, propName);
-                if (isNamedType(propType)) {
-                    continue; // do nothing for named schema, it is executed with the next any call
-                }
-                const propSchema = propType;
-                const propValueType = oasTypeOf(propValue);
-                if (propSchema === undefined) {
-                    if (propName.startsWith('x-'))
-                        continue;
-                    report({
-                        message: `Property \`${propName}\` is not expected here.`,
-                        suggest: getSuggest(propName, Object.keys(type.properties)),
-                        from: refLocation,
-                        location: propLocation.key(),
-                    });
-                    continue;
-                }
-                if (propSchema === null) {
-                    continue; // just defined, no validation
-                }
-                if (propSchema.resolvable !== false && isRef(propValue)) {
-                    propValue = resolve(propValue).node;
-                }
-                if (propSchema.items && propSchema.items?.enum && Array.isArray(propValue)) {
-                    for (let i = 0; i < propValue.length; i++) {
-                        validateSchemaEnumType(propSchema.items?.enum, propValue[i], propName, refLocation, {
-                            report,
-                            location: location.child([propName, i]),
-                        });
-                    }
-                }
-                if (propSchema.enum) {
-                    validateSchemaEnumType(propSchema.enum, propValue, propName, refLocation, {
-                        report,
-                        location: location.child([propName]),
-                    });
-                }
-                else if (propSchema.type && !matchesJsonSchemaType(propValue, propSchema.type, false)) {
-                    report({
-                        message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
-                        from: refLocation,
-                        location: propLocation,
-                    });
-                    ignoreNextVisitorsOnNode();
-                }
-                else if (propValueType === 'array' && propSchema.items?.type) {
-                    const itemsType = propSchema.items?.type;
-                    for (let i = 0; i < propValue.length; i++) {
-                        const item = propValue[i];
-                        if (!matchesJsonSchemaType(item, itemsType, false)) {
-                            report({
-                                message: `Expected type \`${itemsType}\` but got \`${oasTypeOf(item)}\`.`,
-                                from: refLocation,
-                                location: propLocation.child([i]),
-                            });
-                        }
-                    }
-                }
-                if (typeof propSchema.minimum === 'number') {
-                    if (propSchema.minimum > node[propName]) {
-                        report({
-                            message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
-                            from: refLocation,
-                            location: location.child([propName]),
-                        });
-                    }
-                }
-            }
-        },
-    };
-};
-//# sourceMappingURL=struct.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/tag-description.js

@@ -1,9 +0,0 @@
-import { validateDefinedAndNonEmpty } from '../utils.js';
-export const TagDescription = () => {
-    return {
-        Tag(tag, ctx) {
-            validateDefinedAndNonEmpty('description', tag, ctx);
-        },
-    };
-};
-//# sourceMappingURL=tag-description.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/tags-alphabetical.js

@@ -1,18 +0,0 @@
-import { getTagName } from '../utils.js';
-export const TagsAlphabetical = ({ ignoreCase = false }) => {
-    return {
-        Root(root, { report, location }) {
-            if (!root.tags)
-                return;
-            for (let i = 0; i < root.tags.length - 1; i++) {
-                if (getTagName(root.tags[i], ignoreCase) > getTagName(root.tags[i + 1], ignoreCase)) {
-                    report({
-                        message: 'The `tags` array should be in alphabetical order.',
-                        location: location.child(['tags', i]),
-                    });
-                }
-            }
-        },
-    };
-};
-//# sourceMappingURL=tags-alphabetical.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas2/boolean-parameter-prefixes.js

@@ -1,19 +0,0 @@
-export const BooleanParameterPrefixes = (options) => {
-    const prefixes = options.prefixes || ['is', 'has'];
-    const regexp = new RegExp(`^(${prefixes.join('|')})[A-Z-_]`);
-    const wrappedPrefixes = prefixes.map((p) => `\`${p}\``);
-    const prefixesString = wrappedPrefixes.length === 1
-        ? wrappedPrefixes[0]
-        : wrappedPrefixes.slice(0, -1).join(', ') + ' or ' + wrappedPrefixes[prefixes.length - 1];
-    return {
-        Parameter(param, { report, location }) {
-            if (param.type === 'boolean' && !regexp.test(param.name)) {
-                report({
-                    message: `Boolean parameter \`${param.name}\` should have ${prefixesString} prefix.`,
-                    location: location.child('name'),
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=boolean-parameter-prefixes.js.map