@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/other/stats.js

@@ -0,0 +1,190 @@
+export const StatsOAS = (statsAccumulator) => {
+    return {
+        ExternalDocs: {
+            leave() {
+                statsAccumulator.externalDocs.total++;
+            },
+        },
+        ref: {
+            enter(ref) {
+                statsAccumulator.refs.items.add(ref['$ref']);
+            },
+        },
+        Tag: {
+            leave(tag) {
+                statsAccumulator.tags.items.add(tag.name);
+            },
+        },
+        Link: {
+            leave(link) {
+                statsAccumulator.links.items.add(link.operationId);
+            },
+        },
+        WebhooksMap: {
+            Operation: {
+                leave(operation) {
+                    statsAccumulator.webhooks.total++;
+                    if (operation.tags) {
+                        for (const tag of operation.tags) {
+                            statsAccumulator.tags.items.add(tag);
+                        }
+                    }
+                },
+            },
+        },
+        Paths: {
+            PathItem: {
+                leave() {
+                    statsAccumulator.pathItems.total++;
+                },
+                Operation: {
+                    leave(operation) {
+                        statsAccumulator.operations.total++;
+                        if (operation.tags) {
+                            for (const tag of operation.tags) {
+                                statsAccumulator.tags.items.add(tag);
+                            }
+                        }
+                    },
+                },
+                Parameter: {
+                    leave(parameter) {
+                        statsAccumulator.parameters.items.add(parameter.name);
+                    },
+                },
+            },
+        },
+        NamedSchemas: {
+            Schema: {
+                leave() {
+                    statsAccumulator.schemas.total++;
+                },
+            },
+        },
+        Root: {
+            leave() {
+                statsAccumulator.parameters.total = statsAccumulator.parameters.items.size;
+                statsAccumulator.refs.total = statsAccumulator.refs.items.size;
+                statsAccumulator.links.total = statsAccumulator.links.items.size;
+                statsAccumulator.tags.total = statsAccumulator.tags.items.size;
+            },
+        },
+    };
+};
+export const StatsAsync2 = (statsAccumulator) => {
+    return {
+        ExternalDocs: {
+            leave() {
+                statsAccumulator.externalDocs.total++;
+            },
+        },
+        ref: {
+            enter(ref) {
+                statsAccumulator.refs.items.add(ref['$ref']);
+            },
+        },
+        Tag: {
+            leave(tag) {
+                statsAccumulator.tags.items.add(tag.name);
+            },
+        },
+        ChannelMap: {
+            Channel: {
+                leave() {
+                    statsAccumulator.channels.total++;
+                },
+                Operation: {
+                    leave(operation) {
+                        statsAccumulator.operations.total++;
+                        if (operation.tags) {
+                            for (const tag of operation.tags) {
+                                statsAccumulator.tags.items.add(tag);
+                            }
+                        }
+                    },
+                },
+                Parameter: {
+                    leave(parameter) {
+                        if (parameter.name) {
+                            statsAccumulator.parameters.items.add(parameter.name);
+                        }
+                    },
+                },
+            },
+        },
+        NamedSchemas: {
+            Schema: {
+                leave() {
+                    statsAccumulator.schemas.total++;
+                },
+            },
+        },
+        Root: {
+            leave() {
+                statsAccumulator.parameters.total = statsAccumulator.parameters.items.size;
+                statsAccumulator.refs.total = statsAccumulator.refs.items.size;
+                statsAccumulator.tags.total = statsAccumulator.tags.items.size;
+            },
+        },
+    };
+};
+export const StatsAsync3 = (statsAccumulator) => {
+    return {
+        ExternalDocs: {
+            leave() {
+                statsAccumulator.externalDocs.total++;
+            },
+        },
+        ref: {
+            enter(ref) {
+                statsAccumulator.refs.items.add(ref['$ref']);
+            },
+        },
+        Tag: {
+            leave(tag) {
+                statsAccumulator.tags.items.add(tag.name);
+            },
+        },
+        NamedChannels: {
+            Channel: {
+                leave() {
+                    statsAccumulator.channels.total++;
+                },
+                Parameter: {
+                    leave(parameter) {
+                        if (parameter.name) {
+                            statsAccumulator.parameters.items.add(parameter.name);
+                        }
+                    },
+                },
+            },
+        },
+        NamedOperations: {
+            Operation: {
+                leave(operation) {
+                    statsAccumulator.operations.total++;
+                    if (operation.tags) {
+                        for (const tag of operation.tags) {
+                            statsAccumulator.tags.items.add(tag);
+                        }
+                    }
+                },
+            },
+        },
+        NamedSchemas: {
+            Schema: {
+                leave() {
+                    statsAccumulator.schemas.total++;
+                },
+            },
+        },
+        Root: {
+            leave() {
+                statsAccumulator.parameters.total = statsAccumulator.parameters.items.size;
+                statsAccumulator.refs.total = statsAccumulator.refs.items.size;
+                statsAccumulator.tags.total = statsAccumulator.tags.items.size;
+            },
+        },
+    };
+};
+//# sourceMappingURL=stats.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/overlay1/index.js

@@ -0,0 +1,12 @@
+import { Assertions } from '../common/assertions/index.js';
+import { InfoContact } from '../common/info-contact.js';
+import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
+import { Struct } from '../common/struct.js';
+export const rules = {
+    'info-contact': InfoContact,
+    struct: Struct,
+    'no-unresolved-refs': NoUnresolvedRefs,
+    assertions: Assertions,
+};
+export const preprocessors = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-criteria-xpath.js

@@ -0,0 +1,20 @@
+import { isPlainObject } from '../../utils/is-plain-object.js';
+export const NoCriteriaXpath = () => {
+    return {
+        CriterionObject: {
+            enter(criteria, { report, location }) {
+                if (!criteria.type) {
+                    return;
+                }
+                if (criteria.type === 'xpath' ||
+                    (isPlainObject(criteria.type) && criteria.type.type === 'xpath')) {
+                    report({
+                        message: 'The `xpath` type criteria is not supported by Respect.',
+                        location: location.child(['type']),
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-criteria-xpath.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-x-security-both-scheme-and-scheme-name.js

@@ -0,0 +1,30 @@
+import { getOwn } from '../../utils/get-own.js';
+export const NoXSecurityBothSchemeAndSchemeName = () => {
+    function validate(extendedSecurity, { report, location }) {
+        if (!Array.isArray(extendedSecurity))
+            return;
+        for (const security of extendedSecurity) {
+            const hasScheme = getOwn(security, 'scheme');
+            const hasSchemeName = getOwn(security, 'schemeName');
+            if (hasScheme && hasSchemeName) {
+                report({
+                    message: '`x-security` item must not contain both `scheme` and `schemeName`.',
+                    location: location.child(['x-security', extendedSecurity.indexOf(security)]),
+                });
+            }
+        }
+    }
+    return {
+        Workflow: {
+            enter(workflow, context) {
+                validate(workflow?.['x-security'], context);
+            },
+        },
+        Step: {
+            enter(step, context) {
+                validate(step?.['x-security'], context);
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-x-security-both-scheme-and-scheme-name.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-x-security-scheme-name-without-openapi.js

@@ -0,0 +1,25 @@
+export const NoXSecuritySchemeNameWithoutOpenAPI = () => {
+    return {
+        Step: {
+            enter(step, { report, location }) {
+                const hasExtendedOperation = step?.['x-operation'];
+                if (!hasExtendedOperation) {
+                    return;
+                }
+                const extendedSecurity = step?.['x-security'];
+                if (!extendedSecurity) {
+                    return;
+                }
+                for (const security of extendedSecurity) {
+                    if ('schemeName' in security) {
+                        report({
+                            message: 'The `schemeName` can be only used in Step with OpenAPI operation, please use `scheme` instead.',
+                            location: location.child(['x-security', extendedSecurity.indexOf(security)]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-x-security-scheme-name-without-openapi.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/respect-supported-versions.js

@@ -0,0 +1,18 @@
+import { ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT } from '../../typings/arazzo.js';
+import { pluralize } from '../../utils/pluralize.js';
+export const RespectSupportedVersions = () => {
+    const supportedVersions = ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.join(', ');
+    return {
+        Root: {
+            enter(root, { report, location }) {
+                if (!ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.includes(root.arazzo)) {
+                    report({
+                        message: `Only ${supportedVersions} Arazzo ${pluralize('version is', ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.length)} fully supported by Respect.`,
+                        location: location.child('arazzo'),
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=respect-supported-versions.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/x-security-scheme-name-reference.js

@@ -0,0 +1,35 @@
+export const XSecuritySchemeNameReference = () => {
+    let sourceDescriptionsCount = 0;
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions) {
+                sourceDescriptionsCount = Array.isArray(sourceDescriptions) ? sourceDescriptions.length : 0;
+            },
+        },
+        Workflow: {
+            leave(workflow, { report, location }) {
+                const extendedSecurity = workflow?.['x-security'];
+                if (!extendedSecurity || sourceDescriptionsCount <= 1) {
+                    return;
+                }
+                for (const security of extendedSecurity) {
+                    if ('schemeName' in security) {
+                        const schemeName = security.schemeName;
+                        const isReference = typeof schemeName === 'string' && schemeName.startsWith('$sourceDescriptions.');
+                        if (!isReference) {
+                            report({
+                                message: 'When multiple `sourceDescriptions` exist, `workflow.x-security.schemeName` must be a reference to a source description (e.g. `$sourceDescriptions.{name}.{schemeName}`)',
+                                location: location.child([
+                                    'x-security',
+                                    extendedSecurity.indexOf(security),
+                                    'schemeName',
+                                ]),
+                            });
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=x-security-scheme-name-reference.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/x-security-scheme-required-values.js

@@ -0,0 +1,60 @@
+import { logger } from '../../logger.js';
+const REQUIRED_VALUES_BY_AUTH_TYPE = {
+    apiKey: ['apiKey'],
+    basic: ['username', 'password'],
+    digest: ['username', 'password'],
+    bearer: ['token'],
+    oauth2: ['accessToken'],
+    openIdConnect: ['accessToken'],
+    mutualTLS: [],
+};
+function validateSecuritySchemas(extendedSecurity, { report, location }) {
+    if (!extendedSecurity) {
+        return;
+    }
+    for (const securitySchema of extendedSecurity) {
+        // TODO: Handle schemeName case, this will require bundled OpenAPI definitions
+        if ('schemeName' in securitySchema) {
+            continue;
+        }
+        const { scheme, values } = securitySchema;
+        // TODO: Struct rule does not check before this point, so we need to check it here. Investigate if we can move this check to the Struct rule.
+        const authType = scheme?.type === 'http' ? scheme.scheme : scheme?.type;
+        if (authType === 'mutualTLS') {
+            logger.warn('Please use CLI option to provide mutualTLS certificates for mutualTls authentication security schema.');
+            continue;
+        }
+        const requiredValues = REQUIRED_VALUES_BY_AUTH_TYPE[authType];
+        if (requiredValues) {
+            for (const requiredValue of requiredValues) {
+                if (!values || !(requiredValue in values)) {
+                    report({
+                        message: `The \`${requiredValue}\` is required when using the ${authType} authentication security schema.`,
+                        location: location.child(['x-security', extendedSecurity.indexOf(securitySchema)]),
+                    });
+                }
+            }
+        }
+        else {
+            report({
+                message: `The \`${authType}\` authentication security schema is not supported.`,
+                location: location.child(['x-security', extendedSecurity.indexOf(securitySchema)]),
+            });
+        }
+    }
+}
+export const XSecuritySchemaRequiredValues = () => {
+    return {
+        Step: {
+            enter(step, context) {
+                validateSecuritySchemas(step?.['x-security'], context);
+            },
+        },
+        Workflow: {
+            enter(workflow, context) {
+                validateSecuritySchemas(workflow?.['x-security'], context);
+            },
+        },
+    };
+};
+//# sourceMappingURL=x-security-scheme-required-values.js.map

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

@@ -0,0 +1,172 @@
+import { default as levenshtein } from 'js-levenshtein';
+import { Location } from '../ref-utils.js';
+import { isPlainObject } from '../utils/is-plain-object.js';
+import { validateJsonSchema } from './ajv.js';
+export function oasTypeOf(value) {
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    else if (value === null) {
+        return 'null';
+    }
+    else if (Number.isInteger(value)) {
+        return 'integer';
+    }
+    else {
+        return typeof value;
+    }
+}
+/**
+ * Checks if value matches specified JSON schema type
+ *
+ * @param {*} value - value to check
+ * @param {JSONSchemaType} type - JSON Schema type
+ * @returns boolean
+ */
+export function matchesJsonSchemaType(value, type, nullable) {
+    if (nullable && value === null) {
+        return true;
+    }
+    switch (type) {
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return isPlainObject(value);
+        case 'null':
+            return value === null;
+        case 'integer':
+            return Number.isInteger(value);
+        default:
+            return typeof value === type;
+    }
+}
+export function missingRequiredField(type, field) {
+    return `${type} object should contain \`${field}\` field.`;
+}
+export function missingRequiredOneOfFields(type, fields) {
+    return `${type} object should contain one of the fields: ${fields
+        .map((field) => `\`${field}\``)
+        .join(', ')}.`;
+}
+export function fieldNonEmpty(type, field) {
+    return `${type} object \`${field}\` must be non-empty string.`;
+}
+export function validateDefinedAndNonEmpty(fieldName, value, ctx) {
+    if (!isPlainObject(value)) {
+        return;
+    }
+    if (value[fieldName] === undefined) {
+        ctx.report({
+            message: missingRequiredField(ctx.type.name, fieldName),
+            location: ctx.location.child([fieldName]).key(),
+        });
+    }
+    else if (!value[fieldName]) {
+        ctx.report({
+            message: fieldNonEmpty(ctx.type.name, fieldName),
+            location: ctx.location.child([fieldName]).key(),
+        });
+    }
+}
+export function validateOneOfDefinedAndNonEmpty(fieldNames, value, ctx) {
+    if (!isPlainObject(value)) {
+        return;
+    }
+    if (!fieldNames.some((fieldName) => value.hasOwnProperty(fieldName))) {
+        ctx.report({
+            message: missingRequiredOneOfFields(ctx.type.name, fieldNames),
+            location: ctx.location.key(),
+        });
+    }
+    for (const fieldName of fieldNames) {
+        if (value.hasOwnProperty(fieldName) && !value[fieldName]) {
+            ctx.report({
+                message: fieldNonEmpty(ctx.type.name, fieldName),
+                location: ctx.location.child([fieldName]).key(),
+            });
+        }
+    }
+}
+export function getSuggest(given, variants) {
+    if (given === null)
+        return variants;
+    if (typeof given !== 'string' || !variants.length)
+        return [];
+    const distances = [];
+    for (let i = 0; i < variants.length; i++) {
+        const distance = levenshtein(given, variants[i]);
+        if (distance < 4) {
+            distances.push({ distance, variant: variants[i] });
+        }
+    }
+    distances.sort((a, b) => a.distance - b.distance);
+    // if (bestMatch.distance <= 4) return bestMatch.string;
+    return distances.map((d) => d.variant);
+}
+export function validateExample(example, schema, options) {
+    const { location, ctx, allowAdditionalProperties, ajvContext } = options;
+    const { resolve, location: parentLocation, report, specVersion } = ctx;
+    try {
+        const { valid, errors } = validateJsonSchema(example, schema, {
+            schemaLoc: parentLocation.child('schema'),
+            instancePath: location.pointer,
+            resolve,
+            allowAdditionalProperties,
+            ajvContext,
+            specVersion,
+        });
+        if (!valid) {
+            for (const error of errors) {
+                report({
+                    message: `Example value must conform to the schema: ${error.message}.`,
+                    location: {
+                        ...new Location(location.source, error.instancePath),
+                        reportOnKey: error.keyword === 'unevaluatedProperties' || error.keyword === 'additionalProperties',
+                    },
+                    from: parentLocation,
+                    suggest: error.suggest,
+                });
+            }
+        }
+    }
+    catch (e) {
+        if (e.message === 'discriminator: requires oneOf or anyOf composite keyword') {
+            return;
+        }
+        report({
+            message: `Example validation errored: ${e.message}.`,
+            location: parentLocation.child('schema'),
+            from: parentLocation,
+        });
+    }
+}
+export function validateSchemaEnumType(schemaEnum, propertyValue, propName, refLocation, { report, location }) {
+    if (!schemaEnum) {
+        return;
+    }
+    if (!schemaEnum.includes(propertyValue)) {
+        report({
+            location,
+            message: `\`${propName}\` can be one of the following only: ${schemaEnum
+                .map((type) => `"${type}"`)
+                .join(', ')}.`,
+            from: refLocation,
+            suggest: getSuggest(propertyValue, schemaEnum),
+        });
+    }
+}
+export function validateResponseCodes(responseCodes, codeRange, { report }) {
+    const responseCodeRegexp = new RegExp(`^${codeRange[0]}[0-9Xx]{2}$`);
+    const containsNeededCode = responseCodes.some((code) => (codeRange === '2XX' && code === 'default') || // It's OK to replace 2xx codes with the default
+        responseCodeRegexp.test(code));
+    if (!containsNeededCode) {
+        report({
+            message: `Operation must have at least one \`${codeRange}\` response.`,
+            location: { reportOnKey: true },
+        });
+    }
+}
+export function getTagName(tag, ignoreCase) {
+    return ignoreCase ? tag.name.toLowerCase() : tag.name;
+}
+//# sourceMappingURL=utils.js.map