comty.js 0.59.2 → 0.60.3

package/dist/helpers/handleAfterRequest.js

@@ -1,34 +1,34 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _handleRegenerationEvent = require('./handleRegenerationEvent'); var _handleRegenerationEvent2 = _interopRequireDefault(_handleRegenerationEvent);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _refreshToken = require('./refreshToken'); var _refreshToken2 = _interopRequireDefault(_refreshToken);
 
 exports. default = async (data, callback) => {
     // handle 401, 403 responses
     if (data instanceof Error) {
         if (data.code && (data.code === "ECONNABORTED" || data.code === "ERR_NETWORK")) {
-            console.error(`Request aborted or network error, ignoring`)
+            console.error(`Request aborted or network error`)
             return false
         }
 
         if (data.response.status === 401) {
             // check if the server issue a refresh token on data
-            if (data.response.data.refreshToken) {
-                console.log(`Session expired, but the server issued a refresh token, handling regeneration event`)
+            if (data.response.data.expired) {
+                try {
+                    console.log(`Session expired, trying to regenerate...`)
 
-                // handle regeneration event
-                await _handleRegenerationEvent2.default.call(void 0, data.response.data.refreshToken)
+                    await _refreshToken2.default.call(void 0, )
+                } catch (error) {
+                    __comty_shared_state.eventBus.emit("session.invalid", error.message)
 
-                return await callback()
-            }
+                    console.error(`Failed to regenerate token: ${error.message}`)
+
+                    throw new Error(`Invalid or Expired session`)
+                }
 
-            // check if route is from "session" namespace
-            if (data.config.url.includes("/session")) {
-                return __comty_shared_state.eventBus.emit("session.invalid", "Session expired, but the server did not issue a refresh token")
+                return await callback()
             }
         }
 
         if (data.response.status === 403) {
-            if (data.config.url.includes("/session")) {
-                return __comty_shared_state.eventBus.emit("session.invalid", "Session not valid or not existent")
-            }
+
         }
     }
 }

package/dist/helpers/handleBeforeRequest.js

@@ -1,13 +1,7 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});exports. default = async (request) => {
-    if (__comty_shared_state.onExpiredExceptionEvent) {
-        if (__comty_shared_state.excludedExpiredExceptionURL.includes(request.url)) return
-
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});exports. default = async () => {
+    if (__comty_shared_state.refreshingToken === true) {
         await new Promise((resolve) => {
-            __comty_shared_state.eventBus.once("session.regenerated", () => {
-                console.log(`Session has been regenerated, retrying request`)
-
-                resolve()
-            })
+            __comty_shared_state.eventBus.once("session:refreshed", resolve)
         })
     }
 }

package/dist/helpers/measurePing.js

@@ -0,0 +1,62 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _request = require('../request'); var _request2 = _interopRequireDefault(_request);
+
+const fetchers = {
+    http: () => new Promise(async (resolve) => {
+        const start = Date.now()
+
+        const failTimeout = setTimeout(() => {
+            resolve("timeout")
+        }, 5000)
+
+        _request2.default.call(void 0, {
+            method: "GET",
+            url: "/ping",
+        })
+            .then(() => {
+                clearTimeout(failTimeout)
+                resolve(Date.now() - start)
+            })
+            .catch((err) => {
+                console.log(err)
+                clearTimeout(failTimeout)
+                resolve("failed")
+            })
+    }),
+    ws: () => new Promise((resolve) => {
+        const start = Date.now()
+
+        const failTimeout = setTimeout(() => {
+            resolve("failed")
+        }, 5000)
+
+        globalThis.__comty_shared_state.sockets["main"].on("pong", () => {
+            failTimeout && clearTimeout(failTimeout)
+
+            resolve(Date.now() - start)
+        })
+
+        globalThis.__comty_shared_state.sockets["main"].emit("ping")
+    })
+}
+
+exports. default = async ({ select } = {}) => {
+    let selectedPromises = []
+
+    if (Array.isArray(select)) {
+        select.forEach((item) => {
+            if (!fetchers[item]) {
+                return
+            }
+            selectedPromises.push(fetchers[item]())
+        })
+    } else {
+        selectedPromises = [
+            fetchers["http"](),
+            fetchers["ws"](),
+        ]
+    }
+
+    const result = await Promise.all(selectedPromises)
+
+    return result
+}

package/dist/helpers/refreshToken.js

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _session = require('../models/session'); var _session2 = _interopRequireDefault(_session);
+var _ = require('..');
+exports. default = async () => {
+    __comty_shared_state.eventBus.emit("session:refreshing")
+    __comty_shared_state.refreshingToken = true
+
+    // send request to regenerate token
+    const response = await __comty_shared_state.baseRequest({
+        method: "POST",
+        url: "/auth",
+        data: {
+            authToken: await _session2.default.token,
+            refreshToken: await _session2.default.refreshToken,
+        }
+    }).catch((error) => {
+        return false
+    })
+
+    if (!response) {
+        __comty_shared_state.refreshingToken = false
+
+        throw new Error("Failed to regenerate token.")
+    }
+
+    if (!_optionalChain([response, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.token])) {
+        __comty_shared_state.refreshingToken = false
+
+        throw new Error("Failed to regenerate token, invalid server response.")
+    }
+
+    // set new token
+    _session2.default.token = response.data.token
+    _session2.default.refreshToken = response.data.refreshToken
+
+    // emit event
+    __comty_shared_state.eventBus.emit("session:refreshed")
+    __comty_shared_state.refreshingToken = false
+
+    _.reauthenticateWebsockets.call(void 0, )
+
+    return true
+}

package/dist/hooks/useRequest/index.js

@@ -1,14 +1,13 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _react = require('react'); var _react2 = _interopRequireDefault(_react);
 
 exports. default = (method, ...args) => {
-    if (typeof method !== "function") {
-        throw new Error("useRequest: method must be a function")
-    }
-
     const [loading, setLoading] = _react2.default.useState(true)
     const [result, setResult] = _react2.default.useState(null)
     const [error, setError] = _react2.default.useState(null)
 
+    if (typeof method !== "function") {
+        return [() => {}, null, new Error("Method is not a function"), () => {}]
+    }
     const makeRequest = (...newArgs) => {
         method(...newArgs)
             .then((data) => {

package/dist/index.js

@@ -4,13 +4,9 @@ var _events = require('@foxify/events'); var _events2 = _interopRequireDefault(_
 var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
 var _socketioclient = require('socket.io-client');
 
-var _remotes = require('./remotes'); var _remotes2 = _interopRequireDefault(_remotes);
-
-//import request from "./handlers/request"
-var _withStorage = require('./helpers/withStorage'); var _withStorage2 = _interopRequireDefault(_withStorage);
-
-var _session = require('./models/session'); var _session2 = _interopRequireDefault(_session);
 var _models = require('./models');
+var _withStorage = require('./helpers/withStorage'); var _withStorage2 = _interopRequireDefault(_withStorage);
+var _remote = require('./remote'); var _remote2 = _interopRequireDefault(_remote);
 
 globalThis.isServerMode = typeof window === "undefined" && typeof global !== "undefined"
 
@@ -25,8 +21,19 @@ if (globalThis.isServerMode) {
     }
 }
 
+/**
+ * Creates websockets by disconnecting and removing listeners from existing instances,
+ * then creating new instances for each websocket in the remote.websockets array.
+ * Registers event listeners for connection, disconnection, reconnection, error, and any other events.
+ *
+ * @return {Promise<void>} A promise that resolves when all websockets have been created and event listeners have been registered.
+ */
  async function createWebsockets() {
-    const instances = globalThis.__comty_shared_state.wsInstances
+    if (!_remote2.default.websockets) {
+        return false
+    }
+
+    const instances = globalThis.__comty_shared_state.sockets
 
     for (let [key, instance] of Object.entries(instances)) {
         if (instance.connected) {
@@ -37,66 +44,70 @@ if (globalThis.isServerMode) {
         // remove current listeners
         instance.removeAllListeners()
 
-        delete globalThis.__comty_shared_state.wsInstances[key]
+        delete globalThis.__comty_shared_state.sockets[key]
     }
 
-    for (let [key, remote] of Object.entries(_remotes2.default)) {
-        if (!remote.hasWebsocket) {
-            continue
-        }
-
+    for (let ws of _remote2.default.websockets) {
         let opts = {
             transports: ["websocket"],
-            autoConnect: _nullishCoalesce(remote.autoConnect, () => ( true)),
-            ..._nullishCoalesce(remote.wsParams, () => ( {})),
+            autoConnect: _nullishCoalesce(ws.autoConnect, () => ( true)),
+            forceNew: true,
+            path: ws.path,
+            ..._nullishCoalesce(ws.params, () => ( {})),
         }
 
-        if (remote.noAuth !== true) {
+        if (ws.noAuth !== true) {
             opts.auth = {
-                token: _session2.default.token,
+                token: _withStorage2.default.engine.get("token"),
             }
         }
 
-        globalThis.__comty_shared_state.wsInstances[key] = _socketioclient.io.call(void 0, _nullishCoalesce(remote.wsOrigin, () => ( remote.origin)), opts)
+        globalThis.__comty_shared_state.sockets[ws.namespace] = _socketioclient.io.call(void 0, _remote2.default.origin, opts)
     }
 
     // regsister events
     for (let [key, instance] of Object.entries(instances)) {
         instance.on("connect", () => {
-            console.debug(`[WS-API][${key}] Connected`)
-
-            if (_remotes2.default[key].useClassicAuth && _remotes2.default[key].noAuth !== true) {
-                // try to auth
-                instance.emit("auth", {
-                    token: _session2.default.token,
-                })
-            }
+            //console.debug(`[WS-API][${key}] Connected`)
 
             globalThis.__comty_shared_state.eventBus.emit(`${key}:connected`)
         })
 
         instance.on("disconnect", () => {
-            console.debug(`[WS-API][${key}] Disconnected`)
+            //console.debug(`[WS-API][${key}] Disconnected`)
 
             globalThis.__comty_shared_state.eventBus.emit(`${key}:disconnected`)
         })
 
+        instance.on("reconnect", () => {
+            // console.debug(`[WS-API][${key}] Reconnected`)
+
+            globalThis.__comty_shared_state.eventBus.emit(`${key}:reconnected`)
+
+            reauthenticateWebsockets()
+        })
+
         instance.on("error", (error) => {
-            console.error(`[WS-API][${key}] Error`, error)
+            //console.error(`[WS-API][${key}] Error`, error)
 
             globalThis.__comty_shared_state.eventBus.emit(`${key}:error`, error)
         })
 
         instance.onAny((event, ...args) => {
-            console.debug(`[WS-API][${key}] Event (${event})`, ...args)
+            //console.debug(`[WS-API][${key}] Event (${event})`, ...args)
 
             globalThis.__comty_shared_state.eventBus.emit(`${key}:${event}`, ...args)
         })
     }
 } exports.createWebsockets = createWebsockets;
 
+/**
+ * Disconnects all websocket instances by calling the `disconnect` method on each instance.
+ *
+ * @return {Promise<void>} A promise that resolves when all websocket instances have been disconnected.
+ */
  async function disconnectWebsockets() {
-    const instances = globalThis.__comty_shared_state.wsInstances
+    const instances = globalThis.__comty_shared_state.sockets
 
     for (let [key, instance] of Object.entries(instances)) {
         if (instance.connected) {
@@ -105,97 +116,106 @@ if (globalThis.isServerMode) {
     }
 } exports.disconnectWebsockets = disconnectWebsockets;
 
- async function reconnectWebsockets({ force = false } = {}) {
-    const instances = globalThis.__comty_shared_state.wsInstances
+/**
+ * Reconnects all websocket instances by disconnecting and reconnecting them with the current token.
+ *
+ * @return {Promise<void>} A promise that resolves when all websocket instances have been reconnected.
+ */
+ async function reconnectWebsockets() {
+    const instances = globalThis.__comty_shared_state.sockets
 
     for (let [key, instance] of Object.entries(instances)) {
         if (instance.connected) {
-            if (!instance.auth) {
-                instance.disconnect()
-
-                instance.auth = {
-                    token: _session2.default.token,
-                }
-
-                instance.connect()
-                continue
-            }
-
-            if (!force) {
-                instance.emit("reauthenticate", {
-                    token: _session2.default.token,
-                })
-
-                continue
-            }
-
             // disconnect first
             instance.disconnect()
         }
 
-        if (_remotes2.default[key].noAuth !== true) {
-            instance.auth = {
-                token: _session2.default.token,
-            }
+        instance.auth = {
+            token: _withStorage2.default.engine.get("token"),
         }
 
         instance.connect()
     }
 } exports.reconnectWebsockets = reconnectWebsockets;
 
+/**
+ * Reauthenticates all websocket instances with the current token. If a websocket instance is not connected, it connects to the server. If it is connected, it emits an "auth:reauth" event with the current token.
+ *
+ * @return {Promise<void>} Promise that resolves when all websocket instances have been reauthenticated.
+ */
+ async function reauthenticateWebsockets() {
+    const instances = globalThis.__comty_shared_state.sockets
+
+    for (let [key, instance] of Object.entries(instances)) {
+        const token = _withStorage2.default.engine.get("token")
+
+        instance.auth = {
+            token: token,
+        }
+
+        if (!instance.connected) {
+            instance.connect()
+        } else {
+            instance.emit("auth:reauth", token)
+        }
+    }
+} exports.reauthenticateWebsockets = reauthenticateWebsockets;
+
+/**
+ * Create a client with the specified access key, private key, and websocket enablement.
+ *
+ * @param {Object} options - Optional parameters for accessKey, privateKey, and enableWs
+ * @return {Object} sharedState - Object containing eventBus, mainOrigin, baseRequest, sockets, rest, and version
+ */
  function createClient({
     accessKey = null,
     privateKey = null,
     enableWs = false,
+    origin = _remote2.default.origin,
 } = {}) {
     const sharedState = globalThis.__comty_shared_state = {
-        onExpiredExceptionEvent: false,
-        excludedExpiredExceptionURL: ["/session/regenerate"],
         eventBus: new (0, _events2.default)(),
-        mainOrigin: _remotes2.default.default.origin,
-        instances: Object(),
-        wsInstances: Object(),
+        mainOrigin: origin,
+        baseRequest: null,
+        sockets: new Map(),
         rest: null,
         version: _packagejson2.default.version,
     }
 
-    if (globalThis.isServerMode) {
-        sharedState.rest = _models.createHandlers.call(void 0, )
-    }
+    sharedState.rest = _models.createHandlers.call(void 0, )
 
     if (privateKey && accessKey && globalThis.isServerMode) {
         _withStorage2.default.engine.set("token", `${accessKey}:${privateKey}`)
     }
 
-    // create instances for every remote
-    for (const [key, remote] of Object.entries(_remotes2.default)) {
-        sharedState.instances[key] = _axios2.default.create({
-            baseURL: remote.origin,
-            headers: {
-                "Content-Type": "application/json",
-            }
-        })
-
-        // create a interceptor to attach the token every request
-        sharedState.instances[key].interceptors.request.use((config) => {
-            // check if current request has no Authorization header, if so, attach the token
-            if (!config.headers["Authorization"]) {
-                const sessionToken = _session2.default.token
-
-                if (sessionToken) {
-                    config.headers["Authorization"] = `${globalThis.isServerMode ? "Server" : "Bearer"} ${sessionToken}`
-                } else {
-                    console.warn("Making a request with no session token")
-                }
+    sharedState.baseRequest = _axios2.default.create({
+        baseURL: origin,
+        headers: {
+            "Content-Type": "application/json",
+        }
+    })
+
+    // create a interceptor to attach the token every request
+    sharedState.baseRequest.interceptors.request.use((config) => {
+        // check if current request has no Authorization header, if so, attach the token
+        if (!config.headers["Authorization"]) {
+            const sessionToken = _withStorage2.default.engine.get("token")
+
+            if (sessionToken) {
+                config.headers["Authorization"] = `${globalThis.isServerMode ? "Server" : "Bearer"} ${sessionToken}`
+            } else {
+                console.warn("Making a request with no session token")
             }
+        }
 
-            return config
-        })
-    }
+        return config
+    })
 
     if (enableWs) {
         createWebsockets()
     }
 
     return sharedState
-} exports.default = createClient;
+} exports.createClient = createClient;
+
+exports. default = createClient