@kubb/agent 4.33.1 → 4.33.3

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

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

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

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

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

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

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

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

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

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

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

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

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