@redocly/openapi-core 1.18.1 → 1.20.0

package/src/types/redocly-yaml.ts

@@ -2,11 +2,11 @@ import { rootRedoclyConfigSchema } from '@redocly/config';
 import { listOf } from '.';
 import { omitObjectProps, pickObjectProps, isCustomRuleId } from '../utils';
 import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
+import { SpecVersion, getTypes } from '../oas-types';
 
-import type { NodeType } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
-import { SpecVersion, getTypes } from '../oas-types';
-import { Config } from '../config';
+import type { NodeType } from '.';
+import type { Config } from '../config';
 
 const builtInCommonOASRules = [
   'spec',
@@ -15,6 +15,7 @@ const builtInCommonOASRules = [
   'tag-description',
   'tags-alphabetical',
   'info-license-url',
+  'info-license-strict',
   'info-license',
   'no-ambiguous-paths',
   'no-enum-type-mismatch',
@@ -85,6 +86,18 @@ export type BuiltInOAS3RuleId = typeof builtInOAS3Rules[number];
 const builtInAsync2Rules = [
   'spec',
   'info-contact',
+  'info-license-strict',
+  'operation-operationId',
+  'tag-description',
+  'tags-alphabetical',
+  'channels-kebab-case',
+  'no-channel-trailing-slash',
+] as const;
+
+const builtInAsync3Rules = [
+  'spec',
+  'info-contact',
+  'info-license-strict',
   'operation-operationId',
   'tag-description',
   'tags-alphabetical',
@@ -94,7 +107,9 @@ const builtInAsync2Rules = [
 
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
-const builtInArazzoRules = ['spec'] as const;
+export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
+
+const builtInArazzoRules = ['spec', 'parameters-no-body-inside-in'] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
 
@@ -103,6 +118,7 @@ const builtInRules = [
   ...builtInOAS2Rules,
   ...builtInOAS3Rules,
   ...builtInAsync2Rules,
+  ...builtInAsync3Rules,
   ...builtInArazzoRules,
 ] as const;
 
@@ -221,6 +237,7 @@ const oas3_1NodeTypesList = [
   'Root',
   'Schema',
   'SchemaProperties',
+  'PatternProperties',
   'Info',
   'License',
   'Components',

package/src/typings/arazzo.ts

@@ -1,44 +1,172 @@
-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/src/typings/asyncapi3.ts

@@ -0,0 +1,61 @@
+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/src/typings/common.ts

@@ -13,5 +13,6 @@ export type StatsName =
   | 'pathItems'
   | 'links'
   | 'schemas'
+  | 'webhooks'
   | 'parameters';
 export type StatsAccumulator = Record<StatsName, StatsRow>;

package/src/typings/swagger.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';

package/src/utils.ts

@@ -38,15 +38,15 @@ export function isDefined<T>(x: T | undefined): x is T {
   return x !== undefined;
 }
 
-export function isPlainObject(value: any): value is Record<string, unknown> {
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-export function isEmptyObject(value: any): value is Record<string, unknown> {
+export function isEmptyObject(value: unknown): value is Record<string, unknown> {
   return isPlainObject(value) && Object.keys(value).length === 0;
 }
 
-export function isEmptyArray(value: any) {
+export function isEmptyArray(value: unknown) {
   return Array.isArray(value) && value.length === 0;
 }
 
@@ -317,3 +317,5 @@ export function dequal(foo: any, bar: any): boolean {
 
   return foo !== foo && bar !== bar;
 }
+
+export type CollectFn = (value: unknown) => void;

package/src/visitors.ts

@@ -50,7 +50,25 @@ import type {
   Oas2SecurityScheme,
 } from './typings/swagger';
 import type { Async2Definition } from './typings/asyncapi';
-import type { ArazzoDefinition } from './typings/arazzo';
+import type { Async3Definition } from './typings/asyncapi3';
+import type {
+  ArazzoDefinition,
+  ArazzoSourceDescription,
+  CriteriaObject,
+  ExpectSchema,
+  ExtendedOperation,
+  InfoObject,
+  NoneSourceDescription,
+  OnFailureObject,
+  OnSuccessObject,
+  OpenAPISourceDescription,
+  Parameter,
+  Replacement,
+  RequestBody,
+  SourceDescription,
+  Step,
+  Workflow,
+} from './typings/arazzo';
 
 export type SkipFunctionContext = Pick<
   UserContext,
@@ -213,8 +231,29 @@ type Async2FlatVisitor = {
   Root?: VisitFunctionOrObject<Async2Definition>;
 };
 
+type Async3FlatVisitor = {
+  Root?: VisitFunctionOrObject<Async3Definition>;
+};
+
 type ArazzoFlatVisitor = {
   Root?: VisitFunctionOrObject<ArazzoDefinition>;
+  ParameterObject?: VisitFunctionOrObject<Parameter>;
+  InfoObject?: VisitFunctionOrObject<InfoObject>;
+  OpenAPISourceDescription?: VisitFunctionOrObject<OpenAPISourceDescription>;
+  NoneSourceDescription?: VisitFunctionOrObject<NoneSourceDescription>;
+  ArazzoSourceDescription?: VisitFunctionOrObject<ArazzoSourceDescription>;
+  SourceDescription?: VisitFunctionOrObject<SourceDescription>;
+  ExtendedOperation?: VisitFunctionOrObject<ExtendedOperation>;
+  ExpectSchema?: VisitFunctionOrObject<ExpectSchema>;
+  Replacement?: VisitFunctionOrObject<Replacement>;
+  RequestBody?: VisitFunctionOrObject<RequestBody>;
+  CriteriaObject?: VisitFunctionOrObject<CriteriaObject>;
+  OnSuccessObject?: VisitFunctionOrObject<OnSuccessObject>;
+  OnFailureObject?: VisitFunctionOrObject<OnFailureObject>;
+  Step?: VisitFunctionOrObject<Step>;
+  Steps?: VisitFunctionOrObject<Step[]>;
+  Workflow?: VisitFunctionOrObject<Workflow>;
+  Workflows?: VisitFunctionOrObject<Workflow[]>;
 };
 
 const legacyTypesMap = {
@@ -232,24 +271,35 @@ const legacyTypesMap = {
 };
 
 type Oas3NestedVisitor = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
   [T in keyof Oas3FlatVisitor]: Oas3FlatVisitor[T] extends Function
     ? Oas3FlatVisitor[T]
     : Oas3FlatVisitor[T] & NestedVisitor<Oas3NestedVisitor>;
 };
 
 type Oas2NestedVisitor = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
   [T in keyof Oas2FlatVisitor]: Oas2FlatVisitor[T] extends Function
     ? Oas2FlatVisitor[T]
     : Oas2FlatVisitor[T] & NestedVisitor<Oas2NestedVisitor>;
 };
 
 type Async2NestedVisitor = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
   [T in keyof Async2FlatVisitor]: Async2FlatVisitor[T] extends Function
     ? Async2FlatVisitor[T]
     : Async2FlatVisitor[T] & NestedVisitor<Async2NestedVisitor>;
 };
 
+type Async3NestedVisitor = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  [T in keyof Async3FlatVisitor]: Async3FlatVisitor[T] extends Function
+    ? Async3FlatVisitor[T]
+    : Async3FlatVisitor[T] & NestedVisitor<Async3NestedVisitor>;
+};
+
 type ArazzoNestedVisitor = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
   [T in keyof ArazzoFlatVisitor]: ArazzoFlatVisitor[T] extends Function
     ? ArazzoFlatVisitor[T]
     : ArazzoFlatVisitor[T] & NestedVisitor<ArazzoNestedVisitor>;
@@ -267,6 +317,10 @@ export type Async2Visitor = BaseVisitor &
   Async2NestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, Async2NestedVisitor>>;
 
+export type Async3Visitor = BaseVisitor &
+  Async3NestedVisitor &
+  Record<string, VisitFunction<any> | NestedVisitObject<any, Async3NestedVisitor>>;
+
 export type ArazzoVisitor = BaseVisitor &
   ArazzoNestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, ArazzoNestedVisitor>>;
@@ -293,14 +347,17 @@ export type NormalizedOasVisitors<T extends BaseVisitor> = {
 export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
 export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export type Async2Rule = (options: Record<string, any>) => Async2Visitor | Async2Visitor[];
+export type Async3Rule = (options: Record<string, any>) => Async3Visitor | Async3Visitor[];
 export type ArazzoRule = (options: Record<string, any>) => ArazzoVisitor | ArazzoVisitor[];
 export type Oas3Preprocessor = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Preprocessor = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Preprocessor = (options: Record<string, any>) => Async2Visitor;
+export type Async3Preprocessor = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoPreprocessor = (options: Record<string, any>) => ArazzoVisitor;
 export type Oas3Decorator = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Decorator = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Decorator = (options: Record<string, any>) => Async2Visitor;
+export type Async3Decorator = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoDecorator = (options: Record<string, any>) => ArazzoVisitor;
 
 // alias for the latest version supported

package/src/walk.ts

@@ -1,9 +1,10 @@
 import { Location, isRef } from './ref-utils';
 import { pushStack, popStack } from './utils';
-import { ResolveError, YamlParseError, Source, makeRefId } from './resolve';
-import { SpecVersion } from './oas-types';
+import { YamlParseError, makeRefId } from './resolve';
 import { isNamedType, SpecExtension } from './types';
 
+import type { SpecVersion } from './oas-types';
+import type { ResolveError, Source, ResolvedRefMap, Document } from './resolve';
 import type { Referenced } from './typings/openapi';
 import type {
   VisitorLevelContext,
@@ -14,7 +15,6 @@ import type {
   NormalizeVisitor,
   VisitorNode,
 } from './visitors';
-import type { ResolvedRefMap, Document } from './resolve';
 import type { NormalizedNodeType } from './types';
 import type { RuleSeverity } from './config';