@redocly/openapi-core 1.19.0 → 1.20.0

package/src/types/arazzo.ts

@@ -1,220 +1,254 @@
-import type { NodeType } from '.';
+import { mapOf, type NodeType, listOf } from '.';
+import { DependentRequired, Schema, SchemaProperties } from './oas3_1';
+import { Discriminator, DiscriminatorMapping, ExternalDocs, Xml } from './oas3';
 
-import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
-
-export const ARAZZO_ROOT_TYPE = 'Root';
-
-export const operationMethod = {
-  type: 'string',
-  enum: ['get', 'post', 'put', 'delete', 'patch'],
-} as const;
-export const expectSchema = {
-  type: 'object',
+const Root: NodeType = {
   properties: {
-    statusCode: { type: 'number' },
-    mimeType: { type: 'string' },
-    body: {},
-    schema: {
-      type: 'object',
-      additionalProperties: true,
-    },
+    arazzo: { type: 'string', enum: ['1.0.0'] },
+    info: 'Info',
+    sourceDescriptions: 'SourceDescriptions',
+    'x-parameters': 'Parameters',
+    workflows: 'Workflows',
+    components: 'Components',
+  },
+  required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+  extensionsPrefix: 'x-',
+};
+const NamedParameters: NodeType = {
+  properties: {},
+  additionalProperties: 'Parameter',
+};
+const NamedSuccessActions: NodeType = {
+  properties: {},
+  additionalProperties: 'SuccessActionObject',
+};
+const NamedFailureActions: NodeType = {
+  properties: {},
+  additionalProperties: 'FailureActionObject',
+};
+const Components: NodeType = {
+  properties: {
+    inputs: 'NamedInputs',
+    parameters: 'NamedParameters',
+    successActions: 'NamedSuccessActions',
+    failureActions: 'NamedFailureActions',
+  },
+  extensionsPrefix: 'x-',
+};
+const NamedInputs: NodeType = mapOf('Schema');
+const Info: NodeType = {
+  properties: {
+    title: { type: 'string' },
+    description: { type: 'string' },
+    summary: { type: 'string' },
+    version: { type: 'string' },
   },
-  additionalProperties: false,
-  oneOf: [
-    { required: ['statusCode'] },
-    { required: ['mimeType'] },
-    { required: ['body'] },
-    { required: ['schema'] },
-  ],
-} as const;
-const openAPISourceDescriptionSchema = {
-  type: 'object',
+  required: ['title', 'version'],
+  extensionsPrefix: 'x-',
+};
+const SourceDescriptions: NodeType = {
+  properties: {},
+  items: (value: any) => {
+    if (value?.type === 'openapi') {
+      return 'OpenAPISourceDescription';
+    } else if (value?.type === 'arazzo') {
+      return 'ArazzoSourceDescription';
+    } else {
+      return 'NoneSourceDescription';
+    }
+  },
+};
+const OpenAPISourceDescription: NodeType = {
   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',
+  extensionsPrefix: 'x-',
+};
+const NoneSourceDescription: NodeType = {
   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',
+  extensionsPrefix: 'x-',
+};
+const ArazzoSourceDescription: NodeType = {
   properties: {
     name: { type: 'string' },
     type: { type: 'string', enum: ['arazzo'] },
     url: { type: 'string' },
   },
-  additionalProperties: false,
   required: ['name', 'type', 'url'],
-} as const;
-export const sourceDescriptionSchema = {
-  type: 'object',
-  oneOf: [
-    openAPISourceDescriptionSchema,
-    noneSourceDescriptionSchema,
-    arazzoSourceDescriptionSchema,
-  ],
-} as const;
-const sourceDescriptionsSchema = {
-  type: 'array',
-  items: sourceDescriptionSchema,
-} as const;
-const extendedOperation = {
-  type: 'object',
+  extensionsPrefix: 'x-',
+};
+const ReusableObject: NodeType = {
   properties: {
-    path: { type: 'string' },
-    method: operationMethod,
-    sourceDescriptionName: { type: 'string' },
-    serverUrl: { type: 'string' },
-  },
-  additionalProperties: false,
-  required: ['path', 'method'],
-} as const;
-export 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: {
-        reference: { type: 'string' },
-        value: {
-          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
-        },
-      },
-      required: ['reference'],
-      additionalProperties: false,
+    reference: { type: 'string' },
+    value: {
+      type: 'string',
     },
-  ],
-} as const;
-const parameters = {
-  type: 'array',
-  items: parameter,
-} as const;
-export const infoObject = {
-  type: 'object',
+  },
+  required: ['reference'],
+  extensionsPrefix: 'x-',
+};
+const Parameter: NodeType = {
   properties: {
-    title: { type: 'string' },
-    description: { type: 'string' },
+    in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+    name: { type: 'string' },
+    value: {}, // any
+  },
+  required: ['name', 'value'],
+  extensionsPrefix: 'x-',
+};
+const Parameters: NodeType = {
+  properties: {},
+  items: (value: any) => {
+    if (value?.in) {
+      return 'Parameter';
+    } else {
+      return 'ReusableObject';
+    }
+  },
+};
+const Workflow: NodeType = {
+  properties: {
+    workflowId: { type: 'string' },
     summary: { type: 'string' },
-    version: { type: 'string' },
+    description: { type: 'string' },
+    parameters: 'Parameters',
+    dependsOn: { type: 'array', items: { type: 'string' } },
+    inputs: 'NamedInputs',
+    outputs: 'Outputs',
+    steps: 'Steps',
+    successActions: 'OnSuccessActionList',
+    failureActions: 'OnFailureActionList',
   },
-  additionalProperties: false,
-  required: ['title', 'version'],
-} as const;
-export const replacement = {
-  type: 'object',
+  required: ['workflowId', 'steps'],
+  extensionsPrefix: 'x-',
+};
+const Workflows: NodeType = listOf('Workflow');
+const Steps: NodeType = listOf('Step');
+const Step: NodeType = {
   properties: {
-    target: { type: 'string' },
-    value: {
-      oneOf: [
-        { type: 'string' },
-        { type: 'object' },
-        { type: 'array' },
-        { type: 'number' },
-        { type: 'boolean' },
-      ],
-    },
+    stepId: { type: 'string' },
+    description: { type: 'string' },
+    operationId: { type: 'string' },
+    operationPath: { type: 'string' },
+    workflowId: { type: 'string' },
+    parameters: 'Parameters',
+    successCriteria: listOf('CriterionObject'),
+    onSuccess: 'OnSuccessActionList',
+    onFailure: 'OnFailureActionList',
+    outputs: 'Outputs',
+    'x-inherit': { enum: ['auto', 'none'] },
+    'x-expect': 'ExpectSchema',
+    'x-assert': { type: 'string' },
+    'x-operation': 'ExtendedOperation',
+    requestBody: 'RequestBody',
+  },
+  required: ['stepId'],
+  requiredOneOf: ['x-operation', 'operationId', 'operationPath', 'workflowId'],
+  extensionsPrefix: 'x-',
+};
+const Outputs: NodeType = {
+  properties: {},
+  additionalProperties: {
+    type: 'string',
   },
-} as const;
-export const requestBody = {
-  type: 'object',
+};
+const RequestBody: NodeType = {
   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,
-    },
+    payload: {},
+    replacements: listOf('Replacement'),
   },
-  additionalProperties: false,
   required: ['payload'],
-} as const;
-export const criteriaObject = {
-  type: 'object',
+  extensionsPrefix: 'x-',
+};
+const Replacement: NodeType = {
+  properties: {
+    target: { type: 'string' },
+    value: {},
+  },
+  required: ['target', 'value'],
+  extensionsPrefix: 'x-',
+};
+const ExtendedOperation: NodeType = {
+  properties: {
+    path: { type: 'string' },
+    method: {
+      enum: ['get', 'post', 'put', 'delete', 'patch'],
+    },
+    sourceDescriptionName: { type: 'string' },
+    serverUrl: { type: 'string' },
+  },
+  required: ['path', 'method'],
+};
+const ExpectSchema: NodeType = {
+  properties: {
+    statusCode: { type: 'number' },
+    mimeType: { type: 'string' },
+    body: {},
+    schema: 'Schema',
+  },
+  requiredOneOf: ['statusCode', 'mimeType', 'body', 'schema'],
+};
+const CriterionObject: NodeType = {
   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'] },
-          },
-        },
-      ],
+    type: (value: any) => {
+      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'],
-  additionalProperties: false,
-} as const;
-const criteriaObjects = {
-  type: 'array',
-  items: criteriaObject,
-} as const;
-export const inherit = {
-  type: 'string',
-  enum: ['auto', 'none'],
-} as const;
-const onSuccessObject = {
-  type: 'object',
+};
+const JSONPathCriterion: NodeType = {
+  properties: {
+    type: { type: 'string', enum: ['jsonpath'] },
+    version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+  },
+};
+const XPathCriterion: NodeType = {
+  properties: {
+    type: { type: 'string', enum: ['xpath'] },
+    version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+  },
+};
+const SuccessActionObject: NodeType = {
   properties: {
     name: { type: 'string' },
     type: { type: 'string', enum: ['goto', 'end'] },
     stepId: { type: 'string' },
     workflowId: { type: 'string' },
-    criteria: criteriaObjects,
+    criteria: 'CriterionObject',
   },
-  additionalProperties: false,
   required: ['type', 'name'],
-} as const;
-const onSuccessList = {
-  type: 'array',
-  items: onSuccessObject,
-} as const;
-const onFailureObject = {
-  type: 'object',
+};
+const OnSuccessActionList: NodeType = {
+  properties: {},
+  items: (value: any) => {
+    if (value?.type && value?.name) {
+      return 'SuccessActionObject';
+    } else {
+      return 'ReusableObject';
+    }
+  },
+};
+const FailureActionObject: NodeType = {
   properties: {
     name: { type: 'string' },
     type: { type: 'string', enum: ['goto', 'retry', 'end'] },
@@ -222,170 +256,59 @@ const onFailureObject = {
     stepId: { type: 'string' },
     retryAfter: { type: 'number' },
     retryLimit: { type: 'number' },
-    criteria: criteriaObjects,
+    criteria: 'CriterionObject',
   },
-  additionalProperties: false,
   required: ['type', 'name'],
-} as const;
-const onFailureList = {
-  type: 'array',
-  items: onFailureObject,
-} as const;
-export 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: {
-        oneOf: [
-          {
-            type: 'string',
-          },
-          {
-            type: 'object',
-          },
-          {
-            type: 'array',
-          },
-          {
-            type: 'boolean',
-          },
-          {
-            type: 'number',
-          },
-        ],
-      },
-    },
-    'x-inherit': inherit,
-    'x-expect': expectSchema,
-    'x-assert': { type: 'string' },
-    'x-operation': extendedOperation,
-    requestBody: requestBody,
+};
+const OnFailureActionList: NodeType = {
+  properties: {},
+  items: (value: any) => {
+    if (value?.type && value?.name) {
+      return 'FailureActionObject';
+    } else {
+      return 'ReusableObject';
+    }
   },
-  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;
-export 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
-);
+export const ArazzoTypes: Record<string, NodeType> = {
+  Root,
+  Info,
+  SourceDescriptions,
+  OpenAPISourceDescription,
+  NoneSourceDescription,
+  ArazzoSourceDescription,
+  Parameters,
+  Parameter,
+  ReusableObject,
+  Workflows,
+  Workflow,
+  Steps,
+  Step,
+  RequestBody,
+  Replacement,
+  ExtendedOperation,
+  ExpectSchema,
+  Outputs,
+  CriterionObject,
+  XPathCriterion,
+  JSONPathCriterion,
+  SuccessActionObject,
+  OnSuccessActionList,
+  FailureActionObject,
+  OnFailureActionList,
+  Schema,
+  NamedSchemas: mapOf('Schema'),
+  ExternalDocs,
+  DiscriminatorMapping,
+  Discriminator,
+  DependentRequired,
+  SchemaProperties,
+  PatternProperties: SchemaProperties,
+  Components,
+  NamedInputs,
+  NamedParameters,
+  NamedSuccessActions,
+  NamedFailureActions,
+  Xml,
+};

package/src/types/asyncapi2.ts

@@ -1,6 +1,8 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
 import { isMappingRef } from '../ref-utils';
 
+import type { NodeType } from '.';
+
 const Root: NodeType = {
   properties: {
     asyncapi: null, // TODO: validate semver format and supported version
@@ -129,6 +131,7 @@ const Server: NodeType = {
 export const ServerMap: NodeType = {
   properties: {},
   additionalProperties: (_value: any, key: string) =>
+    // eslint-disable-next-line no-useless-escape
     key.match(/^[A-Za-z0-9_\-]+$/) ? 'Server' : undefined,
 };
 

package/src/types/asyncapi3.ts

@@ -1,4 +1,4 @@
-import { NodeType, listOf, mapOf } from '.';
+import { listOf, mapOf } from '.';
 import {
   AsyncApi2Bindings,
   Schema,
@@ -17,6 +17,8 @@ import {
   MessageExample,
 } from './asyncapi2';
 
+import type { NodeType } from '.';
+
 const Root: NodeType = {
   properties: {
     asyncapi: { type: 'string', enum: ['3.0.0'] },

package/src/types/json-schema-adapter.ts

@@ -3,9 +3,9 @@
 import Ajv from '@redocly/ajv/dist/2020';
 import { isPlainObject } from '../utils';
 
-import type { NodeType, PropType, ResolveTypeFn } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
-import { Oas3Schema } from '../typings/openapi';
+import type { NodeType, PropType, ResolveTypeFn } from '.';
+import type { Oas3Schema } from '../typings/openapi';
 
 const ajv = new Ajv({
   strictSchema: false,