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

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,11 +77,7 @@ export async function loadConfig(
   } = {}
 ): Promise<Config> {
   const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-  const config = await getConfig(configPath);
-  const rawConfig = { ...config, files: files ?? config.files, region: region ?? config.region };
-  if (typeof processRawConfig === 'function') {
-    await processRawConfig(rawConfig);
-  }
+  const rawConfig = await getConfig(configPath, processRawConfig);
 
   const redoclyClient = new RedoclyClient();
   const tokens = await redoclyClient.getTokens();
@@ -85,6 +87,8 @@ export async function loadConfig(
     customExtends,
     configPath,
     tokens,
+    files,
+    region,
   });
 }
 
@@ -105,11 +109,17 @@ export function findConfig(dir?: string): string | undefined {
   return existingConfigFiles[0];
 }
 
-export async function getConfig(configPath: string | undefined = findConfig()): Promise<RawConfig> {
+export async function getConfig(
+  configPath: string | undefined = findConfig(),
+  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>
+): Promise<RawConfig> {
   if (!configPath || !doesYamlFileExist(configPath)) return {};
   try {
     const rawConfig =
       (await loadYaml<RawConfig & DeprecatedInRawConfig & FlatRawConfig>(configPath)) || {};
+    if (typeof processRawConfig === 'function') {
+      await processRawConfig(rawConfig);
+    }
     return transformConfig(rawConfig);
   } catch (e) {
     throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);

package/src/config/minimal.ts

@@ -2,7 +2,6 @@ import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
-    'info-description': 'warn',
     'info-contact': 'off',
     'info-license': 'off',
     'info-license-url': 'off',

package/src/config/recommended.ts

@@ -2,7 +2,6 @@ import type { PluginStyleguideConfig } from './types';
 
 export default {
   rules: {
-    'info-description': 'warn',
     'info-contact': 'off',
     'info-license': 'warn',
     'info-license-url': 'warn',

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/assertions/__tests__/asserts.test.ts

@@ -1,6 +1,6 @@
 import { Location } from '../../../../ref-utils';
 import { Source } from '../../../../resolve';
-import { asserts, buildAssertCustomFunction } from '../asserts';
+import { Asserts, asserts, buildAssertCustomFunction } from '../asserts';
 
 let baseLocation = new Location(jest.fn() as any as Source, 'pointer');
 
@@ -674,9 +674,13 @@ describe('oas3 assertions', () => {
           }
           return [];
         });
-        asserts['local/customFn'] = buildAssertCustomFunction(customFn);
+        asserts['local/customFn' as keyof Asserts] = buildAssertCustomFunction(customFn);
         expect(
-          asserts['local/customFn'](Object.keys(fakeNode), { word: 'foo' }, baseLocation)
+          asserts['local/customFn' as keyof Asserts](
+            Object.keys(fakeNode),
+            { word: 'foo' },
+            baseLocation
+          )
         ).toEqual([
           {
             message: 'First value should be foo',

package/src/rules/common/assertions/__tests__/index.test.ts

@@ -1,61 +1,82 @@
-import { Assertions } from '../.';
+import { Assertion, Assertions } from '../.';
 
 const opts = {
   '0': {
-    subject: 'Operation',
-    property: 'summary',
+    subject: {
+      type: 'Operation',
+      property: 'summary',
+    },
     description: 'example warn text',
     severity: 'warn',
-    pattern: '/example/',
+    assertions: { pattern: '/example/' },
   },
   '1': {
-    subject: 'PathItem',
-    context: [{ type: 'Operation', matchParentKeys: ['post'] }],
+    subject: {
+      type: 'PathItem',
+    },
+    where: [
+      {
+        subject: { type: 'Operation', filterInParentKeys: ['post'], property: 'responses' },
+        assertions: { defined: true },
+      },
+    ],
     description: 'example warn text',
     severity: 'warn',
-    mutuallyExclusive: ['summary', 'security'],
+    assertions: { mutuallyExclusive: ['summary', 'security'] },
   },
   '2': {
-    subject: ['PathItem'],
-    context: [{ type: 'Operation' }],
-    property: 'tags',
+    subject: { type: 'PathItem', property: 'tags' },
+    where: [
+      { subject: { type: 'Operation', property: 'responses' }, assertions: { defined: true } },
+    ],
     description: 'example warn text',
     severity: 'warn',
-    sortOrder: 'desc',
+    assertions: { sortOrder: 'desc' },
   },
   '3': {
-    subject: ['Foo'],
-    context: [{ type: 'Bar' }, { type: 'Baz' }],
-    property: 'test',
+    subject: { type: 'Foo', property: 'test' },
+    where: [
+      { subject: { type: 'Bar' }, assertions: {} },
+      { subject: { type: 'Baz' }, assertions: {} },
+    ],
     description: 'example warn text',
     severity: 'warn',
-    sortOrder: 'desc',
+    assertions: { sortOrder: 'desc' },
   },
 };
 
 describe('Oas3 assertions', () => {
   it('should return the right visitor structure', () => {
-    const visitors = Assertions(opts) as any;
+    const visitors = Assertions(opts as any);
     expect(visitors).toMatchInlineSnapshot(`
       Array [
         Object {
-          "Operation": [Function],
+          "Operation": Object {
+            "enter": [Function],
+          },
         },
         Object {
           "Operation": Object {
-            "PathItem": [Function],
+            "PathItem": Object {
+              "enter": [Function],
+            },
             "skip": [Function],
           },
         },
         Object {
           "Operation": Object {
-            "PathItem": [Function],
+            "PathItem": Object {
+              "enter": [Function],
+            },
+            "skip": [Function],
           },
         },
         Object {
           "Bar": Object {
             "Baz": Object {
-              "Foo": [Function],
+              "Foo": Object {
+                "enter": [Function],
+              },
             },
           },
         },

package/src/rules/common/assertions/__tests__/utils.test.ts

@@ -1,3 +1,4 @@
+import { Assertion, AssertionDefinition } from '..';
 import { isOrdered, buildVisitorObject, getIntersectionLength } from '../utils';
 
 describe('Oas3 assertions', () => {
@@ -25,29 +26,43 @@ describe('Oas3 assertions', () => {
 
     describe('buildVisitorObject', () => {
       it('should return a consistent visitor structure', () => {
-        const context = [
+        const where: AssertionDefinition[] = [
           {
-            type: 'Foo',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Foo',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
           {
-            type: 'Bar',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Bar',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
           {
-            type: 'Roof',
-            matchParentKeys: ['test'],
+            subject: {
+              type: 'Roof',
+              filterInParentKeys: ['test'],
+            },
+            assertions: {},
           },
-        ];
+        ] as AssertionDefinition[];
 
-        const visitors = buildVisitorObject('Bar', context, () => {}) as any;
+        const visitors = buildVisitorObject(
+          { subject: { type: 'Bar' }, where, assertions: {} } as Assertion,
+          () => {}
+        );
 
         expect(visitors).toMatchInlineSnapshot(`
           Object {
             "Foo": Object {
               "Bar": Object {
                 "Roof": Object {
-                  "Bar": [Function],
+                  "Bar": Object {
+                    "enter": [Function],
+                  },
                   "skip": [Function],
                 },
                 "skip": [Function],
@@ -59,24 +74,35 @@ describe('Oas3 assertions', () => {
       });
 
       it('should return the right visitor structure', () => {
-        const context = [
+        const where = [
           {
-            type: 'Operation',
-            matchParentKeys: ['put'],
+            subject: {
+              type: 'Operation',
+              filterInParentKeys: ['put'],
+            },
+            assertions: {},
           },
           {
-            type: 'Responses',
-            matchParentKeys: [201, 200],
+            subject: {
+              type: 'Responses',
+              filterInParentKeys: [201, 200],
+            },
+            assertions: {},
           },
         ];
 
-        const visitors = buildVisitorObject('MediaTypesMap', context, () => {}) as any;
+        const visitors = buildVisitorObject(
+          { subject: { type: 'MediaTypesMap' }, where, assertions: {} } as Assertion,
+          () => {}
+        );
 
         expect(visitors).toMatchInlineSnapshot(`
           Object {
             "Operation": Object {
               "Responses": Object {
-                "MediaTypesMap": [Function],
+                "MediaTypesMap": Object {
+                  "enter": [Function],
+                },
                 "skip": [Function],
               },
               "skip": [Function],