@koine/api 2.0.0-beta.13 → 2.0.0-beta.15

package/ApiError.d.ts

@@ -1,10 +1,4 @@
-/**
- * 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
- *
- */
+/// <reference types="./typings.d.ts" />
 export declare class ApiError<TResponseFail extends Koine.Api.ResponseFail = unknown> extends Error {
     constructor(result: Koine.Api.ResultFail<TResponseFail>);
 }

package/ApiError.js

@@ -0,0 +1,13 @@
+import { __extends } from "tslib";
+var ApiError = (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/cjs/ApiError.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="./typings.d.ts" />
+export declare class ApiError<TResponseFail extends Koine.Api.ResponseFail = unknown> extends Error {
+    constructor(result: Koine.Api.ResultFail<TResponseFail>);
+}
+export default ApiError;

package/cjs/ApiError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+var tslib_1 = require("tslib");
+var ApiError = (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/cjs/createApi.d.ts

@@ -0,0 +1,2 @@
+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/cjs/createApi.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApi = void 0;
+var tslib_1 = require("tslib");
+var buildUrlQueryString_1 = require("@koine/utils/buildUrlQueryString");
+var errorToString_1 = require("@koine/utils/errorToString");
+var isFullObject_1 = require("@koine/utils/isFullObject");
+var createApi = function (apiName, baseUrl, options) {
+    var _a = options || {}, _b = _a.headers, headersBase = _b === void 0 ? {} : _b, _c = _a.request, requestBase = _c === void 0 ? {} : _c, throwErrBase = _a.throwErr, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, processReqBase = _a.processReq, processResBase = _a.processRes, processErrBase = _a.processErr;
+    return ["get", "post", "put", "patch", "delete"].reduce(function (api, method) {
+        api[method] = function (endpoint, options) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            var _a, _b, request, _c, headers, _d, timeout, processReq, _e, processRes, _f, processErr, _g, throwErr, _h, params, json, query, url, requestInit, transformed, transformed, key, timeoutNumber, controller, timeoutId, response, result, msg, e_1, e_2, logMsg;
+            return tslib_1.__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, processReq = _a.processReq, _e = _a.processRes, processRes = _e === void 0 ? processResBase : _e, _f = _a.processErr, processErr = _f === void 0 ? processErrBase : _f, _g = _a.throwErr, throwErr = _g === void 0 ? throwErrBase : _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 (processReqBase) {
+                            transformed = processReqBase(method, url, query, json, params, requestInit);
+                            url = transformed[0];
+                            query = transformed[1];
+                            json = transformed[2];
+                            params = transformed[3];
+                            requestInit = transformed[4];
+                        }
+                        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, isFullObject_1.default)(params)) {
+                            for (key in params) {
+                                url = url.replace("{".concat(key, "}"), params[key].toString());
+                            }
+                        }
+                        timeoutNumber = Number(timeout);
+                        if (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) {
+                            url += (0, buildUrlQueryString_1.default)(query);
+                        }
+                        response = null;
+                        result = null;
+                        msg = "";
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 3, , 4]);
+                        return [4, fetch(url, requestInit)];
+                    case 2:
+                        response = _j.sent();
+                        return [3, 4];
+                    case 3:
+                        e_1 = _j.sent();
+                        msg = (0, errorToString_1.default)(e_1);
+                        return [3, 4];
+                    case 4:
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        if (!response) return [3, 11];
+                        _j.label = 5;
+                    case 5:
+                        _j.trys.push([5, 10, , 11]);
+                        if (!processRes) return [3, 7];
+                        return [4, processRes(response, options || {})];
+                    case 6:
+                        result = _j.sent();
+                        return [3, 9];
+                    case 7: return [4, response.json()];
+                    case 8:
+                        result = _j.sent();
+                        _j.label = 9;
+                    case 9: return [3, 11];
+                    case 10:
+                        e_2 = _j.sent();
+                        msg = (0, errorToString_1.default)(e_2);
+                        return [3, 11];
+                    case 11:
+                        if (!(result === null)) return [3, 14];
+                        if (!processErr) return [3, 13];
+                        return [4, processErr(msg, options || {})];
+                    case 12:
+                        result = _j.sent();
+                        return [3, 14];
+                    case 13:
+                        result = {
+                            data: null,
+                            msg: msg,
+                            status: 100,
+                            fail: true,
+                            ok: false,
+                        };
+                        _j.label = 14;
+                    case 14:
+                        if (throwErr && (result === null || result === void 0 ? void 0 : result.fail)) {
+                            throw result;
+                        }
+                        if (process.env["NODE_ENV"] !== "production") {
+                            logMsg = "".concat(result === null || result === void 0 ? void 0 : result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
+                            if (result === null || result === void 0 ? void 0 : result.ok) {
+                                console.info("\uD83D\uDFE2 ".concat(logMsg));
+                            }
+                            else {
+                                console.info("\uD83D\uDD34 ".concat(logMsg));
+                            }
+                        }
+                        return [2, result];
+                }
+            });
+        }); };
+        return api;
+    }, {});
+};
+exports.createApi = createApi;
+exports.default = exports.createApi;

package/cjs/createApiResultFail.d.ts

@@ -0,0 +1,2 @@
+export declare const createApiResultFail: <T>(data?: T, msg?: string, status?: number) => Koine.Api.ResultFail<T>;
+export default createApiResultFail;

package/cjs/createApiResultFail.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiResultFail = void 0;
+var createApiResultFail = function (data, msg, status) {
+    if (data === void 0) { data = {}; }
+    return ({
+        fail: true,
+        data: data,
+        msg: msg || "",
+        status: status || 404,
+    });
+};
+exports.createApiResultFail = createApiResultFail;
+exports.default = exports.createApiResultFail;

package/cjs/createApiResultOk.d.ts

@@ -0,0 +1,2 @@
+export declare const createApiResultOk: <T>(data?: T, msg?: string) => Koine.Api.ResultOk<T>;
+export default createApiResultOk;

package/cjs/createApiResultOk.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiResultOk = void 0;
+var createApiResultOk = function (data, msg) {
+    if (data === void 0) { data = {}; }
+    return ({
+        ok: true,
+        fail: false,
+        data: data,
+        msg: msg || "",
+        status: 200,
+    });
+};
+exports.createApiResultOk = createApiResultOk;
+exports.default = exports.createApiResultOk;

package/cjs/createSwrApi.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="./typings.d.ts" />
+import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
+import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
+type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
+    when?: boolean | (() => boolean);
+};
+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" ? SWRConfigurationExtended<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>;
+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/cjs/createSwrApi.js

@@ -0,0 +1,61 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwrApi = void 0;
+var tslib_1 = require("tslib");
+var swr_1 = require("swr");
+var mutation_1 = require("swr/mutation");
+var isFunction_1 = require("@koine/utils/isFunction");
+var createApi_1 = require("./createApi");
+function createUseApi(api, method) {
+    return function useApi(endpoint, options, _config) {
+        var _this = this;
+        if (method === "get") {
+            var fetcher = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var data;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, api[method](endpoint, tslib_1.__assign(tslib_1.__assign({}, (options || {})), { throwErr: true }))];
+                        case 1:
+                            data = (_a.sent()).data;
+                            return [2, data];
+                    }
+                });
+            }); };
+            var config_1 = _config;
+            var shouldNotFetch = (config_1 === null || config_1 === void 0 ? void 0 : config_1.when) === false ||
+                ((0, isFunction_1.default)(config_1 === null || config_1 === void 0 ? void 0 : config_1.when) && (config_1 === null || config_1 === void 0 ? void 0 : config_1.when()) === false);
+            return (0, swr_1.default)(shouldNotFetch ? null : options ? [endpoint, options] : [endpoint], fetcher, config_1);
+        }
+        var config = _config;
+        var sender = function (_endpoint, _options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var endpoint, options, _a, ok, data;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        endpoint = Array.isArray(_endpoint) ? _endpoint[0] : _endpoint;
+                        options = Array.isArray(_endpoint) ? _endpoint[1] : {};
+                        return [4, api[method](endpoint, tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, options), (_options.arg || {})), { throwErr: true }))];
+                    case 1:
+                        _a = _b.sent(), ok = _a.ok, data = _a.data;
+                        return [2, ok ? data : data];
+                }
+            });
+        }); };
+        return (0, mutation_1.default)(options ? [endpoint, options] : endpoint, sender, config);
+    };
+}
+var createSwrApi = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var api = createApi_1.default.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;
+};
+exports.createSwrApi = createSwrApi;
+exports.default = exports.createSwrApi;

package/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextApiResponse12 = exports.createSwrApi = exports.createApiResultOk = exports.createApiResultFail = exports.createApi = exports.ApiError = void 0;
+var ApiError_1 = require("./ApiError");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return ApiError_1.ApiError; } });
+var createApi_1 = require("./createApi");
+Object.defineProperty(exports, "createApi", { enumerable: true, get: function () { return createApi_1.createApi; } });
+var createApiResultFail_1 = require("./createApiResultFail");
+Object.defineProperty(exports, "createApiResultFail", { enumerable: true, get: function () { return createApiResultFail_1.createApiResultFail; } });
+var createApiResultOk_1 = require("./createApiResultOk");
+Object.defineProperty(exports, "createApiResultOk", { enumerable: true, get: function () { return createApiResultOk_1.createApiResultOk; } });
+var createSwrApi_1 = require("./createSwrApi");
+Object.defineProperty(exports, "createSwrApi", { enumerable: true, get: function () { return createSwrApi_1.createSwrApi; } });
+var nextApiResponse12_1 = require("./nextApiResponse12");
+Object.defineProperty(exports, "nextApiResponse12", { enumerable: true, get: function () { return nextApiResponse12_1.nextApiResponse12; } });

package/cjs/nextApiResponse.d.ts

@@ -0,0 +1,6 @@
+import { NextResponse } from "next/server";
+export declare const nextApiResponse: {
+    ok<T>(data: T, msg?: string): NextResponse<Koine.Api.ResultOk<T>>;
+    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<Koine.Api.ResultFail<T_1>>;
+};
+export default nextApiResponse;

package/cjs/nextApiResponse.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextApiResponse = void 0;
+var server_1 = require("next/server");
+var createApiResultFail_1 = require("./createApiResultFail");
+var createApiResultOk_1 = require("./createApiResultOk");
+exports.nextApiResponse = {
+    ok: function (data, msg) {
+        return server_1.NextResponse.json((0, createApiResultOk_1.default)(data, msg));
+    },
+    fail: function (data, msg, status) {
+        return server_1.NextResponse.json((0, createApiResultFail_1.default)(data, msg, status));
+    },
+};
+exports.default = exports.nextApiResponse;

package/cjs/nextApiResponse12.d.ts

@@ -0,0 +1,6 @@
+import type { NextApiResponse } from "next";
+export declare const nextApiResponse12: (nextRes: NextApiResponse) => {
+    ok<T>(data: T, msg?: string): void;
+    fail<T_1>(data: T_1, msg?: string, status?: number): void;
+};
+export default nextApiResponse12;

package/cjs/nextApiResponse12.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextApiResponse12 = void 0;
+var createApiResultFail_1 = require("./createApiResultFail");
+var createApiResultOk_1 = require("./createApiResultOk");
+var nextApiResponse12 = function (nextRes) {
+    return {
+        ok: function (data, msg) {
+            nextRes.status(200).json((0, createApiResultOk_1.default)(data, msg));
+        },
+        fail: function (data, msg, status) {
+            nextRes
+                .status(status || 404)
+                .json((0, createApiResultFail_1.default)(data, msg, status));
+        },
+    };
+};
+exports.nextApiResponse12 = nextApiResponse12;
+exports.default = exports.nextApiResponse12;

package/cjs/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@koine/api",
+  "sideEffects": false,
+  "dependencies": {
+    "@koine/utils": "*"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    },
+    "swr": {
+      "optional": true
+    }
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/createApi.d.ts

@@ -1,8 +1,2 @@
-/**
- * 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,122 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import buildUrlQueryString from "@koine/utils/buildUrlQueryString";
+import errorToString from "@koine/utils/errorToString";
+import isFullObject from "@koine/utils/isFullObject";
+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 ? {} : _c, throwErrBase = _a.throwErr, _d = _a.timeout, timeoutBase = _d === void 0 ? 10000 : _d, processReqBase = _a.processReq, processResBase = _a.processRes, processErrBase = _a.processErr;
+    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, _b, request, _c, headers, _d, timeout, processReq, _e, processRes, _f, processErr, _g, throwErr, _h, params, json, query, url, requestInit, transformed, transformed, key, timeoutNumber, controller, timeoutId, response, result, msg, e_1, e_2, logMsg;
+            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, processReq = _a.processReq, _e = _a.processRes, processRes = _e === void 0 ? processResBase : _e, _f = _a.processErr, processErr = _f === void 0 ? processErrBase : _f, _g = _a.throwErr, throwErr = _g === void 0 ? throwErrBase : _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 (processReqBase) {
+                            transformed = processReqBase(method, url, query, json, params, requestInit);
+                            url = transformed[0];
+                            query = transformed[1];
+                            json = transformed[2];
+                            params = transformed[3];
+                            requestInit = transformed[4];
+                        }
+                        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) {
+                                url = url.replace("{".concat(key, "}"), params[key].toString());
+                            }
+                        }
+                        timeoutNumber = Number(timeout);
+                        if (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) {
+                            url += buildUrlQueryString(query);
+                        }
+                        response = null;
+                        result = null;
+                        msg = "";
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 3, , 4]);
+                        return [4, fetch(url, requestInit)];
+                    case 2:
+                        response = _j.sent();
+                        return [3, 4];
+                    case 3:
+                        e_1 = _j.sent();
+                        msg = errorToString(e_1);
+                        return [3, 4];
+                    case 4:
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        if (!response) return [3, 11];
+                        _j.label = 5;
+                    case 5:
+                        _j.trys.push([5, 10, , 11]);
+                        if (!processRes) return [3, 7];
+                        return [4, processRes(response, options || {})];
+                    case 6:
+                        result = _j.sent();
+                        return [3, 9];
+                    case 7: return [4, response.json()];
+                    case 8:
+                        result = _j.sent();
+                        _j.label = 9;
+                    case 9: return [3, 11];
+                    case 10:
+                        e_2 = _j.sent();
+                        msg = errorToString(e_2);
+                        return [3, 11];
+                    case 11:
+                        if (!(result === null)) return [3, 14];
+                        if (!processErr) return [3, 13];
+                        return [4, processErr(msg, options || {})];
+                    case 12:
+                        result = _j.sent();
+                        return [3, 14];
+                    case 13:
+                        result = {
+                            data: null,
+                            msg: msg,
+                            status: 100,
+                            fail: true,
+                            ok: false,
+                        };
+                        _j.label = 14;
+                    case 14:
+                        if (throwErr && (result === null || result === void 0 ? void 0 : result.fail)) {
+                            throw result;
+                        }
+                        if (process.env["NODE_ENV"] !== "production") {
+                            logMsg = "".concat(result === null || result === void 0 ? void 0 : result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
+                            if (result === null || result === void 0 ? void 0 : result.ok) {
+                                console.info("\uD83D\uDFE2 ".concat(logMsg));
+                            }
+                            else {
+                                console.info("\uD83D\uDD34 ".concat(logMsg));
+                            }
+                        }
+                        return [2, result];
+                }
+            });
+        }); };
+        return api;
+    }, {});
+};
+export default createApi;

package/createApiResultFail.js

@@ -0,0 +1,10 @@
+export var createApiResultFail = function (data, msg, status) {
+    if (data === void 0) { data = {}; }
+    return ({
+        fail: true,
+        data: data,
+        msg: msg || "",
+        status: status || 404,
+    });
+};
+export default createApiResultFail;

package/createApiResultOk.js

@@ -0,0 +1,11 @@
+export var createApiResultOk = function (data, msg) {
+    if (data === void 0) { data = {}; }
+    return ({
+        ok: true,
+        fail: false,
+        data: data,
+        msg: msg || "",
+        status: 200,
+    });
+};
+export default createApiResultOk;

package/createSwrApi.d.ts

@@ -1,29 +1,10 @@
-import { type BareFetcher, // type Fetcher,
-type SWRConfiguration, type SWRResponse } from "swr";
+/// <reference types="./typings.d.ts" />
+import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
 import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
 type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
-    /**
-     * Conditional fetching as option
-     *
-     * Moving this to an option allows us to keep the endpoints typed dictionary,
-     * e.g. we can write:
-     *
-     * ```js
-     * const { data, mutate } = myApi.useGet("User/{id}",
-     *  { params: { id: aVariableMaybeContainingAnId || "" }, },
-     *  { when: !!aVariableMaybeContainingAnId }
-     * );
-     *
-     * // we still have typed `data`, `mutate`
-     * ```
-     * @see https://swr.vercel.app/docs/conditional-fetching
-     */
     when?: boolean | (() => boolean);
 };
 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" ? SWRConfigurationExtended<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>;

package/createSwrApi.js

@@ -0,0 +1,57 @@
+"use client";
+import { __assign, __awaiter, __generator } from "tslib";
+import useSWR from "swr";
+import useSWRMutation from "swr/mutation";
+import isFunction from "@koine/utils/isFunction";
+import createApi from "./createApi.js";
+function createUseApi(api, method) {
+    return function useApi(endpoint, options, _config) {
+        var _this = this;
+        if (method === "get") {
+            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, api[method](endpoint, __assign(__assign({}, (options || {})), { throwErr: true }))];
+                        case 1:
+                            data = (_a.sent()).data;
+                            return [2, data];
+                    }
+                });
+            }); };
+            var config_1 = _config;
+            var shouldNotFetch = (config_1 === null || config_1 === void 0 ? void 0 : config_1.when) === false ||
+                (isFunction(config_1 === null || config_1 === void 0 ? void 0 : config_1.when) && (config_1 === null || config_1 === void 0 ? void 0 : config_1.when()) === false);
+            return useSWR(shouldNotFetch ? null : options ? [endpoint, options] : [endpoint], fetcher, config_1);
+        }
+        var config = _config;
+        var sender = function (_endpoint, _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, api[method](endpoint, __assign(__assign(__assign({}, options), (_options.arg || {})), { throwErr: true }))];
+                    case 1:
+                        _a = _b.sent(), ok = _a.ok, data = _a.data;
+                        return [2, ok ? data : data];
+                }
+            });
+        }); };
+        return useSWRMutation(options ? [endpoint, options] : endpoint, sender, config);
+    };
+}
+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,6 +1,6 @@
-export { ApiError } from "./ApiError";
-export { createApi } from "./createApi";
-export { createApiResultFail } from "./createApiResultFail";
-export { createApiResultOk } from "./createApiResultOk";
-export { createSwrApi } from "./createSwrApi";
-export { nextApiResponse12 } from "./nextApiResponse12";
+export { ApiError } from "./ApiError.js";
+export { createApi } from "./createApi.js";
+export { createApiResultFail } from "./createApiResultFail.js";
+export { createApiResultOk } from "./createApiResultOk.js";
+export { createSwrApi } from "./createSwrApi.js";
+export { nextApiResponse12 } from "./nextApiResponse12.js";

package/index.js

@@ -0,0 +1,6 @@
+export { ApiError } from "./ApiError.js";
+export { createApi } from "./createApi.js";
+export { createApiResultFail } from "./createApiResultFail.js";
+export { createApiResultOk } from "./createApiResultOk.js";
+export { createSwrApi } from "./createSwrApi.js";
+export { nextApiResponse12 } from "./nextApiResponse12.js";

package/nextApiResponse.d.ts

@@ -1,5 +1,6 @@
+import { NextResponse } from "next/server";
 export declare const nextApiResponse: {
-    ok<T>(data: T, msg?: string): void;
-    fail<T_1>(data: T_1, msg?: string, status?: number): void;
+    ok<T>(data: T, msg?: string): NextResponse<Koine.Api.ResultOk<T>>;
+    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<Koine.Api.ResultFail<T_1>>;
 };
 export default nextApiResponse;

package/nextApiResponse.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import createApiResultFail from "./createApiResultFail.js";
+import createApiResultOk from "./createApiResultOk.js";
+export var nextApiResponse = {
+    ok: function (data, msg) {
+        return NextResponse.json(createApiResultOk(data, msg));
+    },
+    fail: function (data, msg, status) {
+        return NextResponse.json(createApiResultFail(data, msg, status));
+    },
+};
+export default nextApiResponse;

package/nextApiResponse12.js

@@ -0,0 +1,15 @@
+import createApiResultFail from "./createApiResultFail.js";
+import createApiResultOk from "./createApiResultOk.js";
+export var nextApiResponse12 = function (nextRes) {
+    return {
+        ok: function (data, msg) {
+            nextRes.status(200).json(createApiResultOk(data, msg));
+        },
+        fail: function (data, msg, status) {
+            nextRes
+                .status(status || 404)
+                .json(createApiResultFail(data, msg, status));
+        },
+    };
+};
+export default nextApiResponse12;

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@koine/api",
   "sideEffects": false,
+  "dependencies": {
+    "@koine/utils": "2.0.0-beta.15"
+  },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
@@ -9,12 +12,44 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "@koine/utils": "2.0.0-beta.13"
-  },
-  "module": "./index.mjs",
-  "main": "./index.js",
+  "main": "./cjs/index.js",
   "types": "./index.d.ts",
+  "type": "module",
+  "module": "./index.js",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "import": "./index.js"
+    },
+    "./ApiError": {
+      "require": "./cjs/ApiError.js",
+      "import": "./ApiError.js"
+    },
+    "./createApi": {
+      "require": "./cjs/createApi.js",
+      "import": "./createApi.js"
+    },
+    "./createApiResultFail": {
+      "require": "./cjs/createApiResultFail.js",
+      "import": "./createApiResultFail.js"
+    },
+    "./createApiResultOk": {
+      "require": "./cjs/createApiResultOk.js",
+      "import": "./createApiResultOk.js"
+    },
+    "./createSwrApi": {
+      "require": "./cjs/createSwrApi.js",
+      "import": "./createSwrApi.js"
+    },
+    "./nextApiResponse": {
+      "require": "./cjs/nextApiResponse.js",
+      "import": "./nextApiResponse.js"
+    },
+    "./nextApiResponse12": {
+      "require": "./cjs/nextApiResponse12.js",
+      "import": "./nextApiResponse12.js"
+    }
+  },
   "peerDependencies": {},
-  "version": "2.0.0-beta.13"
-}
+  "version": "2.0.0-beta.15"
+}

package/typings.d.ts

@@ -15,7 +15,7 @@ type ExtractEndpointParams<T extends string> = string extends T
   ? { [k in Param]: string | number }
   : never;
 
-declare namespace Koine.Api {
+namespace Koine.Api {
   // @see https://stackoverflow.com/a/60702896/1938970
   // import { Exact } from "type-fest";
 
@@ -28,7 +28,7 @@ declare namespace Koine.Api {
   type ClientCreator<TEndpoints extends Endpoints> = (
     apiName: string,
     baseUrl: string,
-    options?: ClientOptions
+    options?: ClientOptions,
   ) => Client<TEndpoints>;
 
   type ClientOptions = {
@@ -46,7 +46,7 @@ declare namespace Koine.Api {
      *
      * @see RequestInit
      *
-     * @default { credentials: "include", referrerPolicy: "no-referrer" }
+     * @default {}
      */
     request?: Omit<RequestInit, "body" | "headers" | "method">;
     /**
@@ -85,7 +85,7 @@ declare namespace Koine.Api {
 
   type ClientMethod<
     TMethod extends RequestMethod,
-    TEndpoints extends Endpoints
+    TEndpoints extends Endpoints,
   > = <
     TEndpoint extends EndpointUrl<TEndpoints>,
     TOptions extends EndpointOptions<TEndpoints, TEndpoint, TMethod>,
@@ -94,10 +94,10 @@ declare namespace Koine.Api {
       TEndpoints,
       TEndpoint,
       TMethod
-    >
+    >,
   >(
     endpoint: TEndpoint,
-    options?: TOptions
+    options?: TOptions,
   ) => Promise<EndpointResult<TEndpoints, TEndpoint, TMethod>>;
   // ) => Promise<Result<TOk, TFail>>;
 
@@ -117,7 +117,7 @@ declare namespace Koine.Api {
   type EndpointOptions<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = RequestOptions<
     TEndpoints,
     TEndpoint,
@@ -129,31 +129,31 @@ declare namespace Koine.Api {
   type EndpointResultOk<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = ResultOk<TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"]>;
 
   type EndpointResultFail<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = ResultFail<TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"]>;
 
   type EndpointResponseOk<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"];
 
   type EndpointResponseFail<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"];
 
   type EndpointResult<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = Result<
     EndpointResponseOk<TEndpoints, TEndpoint, TMethod>,
     EndpointResponseFail<TEndpoints, TEndpoint, TMethod>
@@ -240,7 +240,7 @@ declare namespace Koine.Api {
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod,
     TJson extends RequestJson,
-    TQuery extends RequestQuery
+    TQuery extends RequestQuery,
   > = Omit<ClientOptions, "processReq"> & {
     processReq?: EndpointRequestProcessor<TEndpoints, TEndpoint, TMethod>;
     /**
@@ -273,7 +273,7 @@ declare namespace Koine.Api {
   type ResponseFail = unknown;
 
   type ResultShared<
-    T extends Record<string, unknown> = Record<string, unknown>
+    T extends Record<string, unknown> = Record<string, unknown>,
   > = T & {
     status: _Response["status"];
     msg: _Response["statusText"];
@@ -297,7 +297,7 @@ declare namespace Koine.Api {
 
   type Result<
     TResponseOk extends ResponseOk,
-    TResponseFail extends ResponseFail
+    TResponseFail extends ResponseFail,
   > =
     | {
         status: _Response["status"];
@@ -324,13 +324,13 @@ declare namespace Koine.Api {
     query: any,
     json: any,
     params: any,
-    requestInit: RequestInit
+    requestInit: RequestInit,
   ) => [
     string, // url
     RequestQuery, // query
     RequestJson, // json
     RequestParams, // params
-    RequestInit // requestInit
+    RequestInit, // requestInit
   ];
 
   /**
@@ -343,20 +343,20 @@ declare namespace Koine.Api {
   type EndpointRequestProcessor<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    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
+    requestInit: RequestInit,
   ) => [
     string, // url
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"], // query
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"], // json
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"], // params
-    RequestInit // requestInit
+    RequestInit, // requestInit
   ];
 
   /**
@@ -365,7 +365,7 @@ declare namespace Koine.Api {
    */
   type ResponseProcessorRes = <TResponseOk extends ResponseOk = ResponseOk>(
     response: _Response,
-    options: TOptions
+    options: TOptions,
   ) => Promise<Koine.Api.Result<TResponseOk>>;
 
   /**
@@ -373,10 +373,10 @@ declare namespace Koine.Api {
    * transformations to a single or all endpoint responses
    */
   type ResponseProcessorErr = <
-    TResponseFail extends ResponseFailed = ResponseFailed
+    TResponseFail extends ResponseFailed = ResponseFailed,
   >(
     msg: string,
-    options: TOptions
+    options: TOptions,
   ) => Promise<Koine.Api.Result<TResponseFail>>;
 
   //////////////////////////////////////////////////////////////////////////////

package/ApiError.mjs

@@ -1,14 +0,0 @@
-/**
- * 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 class ApiError extends Error {
-    constructor(result){
-        super(`Request failed with ${result.status} ${result.msg}`);
-        this.name = "ApiError";
-        Object.assign(this, result);
-    }
-}
-export default ApiError;

package/README.md

@@ -1 +0,0 @@
-# @koine/api

package/createApi.mjs

@@ -1,128 +0,0 @@
-import buildUrlQueryString from "@koine/utils/buildUrlQueryString";
-import errorToString from "@koine/utils/errorToString";
-import isFullObject from "@koine/utils/isFullObject";
-/**
- * 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 const createApi = (apiName, baseUrl, options)=>{
-    const { headers: headersBase = {}, request: requestBase = {
-        referrerPolicy: "no-referrer"
-    }, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase } = options || {};
-    return [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].reduce((api, method)=>{
-        // @ts-expect-error FIXME: type
-        api[method] = async (endpoint, options)=>{
-            const { request = requestBase, headers = headersBase, timeout = timeoutBase, processReq, processRes = processResBase, processErr = processErrBase, throwErr = throwErrBase } = options || {};
-            let { params, json, query } = options || {};
-            let url = `${baseUrl}/${endpoint + "".replace(/^\/*/, "")}`;
-            let requestInit = {
-                method: method.toUpperCase(),
-                ...request,
-                headers: {
-                    "content-type": "application/json",
-                    ...headers
-                }
-            };
-            if (processReqBase) {
-                const transformed = processReqBase(method, url, query, json, params, requestInit);
-                url = transformed[0];
-                query = transformed[1];
-                json = transformed[2];
-                params = transformed[3];
-                requestInit = transformed[4];
-            }
-            if (processReq) {
-                const 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(const key in params){
-                    url = url.replace(`{${key}}`, params[key].toString());
-                }
-            }
-            const timeoutNumber = Number(timeout);
-            let controller;
-            let timeoutId;
-            if (json) {
-                requestInit.body = JSON.stringify(json);
-            }
-            if (timeoutNumber > 0) {
-                controller = new AbortController();
-                timeoutId = setTimeout(()=>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);
-            }
-            let response = null;
-            let result = null;
-            let msg = "";
-            try {
-                response = await fetch(url, requestInit);
-            } catch (e) {
-                msg = errorToString(e);
-            }
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            if (response) {
-                try {
-                    if (processRes) {
-                        result = await processRes(response, options || {});
-                    } else {
-                        result = await response.json();
-                    }
-                } catch (e) {
-                    msg = errorToString(e);
-                }
-            }
-            if (result === null) {
-                if (processErr) {
-                    result = await processErr(msg, options || {});
-                } else {
-                    // this error should only happen on network errors or wrong API urls
-                    // there is no specific HTTP error for this, we can consider these
-                    // two statuses though:
-                    // - [100 Continue](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/100)
-                    // - [501 Not Implemented](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501)
-                    result = {
-                        data: null,
-                        msg,
-                        status: 100,
-                        fail: true,
-                        ok: false
-                    };
-                }
-            }
-            if (throwErr && 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") {
-                const logMsg = `${result?.status}: api[${apiName}] ${method.toUpperCase()} ${url}`;
-                if (result?.ok) {
-                    console.info(`🟢 ${logMsg}`);
-                } else {
-                    console.info(`🔴 ${logMsg}`);
-                }
-            }
-            return result;
-        };
-        return api;
-    }, {});
-};
-export default createApi;

package/createApiResultFail.mjs

@@ -1,7 +0,0 @@
-export const createApiResultFail = (data = {}, msg, status)=>({
-        fail: true,
-        data,
-        msg: msg || "",
-        status: status || 404
-    });
-export default createApiResultFail;

package/createApiResultOk.mjs

@@ -1,8 +0,0 @@
-export const createApiResultOk = (data = {}, msg)=>({
-        ok: true,
-        fail: false,
-        data,
-        msg: msg || "",
-        status: 200
-    });
-export default createApiResultOk;

package/createSwrApi.mjs

@@ -1,82 +0,0 @@
-"use client";
-import useSWR from "swr";
-import useSWRMutation from "swr/mutation";
-import isFunction from "@koine/utils/isFunction";
-import createApi from "./createApi";
-function createUseApi(api, method) {
-    return function useApi(endpoint, options, _config) {
-        if (method === "get") {
-            // const fetcher = async (_endpoint: TEndpoint) => {
-            //   try {
-            //     const { ok, data } = await api[method](_endpoint, {
-            //         ...(options || {}),
-            //         throwErr: 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>;;
-            //     }
-            //   };
-            // }
-            const fetcher = async ()=>{
-                const { data } = await api[method](endpoint, {
-                    ...options || {},
-                    throwErr: true
-                });
-                return data;
-            };
-            const config = _config;
-            const shouldNotFetch = config?.when === false || isFunction(config?.when) && config?.when() === false;
-            // <Data = any, Error = any>(key: Key, config: SWRConfigurationExtended<Data, Error, Fetcher<Data>> | undefined): SWRResponse<Data, Error>;
-            // eslint-disable-next-line react-hooks/rules-of-hooks
-            return useSWR(shouldNotFetch ? null : options ? [
-                endpoint,
-                options
-            ] : [
-                endpoint
-            ], fetcher, config);
-        }
-        const config = _config;
-        const sender = async (// 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)=>{
-            const endpoint = Array.isArray(_endpoint) ? _endpoint[0] : _endpoint;
-            const options = Array.isArray(_endpoint) ? _endpoint[1] : {};
-            const { ok, data } = await api[method](endpoint, {
-                ...options,
-                ..._options.arg || {},
-                throwErr: true
-            });
-            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 const createSwrApi = (...args)=>{
-    const api = createApi(...args);
-    [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].forEach((method)=>{
-        const hookName = `use${method.charAt(0).toUpperCase() + method.slice(1)}`;
-        api[hookName] = createUseApi(api, method);
-    });
-    return api;
-};
-export default createSwrApi;

package/nextApiResponse.mjs

@@ -1,12 +0,0 @@
-import { NextResponse } from "next/server";
-import createApiResultFail from "./createApiResultFail";
-import createApiResultOk from "./createApiResultOk";
-export const nextApiResponse = {
-    ok (data, msg) {
-        NextResponse.json(createApiResultOk(data, msg));
-    },
-    fail (data, msg, status) {
-        NextResponse.json(createApiResultFail(data, msg, status));
-    }
-};
-export default nextApiResponse;

package/nextApiResponse12.mjs

@@ -1,13 +0,0 @@
-import createApiResultFail from "./createApiResultFail";
-import createApiResultOk from "./createApiResultOk";
-export const nextApiResponse12 = (nextRes)=>{
-    return {
-        ok (data, msg) {
-            nextRes.status(200).json(createApiResultOk(data, msg));
-        },
-        fail (data, msg, status) {
-            nextRes.status(status || 404).json(createApiResultFail(data, msg, status));
-        }
-    };
-};
-export default nextApiResponse12;