serverpreconfigured 2.2.15 → 2.2.17

package/dist/routes/wsauth.js

@@ -0,0 +1,33 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.router = void 0;
+const express_1 = __importDefault(require("express"));
+const response_1 = require("../utils/response");
+const wsauth_1 = require("../wsauth/wsauth");
+const auth_1 = require("../middlewares/auth");
+exports.router = express_1.default.Router();
+exports.router.post('/gettoken', auth_1.setUserDataMiddleware, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let userId = req.user.id;
+        let n = yield (0, wsauth_1.setWSAuthDataNewToken)(userId);
+        return res.send((0, response_1.JSONResponse)({ token: n.dataValues.token,
+            expiration: n.dataValues.expiration,
+            userId: userId
+        }));
+    }
+    catch (e) {
+        return (0, response_1.sendIError)(req, res, e);
+    }
+}));

package/dist/server.d.ts

@@ -0,0 +1,15 @@
+export * from "./auth/auth";
+export { User } from "./database/models/User";
+export { dataBase } from "./database/database";
+export * from "./sessions/secureset";
+export * from "./sessions/secureget";
+export * from "./users/users";
+export { WebSocketAuth } from "./database/models/WSAuth";
+export * from "./wsauth/wsauth";
+export { randomString } from "./utils/string/random";
+export { JSONResponse } from "./utils/response";
+import ExpressServer from "./expressServer";
+export { debugMessage } from "./utils/debug/debug";
+export * from "./middlewares/auth";
+export * from "./middlewares/wsauth";
+export default ExpressServer;

package/dist/server.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugMessage = exports.JSONResponse = exports.randomString = exports.WebSocketAuth = exports.dataBase = exports.User = void 0;
+__exportStar(require("./auth/auth"), exports);
+;
+var User_1 = require("./database/models/User");
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return User_1.User; } });
+var database_1 = require("./database/database");
+Object.defineProperty(exports, "dataBase", { enumerable: true, get: function () { return database_1.dataBase; } });
+__exportStar(require("./sessions/secureset"), exports);
+__exportStar(require("./sessions/secureget"), exports);
+__exportStar(require("./users/users"), exports);
+var WSAuth_1 = require("./database/models/WSAuth");
+Object.defineProperty(exports, "WebSocketAuth", { enumerable: true, get: function () { return WSAuth_1.WebSocketAuth; } });
+__exportStar(require("./wsauth/wsauth"), exports);
+var random_1 = require("./utils/string/random");
+Object.defineProperty(exports, "randomString", { enumerable: true, get: function () { return random_1.randomString; } });
+var response_1 = require("./utils/response");
+Object.defineProperty(exports, "JSONResponse", { enumerable: true, get: function () { return response_1.JSONResponse; } });
+const expressServer_1 = __importDefault(require("./expressServer"));
+var debug_1 = require("./utils/debug/debug");
+Object.defineProperty(exports, "debugMessage", { enumerable: true, get: function () { return debug_1.debugMessage; } });
+__exportStar(require("./middlewares/auth"), exports);
+__exportStar(require("./middlewares/wsauth"), exports);
+exports.default = expressServer_1.default;

package/dist/sessions/secureget.d.ts

@@ -0,0 +1 @@
+export declare function getSessionValue(req: any, get: string): any;

package/dist/sessions/secureget.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionValue = void 0;
+function getSessionValue(req, get) {
+    return req.session[get];
+}
+exports.getSessionValue = getSessionValue;

package/dist/sessions/secureset.d.ts

@@ -0,0 +1,2 @@
+export declare function setSessionValue(req: any, to: string, value: any): void;
+export declare function deleteSessionValue(req: any, to: string): void;

package/dist/sessions/secureset.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSessionValue = exports.setSessionValue = void 0;
+function setSessionValue(req, to, value) {
+    req.session[to] = value;
+}
+exports.setSessionValue = setSessionValue;
+function deleteSessionValue(req, to) {
+    setSessionValue(req, to, undefined);
+}
+exports.deleteSessionValue = deleteSessionValue;

package/dist/settings/database/database.d.ts

@@ -0,0 +1,11 @@
+export const dialect: string;
+export const host: any;
+export const database: any;
+export const username: any;
+export const password: string | undefined;
+export const port: any;
+export namespace define {
+    const underscored: boolean;
+    const timestamps: boolean;
+}
+export const logging: boolean;

package/dist/settings/database/database.js

@@ -0,0 +1,15 @@
+"use strict";
+const ENV = require("./../env").default;
+module.exports = {
+    dialect: ENV.DATABASE.dialect,
+    host: ENV.DATABASE.host,
+    database: ENV.DATABASE.database,
+    username: ENV.DATABASE.username,
+    password: ENV.DATABASE.password,
+    port: ENV.DATABASE.port,
+    define: {
+        underscored: true,
+        timestamps: true,
+    },
+    logging: false,
+};

package/dist/settings/env.d.ts

@@ -0,0 +1,15 @@
+declare const ENV: {
+    NODE_ENV: string;
+    ALLOW_CORS: boolean;
+    PORT: number;
+    DATABASE: {
+        dialect: string;
+        port: any;
+        host: any;
+        database: any;
+        username: any;
+        password: string | undefined;
+    };
+    SESSION_SECRET: string;
+};
+export default ENV;

package/dist/settings/env.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const custom_env_path = path_1.default.join(process.cwd(), "spc_envfile.json");
+var custom_env = {};
+try {
+    custom_env = JSON.parse(fs_1.default.readFileSync(custom_env_path).toString());
+}
+catch (e) {
+    custom_env = {};
+}
+const ENV = {
+    NODE_ENV: process.env.SERVER_ENV == 'development' ? 'development' : 'production',
+    ALLOW_CORS: process.env.ALLOW_CORS == 'ALLOW' ? true : false,
+    PORT: process.env.SERVER_PORT ? parseInt(process.env.SERVER_PORT) : 3000,
+    DATABASE: {
+        dialect: process.env.DATABASE_DIALECT ? process.env.DATABASE_DIALECT : 'postgres',
+        port: (custom_env.DATABASE && custom_env.DATABASE.PORT) || process.env.DATABASE_PORT || 5432,
+        host: (custom_env.DATABASE && custom_env.DATABASE.HOST) || (process.env.DATABASE_HOST ? process.env.DATABASE_HOST : 'localhost'),
+        database: (custom_env.DATABASE && custom_env.DATABASE.DATABASE) || (process.env.DATABASE_DATABASE || 'postgres'),
+        username: (custom_env.DATABASE && custom_env.DATABASE.USERNAME) || (process.env.DATABASE_USERNAME ? process.env.DATABASE_USERNAME : 'postgres'),
+        password: (custom_env.DATABASE && custom_env.DATABASE.PASSWOR) || process.env.DATABASE_PASSWORD ? process.env.DATABASE_PASSWORD : '',
+    },
+    SESSION_SECRET: process.env.SESSION_SECRET ? process.env.SESSION_SECRET : "secret key session",
+};
+exports.default = ENV;

package/dist/users/password.d.ts

@@ -0,0 +1,3 @@
+import { PasswordVerifyResult } from './types';
+export declare function createArgon2Hash(password_string: string): Promise<string | false>;
+export declare function checkArgon2Password(password_hash: string, password_string: string): Promise<PasswordVerifyResult>;

package/dist/users/password.js

@@ -0,0 +1,41 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArgon2Password = exports.createArgon2Hash = void 0;
+const argon2_1 = __importDefault(require("argon2"));
+function createArgon2Hash(password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let hash = yield argon2_1.default.hash(password_string);
+            return hash;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.createArgon2Hash = createArgon2Hash;
+function checkArgon2Password(password_hash, password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (yield argon2_1.default.verify(password_hash, password_string))
+                return "Match";
+            return "Dont Match";
+        }
+        catch (e) {
+            return "Dont Match";
+        }
+    });
+}
+exports.checkArgon2Password = checkArgon2Password;

package/dist/users/types.d.ts

@@ -0,0 +1,6 @@
+export interface UserCreateInterface {
+    first_name: string;
+    email: string;
+    password_string: string;
+}
+export declare type PasswordVerifyResult = 'Match' | 'Dont Match';

package/dist/users/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/dist/users/users.d.ts

@@ -0,0 +1,12 @@
+import { User } from "./../database/models/User";
+import { UserCreateInterface } from "./types";
+export declare function updateUserLastAction(user: User): Promise<User>;
+export declare function getUserSessionData(req: any): string;
+export declare function getUserById(id: Number): Promise<any>;
+export declare function getUserByEmail(email: string): Promise<any>;
+export declare function getUserIdByUserEmail(email: string): Promise<number>;
+export declare function deleteUserById(id: Number): Promise<any>;
+export declare function isUserExist(email: string): Promise<boolean>;
+export declare function createUser(data: UserCreateInterface): Promise<any>;
+export declare function changeUserPassword(email: string, password: string): Promise<User>;
+export declare function checkUserPassword(email: string, password_string: string): Promise<boolean>;

package/dist/users/users.js

@@ -0,0 +1,143 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUserPassword = exports.changeUserPassword = exports.createUser = exports.isUserExist = exports.deleteUserById = exports.getUserIdByUserEmail = exports.getUserByEmail = exports.getUserById = exports.getUserSessionData = exports.updateUserLastAction = void 0;
+const User_1 = require("./../database/models/User");
+const password_1 = require("./password");
+const config_1 = require("../auth/config");
+const secureget_1 = require("../sessions/secureget");
+function updateUserLastAction(user) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            user.last_action = new Date();
+            yield user.save();
+            return user;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.updateUserLastAction = updateUserLastAction;
+function getUserSessionData(req) {
+    return (0, secureget_1.getSessionValue)(req, config_1.SESSION_LOGGED_DATA);
+}
+exports.getUserSessionData = getUserSessionData;
+function getUserById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.findOne({ where: { id: id.toString() } });
+        return (result);
+    });
+}
+exports.getUserById = getUserById;
+function getUserByEmail(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.findOne({ where: { email: email } });
+        return (result);
+    });
+}
+exports.getUserByEmail = getUserByEmail;
+function getUserIdByUserEmail(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let u = yield getUserByEmail(email);
+            if (!Boolean(u))
+                return NaN;
+            return u.dataValues.id;
+        }
+        catch (e) {
+            return NaN;
+        }
+    });
+}
+exports.getUserIdByUserEmail = getUserIdByUserEmail;
+function deleteUserById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.destroy({ where: { id: id.toString() } });
+        return result;
+    });
+}
+exports.deleteUserById = deleteUserById;
+function isUserExist(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let user = yield getUserByEmail(email);
+            return Boolean(user);
+        }
+        catch (e) {
+            throw (e);
+        }
+    });
+}
+exports.isUserExist = isUserExist;
+function createUser(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let user_exist = false;
+        try {
+            user_exist = yield isUserExist(data.email);
+        }
+        catch (e) {
+            throw (e);
+        }
+        if (user_exist)
+            throw "User exist";
+        let hash = yield (0, password_1.createArgon2Hash)(data.password_string);
+        if (!hash)
+            throw "Create argon2 hash error";
+        try {
+            let user_instance = yield User_1.User.create({ email: data.email,
+                first_name: data.first_name,
+                password_hash: hash });
+            return user_instance;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.createUser = createUser;
+function changeUserPassword(email, password) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let user = yield User_1.User.findOne({ where: { email } });
+            if (!user)
+                throw "Unknwon User";
+            let hash = yield (0, password_1.createArgon2Hash)(password);
+            if (typeof (hash) !== "string")
+                throw "Create Hash Error";
+            user.password_hash = hash;
+            yield user.save();
+            return user;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.changeUserPassword = changeUserPassword;
+function checkUserPassword(email, password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let user;
+        try {
+            user = yield getUserByEmail(email);
+        }
+        catch (e) {
+            throw e;
+        }
+        if (!user)
+            return false;
+        let hash = user.dataValues.password_hash;
+        if ((yield (0, password_1.checkArgon2Password)(hash, password_string)) == 'Match')
+            return true;
+        return false;
+    });
+}
+exports.checkUserPassword = checkUserPassword;

package/dist/utils/debug/debug.d.ts

@@ -0,0 +1 @@
+export declare function debugMessage(isDebug: boolean, message: string, data?: any): void;

package/dist/utils/debug/debug.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugMessage = void 0;
+function debugMessage(isDebug, message, data = {}) {
+    if (!isDebug)
+        return;
+    let error = new Error();
+    let stack = error.stack.split("\n");
+    let addData = data.data ? JSON.stringify(data.data) : "";
+    console.log("----DEBUG----" +
+        "\nCaller: " + stack[2] +
+        "\nMessage: " + message +
+        (addData ? "\naddData: " + addData : ""));
+}
+exports.debugMessage = debugMessage;

package/dist/utils/response.d.ts

@@ -0,0 +1,8 @@
+import { LogSeverity } from "../logs/logs";
+export declare function JSONResponse(data: any, error?: any): string;
+export interface SendIErrorOptions {
+    severity?: LogSeverity;
+    penTestSuspcion?: boolean;
+}
+export declare function sendIError(req: any, res: any, error?: any, options?: SendIErrorOptions): any;
+export declare function WSResponse(isOK: boolean, message?: string, errorMessage?: string, data?: any): string;

package/dist/utils/response.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSResponse = exports.sendIError = exports.JSONResponse = void 0;
+const logs_1 = require("../logs/logs");
+function JSONResponse(data, error) {
+    return JSON.stringify({
+        data,
+        hasError: Boolean(error),
+        error,
+    });
+}
+exports.JSONResponse = JSONResponse;
+;
+function sendIError(req, res, error, options) {
+    (0, logs_1.saveInternalErrorLog)(req, error, options);
+    return res.status(500).send(JSONResponse("", "I-E"));
+}
+exports.sendIError = sendIError;
+function WSResponse(isOK, message = '', errorMessage = "", data = {}) {
+    return JSON.stringify({
+        is_ok: isOK,
+        message: message,
+        error_message: errorMessage,
+        data: data
+    });
+}
+exports.WSResponse = WSResponse;

package/dist/utils/string/random.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length: number): string;

package/dist/utils/string/random.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = void 0;
+function randomString(length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() *
+            charactersLength));
+    }
+    return result;
+}
+exports.randomString = randomString;

package/dist/utils/validators/email.d.ts

@@ -0,0 +1 @@
+export declare function checkEmail(email: string): boolean;

package/dist/utils/validators/email.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmail = void 0;
+function checkEmail(email) {
+    const atIndex = email.indexOf("@");
+    if (atIndex < 1)
+        return false;
+    const after = email.slice(atIndex + 1);
+    if (after.length < 3)
+        return false;
+    if (after.indexOf('@') >= 0)
+        return false;
+    const periodIndex = after.indexOf('.');
+    if (periodIndex < 1 || periodIndex >= after.length - 1)
+        return false;
+    return true;
+}
+exports.checkEmail = checkEmail;

package/dist/wsauth/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/wsauth/wsauth.d.ts

@@ -0,0 +1,5 @@
+export declare function getWSAuthDataByUserId(userId: number): Promise<any>;
+export declare function setWSAuthDataNewToken(userId: number, expiration_hours?: number): Promise<any>;
+export declare function checkWSAuthToken(userId: number, token: string): Promise<boolean>;
+export declare function authenticateWS(userId: number, token: string, connection_token: string): Promise<boolean>;
+export declare function checkConnectionAuth(userId: number, connection_token: string): Promise<boolean>;

package/dist/wsauth/wsauth.js

@@ -0,0 +1,111 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConnectionAuth = exports.authenticateWS = exports.checkWSAuthToken = exports.setWSAuthDataNewToken = exports.getWSAuthDataByUserId = void 0;
+const server_1 = require("../server");
+const random_1 = require("./../utils/string/random");
+function getWSAuthDataByUserId(userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let u = yield server_1.WebSocketAuth.findOne({ where: { user_id: userId.toString() } });
+            return u;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.getWSAuthDataByUserId = getWSAuthDataByUserId;
+function setWSAuthDataNewToken(userId, expiration_hours = 72) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            let token = (0, random_1.randomString)(50);
+            let expiration = new Date();
+            expiration.setTime(expiration.getTime() + expiration_hours * 60 * 60 * 1000);
+            if (!Boolean(ws)) {
+                return yield server_1.WebSocketAuth.create({ user_id: userId.toString(),
+                    token: token,
+                    expiration: expiration,
+                    is_active: true,
+                    auth_connection_token: "",
+                });
+            }
+            else {
+                ws.token = token;
+                ws.expiration = expiration;
+                ws.is_active = true;
+                ws.auth_connection_token = "";
+                return yield ws.save();
+            }
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.setWSAuthDataNewToken = setWSAuthDataNewToken;
+function checkWSAuthToken(userId, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            if (!Boolean(ws))
+                return false;
+            if (!ws.dataValues.is_active)
+                return false;
+            if (ws.dataValues.token != token)
+                return false;
+            if (Date.now() > ws.dataValues.expiration.getTime())
+                return false;
+            return true;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.checkWSAuthToken = checkWSAuthToken;
+function authenticateWS(userId, token, connection_token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!(yield checkWSAuthToken(userId, token)))
+                return false;
+            let ws = yield getWSAuthDataByUserId(userId);
+            ws.auth_connection_token = connection_token;
+            yield ws.save();
+            return true;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.authenticateWS = authenticateWS;
+function checkConnectionAuth(userId, connection_token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let ws = yield getWSAuthDataByUserId(userId);
+            if (!Boolean(ws))
+                return false;
+            if (!ws.dataValues.is_active)
+                return false;
+            if (Date.now() > ws.dataValues.expiration.getTime())
+                return false;
+            if (ws.dataValues.auth_connection_token !== connection_token)
+                return false;
+            return true;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.checkConnectionAuth = checkConnectionAuth;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverpreconfigured",
-  "version": "2.2.15",
+  "version": "2.2.17",
   "description": "\"Pre-configured server with authentication system and database integration\"",
   "main": "dist/server.js",
   "keywords": [