@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/rules/oas3/no-example-value-and-externalValue.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoExampleValueAndExternalValue = void 0;
+const NoExampleValueAndExternalValue = () => {
+    return {
+        Example(example, { report, location }) {
+            if (example.value && example.externalValue) {
+                report({
+                    message: 'Example object can have either `value` or `externalValue` fields.',
+                    location: location.child(['value']).key(),
+                });
+            }
+        },
+    };
+};
+exports.NoExampleValueAndExternalValue = NoExampleValueAndExternalValue;

package/lib/rules/oas3/no-invalid-media-type-examples.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const ValidContentExamples: Oas3Rule;

package/lib/rules/oas3/no-invalid-media-type-examples.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidContentExamples = void 0;
+const ref_utils_1 = require("../../ref-utils");
+const utils_1 = require("../utils");
+const ValidContentExamples = (opts) => {
+    const allowAdditionalProperties = (0, utils_1.getAdditionalPropertiesOption)(opts) ?? false;
+    return {
+        MediaType: {
+            leave(mediaType, ctx) {
+                const { location, resolve } = ctx;
+                if (!mediaType.schema)
+                    return;
+                if (mediaType.example !== undefined) {
+                    resolveAndValidateExample(mediaType.example, location.child('example'));
+                }
+                else if (mediaType.examples) {
+                    for (const exampleName of Object.keys(mediaType.examples)) {
+                        resolveAndValidateExample(mediaType.examples[exampleName], location.child(['examples', exampleName, 'value']), true);
+                    }
+                }
+                function resolveAndValidateExample(example, location, isMultiple) {
+                    if ((0, ref_utils_1.isRef)(example)) {
+                        const resolved = resolve(example);
+                        if (!resolved.location)
+                            return;
+                        location = isMultiple ? resolved.location.child('value') : resolved.location;
+                        example = resolved.node;
+                    }
+                    if (isMultiple && typeof example.value === 'undefined') {
+                        return;
+                    }
+                    (0, utils_1.validateExample)(isMultiple ? example.value : example, mediaType.schema, location, ctx, allowAdditionalProperties);
+                }
+            },
+        },
+    };
+};
+exports.ValidContentExamples = ValidContentExamples;

package/lib/rules/oas3/no-server-example.com.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const NoServerExample: Oas3Rule;

package/lib/rules/oas3/no-server-example.com.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoServerExample = void 0;
+const NoServerExample = () => {
+    return {
+        Server(server, { report, location }) {
+            // eslint-disable-next-line no-useless-escape
+            const pattern = /^(.*[\/.])?(example\.com|localhost)([\/:?].*|$)/;
+            if (server.url && pattern.test(server.url)) {
+                report({
+                    message: 'Server `url` should not point to example.com or localhost.',
+                    location: location.child(['url']),
+                });
+            }
+        },
+    };
+};
+exports.NoServerExample = NoServerExample;

package/lib/rules/oas3/no-server-trailing-slash.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const NoServerTrailingSlash: Oas3Rule;

package/lib/rules/oas3/no-server-trailing-slash.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoServerTrailingSlash = void 0;
+const NoServerTrailingSlash = () => {
+    return {
+        Server(server, { report, location }) {
+            if (!server.url)
+                return;
+            if (server.url.endsWith('/') && server.url !== '/') {
+                report({
+                    message: 'Server `url` should not have a trailing slash.',
+                    location: location.child(['url']),
+                });
+            }
+        },
+    };
+};
+exports.NoServerTrailingSlash = NoServerTrailingSlash;

package/lib/rules/oas3/no-server-variables-empty-enum.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const NoServerVariablesEmptyEnum: Oas3Rule;

package/lib/rules/oas3/no-server-variables-empty-enum.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoServerVariablesEmptyEnum = void 0;
+var enumError;
+(function (enumError) {
+    enumError["empty"] = "empty";
+    enumError["invalidDefaultValue"] = "invalidDefaultValue";
+})(enumError || (enumError = {}));
+const NoServerVariablesEmptyEnum = () => {
+    return {
+        Root(root, { report, location }) {
+            if (!root.servers || root.servers.length === 0)
+                return;
+            const invalidVariables = [];
+            if (Array.isArray(root.servers)) {
+                for (const server of root.servers) {
+                    const enumErrors = checkEnumVariables(server);
+                    if (!enumErrors)
+                        continue;
+                    invalidVariables.push(...enumErrors);
+                }
+            }
+            else {
+                const enumErrors = checkEnumVariables(root.servers);
+                if (!enumErrors)
+                    return;
+                invalidVariables.push(...enumErrors);
+            }
+            for (const invalidVariable of invalidVariables) {
+                if (invalidVariable === enumError.empty) {
+                    report({
+                        message: 'Server variable with `enum` must be a non-empty array.',
+                        location: location.child(['servers']).key(),
+                    });
+                }
+                if (invalidVariable === enumError.invalidDefaultValue) {
+                    report({
+                        message: 'Server variable define `enum` and `default`. `enum` must include default value',
+                        location: location.child(['servers']).key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.NoServerVariablesEmptyEnum = NoServerVariablesEmptyEnum;
+function checkEnumVariables(server) {
+    if (server.variables && Object.keys(server.variables).length === 0)
+        return;
+    const errors = [];
+    for (const variable in server.variables) {
+        const serverVariable = server.variables[variable];
+        if (!serverVariable.enum)
+            continue;
+        if (Array.isArray(serverVariable.enum) && serverVariable.enum?.length === 0)
+            errors.push(enumError.empty);
+        if (!serverVariable.default)
+            continue;
+        const defaultValue = server.variables[variable].default;
+        if (serverVariable.enum && !serverVariable.enum.includes(defaultValue))
+            errors.push(enumError.invalidDefaultValue);
+    }
+    if (errors.length)
+        return errors;
+    return;
+}

package/lib/rules/oas3/no-undefined-server-variable.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const NoUndefinedServerVariable: Oas3Rule;

package/lib/rules/oas3/no-undefined-server-variable.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoUndefinedServerVariable = void 0;
+const NoUndefinedServerVariable = () => {
+    return {
+        Server(server, { report, location }) {
+            if (!server.url)
+                return;
+            const urlVariables = server.url.match(/{[^}]+}/g)?.map((e) => e.slice(1, e.length - 1)) || [];
+            const definedVariables = (server?.variables && Object.keys(server.variables)) || [];
+            for (const serverVar of urlVariables) {
+                if (!definedVariables.includes(serverVar)) {
+                    report({
+                        message: `The \`${serverVar}\` variable is not defined in the \`variables\` objects.`,
+                        location: location.child(['url']),
+                    });
+                }
+            }
+            for (const definedServerVar of definedVariables) {
+                if (!urlVariables.includes(definedServerVar)) {
+                    report({
+                        message: `The \`${definedServerVar}\` variable is not used in the server's \`url\` field.`,
+                        location: location.child(['variables', definedServerVar]).key(),
+                        from: location.child('url'),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.NoUndefinedServerVariable = NoUndefinedServerVariable;

package/lib/rules/oas3/no-unused-components.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const NoUnusedComponents: Oas3Rule;

package/lib/rules/oas3/no-unused-components.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoUnusedComponents = void 0;
+const NoUnusedComponents = () => {
+    const components = new Map();
+    function registerComponent(location, name) {
+        components.set(location.absolutePointer, {
+            used: components.get(location.absolutePointer)?.used || false,
+            location,
+            name,
+        });
+    }
+    return {
+        ref(ref, { type, resolve, key, location }) {
+            if (['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(type.name)) {
+                const resolvedRef = resolve(ref);
+                if (!resolvedRef.location)
+                    return;
+                components.set(resolvedRef.location.absolutePointer, {
+                    used: true,
+                    name: key.toString(),
+                    location,
+                });
+            }
+        },
+        Root: {
+            leave(_, { report }) {
+                components.forEach((usageInfo) => {
+                    if (!usageInfo.used) {
+                        report({
+                            message: `Component: "${usageInfo.name}" is never used.`,
+                            location: usageInfo.location.key(),
+                        });
+                    }
+                });
+            },
+        },
+        NamedSchemas: {
+            Schema(schema, { location, key }) {
+                if (!schema.allOf) {
+                    // FIXME: find a better way to detect possible discriminator
+                    registerComponent(location, key.toString());
+                }
+            },
+        },
+        NamedParameters: {
+            Parameter(_parameter, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedResponses: {
+            Response(_response, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedExamples: {
+            Example(_example, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedRequestBodies: {
+            RequestBody(_requestBody, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedHeaders: {
+            Header(_header, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+    };
+};
+exports.NoUnusedComponents = NoUnusedComponents;

package/lib/rules/oas3/operation-4xx-problem-details-rfc7807.d.ts

@@ -0,0 +1,5 @@
+import type { Oas3Rule } from '../../visitors';
+/**
+ * Validation according to rfc7807 - https://datatracker.ietf.org/doc/html/rfc7807
+ */
+export declare const Operation4xxProblemDetailsRfc7807: Oas3Rule;

package/lib/rules/oas3/operation-4xx-problem-details-rfc7807.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation4xxProblemDetailsRfc7807 = void 0;
+const utils_1 = require("../utils");
+/**
+ * Validation according to rfc7807 - https://datatracker.ietf.org/doc/html/rfc7807
+ */
+const Operation4xxProblemDetailsRfc7807 = () => {
+    return {
+        Response: {
+            skip(_, key) {
+                return !/4[Xx0-9]{2}/.test(`${key}`);
+            },
+            enter(response, { report, location }) {
+                if (!response.content || !response.content['application/problem+json'])
+                    report({
+                        message: 'Response `4xx` must have content-type `application/problem+json`.',
+                        location: location.key(),
+                    });
+            },
+            MediaType: {
+                skip(_, key) {
+                    return key !== 'application/problem+json';
+                },
+                enter(media, ctx) {
+                    (0, utils_1.validateDefinedAndNonEmpty)('schema', media, ctx);
+                },
+                SchemaProperties(schema, ctx) {
+                    (0, utils_1.validateDefinedAndNonEmpty)('type', schema, ctx);
+                    (0, utils_1.validateDefinedAndNonEmpty)('title', schema, ctx);
+                },
+            },
+        },
+    };
+};
+exports.Operation4xxProblemDetailsRfc7807 = Operation4xxProblemDetailsRfc7807;

package/lib/rules/oas3/request-mime-type.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const RequestMimeType: Oas3Rule;

package/lib/rules/oas3/request-mime-type.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMimeType = void 0;
+const utils_1 = require("../../utils");
+const RequestMimeType = ({ allowedValues }) => {
+    return {
+        Paths: {
+            RequestBody: {
+                leave(requestBody, ctx) {
+                    (0, utils_1.validateMimeTypeOAS3)({ type: 'consumes', value: requestBody }, ctx, allowedValues);
+                },
+            },
+            Callback: {
+                RequestBody() { },
+                Response: {
+                    leave(response, ctx) {
+                        (0, utils_1.validateMimeTypeOAS3)({ type: 'consumes', value: response }, ctx, allowedValues);
+                    },
+                },
+            },
+        },
+        WebhooksMap: {
+            Response: {
+                leave(response, ctx) {
+                    (0, utils_1.validateMimeTypeOAS3)({ type: 'consumes', value: response }, ctx, allowedValues);
+                },
+            },
+        },
+    };
+};
+exports.RequestMimeType = RequestMimeType;

package/lib/rules/oas3/response-contains-property.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const ResponseContainsProperty: Oas3Rule;

package/lib/rules/oas3/response-contains-property.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsProperty = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsProperty = (options) => {
+    const names = options.names || {};
+    let key;
+    return {
+        Operation: {
+            Response: {
+                skip: (_response, key) => {
+                    return `${key}` === '204';
+                },
+                enter: (_response, ctx) => {
+                    key = ctx.key;
+                },
+                MediaType: {
+                    Schema(schema, { report, location }) {
+                        if (schema.type !== 'object')
+                            return;
+                        const expectedProperties = names[key] ||
+                            names[(0, utils_1.getMatchingStatusCodeRange)(key)] ||
+                            names[(0, utils_1.getMatchingStatusCodeRange)(key).toLowerCase()] ||
+                            [];
+                        for (const expectedProperty of expectedProperties) {
+                            if (!schema.properties?.[expectedProperty]) {
+                                report({
+                                    message: `Response object must contain a top-level "${expectedProperty}" property.`,
+                                    location: location.child('properties').key(),
+                                });
+                            }
+                        }
+                    },
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsProperty = ResponseContainsProperty;

package/lib/rules/oas3/response-mime-type.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const ResponseMimeType: Oas3Rule;

package/lib/rules/oas3/response-mime-type.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseMimeType = void 0;
+const utils_1 = require("../../utils");
+const ResponseMimeType = ({ allowedValues }) => {
+    return {
+        Paths: {
+            Response: {
+                leave(response, ctx) {
+                    (0, utils_1.validateMimeTypeOAS3)({ type: 'produces', value: response }, ctx, allowedValues);
+                },
+            },
+            Callback: {
+                Response() { },
+                RequestBody: {
+                    leave(requestBody, ctx) {
+                        (0, utils_1.validateMimeTypeOAS3)({ type: 'produces', value: requestBody }, ctx, allowedValues);
+                    },
+                },
+            },
+        },
+        WebhooksMap: {
+            RequestBody: {
+                leave(requestBody, ctx) {
+                    (0, utils_1.validateMimeTypeOAS3)({ type: 'produces', value: requestBody }, ctx, allowedValues);
+                },
+            },
+        },
+    };
+};
+exports.ResponseMimeType = ResponseMimeType;

package/lib/rules/oas3/spec-components-invalid-map-name.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from '../../visitors';
+export declare const SpecComponentsInvalidMapName: Oas3Rule;

package/lib/rules/oas3/spec-components-invalid-map-name.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecComponentsInvalidMapName = void 0;
+const SpecComponentsInvalidMapName = () => {
+    const KEYS_REGEX = '^[a-zA-Z0-9\\.\\-_]+$';
+    function validateKey(key, report, location, component) {
+        if (!new RegExp(KEYS_REGEX).test(key)) {
+            report({
+                message: `The map key in ${component} "${key}" does not match the regular expression "${KEYS_REGEX}"`,
+                location: location.key(),
+            });
+        }
+    }
+    return {
+        NamedSchemas: {
+            Schema(_node, { key, report, location }) {
+                validateKey(key, report, location, 'schemas');
+            },
+        },
+        NamedParameters: {
+            Parameter(_node, { key, report, location }) {
+                validateKey(key, report, location, 'parameters');
+            },
+        },
+        NamedResponses: {
+            Response(_node, { key, report, location }) {
+                validateKey(key, report, location, 'responses');
+            },
+        },
+        NamedExamples: {
+            Example(_node, { key, report, location }) {
+                validateKey(key, report, location, 'examples');
+            },
+        },
+        NamedRequestBodies: {
+            RequestBody(_node, { key, report, location }) {
+                validateKey(key, report, location, 'requestBodies');
+            },
+        },
+        NamedHeaders: {
+            Header(_node, { key, report, location }) {
+                validateKey(key, report, location, 'headers');
+            },
+        },
+        NamedSecuritySchemes: {
+            SecurityScheme(_node, { key, report, location }) {
+                validateKey(key, report, location, 'securitySchemes');
+            },
+        },
+        NamedLinks: {
+            Link(_node, { key, report, location }) {
+                validateKey(key, report, location, 'links');
+            },
+        },
+        NamedCallbacks: {
+            Callback(_node, { key, report, location }) {
+                validateKey(key, report, location, 'callbacks');
+            },
+        },
+    };
+};
+exports.SpecComponentsInvalidMapName = SpecComponentsInvalidMapName;

package/lib/rules/other/stats.d.ts

@@ -0,0 +1,41 @@
+import type { Oas3Parameter, OasRef, Oas3Tag } from '../../typings/openapi';
+import type { Oas2Parameter } from '../../typings/swagger';
+import type { StatsAccumulator } from '../../typings/common';
+export declare const Stats: (statsAccumulator: StatsAccumulator) => {
+    ExternalDocs: {
+        leave(): void;
+    };
+    ref: {
+        enter(ref: OasRef): void;
+    };
+    Tag: {
+        leave(tag: Oas3Tag): void;
+    };
+    Link: {
+        leave(link: any): void;
+    };
+    Root: {
+        leave(): void;
+    };
+    WebhooksMap: {
+        Operation: {
+            leave(operation: any): void;
+        };
+    };
+    Paths: {
+        PathItem: {
+            leave(): void;
+            Operation: {
+                leave(operation: any): void;
+            };
+            Parameter: {
+                leave(parameter: Oas2Parameter | Oas3Parameter): void;
+            };
+        };
+    };
+    NamedSchemas: {
+        Schema: {
+            leave(): void;
+        };
+    };
+};

package/lib/rules/other/stats.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stats = void 0;
+const Stats = (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);
+            },
+        },
+        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;
+            },
+        },
+        WebhooksMap: {
+            Operation: {
+                leave(operation) {
+                    statsAccumulator.webhooks.total++;
+                    operation.tags &&
+                        operation.tags.forEach((tag) => {
+                            statsAccumulator.tags.items.add(tag);
+                        });
+                },
+            },
+        },
+        Paths: {
+            PathItem: {
+                leave() {
+                    statsAccumulator.pathItems.total++;
+                },
+                Operation: {
+                    leave(operation) {
+                        statsAccumulator.operations.total++;
+                        operation.tags &&
+                            operation.tags.forEach((tag) => {
+                                statsAccumulator.tags.items.add(tag);
+                            });
+                    },
+                },
+                Parameter: {
+                    leave(parameter) {
+                        statsAccumulator.parameters.items.add(parameter.name);
+                    },
+                },
+            },
+        },
+        NamedSchemas: {
+            Schema: {
+                leave() {
+                    statsAccumulator.schemas.total++;
+                },
+            },
+        },
+    };
+};
+exports.Stats = Stats;

package/lib/rules/spot/no-criteria-xpath.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const NoCriteriaXpath: Arazzo1Rule;

package/lib/rules/spot/no-criteria-xpath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoCriteriaXpath = void 0;
+const NoCriteriaXpath = () => {
+    return {
+        CriterionObject: {
+            enter(criteria, { report, location }) {
+                if (!criteria.type) {
+                    return;
+                }
+                if (criteria?.type?.type === 'xpath' || criteria?.type === 'xpath') {
+                    report({
+                        message: 'The `xpath` type criteria is not supported by Spot.',
+                        location: location.child(['type']),
+                    });
+                }
+            },
+        },
+    };
+};
+exports.NoCriteriaXpath = NoCriteriaXpath;

package/lib/rules/spot/spot-supported-versions.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const SpotSupportedVersions: Arazzo1Rule;