serverpreconfigured 1.0.3 → 1.0.4

package/dist/database/models/WSAuth.d.ts

@@ -2,5 +2,6 @@ import { Model } from "sequelize";
 export declare class WebSocketAuth extends Model {
     token: string;
     expiration: Date;
+    auth_connection_token: string;
     static init(sequelize: any): void;
 }

package/dist/database/models/WSAuth.js

@@ -8,6 +8,8 @@ class WebSocketAuth extends sequelize_1.Model {
             token: sequelize_2.DataTypes.STRING,
             expiration: sequelize_2.DataTypes.DATE,
             user_id: sequelize_2.DataTypes.INTEGER,
+            is_active: sequelize_2.DataTypes.BOOLEAN,
+            auth_connection_token: sequelize_2.DataTypes.STRING,
         }, {
             sequelize: sequelize,
             tableName: 'spc_wsauth'

package/dist/server.d.ts

@@ -5,6 +5,7 @@ export { setSessionValue, deleteSessionValue } from "./sessions/secureset";
 export { getSessionValue } from "./sessions/secureget";
 export { checkUserPassword } from "./users/users";
 export { WebSocketAuth } from "./database/models/WSAuth";
-export { checkWSAuthToken } from "./wsauth/wsauth";
+export { checkWSAuthToken, authenticateWS, checkConnectionAuth } from "./wsauth/wsauth";
+export { randomString } from "./utils/string/random";
 import ExpressServer from "./expressServer";
 export default ExpressServer;

package/dist/server.js

@@ -21,6 +21,11 @@ var WSAuth_1 = require("./database/models/WSAuth");
 exports.WebSocketAuth = WSAuth_1.WebSocketAuth;
 var wsauth_1 = require("./wsauth/wsauth");
 exports.checkWSAuthToken = wsauth_1.checkWSAuthToken;
+exports.authenticateWS = wsauth_1.authenticateWS;
+exports.checkConnectionAuth = wsauth_1.checkConnectionAuth;
+var random_1 = require("./utils/string/random");
+exports.randomString = random_1.randomString;
 const expressServer_1 = __importDefault(require("./expressServer"));
+;
 exports.default = expressServer_1.default;
 const e = new expressServer_1.default();

package/dist/users/password.d.ts

@@ -1,2 +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<"Match" | "Dont Match">;
+export declare function checkArgon2Password(password_hash: string, password_string: string): Promise<PasswordVerifyResult>;

package/dist/users/users.js

@@ -31,7 +31,7 @@ function getUserIdByUserEmail(email) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             let u = yield getUserByEmail(email);
-            if (u == null || u == undefined)
+            if (!Boolean(u))
                 return NaN;
             return u.dataValues.id;
         }

package/dist/wsauth/types.d.ts

@@ -0,0 +1,4 @@
+export declare enum AuthenticateWSResult {
+    OK = 1,
+    InvalidToken = 2
+}

package/dist/wsauth/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AuthenticateWSResult;
+(function (AuthenticateWSResult) {
+    AuthenticateWSResult[AuthenticateWSResult["OK"] = 1] = "OK";
+    AuthenticateWSResult[AuthenticateWSResult["InvalidToken"] = 2] = "InvalidToken";
+})(AuthenticateWSResult = exports.AuthenticateWSResult || (exports.AuthenticateWSResult = {}));

package/dist/wsauth/wsauth.d.ts

@@ -1,3 +1,6 @@
+import { AuthenticateWSResult } from "./types";
 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<AuthenticateWSResult>;
+export declare function checkConnectionAuth(userId: number, connection_token: string): Promise<boolean>;

package/dist/wsauth/wsauth.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const server_1 = require("../server");
 const server_2 = require("../server");
 const random_1 = require("./../utils/string/random");
+const types_1 = require("./types");
 server_1.WebSocketAuth.init(server_2.dataBase);
 function getWSAuthDataByUserId(userId) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -32,15 +33,19 @@ function setWSAuthDataNewToken(userId, expiration_hours = 72) {
             let token = random_1.randomString(50);
             let expiration = new Date();
             expiration.setTime(expiration.getTime() + expiration_hours * 60 * 60 * 1000);
-            if (ws == null || ws == undefined) {
+            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();
             }
         }
@@ -56,6 +61,8 @@ function checkWSAuthToken(userId, token) {
             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())
@@ -63,8 +70,44 @@ function checkWSAuthToken(userId, token) {
             return true;
         }
         catch (e) {
-            return false;
+            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 types_1.AuthenticateWSResult.InvalidToken;
+            let ws = yield getWSAuthDataByUserId(userId);
+            ws.auth_connection_token = connection_token;
+            yield ws.save();
+            return types_1.AuthenticateWSResult.OK;
+        }
+        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/migrations/20220320173911-serverpreconfigured-startwsauth.js

@@ -21,6 +21,16 @@ module.exports = {
          type:Sequelize.DATE,
          allowNull:false,
        },
+       is_active:{
+         type:Sequelize.BOOLEAN,
+         allowNull:false,
+         defaultValue:true,
+       },
+       auth_connection_token:{
+         type:Sequelize.STRING,
+         allowNull:true,
+         defaultValue:"",
+       },
        created_at:{
         type:Sequelize.DATE,
         allowNull:false,

package/package.json

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

package/src/database/models/WSAuth.ts

@@ -3,11 +3,14 @@ import { DataTypes } from "sequelize";
 export class WebSocketAuth extends Model{
     declare token:string;
     declare expiration:Date;
+    declare auth_connection_token:string;
     static init(sequelize:any){
         super.init({
           token:DataTypes.STRING,
           expiration:DataTypes.DATE,
           user_id:DataTypes.INTEGER, 
+          is_active:DataTypes.BOOLEAN,
+          auth_connection_token:DataTypes.STRING,
         },{
           sequelize:sequelize,
           tableName:'spc_wsauth'

package/src/server.ts

@@ -5,7 +5,9 @@ export { setSessionValue,deleteSessionValue } from "./sessions/secureset";
 export { getSessionValue } from "./sessions/secureget";
 export { checkUserPassword } from "./users/users";
 export { WebSocketAuth } from "./database/models/WSAuth";
-export { checkWSAuthToken } from "./wsauth/wsauth";
+export { checkWSAuthToken ,authenticateWS,checkConnectionAuth} from "./wsauth/wsauth";
+export { randomString } from "./utils/string/random"
 import ExpressServer from "./expressServer";
+;
 export default ExpressServer;
 const e=new ExpressServer();

package/src/users/password.ts

@@ -9,7 +9,7 @@ export async function createArgon2Hash(password_string:string){
    }
 }
 
-export async function checkArgon2Password(password_hash:string,password_string:string){
+export async function checkArgon2Password(password_hash:string,password_string:string):Promise<PasswordVerifyResult>{
   try{
      if(await argon2.verify(password_hash,password_string))
         return "Match";

package/src/users/users.ts

@@ -15,7 +15,7 @@ export async function getUserByEmail(email:string){
 export async function getUserIdByUserEmail(email:string):Promise<number>{
      try{
         let u=await getUserByEmail(email);
-        if(u==null || u==undefined)
+        if(!Boolean(u))
           return NaN;
         return u.dataValues.id;
      }catch(e){

package/src/wsauth/types.ts

@@ -0,0 +1,4 @@
+export enum AuthenticateWSResult{
+    OK=1,
+    InvalidToken,
+}

package/src/wsauth/wsauth.ts

@@ -1,8 +1,9 @@
 import { WebSocketAuth } from "../server";
 import { dataBase } from "../server";
 import {randomString} from "./../utils/string/random";
+import {AuthenticateWSResult} from "./types";
 WebSocketAuth.init(dataBase);
-export async function getWSAuthDataByUserId(userId:number){
+export async function getWSAuthDataByUserId(userId:number):Promise<any>{
    try{
       let u=await WebSocketAuth.findOne({where:{user_id:userId.toString()}});
       return u;
@@ -17,14 +18,18 @@ export async function setWSAuthDataNewToken(userId:number,expiration_hours:numbe
       let token=randomString(50);
       let expiration=new Date();
       expiration.setTime(expiration.getTime()+expiration_hours*60*60*1000);
-      if(ws==null || ws==undefined){
+      if(!Boolean(ws)){
           return await 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 await ws.save();
       }
    }catch(e){
@@ -37,12 +42,44 @@ export async function checkWSAuthToken(userId:number,token:string):Promise<boole
        let ws=await 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){
-       return false;
+       throw e;
     }
+}
+
+export async function authenticateWS(userId:number,token:string,connection_token:string):Promise<AuthenticateWSResult>{
+    try{
+      if(!(await checkWSAuthToken(userId,token)))
+         return AuthenticateWSResult.InvalidToken; 
+      let ws=await getWSAuthDataByUserId(userId);  
+      ws.auth_connection_token=connection_token;
+      await ws.save();
+      return AuthenticateWSResult.OK;
+    }catch(e){
+       throw e;
+    } 
+}
+
+export async function checkConnectionAuth(userId:number,connection_token:string):Promise<boolean>{
+   try{
+     let ws=await 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;
+   }
 }