outers
Version:
outers - a all in one package for your day to day use
287 lines • 17.6 kB
JavaScript
"use strict";
/* eslint-disable @typescript-eslint/ban-types */
/* eslint-disable @typescript-eslint/no-explicit-any */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _createSocketCluster_ExpressServer, _createSocketCluster_HTTPServer, _createSocketCluster_WebSocketServer, _createSocketCluster_PORT, _createSocketCluster_NumberOfWorkers, _createSocketCluster_BeforeListenFunctions, _createSocketCluster_AfterListenFunctions, _createSocketCluster_FunctionMiddlewares, _createSocketCluster_GlobalResponseObject, _createSocketCluster_EnableTrustProxy, _createSocketCluster_WebSocketConnectionHandler;
Object.defineProperty(exports, "__esModule", { value: true });
const node_os_1 = require("node:os"); // Import os module
const express_1 = __importDefault(require("express")); // Import express module
const http_1 = require("http"); // Import HTTP Server module
const ws_1 = require("ws"); // Import WebSocket module
const node_cluster_1 = __importDefault(require("node:cluster")); // Import Cluster module
const { isPrimary } = node_cluster_1.default; // Import isPrimary from Cluster
const Console_log_1 = require("../../Logs/Console.log"); // Import Console module
// Main Class
/**
* Represents a class for creating a SocketCluster cluster.
*/
class createSocketCluster {
/**
* Creates an instance of CreateClusterByClass.
* @param ExpressServer - Express Server Instance.
* @param PORT - Port Number to Listen.
* @param NumberOfWorkers - Number of Copies of Workers.
* @param BeforeListenFunctions - Any Functions to run before listen.
* @param AfterListenFunctions - Any Functions to run after listen.
* @param FunctionMiddlewares - Any Middlewares to apply.
* @param EnableTrustProxy - Enable Trust Proxy.
*/
constructor(ExpressServer, PORT, NumberOfWorkers, BeforeListenFunctions, AfterListenFunctions, FunctionMiddlewares, EnableTrustProxy) {
// Properties
/**
* Express Server Instance.
*/
_createSocketCluster_ExpressServer.set(this, void 0);
/**
* HTTP Server Instance.
*/
_createSocketCluster_HTTPServer.set(this, void 0);
/**
* WebSocket Server Instance.
*/
_createSocketCluster_WebSocketServer.set(this, void 0);
/**
* Port Number to Listen.
*/
_createSocketCluster_PORT.set(this, void 0);
// Private Properties
/**
* Number of Copies of Workers.
*/
_createSocketCluster_NumberOfWorkers.set(this, void 0);
/**
* Any Functions to run before listen.
*/
_createSocketCluster_BeforeListenFunctions.set(this, void 0);
/**
* Any Functions to run after listen.
*/
_createSocketCluster_AfterListenFunctions.set(this, void 0);
/**
* Any Middlewares to apply.
*/
_createSocketCluster_FunctionMiddlewares.set(this, void 0);
/**
* Any ResponseObject.
*/
_createSocketCluster_GlobalResponseObject.set(this, void 0);
/**
* Enable Trust Proxy.
*/
_createSocketCluster_EnableTrustProxy.set(this, void 0);
/**
* Store WebSocket connection handler.
*/
_createSocketCluster_WebSocketConnectionHandler.set(this, void 0);
__classPrivateFieldSet(this, _createSocketCluster_ExpressServer, ExpressServer !== null && ExpressServer !== void 0 ? ExpressServer : (0, express_1.default)(), "f");
__classPrivateFieldSet(this, _createSocketCluster_HTTPServer, new http_1.Server(__classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f")), "f");
__classPrivateFieldSet(this, _createSocketCluster_WebSocketServer, new ws_1.WebSocketServer({ server: __classPrivateFieldGet(this, _createSocketCluster_HTTPServer, "f") }), "f");
__classPrivateFieldSet(this, _createSocketCluster_PORT, PORT, "f");
__classPrivateFieldSet(this, _createSocketCluster_NumberOfWorkers, NumberOfWorkers !== null && NumberOfWorkers !== void 0 ? NumberOfWorkers : (0, node_os_1.cpus)().length, "f");
__classPrivateFieldSet(this, _createSocketCluster_BeforeListenFunctions, BeforeListenFunctions !== null && BeforeListenFunctions !== void 0 ? BeforeListenFunctions : [], "f");
__classPrivateFieldSet(this, _createSocketCluster_AfterListenFunctions, AfterListenFunctions !== null && AfterListenFunctions !== void 0 ? AfterListenFunctions : [], "f");
__classPrivateFieldSet(this, _createSocketCluster_FunctionMiddlewares, FunctionMiddlewares !== null && FunctionMiddlewares !== void 0 ? FunctionMiddlewares : [], "f");
__classPrivateFieldSet(this, _createSocketCluster_GlobalResponseObject, {
ActiveServer: __classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f"),
ActiveWorker: __classPrivateFieldGet(this, _createSocketCluster_NumberOfWorkers, "f"),
TotalBeforeFunctions: __classPrivateFieldGet(this, _createSocketCluster_BeforeListenFunctions, "f").length,
TotalAfterFunctions: __classPrivateFieldGet(this, _createSocketCluster_AfterListenFunctions, "f").length,
ActiveMiddlewares: __classPrivateFieldGet(this, _createSocketCluster_FunctionMiddlewares, "f"),
TotalCPU: (0, node_os_1.cpus)().length,
TotalFreeRam: `${((0, node_os_1.freemem)() / 1024 / 1024 / 1024).toFixed(2)} GB`,
TotalRam: `${((0, node_os_1.totalmem)() / 1024 / 1024 / 1024).toFixed(2)} GB`,
Architecture: (0, node_os_1.arch)(),
Platform: (0, node_os_1.platform)(),
}, "f");
__classPrivateFieldSet(this, _createSocketCluster_EnableTrustProxy, EnableTrustProxy !== null && EnableTrustProxy !== void 0 ? EnableTrustProxy : false, "f");
__classPrivateFieldSet(this, _createSocketCluster_WebSocketConnectionHandler, __classPrivateFieldGet(this, _createSocketCluster_WebSocketServer, "f"), "f");
}
/**
* Starts the server.
* @returns A Promise that resolves to the ResponseObject or undefined.
* @throws Error if Express Server or Port is not provided.
*/
StartServer() {
return __awaiter(this, void 0, void 0, function* () {
if (!__classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f") || !__classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f") === undefined) {
throw new Error("Express Server is not provided");
}
if (!__classPrivateFieldGet(this, _createSocketCluster_PORT, "f") || __classPrivateFieldGet(this, _createSocketCluster_PORT, "f") === undefined) {
throw new Error("Port is not provided");
}
let ProcessCopy = __classPrivateFieldGet(this, _createSocketCluster_NumberOfWorkers, "f");
if (isPrimary) {
(0, Console_log_1.bright)(`${(0, node_os_1.platform)()} ${(0, node_os_1.arch)()} server : ${((0, node_os_1.freemem)() /
1024 /
1024 /
1024).toFixed(2)} GB Free Ram : ${(0, node_os_1.cpus)()[0].model}`);
while (ProcessCopy > 0) {
node_cluster_1.default.fork();
ProcessCopy--;
}
node_cluster_1.default.on("online", (worker) => {
(0, Console_log_1.green)(`🚀 Worker ${worker.process.pid} started 🚀`);
(0, Console_log_1.blue)(`Environment Variables Loaded Successfully in Worker : ${worker.process.pid}`);
__classPrivateFieldGet(this, _createSocketCluster_GlobalResponseObject, "f").ActiveWorker++;
(0, Console_log_1.yellow)(`Worker ${worker.process.pid} is listening`);
});
node_cluster_1.default.on("exit", (worker) => {
(0, Console_log_1.red)(`Worker ${worker.process.pid} died`);
node_cluster_1.default.fork();
(0, Console_log_1.green)("🚀 Worker restarted 🚀");
(0, Console_log_1.blue)(`Environment Variables Loaded Successfully in Worker : ${worker.process.pid}`);
(0, Console_log_1.yellow)("Worker is listening");
});
}
else {
__classPrivateFieldGet(this, _createSocketCluster_EnableTrustProxy, "f") === true
? __classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f").set("trust proxy", true)
: (0, Console_log_1.yellow)("Trust Proxy is not enabled, if you are working behind a proxy, please enable it to get the real IP Address");
if (__classPrivateFieldGet(this, _createSocketCluster_FunctionMiddlewares, "f").length > 0 ||
__classPrivateFieldGet(this, _createSocketCluster_FunctionMiddlewares, "f") !== undefined) {
__classPrivateFieldGet(this, _createSocketCluster_FunctionMiddlewares, "f").forEach((FunctionMiddleware) => {
__classPrivateFieldGet(this, _createSocketCluster_ExpressServer, "f").use(FunctionMiddleware);
});
}
if (__classPrivateFieldGet(this, _createSocketCluster_BeforeListenFunctions, "f").length > 0 ||
__classPrivateFieldGet(this, _createSocketCluster_BeforeListenFunctions, "f") !== undefined) {
for (const ListenFunction of __classPrivateFieldGet(this, _createSocketCluster_BeforeListenFunctions, "f")) {
yield ListenFunction();
}
}
try {
const ActiveServer = __classPrivateFieldGet(this, _createSocketCluster_HTTPServer, "f").listen(__classPrivateFieldGet(this, _createSocketCluster_PORT, "f"), () => __awaiter(this, void 0, void 0, function* () {
(0, Console_log_1.green)(`🚀 Server is listening on Port ${__classPrivateFieldGet(this, _createSocketCluster_PORT, "f")} 🚀`);
if (__classPrivateFieldGet(this, _createSocketCluster_AfterListenFunctions, "f").length > 0 ||
__classPrivateFieldGet(this, _createSocketCluster_AfterListenFunctions, "f") !== undefined) {
for (const ListenFunction of __classPrivateFieldGet(this, _createSocketCluster_AfterListenFunctions, "f")) {
yield ListenFunction();
}
}
}));
__classPrivateFieldGet(this, _createSocketCluster_GlobalResponseObject, "f").ActiveServer = ActiveServer;
__classPrivateFieldGet(this, _createSocketCluster_WebSocketServer, "f").on("connection", (ws) => {
(0, Console_log_1.green)("Client connected");
ws.on("message", (message) => {
(0, Console_log_1.blue)(`Received message: ${message}`);
});
ws.on("close", () => {
(0, Console_log_1.red)("Client disconnected");
});
__classPrivateFieldSet(this, _createSocketCluster_WebSocketConnectionHandler, ws, "f");
});
return Object.freeze(__classPrivateFieldGet(this, _createSocketCluster_GlobalResponseObject, "f"));
}
catch (error) {
(0, Console_log_1.red)(`Error in Starting Server : ${error}`);
return Object.freeze(Object.assign({ Error: error }, __classPrivateFieldGet(this, _createSocketCluster_GlobalResponseObject, "f")));
}
}
});
}
/**
* Gets the WebSocket connection handler.
* @returns The WebSocket connection handler or null.
*/
getWebSocketConnectionHandler() {
return __classPrivateFieldGet(this, _createSocketCluster_WebSocketConnectionHandler, "f");
}
/**
* Sets the number of workers.
* @param NumberOfWorkers - The number of workers.
* @throws Error if NumberOfWorkers is not provided, not a number, or not a positive number.
*/
SetNumberOfWorkers(NumberOfWorkers) {
if (!NumberOfWorkers) {
throw new Error("Number of Workers is not provided");
}
if (typeof NumberOfWorkers !== "number") {
throw new Error("Number of Workers is not a Number");
}
if (NumberOfWorkers <= 0) {
throw new Error("Number of Workers is not a Positive Number");
}
__classPrivateFieldSet(this, _createSocketCluster_NumberOfWorkers, NumberOfWorkers, "f");
}
/**
* Adds a function to run before listen.
* @param FunctionToRun - The function to run before listen.
* @throws Error if FunctionToRun is not provided or not a function.
*/
AddBeforeListenFunction(FunctionToRun) {
if (!FunctionToRun) {
throw new Error("Function to Run is not provided");
}
if (typeof FunctionToRun !== "function") {
throw new Error("Function to Run is not a Function");
}
__classPrivateFieldGet(this, _createSocketCluster_BeforeListenFunctions, "f").push(FunctionToRun);
}
/**
* Adds a function to run after listen.
* @param FunctionToRun - The function to run after listen.
* @throws Error if FunctionToRun is not provided or not a function.
*/
AddAfterListenFunction(FunctionToRun) {
if (!FunctionToRun) {
throw new Error("Function to Run is not provided");
}
if (typeof FunctionToRun !== "function") {
throw new Error("Function to Run is not a Function");
}
__classPrivateFieldGet(this, _createSocketCluster_AfterListenFunctions, "f").push(FunctionToRun);
}
/**
* Adds a middleware function.
* @param FunctionToRun - The middleware function to add.
* @throws Error if FunctionToRun is not provided or not a function.
*/
AddMiddleware(FunctionToRun) {
if (!FunctionToRun) {
throw new Error("Function to Run is not provided");
}
if (typeof FunctionToRun !== "function") {
throw new Error("Function to Run is not a Function");
}
__classPrivateFieldGet(this, _createSocketCluster_FunctionMiddlewares, "f").push(FunctionToRun);
}
/**
* Sets the status of the Trust Proxy.
* @param Status - The status of the Trust Proxy.
* @throws Error if Status is not provided or not a boolean.
*/
SetEnableTrustProxy(Status) {
if (!Status) {
throw new Error("Trust Proxy Status is not provided");
}
if (typeof Status !== "boolean") {
throw new Error("Trust Proxy Status is not a Boolean");
}
__classPrivateFieldSet(this, _createSocketCluster_EnableTrustProxy, Status, "f");
}
}
_createSocketCluster_ExpressServer = new WeakMap(), _createSocketCluster_HTTPServer = new WeakMap(), _createSocketCluster_WebSocketServer = new WeakMap(), _createSocketCluster_PORT = new WeakMap(), _createSocketCluster_NumberOfWorkers = new WeakMap(), _createSocketCluster_BeforeListenFunctions = new WeakMap(), _createSocketCluster_AfterListenFunctions = new WeakMap(), _createSocketCluster_FunctionMiddlewares = new WeakMap(), _createSocketCluster_GlobalResponseObject = new WeakMap(), _createSocketCluster_EnableTrustProxy = new WeakMap(), _createSocketCluster_WebSocketConnectionHandler = new WeakMap();
exports.default = createSocketCluster;
//# sourceMappingURL=createSocketClusterByClass.method.js.map