@redocly/openapi-core 1.18.1 → 1.19.0

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.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,20 @@ 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) {
     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 +75,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;