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

package/lib/walk.js

@@ -101,10 +101,9 @@ function walkDocument(opts) {
                         if (!activatedOn.skipped) {
                             visitedBySome = true;
                             enteredContexts.add(context);
-                            const ignoreNextVisitorsOnNode = visitWithContext(visit, resolvedNode, context, ruleId, severity);
-                            if (ignoreNextVisitorsOnNode) {
+                            const { ignoreNextVisitorsOnNode } = visitWithContext(visit, resolvedNode, context, ruleId, severity);
+                            if (ignoreNextVisitorsOnNode)
                                 break;
-                            }
                         }
                     }
                 }
@@ -211,17 +210,15 @@ function walkDocument(opts) {
                 key,
                 parentLocations: collectParentsLocations(context),
                 oasVersion: ctx.oasVersion,
-                ignoreNextVisitorsOnNode: () => {
-                    ignoreNextVisitorsOnNode = true;
-                },
+                ignoreNextVisitorsOnNode: () => { ignoreNextVisitorsOnNode = true; },
                 getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
             }, collectParents(context), context);
-            return ignoreNextVisitorsOnNode;
+            return { ignoreNextVisitorsOnNode };
         }
         function resolve(ref, from = currentLocation.source.absoluteRef) {
             if (!ref_utils_1.isRef(ref))
                 return { location, node: ref };
-            const refId = from + '::' + ref.$ref;
+            const refId = resolve_1.makeRefId(from, ref.$ref);
             const resolvedRef = resolvedRefMap.get(refId);
             if (!resolvedRef) {
                 return {

package/package.json

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

package/src/bundle.ts

@@ -1,5 +1,5 @@
 import isEqual = require('lodash.isequal');
-import { BaseResolver, resolveDocument, Document } from './resolve';
+import { BaseResolver, resolveDocument, Document, ResolvedRefMap, makeRefId } from './resolve';
 import { Oas3Rule, normalizeVisitors, Oas3Visitor, Oas2Visitor } from './visitors';
 import { Oas3Types } from './types/oas3';
 import { Oas2Types } from './types/oas2';
@@ -14,6 +14,8 @@ import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';
 import { OasRef } from './typings/openapi';
 import { isRedoclyRegistryURL } from './redocly';
+import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from './rules/oas2/remove-unused-components';
+import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from './rules/oas3/remove-unused-components';
 
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 
@@ -31,6 +33,7 @@ export async function bundle(opts: {
   dereference?: boolean;
   base?: string;
   skipRedoclyRegistryRefs?: boolean;
+  removeUnusedComponents?: boolean;
 }) {
   const {
     ref,
@@ -66,6 +69,7 @@ export async function bundleDocument(opts: {
   externalRefResolver: BaseResolver;
   dereference?: boolean;
   skipRedoclyRegistryRefs?: boolean;
+  removeUnusedComponents?: boolean;
 }) {
   const {
     document,
@@ -74,6 +78,7 @@ export async function bundleDocument(opts: {
     externalRefResolver,
     dereference = false,
     skipRedoclyRegistryRefs = false,
+    removeUnusedComponents = false,
   } = opts;
   const oasVersion = detectOpenAPI(document.parsed);
   const oasMajorVersion = openAPIMajor(oasVersion);
@@ -92,6 +97,7 @@ export async function bundleDocument(opts: {
 
   const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
   const decorators = initRules(rules as any, config, 'decorators', oasVersion);
+
   const ctx: BundleContext = {
     problems: [],
     oasVersion: oasVersion,
@@ -99,25 +105,35 @@ export async function bundleDocument(opts: {
     visitorsData: {},
   };
 
+  if (removeUnusedComponents) {
+    decorators.push({
+      severity: 'error',
+      ruleId: 'remove-unused-components',
+      visitor: oasMajorVersion === OasMajorVersion.Version2
+        ? RemoveUnusedComponentsOas2({})
+        : RemoveUnusedComponentsOas3({})
+    })
+  }
+
+  const resolvedRefMap = await resolveDocument({
+    rootDocument: document,
+    rootType: types.DefinitionRoot,
+    externalRefResolver,
+  });
+
   const bundleVisitor = normalizeVisitors(
     [
       ...preprocessors,
       {
         severity: 'error',
         ruleId: 'bundler',
-        visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document),
+        visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap),
       },
       ...decorators,
     ],
     types,
   );
 
-  const resolvedRefMap = await resolveDocument({
-    rootDocument: document,
-    rootType: types.DefinitionRoot,
-    externalRefResolver,
-  });
-
   walkDocument({
     document,
     rootType: types.DefinitionRoot as NormalizedNodeType,
@@ -136,7 +152,7 @@ export async function bundleDocument(opts: {
   };
 }
 
-function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
+export function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
   switch (version) {
     case OasMajorVersion.Version3:
       switch (typeName) {
@@ -182,6 +198,7 @@ function makeBundleVisitor(
   dereference: boolean,
   skipRedoclyRegistryRefs: boolean,
   rootDocument: Document,
+  resolvedRefMap: ResolvedRefMap
 ) {
   let components: Record<string, Record<string, any>>;
 
@@ -214,6 +231,7 @@ function makeBundleVisitor(
             replaceRef(node, resolved, ctx);
           } else {
             node.$ref = saveComponent(componentType, resolved, ctx);
+            resolveBundledComponent(node, resolved, ctx);
           }
         }
       },
@@ -251,6 +269,17 @@ function makeBundleVisitor(
     };
   }
 
+  function resolveBundledComponent(node: OasRef, resolved: ResolveResult<any>, ctx: UserContext) {
+    const newRefId = makeRefId(ctx.location.source.absoluteRef, node.$ref)
+    resolvedRefMap.set(newRefId, {
+      document: rootDocument,
+      isRemote: false,
+      node: resolved.node,
+      nodePointer: node.$ref,
+      resolved: true,
+    });
+  }
+
   function replaceRef(ref: OasRef, resolved: ResolveResult<any>, ctx: UserContext) {
     if (!isPlainObject(resolved.node)) {
       ctx.parent[ctx.key] = resolved.node;

package/src/config/config.ts

@@ -38,10 +38,9 @@ export type PreprocessorConfig =
   | ProblemSeverity
   | 'off'
   | 'on'
-  | {
+  | ({
       severity?: ProblemSeverity;
-      options?: Record<string, any>;
-    };
+    } & Record<string, any>);
 
 export type DecoratorConfig = PreprocessorConfig;
 

package/src/format/format.ts

@@ -46,7 +46,7 @@ function severityToNumber(severity: ProblemSeverity) {
   return severity === 'error' ? 1 : 2;
 }
 
-export type OutputFormat = 'codeframe' | 'stylish' | 'json';
+export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle';
 
 export function getTotals(problems: (NormalizedProblem & { ignored?: boolean })[]): Totals {
   let errors = 0;
@@ -111,7 +111,7 @@ export function formatProblems(
         process.stderr.write(`${formatCodeframe(problem, i)}\n`);
       }
       break;
-    case 'stylish':
+    case 'stylish': {
       const groupedByFile = groupByFiles(problems);
       for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(
         groupedByFile,
@@ -126,6 +126,22 @@ export function formatProblems(
         process.stderr.write('\n');
       }
       break;
+    }
+    case 'checkstyle': {
+      const groupedByFile = groupByFiles(problems);
+
+      process.stdout.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+      process.stdout.write('<checkstyle version="4.3">\n');
+
+      for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+        process.stdout.write(`<file name="${xmlEscape(path.relative(cwd, file))}">\n`);
+        fileProblems.forEach(formatCheckstyle);
+        process.stdout.write(`</file>\n`);
+      }
+
+      process.stdout.write(`</checkstyle>\n`);
+      break;
+    }
   }
 
   if (totalProblems - ignoredProblems > maxProblems) {
@@ -204,6 +220,16 @@ export function formatProblems(
       locationPad,
     )}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;
   }
+
+  function formatCheckstyle(problem: OnlyLineColProblem) {
+    const { line, col } = problem.location[0].start;
+    const severity = problem.severity == 'warn' ? 'warning' : 'error';
+    const message = xmlEscape(problem.message);
+    const source = xmlEscape(problem.ruleId);
+    process.stdout.write(
+      `<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`,
+    );
+  }
 }
 
 function formatFrom(cwd: string, location?: LocationObject) {
@@ -261,3 +287,22 @@ const groupByFiles = (problems: NormalizedProblem[]) => {
 
   return fileGroups;
 };
+
+function xmlEscape(s: string): string {
+  return s.replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, (char) => {
+    switch (char) {
+      case '<':
+        return '&lt;';
+      case '>':
+        return '&gt;';
+      case '&':
+        return '&amp;';
+      case '"':
+        return '&quot;';
+      case "'":
+        return '&apos;';
+      default:
+        return `&#${char.charCodeAt(0)};`;
+    }
+  });
+}

package/src/index.ts

@@ -47,4 +47,4 @@ export {
 export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
 export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
 export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
-export { bundle, bundleDocument } from './bundle';
+export { bundle, bundleDocument, mapTypeToComponent } from './bundle';

package/src/resolve.ts

@@ -74,6 +74,10 @@ export type Document = {
   parsed: any;
 };
 
+export function makeRefId(absoluteRef: string, pointer: string) {
+  return absoluteRef + '::' + pointer;
+}
+
 export function makeDocumentFromString(sourceString: string, absoluteRef: string) {
   const source = new Source(absoluteRef, sourceString);
   try {
@@ -323,10 +327,8 @@ export async function resolveDocument(opts: {
           document: undefined,
           error: error,
         };
-
-        const refId = document.source.absoluteRef + '::' + ref.$ref;
+        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
         resolvedRefMap.set(refId, resolvedRef);
-
         return resolvedRef;
       }
 
@@ -367,13 +369,11 @@ export async function resolveDocument(opts: {
 
       resolvedRef.node = target;
       resolvedRef.document = targetDoc;
-      const refId = document.source.absoluteRef + '::' + ref.$ref;
-
+      const refId = makeRefId(document.source.absoluteRef, ref.$ref);
       if (resolvedRef.document && isRef(target)) {
         resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
       }
       resolvedRefMap.set(refId, resolvedRef);
-
       return { ...resolvedRef };
     }
   }

package/src/rules/__tests__/config.ts

@@ -1,10 +1,11 @@
-import { LintConfig, RuleConfig } from "../../config/config";
+import { DecoratorConfig, LintConfig, RuleConfig } from '../../config/config';
 import { defaultPlugin } from '../../config/builtIn';
 
-export function makeConfig(rules: Record<string, RuleConfig>) {
+export function makeConfig(rules: Record<string, RuleConfig>, decorators?:  Record<string, DecoratorConfig>) {
   return new LintConfig({
     plugins: [defaultPlugin],
     extends: [],
-    rules
+    rules,
+    decorators,
   });
-}
+}

package/src/rules/__tests__/hide-internals.test.ts

@@ -0,0 +1,317 @@
+import { outdent } from 'outdent';
+import { bundleDocument } from '../../bundle';
+import { BaseResolver } from '../../resolve';
+import { parseYamlToDocument, yamlSerializer } from '../../../__tests__/utils';
+import { makeConfig } from './config';
+
+describe('oas3 remove-x-internal', () => {
+  expect.addSnapshotSerializer(yamlSerializer);
+  const testDocument = parseYamlToDocument(
+    outdent`
+      openapi: 3.0.0
+      paths:
+        /pet:
+          removeit: true
+          get:
+            parameters:
+              - $ref: '#/components/parameters/x'
+      components:
+        parameters:
+          x:
+            name: x
+    `,
+  );
+
+  it('should use `internalFlagProperty` option to remove internal paths', async () => {
+    const { bundle: res } = await bundleDocument({
+      document: testDocument,
+      externalRefResolver: new BaseResolver(),
+      config: makeConfig({}, { 'remove-x-internal': { internalFlagProperty: 'removeit' } }),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+          openapi: 3.0.0
+          components:
+            parameters:
+              x:
+                name: x
+
+        `);
+  });
+
+  it('should clean types: Server, Operation, Parameter, PathItem, Example', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.0
+        servers:
+          - url: //petstore.swagger.io/v2
+            description: Default server
+            x-internal: true
+        paths:
+          /pet:
+            get:
+              x-internal: true
+              operationId: getPet
+              parameters:
+                - $ref: '#/components/parameters/x'
+            put:
+              parameters:
+                - name: Accept-Language
+                  x-internal: true
+                  in: header
+                  example: en-US
+                  required: false
+                - name: cookieParam
+                  x-internal: true
+                  in: cookie
+                  description: Some cookie
+                  required: true
+          /admin:
+            x-internal: true
+            post:
+              parameters:
+                - $ref: '#/components/parameters/y'
+          /store/order:
+            post:
+              operationId: placeOrder
+              responses:
+                '200':
+                  description: successful operation
+                  content:
+                    application/json:
+                      examples:
+                        response:
+                          x-internal: true
+                          value: OK
+        components:
+          parameters:
+            x:
+              name: x
+            y:
+              name: y
+      `,
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.1.0
+      paths:
+        /pet:
+          put: {}
+        /store/order:
+          post:
+            operationId: placeOrder
+            responses:
+              '200':
+                description: successful operation
+                content:
+                  application/json: {}
+      components:
+        parameters:
+          x:
+            name: x
+          'y':
+            name: 'y'
+
+      `);
+  });
+
+  it('should clean types: Schema, Response, RequestBody, MediaType, Callback', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.0
+        paths:
+          /pet:
+            post:
+              summary: test
+              requestBody:
+                x-internal: true
+                content:
+                  application/x-www-form-urlencoded:
+                    schema:
+                      type: object
+          /store/order:
+            post:
+              operationId: storeOrder
+              parameters:
+                - name: api_key
+                  schema:
+                    x-internal: true
+                    type: string
+              responses:
+                '200':
+                  x-internal: true
+                  content:
+                    application/json:
+                      examples:
+                        response:
+                          value: OK
+              requestBody:
+                content:
+                  application/x-www-form-urlencoded:
+                    x-internal: true
+                    schema:
+                      type: object
+              callbacks:
+                orderInProgress:
+                  x-internal: true
+                  '{$request.body#/callbackUrl}?event={$request.body#/eventName}':
+                    servers:
+                      - url: //callback-url.path-level/v1
+                        description: Path level server
+      `,
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+    });
+
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.1.0
+      paths:
+        /pet:
+          post:
+            summary: test
+        /store/order:
+          post:
+            operationId: storeOrder
+            parameters:
+              - name: api_key
+            requestBody: {}
+      components: {}
+
+      `);
+  });
+
+  it('should remove refs', async () => {
+    const testDoc = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.1
+        info:
+          version: 1.0.0
+          title: Test API
+        paths:
+          /test1:
+            get:
+              parameters:
+                - $ref: '#/components/parameters/Internal'
+                - in: query
+                  name: inline
+                  schema:
+                    type: string
+                - in: query
+                  name: inline-internal
+                  schema:
+                    type: string
+                  x-internal: true
+          /test2:
+            get:
+              parameters:
+                - $ref: '#/components/parameters/Public'
+                - $ref: '#/components/parameters/Internal'
+              requestBody:
+                $ref: '#/components/requestBodies/Public'
+        components:
+          requestBodies:
+            Public:
+              content:
+                application/json:
+                  schema:
+                    type: string
+              required: true
+              x-internal: true
+          parameters:
+            Public:
+              in: path
+              name: product_id
+              schema:
+                type: string
+            Internal:
+              in: header
+              name: X-Vendor
+              schema:
+                type: string
+              x-internal: true
+      `,
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+      openapi: 3.0.1
+      info:
+        version: 1.0.0
+        title: Test API
+      paths:
+        /test1:
+          get:
+            parameters:
+              - in: query
+                name: inline
+                schema:
+                  type: string
+        /test2:
+          get:
+            parameters:
+              - $ref: '#/components/parameters/Public'
+      components:
+        parameters:
+          Public:
+            in: path
+            name: product_id
+            schema:
+              type: string
+
+    `);
+  });
+});
+
+describe('oas2 remove-x-internal', () => {
+  it('should clean types - base test', 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-internal: true
+                  in: path
+                  name: geo-id
+                  required: true
+                  type: string
+                - description: Max number of media to return.
+                  x-internal: true
+                  format: int32
+                  in: query
+                  name: count
+                  required: false
+                  type: integer
+              responses:
+                '200':
+                  x-internal: true
+                  description: List of recent media entries.
+      `,
+    );
+    const { bundle: res } = await bundleDocument({
+      document: testDoc,
+      externalRefResolver: new BaseResolver(),
+      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+    });
+    expect(res.parsed).toMatchInlineSnapshot(`
+          swagger: '2.0'
+          host: api.instagram.com
+          paths:
+            /geographies/{geo-id}/media/recent:
+              get: {}
+
+        `);
+  });
+});