@redocly/cli 1.9.0 → 1.9.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @redocly/cli
 
+## 1.9.1
+
+### Patch Changes
+
+- Adds support for using logical AND for the security schema so that the `join` command generates the correct schema.
+- Fixed a bug with resolving $refs to file names that contain the hash symbol.
+- Fixed a problem where the `join` command did not process schemas containing `null` values when the `--prefix-components-with-info-prop` option was used.'
+- Updated @redocly/openapi-core to v1.9.1.
+
 ## 1.9.0
 
 ### Minor Changes

package/lib/__mocks__/@redocly/openapi-core.js

@@ -41,7 +41,8 @@ class BaseResolver {
         this.resolveDocument = jest
             .fn()
             .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.firstDocument }))
-            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.secondDocument }));
+            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.secondDocument }))
+            .mockImplementationOnce(() => Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: documents_1.thirdDocument }));
     }
 }
 exports.BaseResolver = BaseResolver;

package/lib/__mocks__/documents.d.ts

@@ -90,3 +90,61 @@ export declare const secondDocument: {
     };
     components: {};
 };
+export declare const thirdDocument: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    paths: {};
+    components: {
+        schemas: {
+            SchemaWithNull: {
+                type: string;
+                default: null;
+                nullable: boolean;
+            };
+            SchemaWithRef: {
+                type: string;
+                properties: {
+                    schemaType: {
+                        type: string;
+                        enum: string[];
+                    };
+                    foo: {
+                        $ref: string;
+                    };
+                };
+            };
+            SchemaWithDiscriminator: {
+                discriminator: {
+                    propertyName: string;
+                    mapping: {
+                        foo: string;
+                        bar: string;
+                    };
+                };
+                oneOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    properties: {
+                        schemaType: {
+                            type: string;
+                            enum: string[];
+                        };
+                        bar: {
+                            type: string;
+                        };
+                    };
+                    $ref?: undefined;
+                })[];
+            };
+        };
+    };
+};

package/lib/__mocks__/documents.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.secondDocument = exports.firstDocument = void 0;
+exports.thirdDocument = exports.secondDocument = exports.firstDocument = void 0;
 exports.firstDocument = {
     openapi: '3.0.0',
     servers: [{ url: 'http://localhost:8080' }],
     info: {
         description: 'example test',
         version: '1.0.0',
-        title: 'Swagger Petstore',
+        title: 'First API',
         termsOfService: 'http://swagger.io/terms/',
         license: {
             name: 'Apache 2.0',
@@ -37,7 +37,7 @@ exports.secondDocument = {
     info: {
         description: 'example test',
         version: '1.0.0',
-        title: 'Swagger Petstore',
+        title: 'Second API',
         termsOfService: 'http://swagger.io/terms/',
         license: {
             name: 'Apache 2.0',
@@ -61,3 +61,63 @@ exports.secondDocument = {
     },
     components: {},
 };
+exports.thirdDocument = {
+    openapi: '3.0.0',
+    info: {
+        title: 'Third API',
+        version: '1.0',
+    },
+    servers: [
+        {
+            url: 'https://api.server.test/v1',
+        },
+    ],
+    paths: {},
+    components: {
+        schemas: {
+            SchemaWithNull: {
+                type: 'string',
+                default: null,
+                nullable: true,
+            },
+            SchemaWithRef: {
+                type: 'object',
+                properties: {
+                    schemaType: {
+                        type: 'string',
+                        enum: ['foo'],
+                    },
+                    foo: {
+                        $ref: '#/components/schemas/SchemaWithNull',
+                    },
+                },
+            },
+            SchemaWithDiscriminator: {
+                discriminator: {
+                    propertyName: 'schemaType',
+                    mapping: {
+                        foo: '#/components/schemas/SchemaWithRef',
+                        bar: '#/components/schemas/SchemaWithNull',
+                    },
+                },
+                oneOf: [
+                    {
+                        $ref: '#/components/schemas/SchemaWithRef',
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            schemaType: {
+                                type: 'string',
+                                enum: ['bar'],
+                            },
+                            bar: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};

package/lib/__tests__/commands/join.test.js

@@ -9,15 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const join_1 = require("../../commands/join");
-const miscellaneous_1 = require("../../utils/miscellaneous");
 const colorette_1 = require("colorette");
 const openapi_core_1 = require("@redocly/openapi-core");
+const join_1 = require("../../commands/join");
+const miscellaneous_1 = require("../../utils/miscellaneous");
 const openapi_core_2 = require("../../__mocks__/@redocly/openapi-core");
 const config_1 = require("../fixtures/config");
 jest.mock('../../utils/miscellaneous');
 jest.mock('colorette');
-describe('handleJoin fails', () => {
+describe('handleJoin', () => {
     const colloreteYellowMock = colorette_1.yellow;
     colloreteYellowMock.mockImplementation((string) => string);
     it('should call exitWithError because only one entrypoint', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -105,4 +105,127 @@ describe('handleJoin fails', () => {
         expect(config.styleguide.skipDecorators).not.toHaveBeenCalled();
         expect(config.styleguide.skipPreprocessors).not.toHaveBeenCalled();
     }));
+    it('should handle join with prefix-components-with-info-prop and null values', () => __awaiter(void 0, void 0, void 0, function* () {
+        openapi_core_1.detectSpec.mockReturnValue('oas3_0');
+        yield (0, join_1.handleJoin)({
+            apis: ['first.yaml', 'second.yaml', 'third.yaml'],
+            'prefix-components-with-info-prop': 'title',
+            output: 'join-result.yaml',
+        }, config_1.ConfigFixture, 'cli-version');
+        expect(miscellaneous_1.writeToFileByExtension).toHaveBeenCalledWith({
+            openapi: '3.0.0',
+            info: {
+                description: 'example test',
+                version: '1.0.0',
+                title: 'First API',
+                termsOfService: 'http://swagger.io/terms/',
+                license: {
+                    name: 'Apache 2.0',
+                    url: 'http://www.apache.org/licenses/LICENSE-2.0.html',
+                },
+            },
+            servers: [
+                {
+                    url: 'http://localhost:8080',
+                },
+                {
+                    url: 'https://api.server.test/v1',
+                },
+            ],
+            tags: [
+                {
+                    name: 'pet',
+                    'x-displayName': 'pet',
+                },
+            ],
+            paths: {
+                '/GETUser/{userId}': {
+                    summary: 'get user by id',
+                    description: 'user info',
+                    servers: [
+                        {
+                            url: '/user',
+                        },
+                        {
+                            url: '/pet',
+                            description: 'pet server',
+                        },
+                    ],
+                    get: {
+                        tags: ['pet'],
+                        summary: 'Find pet by ID',
+                        description: 'Returns a single pet',
+                        operationId: 'getPetById',
+                        servers: [
+                            {
+                                url: '/pet',
+                            },
+                        ],
+                    },
+                    parameters: [
+                        {
+                            name: 'param1',
+                            in: 'header',
+                            schema: {
+                                description: 'string',
+                            },
+                        },
+                    ],
+                },
+            },
+            components: {
+                schemas: {
+                    'Third API_SchemaWithNull': {
+                        type: 'string',
+                        default: null,
+                        nullable: true,
+                    },
+                    'Third API_SchemaWithRef': {
+                        type: 'object',
+                        properties: {
+                            schemaType: {
+                                type: 'string',
+                                enum: ['foo'],
+                            },
+                            foo: {
+                                $ref: '#/components/schemas/Third API_SchemaWithNull',
+                            },
+                        },
+                    },
+                    'Third API_SchemaWithDiscriminator': {
+                        discriminator: {
+                            propertyName: 'schemaType',
+                            mapping: {
+                                foo: '#/components/schemas/Third API_SchemaWithRef',
+                                bar: '#/components/schemas/Third API_SchemaWithNull',
+                            },
+                        },
+                        oneOf: [
+                            {
+                                $ref: '#/components/schemas/Third API_SchemaWithRef',
+                            },
+                            {
+                                type: 'object',
+                                properties: {
+                                    schemaType: {
+                                        type: 'string',
+                                        enum: ['bar'],
+                                    },
+                                    bar: {
+                                        type: 'string',
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+            'x-tagGroups': [
+                {
+                    name: 'First API',
+                    tags: ['pet'],
+                },
+            ],
+        }, 'join-result.yaml', true);
+    }));
 });

package/lib/commands/join.d.ts

@@ -1,4 +1,5 @@
-import { Config, RuleSeverity } from '@redocly/openapi-core';
+import { Config } from '@redocly/openapi-core';
+import type { RuleSeverity } from '@redocly/openapi-core';
 export type JoinOptions = {
     apis: string[];
     lint?: boolean;

package/lib/commands/join.js

@@ -18,7 +18,7 @@ const openapi_core_1 = require("@redocly/openapi-core");
 const miscellaneous_1 = require("../utils/miscellaneous");
 const js_utils_1 = require("../utils/js-utils");
 const types_1 = require("./split/types");
-const COMPONENTS = 'components';
+const split_1 = require("./split");
 const Tags = 'tags';
 const xTagGroups = 'x-tagGroups';
 let potentialConflictsTotal = 0;
@@ -112,7 +112,7 @@ function handleJoin(argv, config, packageVersion) {
             const tagsPrefix = prefixTagsWithFilename
                 ? apiFilename
                 : getInfoPrefix(info, prefixTagsWithInfoProp, 'tags');
-            const componentsPrefix = getInfoPrefix(info, prefixComponentsWithInfoProp, COMPONENTS);
+            const componentsPrefix = getInfoPrefix(info, prefixComponentsWithInfoProp, types_1.COMPONENTS);
             if (openapi.hasOwnProperty('x-tagGroups')) {
                 process.stderr.write((0, colorette_1.yellow)(`warning: x-tagGroups at ${(0, colorette_1.blue)(api)} will be skipped \n`));
             }
@@ -390,13 +390,13 @@ function handleJoin(argv, config, packageVersion) {
         function collectComponents(openapi, { api, potentialConflicts, componentsPrefix }) {
             const { components } = openapi;
             if (components) {
-                if (!joinedDef.hasOwnProperty(COMPONENTS)) {
-                    joinedDef[COMPONENTS] = {};
+                if (!joinedDef.hasOwnProperty(types_1.COMPONENTS)) {
+                    joinedDef[types_1.COMPONENTS] = {};
                 }
                 for (const [component, componentObj] of Object.entries(components)) {
-                    if (!potentialConflicts[COMPONENTS].hasOwnProperty(component)) {
-                        potentialConflicts[COMPONENTS][component] = {};
-                        joinedDef[COMPONENTS][component] = {};
+                    if (!potentialConflicts[types_1.COMPONENTS].hasOwnProperty(component)) {
+                        potentialConflicts[types_1.COMPONENTS][component] = {};
+                        joinedDef[types_1.COMPONENTS][component] = {};
                     }
                     for (const item of Object.keys(componentObj)) {
                         const componentPrefix = addPrefix(item, componentsPrefix);
@@ -449,7 +449,7 @@ function handleJoin(argv, config, packageVersion) {
             var _a;
             const firstApi = documents[0];
             const openapi = firstApi.parsed;
-            const componentsPrefix = getInfoPrefix(openapi.info, prefixComponentsWithInfoProp, COMPONENTS);
+            const componentsPrefix = getInfoPrefix(openapi.info, prefixComponentsWithInfoProp, types_1.COMPONENTS);
             if (!openapi.openapi)
                 (0, miscellaneous_1.exitWithError)('Version of specification is not found in. \n');
             if (!openapi.info)
@@ -481,7 +481,7 @@ function iteratePotentialConflicts(potentialConflicts, withoutXTagGroups) {
         for (const [key, value] of Object.entries(potentialConflicts[group])) {
             const conflicts = filterConflicts(value);
             if (conflicts.length) {
-                if (group === COMPONENTS) {
+                if (group === types_1.COMPONENTS) {
                     for (const [_, conflict] of Object.entries(conflicts)) {
                         if (validateComponentsDifference(conflict[1])) {
                             conflict[1] = conflict[1].map((c) => Object.keys(c)[0]);
@@ -540,8 +540,11 @@ function addComponentsPrefix(description, componentsPrefix) {
 function addSecurityPrefix(security, componentsPrefix) {
     return componentsPrefix
         ? security === null || security === void 0 ? void 0 : security.map((s) => {
-            const key = Object.keys(s)[0];
-            return { [componentsPrefix + '_' + key]: s[key] };
+            const joinedSecuritySchema = {};
+            for (const [key, value] of Object.entries(s)) {
+                Object.assign(joinedSecuritySchema, { [componentsPrefix + '_' + key]: value });
+            }
+            return joinedSecuritySchema;
         })
         : security;
 }
@@ -571,27 +574,18 @@ function validateApi(document, config, externalRefResolver, packageVersion) {
         }
     });
 }
-function crawl(object, visitor) {
-    if (!(0, js_utils_1.isObject)(object))
-        return;
-    for (const key of Object.keys(object)) {
-        visitor(object[key], key);
-        crawl(object[key], visitor);
-    }
-}
 function replace$Refs(obj, componentsPrefix) {
-    crawl(obj, (node) => {
-        if (node.$ref && (0, js_utils_1.isString)(node.$ref) && node.$ref.startsWith(`#/${COMPONENTS}/`)) {
+    (0, split_1.crawl)(obj, (node) => {
+        if (node.$ref && typeof node.$ref === 'string' && (0, split_1.startsWithComponents)(node.$ref)) {
             const name = path.basename(node.$ref);
             node.$ref = node.$ref.replace(name, componentsPrefix + '_' + name);
         }
-        else if (node.discriminator &&
-            node.discriminator.mapping &&
-            (0, js_utils_1.isObject)(node.discriminator.mapping)) {
+        else if ((0, js_utils_1.isObject)(node.discriminator) && (0, js_utils_1.isObject)(node.discriminator.mapping)) {
             const { mapping } = node.discriminator;
             for (const name of Object.keys(mapping)) {
-                if ((0, js_utils_1.isString)(mapping[name]) && mapping[name].startsWith(`#/${COMPONENTS}/`)) {
-                    mapping[name] = mapping[name]
+                const mappingPointer = mapping[name];
+                if (typeof mappingPointer === 'string' && (0, split_1.startsWithComponents)(mappingPointer)) {
+                    mapping[name] = mappingPointer
                         .split('/')
                         .map((name, i, arr) => {
                         return arr.length - 1 === i && !name.includes(componentsPrefix)

package/lib/commands/split/index.d.ts

@@ -1,4 +1,4 @@
-import { Oas3PathItem, Referenced } from './types';
+import type { Oas3PathItem, Referenced } from './types';
 export type SplitOptions = {
     api: string;
     outDir: string;
@@ -6,5 +6,7 @@ export type SplitOptions = {
     config?: string;
 };
 export declare function handleSplit(argv: SplitOptions): Promise<void>;
+export declare function startsWithComponents(node: string): boolean;
+export declare function crawl(object: unknown, visitor: (node: Record<string, unknown>) => void): void;
 declare function iteratePathItems(pathItems: Record<string, Referenced<Oas3PathItem>> | undefined, openapiDir: string, outDir: string, componentsFiles: object, pathSeparator: string, codeSamplesPathPrefix: string | undefined, ext: string): void;
 export { iteratePathItems };

package/lib/commands/split/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.iteratePathItems = exports.handleSplit = void 0;
+exports.iteratePathItems = exports.crawl = exports.startsWithComponents = exports.handleSplit = void 0;
 const colorette_1 = require("colorette");
 const fs = require("fs");
 const openapi_core_1 = require("@redocly/openapi-core");
@@ -44,9 +44,10 @@ function splitDefinition(openapi, openapiDir, pathSeparator, ext) {
     replace$Refs(openapi, openapiDir, componentsFiles);
     (0, miscellaneous_1.writeToFileByExtension)(openapi, path.join(openapiDir, `openapi.${ext}`));
 }
-function isStartsWithComponents(node) {
-    return node.startsWith(types_1.componentsPath);
+function startsWithComponents(node) {
+    return node.startsWith(`#/${types_1.COMPONENTS}/`);
 }
+exports.startsWithComponents = startsWithComponents;
 function isSupportedExtension(filename) {
     return filename.endsWith('.yaml') || filename.endsWith('.yml') || filename.endsWith('.json');
 }
@@ -92,22 +93,22 @@ function traverseDirectoryDeepCallback(filename, directory, componentsFiles) {
 function crawl(object, visitor) {
     if (!(0, js_utils_1.isObject)(object))
         return;
+    visitor(object);
     for (const key of Object.keys(object)) {
-        visitor(object, key);
         crawl(object[key], visitor);
     }
 }
+exports.crawl = crawl;
 function replace$Refs(obj, relativeFrom, componentFiles = {}) {
     crawl(obj, (node) => {
-        if (node.$ref && (0, js_utils_1.isString)(node.$ref) && isStartsWithComponents(node.$ref)) {
+        if (node.$ref && typeof node.$ref === 'string' && startsWithComponents(node.$ref)) {
             replace(node, '$ref');
         }
-        else if (node.discriminator &&
-            node.discriminator.mapping &&
-            (0, js_utils_1.isObject)(node.discriminator.mapping)) {
+        else if ((0, js_utils_1.isObject)(node.discriminator) && (0, js_utils_1.isObject)(node.discriminator.mapping)) {
             const { mapping } = node.discriminator;
             for (const name of Object.keys(mapping)) {
-                if ((0, js_utils_1.isString)(mapping[name]) && isStartsWithComponents(mapping[name])) {
+                const mappingPointer = mapping[name];
+                if (typeof mappingPointer === 'string' && startsWithComponents(mappingPointer)) {
                     replace(node.discriminator.mapping, name);
                 }
             }

package/lib/commands/split/types.d.ts

@@ -4,14 +4,13 @@ export type Definition = Oas3_1Definition | Oas3Definition | Oas2Definition;
 export interface ComponentsFiles {
     [schemas: string]: any;
 }
-export interface refObj {
+export interface RefObject {
     [$ref: string]: string;
 }
 export declare const COMPONENTS = "components";
 export declare const PATHS = "paths";
 export declare const WEBHOOKS = "webhooks";
 export declare const xWEBHOOKS = "x-webhooks";
-export declare const componentsPath = "#/components/";
 export declare enum OPENAPI3_METHOD {
     get = "get",
     put = "put",

package/lib/commands/split/types.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENAPI3_COMPONENT_NAMES = exports.OPENAPI3_COMPONENT = exports.OPENAPI3_METHOD_NAMES = exports.OPENAPI3_METHOD = exports.componentsPath = exports.xWEBHOOKS = exports.WEBHOOKS = exports.PATHS = exports.COMPONENTS = void 0;
+exports.OPENAPI3_COMPONENT_NAMES = exports.OPENAPI3_COMPONENT = exports.OPENAPI3_METHOD_NAMES = exports.OPENAPI3_METHOD = exports.xWEBHOOKS = exports.WEBHOOKS = exports.PATHS = exports.COMPONENTS = void 0;
 exports.COMPONENTS = 'components';
 exports.PATHS = 'paths';
 exports.WEBHOOKS = 'webhooks';
 exports.xWEBHOOKS = 'x-webhooks';
-exports.componentsPath = `#/${exports.COMPONENTS}/`;
 var OPENAPI3_METHOD;
 (function (OPENAPI3_METHOD) {
     OPENAPI3_METHOD["get"] = "get";

package/lib/utils/js-utils.d.ts

@@ -1,4 +1,4 @@
-export declare function isObject(obj: any): boolean;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function isEmptyObject(obj: any): boolean;
 export declare function isString(str: string): boolean;
 export declare function keysOf<T>(obj: T): (keyof T)[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "",
   "license": "MIT",
   "bin": {
@@ -36,7 +36,7 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/openapi-core": "1.9.0",
+    "@redocly/openapi-core": "1.9.1",
     "abort-controller": "^3.0.0",
     "chokidar": "^3.5.1",
     "colorette": "^1.2.0",

package/src/__mocks__/@redocly/openapi-core.ts

@@ -1,5 +1,5 @@
 import { ConfigFixture } from './../../__tests__/fixtures/config';
-import { firstDocument, secondDocument } from '../documents';
+import { firstDocument, secondDocument, thirdDocument } from '../documents';
 
 import type { Document } from '@redocly/openapi-core';
 
@@ -47,6 +47,9 @@ export class BaseResolver {
     )
     .mockImplementationOnce(() =>
       Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: secondDocument })
+    )
+    .mockImplementationOnce(() =>
+      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: thirdDocument })
     );
 }
 

package/src/__mocks__/documents.ts

@@ -4,7 +4,7 @@ export const firstDocument = {
   info: {
     description: 'example test',
     version: '1.0.0',
-    title: 'Swagger Petstore',
+    title: 'First API',
     termsOfService: 'http://swagger.io/terms/',
     license: {
       name: 'Apache 2.0',
@@ -36,7 +36,7 @@ export const secondDocument = {
   info: {
     description: 'example test',
     version: '1.0.0',
-    title: 'Swagger Petstore',
+    title: 'Second API',
     termsOfService: 'http://swagger.io/terms/',
     license: {
       name: 'Apache 2.0',
@@ -61,3 +61,64 @@ export const secondDocument = {
   },
   components: {},
 };
+
+export const thirdDocument = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Third API',
+    version: '1.0',
+  },
+  servers: [
+    {
+      url: 'https://api.server.test/v1',
+    },
+  ],
+  paths: {},
+  components: {
+    schemas: {
+      SchemaWithNull: {
+        type: 'string',
+        default: null,
+        nullable: true,
+      },
+      SchemaWithRef: {
+        type: 'object',
+        properties: {
+          schemaType: {
+            type: 'string',
+            enum: ['foo'],
+          },
+          foo: {
+            $ref: '#/components/schemas/SchemaWithNull',
+          },
+        },
+      },
+      SchemaWithDiscriminator: {
+        discriminator: {
+          propertyName: 'schemaType',
+          mapping: {
+            foo: '#/components/schemas/SchemaWithRef',
+            bar: '#/components/schemas/SchemaWithNull',
+          },
+        },
+        oneOf: [
+          {
+            $ref: '#/components/schemas/SchemaWithRef',
+          },
+          {
+            type: 'object',
+            properties: {
+              schemaType: {
+                type: 'string',
+                enum: ['bar'],
+              },
+              bar: {
+                type: 'string',
+              },
+            },
+          },
+        ],
+      },
+    },
+  },
+};