@redocly/openapi-core 1.0.0-beta.80 → 1.0.0-beta.81

package/lib/types/oas3_1.js

@@ -21,35 +21,19 @@ const DefinitionRoot = {
 };
 const License = {
     properties: {
-        name: {
-            type: 'string',
-        },
-        url: {
-            type: 'string',
-        },
-        identifier: {
-            type: 'string',
-        },
+        name: { type: 'string' },
+        url: { type: 'string' },
+        identifier: { type: 'string' },
     },
     required: ['name'],
 };
 const Info = {
     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',
     },
@@ -84,9 +68,7 @@ const Operation = {
         servers: _1.listOf('Server'),
         requestBody: 'RequestBody',
         responses: 'ResponsesMap',
-        deprecated: {
-            type: 'boolean',
-        },
+        deprecated: { type: 'boolean' },
         callbacks: _1.mapOf('Callback'),
         'x-codeSamples': _1.listOf('XCodeSample'),
         'x-code-samples': _1.listOf('XCodeSample'), // deprecated
@@ -137,7 +119,7 @@ const Schema = {
         then: 'Schema',
         else: 'Schema',
         dependentSchemas: _1.listOf('Schema'),
-        prefixItems: { type: 'array' },
+        prefixItems: _1.listOf('Schema'),
         contains: 'Schema',
         patternProperties: { type: 'object' },
         propertyNames: 'Schema',
@@ -149,18 +131,16 @@ const Schema = {
             if (Array.isArray(value)) {
                 return _1.listOf('Schema');
             }
-            else {
-                return 'Schema';
-            }
-        },
-        additionalProperties: (value) => {
-            if (typeof value === 'boolean') {
+            else if (typeof value === 'boolean') {
                 return { type: 'boolean' };
             }
             else {
                 return 'Schema';
             }
         },
+        additionalProperties: (value) => {
+            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+        },
         description: { type: 'string' },
         format: { type: 'string' },
         contentEncoding: { type: 'string' },
@@ -181,30 +161,53 @@ const SecurityScheme = {
         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 === null || value === void 0 ? void 0 : value.type)) {
-            return ['type'];
-        }
-        if (value.type === 'apiKey') {
-            return ['type', 'name', 'in'];
+        switch (value === null || value === void 0 ? void 0 : 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'];
         }
-        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 === null || value === void 0 ? void 0 : value.type) {
+            case 'apiKey':
+                return ['type', 'name', 'in', 'description'];
+            case 'http':
+                return ['type', 'scheme', 'bearerFormat', 'description'];
+            case 'oauth2':
+                switch (value === null || value === void 0 ? void 0 : 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-',
 };
 exports.Oas3_1Types = Object.assign(Object.assign({}, oas3_1.Oas3Types), { Info,
     DefinitionRoot,

package/lib/utils.js

@@ -138,7 +138,7 @@ function readFileAsStringSync(filePath) {
 }
 exports.readFileAsStringSync = readFileAsStringSync;
 function isPathParameter(pathSegment) {
-    return pathSegment.startsWith('{') && pathSegment.endsWith('{');
+    return pathSegment.startsWith('{') && pathSegment.endsWith('}');
 }
 exports.isPathParameter = isPathParameter;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.80",
+  "version": "1.0.0-beta.81",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/redocly/registry-api.ts

@@ -3,6 +3,7 @@ import { RegistryApiTypes } from './registry-api-types';
 import { AccessTokens, Region, DEFAULT_REGION, DOMAINS } from '../config/config';
 import { isNotEmptyObject } from '../utils';
 const version = require('../../package.json').version;
+const HttpsProxyAgent = require('https-proxy-agent');
 
 export class RegistryApi {
   constructor(private accessTokens: AccessTokens, private region: Region) {}
@@ -23,7 +24,12 @@ export class RegistryApi {
   private async request(path = '', options: RequestInit = {}, region?: Region) {
     const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
     if (!headers.hasOwnProperty('authorization')) { throw new Error('Unauthorized'); }
-    const response = await fetch(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
+    const proxy = process.env.REDOCLY_PROXY;
+    const agent = proxy ? new HttpsProxyAgent(proxy) : undefined;
+    const response = await fetch(
+      `${this.getBaseUrl(region)}${path}`,
+      Object.assign({}, options, { headers, agent }),
+    );
     if (response.status === 401) { throw new Error('Unauthorized'); }
     if (response.status === 404) {
       const body: RegistryApiTypes.NotFoundProblemResponse = await response.json();

package/src/rules/common/operation-security-defined.ts

@@ -1,6 +1,8 @@
 import { Oas3Rule, Oas2Rule } from '../../visitors';
 import { Location } from '../../ref-utils';
 import { UserContext } from '../../walk';
+import { Oas2SecurityScheme } from '../../typings/swagger';
+import { Oas3SecurityScheme } from '../../typings/openapi';
 
 export const OperationSecurityDefined: Oas3Rule | Oas2Rule = () => {
   let referencedSchemes = new Map<
@@ -25,11 +27,8 @@ export const OperationSecurityDefined: Oas3Rule | Oas2Rule = () => {
         }
       },
     },
-    SecurityScheme(_securityScheme: object, { key }: UserContext) {
-      referencedSchemes.set(key.toString(), {
-        defined: true,
-        from: [],
-      });
+    SecurityScheme(_securityScheme: Oas2SecurityScheme | Oas3SecurityScheme, { key }: UserContext) {
+      referencedSchemes.set(key.toString(), { defined: true, from: [] });
     },
     SecurityRequirement(requirements, { location }) {
       for (const requirement of Object.keys(requirements)) {

package/src/rules/common/spec.ts

@@ -2,6 +2,7 @@ import type { Oas3Rule, Oas2Rule } from '../../visitors';
 import { isNamedType } from '../../types';
 import { oasTypeOf, matchesJsonSchemaType, getSuggest } from '../utils';
 import { isRef } from '../../ref-utils';
+import { isPlainObject } from '../../utils';
 
 export const OasSpec: Oas3Rule | Oas2Rule = () => {
   return {
@@ -26,6 +27,7 @@ export const OasSpec: Oas3Rule | Oas2Rule = () => {
 
       const required =
         typeof type.required === 'function' ? type.required(node, key) : type.required;
+
       for (let propName of required || []) {
         if (!(node as object).hasOwnProperty(propName)) {
           report({
@@ -35,6 +37,22 @@ export const OasSpec: Oas3Rule | Oas2Rule = () => {
         }
       }
 
+      const allowed = type.allowed?.(node);
+      if (allowed && isPlainObject(node)) {
+        for (const propName in node) {
+          if (allowed.includes(propName) ||
+           (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
+           !Object.keys(type.properties).includes(propName)
+          ) {
+            continue;
+          }
+          report({
+            message: `The field \`${propName}\` is not allowed here.`,
+            location: location.child([propName]).key()
+          });
+        }
+      }
+
       const requiredOneOf = type.requiredOneOf || null;
       if (requiredOneOf) {
         let hasProperty = false;

package/src/rules/oas3/no-invalid-media-type-examples.ts

@@ -13,31 +13,27 @@ export const ValidContentExamples: Oas3Rule = (opts) => {
         const { location, resolve } = ctx;
         if (!mediaType.schema) return;
         if (mediaType.example) {
+         resolveAndValidateExample(mediaType.example, location.child('example'));
+        } else if (mediaType.examples) {
+          for (const exampleName of Object.keys(mediaType.examples)) {
+            resolveAndValidateExample(mediaType.examples[exampleName], location.child(['examples', exampleName, 'value']), true);
+          }
+        }
+
+        function resolveAndValidateExample(example: Oas3Example | any, location: Location, isMultiple?: boolean) {
+          if (isRef(example)) {
+            const resolved = resolve<Oas3Example>(example);
+            if (!resolved.location) return;
+            location = isMultiple ? resolved.location.child('value') : resolved.location;
+            example = resolved.node;
+          }
           validateExample(
-            mediaType.example,
-            mediaType.schema,
-            location.child('example'),
+            isMultiple ? example.value : example,
+            mediaType.schema!,
+            location,
             ctx,
             disallowAdditionalProperties,
           );
-        } else if (mediaType.examples) {
-          for (const exampleName of Object.keys(mediaType.examples)) {
-            let example = mediaType.examples[exampleName];
-            let dataLoc: Location = location.child(['examples', exampleName, 'value']);
-            if (isRef(example)) {
-              const resolved = resolve<Oas3Example>(example);
-              if (!resolved.location) continue;
-              dataLoc = resolved.location.child('value');
-              example = resolved.node;
-            }
-            validateExample(
-              example.value,
-              mediaType.schema,
-              dataLoc,
-              ctx,
-              disallowAdditionalProperties,
-            );
-          }
         }
       },
     },

package/src/types/index.ts

@@ -24,6 +24,8 @@ export type NodeType = {
   items?: string;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
+  allowed?: ((value: any) => string[] | undefined);
+  extensionsPrefix?: string;
 };
 type PropType = string | NodeType | ScalarSchema | undefined | null;
 type ResolveTypeFn = (value: any, key: string) => string | PropType;
@@ -35,6 +37,8 @@ export type NormalizedNodeType = {
   items?: NormalizedNodeType;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
+  allowed?: ((value: any) => string[] | undefined);
+  extensionsPrefix?: string;
 };
 
 type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | undefined | null;

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 = {