@redocly/openapi-core 1.18.1 → 1.20.0

package/lib/redocly/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedoclyClient = exports.TOKEN_FILENAME = void 0;
 const fs_1 = require("fs");
@@ -47,10 +38,8 @@ class RedoclyClient {
     hasToken() {
         return !!this.accessTokens[this.region];
     }
-    getAuthorizationHeader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.accessTokens[this.region];
-        });
+    async getAuthorizationHeader() {
+        return this.accessTokens[this.region];
     }
     // </backward compatibility: portal>
     setAccessTokens(accessTokens) {
@@ -60,13 +49,19 @@ class RedoclyClient {
         const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
         const credentials = this.readCredentialsFile(credentialsPath);
         if ((0, utils_1.isNotEmptyObject)(credentials)) {
-            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token &&
-                !credentials[this.region] && {
-                [this.region]: credentials.token,
-            })));
+            this.setAccessTokens({
+                ...credentials,
+                ...(credentials.token &&
+                    !credentials[this.region] && {
+                    [this.region]: credentials.token,
+                }),
+            });
         }
         if (env_1.env.REDOCLY_AUTHORIZATION) {
-            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: env_1.env.REDOCLY_AUTHORIZATION }));
+            this.setAccessTokens({
+                ...this.accessTokens,
+                [this.region]: env_1.env.REDOCLY_AUTHORIZATION,
+            });
         }
     }
     getAllTokens() {
@@ -74,65 +69,57 @@ class RedoclyClient {
             .filter(([region]) => domains_1.AVAILABLE_REGIONS.includes(region))
             .map(([region, token]) => ({ region, token }));
     }
-    getValidTokens() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allTokens = this.getAllTokens();
-            const verifiedTokens = yield Promise.allSettled(allTokens.map(({ token }) => this.verifyToken(token)));
-            return allTokens
-                .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
-                .map(({ token, region }) => ({ token, region, valid: true }));
-        });
-    }
-    getTokens() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.hasTokens() ? yield this.getValidTokens() : [];
-        });
-    }
-    isAuthorizedWithRedoclyByRegion() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasTokens()) {
-                return false;
-            }
-            const accessToken = this.accessTokens[this.region];
-            if (!accessToken) {
-                return false;
-            }
-            try {
-                yield this.verifyToken(accessToken);
-                return true;
-            }
-            catch (err) {
-                return false;
-            }
-        });
-    }
-    isAuthorizedWithRedocly() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.hasTokens() && (0, utils_1.isNotEmptyObject)(yield this.getValidTokens());
-        });
+    async getValidTokens() {
+        const allTokens = this.getAllTokens();
+        const verifiedTokens = await Promise.allSettled(allTokens.map(({ token }) => this.verifyToken(token)));
+        return allTokens
+            .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
+            .map(({ token, region }) => ({ token, region, valid: true }));
+    }
+    async getTokens() {
+        return this.hasTokens() ? await this.getValidTokens() : [];
+    }
+    async isAuthorizedWithRedoclyByRegion() {
+        if (!this.hasTokens()) {
+            return false;
+        }
+        const accessToken = this.accessTokens[this.region];
+        if (!accessToken) {
+            return false;
+        }
+        try {
+            await this.verifyToken(accessToken);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async isAuthorizedWithRedocly() {
+        return this.hasTokens() && (0, utils_1.isNotEmptyObject)(await this.getValidTokens());
     }
     readCredentialsFile(credentialsPath) {
         return (0, fs_1.existsSync)(credentialsPath) ? JSON.parse((0, fs_1.readFileSync)(credentialsPath, 'utf-8')) : {};
     }
-    verifyToken(accessToken, verbose = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.registryApi.authStatus(accessToken, verbose);
-        });
-    }
-    login(accessToken, verbose = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
-            try {
-                yield this.verifyToken(accessToken, verbose);
-            }
-            catch (err) {
-                throw new Error('Authorization failed. Please check if you entered a valid API key.');
-            }
-            const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken, token: accessToken });
-            this.accessTokens = credentials;
-            this.registryApi.setAccessTokens(credentials);
-            (0, fs_1.writeFileSync)(credentialsPath, JSON.stringify(credentials, null, 2));
-        });
+    async verifyToken(accessToken, verbose = false) {
+        return this.registryApi.authStatus(accessToken, verbose);
+    }
+    async login(accessToken, verbose = false) {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        try {
+            await this.verifyToken(accessToken, verbose);
+        }
+        catch (err) {
+            throw new Error('Authorization failed. Please check if you entered a valid API key.');
+        }
+        const credentials = {
+            ...this.readCredentialsFile(credentialsPath),
+            [this.region]: accessToken,
+            token: accessToken, // FIXME: backward compatibility, remove on 1.0.0
+        };
+        this.accessTokens = credentials;
+        this.registryApi.setAccessTokens(credentials);
+        (0, fs_1.writeFileSync)(credentialsPath, JSON.stringify(credentials, null, 2));
     }
     logout() {
         const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);

package/lib/redocly/registry-api.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryApi = void 0;
 const node_fetch_1 = require("node-fetch");
@@ -29,86 +20,77 @@ class RegistryApi {
         this.accessTokens = accessTokens;
         return this;
     }
-    request(path = '', options = {}) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentCommand = typeof process !== 'undefined' ? ((_a = process.env) === null || _a === void 0 ? void 0 : _a.REDOCLY_CLI_COMMAND) || '' : '';
-            const redoclyEnv = typeof process !== 'undefined' ? ((_b = process.env) === null || _b === void 0 ? void 0 : _b.REDOCLY_ENVIRONMENT) || '' : '';
-            const headers = Object.assign({}, options.headers || {}, {
-                'x-redocly-cli-version': version,
-                'user-agent': `redocly-cli / ${version} ${currentCommand} ${redoclyEnv}`,
-            });
-            if (!headers.hasOwnProperty('authorization')) {
-                throw new Error('Unauthorized');
-            }
-            const response = yield (0, node_fetch_1.default)(`${this.getBaseUrl()}${path}`, Object.assign({}, options, { headers, agent: (0, utils_1.getProxyAgent)() }));
-            if (response.status === 401) {
-                throw new Error('Unauthorized');
-            }
-            if (response.status === 404) {
-                const body = yield response.json();
-                throw new Error(body.code);
-            }
-            return response;
+    async request(path = '', options = {}) {
+        const currentCommand = typeof process !== 'undefined' ? process.env?.REDOCLY_CLI_COMMAND || '' : '';
+        const redoclyEnv = typeof process !== 'undefined' ? process.env?.REDOCLY_ENVIRONMENT || '' : '';
+        const headers = Object.assign({}, options.headers || {}, {
+            'x-redocly-cli-version': version,
+            'user-agent': `redocly-cli / ${version} ${currentCommand} ${redoclyEnv}`,
         });
+        if (!headers.hasOwnProperty('authorization')) {
+            throw new Error('Unauthorized');
+        }
+        const response = await (0, node_fetch_1.default)(`${this.getBaseUrl()}${path}`, Object.assign({}, options, { headers, agent: (0, utils_1.getProxyAgent)() }));
+        if (response.status === 401) {
+            throw new Error('Unauthorized');
+        }
+        if (response.status === 404) {
+            const body = await response.json();
+            throw new Error(body.code);
+        }
+        return response;
     }
-    authStatus(accessToken, verbose = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const response = yield this.request('', { headers: { authorization: accessToken } });
-                return yield response.json();
-            }
-            catch (error) {
-                if (verbose) {
-                    console.log(error);
-                }
-                throw error;
+    async authStatus(accessToken, verbose = false) {
+        try {
+            const response = await this.request('', { headers: { authorization: accessToken } });
+            return await response.json();
+        }
+        catch (error) {
+            if (verbose) {
+                console.log(error);
             }
-        });
+            throw error;
+        }
     }
-    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    authorization: this.accessToken,
-                },
-                body: JSON.stringify({
-                    filesHash,
-                    filename,
-                    isUpsert,
-                }),
-            });
-            if (response.ok) {
-                return response.json();
-            }
-            throw new Error('Could not prepare file upload');
+    async prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            body: JSON.stringify({
+                filesHash,
+                filename,
+                isUpsert,
+            }),
         });
+        if (response.ok) {
+            return response.json();
+        }
+        throw new Error('Could not prepare file upload');
     }
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.request(`/${organizationId}/${name}/${version}`, {
-                method: 'PUT',
-                headers: {
-                    'content-type': 'application/json',
-                    authorization: this.accessToken,
-                },
-                body: JSON.stringify({
-                    rootFilePath,
-                    filePaths,
-                    branch,
-                    isUpsert,
-                    isPublic,
-                    batchId,
-                    batchSize,
-                }),
-            });
-            if (response.ok) {
-                return;
-            }
-            throw new Error('Could not push api');
+    async pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}`, {
+            method: 'PUT',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            body: JSON.stringify({
+                rootFilePath,
+                filePaths,
+                branch,
+                isUpsert,
+                isPublic,
+                batchId,
+                batchSize,
+            }),
         });
+        if (response.ok) {
+            return;
+        }
+        throw new Error('Could not push api');
     }
 }
 exports.RegistryApi = RegistryApi;

package/lib/ref-utils.d.ts

@@ -1,5 +1,5 @@
-import { Source } from './resolve';
-import { OasRef } from './typings/openapi';
+import type { Source } from './resolve';
+import type { OasRef } from './typings/openapi';
 export declare function joinPointer(base: string, key: string | number): string;
 export declare function isRef(node: any): node is OasRef;
 export declare class Location {

package/lib/ref-utils.js

@@ -1,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAnchor = exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
+exports.Location = void 0;
+exports.joinPointer = joinPointer;
+exports.isRef = isRef;
+exports.unescapePointer = unescapePointer;
+exports.escapePointer = escapePointer;
+exports.parseRef = parseRef;
+exports.parsePointer = parsePointer;
+exports.pointerBaseName = pointerBaseName;
+exports.refBaseName = refBaseName;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.isMappingRef = isMappingRef;
+exports.isAnchor = isAnchor;
 const utils_1 = require("./utils");
 function joinPointer(base, key) {
     if (base === '')
         base = '#/';
     return base[base.length - 1] === '/' ? base + key : base + '/' + key;
 }
-exports.joinPointer = joinPointer;
 function isRef(node) {
     return node && typeof node.$ref === 'string';
 }
-exports.isRef = isRef;
 class Location {
     constructor(source, pointer) {
         this.source = source;
@@ -21,7 +30,7 @@ class Location {
         return new Location(this.source, joinPointer(this.pointer, (Array.isArray(components) ? components : [components]).map(escapePointer).join('/')));
     }
     key() {
-        return Object.assign(Object.assign({}, this), { reportOnKey: true });
+        return { ...this, reportOnKey: true };
     }
     get absolutePointer() {
         return this.source.absoluteRef + (this.pointer === '#/' ? '' : this.pointer);
@@ -31,13 +40,11 @@ exports.Location = Location;
 function unescapePointer(fragment) {
     return decodeURIComponent(fragment.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
-exports.unescapePointer = unescapePointer;
 function escapePointer(fragment) {
     if (typeof fragment === 'number')
         return fragment;
     return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
 }
-exports.escapePointer = escapePointer;
 function parseRef(ref) {
     const [uri, pointer = ''] = ref.split('#/');
     return {
@@ -45,25 +52,21 @@ function parseRef(ref) {
         pointer: parsePointer(pointer),
     };
 }
-exports.parseRef = parseRef;
 function parsePointer(pointer) {
     return pointer.split('/').map(unescapePointer).filter(utils_1.isTruthy);
 }
-exports.parsePointer = parsePointer;
 function pointerBaseName(pointer) {
     const parts = pointer.split('/');
     return parts[parts.length - 1];
 }
-exports.pointerBaseName = pointerBaseName;
 function refBaseName(ref) {
+    // eslint-disable-next-line no-useless-escape
     const parts = ref.split(/[\/\\]/); // split by '\' and '/'
     return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
-exports.refBaseName = refBaseName;
 function isAbsoluteUrl(ref) {
     return ref.startsWith('http://') || ref.startsWith('https://');
 }
-exports.isAbsoluteUrl = isAbsoluteUrl;
 function isMappingRef(mapping) {
     // TODO: proper detection of mapping refs
     return (mapping.startsWith('#') ||
@@ -73,8 +76,6 @@ function isMappingRef(mapping) {
         mapping.startsWith('../') ||
         mapping.indexOf('/') > -1);
 }
-exports.isMappingRef = isMappingRef;
 function isAnchor(ref) {
     return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
 }
-exports.isAnchor = isAnchor;

package/lib/resolve.d.ts

@@ -1,6 +1,6 @@
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
-import { NormalizedNodeType } from './types';
-import { ResolveConfig } from './config/types';
+import type { NormalizedNodeType } from './types';
+import type { ResolveConfig } from './config/types';
 export type CollectedRefs = Map<string, Document>;
 export declare class Source {
     absoluteRef: string;