From 33fbabdd72ddcc57eab57cb626cb436f821b1c51 Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Mon, 12 Aug 2019 22:31:40 +0200 Subject: [PATCH] fix(core): update --- .vscode/launch.json | 29 ++++++++ test/test.expressserver.ts | 73 ++++++--------------- test/test.ts | 71 ++++++-------------- ts/smartsocket.classes.smartsocket.ts | 9 ++- ts/smartsocket.classes.smartsocketclient.ts | 44 ++++++++----- ts/smartsocket.classes.socketconnection.ts | 29 ++++---- ts/smartsocket.classes.socketfunction.ts | 29 ++++---- ts/smartsocket.classes.socketrequest.ts | 41 ++++++++---- ts/smartsocket.classes.socketrole.ts | 32 +++++++-- ts/smartsocket.helpers.ts | 60 ----------------- 10 files changed, 190 insertions(+), 227 deletions(-) create mode 100644 .vscode/launch.json delete mode 100644 ts/smartsocket.helpers.ts diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..112db52 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,29 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "current file", + "type": "node", + "request": "launch", + "args": [ + "${relativeFile}" + ], + "runtimeArgs": ["-r", "@gitzone/tsrun"], + "cwd": "${workspaceRoot}", + "protocol": "inspector", + "internalConsoleOptions": "openOnSessionStart" + }, + { + "name": "test.ts", + "type": "node", + "request": "launch", + "args": [ + "test/test.ts" + ], + "runtimeArgs": ["-r", "@gitzone/tsrun"], + "cwd": "${workspaceRoot}", + "protocol": "inspector", + "internalConsoleOptions": "openOnSessionStart" + } + ] +} diff --git a/test/test.expressserver.ts b/test/test.expressserver.ts index f21dc8b..4a468d4 100644 --- a/test/test.expressserver.ts +++ b/test/test.expressserver.ts @@ -36,10 +36,6 @@ tap.test('Should accept an smartExpressServer as server', async () => { await myseServer.start(); }); -tap.test('should start listening when .started is called', async () => { - await testSmartsocket.start(); -}); - // class socketrole tap.test('should add a socketrole', async () => { testSocketRole1 = new smartsocket.SocketRole({ @@ -53,16 +49,21 @@ tap.test('should add a socketrole', async () => { tap.test('should register a new Function', async () => { testSocketFunction1 = new smartsocket.SocketFunction({ allowedRoles: [testSocketRole1], - funcDef: async dataArg => { + funcDef: async (dataArg, socketConnectionArg) => { return dataArg; }, funcName: 'testFunction1' }); + testSmartsocket.addSocketFunction(testSocketFunction1); + console.log(testSmartsocket.socketFunctions); +}); + +tap.test('should start listening when .started is called', async () => { + await testSmartsocket.start(); }); // class SmartsocketClient tap.test('should react to a new websocket connection from client', async () => { - const done = smartpromise.defer(); testSmartsocketClient = new smartsocket.SmartsocketClient({ port: testConfig.port, url: 'http://localhost', @@ -70,26 +71,15 @@ tap.test('should react to a new websocket connection from client', async () => { alias: 'testClient1', role: 'testRole1' }); - testSmartsocketClient.connect().then(() => { - done.resolve(); - }); - await done.promise; + testSmartsocketClient.addSocketFunction(testSocketFunction1); + console.log(testSmartsocketClient.socketFunctions); + await testSmartsocketClient.connect(); }); -tap.test('client should disconnect and reconnect', async () => { - let done = smartpromise.defer(); - testSmartsocketClient - .disconnect() - .then(() => { - let done = smartpromise.defer(); - setTimeout(() => { - testSmartsocketClient.connect().then(done.resolve); - }, 0); - return done.promise; - }) - .then(() => { - done.resolve(); - }); - await done.promise; + +tap.test('client should disconnect and reconnect', async tools => { + await testSmartsocketClient.disconnect(); + await tools.delayFor(100); + await testSmartsocketClient.connect(); }); tap.test('2 clients should connect in parallel', async () => { @@ -97,37 +87,14 @@ tap.test('2 clients should connect in parallel', async () => { }); tap.test('should be able to make a functionCall from client to server', async () => { - let done = smartpromise.defer(); - testSmartsocketClient - .serverCall('testFunction1', { - value1: 'hello' - }) - .then(dataArg => { - console.log(dataArg); - done.resolve(); - }); - await done.promise; + const response = await testSmartsocketClient.serverCall('testFunction1', { + value1: 'hello' + }); + console.log(response); }); tap.test('should be able to make a functionCall from server to client', async () => { - let done = smartpromise.defer(); - let targetSocket = (() => { - return smartsocket.allSocketConnections.find(socketConnectionArg => { - return socketConnectionArg.alias === 'testClient1'; - }); - })(); - testSmartsocket - .clientCall( - 'testFunction1', - { - value1: 'helloFromServer' - }, - targetSocket - ) - .then(dataArg => { - console.log(dataArg); - done.resolve(); - }); + }); // terminate diff --git a/test/test.ts b/test/test.ts index 90e780f..512a593 100644 --- a/test/test.ts +++ b/test/test.ts @@ -22,10 +22,6 @@ tap.test('should create a new smartsocket', async () => { expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket); }); -tap.test('should start listening when .started is called', async () => { - await testSmartsocket.start(); -}); - // class socketrole tap.test('should add a socketrole', async () => { testSocketRole1 = new smartsocket.SocketRole({ @@ -44,11 +40,16 @@ tap.test('should register a new Function', async () => { }, funcName: 'testFunction1' }); + testSmartsocket.addSocketFunction(testSocketFunction1); + console.log(testSmartsocket.socketFunctions); +}); + +tap.test('should start listening when .started is called', async () => { + await testSmartsocket.start(); }); // class SmartsocketClient tap.test('should react to a new websocket connection from client', async () => { - const done = smartpromise.defer(); testSmartsocketClient = new smartsocket.SmartsocketClient({ port: testConfig.port, url: 'http://localhost', @@ -56,26 +57,15 @@ tap.test('should react to a new websocket connection from client', async () => { alias: 'testClient1', role: 'testRole1' }); - testSmartsocketClient.connect().then(() => { - done.resolve(); - }); - await done.promise; + testSmartsocketClient.addSocketFunction(testSocketFunction1); + console.log(testSmartsocketClient.socketFunctions); + await testSmartsocketClient.connect(); }); -tap.test('client should disconnect and reconnect', async () => { - let done = smartpromise.defer(); - testSmartsocketClient - .disconnect() - .then(() => { - let done = smartpromise.defer(); - setTimeout(() => { - testSmartsocketClient.connect().then(done.resolve); - }, 0); - return done.promise; - }) - .then(() => { - done.resolve(); - }); - await done.promise; + +tap.test('client should disconnect and reconnect', async tools => { + await testSmartsocketClient.disconnect(); + await tools.delayFor(100); + await testSmartsocketClient.connect(); }); tap.test('2 clients should connect in parallel', async () => { @@ -83,37 +73,14 @@ tap.test('2 clients should connect in parallel', async () => { }); tap.test('should be able to make a functionCall from client to server', async () => { - let done = smartpromise.defer(); - testSmartsocketClient - .serverCall('testFunction1', { - value1: 'hello' - }) - .then(dataArg => { - console.log(dataArg); - done.resolve(); - }); - await done.promise; + const response = await testSmartsocketClient.serverCall('testFunction1', { + value1: 'hello' + }); + console.log(response); }); tap.test('should be able to make a functionCall from server to client', async () => { - let done = smartpromise.defer(); - let targetSocket = (() => { - return smartsocket.allSocketConnections.find(socketConnectionArg => { - return socketConnectionArg.alias === 'testClient1'; - }); - })(); - testSmartsocket - .clientCall( - 'testFunction1', - { - value1: 'helloFromServer' - }, - targetSocket - ) - .then(dataArg => { - console.log(dataArg); - done.resolve(); - }); + }); // terminate diff --git a/ts/smartsocket.classes.smartsocket.ts b/ts/smartsocket.classes.smartsocket.ts index d4f2178..35262a0 100644 --- a/ts/smartsocket.classes.smartsocket.ts +++ b/ts/smartsocket.classes.smartsocket.ts @@ -1,5 +1,4 @@ import * as plugins from './smartsocket.plugins'; -import * as helpers from './smartsocket.helpers'; // classes import { Objectmap } from '@pushrocks/lik'; @@ -21,6 +20,8 @@ export class Smartsocket { public io: SocketIO.Server; public openSockets = new Objectmap(); public socketRoles = new Objectmap(); + public socketFunctions = new Objectmap(); + public socketRequests = new Objectmap(); private socketServer = new SocketServer(this); @@ -74,7 +75,7 @@ export class Smartsocket { targetSocketConnectionArg: SocketConnection ) { const done = plugins.smartpromise.defer(); - const socketRequest = new SocketRequest({ + const socketRequest = new SocketRequest(this, { funcCallData: { funcDataArg: dataArg, funcName: functionNameArg @@ -100,6 +101,10 @@ export class Smartsocket { return; } + public addSocketFunction(socketFunction: SocketFunction) { + this.socketFunctions.add(socketFunction); + } + /** * the standard handler for new socket connections */ diff --git a/ts/smartsocket.classes.smartsocketclient.ts b/ts/smartsocket.classes.smartsocketclient.ts index 38d4932..2a005a7 100644 --- a/ts/smartsocket.classes.smartsocketclient.ts +++ b/ts/smartsocket.classes.smartsocketclient.ts @@ -3,6 +3,7 @@ import * as plugins from './smartsocket.plugins'; import { SocketConnection } from './smartsocket.classes.socketconnection'; import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction'; import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest'; +import { SocketRole } from './smartsocket.classes.socketrole'; /** * interface for class SmartsocketClient @@ -16,12 +17,17 @@ export interface ISmartsocketClientOptions { } export class SmartsocketClient { - alias: string; - role: string; - socketConnection: SocketConnection; - serverUrl: string; - serverPort: number; - serverPassword: string; + public alias: string; + public role: string; + public socketConnection: SocketConnection; + public serverUrl: string; + public serverPort: number; + public serverPassword: string; + + public socketFunctions = new plugins.lik.Objectmap(); + public socketRequests = new plugins.lik.Objectmap(); + public socketRoles = new plugins.lik.Objectmap(); + constructor(optionsArg: ISmartsocketClientOptions) { this.alias = optionsArg.alias; this.role = optionsArg.role; @@ -30,19 +36,23 @@ export class SmartsocketClient { this.serverPassword = optionsArg.password; } + public addSocketFunction(socketFunction: SocketFunction) { + this.socketFunctions.add(socketFunction); + } + /** * connect the client to the server */ - connect() { - let done = plugins.smartpromise.defer(); + public connect() { + const done = plugins.smartpromise.defer(); plugins.smartlog.defaultLogger.log('info', 'trying to connect...'); - let socketUrl = `${this.serverUrl}:${this.serverPort}`; + const socketUrl = `${this.serverUrl}:${this.serverPort}`; this.socketConnection = new SocketConnection({ alias: this.alias, authenticated: false, role: undefined, side: 'client', - smartsocketHost: null, + smartsocketHost: this, socket: plugins.socketIoClient(socketUrl, { multiplex: false }) }); this.socketConnection.socket.on('requestAuth', () => { @@ -62,8 +72,8 @@ export class SmartsocketClient { return done.promise; } - disconnect() { - let done = plugins.smartpromise.defer(); + public disconnect() { + const done = plugins.smartpromise.defer(); this.socketConnection.socket.disconnect(); this.socketConnection = undefined; plugins.smartlog.defaultLogger.log('ok', 'disconnected!'); @@ -71,9 +81,9 @@ export class SmartsocketClient { return done.promise; } - serverCall(functionNameArg: string, dataArg: any) { - let done = plugins.smartpromise.defer(); - let socketRequest = new SocketRequest({ + public serverCall(functionNameArg: string, dataArg: any) { + const done = plugins.smartpromise.defer(); + const socketRequest = new SocketRequest(this, { side: 'requesting', originSocketConnection: this.socketConnection, shortId: plugins.shortid.generate(), @@ -82,8 +92,8 @@ export class SmartsocketClient { funcDataArg: dataArg } }); - socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => { - done.resolve(dataArg.funcDataArg); + socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => { + done.resolve(dataArg2.funcDataArg); }); return done.promise; } diff --git a/ts/smartsocket.classes.socketconnection.ts b/ts/smartsocket.classes.socketconnection.ts index a884bb0..af16bb0 100644 --- a/ts/smartsocket.classes.socketconnection.ts +++ b/ts/smartsocket.classes.socketconnection.ts @@ -1,5 +1,4 @@ import * as plugins from './smartsocket.plugins'; -import * as helpers from './smartsocket.helpers'; import { Objectmap } from '@pushrocks/lik'; @@ -9,12 +8,12 @@ import { SocketFunction } from './smartsocket.classes.socketfunction'; import { SocketRequest, ISocketRequestDataObject, - allSocketRequests } from './smartsocket.classes.socketrequest'; import { SocketRole } from './smartsocket.classes.socketrole'; // socket.io import * as SocketIO from 'socket.io'; +import { SmartsocketClient } from './smartsocket.classes.smartsocketclient'; // export interfaces @@ -31,7 +30,7 @@ export interface ISocketConnectionConstructorOptions { authenticated: boolean; role: SocketRole; side: TSocketConnectionSide; - smartsocketHost: Smartsocket; + smartsocketHost: Smartsocket | SmartsocketClient; socket: SocketIO.Socket | SocketIOClient.Socket; } @@ -55,14 +54,14 @@ export class SocketConnection { public side: TSocketConnectionSide; public authenticated: boolean = false; public role: SocketRole; - public smartsocketHost: Smartsocket; + public smartsocketRef: Smartsocket | SmartsocketClient; public socket: SocketIO.Socket | SocketIOClient.Socket; constructor(optionsArg: ISocketConnectionConstructorOptions) { this.alias = optionsArg.alias; this.authenticated = optionsArg.authenticated; this.role = optionsArg.role; this.side = optionsArg.side; - this.smartsocketHost = optionsArg.smartsocketHost; + this.smartsocketRef = optionsArg.smartsocketHost; this.socket = optionsArg.socket; // standard behaviour that is always true @@ -82,19 +81,19 @@ export class SocketConnection { /** * authenticate the socket */ - authenticate() { - let done = plugins.smartpromise.defer(); + public authenticate() { + const done = plugins.smartpromise.defer(); this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => { plugins.smartlog.defaultLogger.log( 'info', 'received authentication data. now hashing and comparing...' ); this.socket.removeListener('dataAuth', () => {}); - if (helpers.checkPasswordForRole(dataArg, this.smartsocketHost)) { + if (SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) { // TODO: authenticate password this.alias = dataArg.alias; this.authenticated = true; - this.role = helpers.getSocketRoleByName(dataArg.role, this.smartsocketHost); + this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role); this.socket.emit('authenticated'); plugins.smartlog.defaultLogger.log( 'ok', @@ -116,20 +115,20 @@ export class SocketConnection { /** * listen to function requests */ - listenToFunctionRequests() { - let done = plugins.smartpromise.defer(); + public listenToFunctionRequests() { + const done = plugins.smartpromise.defer(); if (this.authenticated) { this.socket.on('function', (dataArg: ISocketRequestDataObject) => { // check if requested function is available to the socket's scope plugins.smartlog.defaultLogger.log('info', 'function request received'); - let referencedFunction: SocketFunction = this.role.allowedFunctions.find( + const referencedFunction: SocketFunction = this.role.allowedFunctions.find( socketFunctionArg => { return socketFunctionArg.name === dataArg.funcCallData.funcName; } ); if (referencedFunction !== undefined) { plugins.smartlog.defaultLogger.log('ok', 'function in access scope'); - let localSocketRequest = new SocketRequest({ + const localSocketRequest = new SocketRequest(this.smartsocketRef, { side: 'responding', originSocketConnection: this, shortId: dataArg.shortId, @@ -148,7 +147,7 @@ export class SocketConnection { 'info', `received response for request with id ${dataArg.shortId}` ); - let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId); + const targetSocketRequest = SocketRequest.getSocketRequestById(this.smartsocketRef, dataArg.shortId); targetSocketRequest.handleResponse(dataArg); }); plugins.smartlog.defaultLogger.log( @@ -157,7 +156,7 @@ export class SocketConnection { ); done.resolve(this); } else { - let errMessage: 'socket needs to be authenticated first'; + const errMessage = 'socket needs to be authenticated first'; plugins.smartlog.defaultLogger.log('error', errMessage); done.reject(errMessage); } diff --git a/ts/smartsocket.classes.socketfunction.ts b/ts/smartsocket.classes.socketfunction.ts index 615c320..00f3698 100644 --- a/ts/smartsocket.classes.socketfunction.ts +++ b/ts/smartsocket.classes.socketfunction.ts @@ -4,6 +4,8 @@ import * as plugins from './smartsocket.plugins'; import { Objectmap } from '@pushrocks/lik'; import { SocketRole } from './smartsocket.classes.socketrole'; import { SocketConnection } from './smartsocket.classes.socketconnection'; +import { Smartsocket } from './smartsocket.classes.smartsocket'; +import { SmartsocketClient } from './smartsocket.classes.smartsocketclient'; // export interfaces @@ -29,18 +31,24 @@ export interface ISocketFunctionCall { */ export type TFuncDef = (dataArg: any, connectionArg: SocketConnection) => PromiseLike; -// export objects -export let allSocketFunctions = new Objectmap(); - // export classes /** * class that respresents a function that can be transparently called using a SocketConnection */ export class SocketFunction { - name: string; - funcDef: TFuncDef; - roles: SocketRole[]; + // STATIC + public static getSocketFunctionByName (smartsocketRefArg: Smartsocket | SmartsocketClient, functionNameArg: string): SocketFunction { + console.log(smartsocketRefArg.socketFunctions); + return smartsocketRefArg.socketFunctions.find(socketFunctionArg => { + return socketFunctionArg.name === functionNameArg; + }); + } + + // INSTANCE + public name: string; + public funcDef: TFuncDef; + public roles: SocketRole[]; /** * the constructor for SocketFunction @@ -49,20 +57,19 @@ export class SocketFunction { this.name = optionsArg.funcName; this.funcDef = optionsArg.funcDef; this.roles = optionsArg.allowedRoles; - for (let socketRoleArg of this.roles) { + for (const socketRoleArg of this.roles) { this._notifyRole(socketRoleArg); } - allSocketFunctions.add(this); // map instance with Objectmap } /** * invokes the function of this SocketFunction */ - invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise { - let done = plugins.smartpromise.defer(); + public invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise { + const done = plugins.smartpromise.defer(); if (dataArg.funcName === this.name) { this.funcDef(dataArg.funcDataArg, socketConnectionArg).then((resultData: any) => { - let funcResponseData: ISocketFunctionCall = { + const funcResponseData: ISocketFunctionCall = { funcName: this.name, funcDataArg: resultData }; diff --git a/ts/smartsocket.classes.socketrequest.ts b/ts/smartsocket.classes.socketrequest.ts index 67b0a07..5514b37 100644 --- a/ts/smartsocket.classes.socketrequest.ts +++ b/ts/smartsocket.classes.socketrequest.ts @@ -1,14 +1,14 @@ import * as plugins from './smartsocket.plugins'; -import * as helpers from './smartsocket.helpers'; // import interfaces -import { ISocketFunctionCall } from './smartsocket.classes.socketfunction'; +import { SocketFunction, ISocketFunctionCall } from './smartsocket.classes.socketfunction'; // import classes import { Objectmap } from '@pushrocks/lik'; -import { SocketFunction } from './smartsocket.classes.socketfunction'; import { SocketConnection } from './smartsocket.classes.socketconnection'; import { defaultLogger } from '@pushrocks/smartlog'; +import { Smartsocket } from './smartsocket.classes.smartsocket'; +import { SmartsocketClient } from './smartsocket.classes.smartsocketclient'; // export interfaces export type TSocketRequestStatus = 'new' | 'pending' | 'finished'; @@ -33,23 +33,36 @@ export interface ISocketRequestDataObject { responseTimeout?: number; } -// export objects -export let allSocketRequests = new Objectmap(); - // export classes export class SocketRequest { + // STATIC + public static getSocketRequestById( + smartsocketRef: Smartsocket | SmartsocketClient, + shortIdArg: string + ): SocketRequest { + return smartsocketRef.socketRequests.find(socketRequestArg => { + return socketRequestArg.shortid === shortIdArg; + }); + } + + // INSTANCE public status: TSocketRequestStatus = 'new'; public side: TSocketRequestSide; public shortid: string; public originSocketConnection: SocketConnection; public funcCallData: ISocketFunctionCall; public done = plugins.smartpromise.defer(); - constructor(optionsArg: SocketRequestConstructorOptions) { + + public smartsocketRef: Smartsocket | SmartsocketClient; + + + constructor(smartsocketRefArg: Smartsocket | SmartsocketClient, optionsArg: SocketRequestConstructorOptions) { + this.smartsocketRef = smartsocketRefArg; this.side = optionsArg.side; this.shortid = optionsArg.shortId; this.funcCallData = optionsArg.funcCallData; this.originSocketConnection = optionsArg.originSocketConnection; - allSocketRequests.add(this); + this.smartsocketRef.socketRequests.add(this); } // requesting -------------------------- @@ -58,7 +71,7 @@ export class SocketRequest { * dispatches a socketrequest from the requesting to the receiving side */ public dispatch() { - let requestData: ISocketRequestDataObject = { + const requestData: ISocketRequestDataObject = { funcCallData: this.funcCallData, shortId: this.shortid }; @@ -72,7 +85,7 @@ export class SocketRequest { public handleResponse(responseDataArg: ISocketRequestDataObject) { plugins.smartlog.defaultLogger.log('info', 'handling response!'); this.done.resolve(responseDataArg.funcCallData); - allSocketRequests.remove(this); + this.smartsocketRef.socketRequests.remove(this); } // responding -------------------------- @@ -81,9 +94,11 @@ export class SocketRequest { * creates the response on the responding side */ public async createResponse(): Promise { - const targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName( + const targetSocketFunction: SocketFunction = SocketFunction.getSocketFunctionByName( + this.smartsocketRef, this.funcCallData.funcName ); + if (!targetSocketFunction) { defaultLogger.log( 'warn', @@ -95,12 +110,12 @@ export class SocketRequest { plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`); targetSocketFunction.invoke(this.funcCallData, this.originSocketConnection).then(resultData => { plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.'); - let requestData: ISocketRequestDataObject = { + const requestData: ISocketRequestDataObject = { funcCallData: resultData, shortId: this.shortid }; this.originSocketConnection.socket.emit('functionResponse', requestData); - allSocketRequests.remove(this); + this.smartsocketRef.socketRequests.remove(this); }); } } diff --git a/ts/smartsocket.classes.socketrole.ts b/ts/smartsocket.classes.socketrole.ts index fa0d48d..9be3ac6 100644 --- a/ts/smartsocket.classes.socketrole.ts +++ b/ts/smartsocket.classes.socketrole.ts @@ -1,8 +1,12 @@ import * as plugins from './smartsocket.plugins'; + // import classes import { Objectmap } from '@pushrocks/lik'; import { SocketFunction } from './smartsocket.classes.socketfunction'; +import { Smartsocket } from './smartsocket.classes.smartsocket'; +import { SmartsocketClient } from './smartsocket.classes.smartsocketclient'; +import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection'; /** * interface for class SocketRole @@ -16,14 +20,34 @@ export interface SocketRoleOptions { * A socketrole defines access to certain routines. */ export class SocketRole { - name: string; - passwordHash: string; - allowedFunctions = new Objectmap(); + // STATIC + public static getSocketRoleByName( + referenceSmartsocket: Smartsocket | SmartsocketClient, + socketRoleNameArg: string, + ): SocketRole{ + return referenceSmartsocket.socketRoles.find(socketRoleArg => { + return socketRoleArg.name === socketRoleNameArg; + }); + } + + public static checkPasswordForRole ( + dataArg: ISocketConnectionAuthenticationObject, + referenceSmartsocket: Smartsocket | SmartsocketClient + ): boolean { + const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role).passwordHash; + const computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password); + return targetPasswordHash === computedCompareHash; + } + + // INSTANCE + public name: string; + public passwordHash: string; + public allowedFunctions = new Objectmap(); constructor(optionsArg: SocketRoleOptions) { this.name = optionsArg.name; this.passwordHash = optionsArg.passwordHash; } - addSocketFunction(socketFunctionArg: SocketFunction) { + public addSocketFunction(socketFunctionArg: SocketFunction) { this.allowedFunctions.add(socketFunctionArg); } } diff --git a/ts/smartsocket.helpers.ts b/ts/smartsocket.helpers.ts deleted file mode 100644 index 534dd0e..0000000 --- a/ts/smartsocket.helpers.ts +++ /dev/null @@ -1,60 +0,0 @@ -import * as plugins from './smartsocket.plugins'; - -// classes -import { Smartsocket } from './smartsocket.classes.smartsocket'; -import { SocketFunction, allSocketFunctions } from './smartsocket.classes.socketfunction'; -import { - SocketConnection, - ISocketConnectionAuthenticationObject -} from './smartsocket.classes.socketconnection'; -import { - SocketRequest, - allSocketRequests, - TSocketRequestSide -} from './smartsocket.classes.socketrequest'; -import { SocketRole } from './smartsocket.classes.socketrole'; - -// SocketConnection helpers -export let checkPasswordForRole = ( - dataArg: ISocketConnectionAuthenticationObject, - referenceSmartsocket: Smartsocket -): boolean => { - let targetPasswordHash = getSocketRoleByName(dataArg.role, referenceSmartsocket).passwordHash; - let computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password); - return targetPasswordHash === computedCompareHash; -}; - -// SocketFunction helpers -export let getSocketFunctionByName = (functionNameArg: string): SocketFunction => { - return allSocketFunctions.find(socketFunctionArg => { - return socketFunctionArg.name === functionNameArg; - }); -}; - -// SocketRequest helpers - -/** - * get corresponding Socketrequest instance by shortId - */ -export let getSocketRequestById = ( - shortIdArg: string, - requestSide?: TSocketRequestSide -): SocketRequest => { - return allSocketRequests.find(socketRequestArg => { - return socketRequestArg.shortid === shortIdArg; - }); -}; - -// SocketRole helpers - -/** - * get corresponding SocketRole instance by name - */ -export let getSocketRoleByName = ( - socketRoleNameArg: string, - referenceSmartsocket: Smartsocket -): SocketRole => { - return referenceSmartsocket.socketRoles.find(socketRoleArg => { - return socketRoleArg.name === socketRoleNameArg; - }); -};