@redocly/openapi-core 1.0.0-beta.101 → 1.0.0-beta.104

package/lib/walk.js

@@ -32,6 +32,26 @@ function walkDocument(opts) {
     walkNode(document.parsed, rootType, new ref_utils_1.Location(document.source, '#/'), undefined, '');
     function walkNode(node, type, location, parent, key) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const resolve = (ref, from = currentLocation.source.absoluteRef) => {
+            if (!ref_utils_1.isRef(ref))
+                return { location, node: ref };
+            const refId = resolve_1.makeRefId(from, ref.$ref);
+            const resolvedRef = resolvedRefMap.get(refId);
+            if (!resolvedRef) {
+                return {
+                    location: undefined,
+                    node: undefined,
+                };
+            }
+            const { resolved, node, document, nodePointer, error } = resolvedRef;
+            const newLocation = resolved
+                ? new ref_utils_1.Location(document.source, nodePointer)
+                : error instanceof resolve_1.YamlParseError
+                    ? new ref_utils_1.Location(error.source, '')
+                    : undefined;
+            return { location: newLocation, node, error };
+        };
+        const rawLocation = location;
         let currentLocation = location;
         const { node: resolvedNode, location: resolvedLocation, error } = resolve(node);
         const enteredContexts = new Set();
@@ -44,13 +64,15 @@ function walkDocument(opts) {
                     visitor(node, {
                         report,
                         resolve,
+                        rawNode: node,
+                        rawLocation,
                         location,
                         type,
                         parent,
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
-                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
                     }, { node: resolvedNode, location: resolvedLocation, error });
                     if ((resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef) && ctx.refTypes) {
                         ctx.refTypes.set(resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef, type);
@@ -101,7 +123,7 @@ function walkDocument(opts) {
                         if (!activatedOn.skipped) {
                             visitedBySome = true;
                             enteredContexts.add(context);
-                            const { ignoreNextVisitorsOnNode } = visitWithContext(visit, resolvedNode, context, ruleId, severity);
+                            const { ignoreNextVisitorsOnNode } = visitWithContext(visit, resolvedNode, node, context, ruleId, severity);
                             if (ignoreNextVisitorsOnNode)
                                 break;
                         }
@@ -173,7 +195,7 @@ function walkDocument(opts) {
             }
             for (const { context, visit, ruleId, severity } of currentLeaveVisitors) {
                 if (!context.isSkippedLevel && enteredContexts.has(context)) {
-                    visitWithContext(visit, resolvedNode, context, ruleId, severity);
+                    visitWithContext(visit, resolvedNode, node, context, ruleId, severity);
                 }
             }
         }
@@ -186,54 +208,41 @@ function walkDocument(opts) {
                     visitor(node, {
                         report,
                         resolve,
+                        rawNode: node,
+                        rawLocation,
                         location,
                         type,
                         parent,
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
-                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
                     }, { node: resolvedNode, location: resolvedLocation, error });
                 }
             }
         }
         // returns true ignores all the next visitors on the specific node
-        function visitWithContext(visit, node, context, ruleId, severity) {
+        function visitWithContext(visit, resolvedNode, node, context, ruleId, severity) {
             const report = reportFn.bind(undefined, ruleId, severity);
             let ignoreNextVisitorsOnNode = false;
-            visit(node, {
+            visit(resolvedNode, {
                 report,
                 resolve,
+                rawNode: node,
                 location: currentLocation,
+                rawLocation,
                 type,
                 parent,
                 key,
                 parentLocations: collectParentsLocations(context),
                 oasVersion: ctx.oasVersion,
-                ignoreNextVisitorsOnNode: () => { ignoreNextVisitorsOnNode = true; },
+                ignoreNextVisitorsOnNode: () => {
+                    ignoreNextVisitorsOnNode = true;
+                },
                 getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
             }, collectParents(context), context);
             return { ignoreNextVisitorsOnNode };
         }
-        function resolve(ref, from = currentLocation.source.absoluteRef) {
-            if (!ref_utils_1.isRef(ref))
-                return { location, node: ref };
-            const refId = resolve_1.makeRefId(from, ref.$ref);
-            const resolvedRef = resolvedRefMap.get(refId);
-            if (!resolvedRef) {
-                return {
-                    location: undefined,
-                    node: undefined,
-                };
-            }
-            const { resolved, node, document, nodePointer, error } = resolvedRef;
-            const newLocation = resolved
-                ? new ref_utils_1.Location(document.source, nodePointer)
-                : error instanceof resolve_1.YamlParseError
-                    ? new ref_utils_1.Location(error.source, '')
-                    : undefined;
-            return { location: newLocation, node, error };
-        }
         function reportFn(ruleId, severity, opts) {
             const loc = opts.location
                 ? Array.isArray(opts.location)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.101",
+  "version": "1.0.0-beta.104",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -16,7 +16,8 @@
     "fs": false,
     "path": "path-browserify",
     "os": false,
-    "node-fetch": false
+    "node-fetch": false,
+    "colorette": false
   },
   "homepage": "https://github.com/Redocly/redocly-cli",
   "keywords": [

package/src/__tests__/lint.test.ts

@@ -85,7 +85,7 @@ describe('lint', () => {
             },
           ],
           "message": "Expected type \`ConfigApis\` (object) but got \`string\`",
-          "ruleId": "spec",
+          "ruleId": "configuration spec",
           "severity": "error",
           "suggest": Array [],
         },
@@ -97,8 +97,8 @@ describe('lint', () => {
               "source": "",
             },
           ],
-          "message": "Expected type \`string\` but got \`object\`.",
-          "ruleId": "spec",
+          "message": "\`layout\` can be one of the following only: \\"stacked\\", \\"three-panel\\".",
+          "ruleId": "configuration spec",
           "severity": "error",
           "suggest": Array [],
         },
@@ -123,6 +123,19 @@ describe('lint', () => {
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
       Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/apis/lint",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "The field \`root\` must be present on this level.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
         Object {
           "location": Array [
             Object {
@@ -132,7 +145,7 @@ describe('lint', () => {
             },
           ],
           "message": "Property \`plugins\` is not expected here.",
-          "ruleId": "spec",
+          "ruleId": "configuration spec",
           "severity": "error",
           "suggest": Array [],
         },

package/src/config/__tests__/load.test.ts

@@ -44,6 +44,12 @@ describe('loadConfig', () => {
       },
     ]);
   });
+
+  it('should call callback if such passed', async () => {
+    const mockFn = jest.fn();
+    await loadConfig(undefined, undefined, mockFn);
+    expect(mockFn).toHaveBeenCalled();
+  });
 });
 
 describe('findConfig', () => {

package/src/config/load.ts

@@ -8,11 +8,16 @@ import { resolveConfig } from './config-resolvers';
 
 import type { RawConfig, Region } from './types';
 
-export async function loadConfig(
-  configPath: string | undefined = findConfig(),
-  customExtends?: string[],
-): Promise<Config> {
-  const rawConfig = await getConfig(configPath);
+async function addConfigMetadata({
+  rawConfig,
+  customExtends,
+  configPath
+}: {
+  rawConfig: RawConfig;
+  customExtends?: string[];
+  configPath?: string;
+  
+}): Promise<Config> {
   if (customExtends !== undefined) {
     rawConfig.lint = rawConfig.lint || {};
     rawConfig.lint.extends = customExtends;
@@ -56,6 +61,24 @@ export async function loadConfig(
   return resolveConfig(rawConfig, configPath);
 }
 
+export async function loadConfig(
+  configPath: string | undefined = findConfig(),
+  customExtends?: string[],
+  processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>,
+): Promise<Config> {
+  const rawConfig = await getConfig(configPath);
+
+  if (typeof processRawConfig === 'function') {
+    await processRawConfig(rawConfig);
+  }
+
+  return await addConfigMetadata({
+    rawConfig,
+    customExtends,
+    configPath,
+  });
+};
+
 export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
 
 export function findConfig(dir?: string): string | undefined {

package/src/config/types.ts

@@ -11,17 +11,18 @@ import type {
 } from '../oas-types';
 import type { NodeType } from '../types';
 
+export type RuleSeverity = ProblemSeverity | 'off';
+
+export type PreprocessorSeverity = RuleSeverity | 'on';
+
 export type RuleConfig =
-  | ProblemSeverity
-  | 'off'
+  | RuleSeverity
   | ({
       severity?: ProblemSeverity;
     } & Record<string, any>);
 
 export type PreprocessorConfig =
-  | ProblemSeverity
-  | 'off'
-  | 'on'
+  | PreprocessorSeverity
   | ({
       severity?: ProblemSeverity;
     } & Record<string, any>);

package/src/decorators/__tests__/filter-in.test.ts

@@ -0,0 +1,310 @@
+import { outdent } from 'outdent';
+import { bundleDocument } from '../../bundle';
+import { BaseResolver } from '../../resolve';
+import { makeConfig, parseYamlToDocument, yamlSerializer } from '../../../__tests__/utils';
+
+describe('oas3 filter-in', () => {
+  expect.addSnapshotSerializer(yamlSerializer);
+
+  const inputDoc = parseYamlToDocument(
+    outdent`
+        openapi: 3.0.0
+        paths:
+          /pet:
+            x-audience: Global
+            post:
+              summary: test
+          /user:
+            x-audience: [Public, Global]
+            post:
+              summary: test
+          /post:
+            get:
+              summary: test                        
+          /order:
+            x-audience: [Public, Protected]
+            post:
+              operationId: storeOrder
+              callbacks:
+                x-access: protected`
+  );
+
+  it('should include /user path and remove y parameter', async () => {
+    const testDocument = parseYamlToDocument(
+      outdent`
+      openapi: 3.0.0
+      paths:
+        /pet:
+          x-access: private
+          get:
+            parameters:
+              - $ref: '#/components/parameters/x'
+        /user:
+          x-access: public
+          get:
+            parameters:
+              - $ref: '#/components/parameters/y'      
+      components:
+        parameters:
+          x:
+            name: x
+          y:
+            x-access: private
+            name: y            
+    `
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDocument,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig({}, { 'filter-in': { value: 'public', property: 'x-access' } }),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.0
+      paths:
+        /user:
+          x-access: public
+          get: {}
+      components:
+        parameters:
+          x:
+            name: x
+
+    `);
+  });
+
+  it('should include /order and /post paths', async () => {
+    const { bundle: res } = await bundleDocument({
+      document: inputDoc,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig(
+        {},
+        {
+          'filter-in': {
+            property: 'x-audience',
+            value: ['Public', 'Protected'],
+            matchStrategy: 'all',
+          },
+        }
+      ),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.0
+      paths:
+        /post:
+          get:
+            summary: test
+        /order:
+          x-audience:
+            - Public
+            - Protected
+          post:
+            operationId: storeOrder
+            callbacks:
+              x-access: protected
+      components: {}
+
+    `);
+  });
+
+  it('should include all paths', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          /pet:
+            x-audience: Global
+            post:
+              summary: test
+          /user:
+            x-audience: [Public, Global]
+            post:
+              summary: test            
+          /order:
+            x-audience: [Public, Protected]
+            post:
+              operationId: storeOrder
+              parameters:
+                - name: api_key
+                 `
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig(
+        {},
+        {
+          'filter-in': {
+            property: 'x-audience',
+            value: ['Public', 'Global'],
+            matchStrategy: 'any',
+          },
+        }
+      ),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.0
+      paths:
+        /pet:
+          x-audience: Global
+          post:
+            summary: test
+        /user:
+          x-audience:
+            - Public
+            - Global
+          post:
+            summary: test
+        /order:
+          x-audience:
+            - Public
+            - Protected
+          post:
+            operationId: storeOrder
+            parameters:
+              - name: api_key
+      components: {}
+
+    `);
+  });
+
+  it('should include path without x-audience property ', async () => {
+    const { bundle: res } = await bundleDocument({
+      document: inputDoc,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig(
+        {},
+        {
+          'filter-in': {
+            property: 'x-audience',
+            value: 'non-existing-audience',
+            matchStrategy: 'any',
+          },
+        }
+      ),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.0
+      paths:
+        /post:
+          get:
+            summary: test
+      components: {}
+
+    `);
+  });
+
+  it('should include /pet and /account without post method', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          /pet:
+            x-audience: Global
+            post:
+              summary: test
+          /user:
+            x-audience: Private
+            post:
+              summary: test
+            get:
+               summary: get
+               x-audience: [Public, Global]
+          /account:
+            get:
+               summary: get
+            post: 
+               summary: test
+               x-audience: Private     
+                 `
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig(
+        {},
+        {
+          'filter-in': {
+            property: 'x-audience',
+            value: ['Public', 'Global'],
+            matchStrategy: 'any',
+          },
+        }
+      ),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.0
+      paths:
+        /pet:
+          x-audience: Global
+          post:
+            summary: test
+        /account:
+          get:
+            summary: get
+      components: {}
+
+    `);
+  });
+});
+
+describe('oas2 filter-in', () => {
+  it('should include only one parameter and not include response', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        swagger: '2.0'
+        host: api.instagram.com
+        paths:
+          '/geographies/{geo-id}/media/recent':
+            get:
+              parameters:
+                - description: The geography ID.
+                  x-access: private
+                  in: path
+                  name: geo-id
+                  required: true
+                  type: string
+                - description: Max number of media to return.
+                  x-access: public
+                  format: int32
+                  in: query
+                  name: count
+                  required: false
+                  type: integer
+              responses:
+                '200':
+                  description: List of recent media entries.
+                  x-access: [private, protected]
+      `
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: await makeConfig(
+        {},
+        {
+          'filter-in': {
+            property: 'x-access',
+            value: ['public', 'global'],
+            matchStrategy: 'any',
+          },
+        }
+      ),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      swagger: '2.0'
+      host: api.instagram.com
+      paths:
+        /geographies/{geo-id}/media/recent:
+          get:
+            parameters:
+              - description: Max number of media to return.
+                x-access: public
+                format: int32
+                in: query
+                name: count
+                required: false
+                type: integer
+
+    `);
+  });
+});