@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/rules/spot/spot-supported-versions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotSupportedVersions = void 0;
+const arazzo_1 = require("../../typings/arazzo");
+const utils_1 = require("../../utils");
+const SpotSupportedVersions = () => {
+    const supportedVersions = arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.join(', ');
+    return {
+        Root: {
+            enter(root, { report, location }) {
+                if (!arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.includes(root.arazzo)) {
+                    report({
+                        message: `Only ${supportedVersions} Arazzo ${(0, utils_1.pluralize)('version is', arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.length)} supported by Spot.`,
+                        location: location.child('arazzo'),
+                    });
+                }
+            },
+        },
+    };
+};
+exports.SpotSupportedVersions = SpotSupportedVersions;

package/lib/rules/utils.d.ts

@@ -0,0 +1,22 @@
+import { Location } from '../ref-utils';
+import type { Oas3Schema, Oas3_1Schema, Referenced } from '../typings/openapi';
+import type { UserContext } from '../walk';
+export declare function oasTypeOf(value: unknown): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "integer" | "array" | "null";
+/**
+ * Checks if value matches specified JSON schema type
+ *
+ * @param {*} value - value to check
+ * @param {JSONSchemaType} type - JSON Schema type
+ * @returns boolean
+ */
+export declare function matchesJsonSchemaType(value: unknown, type: string, nullable: boolean): boolean;
+export declare function missingRequiredField(type: string, field: string): string;
+export declare function missingRequiredOneOfFields(type: string, fields: string[]): string;
+export declare function fieldNonEmpty(type: string, field: string): string;
+export declare function validateDefinedAndNonEmpty(fieldName: string, value: any, ctx: UserContext): void;
+export declare function validateOneOfDefinedAndNonEmpty(fieldNames: string[], value: any, ctx: UserContext): void;
+export declare function getSuggest(given: string, variants: string[]): string[];
+export declare function validateExample(example: any, schema: Referenced<Oas3Schema | Oas3_1Schema>, dataLoc: Location, { resolve, location, report }: UserContext, allowAdditionalProperties: boolean): void;
+export declare function getAdditionalPropertiesOption(opts: Record<string, any>): boolean;
+export declare function validateSchemaEnumType(schemaEnum: string[], propertyValue: string, propName: string, refLocation: Location | undefined, { report, location }: UserContext): void;
+export declare function validateResponseCodes(responseCodes: string[], codeRange: string, { report }: UserContext): void;

package/lib/rules/utils.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oasTypeOf = oasTypeOf;
+exports.matchesJsonSchemaType = matchesJsonSchemaType;
+exports.missingRequiredField = missingRequiredField;
+exports.missingRequiredOneOfFields = missingRequiredOneOfFields;
+exports.fieldNonEmpty = fieldNonEmpty;
+exports.validateDefinedAndNonEmpty = validateDefinedAndNonEmpty;
+exports.validateOneOfDefinedAndNonEmpty = validateOneOfDefinedAndNonEmpty;
+exports.getSuggest = getSuggest;
+exports.validateExample = validateExample;
+exports.getAdditionalPropertiesOption = getAdditionalPropertiesOption;
+exports.validateSchemaEnumType = validateSchemaEnumType;
+exports.validateResponseCodes = validateResponseCodes;
+const levenshtein = require("js-levenshtein");
+const ref_utils_1 = require("../ref-utils");
+const ajv_1 = require("./ajv");
+const utils_1 = require("../utils");
+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
+ */
+function matchesJsonSchemaType(value, type, nullable) {
+    if (nullable && value === null) {
+        return true;
+    }
+    switch (type) {
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'null':
+            return value === null;
+        case 'integer':
+            return Number.isInteger(value);
+        default:
+            return typeof value === type;
+    }
+}
+function missingRequiredField(type, field) {
+    return `${type} object should contain \`${field}\` field.`;
+}
+function missingRequiredOneOfFields(type, fields) {
+    return `${type} object should contain one of the fields: ${fields
+        .map((field) => `\`${field}\``)
+        .join(', ')}.`;
+}
+function fieldNonEmpty(type, field) {
+    return `${type} object \`${field}\` must be non-empty string.`;
+}
+function validateDefinedAndNonEmpty(fieldName, value, ctx) {
+    if (!(0, utils_1.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(),
+        });
+    }
+}
+function validateOneOfDefinedAndNonEmpty(fieldNames, value, ctx) {
+    if (!(0, utils_1.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(),
+            });
+        }
+    }
+}
+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);
+}
+function validateExample(example, schema, dataLoc, { resolve, location, report }, allowAdditionalProperties) {
+    try {
+        const { valid, errors } = (0, ajv_1.validateJsonSchema)(example, schema, location.child('schema'), dataLoc.pointer, resolve, allowAdditionalProperties);
+        if (!valid) {
+            for (const error of errors) {
+                report({
+                    message: `Example value must conform to the schema: ${error.message}.`,
+                    location: {
+                        ...new ref_utils_1.Location(dataLoc.source, error.instancePath),
+                        reportOnKey: error.keyword === 'unevaluatedProperties' || error.keyword === 'additionalProperties',
+                    },
+                    from: location,
+                    suggest: error.suggest,
+                });
+            }
+        }
+    }
+    catch (e) {
+        if (e.message === 'discriminator: requires oneOf or anyOf composite keyword') {
+            return;
+        }
+        report({
+            message: `Example validation errored: ${e.message}.`,
+            location: location.child('schema'),
+            from: location,
+        });
+    }
+}
+function getAdditionalPropertiesOption(opts) {
+    if (opts.disallowAdditionalProperties === undefined) {
+        return opts.allowAdditionalProperties;
+    }
+    if (opts.allowAdditionalProperties !== undefined) {
+        (0, utils_1.showErrorForDeprecatedField)('disallowAdditionalProperties', 'allowAdditionalProperties', undefined);
+    }
+    (0, utils_1.showWarningForDeprecatedField)('disallowAdditionalProperties', 'allowAdditionalProperties');
+    return !opts.disallowAdditionalProperties;
+}
+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),
+        });
+    }
+}
+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 },
+        });
+    }
+}

package/lib/types/arazzo.d.ts

@@ -0,0 +1,2 @@
+import { type NodeType } from '.';
+export declare const Arazzo1Types: Record<string, NodeType>;

package/lib/types/arazzo.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arazzo1Types = void 0;
+const _1 = require(".");
+const oas3_1_1 = require("./oas3_1");
+const oas3_1 = require("./oas3");
+const Root = {
+    properties: {
+        arazzo: { type: 'string' },
+        info: 'Info',
+        sourceDescriptions: 'SourceDescriptions',
+        workflows: 'Workflows',
+        components: 'Components',
+    },
+    required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+    extensionsPrefix: 'x-',
+};
+const NamedParameters = {
+    properties: {},
+    additionalProperties: 'Parameter',
+};
+const NamedSuccessActions = {
+    properties: {},
+    additionalProperties: 'SuccessActionObject',
+};
+const NamedFailureActions = {
+    properties: {},
+    additionalProperties: 'FailureActionObject',
+};
+const Components = {
+    properties: {
+        inputs: 'NamedInputs',
+        parameters: 'NamedParameters',
+        successActions: 'NamedSuccessActions',
+        failureActions: 'NamedFailureActions',
+    },
+    extensionsPrefix: 'x-',
+};
+const NamedInputs = (0, _1.mapOf)('Schema');
+const Info = {
+    properties: {
+        title: { type: 'string' },
+        description: { type: 'string' },
+        summary: { type: 'string' },
+        version: { type: 'string' },
+    },
+    required: ['title', 'version'],
+    extensionsPrefix: 'x-',
+};
+const SourceDescriptions = {
+    properties: {},
+    items: (value) => {
+        if (value?.type === 'openapi') {
+            return 'OpenAPISourceDescription';
+        }
+        else {
+            return 'ArazzoSourceDescription';
+        }
+    },
+};
+const OpenAPISourceDescription = {
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['openapi'] },
+        url: { type: 'string' },
+        'x-serverUrl': { type: 'string' },
+    },
+    required: ['name', 'type', 'url'],
+    extensionsPrefix: 'x-',
+};
+const ArazzoSourceDescription = {
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['arazzo'] },
+        url: { type: 'string' },
+    },
+    required: ['name', 'type', 'url'],
+    extensionsPrefix: 'x-',
+};
+const ReusableObject = {
+    properties: {
+        reference: { type: 'string' },
+        value: {}, // any
+    },
+    required: ['reference'],
+    extensionsPrefix: 'x-',
+};
+const Parameter = {
+    properties: {
+        in: { type: 'string', enum: ['header', 'query', 'path', 'cookie'] },
+        name: { type: 'string' },
+        value: {}, // any
+    },
+    required: ['name', 'value'],
+    extensionsPrefix: 'x-',
+};
+const Parameters = {
+    properties: {},
+    items: (value) => {
+        if (value?.reference) {
+            return 'ReusableObject';
+        }
+        else {
+            return 'Parameter';
+        }
+    },
+};
+const Workflow = {
+    properties: {
+        workflowId: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        parameters: 'Parameters',
+        dependsOn: { type: 'array', items: { type: 'string' } },
+        inputs: 'Schema',
+        outputs: 'Outputs',
+        steps: 'Steps',
+        successActions: 'OnSuccessActionList',
+        failureActions: 'OnFailureActionList',
+    },
+    required: ['workflowId', 'steps'],
+    extensionsPrefix: 'x-',
+};
+const Workflows = (0, _1.listOf)('Workflow');
+const Steps = (0, _1.listOf)('Step');
+const Step = {
+    properties: {
+        stepId: { type: 'string' },
+        description: { type: 'string' },
+        operationId: { type: 'string' },
+        operationPath: { type: 'string' },
+        workflowId: { type: 'string' },
+        parameters: 'Parameters',
+        successCriteria: (0, _1.listOf)('CriterionObject'),
+        onSuccess: 'OnSuccessActionList',
+        onFailure: 'OnFailureActionList',
+        outputs: 'Outputs',
+        'x-operation': 'ExtendedOperation',
+        requestBody: 'RequestBody',
+    },
+    required: ['stepId'],
+    requiredOneOf: ['x-operation', 'operationId', 'operationPath', 'workflowId'],
+    extensionsPrefix: 'x-',
+};
+const Outputs = {
+    properties: {},
+    additionalProperties: {
+        type: 'string',
+    },
+};
+const RequestBody = {
+    properties: {
+        contentType: { type: 'string' },
+        payload: {},
+        replacements: (0, _1.listOf)('Replacement'),
+    },
+    required: ['payload'],
+    extensionsPrefix: 'x-',
+};
+const Replacement = {
+    properties: {
+        target: { type: 'string' },
+        value: {},
+    },
+    required: ['target', 'value'],
+    extensionsPrefix: 'x-',
+};
+const ExtendedOperation = {
+    properties: {
+        url: { type: 'string' },
+        method: {
+            enum: [
+                'get',
+                'post',
+                'put',
+                'delete',
+                'patch',
+                'GET',
+                'POST',
+                'PUT',
+                'DELETE',
+                'PATCH',
+                'options',
+                'OPTIONS',
+                'head',
+                'HEAD',
+                'trace',
+                'TRACE',
+                'connect',
+                'CONNECT',
+            ],
+        },
+    },
+    required: ['url', 'method'],
+};
+const CriterionObject = {
+    properties: {
+        condition: { type: 'string' },
+        context: { type: 'string' },
+        type: (value) => {
+            if (!value) {
+                return undefined;
+            }
+            else if (typeof value === 'string') {
+                return { enum: ['regex', 'jsonpath', 'simple', 'xpath'] };
+            }
+            else if (value?.type === 'jsonpath') {
+                return 'JSONPathCriterion';
+            }
+            else {
+                return 'XPathCriterion';
+            }
+        },
+    },
+    required: ['condition'],
+};
+const JSONPathCriterion = {
+    properties: {
+        type: { type: 'string', enum: ['jsonpath'] },
+        version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+    },
+};
+const XPathCriterion = {
+    properties: {
+        type: { type: 'string', enum: ['xpath'] },
+        version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+    },
+};
+const SuccessActionObject = {
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['goto', 'end'] },
+        stepId: { type: 'string' },
+        workflowId: { type: 'string' },
+        criteria: (0, _1.listOf)('CriterionObject'),
+    },
+    required: ['type', 'name'],
+};
+const OnSuccessActionList = {
+    properties: {},
+    items: (value) => {
+        if (value?.type && value?.name) {
+            return 'SuccessActionObject';
+        }
+        else {
+            return 'ReusableObject';
+        }
+    },
+};
+const FailureActionObject = {
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['goto', 'retry', 'end'] },
+        workflowId: { type: 'string' },
+        stepId: { type: 'string' },
+        retryAfter: { type: 'number' },
+        retryLimit: { type: 'number' },
+        criteria: (0, _1.listOf)('CriterionObject'),
+    },
+    required: ['type', 'name'],
+};
+const OnFailureActionList = {
+    properties: {},
+    items: (value) => {
+        if (value?.type && value?.name) {
+            return 'FailureActionObject';
+        }
+        else {
+            return 'ReusableObject';
+        }
+    },
+};
+exports.Arazzo1Types = {
+    Root,
+    Info,
+    SourceDescriptions,
+    OpenAPISourceDescription,
+    ArazzoSourceDescription,
+    Parameters,
+    Parameter,
+    ReusableObject,
+    Workflows,
+    Workflow,
+    Steps,
+    Step,
+    RequestBody,
+    Replacement,
+    ExtendedOperation,
+    Outputs,
+    CriterionObject,
+    XPathCriterion,
+    JSONPathCriterion,
+    SuccessActionObject,
+    OnSuccessActionList,
+    FailureActionObject,
+    OnFailureActionList,
+    Schema: oas3_1_1.Schema,
+    NamedSchemas: (0, _1.mapOf)('Schema'),
+    ExternalDocs: oas3_1.ExternalDocs,
+    DiscriminatorMapping: oas3_1.DiscriminatorMapping,
+    Discriminator: oas3_1.Discriminator,
+    DependentRequired: oas3_1_1.DependentRequired,
+    SchemaProperties: oas3_1_1.SchemaProperties,
+    PatternProperties: oas3_1_1.SchemaProperties,
+    Components,
+    NamedInputs,
+    NamedParameters,
+    NamedSuccessActions,
+    NamedFailureActions,
+    Xml: oas3_1.Xml,
+};

package/lib/types/asyncapi2.d.ts

@@ -0,0 +1,17 @@
+import type { NodeType } from '.';
+export declare const Tag: NodeType;
+export declare const ExternalDocs: NodeType;
+export declare const ServerMap: NodeType;
+export declare const ServerVariable: NodeType;
+export declare const Contact: NodeType;
+export declare const License: NodeType;
+export declare const CorrelationId: NodeType;
+export declare const MessageExample: NodeType;
+export declare const Schema: NodeType;
+export declare const SchemaProperties: NodeType;
+export declare const DiscriminatorMapping: NodeType;
+export declare const Discriminator: NodeType;
+export declare const SecuritySchemeFlows: NodeType;
+export declare const Dependencies: NodeType;
+export declare const AsyncApi2Bindings: Record<string, NodeType>;
+export declare const AsyncApi2Types: Record<string, NodeType>;