@redocly/openapi-core 1.10.6 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @redocly/openapi-core
 
+## 1.11.0
+
+### Minor Changes
+
+- Added support for a `github-actions` output format for the `lint` command to annotate reported problems on files when used in a GitHub Actions workflow.
+
+### Patch Changes
+
+- Fixed [`no-invalid-media-type-examples`](https://redocly.com/docs/cli/rules/no-invalid-media-type-examples/) rule `externalValue` example validation.
+- Process remove-unused-components rule transitively; components are now removed if they were previously referenced by a removed component.
+
 ## 1.10.6
 
 ### Patch Changes

package/lib/decorators/oas2/remove-unused-components.js

@@ -5,16 +5,38 @@ const utils_1 = require("../../utils");
 const RemoveUnusedComponents = () => {
     const components = new Map();
     function registerComponent(location, componentType, name) {
-        var _a;
+        var _a, _b;
         components.set(location.absolutePointer, {
-            used: ((_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.used) || false,
+            usedIn: (_b = (_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.usedIn) !== null && _b !== void 0 ? _b : [],
             componentType,
             name,
         });
     }
+    function removeUnusedComponents(root, removedPaths) {
+        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 ((0, utils_1.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)
@@ -22,31 +44,23 @@ const RemoveUnusedComponents = () => {
                     const [fileLocation, localPointer] = resolvedRef.location.absolutePointer.split('#', 2);
                     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();
-                data.removedCount = 0;
-                const rootComponents = new Set();
-                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 ((0, utils_1.isEmptyObject)(root[component])) {
-                        delete root[component];
-                    }
-                }
+                data.removedCount = removeUnusedComponents(root, []);
             },
         },
         NamedSchemas: {

package/lib/decorators/oas3/remove-unused-components.js

@@ -5,16 +5,36 @@ const utils_1 = require("../../utils");
 const RemoveUnusedComponents = () => {
     const components = new Map();
     function registerComponent(location, componentType, name) {
-        var _a;
+        var _a, _b;
         components.set(location.absolutePointer, {
-            used: ((_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.used) || false,
+            usedIn: (_b = (_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.usedIn) !== null && _b !== void 0 ? _b : [],
             componentType,
             name,
         });
     }
+    function removeUnusedComponents(root, removedPaths) {
+        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 ((0, utils_1.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)) {
                     const resolvedRef = resolve(ref);
                     if (!resolvedRef.location)
@@ -22,28 +42,23 @@ const RemoveUnusedComponents = () => {
                     const [fileLocation, localPointer] = resolvedRef.location.absolutePointer.split('#', 2);
                     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();
-                data.removedCount = 0;
-                components.forEach((usageInfo) => {
-                    const { used, componentType, name } = usageInfo;
-                    if (!used && componentType && root.components) {
-                        const componentChild = root.components[componentType];
-                        delete componentChild[name];
-                        data.removedCount++;
-                        if ((0, utils_1.isEmptyObject)(componentChild)) {
-                            delete root.components[componentType];
-                        }
-                    }
-                });
+                data.removedCount = removeUnusedComponents(root, []);
                 if ((0, utils_1.isEmptyObject)(root.components)) {
                     delete root.components;
                 }

package/lib/format/format.d.ts

@@ -4,7 +4,7 @@ export type Totals = {
     warnings: number;
     ignored: number;
 };
-export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate' | 'summary';
+export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate' | 'summary' | 'github-actions';
 export declare function getTotals(problems: (NormalizedProblem & {
     ignored?: boolean;
 })[]): Totals;

package/lib/format/format.js

@@ -103,6 +103,8 @@ function formatProblems(problems, opts) {
         case 'summary':
             formatSummary(problems);
             break;
+        case 'github-actions':
+            outputForGithubActions(problems, cwd);
     }
     if (totalProblems - ignoredProblems > maxProblems) {
         logger_1.logger.info(`< ... ${totalProblems - maxProblems} more problems hidden > ${logger_1.colorize.gray('increase with `--max-problems N`')}\n`);
@@ -266,3 +268,58 @@ function xmlEscape(s) {
         }
     });
 }
+function outputForGithubActions(problems, cwd) {
+    var _a, _b;
+    for (const problem of problems) {
+        for (const location of problem.location.map(codeframes_1.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: (0, ref_utils_1.isAbsoluteUrl)(location.source.absoluteRef)
+                    ? location.source.absoluteRef
+                    : path.relative(cwd, location.source.absoluteRef),
+                line: location.start.line,
+                col: location.start.col,
+                endLine: (_a = location.end) === null || _a === void 0 ? void 0 : _a.line,
+                endColumn: (_b = location.end) === null || _b === void 0 ? void 0 : _b.col,
+            };
+            output_1.output.write(`::${command} ${formatProperties(properties)}::${escapeMessage(message)}\n`);
+        }
+    }
+    function formatProperties(props) {
+        return Object.entries(props)
+            .filter(([, v]) => v !== null && v !== undefined)
+            .map(([k, v]) => `${k}=${escapeProperty(v)}`)
+            .join(',');
+    }
+    function toString(v) {
+        if (v === null || v === undefined) {
+            return '';
+        }
+        else if (typeof v === 'string' || v instanceof String) {
+            return v;
+        }
+        return JSON.stringify(v);
+    }
+    function escapeMessage(v) {
+        return toString(v).replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+    }
+    function escapeProperty(v) {
+        return toString(v)
+            .replace(/%/g, '%25')
+            .replace(/\r/g, '%0D')
+            .replace(/\n/g, '%0A')
+            .replace(/:/g, '%3A')
+            .replace(/,/g, '%2C');
+    }
+}

package/lib/rules/oas3/no-invalid-media-type-examples.js

@@ -28,6 +28,9 @@ const ValidContentExamples = (opts) => {
                         location = isMultiple ? resolved.location.child('value') : resolved.location;
                         example = resolved.node;
                     }
+                    if (isMultiple && typeof example.value === 'undefined') {
+                        return;
+                    }
                     (0, utils_1.validateExample)(isMultiple ? example.value : example, mediaType.schema, location, ctx, allowAdditionalProperties);
                 }
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.10.6",
+  "version": "1.11.0",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -35,7 +35,7 @@
   ],
   "dependencies": {
     "@redocly/ajv": "^8.11.0",
-    "@redocly/config": "^0.1.4",
+    "@redocly/config": "^0.2.0",
     "colorette": "^1.2.0",
     "js-levenshtein": "^1.1.6",
     "js-yaml": "^4.1.0",

package/src/__tests__/format.test.ts

@@ -1,6 +1,8 @@
 import { outdent } from 'outdent';
 
 import { formatProblems, getTotals } from '../format/format';
+import { LocationObject, NormalizedProblem } from '../walk';
+import { Source } from '../resolve';
 
 describe('format', () => {
   function replaceColors(log: string) {
@@ -40,6 +42,10 @@ describe('format', () => {
       output += str;
       return true;
     });
+    jest.spyOn(process.stdout, 'write').mockImplementation((str: string | Uint8Array) => {
+      output += str;
+      return true;
+    });
   });
 
   it('should correctly format summary output', () => {
@@ -73,4 +79,32 @@ describe('format', () => {
       "
     `);
   });
+
+  it('should format problems using github-actions', () => {
+    const problems = [
+      {
+        ruleId: 'spec',
+        message: 'message',
+        severity: 'error' as const,
+        location: [
+          {
+            source: { absoluteRef: 'openapi.yaml' } as Source,
+            start: { line: 1, col: 2 },
+            end: { line: 3, col: 4 },
+          } as LocationObject,
+        ],
+        suggest: [],
+      },
+    ];
+
+    formatProblems(problems, {
+      format: 'github-actions',
+      version: '1.0.0',
+      totals: getTotals(problems),
+    });
+
+    expect(output).toEqual(
+      '::error title=spec,file=openapi.yaml,line=1,col=2,endLine=3,endColumn=4::message\n'
+    );
+  });
 });

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',
+          },
+        },
+      },
+    });
+  });
 });