@redocly/openapi-core 1.19.0 → 1.20.1

package/src/types/oas3.ts

@@ -44,7 +44,7 @@ const TagGroup: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const ExternalDocs: NodeType = {
+export const ExternalDocs: NodeType = {
   properties: {
     description: { type: 'string' },
     url: { type: 'string' },
@@ -369,7 +369,7 @@ const Schema: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const Xml: NodeType = {
+export const Xml: NodeType = {
   properties: {
     name: { type: 'string' },
     namespace: { type: 'string' },
@@ -385,7 +385,7 @@ const SchemaProperties: NodeType = {
   additionalProperties: 'Schema',
 };
 
-const DiscriminatorMapping: NodeType = {
+export const DiscriminatorMapping: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (isMappingRef(value)) {
@@ -396,7 +396,7 @@ const DiscriminatorMapping: NodeType = {
   },
 };
 
-const Discriminator: NodeType = {
+export const Discriminator: NodeType = {
   properties: {
     propertyName: { type: 'string' },
     mapping: 'DiscriminatorMapping',

package/src/types/oas3_1.ts

@@ -87,7 +87,7 @@ const Operation: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const Schema: NodeType = {
+export const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
     $anchor: { type: 'string' },
@@ -186,7 +186,7 @@ const Schema: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const SchemaProperties: NodeType = {
+export const SchemaProperties: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
     if (typeof value === 'boolean') {
@@ -267,7 +267,7 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
-const DependentRequired: NodeType = {
+export const DependentRequired: NodeType = {
   properties: {},
   additionalProperties: { type: 'array', items: { type: 'string' } },
 };

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,7 @@ export type BuiltInOAS3RuleId = typeof builtInOAS3Rules[number];
 const builtInAsync2Rules = [
   'spec',
   'info-contact',
+  'info-license-strict',
   'operation-operationId',
   'tag-description',
   'tags-alphabetical',
@@ -95,6 +97,7 @@ const builtInAsync2Rules = [
 const builtInAsync3Rules = [
   'spec',
   'info-contact',
+  'info-license-strict',
   'operation-operationId',
   'tag-description',
   'tags-alphabetical',
@@ -106,7 +109,7 @@ export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
 export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
 
-const builtInArazzoRules = ['spec'] as const;
+const builtInArazzoRules = ['spec', 'parameters-no-body-inside-in'] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
 

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/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/visitors.ts

@@ -51,7 +51,24 @@ import type {
 } from './typings/swagger';
 import type { Async2Definition } from './typings/asyncapi';
 import type { Async3Definition } from './typings/asyncapi3';
-import type { ArazzoDefinition } from './typings/arazzo';
+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,
@@ -220,6 +237,23 @@ type Async3FlatVisitor = {
 
 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 = {
@@ -237,30 +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>;

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';