@redocly/openapi-core 1.18.1 → 1.20.0

package/lib/types/redocly-yaml.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigTypes = exports.createConfigTypes = void 0;
+exports.ConfigTypes = void 0;
+exports.createConfigTypes = createConfigTypes;
 const config_1 = require("@redocly/config");
 const _1 = require(".");
 const utils_1 = require("../utils");
@@ -13,6 +14,7 @@ const builtInCommonOASRules = [
     'tag-description',
     'tags-alphabetical',
     'info-license-url',
+    'info-license-strict',
     'info-license',
     'no-ambiguous-paths',
     'no-enum-type-mismatch',
@@ -74,18 +76,30 @@ const builtInOAS3Rules = [
 const builtInAsync2Rules = [
     'spec',
     'info-contact',
+    'info-license-strict',
     'operation-operationId',
     'tag-description',
     'tags-alphabetical',
     'channels-kebab-case',
     'no-channel-trailing-slash',
 ];
-const builtInArazzoRules = ['spec'];
+const builtInAsync3Rules = [
+    'spec',
+    'info-contact',
+    'info-license-strict',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'channels-kebab-case',
+    'no-channel-trailing-slash',
+];
+const builtInArazzoRules = ['spec', 'parameters-no-body-inside-in'];
 const builtInRules = [
     ...builtInCommonOASRules,
     ...builtInOAS2Rules,
     ...builtInOAS3Rules,
     ...builtInAsync2Rules,
+    ...builtInAsync3Rules,
     ...builtInArazzoRules,
 ];
 const oas2NodeTypesList = [
@@ -195,6 +209,7 @@ const oas3_1NodeTypesList = [
     'Root',
     'Schema',
     'SchemaProperties',
+    'PatternProperties',
     'Info',
     'License',
     'Components',
@@ -231,35 +246,56 @@ const ConfigStyleguide = {
         arazzoDecorators: { type: 'object' },
     },
 };
-const createConfigRoot = (nodeTypes) => (Object.assign(Object.assign({}, nodeTypes.rootRedoclyConfigSchema), { properties: Object.assign(Object.assign(Object.assign({}, nodeTypes.rootRedoclyConfigSchema.properties), ConfigStyleguide.properties), { apis: 'ConfigApis', 'features.openapi': 'ConfigReferenceDocs', 'features.mockServer': 'ConfigMockServer', organization: { type: 'string' }, region: { enum: ['us', 'eu'] }, telemetry: { enum: ['on', 'off'] }, resolve: {
+const createConfigRoot = (nodeTypes) => ({
+    ...nodeTypes.rootRedoclyConfigSchema,
+    properties: {
+        ...nodeTypes.rootRedoclyConfigSchema.properties,
+        ...ConfigStyleguide.properties,
+        apis: 'ConfigApis', // Override apis with internal format
+        'features.openapi': 'ConfigReferenceDocs', // deprecated
+        'features.mockServer': 'ConfigMockServer', // deprecated
+        organization: { type: 'string' },
+        region: { enum: ['us', 'eu'] },
+        telemetry: { enum: ['on', 'off'] },
+        resolve: {
             properties: {
                 http: 'ConfigHTTP',
                 doNotResolveExamples: { type: 'boolean' },
             },
-        }, files: {
+        },
+        files: {
             type: 'array',
             items: {
                 type: 'string',
             },
-        } }) }));
+        },
+    },
+});
 const ConfigApis = {
     properties: {},
     additionalProperties: 'ConfigApisProperties',
 };
-const createConfigApisProperties = (nodeTypes) => {
-    var _a;
-    return (Object.assign(Object.assign({}, nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties']), { properties: Object.assign(Object.assign(Object.assign(Object.assign({}, (_a = nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties']) === null || _a === void 0 ? void 0 : _a.properties), { labels: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-            } }), ConfigStyleguide.properties), { 'features.openapi': 'ConfigReferenceDocs', 'features.mockServer': 'ConfigMockServer', files: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-            } }) }));
-};
+const createConfigApisProperties = (nodeTypes) => ({
+    ...nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties'],
+    properties: {
+        ...nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties']?.properties,
+        labels: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+        ...ConfigStyleguide.properties,
+        'features.openapi': 'ConfigReferenceDocs', // deprecated
+        'features.mockServer': 'ConfigMockServer', // deprecated
+        files: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+    },
+});
 const ConfigHTTP = {
     properties: {
         headers: {
@@ -539,7 +575,14 @@ const FontConfig = {
     },
 };
 const ButtonsConfig = {
-    properties: Object.assign(Object.assign({}, (0, utils_1.omitObjectProps)(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, hoverStyle: { type: 'string' }, boxShadow: { type: 'string' }, hoverBoxShadow: { type: 'string' }, sizes: 'Sizes' }),
+    properties: {
+        ...(0, utils_1.omitObjectProps)(FontConfig.properties, ['fontSize', 'lineHeight']),
+        borderRadius: { type: 'string' },
+        hoverStyle: { type: 'string' },
+        boxShadow: { type: 'string' },
+        hoverBoxShadow: { type: 'string' },
+        sizes: 'Sizes',
+    },
 };
 const BadgeFontConfig = {
     properties: (0, utils_1.pickObjectProps)(FontConfig.properties, ['fontSize', 'lineHeight']),
@@ -551,7 +594,12 @@ const BadgeSizes = {
     },
 };
 const HttpBadgesConfig = {
-    properties: Object.assign(Object.assign({}, (0, utils_1.omitObjectProps)(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, color: { type: 'string' }, sizes: 'BadgeSizes' }),
+    properties: {
+        ...(0, utils_1.omitObjectProps)(FontConfig.properties, ['fontSize', 'lineHeight']),
+        borderRadius: { type: 'string' },
+        color: { type: 'string' },
+        sizes: 'BadgeSizes',
+    },
 };
 const LabelControls = {
     properties: {
@@ -650,13 +698,38 @@ const SpacingConfig = {
     },
 };
 const Sidebar = {
-    properties: Object.assign(Object.assign({}, (0, utils_1.omitObjectProps)(FontConfig.properties, ['fontWeight', 'lineHeight'])), { activeBgColor: { type: 'string' }, activeTextColor: { type: 'string' }, backgroundColor: { type: 'string' }, borderRadius: { type: 'string' }, breakPath: { type: 'boolean' }, caretColor: { type: 'string' }, caretSize: { type: 'string' }, groupItems: 'GroupItemsConfig', level1items: 'Level1Items', rightLineColor: { type: 'string' }, separatorLabelColor: { type: 'string' }, showAtBreakpoint: { type: 'string' }, spacing: 'SpacingConfig', textColor: { type: 'string' }, width: { type: 'string' } }),
+    properties: {
+        ...(0, utils_1.omitObjectProps)(FontConfig.properties, ['fontWeight', 'lineHeight']),
+        activeBgColor: { type: 'string' },
+        activeTextColor: { type: 'string' },
+        backgroundColor: { type: 'string' },
+        borderRadius: { type: 'string' },
+        breakPath: { type: 'boolean' },
+        caretColor: { type: 'string' },
+        caretSize: { type: 'string' },
+        groupItems: 'GroupItemsConfig',
+        level1items: 'Level1Items',
+        rightLineColor: { type: 'string' },
+        separatorLabelColor: { type: 'string' },
+        showAtBreakpoint: { type: 'string' },
+        spacing: 'SpacingConfig',
+        textColor: { type: 'string' },
+        width: { type: 'string' },
+    },
 };
 const Heading = {
-    properties: Object.assign(Object.assign({}, FontConfig.properties), { color: { type: 'string' }, transform: { type: 'string' } }),
+    properties: {
+        ...FontConfig.properties,
+        color: { type: 'string' },
+        transform: { type: 'string' },
+    },
 };
 const CodeConfig = {
-    properties: Object.assign(Object.assign({}, FontConfig.properties), { backgroundColor: { type: 'string' }, color: { type: 'string' }, wordBreak: {
+    properties: {
+        ...FontConfig.properties,
+        backgroundColor: { type: 'string' },
+        color: { type: 'string' },
+        wordBreak: {
             enum: [
                 'break-all',
                 'break-word',
@@ -667,7 +740,9 @@ const CodeConfig = {
                 'inherit',
                 'initial',
             ],
-        }, wrap: { type: 'boolean' } }),
+        },
+        wrap: { type: 'boolean' },
+    },
 };
 const HeadingsConfig = {
     properties: (0, utils_1.omitObjectProps)(FontConfig.properties, ['fontSize']),
@@ -682,10 +757,29 @@ const LinksConfig = {
     },
 };
 const Typography = {
-    properties: Object.assign(Object.assign({ code: 'CodeConfig', fieldName: 'FontConfig' }, (0, utils_1.pickObjectProps)(FontConfig.properties, ['fontSize', 'fontFamily'])), { fontWeightBold: { type: 'string' }, fontWeightLight: { type: 'string' }, fontWeightRegular: { type: 'string' }, heading1: 'Heading', heading2: 'Heading', heading3: 'Heading', headings: 'HeadingsConfig', lineHeight: { type: 'string' }, links: 'LinksConfig', optimizeSpeed: { type: 'boolean' }, rightPanelHeading: 'Heading', smoothing: { enum: ['auto', 'none', 'antialiased', 'subpixel-antialiased', 'grayscale'] } }),
+    properties: {
+        code: 'CodeConfig',
+        fieldName: 'FontConfig',
+        ...(0, utils_1.pickObjectProps)(FontConfig.properties, ['fontSize', 'fontFamily']),
+        fontWeightBold: { type: 'string' },
+        fontWeightLight: { type: 'string' },
+        fontWeightRegular: { type: 'string' },
+        heading1: 'Heading',
+        heading2: 'Heading',
+        heading3: 'Heading',
+        headings: 'HeadingsConfig',
+        lineHeight: { type: 'string' },
+        links: 'LinksConfig',
+        optimizeSpeed: { type: 'boolean' },
+        rightPanelHeading: 'Heading',
+        smoothing: { enum: ['auto', 'none', 'antialiased', 'subpixel-antialiased', 'grayscale'] },
+    },
 };
 const TokenProps = {
-    properties: Object.assign({ color: { type: 'string' } }, (0, utils_1.omitObjectProps)(FontConfig.properties, ['fontWeight'])),
+    properties: {
+        color: { type: 'string' },
+        ...(0, utils_1.omitObjectProps)(FontConfig.properties, ['fontWeight']),
+    },
 };
 const CodeBlock = {
     properties: {
@@ -754,7 +848,7 @@ const ConfigTheme = {
         sidebar: 'Sidebar',
         spacing: 'ThemeSpacing',
         typography: 'Typography',
-        links: { properties: { color: { type: 'string' } } },
+        links: { properties: { color: { type: 'string' } } }, // deprecated
         codeSample: { properties: { backgroundColor: { type: 'string' } } }, // deprecated
     },
 };
@@ -812,7 +906,7 @@ const ConfigReferenceDocs = {
         maxDisplayedEnumValues: { type: 'number' },
         menuToggle: { type: 'boolean' },
         nativeScrollbars: { type: 'boolean' },
-        noAutoAuth: { type: 'boolean' },
+        noAutoAuth: { type: 'boolean' }, // deprecated
         oAuth2RedirectURI: { type: 'string' },
         onDeepLinkClick: { type: 'object' },
         onlyRequiredInSamples: { type: 'boolean' },
@@ -822,7 +916,7 @@ const ConfigReferenceDocs = {
         requestInterceptor: { type: 'object' },
         requiredPropsFirst: { type: 'boolean' },
         routingBasePath: { type: 'string' },
-        routingStrategy: { type: 'string' },
+        routingStrategy: { type: 'string' }, // deprecated
         samplesTabsMaxCount: { type: 'number' },
         schemaExpansionLevel: (value) => {
             if (typeof value === 'number') {
@@ -851,7 +945,7 @@ const ConfigReferenceDocs = {
         searchTagTitleBoost: { type: 'number' },
         sendXUserAgentInTryIt: { type: 'boolean' },
         showChangeLayoutButton: { type: 'boolean' },
-        showConsole: { type: 'boolean' },
+        showConsole: { type: 'boolean' }, // deprecated
         showExtensions: (value) => {
             if (typeof value === 'boolean') {
                 return { type: 'boolean' };
@@ -878,8 +972,8 @@ const ConfigReferenceDocs = {
         sortOperationsAlphabetically: { type: 'boolean' },
         sortPropsAlphabetically: { type: 'boolean' },
         sortTagsAlphabetically: { type: 'boolean' },
-        suppressWarnings: { type: 'boolean' },
-        unstable_externalDescription: { type: 'boolean' },
+        suppressWarnings: { type: 'boolean' }, // deprecated
+        unstable_externalDescription: { type: 'boolean' }, // deprecated
         unstable_ignoreMimeParameters: { type: 'boolean' },
         untrustedDefinition: { type: 'boolean' },
         mockServer: {
@@ -903,16 +997,21 @@ const ConfigMockServer = {
 };
 function createConfigTypes(extraSchemas, config) {
     const nodeNames = Object.values(oas_types_1.SpecVersion).flatMap((version) => {
-        const types = (config === null || config === void 0 ? void 0 : config.styleguide)
+        const types = config?.styleguide
             ? config.styleguide.extendTypes((0, oas_types_1.getTypes)(version), version)
             : (0, oas_types_1.getTypes)(version);
         return Object.keys(types);
     });
     // Create types based on external schemas
     const nodeTypes = (0, json_schema_adapter_1.getNodeTypesFromJSONSchema)('rootRedoclyConfigSchema', extraSchemas);
-    return Object.assign(Object.assign(Object.assign({}, CoreConfigTypes), { ConfigRoot: createConfigRoot(nodeTypes), ConfigApisProperties: createConfigApisProperties(nodeTypes), AssertionDefinitionSubject: createAssertionDefinitionSubject(nodeNames) }), nodeTypes);
+    return {
+        ...CoreConfigTypes,
+        ConfigRoot: createConfigRoot(nodeTypes), // This is the REAL config root type
+        ConfigApisProperties: createConfigApisProperties(nodeTypes),
+        AssertionDefinitionSubject: createAssertionDefinitionSubject(nodeNames),
+        ...nodeTypes,
+    };
 }
-exports.createConfigTypes = createConfigTypes;
 const CoreConfigTypes = {
     Assert,
     ConfigApis,

package/lib/typings/arazzo.d.ts

@@ -1,30 +1,148 @@
-import type { FromSchema } from 'json-schema-to-ts';
-import type { arazzoSchema, parameter, operationMethod, expectSchema, sourceDescriptionSchema, infoObject, requestBody, replacement, inherit, criteriaObject, step, workflow } from '../types/arazzo';
-export type ArazzoDefinition = FromSchema<typeof arazzoSchema>;
-export type OperationMethod = FromSchema<typeof operationMethod>;
-export type ResponseContext = {
-    statusCode: number;
-    body: any;
-    headers: Headers;
-    mimeType: string;
-} & Record<string, any>;
-export type Expect = FromSchema<typeof expectSchema>;
-export type SourceDescription = FromSchema<typeof sourceDescriptionSchema>;
-export type Parameter = FromSchema<typeof parameter>;
-export type InfoObject = FromSchema<typeof infoObject>;
-export type RequestBody = FromSchema<typeof requestBody>;
-export type Replacement = FromSchema<typeof replacement>;
-export type Inherit = FromSchema<typeof inherit>;
-export type CriteriaObject = FromSchema<typeof criteriaObject>;
-export type VerboseLog = {
-    method: OperationMethod;
+export interface InfoObject {
+    title: string;
+    description?: string;
+    summary?: string;
+    version: string;
+}
+export interface OpenAPISourceDescription {
+    name: string;
+    type: 'openapi';
+    url: string;
+    'x-serverUrl'?: string;
+}
+export interface NoneSourceDescription {
+    name: string;
+    type: 'none';
+    'x-serverUrl': string;
+}
+export interface ArazzoSourceDescription {
+    name: string;
+    type: 'arazzo';
+    url: string;
+}
+export type SourceDescription = OpenAPISourceDescription | NoneSourceDescription | ArazzoSourceDescription;
+export interface Parameter {
+    in?: 'header' | 'query' | 'path' | 'cookie' | 'body';
+    name: string;
+    value: string | number | boolean;
+    reference?: string;
+}
+export interface ExtendedOperation {
     path: string;
-    host: string;
-    body?: any;
-    headerParams?: Record<string, string>;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+    sourceDescriptionName?: string;
+    serverUrl?: string;
+}
+export interface ExpectSchema {
     statusCode?: number;
-};
-export type Step = FromSchema<typeof step>;
-export type Workflow = FromSchema<typeof workflow> & {
+    mimeType?: string;
+    body?: any;
+    schema?: {
+        [key: string]: any;
+    };
+}
+export interface Replacement {
+    target: string;
+    value: string | object | any[];
+}
+export interface RequestBody {
+    contentType?: string;
+    payload: string | object | any[];
+    encoding?: string;
+    replacements?: Replacement[];
+}
+export interface CriteriaObject {
+    condition: string;
+    context?: string;
+    type?: 'regex' | 'jsonpath' | 'simple' | 'xpath' | {
+        type: 'jsonpath';
+        version: 'draft-goessner-dispatch-jsonpath-00';
+    } | {
+        type: 'xpath';
+        version: 'xpath-30' | 'xpath-20' | 'xpath-10';
+    };
+}
+export interface OnSuccessObject {
+    name: string;
+    type: 'goto' | 'end';
+    stepId?: string;
+    workflowId?: string;
+    criteria?: CriteriaObject[];
+}
+export interface OnFailureObject {
+    name: string;
+    type: 'goto' | 'retry' | 'end';
+    workflowId?: string;
+    stepId?: string;
+    retryAfter?: number;
+    retryLimit?: number;
+    criteria?: CriteriaObject[];
+}
+export interface Step {
+    stepId: string;
+    description?: string;
+    operationId?: string;
+    operationPath?: string;
+    workflowId?: string;
+    parameters?: Parameter[];
+    successCriteria?: CriteriaObject[];
+    onSuccess?: OnSuccessObject[];
+    onFailure?: OnFailureObject[];
+    outputs?: {
+        [key: string]: string | object | any[] | boolean | number;
+    };
+    'x-inherit'?: 'auto' | 'none';
+    'x-expect'?: ExpectSchema;
+    'x-assert'?: string;
+    'x-operation'?: ExtendedOperation;
+    requestBody?: RequestBody;
+}
+export interface Workflow {
+    workflowId: string;
+    summary?: string;
+    description?: string;
+    parameters?: Parameter[];
+    dependsOn?: string[];
+    inputs?: {
+        type: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null';
+        properties?: {
+            [key: string]: any;
+        };
+        required?: string[];
+        items?: {
+            [key: string]: any;
+        };
+    };
+    outputs?: {
+        [key: string]: string;
+    };
     steps: Step[];
-};
+    successActions?: OnSuccessObject[];
+    failureActions?: OnFailureObject[];
+}
+export interface ArazzoDefinition {
+    arazzo: '1.0.0';
+    info: InfoObject;
+    sourceDescriptions: SourceDescription[];
+    'x-parameters'?: Parameter[];
+    workflows: Workflow[];
+    components?: {
+        inputs?: {
+            [key: string]: {
+                type: string;
+                properties?: {
+                    [key: string]: any;
+                };
+            };
+        };
+        parameters?: {
+            [key: string]: Parameter;
+        };
+        successActions?: {
+            [key: string]: OnSuccessObject;
+        };
+        failureActions?: {
+            [key: string]: OnFailureObject;
+        };
+    };
+}

package/lib/typings/asyncapi3.d.ts

@@ -0,0 +1,53 @@
+export interface Async3Definition {
+    asyncapi: string;
+    servers?: Record<string, any>;
+    info: Async3Info;
+    channels?: Record<string, Channel>;
+    components?: Record<string, any>;
+    operations?: Record<string, any>;
+    defaultContentType?: string;
+}
+export interface Async3Info {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: Async3Contact;
+    license?: Async3License;
+    tags?: Tag[];
+    externalDocs?: ExternalDoc;
+}
+export interface Async3Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface Async3License {
+    name: string;
+    url?: string;
+}
+export interface Tag {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDoc;
+}
+export interface ExternalDoc {
+    url: string;
+    description?: string;
+}
+export interface Channel {
+    address?: string | null;
+    messages?: Record<string, any>;
+    title?: string;
+    summary?: string;
+    description?: string;
+    servers?: Record<string, any>[];
+    parameters?: Record<string, any>;
+    tags?: Record<string, any>;
+    externalDocs?: ExternalDocumentation;
+    bindings?: Record<string, any>;
+}
+export interface ExternalDocumentation {
+    url: string;
+    description?: string;
+}

package/lib/typings/asyncapi3.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typings/common.d.ts

@@ -4,5 +4,5 @@ export interface StatsRow {
     color: 'red' | 'yellow' | 'green' | 'white' | 'magenta' | 'cyan';
     items?: Set<string>;
 }
-export type StatsName = 'operations' | 'refs' | 'tags' | 'externalDocs' | 'pathItems' | 'links' | 'schemas' | 'parameters';
+export type StatsName = 'operations' | 'refs' | 'tags' | 'externalDocs' | 'pathItems' | 'links' | 'schemas' | 'webhooks' | 'parameters';
 export type StatsAccumulator = Record<StatsName, StatsRow>;

package/lib/typings/swagger.d.ts

@@ -1,5 +1,5 @@
-import { Referenced } from './openapi';
-import { Schema } from 'js-yaml';
+import type { Schema } from 'js-yaml';
+import type { Referenced } from './openapi';
 export interface Oas2Definition {
     swagger: '2.0';
     info?: Oas2Info;

package/lib/utils.d.ts

@@ -16,9 +16,9 @@ export declare function popStack<T, P extends Stack<T>>(head: P): StackFrame<T>
 export type BundleOutputFormat = 'json' | 'yml' | 'yaml';
 export declare function loadYaml<T>(filename: string): Promise<T>;
 export declare function isDefined<T>(x: T | undefined): x is T;
-export declare function isPlainObject(value: any): value is Record<string, unknown>;
-export declare function isEmptyObject(value: any): value is Record<string, unknown>;
-export declare function isEmptyArray(value: any): boolean;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isEmptyObject(value: unknown): value is Record<string, unknown>;
+export declare function isEmptyArray(value: unknown): boolean;
 export declare function readFileFromUrl(url: string, config: HttpResolveConfig): Promise<{
     body: any;
     mimeType: any;
@@ -57,3 +57,4 @@ export declare function getProxyAgent(): HttpsProxyAgent<string> | undefined;
  * Borrowed the source code from https://github.com/lukeed/dequal.
  */
 export declare function dequal(foo: any, bar: any): boolean;
+export type CollectFn = (value: unknown) => void;