@redocly/openapi-core 1.17.0 → 1.18.0

package/src/config/utils.ts

@@ -56,18 +56,21 @@ function extractFlatConfig<
   oas3_0Rules,
   oas3_1Rules,
   async2Rules,
+  arazzoRules,
 
   preprocessors,
   oas2Preprocessors,
   oas3_0Preprocessors,
   oas3_1Preprocessors,
   async2Preprocessors,
+  arazzoPreprocessors,
 
   decorators,
   oas2Decorators,
   oas3_0Decorators,
   oas3_1Decorators,
   async2Decorators,
+  arazzoDecorators,
 
   ...rawConfigRest
 }: T): {
@@ -83,18 +86,21 @@ function extractFlatConfig<
     oas3_0Rules,
     oas3_1Rules,
     async2Rules,
+    arazzoRules,
 
     preprocessors,
     oas2Preprocessors,
     oas3_0Preprocessors,
     oas3_1Preprocessors,
     async2Preprocessors,
+    arazzoPreprocessors,
 
     decorators,
     oas2Decorators,
     oas3_0Decorators,
     oas3_1Decorators,
     async2Decorators,
+    arazzoDecorators,
 
     doNotResolveExamples: rawConfigRest.resolve?.doNotResolveExamples,
   };
@@ -152,18 +158,21 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
     oas3_0Rules: {},
     oas3_1Rules: {},
     async2Rules: {},
+    arazzoRules: {},
 
     preprocessors: {},
     oas2Preprocessors: {},
     oas3_0Preprocessors: {},
     oas3_1Preprocessors: {},
     async2Preprocessors: {},
+    arazzoPreprocessors: {},
 
     decorators: {},
     oas2Decorators: {},
     oas3_0Decorators: {},
     oas3_1Decorators: {},
     async2Decorators: {},
+    arazzoDecorators: {},
 
     plugins: [],
     pluginPaths: [],
@@ -186,6 +195,8 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
     assignExisting(result.oas3_1Rules, rulesConf.rules || {});
     Object.assign(result.async2Rules, rulesConf.async2Rules);
     assignExisting(result.async2Rules, rulesConf.rules || {});
+    Object.assign(result.arazzoRules, rulesConf.arazzoRules);
+    assignExisting(result.arazzoRules, rulesConf.rules || {});
 
     Object.assign(result.preprocessors, rulesConf.preprocessors);
     Object.assign(result.oas2Preprocessors, rulesConf.oas2Preprocessors);
@@ -196,6 +207,8 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
     assignExisting(result.oas3_1Preprocessors, rulesConf.preprocessors || {});
     Object.assign(result.async2Preprocessors, rulesConf.async2Preprocessors);
     assignExisting(result.async2Preprocessors, rulesConf.preprocessors || {});
+    Object.assign(result.arazzoPreprocessors, rulesConf.arazzoPreprocessors);
+    assignExisting(result.arazzoPreprocessors, rulesConf.preprocessors || {});
 
     Object.assign(result.decorators, rulesConf.decorators);
     Object.assign(result.oas2Decorators, rulesConf.oas2Decorators);
@@ -206,6 +219,8 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
     assignExisting(result.oas3_1Decorators, rulesConf.decorators || {});
     Object.assign(result.async2Decorators, rulesConf.async2Decorators);
     assignExisting(result.async2Decorators, rulesConf.decorators || {});
+    Object.assign(result.arazzoDecorators, rulesConf.arazzoDecorators);
+    assignExisting(result.arazzoDecorators, rulesConf.decorators || {});
 
     result.plugins!.push(...(rulesConf.plugins || []));
     result.pluginPaths!.push(...(rulesConf.pluginPaths || []));

package/src/decorators/arazzo/index.ts

@@ -0,0 +1 @@
+export const decorators = {};

package/src/decorators/async2/index.ts

@@ -0,0 +1 @@
+export const decorators = {};

package/src/index.ts

@@ -8,6 +8,7 @@ export {
   pause,
 } from './utils';
 export { Oas3_1Types } from './types/oas3_1';
+export { ArazzoTypes } from './types/arazzo';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';
 export { AsyncApi2Types } from './types/asyncapi';

package/src/oas-types.ts

@@ -5,15 +5,18 @@ import {
   Oas2Preprocessor,
   Async2Preprocessor,
   Async2Rule,
+  ArazzoPreprocessor,
+  ArazzoRule,
 } from './visitors';
 import { Oas2Types } from './types/oas2';
 import { Oas3Types } from './types/oas3';
 import { Oas3_1Types } from './types/oas3_1';
 import { AsyncApi2Types } from './types/asyncapi';
+import { ArazzoTypes } from './types/arazzo';
 import {
   BuiltInAsync2RuleId,
   BuiltInCommonOASRuleId,
-  BuiltInCommonRuleId,
+  BuiltInArazzoRuleId,
   BuiltInOAS2RuleId,
   BuiltInOAS3RuleId,
 } from './types/redocly-yaml';
@@ -25,12 +28,14 @@ export enum SpecVersion {
   OAS3_0 = 'oas3_0',
   OAS3_1 = 'oas3_1',
   Async2 = 'async2', // todo split into 2.x maybe?
+  Arazzo = 'arazzo',
 }
 
 export enum SpecMajorVersion {
   OAS2 = 'oas2',
   OAS3 = 'oas3',
   Async2 = 'async2',
+  Arazzo = 'arazzo',
 }
 
 const typesMap = {
@@ -38,6 +43,7 @@ const typesMap = {
   [SpecVersion.OAS3_0]: Oas3Types,
   [SpecVersion.OAS3_1]: Oas3_1Types,
   [SpecVersion.Async2]: AsyncApi2Types,
+  [SpecVersion.Arazzo]: ArazzoTypes,
 };
 
 export type RuleMap<Key extends string, RuleConfig, T> = Record<
@@ -45,26 +51,35 @@ export type RuleMap<Key extends string, RuleConfig, T> = Record<
   RuleConfig
 >;
 export type Oas3RuleSet<T = undefined> = RuleMap<
-  BuiltInCommonRuleId | BuiltInCommonOASRuleId | BuiltInOAS3RuleId | 'assertions',
+  BuiltInCommonOASRuleId | BuiltInOAS3RuleId | 'assertions',
   Oas3Rule,
   T
 >;
 export type Oas2RuleSet<T = undefined> = RuleMap<
-  BuiltInCommonRuleId | BuiltInCommonOASRuleId | BuiltInOAS2RuleId | 'assertions',
+  BuiltInCommonOASRuleId | BuiltInOAS2RuleId | 'assertions',
   Oas2Rule,
   T
 >;
 export type Async2RuleSet<T = undefined> = RuleMap<
-  BuiltInCommonRuleId | BuiltInAsync2RuleId | 'assertions',
+  BuiltInAsync2RuleId | 'assertions',
   Async2Rule,
   T
 >;
+export type ArazzoRuleSet<T = undefined> = RuleMap<
+  BuiltInArazzoRuleId | 'assertions',
+  ArazzoRule,
+  T
+>;
+
 export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
 export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
 export type Async2PreprocessorsSet = Record<string, Async2Preprocessor>;
+export type ArazzoPreprocessorsSet = Record<string, ArazzoPreprocessor>;
+
 export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
 export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
 export type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
+export type ArazzoDecoratorsSet = Record<string, ArazzoPreprocessor>;
 
 export function detectSpec(root: any): SpecVersion {
   if (typeof root !== 'object') {
@@ -100,6 +115,10 @@ export function detectSpec(root: any): SpecVersion {
     throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
   }
 
+  if (root.arazzo && root.arazzo.startsWith('1.')) {
+    return SpecVersion.Arazzo;
+  }
+
   throw new Error(`Unsupported specification`);
 }
 
@@ -108,6 +127,8 @@ export function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion {
     return SpecMajorVersion.OAS2;
   } else if (version === SpecVersion.Async2) {
     return SpecMajorVersion.Async2;
+  } else if (version === SpecVersion.Arazzo) {
+    return SpecMajorVersion.Arazzo;
   } else {
     return SpecMajorVersion.OAS3;
   }

package/src/rules/arazzo/index.ts

@@ -0,0 +1,11 @@
+import { ArazzoRule } from '../../visitors';
+import { Spec } from '../common/spec';
+import type { ArazzoRuleSet } from '../../oas-types';
+import { Assertions } from '../common/assertions';
+
+export const rules: ArazzoRuleSet<'built-in'> = {
+  spec: Spec as ArazzoRule,
+  assertions: Assertions,
+};
+
+export const preprocessors = {};

package/src/rules/common/spec.ts

@@ -1,11 +1,11 @@
-import type { Oas3Rule, Oas2Rule, Async2Rule } from '../../visitors';
+import type { Oas3Rule, Oas2Rule, Async2Rule, ArazzoRule } from '../../visitors';
 import { isNamedType, SpecExtension } from '../../types';
 import { oasTypeOf, matchesJsonSchemaType, getSuggest, validateSchemaEnumType } from '../utils';
 import { isRef } from '../../ref-utils';
 import { isPlainObject } from '../../utils';
 import { UserContext } from '../../walk';
 
-export const Spec: Oas3Rule | Oas2Rule | Async2Rule = () => {
+export const Spec: Oas3Rule | Oas2Rule | Async2Rule | ArazzoRule = () => {
   return {
     any(
       node: any,

package/src/types/arazzo.ts

@@ -0,0 +1,386 @@
+import type { NodeType } from '.';
+
+import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
+
+export const ARAZZO_ROOT_TYPE = 'Root';
+
+const operationMethod = {
+  type: 'string',
+  enum: ['get', 'post', 'put', 'delete', 'patch'],
+} as const;
+const expectSchema = {
+  type: 'object',
+  properties: {
+    statusCode: { type: 'number' },
+    mimeType: { type: 'string' },
+    body: {},
+    schema: {
+      type: 'object',
+      additionalProperties: true,
+    },
+  },
+  additionalProperties: false,
+  oneOf: [
+    { required: ['statusCode'] },
+    { required: ['mimeType'] },
+    { required: ['body'] },
+    { required: ['schema'] },
+  ],
+} as const;
+const openAPISourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['openapi'] },
+    url: { type: 'string' },
+    'x-serverUrl': { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'url'],
+} as const;
+const noneSourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['none'] },
+    'x-serverUrl': { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'x-serverUrl'],
+} as const;
+const arazzoSourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['arazzo'] },
+    url: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'url'],
+} as const;
+const sourceDescriptionSchema = {
+  type: 'object',
+  oneOf: [
+    openAPISourceDescriptionSchema,
+    noneSourceDescriptionSchema,
+    arazzoSourceDescriptionSchema,
+  ],
+} as const;
+const sourceDescriptionsSchema = {
+  type: 'array',
+  items: sourceDescriptionSchema,
+} as const;
+const extendedOperation = {
+  type: 'object',
+  properties: {
+    path: { type: 'string' },
+    method: operationMethod,
+    sourceDescriptionName: { type: 'string' },
+    serverUrl: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['path', 'method'],
+} as const;
+const parameter = {
+  type: 'object',
+  oneOf: [
+    {
+      type: 'object',
+      properties: {
+        in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+        name: { type: 'string' },
+        value: {
+          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+        },
+      },
+      required: ['name', 'value'],
+      additionalProperties: false,
+    },
+    {
+      type: 'object',
+      properties: {
+        $ref: { type: 'string' },
+        value: {
+          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+        },
+      },
+      required: ['$ref'],
+      additionalProperties: false,
+    },
+    {
+      type: 'object',
+      properties: {
+        reference: { type: 'string' },
+        value: {
+          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+        },
+      },
+      required: ['reference'],
+      additionalProperties: false,
+    },
+  ],
+} as const;
+const parameters = {
+  type: 'array',
+  items: parameter,
+} as const;
+const infoObject = {
+  type: 'object',
+  properties: {
+    title: { type: 'string' },
+    description: { type: 'string' },
+    summary: { type: 'string' },
+    version: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['title', 'version'],
+} as const;
+const replacement = {
+  type: 'object',
+  properties: {
+    target: { type: 'string' },
+    value: {
+      oneOf: [
+        { type: 'string' },
+        { type: 'object' },
+        { type: 'array' },
+        { type: 'number' },
+        { type: 'boolean' },
+      ],
+    },
+  },
+} as const;
+const requestBody = {
+  type: 'object',
+  properties: {
+    contentType: { type: 'string' },
+    payload: {
+      oneOf: [
+        { type: 'string' },
+        { type: 'object', additionalProperties: true },
+        { type: 'array' },
+        { type: 'number' },
+        { type: 'boolean' },
+      ],
+    },
+    encoding: { type: 'string' },
+    replacements: {
+      type: 'array',
+      items: replacement,
+    },
+  },
+  additionalProperties: false,
+  required: ['payload'],
+} as const;
+const criteriaObject = {
+  type: 'object',
+  properties: {
+    condition: { type: 'string' },
+    context: { type: 'string' },
+    type: {
+      oneOf: [
+        { type: 'string', enum: ['regex', 'jsonpath', 'simple', 'xpath'] },
+        {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['jsonpath'] },
+            version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+          },
+        },
+        {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['xpath'] },
+            version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+          },
+        },
+      ],
+    },
+  },
+  required: ['condition'],
+  additionalProperties: false,
+} as const;
+const criteriaObjects = {
+  type: 'array',
+  items: criteriaObject,
+} as const;
+const inherit = {
+  type: 'string',
+  enum: ['auto', 'none'],
+} as const;
+const onSuccessObject = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['goto', 'end'] },
+    stepId: { type: 'string' },
+    workflowId: { type: 'string' },
+    criteria: criteriaObjects,
+  },
+  additionalProperties: false,
+  required: ['type', 'name'],
+} as const;
+const onSuccessList = {
+  type: 'array',
+  items: onSuccessObject,
+} as const;
+const onFailureObject = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['goto', 'retry', 'end'] },
+    workflowId: { type: 'string' },
+    stepId: { type: 'string' },
+    retryAfter: { type: 'number' },
+    retryLimit: { type: 'number' },
+    criteria: criteriaObjects,
+  },
+  additionalProperties: false,
+  required: ['type', 'name'],
+} as const;
+const onFailureList = {
+  type: 'array',
+  items: onFailureObject,
+} as const;
+const step = {
+  type: 'object',
+  properties: {
+    stepId: { type: 'string' },
+    description: { type: 'string' },
+    operationId: { type: 'string' },
+    operationPath: { type: 'string' },
+    workflowId: { type: 'string' },
+    parameters: parameters,
+    successCriteria: criteriaObjects,
+    onSuccess: onSuccessList,
+    onFailure: onFailureList,
+    outputs: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string',
+      },
+    },
+    'x-inherit': inherit,
+    'x-expect': expectSchema,
+    'x-assert': { type: 'string' },
+    'x-operation': extendedOperation,
+    requestBody: requestBody,
+  },
+  required: ['stepId'],
+  oneOf: [
+    { required: ['x-operation'] },
+    { required: ['operationId'] },
+    { required: ['operationPath'] },
+    { required: ['workflowId'] },
+  ],
+} as const;
+const steps = {
+  type: 'array',
+  items: step,
+} as const;
+const JSONSchema = {
+  type: 'object',
+  properties: {
+    type: {
+      type: 'string',
+      enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+    },
+    properties: {
+      type: 'object',
+      additionalProperties: true,
+    },
+    required: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+    items: {
+      type: 'object',
+      additionalProperties: true,
+    },
+  },
+  required: ['type'],
+  additionalProperties: true,
+} as const;
+const workflow = {
+  type: 'object',
+  properties: {
+    workflowId: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    parameters: parameters,
+    dependsOn: { type: 'array', items: { type: 'string' } },
+    inputs: JSONSchema,
+    outputs: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string',
+      },
+    },
+    steps: steps,
+    successActions: {
+      type: 'array',
+      items: onSuccessObject,
+    },
+    failureActions: {
+      type: 'array',
+      items: onFailureObject,
+    },
+  },
+  additionalProperties: false,
+  required: ['workflowId', 'steps'],
+} as const;
+const workflows = {
+  type: 'array',
+  items: workflow,
+} as const;
+export const arazzoSchema = {
+  type: 'object',
+  properties: {
+    arazzo: { type: 'string', enum: ['1.0.0'] },
+    info: infoObject,
+    sourceDescriptions: sourceDescriptionsSchema,
+    'x-parameters': parameters,
+    workflows: workflows,
+    components: {
+      type: 'object',
+      properties: {
+        inputs: {
+          type: 'object',
+          additionalProperties: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              type: {
+                type: 'string',
+              },
+              properties: {
+                type: 'object',
+                additionalProperties: true,
+              },
+            },
+            required: ['type'],
+          },
+        },
+        parameters: {
+          type: 'object',
+          additionalProperties: parameter,
+        },
+        successActions: {
+          type: 'object',
+          additionalProperties: onSuccessObject,
+        },
+        failureActions: {
+          type: 'object',
+          additionalProperties: onFailureObject,
+        },
+      },
+    },
+  },
+  additionalProperties: false,
+  required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+} as const;
+
+export const ArazzoTypes: Record<string, NodeType> = getNodeTypesFromJSONSchema(
+  ARAZZO_ROOT_TYPE,
+  arazzoSchema
+);

package/src/types/oas3.ts

@@ -346,13 +346,6 @@ const Schema: NodeType = {
         return 'Schema';
       }
     },
-    additionalItems: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
     additionalProperties: (value: any) => {
       if (typeof value === 'boolean') {
         return { type: 'boolean' };

package/src/types/oas3_1.ts

@@ -134,6 +134,7 @@ const Schema: NodeType = {
     then: 'Schema',
     else: 'Schema',
     dependentSchemas: listOf('Schema'),
+    dependentRequired: 'DependentRequired',
     prefixItems: listOf('Schema'),
     contains: 'Schema',
     minContains: { type: 'integer', minimum: 0 },
@@ -266,6 +267,11 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
+const DependentRequired: NodeType = {
+  properties: {},
+  additionalProperties: { type: 'array', items: { type: 'string' } },
+};
+
 export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   ...Oas3Types,
   Info,
@@ -277,4 +283,5 @@ export const Oas3_1Types: Record<Oas3_1NodeType, NodeType> = {
   NamedPathItems: mapOf('PathItem'),
   SecurityScheme,
   Operation,
+  DependentRequired,
 };