comty.js 0.60.6 → 0.60.7

package/dist/addons.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); class AddonsManager {constructor() { AddonsManager.prototype.__init.call(this); }
+	__init() {this.addons = new Map()}
+
+	register(name, addon) {
+		this.addons.set(name, addon)
+	}
+
+	get(name) {
+		return this.addons.get(name)
+	}
+
+	// search all addons registered, and find all addons that has a addon[operation] function
+	getByOperation(operation) {
+		return Array.from(this.addons.values())
+			.filter((addon) => addon[operation])
+			.map((addon) => {
+				return {
+					id: addon.constructor.id,
+					fn: addon[operation],
+				}
+			})
+	}
+} exports.default = AddonsManager;

package/dist/helpers/processWithAddons.js

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); async function processAddons({
+	operation,
+	initialData,
+	fnArguments,
+	normalizeAddonResult,
+}) {
+	const addons = __comty_shared_state.addons.getByOperation(operation)
+
+	let processedData = initialData
+
+	if (typeof fnArguments === "undefined") {
+		fnArguments = []
+	}
+
+	for (const addon of addons) {
+		try {
+			const addonResult = await addon.fn(...fnArguments)
+
+			processedData = normalizeAddonResult({
+				operation,
+				currentData: processedData,
+				addonResult,
+			})
+		} catch (error) {
+			console.error(`Error in [${operation}] addon:`, error)
+		}
+	}
+
+	return processedData
+} exports.default = processAddons;

package/dist/index.js

@@ -4,21 +4,22 @@ var _events = require('@foxify/events'); var _events2 = _interopRequireDefault(_
 var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
 var _socketioclient = require('socket.io-client');
 
-var _models = require('./models');
+var _addons = require('./addons'); var _addons2 = _interopRequireDefault(_addons);
 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"
+globalThis.isServerMode =
+	typeof window === "undefined" && typeof global !== "undefined"
 
 if (globalThis.isServerMode) {
-    const { Buffer } = require("buffer")
-
-    globalThis.b64Decode = (data) => {
-        return Buffer.from(data, "base64").toString("utf-8")
-    }
-    globalThis.b64Encode = (data) => {
-        return Buffer.from(data, "utf-8").toString("base64")
-    }
+	const { Buffer } = require("buffer")
+
+	globalThis.b64Decode = (data) => {
+		return Buffer.from(data, "base64").toString("utf-8")
+	}
+	globalThis.b64Encode = (data) => {
+		return Buffer.from(data, "utf-8").toString("base64")
+	}
 }
 
 /**
@@ -29,76 +30,82 @@ if (globalThis.isServerMode) {
  * @return {Promise<void>} A promise that resolves when all websockets have been created and event listeners have been registered.
  */
  async function createWebsockets() {
-    if (!_remote2.default.websockets) {
-        return false
-    }
-
-    const instances = globalThis.__comty_shared_state.sockets
-
-    for (let [key, instance] of Object.entries(instances)) {
-        if (instance.connected) {
-            // disconnect first
-            instance.disconnect()
-        }
-
-        // remove current listeners
-        instance.removeAllListeners()
-
-        delete globalThis.__comty_shared_state.sockets[key]
-    }
-
-    for (let ws of _remote2.default.websockets) {
-        let opts = {
-            transports: ["websocket"],
-            autoConnect: _nullishCoalesce(ws.autoConnect, () => ( true)),
-            forceNew: true,
-            path: ws.path,
-            ..._nullishCoalesce(ws.params, () => ( {})),
-        }
-
-        if (ws.noAuth !== true) {
-            opts.auth = {
-                token: _withStorage2.default.engine.get("token"),
-            }
-        }
-
-        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`)
-
-            globalThis.__comty_shared_state.eventBus.emit(`${key}:connected`)
-        })
-
-        instance.on("disconnect", () => {
-            //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)
-
-            globalThis.__comty_shared_state.eventBus.emit(`${key}:error`, error)
-        })
-
-        instance.onAny((event, ...args) => {
-            //console.debug(`[WS-API][${key}] Event (${event})`, ...args)
-
-            globalThis.__comty_shared_state.eventBus.emit(`${key}:${event}`, ...args)
-        })
-    }
+	if (!_remote2.default.websockets) {
+		return false
+	}
+
+	const instances = globalThis.__comty_shared_state.sockets
+
+	for (let [key, instance] of Object.entries(instances)) {
+		if (instance.connected) {
+			// disconnect first
+			instance.disconnect()
+		}
+
+		// remove current listeners
+		instance.removeAllListeners()
+
+		delete globalThis.__comty_shared_state.sockets[key]
+	}
+
+	for (let ws of _remote2.default.websockets) {
+		let opts = {
+			transports: ["websocket"],
+			autoConnect: _nullishCoalesce(ws.autoConnect, () => ( true)),
+			forceNew: true,
+			path: ws.path,
+			...(_nullishCoalesce(ws.params, () => ( {}))),
+		}
+
+		if (ws.noAuth !== true) {
+			opts.auth = {
+				token: _withStorage2.default.engine.get("token"),
+			}
+		}
+
+		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`)
+
+			globalThis.__comty_shared_state.eventBus.emit(`${key}:connected`)
+		})
+
+		instance.on("disconnect", () => {
+			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)
+
+			globalThis.__comty_shared_state.eventBus.emit(`${key}:error`, error)
+		})
+
+		instance.onAny((event, ...args) => {
+			console.debug(`[WS-API][${key}] Event (${event})`, ...args)
+
+			globalThis.__comty_shared_state.eventBus.emit(
+				`${key}:${event}`,
+				...args,
+			)
+		})
+	}
 } exports.createWebsockets = createWebsockets;
 
 /**
@@ -107,13 +114,13 @@ if (globalThis.isServerMode) {
  * @return {Promise<void>} A promise that resolves when all websocket instances have been disconnected.
  */
  async function disconnectWebsockets() {
-    const instances = globalThis.__comty_shared_state.sockets
+	const instances = globalThis.__comty_shared_state.sockets
 
-    for (let [key, instance] of Object.entries(instances)) {
-        if (instance.connected) {
-            instance.disconnect()
-        }
-    }
+	for (let [key, instance] of Object.entries(instances)) {
+		if (instance.connected) {
+			instance.disconnect()
+		}
+	}
 } exports.disconnectWebsockets = disconnectWebsockets;
 
 /**
@@ -122,20 +129,20 @@ if (globalThis.isServerMode) {
  * @return {Promise<void>} A promise that resolves when all websocket instances have been reconnected.
  */
  async function reconnectWebsockets() {
-    const instances = globalThis.__comty_shared_state.sockets
+	const instances = globalThis.__comty_shared_state.sockets
 
-    for (let [key, instance] of Object.entries(instances)) {
-        if (instance.connected) {
-            // disconnect first
-            instance.disconnect()
-        }
+	for (let [key, instance] of Object.entries(instances)) {
+		if (instance.connected) {
+			// disconnect first
+			instance.disconnect()
+		}
 
-        instance.auth = {
-            token: _withStorage2.default.engine.get("token"),
-        }
+		instance.auth = {
+			token: _withStorage2.default.engine.get("token"),
+		}
 
-        instance.connect()
-    }
+		instance.connect()
+	}
 } exports.reconnectWebsockets = reconnectWebsockets;
 
 /**
@@ -144,21 +151,21 @@ if (globalThis.isServerMode) {
  * @return {Promise<void>} Promise that resolves when all websocket instances have been reauthenticated.
  */
  async function reauthenticateWebsockets() {
-    const instances = globalThis.__comty_shared_state.sockets
+	const instances = globalThis.__comty_shared_state.sockets
 
-    for (let [key, instance] of Object.entries(instances)) {
-        const token = _withStorage2.default.engine.get("token")
+	for (let [key, instance] of Object.entries(instances)) {
+		const token = _withStorage2.default.engine.get("token")
 
-        instance.auth = {
-            token: token,
-        }
+		instance.auth = {
+			token: token,
+		}
 
-        if (!instance.connected) {
-            instance.connect()
-        } else {
-            instance.emit("auth:reauth", token)
-        }
-    }
+		if (!instance.connected) {
+			instance.connect()
+		} else {
+			instance.emit("auth:reauth", token)
+		}
+	}
 } exports.reauthenticateWebsockets = reauthenticateWebsockets;
 
 /**
@@ -168,54 +175,54 @@ if (globalThis.isServerMode) {
  * @return {Object} sharedState - Object containing eventBus, mainOrigin, baseRequest, sockets, rest, and version
  */
  function createClient({
-    accessKey = null,
-    privateKey = null,
-    enableWs = false,
-    origin = _remote2.default.origin,
+	accessKey = null,
+	privateKey = null,
+	enableWs = false,
+	origin = _remote2.default.origin,
 } = {}) {
-    const sharedState = globalThis.__comty_shared_state = {
-        eventBus: new (0, _events2.default)(),
-        mainOrigin: origin,
-        baseRequest: null,
-        sockets: new Map(),
-        rest: null,
-        version: _packagejson2.default.version,
-    }
-
-    sharedState.rest = _models.createHandlers.call(void 0, )
-
-    if (privateKey && accessKey && globalThis.isServerMode) {
-        _withStorage2.default.engine.set("token", `${accessKey}:${privateKey}`)
-    }
-
-    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
-    })
-
-    if (enableWs) {
-        createWebsockets()
-    }
-
-    return sharedState
+	const sharedState = (globalThis.__comty_shared_state = {
+		eventBus: new (0, _events2.default)(),
+		mainOrigin: origin,
+		baseRequest: null,
+		sockets: new Map(),
+		rest: null,
+		version: _packagejson2.default.version,
+		addons: new (0, _addons2.default)(),
+	})
+
+	if (privateKey && accessKey && globalThis.isServerMode) {
+		_withStorage2.default.engine.set("token", `${accessKey}:${privateKey}`)
+	}
+
+	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
+	})
+
+	if (enableWs) {
+		createWebsockets()
+	}
+
+	return sharedState
 } exports.createClient = createClient;
 
-exports. default = createClient
+exports. default = createClient