@koine/api 2.0.0-beta.8 → 2.0.0-beta.80

package/ApiError.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./ApiError";
+export { default } from "./ApiError";

package/ApiError.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./ApiError.cjs.js').default;

package/ApiError.cjs.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class ApiError extends Error {
+    constructor(result) {
+        super(`Request failed with ${result.status} ${result.msg}`);
+        this.name = "ApiError";
+        Object.assign(this, result);
+    }
+}
+
+exports.ApiError = ApiError;
+exports["default"] = ApiError;

package/ApiError.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './ApiError.cjs.js';
+export { _default as default } from './ApiError.cjs.default.js';

package/ApiError.d.ts

@@ -1,11 +1,5 @@
-/**
- * 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>);
+import type { Api } from "./types";
+export declare class ApiError<TResponseFail extends Api.ResponseFail = unknown> extends Error {
+    constructor(result: Api.ResultFail<TResponseFail>);
 }
 export default ApiError;

package/ApiError.esm.js

@@ -0,0 +1,9 @@
+class ApiError extends Error {
+    constructor(result) {
+        super(`Request failed with ${result.status} ${result.msg}`);
+        this.name = "ApiError";
+        Object.assign(this, result);
+    }
+}
+
+export { ApiError, ApiError as default };

package/createApi.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./createApi";
+export { default } from "./createApi";

package/createApi.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./createApi.cjs.js').default;

package/{createApi.js → createApi.cjs.js}

@@ -1,39 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createApi: function() {
-        return createApi;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _buildUrlQueryString = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/buildUrlQueryString"));
-const _errorToString = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/errorToString"));
-const _isFullObject = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/isFullObject"));
-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 || {};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@koine/utils');
+
+let apiMethods = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+];
+let createApi = (apiName, baseUrl, options) => {
+    const { headers: headersBase = {}, request: requestBase = {}, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase, } = options || {};
+    return apiMethods.reduce((api, method) => {
+        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 = {
@@ -41,8 +23,8 @@ const createApi = (apiName, baseUrl, options)=>{
                 ...request,
                 headers: {
                     "content-type": "application/json",
-                    ...headers
-                }
+                    ...headers,
+                },
             };
             if (processReqBase) {
                 const transformed = processReqBase(method, url, query, json, params, requestInit);
@@ -60,8 +42,8 @@ const createApi = (apiName, baseUrl, options)=>{
                 params = transformed[3];
                 requestInit = transformed[4];
             }
-            if ((0, _isFullObject.default)(params)) {
-                for(const key in params){
+            if (utils.isFullObject(params)) {
+                for (const key in params) {
                     url = url.replace(`{${key}}`, params[key].toString());
                 }
             }
@@ -73,20 +55,20 @@ const createApi = (apiName, baseUrl, options)=>{
             }
             if (timeoutNumber > 0) {
                 controller = new AbortController();
-                timeoutId = setTimeout(()=>controller.abort(), timeoutNumber);
+                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 += (0, _buildUrlQueryString.default)(query);
+                url += utils.buildUrlQueryString(query);
             }
             let response = null;
             let result = null;
             let msg = "";
             try {
                 response = await fetch(url, requestInit);
-            } catch (e) {
-                msg = (0, _errorToString.default)(e);
+            }
+            catch (e) {
+                msg = utils.errorToString(e);
             }
             if (timeoutId) {
                 clearTimeout(timeoutId);
@@ -95,42 +77,38 @@ const createApi = (apiName, baseUrl, options)=>{
                 try {
                     if (processRes) {
                         result = await processRes(response, options || {});
-                    } else {
+                    }
+                    else {
                         result = await response.json();
                     }
-                } catch (e) {
-                    msg = (0, _errorToString.default)(e);
+                }
+                catch (e) {
+                    msg = utils.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)
+                }
+                else {
                     result = {
                         data: null,
                         msg,
                         status: 100,
                         fail: true,
-                        ok: false
+                        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") {
+            if (process.env["NODE_ENV"] === "development") {
                 const logMsg = `${result?.status}: api[${apiName}] ${method.toUpperCase()} ${url}`;
                 if (result?.ok) {
                     console.info(`🟢 ${logMsg}`);
-                } else {
+                }
+                else {
                     console.info(`🔴 ${logMsg}`);
                 }
             }
@@ -139,4 +117,6 @@ const createApi = (apiName, baseUrl, options)=>{
         return api;
     }, {});
 };
-const _default = createApi;
+
+exports.createApi = createApi;
+exports["default"] = createApi;

package/createApi.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './createApi.cjs.js';
+export { _default as default } from './createApi.cjs.default.js';

package/createApi.d.ts

@@ -1,8 +1,3 @@
-/**
- * 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>;
+import type { Api } from "./types";
+export declare let createApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions) => Api.Client<TEndpoints>;
 export default createApi;

package/{createApi.mjs → createApi.esm.js}

@@ -1,25 +1,17 @@
-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 || {};
+import { isFullObject, buildUrlQueryString, errorToString } from '@koine/utils';
+
+let apiMethods = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+];
+let createApi = (apiName, baseUrl, options) => {
+    const { headers: headersBase = {}, request: requestBase = {}, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase, } = options || {};
+    return apiMethods.reduce((api, method) => {
+        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 = {
@@ -27,8 +19,8 @@ import isFullObject from "@koine/utils/isFullObject";
                 ...request,
                 headers: {
                     "content-type": "application/json",
-                    ...headers
-                }
+                    ...headers,
+                },
             };
             if (processReqBase) {
                 const transformed = processReqBase(method, url, query, json, params, requestInit);
@@ -47,7 +39,7 @@ import isFullObject from "@koine/utils/isFullObject";
                 requestInit = transformed[4];
             }
             if (isFullObject(params)) {
-                for(const key in params){
+                for (const key in params) {
                     url = url.replace(`{${key}}`, params[key].toString());
                 }
             }
@@ -59,11 +51,10 @@ import isFullObject from "@koine/utils/isFullObject";
             }
             if (timeoutNumber > 0) {
                 controller = new AbortController();
-                timeoutId = setTimeout(()=>controller.abort(), timeoutNumber);
+                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;
@@ -71,7 +62,8 @@ import isFullObject from "@koine/utils/isFullObject";
             let msg = "";
             try {
                 response = await fetch(url, requestInit);
-            } catch (e) {
+            }
+            catch (e) {
                 msg = errorToString(e);
             }
             if (timeoutId) {
@@ -81,42 +73,38 @@ import isFullObject from "@koine/utils/isFullObject";
                 try {
                     if (processRes) {
                         result = await processRes(response, options || {});
-                    } else {
+                    }
+                    else {
                         result = await response.json();
                     }
-                } catch (e) {
+                }
+                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)
+                }
+                else {
                     result = {
                         data: null,
                         msg,
                         status: 100,
                         fail: true,
-                        ok: false
+                        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") {
+            if (process.env["NODE_ENV"] === "development") {
                 const logMsg = `${result?.status}: api[${apiName}] ${method.toUpperCase()} ${url}`;
                 if (result?.ok) {
                     console.info(`🟢 ${logMsg}`);
-                } else {
+                }
+                else {
                     console.info(`🔴 ${logMsg}`);
                 }
             }
@@ -125,4 +113,5 @@ import isFullObject from "@koine/utils/isFullObject";
         return api;
     }, {});
 };
-export default createApi;
+
+export { createApi, createApi as default };

package/createApiResultFail.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./createApiResultFail";
+export { default } from "./createApiResultFail";

package/createApiResultFail.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./createApiResultFail.cjs.js').default;

package/createApiResultFail.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let createApiResultOk = (data = {}, msg) => ({
+    ok: true,
+    fail: false,
+    data,
+    msg: msg || "",
+    status: 200,
+});
+let createApiResultFail = (data = {}, msg, status) => ({
+    fail: true,
+    data,
+    msg: msg || "",
+    status: status || 404,
+});
+
+exports.createApiResultFail = createApiResultFail;
+exports.createApiResultOk = createApiResultOk;
+exports["default"] = createApiResultFail;

package/createApiResultFail.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './createApiResultFail.cjs.js';
+export { _default as default } from './createApiResultFail.cjs.default.js';

package/createApiResultFail.d.ts

@@ -0,0 +1,4 @@
+import type { Api } from "./types";
+export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
+export declare let createApiResultFail: <T>(data?: T, msg?: string, status?: number) => Api.ResultFail<T>;
+export default createApiResultFail;

package/createApiResultFail.esm.js

@@ -0,0 +1,15 @@
+let createApiResultOk = (data = {}, msg) => ({
+    ok: true,
+    fail: false,
+    data,
+    msg: msg || "",
+    status: 200,
+});
+let createApiResultFail = (data = {}, msg, status) => ({
+    fail: true,
+    data,
+    msg: msg || "",
+    status: status || 404,
+});
+
+export { createApiResultFail, createApiResultOk, createApiResultFail as default };

package/createApiResultOk.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./createApiResultOk";
+export { default } from "./createApiResultOk";

package/createApiResultOk.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./createApiResultOk.cjs.js').default;

package/createApiResultOk.cjs.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let createApiResultOk = (data = {}, msg) => ({
+    ok: true,
+    fail: false,
+    data,
+    msg: msg || "",
+    status: 200,
+});
+
+exports.createApiResultOk = createApiResultOk;
+exports["default"] = createApiResultOk;

package/createApiResultOk.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './createApiResultOk.cjs.js';
+export { _default as default } from './createApiResultOk.cjs.default.js';

package/createApiResultOk.d.ts

@@ -0,0 +1,3 @@
+import type { Api } from "./types";
+export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
+export default createApiResultOk;

package/createApiResultOk.esm.js

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

package/createSwrApi.cjs.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var useSWR = require('swr');
+var utils = require('@koine/utils');
+var createApi = require('./createApi.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var useSWR__default = /*#__PURE__*/_interopDefaultLegacy(useSWR);
+
+let createUseApi = (api) => (endpoint, options, config) => {
+    const fetcher = async () => {
+        const { data } = await api.get(endpoint, {
+            ...(options || {}),
+            throwErr: true,
+        });
+        return data;
+    };
+    const shouldNotFetch = config?.when === false ||
+        (utils.isFunction(config?.when) && config?.when() === false);
+    return useSWR__default["default"](shouldNotFetch ? null : options ? [endpoint, options] : [endpoint], fetcher, config);
+};
+let createSwrApi = (...args) => {
+    const api = createApi.createApi(...args);
+    api.use = createUseApi(api);
+    return api;
+};
+
+exports.createSwrApi = createSwrApi;
+exports.createUseApi = createUseApi;

package/createSwrApi.esm.js

@@ -0,0 +1,23 @@
+import useSWR from 'swr';
+import { isFunction } from '@koine/utils';
+import { createApi } from './createApi.esm.js';
+
+let createUseApi = (api) => (endpoint, options, config) => {
+    const fetcher = async () => {
+        const { data } = await api.get(endpoint, {
+            ...(options || {}),
+            throwErr: true,
+        });
+        return data;
+    };
+    const shouldNotFetch = config?.when === false ||
+        (isFunction(config?.when) && config?.when() === false);
+    return useSWR(shouldNotFetch ? null : options ? [endpoint, options] : [endpoint], fetcher, config);
+};
+let createSwrApi = (...args) => {
+    const api = createApi(...args);
+    api.use = createUseApi(api);
+    return api;
+};
+
+export { createUseApi as a, createSwrApi as c };

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./index";

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ApiError = require('./ApiError.cjs.js');
+var createApi = require('./createApi.cjs.js');
+var createApiResultFail = require('./createApiResultFail.cjs.js');
+var createApiResultOk = require('./createApiResultOk.cjs.js');
+require('@koine/utils');
+
+
+
+exports.ApiError = ApiError.ApiError;
+exports.createApi = createApi.createApi;
+exports.createApiResultFail = createApiResultFail.createApiResultFail;
+exports.createApiResultOk = createApiResultOk.createApiResultOk;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.d.ts

@@ -1,4 +1,5 @@
 export { ApiError } from "./ApiError";
 export { createApi } from "./createApi";
-export { createSwrApi } from "./createSwrApi";
-export { nextApiResponse } from "./nextApiResponse";
+export { createApiResultFail } from "./createApiResultFail";
+export { createApiResultOk } from "./createApiResultOk";
+export type { Api } from "./types";

package/index.esm.js

@@ -0,0 +1,5 @@
+export { ApiError } from './ApiError.esm.js';
+export { createApi } from './createApi.esm.js';
+export { createApiResultFail } from './createApiResultFail.esm.js';
+export { createApiResultOk } from './createApiResultOk.esm.js';
+import '@koine/utils';

package/next/nextApiResponse.d.ts

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

package/next/nextApiResponse12.d.ts

@@ -0,0 +1,6 @@
+import type { NextApiResponse } from "next";
+export declare let 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/next.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./next";

package/next.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./next.cjs.js').default;

package/next.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('next/server');
+var createApiResultFail = require('./createApiResultFail.cjs.js');
+var createApiResultOk = require('./createApiResultOk.cjs.js');
+
+let nextApiResponse = {
+    ok(data, msg) {
+        return server.NextResponse.json(createApiResultOk.createApiResultOk(data, msg));
+    },
+    fail(data, msg, status) {
+        return server.NextResponse.json(createApiResultFail.createApiResultFail(data, msg, status));
+    },
+};
+
+let nextApiResponse12 = (nextRes) => ({
+    ok(data, msg) {
+        nextRes.status(200).json(createApiResultOk.createApiResultOk(data, msg));
+    },
+    fail(data, msg, status) {
+        nextRes.status(status || 404).json(createApiResultFail.createApiResultFail(data, msg, status));
+    },
+});
+
+exports.nextApiResponse = nextApiResponse;
+exports.nextApiResponse12 = nextApiResponse12;

package/next.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './next.cjs.js';
+export { _default as default } from './next.cjs.default.js';

package/next.d.ts

@@ -0,0 +1,2 @@
+export { nextApiResponse } from "./next/nextApiResponse";
+export { nextApiResponse12 } from "./next/nextApiResponse12";