@koine/api 1.0.20 → 1.0.21

package/core/index.d.ts

@@ -5,8 +5,8 @@
  * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
  *
  */
-export declare class ApiError<DataFailed extends Koine.Api.DataFailed = unknown> extends Error {
-    constructor(result: Koine.Api.ResponseFailed<DataFailed>);
+export declare class ApiError<TResponseFail extends Koine.Api.ResponseFail = unknown> extends Error {
+    constructor(result: Koine.Api.ResultFail<TResponseFail>);
 }
 /**
  * Create api client

package/core/index.js

@@ -26,15 +26,15 @@ export { ApiError };
  */
 export var createApi = function (apiName, baseUrl, options) {
     var _a = options || {}, adapterBase = _a.adapter, _b = _a.request, requestBase = _b === void 0 ? {
+        credentials: "include",
+        referrerPolicy: "no-referrer",
         // mode: "cors",
         // redirect: "follow",
-        credentials: "include",
         // cache: "no-cache",
-        referrerPolicy: "no-referrer",
     } : _b, shouldThrowBase = _a.shouldThrow;
     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, params, _b, request, _c, headers, _d, timeout, _e, adapter, _f, shouldThrow, requestInit, timeoutNumber, controller, timeoutId, url, response, e_1, result, e_2, pre;
+            var _a, json, params, _b, request, _c, headers, _d, timeout, _e, adapter, _f, shouldThrow, requestInit, timeoutNumber, controller, timeoutId, url, response, e_1, result, e_2, msg;
             return __generator(this, function (_g) {
                 switch (_g.label) {
                     case 0:
@@ -113,12 +113,12 @@ export var createApi = function (apiName, baseUrl, options) {
                             throw result;
                         }
                         if (process.env["NODE_ENV"] !== "production") {
-                            pre = "api[".concat(apiName, "] ").concat(method.toUpperCase(), " to ").concat(url);
+                            msg = "".concat(result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
                             if (result.ok) {
-                                console.log("".concat(pre, " success."));
+                                console.log("[@koine] \uD83D\uDFE2 ".concat(msg));
                             }
                             else {
-                                console.log("".concat(pre, " failed."));
+                                console.log("[@koine] \uD83D\uDD34 ".concat(msg));
                             }
                         }
                         return [2 /*return*/, result];

package/next/index.d.ts

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

package/next/index.js

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

package/node/core/index.js

@@ -29,15 +29,15 @@ exports.ApiError = ApiError;
  */
 var createApi = function (apiName, baseUrl, options) {
     var _a = options || {}, adapterBase = _a.adapter, _b = _a.request, requestBase = _b === void 0 ? {
+        credentials: "include",
+        referrerPolicy: "no-referrer",
         // mode: "cors",
         // redirect: "follow",
-        credentials: "include",
         // cache: "no-cache",
-        referrerPolicy: "no-referrer",
     } : _b, shouldThrowBase = _a.shouldThrow;
     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, json, params, _b, request, _c, headers, _d, timeout, _e, adapter, _f, shouldThrow, requestInit, timeoutNumber, controller, timeoutId, url, response, e_1, result, e_2, pre;
+            var _a, json, params, _b, request, _c, headers, _d, timeout, _e, adapter, _f, shouldThrow, requestInit, timeoutNumber, controller, timeoutId, url, response, e_1, result, e_2, msg;
             return tslib_1.__generator(this, function (_g) {
                 switch (_g.label) {
                     case 0:
@@ -116,12 +116,12 @@ var createApi = function (apiName, baseUrl, options) {
                             throw result;
                         }
                         if (process.env["NODE_ENV"] !== "production") {
-                            pre = "api[".concat(apiName, "] ").concat(method.toUpperCase(), " to ").concat(url);
+                            msg = "".concat(result.status, ": api[").concat(apiName, "] ").concat(method.toUpperCase(), " ").concat(url);
                             if (result.ok) {
-                                console.log("".concat(pre, " success."));
+                                console.log("[@koine] \uD83D\uDFE2 ".concat(msg));
                             }
                             else {
-                                console.log("".concat(pre, " failed."));
+                                console.log("[@koine] \uD83D\uDD34 ".concat(msg));
                             }
                         }
                         return [2 /*return*/, result];

package/node/next/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nextApiResponse = void 0;
-var nextApiResponse = function (nextRes, response) {
-    // nextRes.status(response.status).json(response.data || response.msg);
-    nextRes.status(response.status).json(response);
+var nextApiResponse = function (nextRes, result) {
+    // nextRes.status(result.status).json(result.data || result.msg);
+    nextRes.status(result.status).json(result);
 };
 exports.nextApiResponse = nextApiResponse;

package/node/swr/index.js

@@ -18,9 +18,9 @@ function createUseApi(api, method) {
             //       if (ok) {
             //         return data;
             //       }
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>;
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;
             //     } catch(e) {
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>;;
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;;
             //     }
             //   };
             // }
@@ -41,11 +41,20 @@ function createUseApi(api, method) {
             return (0, swr_1.default)(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 _a, ok, data;
+        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, params, 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) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, api[method](_endpoint, tslib_1.__assign(tslib_1.__assign({}, (_options.arg || {})), { shouldThrow: true }))];
+                    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 }))];
                     case 1:
                         _a = _b.sent(), ok = _a.ok, data = _a.data;
                         return [2 /*return*/, ok ? data : data];
@@ -56,7 +65,7 @@ function createUseApi(api, method) {
         // eslint-disable-next-line react-hooks/rules-of-hooks
         return (0, mutation_1.default)(
         // @ts-expect-error FIXME: I can't get it...
-        options ? [endpoint, options] : [endpoint], sender, config);
+        options ? [endpoint, options] : endpoint, sender, config);
     };
 }
 /**

package/package.json

@@ -4,13 +4,13 @@
   "main": "./node/index.js",
   "typings": "./index.d.ts",
   "dependencies": {
-    "@koine/utils": "1.0.20",
+    "@koine/utils": "1.0.21",
     "next": "^12.1.6",
     "swr": "^2.0.0-beta.3",
     "tslib": "^2.4.0"
   },
   "peerDependencies": {},
-  "version": "1.0.20",
+  "version": "1.0.21",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/swr/index.d.ts

@@ -1,6 +1,6 @@
 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.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, config?: THookName extends "useGet" ? SWRConfiguration<Koine.Api.EndpointResponseSuccesfull<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>> : SWRMutationConfiguration<Koine.Api.EndpointResponseSuccesfull<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>) => THookName extends "useGet" ? SWRResponse<Koine.Api.EndpointResponseSuccesfull<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>> : SWRMutationResponse<Koine.Api.EndpointResponseSuccesfull<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>;
+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.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, config?: THookName extends "useGet" ? SWRConfiguration<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationConfiguration<Koine.Api.EndpointResultOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResultFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>) => THookName extends "useGet" ? SWRResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationResponse<Koine.Api.EndpointResultOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResultFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>;
 /**
  * It creates an api client extended with auto-generated SWR wrapper hooks
  */

package/swr/index.js

@@ -15,9 +15,9 @@ function createUseApi(api, method) {
             //       if (ok) {
             //         return data;
             //       }
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>;
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;
             //     } catch(e) {
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>;;
+            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;;
             //     }
             //   };
             // }
@@ -38,11 +38,20 @@ function createUseApi(api, method) {
             return useSWR(options ? [endpoint, options] : [endpoint], fetcher, config_1);
         }
         var config = _config;
-        var sender = function (_endpoint, _options) { return __awaiter(_this, void 0, void 0, function () {
-            var _a, ok, data;
+        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, params, 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: return [4 /*yield*/, api[method](_endpoint, __assign(__assign({}, (_options.arg || {})), { shouldThrow: true }))];
+                    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 || {})), { shouldThrow: true }))];
                     case 1:
                         _a = _b.sent(), ok = _a.ok, data = _a.data;
                         return [2 /*return*/, ok ? data : data];
@@ -53,7 +62,7 @@ function createUseApi(api, method) {
         // 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);
+        options ? [endpoint, options] : endpoint, sender, config);
     };
 }
 /**

package/typings.d.ts

@@ -37,12 +37,12 @@ declare namespace Koine.Api {
   > = <
     TEndpoint extends EndpointUrl<TEndpoints>,
     TOptions extends EndpointRequestOptions<TEndpoints, TEndpoint, TMethod>,
-    TSuccesfull extends Koine.Api.DataSuccesfull = Koine.Api.EndpointResponseSuccesfull<
+    TSuccesfull extends Koine.Api.DataSuccesfull = Koine.Api.EndpointResponseOk<
       TEndpoints,
       TEndpoint,
       TMethod
     >,
-    TFailed extends Koine.Api.DataFailed = Koine.Api.EndpointResponseFailed<
+    TFailed extends Koine.Api.DataFailed = Koine.Api.EndpointResponseFail<
       TEndpoints,
       TEndpoint,
       TMethod
@@ -72,29 +72,41 @@ declare namespace Koine.Api {
     TMethod extends RequestMethod
   > = RequestOptions<
     TMethod,
-    TEndpoints[TEndpoint][Uppercase<TMethod>]["request"],
+    TEndpoints[TEndpoint][Uppercase<TMethod>]["json"],
     TEndpoints[TEndpoint][Uppercase<TMethod>]["params"]
   >;
 
-  type EndpointResponseSuccesfull<
+  type EndpointResultOk<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod
-  > = TEndpoints[TEndpoint][Uppercase<TMethod>]["response"];
+  > = ResultOk<TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"]>;
 
-  type EndpointResponseFailed<
+  type EndpointResultFail<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod
-  > = TEndpoints[TEndpoint][Uppercase<TMethod>]["error"];
+  > = ResultFail<TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"]>;
+
+  type EndpointResponseOk<
+    TEndpoints extends Endpoints,
+    TEndpoint extends EndpointUrl<TEndpoints>,
+    TMethod extends RequestMethod
+  > = TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"];
+
+  type EndpointResponseFail<
+    TEndpoints extends Endpoints,
+    TEndpoint extends EndpointUrl<TEndpoints>,
+    TMethod extends RequestMethod
+  > = TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"];
 
   type EndpointResponse<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod
   > = Response<
-    EndpointResponseSuccesfull<TEndpoints, TEndpoint, TMethod>,
-    EndpointResponseFailed<TEndpoints, TEndpoint, TMethod>
+    EndpointResponseOk<TEndpoints, TEndpoint, TMethod>,
+    EndpointResponseFail<TEndpoints, TEndpoint, TMethod>
   >;
 
   //////////////////////////////////////////////////////////////////////////////
@@ -138,20 +150,20 @@ declare namespace Koine.Api {
     /**
      * The request body of a non-GET request
      */
-    request?: RequestJson;
-    /**
-     * The JSON response data returned by the request in case of success
-     */
-    response?: null | unknown;
+    json?: RequestJson;
     /**
      * The parameters to encode in the URL of the request
      */
     params?: RequestParams;
+    /**
+     * The JSON response data returned by the request in case of success
+     */
+    ok?: null | unknown;
     /**
      * The shape of the error data returned by the request in case of
      * failure
      */
-    error?: null | unknown;
+    fail?: null | unknown;
   };
 
   //////////////////////////////////////////////////////////////////////////////
@@ -231,65 +243,65 @@ declare namespace Koine.Api {
 
   //////////////////////////////////////////////////////////////////////////////
   //
-  // Response
+  // Response/Result
   //
   //////////////////////////////////////////////////////////////////////////////
 
-  type DataSuccesfull = unknown;
+  type ResponseOk = unknown;
 
-  type DataFailed = unknown;
+  type ResponseFail = unknown;
 
-  type ResponseShared<
+  type ResultShared<
     T extends Record<string, unknown> = Record<string, unknown>
   > = T & {
     status: _Response["status"];
     msg: _Response["statusText"];
   };
 
-  type ResponseSuccesfull<Data extends DataSuccesfull = DataSuccesfull> = {
+  type ResultOk<TResponse extends ResponseOk = ResponseOk> = {
     status: _Response["status"];
     msg: _Response["statusText"];
     ok: true;
     fail?: false;
-    data: Data;
+    data: TResponse;
   };
 
-  type ResponseFailed<Data extends DataFailed = DataFailed> = {
+  type ResultFail<TResponse extends ResponseFail = ResponseFail> = {
     status: _Response["status"];
     msg: _Response["statusText"];
     ok?: false;
     fail: true;
-    data: Data;
+    data: TResponse;
   };
 
-  type Response<Succesfull extends DataSuccesfull, Failed extends DataFailed> =
+  type Result<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
-    // | ResponseSuccesfull<Succesfull>
-    // | ResponseFailed<Succesfull>;
+    // | ResultOk<TOk>
+    // | ResultFail<TOk>;
     | {
         status: _Response["status"];
         msg: _Response["statusText"];
         ok: true;
         fail?: false;
-        data: Succesfull;
+        data: TResponseOk;
       }
     | {
         status: _Response["status"];
         msg: _Response["statusText"];
         ok?: false;
         fail: true;
-        data: Failed;
+        data: TResponseFail;
       };
 
   type ResponseAdapter = <
-    Succesfull extends DataSuccesfull = DataSuccesfull,
-    Failed extends DataFailed = DataFailed
+    TResponseOk extends ResponseOk = ResponseOk,
+    TResponseFail extends ResponseFailed = ResponseFailed
   >(
     response: _Response,
     options: TOptions
-  ) => Promise<Koine.Api.Response<Succesfull, Failed>>;
+  ) => Promise<Koine.Api.Result<TResponseOk, TResponseFail>>;
 
   //////////////////////////////////////////////////////////////////////////////
   //
@@ -348,7 +360,7 @@ declare namespace Koine.Api {
    */
   type GenerateResponseShortcuts<TEndpoints extends Endpoints> = {
     [TMethod in RequestMethod]: {
-      [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl][Uppercase<TMethod>]["response"];
+      [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl][Uppercase<TMethod>]["ok"];
     };
   };
 
@@ -363,7 +375,7 @@ declare namespace Koine.Api {
    * ```
    */
   type GenerateGetShortcuts<TEndpoints extends Endpoints> = {
-    [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl]["GET"]["response"];
+    [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl]["GET"]["ok"];
   };
 
   /**
@@ -377,12 +389,12 @@ declare namespace Koine.Api {
    * ```
    */
   type GeneratePostShortcuts<TEndpoints extends Endpoints> = {
-    [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl]["POST"]["response"];
+    [TEndpointUrl in keyof TEndpoints]: TEndpoints[TEndpointUrl]["POST"]["ok"];
   };
 
   /**
    * This is not useful as it is the same as doing
-   * `API.Endpoints["my/endpoint"]["GET"]["response"];`
+   * `API.Endpoints["my/endpoint"]["GET"]["ok"];`
    *
    * @example
    * ```ts
@@ -390,7 +402,7 @@ declare namespace Koine.Api {
    * type Response = Koine.Api.GenerateResponseShortcuts<Endpoints>;
    *
    * // consume the type wherever in your app:
-   * type MyData = API.$["my/endpoint"]["get"]["response"];
+   * type MyData = API.$["my/endpoint"]["get"]["ok"];
    * ```
    * @deprecated
    */