@koine/api 1.0.53 → 1.0.54

package/ApiError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Custom `ApiError` class extending `Error` to throw in failed response.
+ *
+ * @see https://eslint.org/docs/rules/no-throw-literal
+ * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
+ *
+ */
+export declare class ApiError<TResponseFail extends Koine.Api.ResponseFail = unknown> extends Error {
+    constructor(result: Koine.Api.ResultFail<TResponseFail>);
+}
+export default ApiError;

package/ApiError.js

@@ -0,0 +1,20 @@
+import { __extends } from "tslib";
+/**
+ * Custom `ApiError` class extending `Error` to throw in failed response.
+ *
+ * @see https://eslint.org/docs/rules/no-throw-literal
+ * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
+ *
+ */
+var ApiError = /** @class */ (function (_super) {
+    __extends(ApiError, _super);
+    function ApiError(result) {
+        var _this = _super.call(this, "Request failed with ".concat(result.status, " ").concat(result.msg)) || this;
+        _this.name = "ApiError";
+        Object.assign(_this, result);
+        return _this;
+    }
+    return ApiError;
+}(Error));
+export { ApiError };
+export default ApiError;

package/createApi.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create api client
+ *
+ * @param apiName Short name to use in debug logs
+ * @param baseUrl Either relativ eor absolute, it must end without trailing slash
+ */
+export declare const createApi: <TEndpoints extends Koine.Api.Endpoints>(apiName: string, baseUrl: string, options?: Koine.Api.ClientOptions) => Koine.Api.Client<TEndpoints>;
+export default createApi;

package/createApi.js

@@ -0,0 +1,127 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { buildUrlQueryString, isFullObject } from "@koine/utils";
+/**
+ * Create api client
+ *
+ * @param apiName Short name to use in debug logs
+ * @param baseUrl Either relativ eor absolute, it must end without trailing slash
+ */
+export var createApi = function (apiName, baseUrl, options) {
+    var _a = options || {}, _b = _a.headers, headersBase = _b === void 0 ? {} : _b, _c = _a.request, requestBase = _c === void 0 ? {
+        credentials: "include",
+        referrerPolicy: "no-referrer",
+        // mode: "cors",
+        // redirect: "follow",
+        // cache: "no-cache",
+    } : _c, exceptionBase = _a.exception, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, processReqBase = _a.processReq, processResBase = _a.processRes;
+    return ["get", "post", "put", "patch", "delete"].reduce(function (api, method) {
+        // @ts-expect-error FIXME: type
+        api[method] = function (endpoint, options) { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, _b, request, _c, headers, _d, timeout, _e, processReq, _f, processRes, _g, exception, _h, params, json, query, url, requestInit, transformed, key, timeoutNumber, controller, timeoutId, response, e_1, result, e_2, msg;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        _a = options || {}, _b = _a.request, request = _b === void 0 ? requestBase : _b, _c = _a.headers, headers = _c === void 0 ? headersBase : _c, _d = _a.timeout, timeout = _d === void 0 ? timeoutBase : _d, _e = _a.processReq, processReq = _e === void 0 ? processReqBase : _e, _f = _a.processRes, processRes = _f === void 0 ? processResBase : _f, _g = _a.exception, exception = _g === void 0 ? exceptionBase : _g;
+                        _h = options || {}, params = _h.params, json = _h.json, query = _h.query;
+                        url = "".concat(baseUrl, "/").concat(endpoint + "".replace(/^\/*/, ""));
+                        requestInit = __assign(__assign({ method: method.toUpperCase() }, request), { headers: __assign({ "content-type": "application/json" }, headers) });
+                        if (processReq) {
+                            transformed = processReq(method, url, query, json, params, requestInit);
+                            url = transformed[0];
+                            query = transformed[1];
+                            json = transformed[2];
+                            params = transformed[3];
+                            requestInit = transformed[4];
+                        }
+                        if (isFullObject(params)) {
+                            for (key in params) {
+                                endpoint = endpoint.replace("{".concat(key, "}"), params[key].toString());
+                            }
+                        }
+                        timeoutNumber = Number(timeout);
+                        if (method !== "get" && json) {
+                            requestInit.body = JSON.stringify(json);
+                        }
+                        if (timeoutNumber > 0) {
+                            controller = new AbortController();
+                            timeoutId = setTimeout(function () { return controller.abort(); }, timeoutNumber);
+                            requestInit.signal = controller.signal;
+                        }
+                        if (query) {
+                            // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
+                            url += buildUrlQueryString(query);
+                        }
+                        if (!exception) return [3 /*break*/, 5];
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, fetch(url, requestInit)];
+                    case 2:
+                        response = _j.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _j.sent();
+                        // eslint-disable-next-line no-throw-literal
+                        throw { e: e_1 };
+                    case 4: return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, fetch(url, requestInit)];
+                    case 6:
+                        response = _j.sent();
+                        _j.label = 7;
+                    case 7:
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        if (!exception) return [3 /*break*/, 15];
+                        _j.label = 8;
+                    case 8:
+                        _j.trys.push([8, 13, , 14]);
+                        if (!processRes) return [3 /*break*/, 10];
+                        return [4 /*yield*/, processRes(response, options || {})];
+                    case 9:
+                        result = _j.sent();
+                        return [3 /*break*/, 12];
+                    case 10: return [4 /*yield*/, response.json()];
+                    case 11:
+                        result = _j.sent();
+                        _j.label = 12;
+                    case 12: return [3 /*break*/, 14];
+                    case 13:
+                        e_2 = _j.sent();
+                        // eslint-disable-next-line no-throw-literal
+                        throw { e: e_2 };
+                    case 14: return [3 /*break*/, 19];
+                    case 15:
+                        if (!processRes) return [3 /*break*/, 17];
+                        return [4 /*yield*/, processRes(response, options || {})];
+                    case 16:
+                        result = _j.sent();
+                        return [3 /*break*/, 19];
+                    case 17: return [4 /*yield*/, response.json()];
+                    case 18:
+                        result = _j.sent();
+                        _j.label = 19;
+                    case 19:
+                        if (exception && result.fail) {
+                            // throw new ApiError<Failed>(result);
+                            // I prefer to throw an object literal despite what eslint says
+                            // eslint-disable-next-line no-throw-literal
+                            throw result;
+                        }
+                        if (process.env["NODE_ENV"] !== "production") {
+                            msg = "".concat(result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
+                            if (result.ok) {
+                                console.log("\uD83D\uDFE2 ".concat(msg));
+                            }
+                            else {
+                                console.log("\uD83D\uDD34 ".concat(msg));
+                            }
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        }); };
+        return api;
+    }, {});
+};
+export default createApi;

package/createSwrApi.d.ts

@@ -0,0 +1,14 @@
+import { type SWRConfiguration, type SWRResponse } from "swr";
+import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
+declare type KoineApiMethodHookSWR<THookName extends keyof Koine.Api.HooksMapsByName, TEndpoints extends Koine.Api.Endpoints> = <TEndpoint extends Koine.Api.EndpointUrl<TEndpoints>, TMethod extends Koine.Api.RequestMethod = Koine.Api.HooksMapsByName[THookName]>(endpoint: TEndpoint, options?: Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, config?: THookName extends "useGet" ? SWRConfiguration<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationConfiguration<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>) => THookName extends "useGet" ? SWRResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>;
+/**
+ * It creates an api client extended with auto-generated SWR wrapper hooks
+ */
+export declare const createSwrApi: <TEndpoints extends Koine.Api.Endpoints>(apiName: string, baseUrl: string, options?: Koine.Api.ClientOptions | undefined) => Koine.Api.Client<TEndpoints> & {
+    useGet: KoineApiMethodHookSWR<"useGet", TEndpoints>;
+    usePost: KoineApiMethodHookSWR<"usePost", TEndpoints>;
+    usePut: KoineApiMethodHookSWR<"usePut", TEndpoints>;
+    usePatch: KoineApiMethodHookSWR<"usePatch", TEndpoints>;
+    useDelete: KoineApiMethodHookSWR<"useDelete", TEndpoints>;
+};
+export default createSwrApi;

package/createSwrApi.js

@@ -0,0 +1,83 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import useSWR from "swr";
+import useSWRMutation from "swr/mutation";
+import { createApi } from "./createApi";
+function createUseApi(api, method) {
+    return function useApi(endpoint, options, _config) {
+        var _this = this;
+        if (method === "get") {
+            // const fetcher = async (_endpoint: TEndpoint) => {
+            //   try {
+            //     const { ok, data } = await api[method](_endpoint, {
+            //         ...(options || {}),
+            //         exception: true,
+            //       });
+            //       if (ok) {
+            //         return data;
+            //       }
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;
+            //     } catch(e) {
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;;
+            //     }
+            //   };
+            // }
+            var fetcher = function () { return __awaiter(_this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api[method](endpoint, __assign(__assign({}, (options || {})), { exception: true }))];
+                        case 1:
+                            data = (_a.sent()).data;
+                            return [2 /*return*/, data];
+                    }
+                });
+            }); };
+            var config_1 = _config;
+            // <Data = any, Error = any>(key: Key, config: SWRConfiguration<Data, Error, Fetcher<Data>> | undefined): SWRResponse<Data, Error>;
+            // eslint-disable-next-line react-hooks/rules-of-hooks
+            return useSWR(options ? [endpoint, options] : [endpoint], fetcher, config_1);
+        }
+        var config = _config;
+        var sender = function (
+        // if the first argument is an array the second tem are the base options
+        // defined when calling the usePost/Put/etc. hook, these will be overriden
+        // by the _options just here below
+        _endpoint, 
+        // these are the options arriving when calling `trigger({ json, query, etc... })
+        _options) { return __awaiter(_this, void 0, void 0, function () {
+            var endpoint, options, _a, ok, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        endpoint = Array.isArray(_endpoint) ? _endpoint[0] : _endpoint;
+                        options = Array.isArray(_endpoint) ? _endpoint[1] : {};
+                        return [4 /*yield*/, api[method](endpoint, __assign(__assign(__assign({}, options), (_options.arg || {})), { exception: true }))];
+                    case 1:
+                        _a = _b.sent(), ok = _a.ok, data = _a.data;
+                        return [2 /*return*/, ok ? data : data];
+                }
+            });
+        }); };
+        // config.fetcher = sender;
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        return useSWRMutation(
+        // @ts-expect-error FIXME: I can't get it...
+        options ? [endpoint, options] : endpoint, sender, config);
+    };
+}
+/**
+ * It creates an api client extended with auto-generated SWR wrapper hooks
+ */
+export var createSwrApi = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var api = createApi.apply(void 0, args);
+    ["get", "post", "put", "patch", "delete"].forEach(function (method) {
+        var hookName = "use".concat(method.charAt(0).toUpperCase() + method.slice(1));
+        api[hookName] = createUseApi(api, method);
+    });
+    return api;
+};
+export default createSwrApi;

package/index.d.ts

@@ -1,3 +1,4 @@
-export * from "./core";
-export * from "./next";
-export * from "./swr";
+export * from "./ApiError";
+export * from "./createApi";
+export * from "./createSwrApi";
+export * from "./nextApiResponse";

package/index.js

@@ -1,3 +1,4 @@
-export * from "./core";
-export * from "./next";
-export * from "./swr";
+export * from "./ApiError";
+export * from "./createApi";
+export * from "./createSwrApi";
+export * from "./nextApiResponse";

package/nextApiResponse.d.ts

@@ -0,0 +1,3 @@
+import type { NextApiResponse } from "next";
+export declare const nextApiResponse: (nextRes: NextApiResponse, result: Koine.Api.ResultOk | Koine.Api.ResultFail) => void;
+export default nextApiResponse;

package/nextApiResponse.js

@@ -0,0 +1,5 @@
+export var nextApiResponse = function (nextRes, result) {
+    // nextRes.status(result.status).json(result.data || result.msg);
+    nextRes.status(result.status).json(result);
+};
+export default nextApiResponse;

package/node/ApiError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Custom `ApiError` class extending `Error` to throw in failed response.
+ *
+ * @see https://eslint.org/docs/rules/no-throw-literal
+ * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
+ *
+ */
+var ApiError = /** @class */ (function (_super) {
+    tslib_1.__extends(ApiError, _super);
+    function ApiError(result) {
+        var _this = _super.call(this, "Request failed with ".concat(result.status, " ").concat(result.msg)) || this;
+        _this.name = "ApiError";
+        Object.assign(_this, result);
+        return _this;
+    }
+    return ApiError;
+}(Error));
+exports.ApiError = ApiError;
+exports.default = ApiError;

package/node/{core/index.js → createApi.js}

@@ -1,26 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createApi = exports.ApiError = void 0;
+exports.createApi = void 0;
 var tslib_1 = require("tslib");
 var utils_1 = require("@koine/utils");
-/**
- * Custom `ApiError` class extending `Error` to throw in failed response.
- *
- * @see https://eslint.org/docs/rules/no-throw-literal
- * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
- *
- */
-var ApiError = /** @class */ (function (_super) {
-    tslib_1.__extends(ApiError, _super);
-    function ApiError(result) {
-        var _this = _super.call(this, "Request failed with ".concat(result.status, " ").concat(result.msg)) || this;
-        _this.name = "ApiError";
-        Object.assign(_this, result);
-        return _this;
-    }
-    return ApiError;
-}(Error));
-exports.ApiError = ApiError;
 /**
  * Create api client
  *
@@ -34,22 +16,32 @@ var createApi = function (apiName, baseUrl, options) {
         // mode: "cors",
         // redirect: "follow",
         // cache: "no-cache",
-    } : _c, shouldThrowBase = _a.shouldThrow, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, transformRequestBase = _a.transformRequest, transformResponseBase = _a.transformResponse;
+    } : _c, exceptionBase = _a.exception, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, processReqBase = _a.processReq, processResBase = _a.processRes;
     return ["get", "post", "put", "patch", "delete"].reduce(function (api, method) {
+        // @ts-expect-error FIXME: type
         api[method] = function (endpoint, options) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-            var _a, params, json, query, _b, request, _c, headers, _d, timeout, _e, transformRequest, _f, transformResponse, _g, shouldThrow, requestInit, key, timeoutNumber, controller, timeoutId, url, response, e_1, result, e_2, msg;
-            return tslib_1.__generator(this, function (_h) {
-                switch (_h.label) {
+            var _a, _b, request, _c, headers, _d, timeout, _e, processReq, _f, processRes, _g, exception, _h, params, json, query, url, requestInit, transformed, key, timeoutNumber, controller, timeoutId, response, e_1, result, e_2, msg;
+            return tslib_1.__generator(this, function (_j) {
+                switch (_j.label) {
                     case 0:
-                        _a = options || {}, params = _a.params, json = _a.json, query = _a.query, _b = _a.request, request = _b === void 0 ? requestBase : _b, _c = _a.headers, headers = _c === void 0 ? headersBase : _c, _d = _a.timeout, timeout = _d === void 0 ? timeoutBase : _d, _e = _a.transformRequest, transformRequest = _e === void 0 ? transformRequestBase : _e, _f = _a.transformResponse, transformResponse = _f === void 0 ? transformResponseBase : _f, _g = _a.shouldThrow, shouldThrow = _g === void 0 ? shouldThrowBase : _g;
+                        _a = options || {}, _b = _a.request, request = _b === void 0 ? requestBase : _b, _c = _a.headers, headers = _c === void 0 ? headersBase : _c, _d = _a.timeout, timeout = _d === void 0 ? timeoutBase : _d, _e = _a.processReq, processReq = _e === void 0 ? processReqBase : _e, _f = _a.processRes, processRes = _f === void 0 ? processResBase : _f, _g = _a.exception, exception = _g === void 0 ? exceptionBase : _g;
+                        _h = options || {}, params = _h.params, json = _h.json, query = _h.query;
+                        url = "".concat(baseUrl, "/").concat(endpoint + "".replace(/^\/*/, ""));
                         requestInit = tslib_1.__assign(tslib_1.__assign({ method: method.toUpperCase() }, request), { headers: tslib_1.__assign({ "content-type": "application/json" }, headers) });
+                        if (processReq) {
+                            transformed = processReq(method, url, query, json, params, requestInit);
+                            url = transformed[0];
+                            query = transformed[1];
+                            json = transformed[2];
+                            params = transformed[3];
+                            requestInit = transformed[4];
+                        }
                         if ((0, utils_1.isFullObject)(params)) {
                             for (key in params) {
                                 endpoint = endpoint.replace("{".concat(key, "}"), params[key].toString());
                             }
                         }
                         timeoutNumber = Number(timeout);
-                        url = "".concat(baseUrl, "/").concat(endpoint + "".replace(/^\/*/, ""));
                         if (method !== "get" && json) {
                             requestInit.body = JSON.stringify(json);
                         }
@@ -58,65 +50,62 @@ var createApi = function (apiName, baseUrl, options) {
                             timeoutId = setTimeout(function () { return controller.abort(); }, timeoutNumber);
                             requestInit.signal = controller.signal;
                         }
-                        if (transformRequest) {
-                            requestInit = transformRequest(requestInit);
-                        }
                         if (query) {
                             // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
                             url += (0, utils_1.buildUrlQueryString)(query);
                         }
-                        if (!shouldThrow) return [3 /*break*/, 5];
-                        _h.label = 1;
+                        if (!exception) return [3 /*break*/, 5];
+                        _j.label = 1;
                     case 1:
-                        _h.trys.push([1, 3, , 4]);
+                        _j.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, fetch(url, requestInit)];
                     case 2:
-                        response = _h.sent();
+                        response = _j.sent();
                         return [3 /*break*/, 4];
                     case 3:
-                        e_1 = _h.sent();
+                        e_1 = _j.sent();
                         // eslint-disable-next-line no-throw-literal
                         throw { e: e_1 };
                     case 4: return [3 /*break*/, 7];
                     case 5: return [4 /*yield*/, fetch(url, requestInit)];
                     case 6:
-                        response = _h.sent();
-                        _h.label = 7;
+                        response = _j.sent();
+                        _j.label = 7;
                     case 7:
                         if (timeoutId) {
                             clearTimeout(timeoutId);
                         }
-                        if (!shouldThrow) return [3 /*break*/, 15];
-                        _h.label = 8;
+                        if (!exception) return [3 /*break*/, 15];
+                        _j.label = 8;
                     case 8:
-                        _h.trys.push([8, 13, , 14]);
-                        if (!transformResponse) return [3 /*break*/, 10];
-                        return [4 /*yield*/, transformResponse(response, options || {})];
+                        _j.trys.push([8, 13, , 14]);
+                        if (!processRes) return [3 /*break*/, 10];
+                        return [4 /*yield*/, processRes(response, options || {})];
                     case 9:
-                        result = _h.sent();
+                        result = _j.sent();
                         return [3 /*break*/, 12];
                     case 10: return [4 /*yield*/, response.json()];
                     case 11:
-                        result = _h.sent();
-                        _h.label = 12;
+                        result = _j.sent();
+                        _j.label = 12;
                     case 12: return [3 /*break*/, 14];
                     case 13:
-                        e_2 = _h.sent();
+                        e_2 = _j.sent();
                         // eslint-disable-next-line no-throw-literal
                         throw { e: e_2 };
                     case 14: return [3 /*break*/, 19];
                     case 15:
-                        if (!transformResponse) return [3 /*break*/, 17];
-                        return [4 /*yield*/, transformResponse(response, options || {})];
+                        if (!processRes) return [3 /*break*/, 17];
+                        return [4 /*yield*/, processRes(response, options || {})];
                     case 16:
-                        result = _h.sent();
+                        result = _j.sent();
                         return [3 /*break*/, 19];
                     case 17: return [4 /*yield*/, response.json()];
                     case 18:
-                        result = _h.sent();
-                        _h.label = 19;
+                        result = _j.sent();
+                        _j.label = 19;
                     case 19:
-                        if (shouldThrow && result.fail) {
+                        if (exception && result.fail) {
                             // throw new ApiError<Failed>(result);
                             // I prefer to throw an object literal despite what eslint says
                             // eslint-disable-next-line no-throw-literal
@@ -139,3 +128,4 @@ var createApi = function (apiName, baseUrl, options) {
     }, {});
 };
 exports.createApi = createApi;
+exports.default = exports.createApi;

package/node/{swr/index.js → createSwrApi.js}

@@ -4,7 +4,7 @@ exports.createSwrApi = void 0;
 var tslib_1 = require("tslib");
 var swr_1 = require("swr");
 var mutation_1 = require("swr/mutation");
-var core_1 = require("../core");
+var createApi_1 = require("./createApi");
 function createUseApi(api, method) {
     return function useApi(endpoint, options, _config) {
         var _this = this;
@@ -13,7 +13,7 @@ function createUseApi(api, method) {
             //   try {
             //     const { ok, data } = await api[method](_endpoint, {
             //         ...(options || {}),
-            //         shouldThrow: true,
+            //         exception: true,
             //       });
             //       if (ok) {
             //         return data;
@@ -28,7 +28,7 @@ function createUseApi(api, method) {
                 var data;
                 return tslib_1.__generator(this, function (_a) {
                     switch (_a.label) {
-                        case 0: return [4 /*yield*/, api[method](endpoint, tslib_1.__assign(tslib_1.__assign({}, (options || {})), { shouldThrow: true }))];
+                        case 0: return [4 /*yield*/, api[method](endpoint, tslib_1.__assign(tslib_1.__assign({}, (options || {})), { exception: true }))];
                         case 1:
                             data = (_a.sent()).data;
                             return [2 /*return*/, data];
@@ -54,7 +54,7 @@ function createUseApi(api, method) {
                     case 0:
                         endpoint = Array.isArray(_endpoint) ? _endpoint[0] : _endpoint;
                         options = Array.isArray(_endpoint) ? _endpoint[1] : {};
-                        return [4 /*yield*/, api[method](endpoint, tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, options), (_options.arg || {})), { shouldThrow: true }))];
+                        return [4 /*yield*/, api[method](endpoint, tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, options), (_options.arg || {})), { exception: true }))];
                     case 1:
                         _a = _b.sent(), ok = _a.ok, data = _a.data;
                         return [2 /*return*/, ok ? data : data];
@@ -76,7 +76,7 @@ var createSwrApi = function () {
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
-    var api = core_1.createApi.apply(void 0, args);
+    var api = createApi_1.createApi.apply(void 0, args);
     ["get", "post", "put", "patch", "delete"].forEach(function (method) {
         var hookName = "use".concat(method.charAt(0).toUpperCase() + method.slice(1));
         api[hookName] = createUseApi(api, method);
@@ -84,3 +84,4 @@ var createSwrApi = function () {
     return api;
 };
 exports.createSwrApi = createSwrApi;
+exports.default = exports.createSwrApi;

package/node/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./core"), exports);
-tslib_1.__exportStar(require("./next"), exports);
-tslib_1.__exportStar(require("./swr"), exports);
+tslib_1.__exportStar(require("./ApiError"), exports);
+tslib_1.__exportStar(require("./createApi"), exports);
+tslib_1.__exportStar(require("./createSwrApi"), exports);
+tslib_1.__exportStar(require("./nextApiResponse"), exports);

package/node/{next/index.js → nextApiResponse.js}

@@ -6,3 +6,4 @@ var nextApiResponse = function (nextRes, result) {
     nextRes.status(result.status).json(result);
 };
 exports.nextApiResponse = nextApiResponse;
+exports.default = exports.nextApiResponse;

package/package.json

@@ -5,12 +5,12 @@
   "typings": "./index.d.ts",
   "dependencies": {},
   "peerDependencies": {
-    "@koine/utils": "1.0.53",
-    "next": "^12.2.0",
+    "@koine/utils": "1.0.54",
     "swr": "^2.0.0-beta.6",
+    "next": "^12.2.0",
     "tslib": "^2.4.0"
   },
-  "version": "1.0.53",
+  "version": "1.0.54",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/typings.d.ts

@@ -54,7 +54,7 @@ declare namespace Koine.Api {
      *
      * @default false
      */
-    shouldThrow?: boolean;
+    exception?: boolean;
     /**
      * Timeout in `ms`, if `falsy` there is no timeout
      *
@@ -62,17 +62,17 @@ declare namespace Koine.Api {
      */
     timeout?: number | false | null;
     /**
-     * Transform request before actual http call
+     * Process request before actual http call
      *
      * @default undefined
      */
-    transformRequest?: RequestTransformer;
+    processReq?: RequestProcessor;
     /**
-     * Transform response just after http response
+     * Process response just after http response
      *
      * @default undefined
      */
-    transformResponse?: ResponseTransformer;
+    processRes?: ResponseProcessor;
   };
 
   type ClientMethod<
@@ -80,7 +80,7 @@ declare namespace Koine.Api {
     TEndpoints extends Endpoints
   > = <
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TOptions extends EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>,
+    TOptions extends EndpointOptions<TEndpoints, TEndpoint, TMethod>,
     TOk extends ResponseOk = EndpointResponseOk<TEndpoints, TEndpoint, TMethod>,
     TFail extends ResponseFail = EndpointResponseFail<
       TEndpoints,
@@ -90,7 +90,7 @@ declare namespace Koine.Api {
   >(
     endpoint: TEndpoint,
     options?: TOptions
-  ) => Promise<EndpointResponse<TEndpoints, TEndpoint, TMethod>>;
+  ) => Promise<EndpointResult<TEndpoints, TEndpoint, TMethod>>;
   // ) => Promise<Result<TOk, TFail>>;
 
   /**
@@ -106,15 +106,16 @@ declare namespace Koine.Api {
   //
   //////////////////////////////////////////////////////////////////////////////
 
-  type EndpointRequestOptions<
+  type EndpointOptions<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod
   > = RequestOptions<
+    TEndpoints,
+    TEndpoint,
     TMethod,
     TEndpoints[TEndpoint][Uppercase<TMethod>]["json"],
-    TEndpoints[TEndpoint][Uppercase<TMethod>]["query"],
-    TEndpoint
+    TEndpoints[TEndpoint][Uppercase<TMethod>]["query"]
   >;
 
   type EndpointResultOk<
@@ -141,7 +142,7 @@ declare namespace Koine.Api {
     TMethod extends RequestMethod
   > = TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"];
 
-  type EndpointResponse<
+  type EndpointResult<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod
@@ -213,21 +214,30 @@ declare namespace Koine.Api {
   //
   //////////////////////////////////////////////////////////////////////////////
 
+  type RequestMethod = "get" | "post" | "put" | "patch" | "delete";
+
   type RequestJson = undefined | null | Record<string | number, unknown>;
 
   type RequestQuery = undefined | null | Record<string | number, unknown>;
 
+  type RequestParams =
+    | undefined
+    | null
+    | Record<string | number, string | number>;
+
   /**
    * Request options
    *
    * `ClientOptions` can be overriden here at the single request level.
    */
   type RequestOptions<
+    TEndpoints extends Endpoints,
+    TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod,
     TJson extends RequestJson = RequestJson,
-    TQuery extends RequestQuery = RequestQuery,
-    TEndpoint extends EndpointUrl<TEndpoints> = ""
-  > = ClientOptions & {
+    TQuery extends RequestQuery = RequestQuery
+  > = Omit<ClientOptions, "processReq"> & {
+    processReq?: EndpointRequestProcessor<TEndpoints, TEndpoint, TMethod>;
     /**
      * A dictionary to dynamically interpolate endpoint url params, e.g.:
      *
@@ -241,25 +251,28 @@ declare namespace Koine.Api {
      * Query parameters will be serialized into a string and appended to the URL
      */
     query?: TQuery;
-  } & ([TMethod] extends ["get"]
-      ? {
-          /**
-           * JSON request body
-           *
-           * FIXME: this should be `undefined` here but it breaks
-           */
-          json?: TJson;
-        }
-      : {
-          /**
-           * JSON request body
-           *
-           * @default {}
-           */
-          json?: TJson;
-        });
-
-  type RequestMethod = "get" | "post" | "put" | "patch" | "delete";
+    /**
+     * JSON request body
+     *
+     * FIXME: this should be `undefined` with `get` request mehod
+     */
+    json?: TJson;
+  };
+  // } & ([TMethod] extends ["get"]
+  //     ? {
+  //         /**
+  //          * JSON request body
+  //          */
+  //         json?: TJson;
+  //       }
+  //     : {
+  //         /**
+  //          * JSON request body
+  //          *
+  //          * @default {}
+  //          */
+  //         json?: TJson;
+  //       });
 
   //////////////////////////////////////////////////////////////////////////////
   //
@@ -298,11 +311,6 @@ declare namespace Koine.Api {
     TResponseOk extends ResponseOk,
     TResponseFail extends ResponseFail
   > =
-    // FIXME: without the type duplication below the following two lines do not
-    // work as they do not narrow the type when checking for the boolean values
-    // truthiness
-    // | ResultOk<TOk>
-    // | ResultFail<TOk>;
     | {
         status: _Response["status"];
         msg: _Response["statusText"];
@@ -318,9 +326,53 @@ declare namespace Koine.Api {
         data: TResponseFail;
       };
 
-  type RequestTransformer = (request: RequestInit) => RequestInit;
+  /**
+   * The request processor at the client level, this is meant to apply global
+   * transformations to all endpoints requests
+   */
+  type RequestProcessor = (
+    method: RequestMethod,
+    url: string,
+    query: any,
+    json: any,
+    params: any,
+    requestInit: RequestInit
+  ) => [
+    string, // url
+    RequestQuery, // query
+    RequestJson, // json
+    RequestParams, // params
+    RequestInit // requestInit
+  ];
+
+  /**
+   * The request processor at the request level, this is meant to apply
+   * transformations to a single endpoint request
+   */
+  type EndpointRequestProcessor<
+    TEndpoints extends Endpoints,
+    TEndpoint extends EndpointUrl<TEndpoints>,
+    TMethod extends RequestMethod
+  > = (
+    method: TMethod,
+    url: string,
+    query: EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"],
+    json: EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"],
+    params: EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"],
+    requestInit: RequestInit
+  ) => [
+    string, // url
+    EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"], // query
+    EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"], // json
+    EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"], // params
+    RequestInit // requestInit
+  ];
 
-  type ResponseTransformer = <
+  /**
+   * The response processor at the request level, this is meant to apply
+   * transformations to a single endpoint response
+   */
+  type ResponseProcessor = <
     TResponseOk extends ResponseOk = ResponseOk,
     TResponseFail extends ResponseFailed = ResponseFailed
   >(