@redocly/openapi-core 1.0.0-beta.112 → 1.0.0-beta.113

package/src/config/__tests__/config-resolvers.test.ts

@@ -342,7 +342,7 @@ describe('resolveApis', () => {
 });
 
 describe('resolveConfig', () => {
-  it('should add recommended to top level by default', async () => {
+  it('should NOT add recommended to top level by default IF there is a config file', async () => {
     const rawConfig: RawConfig = {
       apis: {
         petstore: {
@@ -373,7 +373,6 @@ describe('resolveConfig', () => {
     expect(apis['petstore'].styleguide.pluginPaths!.map(removeAbsolutePath)).toEqual([]);
 
     expect(apis['petstore'].styleguide.rules).toEqual({
-      ...(await recommendedStyleguidePreset).rules,
       'operation-2xx-response': 'warn',
       'operation-4xx-response': 'error',
     });

package/src/config/__tests__/fixtures/load-redocly.yaml

@@ -1,4 +1,2 @@
-lint:
   rules:
     info-contact: warn
-  extends: []

package/src/config/__tests__/fixtures/resolve-config/local-config-with-custom-function.yaml

@@ -1,4 +1,3 @@
-lint:
   rules:
     no-invalid-media-type-examples: warn
     operation-4xx-response: off

package/src/config/__tests__/fixtures/resolve-config/local-config-with-wrong-custom-function.yaml

@@ -1,4 +1,3 @@
-lint:
   rules:
     no-invalid-media-type-examples: warn
     operation-4xx-response: off

package/src/config/config-resolvers.ts

@@ -41,25 +41,15 @@ export async function resolveConfig(rawConfig: RawConfig, configPath?: string):
   }
 
   const resolver = new BaseResolver(getResolveConfig(rawConfig.resolve));
-  const configExtends = rawConfig?.styleguide?.extends ?? ['recommended'];
-  const recommendedFallback = !rawConfig?.styleguide?.extends;
-  const styleguideConfig = {
-    ...rawConfig?.styleguide,
-    extends: configExtends,
-    recommendedFallback,
-  };
 
   const apis = await resolveApis({
-    rawConfig: {
-      ...rawConfig,
-      styleguide: styleguideConfig,
-    },
+    rawConfig,
     configPath,
     resolver,
   });
 
   const styleguide = await resolveStyleguideConfig({
-    styleguideConfig,
+    styleguideConfig: rawConfig.styleguide,
     configPath,
     resolver,
   });

package/src/config/config.ts

@@ -4,7 +4,7 @@ import { parseYaml, stringifyYaml } from '../js-yaml';
 import { slash, doesYamlFileExist } from '../utils';
 import { NormalizedProblem } from '../walk';
 import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
-import { env } from '../env';
+import { isBrowser, env } from '../env';
 
 import type { NodeType } from '../types';
 import type {
@@ -17,6 +17,7 @@ import type {
   ResolvedConfig,
   ResolvedStyleguideConfig,
   RuleConfig,
+  RuleSettings,
 } from './types';
 import { getResolveConfig } from './utils';
 
@@ -50,7 +51,7 @@ function getIgnoreFilePath(configFile?: string): string | undefined {
       ? path.join(path.dirname(configFile), IGNORE_FILE)
       : path.join(configFile, IGNORE_FILE);
   } else {
-    return typeof process === 'undefined' ? undefined : path.join(process.cwd(), IGNORE_FILE);
+    return isBrowser ? undefined : path.join(process.cwd(), IGNORE_FILE);
   }
 }
 
@@ -183,7 +184,7 @@ export class StyleguideConfig {
     return extendedTypes;
   }
 
-  getRuleSettings(ruleId: string, oasVersion: OasVersion) {
+  getRuleSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.rules[oasVersion][ruleId] || 'off';
@@ -196,7 +197,7 @@ export class StyleguideConfig {
     }
   }
 
-  getPreprocessorSettings(ruleId: string, oasVersion: OasVersion) {
+  getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
 
@@ -210,7 +211,7 @@ export class StyleguideConfig {
     }
   }
 
-  getDecoratorSettings(ruleId: string, oasVersion: OasVersion) {
+  getDecoratorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.decorators[oasVersion][ruleId] || 'off';

package/src/config/load.ts

@@ -15,18 +15,21 @@ async function addConfigMetadata({
   customExtends,
   configPath,
   tokens,
+  files,
+  region,
 }: {
   rawConfig: RawConfig;
   customExtends?: string[];
   configPath?: string;
   tokens?: RegionalTokenWithValidity[];
+  files?: string[];
+  region?: Region;
 }): Promise<Config> {
   if (customExtends !== undefined) {
     rawConfig.styleguide = rawConfig.styleguide || {};
     rawConfig.styleguide.extends = customExtends;
   } else if (isEmptyObject(rawConfig)) {
-    // TODO: check if we can add recommended here. add message here?
-    // rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
+    rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
   }
 
   if (tokens?.length) {
@@ -58,7 +61,10 @@ async function addConfigMetadata({
     }
   }
 
-  return resolveConfig(rawConfig, configPath);
+  return resolveConfig(
+    { ...rawConfig, files: files ?? rawConfig.files, region: region ?? rawConfig.region },
+    configPath
+  );
 }
 
 export async function loadConfig(
@@ -71,8 +77,7 @@ export async function loadConfig(
   } = {}
 ): Promise<Config> {
   const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-  const config = await getConfig(configPath, processRawConfig);
-  const rawConfig = { ...config, files: files ?? config.files, region: region ?? config.region };
+  const rawConfig = await getConfig(configPath, processRawConfig);
 
   const redoclyClient = new RedoclyClient();
   const tokens = await redoclyClient.getTokens();
@@ -82,6 +87,8 @@ export async function loadConfig(
     customExtends,
     configPath,
     tokens,
+    files,
+    region,
   });
 }
 

package/src/config/rules.ts

@@ -1,13 +1,20 @@
 import { RuleSet, OasVersion } from '../oas-types';
 import { StyleguideConfig } from './config';
 import { isDefined } from '../utils';
+import type { ProblemSeverity } from '../walk';
+
+type InitializedRule = {
+  severity: ProblemSeverity;
+  ruleId: string;
+  visitor: any;
+};
 
 export function initRules<T extends Function, P extends RuleSet<T>>(
   rules: P[],
   config: StyleguideConfig,
   type: 'rules' | 'preprocessors' | 'decorators',
   oasVersion: OasVersion
-) {
+): InitializedRule[] {
   return rules
     .flatMap((ruleset) =>
       Object.keys(ruleset).map((ruleId) => {
@@ -23,19 +30,20 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
         if (ruleSettings.severity === 'off') {
           return undefined;
         }
+        const severity: ProblemSeverity = ruleSettings.severity;
 
         const visitors = rule(ruleSettings);
 
         if (Array.isArray(visitors)) {
           return visitors.map((visitor: any) => ({
-            severity: ruleSettings.severity,
+            severity,
             ruleId,
             visitor: visitor,
           }));
         }
 
         return {
-          severity: ruleSettings.severity,
+          severity,
           ruleId,
           visitor: visitors, // note: actually it is only one visitor object
         };

package/src/config/types.ts

@@ -14,6 +14,8 @@ import { Location } from '../ref-utils';
 
 export type RuleSeverity = ProblemSeverity | 'off';
 
+export type RuleSettings = { severity: RuleSeverity };
+
 export type PreprocessorSeverity = RuleSeverity | 'on';
 
 export type RuleConfig =

package/src/ref-utils.ts

@@ -79,3 +79,7 @@ export function isMappingRef(mapping: string) {
     mapping.indexOf('/') > -1
   );
 }
+
+export function isAnchor(ref: string) {
+  return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
+}

package/src/resolve.ts

@@ -1,10 +1,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { OasRef } from './typings/openapi';
-import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl } from './ref-utils';
+import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl, isAnchor } from './ref-utils';
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType, isNamedType } from './types';
-import { readFileFromUrl, parseYaml } from './utils';
+import { readFileFromUrl, parseYaml, nextTick } from './utils';
 import { ResolveConfig } from './config/types';
 
 export type CollectedRefs = Map<string /* absoluteFilePath */, Document>;
@@ -237,6 +237,7 @@ export async function resolveDocument(opts: {
     type: any
   ) {
     const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+    const anchorRefsMap: Map<string, any> = new Map();
 
     walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
 
@@ -252,6 +253,11 @@ export async function resolveDocument(opts: {
 
       seedNodes.add(nodeId);
 
+      const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+      if (anchor) {
+        anchorRefsMap.set(`#${anchor}`, node);
+      }
+
       if (Array.isArray(node)) {
         const itemsType = type.items;
         // we continue resolving unknown types, but stop early on known scalars
@@ -313,6 +319,22 @@ export async function resolveDocument(opts: {
       if (hasRef(refStack.prev, ref)) {
         throw new Error('Self-referencing circular pointer');
       }
+
+      if (isAnchor(ref.$ref)) {
+        // Wait for all anchors in the document to be collected firstly.
+        await nextTick();
+        const resolvedRef: ResolvedRef = {
+          resolved: true,
+          isRemote: false,
+          node: anchorRefsMap.get(ref.$ref),
+          document,
+          nodePointer: ref.$ref,
+        };
+        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+        resolvedRefMap.set(refId, resolvedRef);
+        return resolvedRef;
+      }
+
       const { uri, pointer } = parseRef(ref.$ref);
       const isRemote = uri !== null;
       let targetDoc: Document;
@@ -336,7 +358,7 @@ export async function resolveDocument(opts: {
       }
 
       let resolvedRef: ResolvedRef = {
-        resolved: true as const,
+        resolved: true,
         document: targetDoc,
         isRemote,
         node: document.parsed,

package/src/rules/common/__tests__/spec.test.ts

@@ -138,6 +138,176 @@ describe('Oas3 spec', () => {
       ]
     `);
   });
+
+  it('should report on nullable without type', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.0.0
+      components:
+        requestBodies:
+          TestRequestBody:
+            content:
+              application/json:
+                schema:
+                  nullable: true
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`paths\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`info\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/requestBodies/TestRequestBody/content/application~1json/schema/nullable",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The \`type\` field must be defined when the \`nullable\` field is used.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on nullable with type defined in allOf', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      openapi: 3.0.0
+      components:
+        requestBodies:
+          TestRequestBody:
+            content:
+              application/json:
+                schema:
+                  nullable: true
+                  allOf:
+                    - $ref: "#/components/requestBodies/TestSchema"
+          schemas:
+            TestSchema:
+              title: TestSchema
+              type: object
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`paths\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`info\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/components/requestBodies/TestRequestBody/content/application~1json/schema/nullable",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The \`type\` field must be defined when the \`nullable\` field is used.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/components/requestBodies/schemas",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "The field \`content\` must be present on this level.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/components/requestBodies/schemas/TestSchema",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Property \`TestSchema\` is not expected here.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
 });
 
 describe('Oas3.1 spec', () => {

package/src/rules/common/spec.ts

@@ -158,6 +158,13 @@ export const OasSpec: Oas3Rule | Oas2Rule = () => {
             });
           }
         }
+
+        if (propName === 'nullable' && !node.type) {
+          report({
+            message: 'The `type` field must be defined when the `nullable` field is used.',
+            location: location.child([propName]),
+          });
+        }
       }
     },
   };

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

@@ -438,4 +438,36 @@ describe('no-invalid-media-type-examples', () => {
       ]
     `);
   });
+
+  it('should not report if allOf used with discriminator', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          /pet:
+            get:
+              responses:
+                '200':
+                  content:
+                    application/json:
+                      schema:
+                        discriminator:
+                          propertyName: powerSource
+                          mapping: {}
+                        allOf: []
+                      examples:
+                        first:
+                          value: {}
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'no-invalid-media-type-examples': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
 });

package/src/rules/utils.ts

@@ -118,6 +118,10 @@ export function validateExample(
       }
     }
   } catch (e) {
+    if (e.message === 'discriminator: requires oneOf or anyOf composite keyword') {
+      return;
+    }
+
     report({
       message: `Example validation errored: ${e.message}.`,
       location: location.child('schema'),

package/src/types/oas2.ts

@@ -16,8 +16,8 @@ const Root: NodeType = {
     parameters: 'NamedParameters',
     responses: 'NamedResponses',
     securityDefinitions: 'NamedSecuritySchemes',
-    security: listOf('SecurityRequirement'),
-    tags: listOf('Tag'),
+    security: 'SecurityRequirementList',
+    tags: 'TagList',
     externalDocs: 'ExternalDocs',
   },
   required: ['swagger', 'paths', 'info'],
@@ -60,7 +60,7 @@ const Paths: NodeType = {
 const PathItem: NodeType = {
   properties: {
     $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
-    parameters: listOf('Parameter'),
+    parameters: 'ParameterList',
 
     get: 'Operation',
     put: 'Operation',
@@ -81,13 +81,13 @@ const Operation: NodeType = {
     operationId: { type: 'string' },
     consumes: { type: 'array', items: { type: 'string' } },
     produces: { type: 'array', items: { type: 'string' } },
-    parameters: listOf('Parameter'),
+    parameters: 'ParameterList',
     responses: 'Responses',
     schemes: { type: 'array', items: { type: 'string' } },
     deprecated: { type: 'boolean' },
-    security: listOf('SecurityRequirement'),
-    'x-codeSamples': listOf('XCodeSample'),
-    'x-code-samples': listOf('XCodeSample'), // deprecated
+    security: 'SecurityRequirementList',
+    'x-codeSamples': 'XCodeSampleList',
+    'x-code-samples': 'XCodeSampleList', // deprecated
     'x-hideTryItPanel': { type: 'boolean' },
   },
   required: ['responses'],
@@ -371,8 +371,10 @@ const SecurityRequirement: NodeType = {
 export const Oas2Types: Record<string, NodeType> = {
   Root,
   Tag,
+  TagList: listOf('Tag'),
   ExternalDocs,
   SecurityRequirement,
+  SecurityRequirementList: listOf('SecurityRequirement'),
   Info,
   Contact,
   License,
@@ -380,6 +382,7 @@ export const Oas2Types: Record<string, NodeType> = {
   PathItem,
   Parameter,
   ParameterItems,
+  ParameterList: listOf('Parameter'),
   Operation,
   Examples,
   Header,
@@ -394,4 +397,5 @@ export const Oas2Types: Record<string, NodeType> = {
   NamedSecuritySchemes: mapOf('SecurityScheme'),
   SecurityScheme,
   XCodeSample,
+  XCodeSampleList: listOf('XCodeSample'),
 };

package/src/types/oas3.ts

@@ -6,9 +6,9 @@ const Root: NodeType = {
   properties: {
     openapi: null,
     info: 'Info',
-    servers: listOf('Server'),
-    security: listOf('SecurityRequirement'),
-    tags: listOf('Tag'),
+    servers: 'ServerList',
+    security: 'SecurityRequirementList',
+    tags: 'TagList',
     externalDocs: 'ExternalDocs',
     paths: 'Paths',
     components: 'Components',
@@ -102,8 +102,8 @@ const WebhooksMap: NodeType = {
 const PathItem: NodeType = {
   properties: {
     $ref: { type: 'string' }, // TODO: verify special $ref handling for Path Item
-    servers: listOf('Server'),
-    parameters: listOf('Parameter'),
+    servers: 'ServerList',
+    parameters: 'ParameterList',
     summary: { type: 'string' },
     description: { type: 'string' },
     get: 'Operation',
@@ -149,15 +149,15 @@ const Operation: NodeType = {
     description: { type: 'string' },
     externalDocs: 'ExternalDocs',
     operationId: { type: 'string' },
-    parameters: listOf('Parameter'),
-    security: listOf('SecurityRequirement'),
-    servers: listOf('Server'),
+    parameters: 'ParameterList',
+    security: 'SecurityRequirementList',
+    servers: 'ServerList',
     requestBody: 'RequestBody',
     responses: 'Responses',
     deprecated: { type: 'boolean' },
     callbacks: 'CallbacksMap',
-    'x-codeSamples': listOf('XCodeSample'),
-    'x-code-samples': listOf('XCodeSample'), // deprecated
+    'x-codeSamples': 'XCodeSampleList',
+    'x-code-samples': 'XCodeSampleList', // deprecated
     'x-hideTryItPanel': { type: 'boolean' },
   },
   required: ['responses'],
@@ -462,17 +462,21 @@ const SecurityScheme: NodeType = {
 export const Oas3Types: Record<string, NodeType> = {
   Root,
   Tag,
+  TagList: listOf('Tag'),
   ExternalDocs,
   Server,
+  ServerList: listOf('Server'),
   ServerVariable,
   ServerVariablesMap: mapOf('ServerVariable'),
   SecurityRequirement,
+  SecurityRequirementList: listOf('SecurityRequirement'),
   Info,
   Contact,
   License,
   Paths,
   PathItem,
   Parameter,
+  ParameterList: listOf('Parameter'),
   Operation,
   Callback: mapOf('PathItem'),
   CallbacksMap: mapOf('Callback'),
@@ -511,5 +515,6 @@ export const Oas3Types: Record<string, NodeType> = {
   OAuth2Flows,
   SecurityScheme,
   XCodeSample,
+  XCodeSampleList: listOf('XCodeSample'),
   WebhooksMap,
 };

package/src/types/oas3_1.ts

@@ -81,6 +81,7 @@ const Operation: NodeType = {
 const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
+    $anchor: { type: 'string' },
     id: { type: 'string' },
     $schema: { type: 'string' },
     definitions: 'NamedSchemas',