@redocly/openapi-core 1.10.6 → 1.12.0

package/src/config/load.ts

@@ -20,6 +20,7 @@ async function addConfigMetadata({
   tokens,
   files,
   region,
+  externalRefResolver,
 }: {
   rawConfig: RawConfig;
   customExtends?: string[];
@@ -27,6 +28,7 @@ async function addConfigMetadata({
   tokens?: RegionalTokenWithValidity[];
   files?: string[];
   region?: Region;
+  externalRefResolver?: BaseResolver;
 }): Promise<Config> {
   if (customExtends !== undefined) {
     rawConfig.styleguide = rawConfig.styleguide || {};
@@ -64,10 +66,15 @@ async function addConfigMetadata({
     }
   }
 
-  return resolveConfig(
-    { ...rawConfig, files: files ?? rawConfig.files, region: region ?? rawConfig.region },
-    configPath
-  );
+  return resolveConfig({
+    rawConfig: {
+      ...rawConfig,
+      files: files ?? rawConfig.files,
+      region: region ?? rawConfig.region,
+    },
+    configPath,
+    externalRefResolver,
+  });
 }
 
 export type RawConfigProcessor = (
@@ -105,6 +112,7 @@ export async function loadConfig(
     tokens,
     files,
     region,
+    externalRefResolver,
   });
 }
 
@@ -156,6 +164,7 @@ type CreateConfigOptions = {
   extends?: string[];
   tokens?: RegionalTokenWithValidity[];
   configPath?: string;
+  externalRefResolver?: BaseResolver;
 };
 
 export async function createConfig(

package/src/config/utils.ts

@@ -173,7 +173,7 @@ export function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]) {
   for (const rulesConf of rulesConfList) {
     if (rulesConf.extends) {
       throw new Error(
-        `'extends' is not supported in shared configs yet: ${JSON.stringify(rulesConf, null, 2)}.`
+        `'extends' is not supported in shared configs yet:\n${JSON.stringify(rulesConf, null, 2)}`
       );
     }
 

package/src/decorators/oas2/__tests__/remove-unused-components.test.ts

@@ -1,5 +1,5 @@
 import { outdent } from 'outdent';
-import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { parseYamlToDocument, makeConfig } from '../../../../__tests__/utils';
 import { bundleDocument } from '../../../bundle';
 import { BaseResolver } from '../../../resolve';
 
@@ -152,4 +152,77 @@ describe('oas2 remove-unused-components', () => {
       },
     });
   });
+
+  it('should remove transitively unused components', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        swagger: '2.0'
+        paths:
+          /pets:
+            get:
+              produces:
+                - application/json
+              parameters: []
+              responses:
+                '200':
+                  schema:
+                    $ref: '#/definitions/Used'
+              operationId: listPets
+              summary: List all pets
+        definitions:
+          Unused:
+            enum:
+              - 1
+              - 2
+            type: integer
+          UnusedTransitive:
+            type: object
+            properties:
+              link:
+                $ref: '#/definitions/Unused'
+          Used:
+            properties:
+              link:
+                type: string
+            type: object
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await bundleDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({}),
+      removeUnusedComponents: true,
+    });
+
+    expect(results.bundle.parsed).toEqual({
+      swagger: '2.0',
+      definitions: {
+        Used: {
+          properties: {
+            link: { type: 'string' },
+          },
+          type: 'object',
+        },
+      },
+      paths: {
+        '/pets': {
+          get: {
+            produces: ['application/json'],
+            parameters: [],
+            summary: 'List all pets',
+            operationId: 'listPets',
+            responses: {
+              '200': {
+                schema: {
+                  $ref: '#/definitions/Used',
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+  });
 });

package/src/decorators/oas2/remove-unused-components.ts

@@ -2,12 +2,12 @@ import { Location } from '../../ref-utils';
 import { isEmptyObject } from '../../utils';
 
 import type { Oas2Decorator } from '../../visitors';
-import type { Oas2Components } from '../../typings/swagger';
+import type { Oas2Components, Oas2Definition } from '../../typings/swagger';
 
 export const RemoveUnusedComponents: Oas2Decorator = () => {
   const components = new Map<
     string,
-    { used: boolean; componentType?: keyof Oas2Components; name: string }
+    { usedIn: Location[]; componentType?: keyof Oas2Components; name: string }
   >();
 
   function registerComponent(
@@ -16,15 +16,46 @@ export const RemoveUnusedComponents: Oas2Decorator = () => {
     name: string
   ): void {
     components.set(location.absolutePointer, {
-      used: components.get(location.absolutePointer)?.used || false,
+      usedIn: components.get(location.absolutePointer)?.usedIn ?? [],
       componentType,
       name,
     });
   }
 
+  function removeUnusedComponents(root: Oas2Definition, removedPaths: string[]): number {
+    const removedLengthStart = removedPaths.length;
+
+    for (const [path, { usedIn, name, componentType }] of components) {
+      const used = usedIn.some(
+        (location) =>
+          !removedPaths.some(
+            (removed) =>
+              // Check if the current location's absolute pointer starts with the 'removed' path
+              // and either its length matches exactly with 'removed' or the character after the 'removed' path is a '/'
+              location.absolutePointer.startsWith(removed) &&
+              (location.absolutePointer.length === removed.length ||
+                location.absolutePointer[removed.length] === '/')
+          )
+      );
+      if (!used && componentType) {
+        removedPaths.push(path);
+        delete root[componentType]![name];
+        components.delete(path);
+
+        if (isEmptyObject(root[componentType])) {
+          delete root[componentType];
+        }
+      }
+    }
+
+    return removedPaths.length > removedLengthStart
+      ? removeUnusedComponents(root, removedPaths)
+      : removedPaths.length;
+  }
+
   return {
     ref: {
-      leave(ref, { type, resolve, key }) {
+      leave(ref, { location, type, resolve, key }) {
         if (['Schema', 'Parameter', 'Response', 'SecurityScheme'].includes(type.name)) {
           const resolvedRef = resolve(ref);
           if (!resolvedRef.location) return;
@@ -33,32 +64,23 @@ export const RemoveUnusedComponents: Oas2Decorator = () => {
           const componentLevelLocalPointer = localPointer.split('/').slice(0, 3).join('/');
           const pointer = `${fileLocation}#${componentLevelLocalPointer}`;
 
-          components.set(pointer, {
-            used: true,
-            name: key.toString(),
-          });
+          const registered = components.get(pointer);
+
+          if (registered) {
+            registered.usedIn.push(location);
+          } else {
+            components.set(pointer, {
+              usedIn: [location],
+              name: key.toString(),
+            });
+          }
         }
       },
     },
     Root: {
       leave(root, ctx) {
         const data = ctx.getVisitorData() as { removedCount: number };
-        data.removedCount = 0;
-
-        const rootComponents = new Set<keyof Oas2Components>();
-        components.forEach((usageInfo) => {
-          const { used, name, componentType } = usageInfo;
-          if (!used && componentType) {
-            rootComponents.add(componentType);
-            delete root[componentType]![name];
-            data.removedCount++;
-          }
-        });
-        for (const component of rootComponents) {
-          if (isEmptyObject(root[component])) {
-            delete root[component];
-          }
-        }
+        data.removedCount = removeUnusedComponents(root, []);
       },
     },
     NamedSchemas: {

package/src/decorators/oas3/__tests__/remove-unused-components.test.ts

@@ -168,4 +168,146 @@ describe('oas3 remove-unused-components', () => {
       },
     });
   });
+
+  it('should remove transitively unused components', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: "3.0.0"
+        paths:
+          /pets:
+            get:
+              summary: List all pets
+              operationId: listPets
+              parameters:
+                - $ref: '#/components/parameters/used'
+        components:
+          parameters:
+            used:
+              name: used
+            unused:
+              name: unused
+          schemas:
+            Unused:
+              type: integer
+              enum:
+                - 1
+                - 2
+            Transitive:
+              type: object
+              properties:
+                link:
+                  $ref: '#/components/schemas/Unused'
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await bundleDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({}),
+      removeUnusedComponents: true,
+    });
+
+    expect(results.bundle.parsed).toEqual({
+      openapi: '3.0.0',
+      paths: {
+        '/pets': {
+          get: {
+            summary: 'List all pets',
+            operationId: 'listPets',
+            parameters: [
+              {
+                $ref: '#/components/parameters/used',
+              },
+            ],
+          },
+        },
+      },
+      components: {
+        parameters: {
+          used: {
+            name: 'used',
+          },
+        },
+      },
+    });
+  });
+
+  it('should remove transitively unused components with colliding paths', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: "3.0.0"
+        paths:
+          /pets:
+            get:
+              responses: 
+                200:
+                  content: 
+                    application/json: 
+                      schema: 
+                        $ref: "#/components/schemas/Transitive2"
+        components:
+          schemas:
+            Unused: # <-- this will be removed correctly
+              type: integer
+            Transitive: # <-- this will be removed correctly
+              type: object
+              properties:
+                link:
+                  $ref: '#/components/schemas/Unused'
+            Used:
+              type: integer
+            Transitive2:
+              type: object
+              properties:
+                link:
+                  $ref: '#/components/schemas/Used'
+        `,
+
+      'foobar.yaml'
+    );
+
+    const results = await bundleDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({}),
+      removeUnusedComponents: true,
+    });
+
+    expect(results.bundle.parsed).toEqual({
+      openapi: '3.0.0',
+      paths: {
+        '/pets': {
+          get: {
+            responses: {
+              200: {
+                content: {
+                  'application/json': {
+                    schema: {
+                      $ref: '#/components/schemas/Transitive2',
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      components: {
+        schemas: {
+          Transitive2: {
+            type: 'object',
+            properties: {
+              link: {
+                $ref: '#/components/schemas/Used',
+              },
+            },
+          },
+          Used: {
+            type: 'integer',
+          },
+        },
+      },
+    });
+  });
 });

package/src/decorators/oas3/remove-unused-components.ts

@@ -2,12 +2,12 @@ import { Location } from '../../ref-utils';
 import { isEmptyObject } from '../../utils';
 
 import type { Oas3Decorator } from '../../visitors';
-import type { Oas3Components } from '../../typings/openapi';
+import type { Oas3Components, Oas3Definition } from '../../typings/openapi';
 
 export const RemoveUnusedComponents: Oas3Decorator = () => {
   const components = new Map<
     string,
-    { used: boolean; componentType?: keyof Oas3Components; name: string }
+    { usedIn: Location[]; componentType?: keyof Oas3Components; name: string }
   >();
 
   function registerComponent(
@@ -16,15 +16,45 @@ export const RemoveUnusedComponents: Oas3Decorator = () => {
     name: string
   ): void {
     components.set(location.absolutePointer, {
-      used: components.get(location.absolutePointer)?.used || false,
+      usedIn: components.get(location.absolutePointer)?.usedIn ?? [],
       componentType,
       name,
     });
   }
 
+  function removeUnusedComponents(root: Oas3Definition, removedPaths: string[]): number {
+    const removedLengthStart = removedPaths.length;
+
+    for (const [path, { usedIn, name, componentType }] of components) {
+      const used = usedIn.some(
+        (location) =>
+          !removedPaths.some(
+            (removed) =>
+              location.absolutePointer.startsWith(removed) &&
+              (location.absolutePointer.length === removed.length ||
+                location.absolutePointer[removed.length] === '/')
+          )
+      );
+
+      if (!used && componentType && root.components) {
+        removedPaths.push(path);
+        const componentChild = root.components[componentType];
+        delete componentChild![name];
+        components.delete(path);
+        if (isEmptyObject(componentChild)) {
+          delete root.components[componentType];
+        }
+      }
+    }
+
+    return removedPaths.length > removedLengthStart
+      ? removeUnusedComponents(root, removedPaths)
+      : removedPaths.length;
+  }
+
   return {
     ref: {
-      leave(ref, { type, resolve, key }) {
+      leave(ref, { location, type, resolve, key }) {
         if (
           ['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(
             type.name
@@ -37,29 +67,24 @@ export const RemoveUnusedComponents: Oas3Decorator = () => {
           const componentLevelLocalPointer = localPointer.split('/').slice(0, 4).join('/');
           const pointer = `${fileLocation}#${componentLevelLocalPointer}`;
 
-          components.set(pointer, {
-            used: true,
-            name: key.toString(),
-          });
+          const registered = components.get(pointer);
+
+          if (registered) {
+            registered.usedIn.push(location);
+          } else {
+            components.set(pointer, {
+              usedIn: [location],
+              name: key.toString(),
+            });
+          }
         }
       },
     },
     Root: {
       leave(root, ctx) {
         const data = ctx.getVisitorData() as { removedCount: number };
-        data.removedCount = 0;
+        data.removedCount = removeUnusedComponents(root, []);
 
-        components.forEach((usageInfo) => {
-          const { used, componentType, name } = usageInfo;
-          if (!used && componentType && root.components) {
-            const componentChild = root.components[componentType];
-            delete componentChild![name];
-            data.removedCount++;
-            if (isEmptyObject(componentChild)) {
-              delete root.components[componentType];
-            }
-          }
-        });
         if (isEmptyObject(root.components)) {
           delete root.components;
         }

package/src/format/format.ts

@@ -51,7 +51,9 @@ export type OutputFormat =
   | 'json'
   | 'checkstyle'
   | 'codeclimate'
-  | 'summary';
+  | 'summary'
+  | 'github-actions'
+  | 'markdown';
 
 export function getTotals(problems: (NormalizedProblem & { ignored?: boolean })[]): Totals {
   let errors = 0;
@@ -155,6 +157,8 @@ export function formatProblems(
     case 'summary':
       formatSummary(problems);
       break;
+    case 'github-actions':
+      outputForGithubActions(problems, cwd);
   }
 
   if (totalProblems - ignoredProblems > maxProblems) {
@@ -373,3 +377,60 @@ function xmlEscape(s: string): string {
     }
   });
 }
+
+function outputForGithubActions(problems: NormalizedProblem[], cwd: string): void {
+  for (const problem of problems) {
+    for (const location of problem.location.map(getLineColLocation)) {
+      let command;
+      switch (problem.severity) {
+        case 'error':
+          command = 'error';
+          break;
+        case 'warn':
+          command = 'warning';
+          break;
+      }
+      const suggest = formatDidYouMean(problem);
+      const message = suggest !== '' ? problem.message + '\n\n' + suggest : problem.message;
+      const properties = {
+        title: problem.ruleId,
+        file: isAbsoluteUrl(location.source.absoluteRef)
+          ? location.source.absoluteRef
+          : path.relative(cwd, location.source.absoluteRef),
+        line: location.start.line,
+        col: location.start.col,
+        endLine: location.end?.line,
+        endColumn: location.end?.col,
+      };
+      output.write(`::${command} ${formatProperties(properties)}::${escapeMessage(message)}\n`);
+    }
+  }
+
+  function formatProperties(props: Record<string, any>): string {
+    return Object.entries(props)
+      .filter(([, v]) => v !== null && v !== undefined)
+      .map(([k, v]) => `${k}=${escapeProperty(v)}`)
+      .join(',');
+  }
+
+  function toString(v: any): string {
+    if (v === null || v === undefined) {
+      return '';
+    } else if (typeof v === 'string' || v instanceof String) {
+      return v as string;
+    }
+    return JSON.stringify(v);
+  }
+
+  function escapeMessage(v: any): string {
+    return toString(v).replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+  }
+  function escapeProperty(v: any): string {
+    return toString(v)
+      .replace(/%/g, '%25')
+      .replace(/\r/g, '%0D')
+      .replace(/\n/g, '%0A')
+      .replace(/:/g, '%3A')
+      .replace(/,/g, '%2C');
+  }
+}

package/src/index.ts

@@ -1,4 +1,11 @@
-export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist, isTruthy } from './utils';
+export {
+  BundleOutputFormat,
+  readFileFromUrl,
+  slash,
+  doesYamlFileExist,
+  isTruthy,
+  pause,
+} from './utils';
 export { Oas3_1Types } from './types/oas3_1';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';

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

@@ -77,13 +77,13 @@ export function getAssertsToApply(assertion: AssertionDefinition): AssertToApply
 
   if (shouldRunOnValues && !assertion.subject.property) {
     throw new Error(
-      `${shouldRunOnValues.name} can't be used on all keys. Please provide a single property`
+      `The '${shouldRunOnValues.name}' assertion can't be used on all keys. Please provide a single property.`
     );
   }
 
   if (shouldRunOnKeys && assertion.subject.property) {
     throw new Error(
-      `${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`
+      `The '${shouldRunOnKeys.name}' assertion can't be used on properties. Please remove the 'property' key.`
     );
   }