1.1.44

.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"
+    }
+  ]
+}

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.39",
+  "version": "1.1.44",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.39",
+  "version": "1.1.44",
   "description": "easy and secure websocket communication",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

test/common/test.ts

@@ -0,0 +1 @@
+console.log('TODO');

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,38 +87,13 @@ 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', {
+  const response = await testSmartsocketClient.serverCall('testFunction1', {
     value1: 'hello'
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
   });
-  await done.promise;
+  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();
-    });
-});
+tap.test('should be able to make a functionCall from server to client', async () => {});
 
 // terminate
 tap.test('should close the server', async () => {

test/test.ts

@@ -9,8 +9,10 @@ import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketConnection: smartsocket.SocketConnection;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSocketFunctionForServer: smartsocket.SocketFunction;
+let testSocketFunctionClient: smartsocket.SocketFunction;
 
 const testConfig = {
   port: 3000
@@ -22,10 +24,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({
@@ -37,18 +35,32 @@ tap.test('should add a socketrole', async () => {
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
     allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
     funcName: 'testFunction1'
   });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    allowedRoles: [],
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1'
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+  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 +68,9 @@ tap.test('should react to a new websocket connection from client', async () => {
     alias: 'testClient1',
     role: 'testRole1'
   });
-  testSmartsocketClient.connect().then(() => {
-    done.resolve();
-  });
-  await done.promise;
-});
-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;
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
+  console.log(testSmartsocketClient.socketFunctions);
+  await testSmartsocketClient.connect();
 });
 
 tap.test('2 clients should connect in parallel', async () => {
@@ -83,37 +78,29 @@ 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', {
+  const response = await testSmartsocketClient.serverCall('testFunction1', {
     value1: 'hello'
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
   });
-  await done.promise;
+  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(
+  const response = await testSmartsocket.clientCall(
     'testFunction1',
     {
-        value1: 'helloFromServer'
+      hi: 'hi there from server'
     },
-      targetSocket
-    )
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
+    testSmartsocket.socketConnections.find(socketConnection => {
+      return true;
+    })
+  );
+  console.log(response);
+});
+
+tap.test('client should disconnect and reconnect', async tools => {
+  await testSmartsocketClient.disconnect();
+  await tools.delayFor(100);
+  await testSmartsocketClient.connect();
 });
 
 // terminate

ts/index.ts

@@ -1,5 +1,3 @@
-import * as plugins from './smartsocket.plugins';
-
 // export main classes
 export * from './smartsocket.classes.smartsocket';
 export * from './smartsocket.classes.smartsocketclient';

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';
@@ -19,8 +18,10 @@ export interface ISmartsocketConstructorOptions {
 export class Smartsocket {
   public options: ISmartsocketConstructorOptions;
   public io: SocketIO.Server;
-  public openSockets = new Objectmap<SocketConnection>();
+  public socketConnections = new Objectmap<SocketConnection>();
   public socketRoles = new Objectmap<SocketRole>();
+  public socketFunctions = new Objectmap<SocketFunction>();
+  public socketRequests = new Objectmap<SocketRequest>();
 
   private socketServer = new SocketServer(this);
 
@@ -49,14 +50,14 @@ export class Smartsocket {
    */
   public async stop() {
     await plugins.smartdelay.delayFor(1000);
-    this.openSockets.forEach((socketObjectArg: SocketConnection) => {
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
       plugins.smartlog.defaultLogger.log(
         'info',
         `disconnect socket with >>alias ${socketObjectArg.alias}`
       );
       socketObjectArg.socket.disconnect();
     });
-    this.openSockets.wipe();
+    this.socketConnections.wipe();
     this.io.close();
 
     // stop the corresponging server
@@ -73,8 +74,7 @@ export class Smartsocket {
     dataArg: any,
     targetSocketConnectionArg: SocketConnection
   ) {
-    const done = plugins.smartpromise.defer();
-    const socketRequest = new SocketRequest({
+    const socketRequest = new SocketRequest(this, {
       funcCallData: {
         funcDataArg: dataArg,
         funcName: functionNameArg
@@ -83,10 +83,8 @@ export class Smartsocket {
       shortId: plugins.shortid.generate(),
       side: 'requesting'
     });
-    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
-      done.resolve(dataArg2.funcDataArg);
-    });
-    const result = await done.promise;
+    const response: ISocketFunctionCall = await socketRequest.dispatch();
+    const result = response.funcDataArg;
     return result;
   }
 
@@ -100,10 +98,14 @@ export class Smartsocket {
     return;
   }
 
+  public addSocketFunction(socketFunction: SocketFunction) {
+    this.socketFunctions.add(socketFunction);
+  }
+
   /**
    * the standard handler for new socket connections
    */
-  private _handleSocketConnection(socketArg) {
+  private async _handleSocketConnection(socketArg: plugins.socketIo.Socket) {
     const socketConnection: SocketConnection = new SocketConnection({
       alias: undefined,
       authenticated: false,
@@ -113,14 +115,8 @@ export class Smartsocket {
       socket: socketArg
     });
     plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
-    socketConnection
-      .authenticate()
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
-      });
+    this.socketConnections.add(socketConnection);
+    await socketConnection.authenticate();
+    await socketConnection.listenToFunctionRequests();
   }
 }

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,40 +17,51 @@ export interface ISmartsocketClientOptions {
 }
 
 export class SmartsocketClient {
-  alias: string;
-  role: string;
-  socketConnection: SocketConnection;
-  serverUrl: string;
-  serverPort: number;
-  serverPassword: string;
+  public alias: string;
+  public socketRole: SocketRole;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+
+  public socketFunctions = new plugins.lik.Objectmap<SocketFunction>();
+  public socketRequests = new plugins.lik.Objectmap<SocketRequest>();
+  public socketRoles = new plugins.lik.Objectmap<SocketRole>();
+
   constructor(optionsArg: ISmartsocketClientOptions) {
     this.alias = optionsArg.alias;
-    this.role = optionsArg.role;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.serverPassword = optionsArg.password;
+    this.socketRole = new SocketRole({
+      name: optionsArg.role,
+      passwordHash: optionsArg.password
+    });
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction) {
+    this.socketFunctions.add(socketFunction);
+    this.socketRole.allowedFunctions.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,
+      role: this.socketRole,
       side: 'client',
-      smartsocketHost: null,
+      smartsocketHost: this,
       socket: plugins.socketIoClient(socketUrl, { multiplex: false })
     });
     this.socketConnection.socket.on('requestAuth', () => {
       console.log('server requested authentication');
       this.socketConnection.socket.emit('dataAuth', {
-        role: this.role,
-        password: this.serverPassword,
+        role: this.socketRole.name,
+        password: this.socketRole.passwordHash,
         alias: this.alias
       });
       this.socketConnection.socket.on('authenticated', () => {
@@ -62,18 +74,23 @@ export class SmartsocketClient {
     return done.promise;
   }
 
-  disconnect() {
-    let done = plugins.smartpromise.defer();
-    this.socketConnection.socket.disconnect();
+  /**
+   * disconnect from the server
+   */
+  public async disconnect() {
+    this.socketConnection.socket.disconnect(true);
     this.socketConnection = undefined;
     plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
-    done.resolve();
-    return done.promise;
   }
 
-  serverCall(functionNameArg: string, dataArg: any) {
-    let done = plugins.smartpromise.defer();
-    let socketRequest = new SocketRequest({
+  /**
+   * dispatches a server call
+   * @param functionNameArg 
+   * @param dataArg 
+   */
+  public async serverCall(functionNameArg: string, dataArg: any): Promise<any> {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
       shortId: plugins.shortid.generate(),
@@ -82,9 +99,8 @@ export class SmartsocketClient {
         funcDataArg: dataArg
       }
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
-      done.resolve(dataArg.funcDataArg);
-    });
-    return done.promise;
+    const response = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
   }
 }

ts/smartsocket.classes.socketconnection.ts

@@ -1,20 +1,16 @@
 import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
 
 import { Objectmap } from '@pushrocks/lik';
 
 // import classes
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
-import {
-  SocketRequest,
-  ISocketRequestDataObject,
-  allSocketRequests
-} from './smartsocket.classes.socketrequest';
+import { SocketRequest, ISocketRequestDataObject } 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 +27,7 @@ export interface ISocketConnectionConstructorOptions {
   authenticated: boolean;
   role: SocketRole;
   side: TSocketConnectionSide;
-  smartsocketHost: Smartsocket;
+  smartsocketHost: Smartsocket | SmartsocketClient;
   socket: SocketIO.Socket | SocketIOClient.Socket;
 }
 
@@ -55,14 +51,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 +78,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 +112,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) {
+        if (referencedFunction) {
           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 +144,10 @@ 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);
     }

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,27 @@ export interface ISocketFunctionCall {
  */
 export type TFuncDef = (dataArg: any, connectionArg: SocketConnection) => PromiseLike<any>;
 
-// export objects
-export let allSocketFunctions = new Objectmap<SocketFunction>();
-
 // 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 +60,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<any> {
-    let done = plugins.smartpromise.defer();
+  public invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise<any> {
+    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
         };

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';
@@ -17,7 +17,7 @@ export type TSocketRequestSide = 'requesting' | 'responding';
 /**
  * interface of constructor of class SocketRequest
  */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions {
   side: TSocketRequestSide;
   originSocketConnection: SocketConnection;
   shortId: string;
@@ -33,23 +33,38 @@ export interface ISocketRequestDataObject {
   responseTimeout?: number;
 }
 
-// export objects
-export let allSocketRequests = new Objectmap<SocketRequest>();
-
 // 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 done = plugins.smartpromise.defer<ISocketFunctionCall>();
+
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+
+  constructor(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: ISocketRequestConstructorOptions
+  ) {
+    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 --------------------------
@@ -57,8 +72,8 @@ export class SocketRequest {
   /**
    * dispatches a socketrequest from the requesting to the receiving side
    */
-  public dispatch() {
-    let requestData: ISocketRequestDataObject = {
+  public dispatch(): Promise<ISocketFunctionCall> {
+    const requestData: ISocketRequestDataObject = {
       funcCallData: this.funcCallData,
       shortId: this.shortid
     };
@@ -72,7 +87,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 +96,11 @@ export class SocketRequest {
    * creates the response on the responding side
    */
   public async createResponse(): Promise<void> {
-    const targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(
+    const targetSocketFunction: SocketFunction = SocketFunction.getSocketFunctionByName(
+      this.smartsocketRef,
       this.funcCallData.funcName
     );
+
     if (!targetSocketFunction) {
       defaultLogger.log(
         'warn',
@@ -95,12 +112,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);
     });
   }
 }

ts/smartsocket.classes.socketrole.ts

@@ -3,11 +3,14 @@ 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
  */
-export interface SocketRoleOptions {
+export interface ISocketRoleOptions {
   name: string;
   passwordHash: string;
 }
@@ -16,14 +19,40 @@ export interface SocketRoleOptions {
  * A socketrole defines access to certain routines.
  */
 export class SocketRole {
-  name: string;
-  passwordHash: string;
-  allowedFunctions = new Objectmap<SocketFunction>();
-  constructor(optionsArg: SocketRoleOptions) {
+  // 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<SocketFunction>();
+  constructor(optionsArg: ISocketRoleOptions) {
     this.name = optionsArg.name;
     this.passwordHash = optionsArg.passwordHash;
   }
-  addSocketFunction(socketFunctionArg: SocketFunction) {
+
+  /**
+   * adds the socketfunction to the socketrole
+   * @param socketFunctionArg
+   */
+  public addSocketFunction(socketFunctionArg: SocketFunction) {
     this.allowedFunctions.add(socketFunctionArg);
   }
 }

ts/smartsocket.helpers.ts

@@ -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;
-  });
-};