api-def 0.12.1 → 0.13.0

package/cjs/RequestContext.js

@@ -1,55 +1,43 @@
 "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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-var ApiUtils_1 = require("./ApiUtils");
-var Utils = require("./Utils");
-var contextIdCounter = 0;
-var RequestContext = /** @class */ (function () {
-    function RequestContext(backend, host, config, rawPath, mocking) {
+const ApiUtils_1 = require("./ApiUtils");
+const Utils = __importStar(require("./Utils"));
+let contextIdCounter = 0;
+class RequestContext {
+    constructor(backend, host, config, rawPath, mocking) {
         this.canceler = null;
         this.response = undefined;
         this.error = null;
@@ -78,93 +66,74 @@ var RequestContext = /** @class */ (function () {
         this.parseRequestBody();
         this.computedRequestUrl = this.resolveRequestUrl();
     }
-    RequestContext.prototype.validatePath = function () {
+    validatePath() {
         this.computedPath = (0, ApiUtils_1.resolvePathParams)(this.rawPath, this.requestConfig.params);
-    };
-    Object.defineProperty(RequestContext.prototype, "computedConfig", {
-        /**
-         * @deprecated Use `requestConfig` instead
-         */
-        get: function () {
-            return this.requestConfig;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RequestContext.prototype, "method", {
-        get: function () {
-            return this.computedMethod;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RequestContext.prototype, "api", {
-        get: function () {
-            return this.host.api;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RequestContext.prototype, "baseUrl", {
-        get: function () {
-            return this.computedBaseUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RequestContext.prototype, "responseType", {
-        get: function () {
-            return this.host.responseType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RequestContext.prototype.initMiddleware = function () {
+    }
+    /**
+     * @deprecated Use `requestConfig` instead
+     */
+    get computedConfig() {
+        return this.requestConfig;
+    }
+    get method() {
+        return this.computedMethod;
+    }
+    get api() {
+        return this.host.api;
+    }
+    get baseUrl() {
+        return this.computedBaseUrl;
+    }
+    get responseType() {
+        return this.host.responseType;
+    }
+    initMiddleware() {
         // Merge API-level and endpoint-level middleware
-        var allMiddleware = __spreadArray(__spreadArray([], this.api.middleware, true), ("middleware" in this.host && Array.isArray(this.host.middleware) ? this.host.middleware : []), true);
+        const allMiddleware = [
+            ...this.api.middleware,
+            ...("middleware" in this.host && Array.isArray(this.host.middleware) ? this.host.middleware : []),
+        ];
         // Process all middleware in one pass
-        for (var i = 0; i < allMiddleware.length; i++) {
-            var events = allMiddleware[i];
-            var eventTypes = Object.keys(events);
-            for (var n = 0; n < eventTypes.length; n++) {
-                var eventType = eventTypes[n];
-                var eventHandlersForType = this.eventHandlers[eventType] || (this.eventHandlers[eventType] = []);
-                var middlewareEventHandlers = events[eventType];
+        for (let i = 0; i < allMiddleware.length; i++) {
+            const events = allMiddleware[i];
+            const eventTypes = Object.keys(events);
+            for (let n = 0; n < eventTypes.length; n++) {
+                const eventType = eventTypes[n];
+                const eventHandlersForType = this.eventHandlers[eventType] || (this.eventHandlers[eventType] = []);
+                const middlewareEventHandlers = events[eventType];
                 if (middlewareEventHandlers) {
                     eventHandlersForType.push(middlewareEventHandlers);
                 }
             }
         }
-    };
-    RequestContext.prototype.generateKey = function () {
-        var key = this.computedPath.trim();
+    }
+    generateKey() {
+        let key = this.computedPath.trim();
         if (this.requestConfig.queryString) {
-            key += "?".concat(this.requestConfig.queryString);
+            key += `?${this.requestConfig.queryString}`;
         }
         return key;
-    };
-    RequestContext.prototype.updateHeaders = function (newHeaders) {
+    }
+    updateHeaders(newHeaders) {
         this.requestConfig.headers = Utils.assign({}, this.requestConfig.headers, newHeaders);
         this.parseRequestBody();
         return this;
-    };
-    RequestContext.prototype.updateParams = function (params) {
+    }
+    updateParams(params) {
         this.requestConfig.params = Utils.assign({}, this.requestConfig.params, params);
         this.computedPath = (0, ApiUtils_1.resolvePathParams)(this.rawPath, this.requestConfig.params);
         this.computedRequestUrl = this.resolveRequestUrl();
         return this;
-    };
-    RequestContext.prototype.parseRequestBody = function () {
-        var _a;
+    }
+    parseRequestBody() {
         if (this.requestConfig.body && this.requestConfig.headers) {
-            var contentTypeKey = Object.keys(this.requestConfig.headers).find(function (key) { return key.toLowerCase() === "content-type"; });
-            var contentType = contentTypeKey && ((_a = this.requestConfig.headers[contentTypeKey]) === null || _a === void 0 ? void 0 : _a.toString().split(";")[0].trim());
+            const contentTypeKey = Object.keys(this.requestConfig.headers).find((key) => key.toLowerCase() === "content-type");
+            const contentType = contentTypeKey && this.requestConfig.headers[contentTypeKey]?.toString().split(";")[0].trim();
             if (contentType === "application/x-www-form-urlencoded") {
-                var searchParams = new URLSearchParams();
-                for (var _i = 0, _b = Object.keys(this.requestConfig.body); _i < _b.length; _i++) {
-                    var key = _b[_i];
-                    var value = this.requestConfig.body[key];
-                    searchParams.append(key, value === null || value === void 0 ? void 0 : value.toString());
+                const searchParams = new URLSearchParams();
+                for (const key of Object.keys(this.requestConfig.body)) {
+                    const value = this.requestConfig.body[key];
+                    searchParams.append(key, value?.toString());
                 }
                 this.parsedBody = searchParams;
             }
@@ -175,89 +144,65 @@ var RequestContext = /** @class */ (function () {
         else {
             this.parsedBody = undefined;
         }
-    };
-    RequestContext.prototype.getParsedBody = function () {
+    }
+    getParsedBody() {
         return this.parsedBody;
-    };
-    RequestContext.prototype.updateQuery = function (newQuery) {
+    }
+    updateQuery(newQuery) {
         this.requestConfig.queryObject = Utils.assign({}, this.requestConfig.queryObject, newQuery);
         this.computedRequestUrl = this.resolveRequestUrl();
         return this;
-    };
-    RequestContext.prototype.triggerEvent = function (eventType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var eventHandlers, i, eventHandler, eventResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        eventHandlers = this.eventHandlers[eventType];
-                        if (!eventHandlers) return [3 /*break*/, 4];
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < eventHandlers.length)) return [3 /*break*/, 4];
-                        eventHandler = eventHandlers[i];
-                        return [4 /*yield*/, eventHandler(this)];
-                    case 2:
-                        eventResult = _a.sent();
-                        if (eventResult) {
-                            return [2 /*return*/, eventResult];
-                        }
-                        _a.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, undefined];
+    }
+    async triggerEvent(eventType) {
+        const eventHandlers = this.eventHandlers[eventType];
+        if (eventHandlers) {
+            for (let i = 0; i < eventHandlers.length; i++) {
+                const eventHandler = eventHandlers[i];
+                const eventResult = await eventHandler(this);
+                if (eventResult) {
+                    return eventResult;
                 }
-            });
-        });
-    };
-    RequestContext.prototype.addCanceller = function (canceler) {
+            }
+        }
+        return undefined;
+    }
+    addCanceller(canceler) {
         this.canceler = canceler;
-    };
-    RequestContext.prototype.cancel = function () {
+    }
+    cancel() {
         this.cancelled = true;
         if (this.canceler) {
             this.canceler();
         }
-    };
-    Object.defineProperty(RequestContext.prototype, "requestUrl", {
-        get: function () {
-            return this.computedRequestUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RequestContext.prototype, "path", {
-        get: function () {
-            return this.computedPath;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RequestContext.prototype.updatePath = function (path) {
+    }
+    get requestUrl() {
+        return this.computedRequestUrl;
+    }
+    get path() {
+        return this.computedPath;
+    }
+    updatePath(path) {
         this.computedPath = path;
         this.computedRequestUrl = this.resolveRequestUrl();
-    };
-    RequestContext.prototype.updateBaseUrl = function (baseUrl) {
+    }
+    updateBaseUrl(baseUrl) {
         this.computedBaseUrl = baseUrl;
         this.computedRequestUrl = this.resolveRequestUrl();
-    };
-    RequestContext.prototype.updateMethod = function (method) {
+    }
+    updateMethod(method) {
         this.computedMethod = method;
-    };
-    RequestContext.prototype.updateBody = function (body) {
-        // @ts-ignore
+    }
+    updateBody(body) {
+        // @ts-expect-error
         this.requestConfig.body = body;
         this.parseRequestBody();
-    };
-    RequestContext.prototype.resolveRequestUrl = function () {
-        var url = (0, ApiUtils_1.resolveUrl)({ baseUrl: this.baseUrl, path: this.computedPath });
+    }
+    resolveRequestUrl() {
+        const url = (0, ApiUtils_1.resolveUrl)({ baseUrl: this.baseUrl, path: this.computedPath });
         if (this.requestConfig.queryString) {
             url.search = this.requestConfig.queryString;
         }
         return url;
-    };
-    return RequestContext;
-}());
+    }
+}
 exports.default = RequestContext;

package/cjs/RequestError.js

@@ -13,8 +13,8 @@ exports.RequestErrorCode = {
     VALIDATION_BODY_VALIDATE_ERROR: "validation/body-validate-error",
     VALIDATION_RESPONSE_VALIDATE_ERROR: "validation/response-validate-error",
 };
-var REQUEST_ERROR_SYMBOL = "isApiDefError";
-var isRequestError = function (error) {
+const REQUEST_ERROR_SYMBOL = "isApiDefError";
+const isRequestError = (error) => {
     if (!error) {
         return false;
     }
@@ -24,10 +24,9 @@ var isRequestError = function (error) {
     return error[REQUEST_ERROR_SYMBOL] === true;
 };
 exports.isRequestError = isRequestError;
-var convertToRequestError = function (config) {
-    var _a;
-    var error = config.error, context = config.context, response = config.response, code = config.code;
-    var body = context.getParsedBody();
+const convertToRequestError = (config) => {
+    const { error, context, response, code } = config;
+    const body = context.getParsedBody();
     if (error.constructor.name === "TypeError") {
         error.constructor = TypeError;
         Object.setPrototypeOf(error, TypeError.prototype);
@@ -36,23 +35,22 @@ var convertToRequestError = function (config) {
         error.constructor = Error;
         Object.setPrototypeOf(error, Error.prototype);
     }
-    var resultError = Object.assign(error, (_a = {
-            name: "RequestError",
-            response: response,
-            code: code
-        },
-        _a[REQUEST_ERROR_SYMBOL] = true,
-        _a.attempts = context.stats.attempt,
-        _a.request = {
+    const resultError = Object.assign(error, {
+        name: "RequestError",
+        response: response,
+        code: code,
+        [REQUEST_ERROR_SYMBOL]: true,
+        attempts: context.stats.attempt,
+        request: {
             url: context.requestUrl.href,
             query: context.requestConfig.queryObject,
             headers: context.requestConfig.headers,
             body: body,
         },
-        _a));
+    });
     try {
         Object.defineProperty(resultError, "message", {
-            value: "A ".concat(context.method.toUpperCase(), " request to '").concat(context.requestUrl.href, "' failed").concat((response === null || response === void 0 ? void 0 : response.status) ? " with status code ".concat(response.status) : "", " [").concat(code, "]: ").concat(resultError.message),
+            value: `A ${context.method.toUpperCase()} request to '${context.requestUrl.href}' failed${response?.status ? ` with status code ${response.status}` : ""} [${code}]: ${resultError.message}`,
         });
     }
     catch (e) {
@@ -63,10 +61,9 @@ var convertToRequestError = function (config) {
     return resultError;
 };
 exports.convertToRequestError = convertToRequestError;
-var getErrorResponse = function (error) {
-    var _a;
+const getErrorResponse = (error) => {
     if ((0, exports.isRequestError)(error)) {
-        return (_a = error.response) !== null && _a !== void 0 ? _a : undefined;
+        return error.response ?? undefined;
     }
     return undefined;
 };