@koine/api 1.0.51 → 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/core/index.js

@@ -1,5 +1,5 @@
 import { __assign, __awaiter, __extends, __generator } from "tslib";
-import { buildUrlQueryString } from "@koine/utils";
+import { buildUrlQueryString, isFullObject } from "@koine/utils";
 /**
  * Custom `ApiError` class extending `Error` to throw in failed response.
  *
@@ -25,24 +25,24 @@ export { ApiError };
  * @param baseUrl Either relativ eor absolute, it must end without trailing slash
  */
 export var createApi = function (apiName, baseUrl, options) {
-    var _a = options || {}, transformRequestBase = _a.transformRequest, transformResponseBase = _a.transformResponse, _b = _a.request, requestBase = _b === void 0 ? {
+    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",
-    } : _b, shouldThrowBase = _a.shouldThrow;
+    } : _c, shouldThrowBase = _a.shouldThrow, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, transformRequestBase = _a.transformRequest, transformResponseBase = _a.transformResponse;
     return ["get", "post", "put", "patch", "delete"].reduce(function (api, method) {
         api[method] = function (endpoint, options) { return __awaiter(void 0, void 0, void 0, function () {
-            var _a, json, path, params, _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;
+            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 __generator(this, function (_h) {
                 switch (_h.label) {
                     case 0:
-                        _a = options || {}, json = _a.json, path = _a.path, params = _a.params, _b = _a.request, request = _b === void 0 ? requestBase : _b, _c = _a.headers, headers = _c === void 0 ? {} : _c, _d = _a.timeout, timeout = _d === void 0 ? 10000 : _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 || {}, 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;
                         requestInit = __assign(__assign({ method: method.toUpperCase() }, request), { headers: __assign({ "content-type": "application/json" }, headers) });
-                        if (path && Object.keys(path).length) {
-                            for (key in path) {
-                                endpoint = endpoint.replace("{".concat(key, "}"), path[key].toString());
+                        if (isFullObject(params)) {
+                            for (key in params) {
+                                endpoint = endpoint.replace("{".concat(key, "}"), params[key].toString());
                             }
                         }
                         timeoutNumber = Number(timeout);
@@ -58,10 +58,9 @@ export var createApi = function (apiName, baseUrl, options) {
                         if (transformRequest) {
                             requestInit = transformRequest(requestInit);
                         }
-                        if (params) {
+                        if (query) {
                             // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
-                            // url += buildUrlQueryString(params as unknown as Koine.Api.RequestParams);
-                            url += buildUrlQueryString(params);
+                            url += buildUrlQueryString(query);
                         }
                         if (!shouldThrow) return [3 /*break*/, 5];
                         _h.label = 1;
@@ -123,10 +122,10 @@ export var createApi = function (apiName, baseUrl, options) {
                         if (process.env["NODE_ENV"] !== "production") {
                             msg = "".concat(result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
                             if (result.ok) {
-                                console.log("[@koine] \uD83D\uDFE2 ".concat(msg));
+                                console.log("\uD83D\uDFE2 ".concat(msg));
                             }
                             else {
-                                console.log("[@koine] \uD83D\uDD34 ".concat(msg));
+                                console.log("\uD83D\uDD34 ".concat(msg));
                             }
                         }
                         return [2 /*return*/, result];

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
  *
@@ -28,28 +10,38 @@ exports.ApiError = ApiError;
  * @param baseUrl Either relativ eor absolute, it must end without trailing slash
  */
 var createApi = function (apiName, baseUrl, options) {
-    var _a = options || {}, transformRequestBase = _a.transformRequest, transformResponseBase = _a.transformResponse, _b = _a.request, requestBase = _b === void 0 ? {
+    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",
-    } : _b, shouldThrowBase = _a.shouldThrow;
+    } : _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, json, path, params, _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 || {}, json = _a.json, path = _a.path, params = _a.params, _b = _a.request, request = _b === void 0 ? requestBase : _b, _c = _a.headers, headers = _c === void 0 ? {} : _c, _d = _a.timeout, timeout = _d === void 0 ? 10000 : _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 (path && Object.keys(path).length) {
-                            for (key in path) {
-                                endpoint = endpoint.replace("{".concat(key, "}"), path[key].toString());
+                        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,66 +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 (params) {
+                        if (query) {
                             // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
-                            // url += buildUrlQueryString(params as unknown as Koine.Api.RequestParams);
-                            url += (0, utils_1.buildUrlQueryString)(params);
+                            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
@@ -126,10 +114,10 @@ var createApi = function (apiName, baseUrl, options) {
                         if (process.env["NODE_ENV"] !== "production") {
                             msg = "".concat(result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
                             if (result.ok) {
-                                console.log("[@koine] \uD83D\uDFE2 ".concat(msg));
+                                console.log("\uD83D\uDFE2 ".concat(msg));
                             }
                             else {
-                                console.log("[@koine] \uD83D\uDD34 ".concat(msg));
+                                console.log("\uD83D\uDD34 ".concat(msg));
                             }
                         }
                         return [2 /*return*/, result];
@@ -140,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];
@@ -46,7 +46,7 @@ function createUseApi(api, method) {
         // 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, params, etc... })
+        // these are the options arriving when calling `trigger({ json, query, etc... })
         _options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var endpoint, options, _a, ok, data;
             return tslib_1.__generator(this, function (_b) {
@@ -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.51",
-    "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.51",
+  "version": "1.0.54",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/swr/index.js

@@ -43,7 +43,7 @@ function createUseApi(api, method) {
         // 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, params, etc... })
+        // 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) {

package/typings.d.ts

@@ -2,6 +2,19 @@
 
 type _Response = Response;
 
+/**
+ * @borrows [awesome-template-literal-types](https://github.com/ghoullier/awesome-template-literal-types#router-params-parsing)
+ */
+type ExtractEndpointParams<T extends string> = string extends T
+  ? Record<string, string>
+  : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  T extends `${infer _Start}{${infer Param}}${infer Rest}`
+  ? { [k in Param | keyof ExtractEndpointParams<Rest>]: string | number }
+  : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  T extends `${infer _Start}{${infer Param}}`
+  ? { [k in Param]: string | number }
+  : never;
+
 declare namespace Koine.Api {
   // @see https://stackoverflow.com/a/60702896/1938970
   // import { Exact } from "type-fest";
@@ -19,6 +32,15 @@ declare namespace Koine.Api {
   ) => Client<TEndpoints>;
 
   type ClientOptions = {
+    /**
+     * Headers will be merged with
+     * ```
+     * { "content-type": "application/json" }
+     * ```
+     *
+     * @default {}
+     */
+    headers?: RequestInit["headers"];
     /**
      * Basic request options to supply to `fetch`
      *
@@ -27,9 +49,30 @@ declare namespace Koine.Api {
      * @default { credentials: "include", referrerPolicy: "no-referrer" }
      */
     request?: Omit<RequestInit, "body" | "headers" | "method">;
-    transformRequest?: RequestTransformer;
-    transformResponse?: ResponseTransformer;
-    shouldThrow?: boolean;
+    /**
+     * Flag to throw error with try/catch
+     *
+     * @default false
+     */
+    exception?: boolean;
+    /**
+     * Timeout in `ms`, if `falsy` there is no timeout
+     *
+     * @default 10000
+     */
+    timeout?: number | false | null;
+    /**
+     * Process request before actual http call
+     *
+     * @default undefined
+     */
+    processReq?: RequestProcessor;
+    /**
+     * Process response just after http response
+     *
+     * @default undefined
+     */
+    processRes?: ResponseProcessor;
   };
 
   type ClientMethod<
@@ -37,13 +80,9 @@ declare namespace Koine.Api {
     TEndpoints extends Endpoints
   > = <
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TOptions extends EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>,
-    TSuccesfull extends Koine.Api.DataSuccesfull = Koine.Api.EndpointResponseOk<
-      TEndpoints,
-      TEndpoint,
-      TMethod
-    >,
-    TFailed extends Koine.Api.DataFailed = Koine.Api.EndpointResponseFail<
+    TOptions extends EndpointOptions<TEndpoints, TEndpoint, TMethod>,
+    TOk extends ResponseOk = EndpointResponseOk<TEndpoints, TEndpoint, TMethod>,
+    TFail extends ResponseFail = EndpointResponseFail<
       TEndpoints,
       TEndpoint,
       TMethod
@@ -51,8 +90,8 @@ declare namespace Koine.Api {
   >(
     endpoint: TEndpoint,
     options?: TOptions
-    // ) => Promise<EndpointResponse<TEndpoints, TEndpoint, TMethod>>;
-  ) => Promise<Result<TSuccesfull, TFailed>>;
+  ) => Promise<EndpointResult<TEndpoints, TEndpoint, TMethod>>;
+  // ) => Promise<Result<TOk, TFail>>;
 
   /**
    * The `api` interface generated by `createApi`
@@ -67,14 +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>]["params"]
+    TEndpoints[TEndpoint][Uppercase<TMethod>]["query"]
   >;
 
   type EndpointResultOk<
@@ -101,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
@@ -155,7 +196,7 @@ declare namespace Koine.Api {
     /**
      * The parameters to encode in the URL of the request
      */
-    params?: RequestParams;
+    query?: RequestQuery;
     /**
      * The JSON response data returned by the request in case of success
      */
@@ -173,83 +214,65 @@ declare namespace Koine.Api {
   //
   //////////////////////////////////////////////////////////////////////////////
 
+  type RequestMethod = "get" | "post" | "put" | "patch" | "delete";
+
   type RequestJson = undefined | null | Record<string | number, unknown>;
 
-  type RequestParams = undefined | null | Record<string | number, unknown>;
+  type RequestQuery = undefined | null | Record<string | number, unknown>;
+
+  type RequestParams =
+    | undefined
+    | null
+    | Record<string | number, string | number>;
 
   /**
-   * Shared request options (for every request method)
+   * Request options
    *
-   * Client options can be overriden here at request level.
+   * `ClientOptions` can be overriden here at the single request level.
    */
-  type RequestOptionsShared = ClientOptions & {
-    /**
-     * Headers will be merged with
-     * ```
-     * { "content-type": "application/json" }
-     * ```
-     */
-    headers?: RequestInit["headers"];
+  type RequestOptions<
+    TEndpoints extends Endpoints,
+    TEndpoint extends EndpointUrl<TEndpoints>,
+    TMethod extends RequestMethod,
+    TJson extends RequestJson = RequestJson,
+    TQuery extends RequestQuery = RequestQuery
+  > = Omit<ClientOptions, "processReq"> & {
+    processReq?: EndpointRequestProcessor<TEndpoints, TEndpoint, TMethod>;
     /**
-     * Timeout in `ms`, if `falsy` there is no timeout
+     * A dictionary to dynamically interpolate endpoint url params, e.g.:
      *
-     * @default 10000
+     * ```js
+     * myapi.get("user/{id}", { path: { id: "12" }})
+     * ```
+     * results in a call to the endpoint `"user/12"`
      */
-    timeout?: number | false | null;
+    params?: ExtractEndpointParams<TEndpoint>;
     /**
-     * Basic request options to supply to `fetch`
-     *
-     * @see RequestInit
-     *
-     * @default { credentials: "include", referrerPolicy: "no-referrer" }
+     * Query parameters will be serialized into a string and appended to the URL
      */
-    request?: Omit<RequestInit, "body" | "headers" | "method">;
+    query?: TQuery;
     /**
-     * A dictionary to dynamically interpolate endpoint url values, e.g.:
+     * JSON request body
      *
-     * ```
-     * "user/{id}" endpoint with { path: { id: "12" }} results in a call
-     * to the endpoint "user/12"
-     * ```
+     * FIXME: this should be `undefined` with `get` request mehod
      */
-    path?: Record<string, string | number>;
+    json?: TJson;
   };
-
-  /**
-   * Request options
-   *
-   * Client options can be overriden here at request level.
-   */
-  type RequestOptions<
-    TMethod extends RequestMethod,
-    TJson extends Record<string, unknown> = {},
-    TParams extends RequestParams = {}
-  > = RequestOptionsShared &
-    ([TMethod] extends ["get"]
-      ? {
-          /**
-           * JSON request body
-           */
-          json?: TJson;
-          /**
-           * Params will be serialized into a string and appended to the URL
-           */
-          params?: TParams;
-        }
-      : {
-          /**
-           * JSON request body
-           *
-           * @default {}
-           */
-          json?: TJson;
-          /**
-           * Params will be serialized into a string and appended to the URL
-           */
-          params?: TParams;
-        });
-
-  type RequestMethod = "get" | "post" | "put" | "patch" | "delete";
+  // } & ([TMethod] extends ["get"]
+  //     ? {
+  //         /**
+  //          * JSON request body
+  //          */
+  //         json?: TJson;
+  //       }
+  //     : {
+  //         /**
+  //          * JSON request body
+  //          *
+  //          * @default {}
+  //          */
+  //         json?: TJson;
+  //       });
 
   //////////////////////////////////////////////////////////////////////////////
   //
@@ -288,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"];
@@ -308,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
   >(