@redocly/openapi-core 1.0.0-beta.79 → 1.0.0-beta.83

package/src/types/oas2.ts

@@ -12,12 +12,10 @@ const DefinitionRoot: NodeType = {
     consumes: { type: 'array', items: { type: 'string' } },
     produces: { type: 'array', items: { type: 'string' } },
     paths: 'PathMap',
-
     definitions: 'NamedSchemas',
     parameters: 'NamedParameters',
     responses: 'NamedResponses',
     securityDefinitions: 'NamedSecuritySchemes',
-
     security: listOf('SecurityRequirement'),
     tags: listOf('Tag'),
     externalDocs: 'ExternalDocs',
@@ -62,7 +60,6 @@ const PathMap: NodeType = {
 const PathItem: NodeType = {
   properties: {
     $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
-
     get: 'Operation',
     put: 'Operation',
     post: 'Operation',
@@ -70,7 +67,6 @@ const PathItem: NodeType = {
     options: 'Operation',
     head: 'Operation',
     patch: 'Operation',
-
     parameters: listOf('Parameter'),
   },
 };
@@ -78,9 +74,7 @@ const PathItem: NodeType = {
 const Operation: NodeType = {
   properties: {
     tags: { type: 'array', items: { type: 'string' } },
-    summary: {
-      type: 'string',
-    },
+    summary: { type: 'string' },
     description: { type: 'string' },
     externalDocs: 'ExternalDocs',
     operationId: { type: 'string' },
@@ -119,11 +113,8 @@ const Parameter: NodeType = {
     in: { type: 'string', enum: ['query', 'header', 'path', 'formData', 'body'] },
     description: { type: 'string' },
     required: { type: 'boolean' },
-
     schema: 'Schema',
-
     type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array', 'file'] },
-
     format: { type: 'string' },
     allowEmptyValue: { type: 'boolean' },
     items: 'ParameterItems',
@@ -197,9 +188,7 @@ const ResponsesMap: NodeType = {
 
 const Response: NodeType = {
   properties: {
-    description: {
-      type: 'string',
-    },
+    description: { type: 'string' },
     schema: 'Schema',
     headers: mapOf('Header'),
     examples: 'Examples',
@@ -217,7 +206,6 @@ const Header: NodeType = {
     description: { type: 'string' },
     type: { type: 'string', enum: ['string', 'number', 'integer', 'boolean', 'array'] },
     format: { type: 'string' },
-
     items: 'ParameterItems',
     collectionFormat: { type: 'string', enum: ['csv', 'ssv', 'tsv', 'pipes', 'multi'] },
     default: null,
@@ -277,7 +265,6 @@ const Schema: NodeType = {
       type: 'string',
       enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
     },
-
     items: (value: any) => {
       if (Array.isArray(value)) {
         return listOf('Schema');
@@ -294,7 +281,6 @@ const Schema: NodeType = {
         return 'Schema';
       }
     },
-
     discriminator: { type: 'string' },
     readOnly: { type: 'boolean' },
     xml: 'Xml',
@@ -323,39 +309,55 @@ const SecurityScheme: NodeType = {
     type: { enum: ['basic', 'apiKey', 'oauth2'] },
     description: { type: 'string' },
     name: { type: 'string' },
-    in: { type: 'string', enum: ['query', 'header', 'cookie'] },
+    in: { type: 'string', enum: ['query', 'header'] },
     flow: { enum: ['implicit', 'password', 'application', 'accessCode'] },
     authorizationUrl: { type: 'string' },
     tokenUrl: { type: 'string' },
     scopes: { type: 'object', additionalProperties: { type: 'string' } },
   },
   required(value) {
-    if (!value?.type) {
-      return ['type'];
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'name', 'in'];
+      case 'oauth2':
+        switch (value?.flow) {
+          case 'implicit':
+            return ['type', 'flow', 'authorizationUrl', 'scopes'];
+          case 'accessCode':
+            return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'scopes'];
+          case 'application':
+          case 'password':
+            return ['type', 'flow', 'tokenUrl', 'scopes'];
+          default:
+            return ['type', 'flow', 'scopes'];
+        }
+      default:
+        return ['type'];
     }
-
-    if (value.type === 'apiKey') {
-      return ['type', 'name', 'in'];
-    } else if (value.type === 'http') {
-      return ['type', 'scheme'];
-    } else if (value.type === 'oauth2') {
-      if (!value?.flow) {
-        return ['type', 'flow'];
-      } else if (value.flow === 'implicit') {
-        return ['type', 'flow', 'authorizationUrl'];
-      } else if (value.flow === 'accessCode') {
-        return ['type', 'flow', 'authorizationUrl', 'tokenUrl'];
-      } else if (value.flow === 'application') {
-        return ['type', 'flow', 'tokenUrl'];
-      } else if (value.flow === 'password') {
-        return ['type', 'flow', 'tokenUrl'];
-      } else {
-        return ['type', 'flow'];
-      }
+  },
+  allowed(value) {
+    switch (value?.type) {
+      case 'basic':
+        return ['type', 'description'];
+      case 'apiKey':
+        return ['type', 'name', 'in', 'description'];
+      case 'oauth2':
+        switch (value?.flow) {
+          case 'implicit':
+            return ['type', 'flow', 'authorizationUrl', 'description', 'scopes'];
+          case 'accessCode':
+            return ['type', 'flow', 'authorizationUrl', 'tokenUrl', 'description', 'scopes'];
+          case 'application':
+          case 'password':
+            return ['type', 'flow', 'tokenUrl', 'description', 'scopes'];
+          default:
+            return ['type', 'flow', 'tokenUrl', 'authorizationUrl', 'description', 'scopes'];
+        }
+      default:
+        return ['type', 'description'];
     }
-
-    return ['type'];
   },
+  extensionsPrefix: 'x-',
 };
 
 const SecurityRequirement: NodeType = {

package/src/types/oas3.ts

@@ -1,6 +1,5 @@
 import { NodeType, listOf, mapOf } from '.';
 import { isMappingRef } from '../ref-utils';
-
 const responseCodeRegexp = /^[0-9][0-9Xx]{2}$/;
 
 const DefinitionRoot: NodeType = {
@@ -29,24 +28,16 @@ const Tag: NodeType = {
 
 const ExternalDocs: NodeType = {
   properties: {
-    description: {
-      type: 'string',
-    },
-    url: {
-      type: 'string',
-    },
+    description: { type: 'string' },
+    url: { type: 'string' },
   },
   required: ['url'],
 };
 
 const Server: NodeType = {
   properties: {
-    url: {
-      type: 'string',
-    },
-    description: {
-      type: 'string',
-    },
+    url: { type: 'string' },
+    description: { type: 'string' },
     variables: mapOf('ServerVariable'),
   },
   required: ['url'],
@@ -58,9 +49,7 @@ const ServerVariable: NodeType = {
       type: 'array',
       items: { type: 'string' },
     },
-    default: {
-      type: 'string',
-    },
+    default: { type: 'string' },
     description: null,
   },
   required: ['default'],
@@ -73,18 +62,10 @@ const SecurityRequirement: NodeType = {
 
 const Info: NodeType = {
   properties: {
-    title: {
-      type: 'string',
-    },
-    version: {
-      type: 'string',
-    },
-    description: {
-      type: 'string',
-    },
-    termsOfService: {
-      type: 'string',
-    },
+    title: { type: 'string' },
+    version: { type: 'string' },
+    description: { type: 'string' },
+    termsOfService: { type: 'string' },
     contact: 'Contact',
     license: 'License',
   },
@@ -93,26 +74,16 @@ const Info: NodeType = {
 
 const Contact: NodeType = {
   properties: {
-    name: {
-      type: 'string',
-    },
-    url: {
-      type: 'string',
-    },
-    email: {
-      type: 'string',
-    },
+    name: { type: 'string' },
+    url: { type: 'string' },
+    email: { type: 'string' },
   },
 };
 
 const License: NodeType = {
   properties: {
-    name: {
-      type: 'string',
-    },
-    url: {
-      type: 'string',
-    },
+    name: { type: 'string' },
+    url: { type: 'string' },
   },
   required: ['name'],
 };
@@ -133,12 +104,8 @@ const PathItem: NodeType = {
     $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
     servers: listOf('Server'),
     parameters: listOf('Parameter'),
-    summary: {
-      type: 'string',
-    },
-    description: {
-      type: 'string',
-    },
+    summary: { type: 'string' },
+    description: { type: 'string' },
     get: 'Operation',
     put: 'Operation',
     post: 'Operation',
@@ -152,33 +119,17 @@ const PathItem: NodeType = {
 
 const Parameter: NodeType = {
   properties: {
-    name: {
-      type: 'string',
-    },
-    in: {
-      enum: ['query', 'header', 'path', 'cookie'],
-    },
-    description: {
-      type: 'string',
-    },
-    required: {
-      type: 'boolean',
-    },
-    deprecated: {
-      type: 'boolean',
-    },
-    allowEmptyValue: {
-      type: 'boolean',
-    },
+    name: { type: 'string' },
+    in: { enum: ['query', 'header', 'path', 'cookie'] },
+    description: { type: 'string' },
+    required: { type: 'boolean' },
+    deprecated: { type: 'boolean' },
+    allowEmptyValue: { type: 'boolean' },
     style: {
       enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
     },
-    explode: {
-      type: 'boolean',
-    },
-    allowReserved: {
-      type: 'boolean',
-    },
+    explode: { type: 'boolean' },
+    allowReserved: { type: 'boolean' },
     schema: 'Schema',
     example: { isExample: true },
     examples: mapOf('Example'),
@@ -207,9 +158,7 @@ const Operation: NodeType = {
     servers: listOf('Server'),
     requestBody: 'RequestBody',
     responses: 'ResponsesMap',
-    deprecated: {
-      type: 'boolean',
-    },
+    deprecated: { type: 'boolean' },
     callbacks: mapOf('Callback'),
     'x-codeSamples': listOf('XCodeSample'),
     'x-code-samples': listOf('XCodeSample'), // deprecated
@@ -227,12 +176,8 @@ const XCodeSample: NodeType = {
 
 const RequestBody: NodeType = {
   properties: {
-    description: {
-      type: 'string',
-    },
-    required: {
-      type: 'boolean',
-    },
+    description: { type: 'string' },
+    required: { type: 'boolean' },
     content: 'MediaTypeMap',
   },
   required: ['content'],
@@ -255,59 +200,35 @@ const MediaType: NodeType = {
 const Example: NodeType = {
   properties: {
     value: { isExample: true },
-    summary: {
-      type: 'string',
-    },
-    description: {
-      type: 'string',
-    },
-    externalValue: {
-      type: 'string',
-    },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    externalValue: { type: 'string' },
   },
 };
 
 const Encoding: NodeType = {
   properties: {
-    contentType: {
-      type: 'string',
-    },
+    contentType: { type: 'string' },
     headers: mapOf('Header'),
     style: {
       enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
     },
-    explode: {
-      type: 'boolean',
-    },
-    allowReserved: {
-      type: 'boolean',
-    },
+    explode: { type: 'boolean' },
+    allowReserved: { type: 'boolean' },
   },
 };
 
 const Header: NodeType = {
   properties: {
-    description: {
-      type: 'string',
-    },
-    required: {
-      type: 'boolean',
-    },
-    deprecated: {
-      type: 'boolean',
-    },
-    allowEmptyValue: {
-      type: 'boolean',
-    },
+    description: { type: 'string' },
+    required: { type: 'boolean' },
+    deprecated: { type: 'boolean' },
+    allowEmptyValue: { type: 'boolean' },
     style: {
       enum: ['form', 'simple', 'label', 'matrix', 'spaceDelimited', 'pipeDelimited', 'deepObject'],
     },
-    explode: {
-      type: 'boolean',
-    },
-    allowReserved: {
-      type: 'boolean',
-    },
+    explode: { type: 'boolean' },
+    allowReserved: { type: 'boolean' },
     schema: 'Schema',
     example: { isExample: true },
     examples: mapOf('Example'),
@@ -316,18 +237,14 @@ const Header: NodeType = {
 };
 
 const ResponsesMap: NodeType = {
-  properties: {
-    default: 'Response',
-  },
+  properties: { default: 'Response' },
   additionalProperties: (_v: any, key: string) =>
     responseCodeRegexp.test(key) ? 'Response' : undefined,
 };
 
 const Response: NodeType = {
   properties: {
-    description: {
-      type: 'string',
-    },
+    description: { type: 'string' },
     headers: mapOf('Header'),
     content: 'MediaTypeMap',
     links: mapOf('Link'),
@@ -391,9 +308,7 @@ const Schema: NodeType = {
     description: { type: 'string' },
     format: { type: 'string' },
     default: null,
-
     nullable: { type: 'boolean' },
-
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },
     xml: 'Xml',
@@ -456,7 +371,7 @@ const ImplicitFlow: NodeType = {
     scopes: { type: 'object', additionalProperties: { type: 'string' } }, // TODO: validate scopes
     authorizationUrl: { type: 'string' },
   },
-  required: ['authorizationUrl', 'scopes'],
+  required: ['authorizationUrl', 'scopes']
 };
 
 const PasswordFlow: NodeType = {
@@ -501,29 +416,41 @@ const SecurityScheme: NodeType = {
     type: { enum: ['apiKey', 'http', 'oauth2', 'openIdConnect'] },
     description: { type: 'string' },
     name: { type: 'string' },
-    in: { type: 'string' },
+    in: { type: 'string', enum: ['query', 'header', 'cookie'] },
     scheme: { type: 'string' },
     bearerFormat: { type: 'string' },
     flows: 'SecuritySchemeFlows',
     openIdConnectUrl: { type: 'string' },
   },
   required(value) {
-    if (!value?.type) {
-      return ['type'];
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'name', 'in'];
+      case 'http':
+        return ['type', 'scheme'];
+      case 'oauth2':
+        return ['type', 'flows'];
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl'];
+      default:
+        return ['type'];
     }
-
-    if (value.type === 'apiKey') {
-      return ['type', 'name', 'in'];
-    } else if (value.type === 'http') {
-      return ['type', 'scheme'];
-    } else if (value.type === 'oauth2') {
-      return ['type', 'flows'];
-    } else if (value.type === 'openIdConnect') {
-      return ['type', 'openIdConnectUrl'];
+  },
+  allowed(value) {
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'name', 'in', 'description'];
+      case 'http':
+        return ['type', 'scheme', 'bearerFormat', 'description'];
+      case 'oauth2':
+        return ['type', 'flows', 'description'];
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl', 'description'];
+      default:
+        return ['type', 'description'];
     }
-
-    return ['type'];
   },
+  extensionsPrefix: 'x-',
 };
 
 export const Oas3Types: Record<string, NodeType> = {

package/src/types/oas3_1.ts

@@ -20,36 +20,20 @@ const DefinitionRoot: NodeType = {
 
 const License: NodeType = {
   properties: {
-    name: {
-      type: 'string',
-    },
-    url: {
-      type: 'string',
-    },
-    identifier: {
-      type: 'string',
-    },
+    name: { type: 'string' },
+    url: { type: 'string' },
+    identifier: { type: 'string' },
   },
   required: ['name'],
 };
 
 const Info: NodeType = {
   properties: {
-    title: {
-      type: 'string',
-    },
-    version: {
-      type: 'string',
-    },
-    description: {
-      type: 'string',
-    },
-    termsOfService: {
-      type: 'string',
-    },
-    summary: {
-      type: 'string',
-    },
+    title: { type: 'string' },
+    version: { type: 'string' },
+    description: { type: 'string' },
+    termsOfService: { type: 'string' },
+    summary: { type: 'string' },
     contact: 'Contact',
     license: 'License',
   },
@@ -86,9 +70,7 @@ const Operation: NodeType = {
     servers: listOf('Server'),
     requestBody: 'RequestBody',
     responses: 'ResponsesMap',
-    deprecated: {
-      type: 'boolean',
-    },
+    deprecated: { type: 'boolean' },
     callbacks: mapOf('Callback'),
     'x-codeSamples': listOf('XCodeSample'),
     'x-code-samples': listOf('XCodeSample'), // deprecated
@@ -103,7 +85,6 @@ const Schema: NodeType = {
     definitions: 'NamedSchemas',
     $defs: 'NamedSchemas',
     $vocabulary: { type: 'string' },
-
     externalDocs: 'ExternalDocs',
     discriminator: 'Discriminator',
     myArbitraryKeyword: { type: 'boolean' },
@@ -140,35 +121,31 @@ const Schema: NodeType = {
     then: 'Schema',
     else: 'Schema',
     dependentSchemas: listOf('Schema'),
-    prefixItems: { type: 'array' },
+    prefixItems: listOf('Schema'),
     contains: 'Schema',
     patternProperties: { type: 'object' },
     propertyNames: 'Schema',
     unevaluatedItems: 'Schema',
     unevaluatedProperties: 'Schema',
     summary: { type: 'string' },
-
     properties: 'SchemaProperties',
     items: (value: any) => {
       if (Array.isArray(value)) {
         return listOf('Schema');
+      } else if (typeof value === 'boolean') {
+        return { type: 'boolean' };
       } else {
         return 'Schema';
       }
     },
     additionalProperties: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
+      return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
     },
     description: { type: 'string' },
     format: { type: 'string' },
     contentEncoding: { type: 'string' },
     contentMediaType: { type: 'string' },
     default: null,
-
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },
     xml: 'Xml',
@@ -185,29 +162,53 @@ const SecurityScheme: NodeType = {
     type: { enum: ['apiKey', 'http', 'oauth2', 'openIdConnect', 'mutualTLS'] },
     description: { type: 'string' },
     name: { type: 'string' },
-    in: { type: 'string' },
+    in: { type: 'string', enum: ['query', 'header', 'cookie'] },
     scheme: { type: 'string' },
     bearerFormat: { type: 'string' },
     flows: 'SecuritySchemeFlows',
     openIdConnectUrl: { type: 'string' },
   },
   required(value) {
-    if (!value?.type) {
-      return ['type'];
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'name', 'in'];
+      case 'http':
+        return ['type', 'scheme'];
+      case 'oauth2':
+        return ['type', 'flows'];
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl'];
+      default:
+        return ['type'];
     }
-
-    if (value.type === 'apiKey') {
-      return ['type', 'name', 'in'];
-    } else if (value.type === 'http') {
-      return ['type', 'scheme'];
-    } else if (value.type === 'oauth2') {
-      return ['type', 'flows'];
-    } else if (value.type === 'openIdConnect') {
-      return ['type', 'openIdConnectUrl'];
+  },
+  allowed(value) {
+    switch (value?.type) {
+      case 'apiKey':
+        return ['type', 'name', 'in', 'description'];
+      case 'http':
+        return ['type', 'scheme', 'bearerFormat', 'description'];
+      case 'oauth2':
+        switch (value?.flows) {
+          case 'implicit':
+            return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'description', 'scopes'];
+          case 'password':
+          case 'clientCredentials':
+            return ['type', 'flows', 'tokenUrl', 'refreshUrl', 'description', 'scopes'];
+          case 'authorizationCode':
+            return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+          default:
+            return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'tokenUrl', 'description', 'scopes'];
+        }
+      case 'openIdConnect':
+        return ['type', 'openIdConnectUrl', 'description'];
+      case 'mutualTLS':
+        return ['type', 'description'];
+      default:
+        return ['type', 'description'];
     }
-
-    return ['type'];
   },
+  extensionsPrefix: 'x-',
 };
 
 export const Oas3_1Types: Record<string, NodeType> = {