1.1.51

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.41",
+  "version": "1.1.51",
   "description": "easy and secure websocket communication",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,26 +19,27 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.10",
+    "@apiglobal/typedrequest-interfaces": "^1.0.7",
-    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/lik": "^3.0.11",
-    "@pushrocks/smartexpress": "^3.0.38",
+    "@pushrocks/smartdelay": "^2.0.6",
+    "@pushrocks/smartexpress": "^3.0.52",
     "@pushrocks/smarthash": "^2.0.6",
-    "@pushrocks/smartlog": "^2.0.19",
+    "@pushrocks/smartlog": "^2.0.21",
-    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartpromise": "^3.0.6",
     "@types/shortid": "0.0.29",
-    "@types/socket.io": "^2.1.2",
+    "@types/socket.io": "^2.1.4",
     "@types/socket.io-client": "^1.4.32",
-    "shortid": "^2.2.14",
+    "shortid": "^2.2.15",
-    "socket.io": "^2.2.0",
+    "socket.io": "^2.3.0",
-    "socket.io-client": "^2.2.0"
+    "socket.io-client": "^2.3.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsbuild": "^2.1.17",
     "@gitzone/tsrun": "^1.2.8",
-    "@gitzone/tstest": "^1.0.24",
+    "@gitzone/tstest": "^1.0.28",
-    "@pushrocks/tapbundle": "^3.0.11",
+    "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^12.7.1",
+    "@types/node": "^12.12.5",
-    "tslint": "^5.18.0",
+    "tslint": "^5.20.0",
     "tslint-config-prettier": "^1.18.0"
   },
   "private": false,

test/test.expressserver.ts

@@ -11,7 +11,7 @@ import smartsocket = require('../ts/index');
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 
 const testConfig = {
@@ -93,9 +93,7 @@ tap.test('should be able to make a functionCall from client to server', async ()
   console.log(response);
 });
 
-tap.test('should be able to make a functionCall from server to client', async () => {
+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,30 @@ 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<any>;
+let testSocketFunctionClient: smartsocket.SocketFunction<any>;
+
+export interface IReqResClient {
+  method: 'testFunction1';
+  request: {
+    value1: string;
+  };
+  response: {
+    value1: string;
+  };
+}
+
+export interface IReqResServer {
+  method: 'testFunction2';
+  request: {
+    hi: string;
+  };
+  response: {
+    hi: string
+  }
+}
 
 const testConfig = {
   port: 3000
@@ -33,14 +55,23 @@ 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(testSocketFunction1);
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    allowedRoles: [],
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction2'
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
   console.log(testSmartsocket.socketFunctions);
 });
 
@@ -57,33 +88,41 @@ tap.test('should react to a new websocket connection from client', async () => {
     alias: 'testClient1',
     role: 'testRole1'
   });
-  testSmartsocketClient.addSocketFunction(testSocketFunction1);
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
   console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 
-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 () => {
   // TODO: implement parallel test
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  const response = await testSmartsocketClient.serverCall('testFunction1', {
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
     value1: 'hello'
   });
   console.log(response);
+  expect(response.value1).to.equal('hello');
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {
-  const response = await testSmartsocketClient.serverCall('testFunction1', {
+  const response = await testSmartsocket.clientCall<IReqResServer>(
-    hi: 'hi there from client'
+    'testFunction2',
-  });
+    {
+      hi: 'hi there from server'
+    },
+    testSmartsocket.socketConnections.find(socketConnection => {
+      return true;
+    })
+  );
   console.log(response);
+  expect(response.hi).to.equal('hi there from server');
+});
+
+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

@@ -3,7 +3,7 @@ import * as plugins from './smartsocket.plugins';
 // classes
 import { Objectmap } from '@pushrocks/lik';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import { ISocketFunctionCallDataRequest, SocketFunction, ISocketFunctionCallDataResponse } from './smartsocket.classes.socketfunction';
 import { SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketServer } from './smartsocket.classes.socketserver';
@@ -18,10 +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 socketFunctions = new Objectmap<SocketFunction<any>>();
-  public socketRequests = new Objectmap<SocketRequest>();
+  public socketRequests = new Objectmap<SocketRequest<any>>();
 
   private socketServer = new SocketServer(this);
 
@@ -50,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
@@ -69,13 +69,12 @@ export class Smartsocket {
   /**
    * allows call to specific client.
    */
-  public async clientCall(
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
-    functionNameArg: string,
+    functionNameArg: T['method'],
-    dataArg: any,
+    dataArg: T['request'],
     targetSocketConnectionArg: SocketConnection
-  ) {
+  ): Promise<T['response']> {
-    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
-    const socketRequest = new SocketRequest(this, {
       funcCallData: {
         funcDataArg: dataArg,
         funcName: functionNameArg
@@ -84,10 +83,8 @@ export class Smartsocket {
       shortId: plugins.shortid.generate(),
       side: 'requesting'
     });
-    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
-      done.resolve(dataArg2.funcDataArg);
+    const result = response.funcDataArg;
-    });
-    const result = await done.promise;
     return result;
   }
 
@@ -101,14 +98,14 @@ export class Smartsocket {
     return;
   }
 
-  public addSocketFunction(socketFunction: SocketFunction) {
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
     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,
@@ -118,14 +115,8 @@ export class Smartsocket {
       socket: socketArg
     });
     plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
+    this.socketConnections.add(socketConnection);
-    socketConnection
+    await socketConnection.authenticate();
-      .authenticate()
+    await socketConnection.listenToFunctionRequests();
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
-      });
   }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,7 +1,7 @@
 import * as plugins from './smartsocket.plugins';
 
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import { ISocketFunctionCallDataRequest, SocketFunction } from './smartsocket.classes.socketfunction';
 import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 
@@ -18,26 +18,28 @@ export interface ISmartsocketClientOptions {
 
 export class SmartsocketClient {
   public alias: string;
-  public role: string;
+  public socketRole: SocketRole;
   public socketConnection: SocketConnection;
   public serverUrl: string;
   public serverPort: number;
-  public serverPassword: string;
 
-  public socketFunctions = new plugins.lik.Objectmap<SocketFunction>();
+  public socketFunctions = new plugins.lik.Objectmap<SocketFunction<any>>();
-  public socketRequests = new plugins.lik.Objectmap<SocketRequest>();
+  public socketRequests = new plugins.lik.Objectmap<SocketRequest<any>>();
   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) {
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
+    this.socketRole.allowedFunctions.add(socketFunction);
   }
 
   /**
@@ -50,40 +52,63 @@ export class SmartsocketClient {
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: undefined,
+      role: this.socketRole,
       side: 'client',
       smartsocketHost: this,
       socket: plugins.socketIoClient(socketUrl, { multiplex: false })
     });
     this.socketConnection.socket.on('requestAuth', () => {
-      console.log('server requested authentication');
+      plugins.smartlog.defaultLogger.log('info', 'server requested authentication');
       this.socketConnection.socket.emit('dataAuth', {
-        role: this.role,
+        role: this.socketRole.name,
-        password: this.serverPassword,
+        password: this.socketRole.passwordHash,
         alias: this.alias
       });
       this.socketConnection.socket.on('authenticated', () => {
-        console.log('client is authenticated');
+        plugins.smartlog.defaultLogger.log('info', 'client is authenticated');
         this.socketConnection.authenticated = true;
         this.socketConnection.listenToFunctionRequests();
         done.resolve();
       });
+
+      // handle errors
+      this.socketConnection.socket.on('reconnect_failed', async () => {
+        this.disconnect();
+      });
+      this.socketConnection.socket.on('connect_error', async () => {
+        this.disconnect();
+      });
     });
     return done.promise;
   }
 
-  public disconnect() {
+  /**
-    const done = plugins.smartpromise.defer();
+   * disconnect from the server
-    this.socketConnection.socket.disconnect();
+   */
+  public async disconnect() {
+    if (this.socketConnection) {
+      this.socketConnection.socket.disconnect(true);
       this.socketConnection = undefined;
       plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
-    done.resolve();
+    }
-    return done.promise;
   }
 
-  public serverCall(functionNameArg: string, dataArg: any) {
+  /**
+   * try a reconnection
+   */
+  public async tryDebouncedReconnect() {
+    await plugins.smartdelay.delayForRandom(10000, 60000);
+    await this.connect();
+  }
+
+  /**
+   * dispatches a server call
+   * @param functionNameArg 
+   * @param dataArg 
+   */
+  public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(functionNameArg: T['method'], dataArg: T['request']): Promise<T['response']> {
     const done = plugins.smartpromise.defer();
-    const socketRequest = new SocketRequest(this, {
+    const socketRequest = new SocketRequest<T>(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
       shortId: plugins.shortid.generate(),
@@ -92,9 +117,8 @@ export class SmartsocketClient {
         funcDataArg: dataArg
       }
     });
-    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+    const response = await socketRequest.dispatch();
-      done.resolve(dataArg2.funcDataArg);
+    const result = response.funcDataArg;
-    });
+    return result;
-    return done.promise;
   }
 }

ts/smartsocket.classes.socketconnection.ts

@@ -5,10 +5,7 @@ import { Objectmap } from '@pushrocks/lik';
 // import classes
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
-import {
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
-  SocketRequest,
-  ISocketRequestDataObject,
-} from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
@@ -118,15 +115,15 @@ export class SocketConnection {
   public listenToFunctionRequests() {
     const done = plugins.smartpromise.defer();
     if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
         // check if requested function is available to the socket's scope
         plugins.smartlog.defaultLogger.log('info', 'function request received');
-        const referencedFunction: SocketFunction = this.role.allowedFunctions.find(
+        const referencedFunction: SocketFunction<any> = 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');
           const localSocketRequest = new SocketRequest(this.smartsocketRef, {
             side: 'responding',
@@ -142,12 +139,15 @@ export class SocketConnection {
           );
         }
       });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
         plugins.smartlog.defaultLogger.log(
           'info',
           `received response for request with id ${dataArg.shortId}`
         );
-        const targetSocketRequest = SocketRequest.getSocketRequestById(this.smartsocketRef, dataArg.shortId);
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
+          this.smartsocketRef,
+          dataArg.shortId
+        );
         targetSocketRequest.handleResponse(dataArg);
       });
       plugins.smartlog.defaultLogger.log(

ts/smartsocket.classes.socketfunction.ts

@@ -12,34 +12,44 @@ import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 /**
  * interface of the contructor options of class SocketFunction
  */
-export interface ISocketFunctionConstructorOptions {
+export interface ISocketFunctionConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  funcName: string;
+  funcName: T['method'];
-  funcDef: TFuncDef;
+  funcDef: TFuncDef<T>;
   allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
 }
 
 /**
  * interface of the Socket Function call, in other words the object that routes a call to a function
  */
-export interface ISocketFunctionCall {
+export interface ISocketFunctionCallDataRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  funcName: string;
+  funcName: T['method'];
-  funcDataArg: any;
+  funcDataArg: T['request'];
+}
+
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  funcName: T['method'];
+  funcDataArg: T['response'];
 }
 
 /**
  * interface for function definition of SocketFunction
  */
-export type TFuncDef = (dataArg: any, connectionArg: SocketConnection) => PromiseLike<any>;
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (dataArg: T['request'], connectionArg: SocketConnection) => PromiseLike<T['response']>;
 
 // export classes
 
 /**
  * class that respresents a function that can be transparently called using a SocketConnection
  */
-export class SocketFunction {
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   // STATIC
-  public static getSocketFunctionByName (smartsocketRefArg: Smartsocket | SmartsocketClient, functionNameArg: string): SocketFunction {
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
-    console.log(smartsocketRefArg.socketFunctions);
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction<Q> {
     return smartsocketRefArg.socketFunctions.find(socketFunctionArg => {
       return socketFunctionArg.name === functionNameArg;
     });
@@ -47,13 +57,13 @@ export class SocketFunction {
 
   // INSTANCE
   public name: string;
-  public funcDef: TFuncDef;
+  public funcDef: TFuncDef<T>;
   public roles: SocketRole[];
 
   /**
    * the constructor for SocketFunction
    */
-  constructor(optionsArg: ISocketFunctionConstructorOptions) {
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
     this.name = optionsArg.funcName;
     this.funcDef = optionsArg.funcDef;
     this.roles = optionsArg.allowedRoles;
@@ -65,20 +75,16 @@ export class SocketFunction {
   /**
    * invokes the function of this SocketFunction
    */
-  public invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise<any> {
+  public async invoke(dataArg: ISocketFunctionCallDataRequest<T>, socketConnectionArg: SocketConnection): Promise<ISocketFunctionCallDataResponse<T>> {
-    const done = plugins.smartpromise.defer();
     if (dataArg.funcName === this.name) {
-      this.funcDef(dataArg.funcDataArg, socketConnectionArg).then((resultData: any) => {
+      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
-        const funcResponseData: ISocketFunctionCall = {
         funcName: this.name,
-          funcDataArg: resultData
+        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg)
       };
-        done.resolve(funcResponseData);
+      return funcResponseData;
-      });
     } else {
       throw new Error("SocketFunction.name does not match the data argument's .name!");
     }
-    return done.promise;
   }
 
   /**

ts/smartsocket.classes.socketrequest.ts

@@ -1,7 +1,7 @@
 import * as plugins from './smartsocket.plugins';
 
 // import interfaces
-import { SocketFunction, ISocketFunctionCall } from './smartsocket.classes.socketfunction';
+import { SocketFunction, ISocketFunctionCallDataRequest, ISocketFunctionCallDataResponse } from './smartsocket.classes.socketfunction';
 
 // import classes
 import { Objectmap } from '@pushrocks/lik';
@@ -17,29 +17,29 @@ export type TSocketRequestSide = 'requesting' | 'responding';
 /**
  * interface of constructor of class SocketRequest
  */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   side: TSocketRequestSide;
   originSocketConnection: SocketConnection;
   shortId: string;
-  funcCallData?: ISocketFunctionCall;
+  funcCallData?: ISocketFunctionCallDataRequest<T>;
 }
 
 /**
  * request object that is sent initially and may or may not receive a response
  */
-export interface ISocketRequestDataObject {
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  funcCallData: ISocketFunctionCall;
+  funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
   shortId: string;
   responseTimeout?: number;
 }
 
 // export classes
-export class SocketRequest {
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   // STATIC
   public static getSocketRequestById(
     smartsocketRef: Smartsocket | SmartsocketClient,
     shortIdArg: string
-  ): SocketRequest {
+  ): SocketRequest<any> {
     return smartsocketRef.socketRequests.find(socketRequestArg => {
       return socketRequestArg.shortid === shortIdArg;
     });
@@ -50,13 +50,15 @@ export class SocketRequest {
   public side: TSocketRequestSide;
   public shortid: string;
   public originSocketConnection: SocketConnection;
-  public funcCallData: ISocketFunctionCall;
+  public funcCallData: ISocketFunctionCallDataRequest<T>;
-  public done = plugins.smartpromise.defer();
+  public done = plugins.smartpromise.defer<ISocketFunctionCallDataResponse<T>>();
 
   public smartsocketRef: Smartsocket | SmartsocketClient;
 
-
+  constructor(
-  constructor(smartsocketRefArg: Smartsocket | SmartsocketClient, optionsArg: SocketRequestConstructorOptions) {
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: ISocketRequestConstructorOptions<T>
+  ) {
     this.smartsocketRef = smartsocketRefArg;
     this.side = optionsArg.side;
     this.shortid = optionsArg.shortId;
@@ -70,8 +72,8 @@ export class SocketRequest {
   /**
    * dispatches a socketrequest from the requesting to the receiving side
    */
-  public dispatch() {
+  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
-    const requestData: ISocketRequestDataObject = {
+    const requestData: ISocketRequestDataObject<T> = {
       funcCallData: this.funcCallData,
       shortId: this.shortid
     };
@@ -82,7 +84,7 @@ export class SocketRequest {
   /**
    * handles the response that is received by the requesting side
    */
-  public handleResponse(responseDataArg: ISocketRequestDataObject) {
+  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
     plugins.smartlog.defaultLogger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
     this.smartsocketRef.socketRequests.remove(this);
@@ -94,7 +96,7 @@ export class SocketRequest {
    * creates the response on the responding side
    */
   public async createResponse(): Promise<void> {
-    const targetSocketFunction: SocketFunction = SocketFunction.getSocketFunctionByName(
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
       this.smartsocketRef,
       this.funcCallData.funcName
     );
@@ -110,11 +112,11 @@ 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.');
-      const requestData: ISocketRequestDataObject = {
+      const responseData: ISocketRequestDataObject<T> = {
         funcCallData: resultData,
         shortId: this.shortid
       };
-      this.originSocketConnection.socket.emit('functionResponse', requestData);
+      this.originSocketConnection.socket.emit('functionResponse', responseData);
       this.smartsocketRef.socketRequests.remove(this);
     });
   }

ts/smartsocket.classes.socketrole.ts

@@ -1,6 +1,5 @@
 import * as plugins from './smartsocket.plugins';
 
-
 // import classes
 import { Objectmap } from '@pushrocks/lik';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
@@ -11,7 +10,7 @@ import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.soc
 /**
  * interface for class SocketRole
  */
-export interface SocketRoleOptions {
+export interface ISocketRoleOptions {
   name: string;
   passwordHash: string;
 }
@@ -23,7 +22,7 @@ export class SocketRole {
   // STATIC
   public static getSocketRoleByName(
     referenceSmartsocket: Smartsocket | SmartsocketClient,
-    socketRoleNameArg: string,
+    socketRoleNameArg: string
   ): SocketRole {
     return referenceSmartsocket.socketRoles.find(socketRoleArg => {
       return socketRoleArg.name === socketRoleNameArg;
@@ -34,7 +33,8 @@ export class SocketRole {
     dataArg: ISocketConnectionAuthenticationObject,
     referenceSmartsocket: Smartsocket | SmartsocketClient
   ): boolean {
-    const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role).passwordHash;
+    const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role)
+      .passwordHash;
     const computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password);
     return targetPasswordHash === computedCompareHash;
   }
@@ -42,12 +42,17 @@ export class SocketRole {
   // INSTANCE
   public name: string;
   public passwordHash: string;
-  public allowedFunctions = new Objectmap<SocketFunction>();
+  public allowedFunctions = new Objectmap<SocketFunction<any>>();
-  constructor(optionsArg: SocketRoleOptions) {
+  constructor(optionsArg: ISocketRoleOptions) {
     this.name = optionsArg.name;
     this.passwordHash = optionsArg.passwordHash;
   }
-  public addSocketFunction(socketFunctionArg: SocketFunction) {
+
+  /**
+   * adds the socketfunction to the socketrole
+   * @param socketFunctionArg
+   */
+  public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
     this.allowedFunctions.add(socketFunctionArg);
   }
 }

ts/smartsocket.classes.socketserver.ts

@@ -2,6 +2,7 @@ import * as plugins from './smartsocket.plugins';
 
 // used in case no other server is supplied
 import * as http from 'http';
+import * as https from 'https';
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 
 /**
@@ -10,7 +11,7 @@ import { Smartsocket } from './smartsocket.classes.smartsocket';
  */
 export class SocketServer {
   private smartsocket: Smartsocket;
-  private httpServer: http.Server;
+  private httpServer: http.Server | https.Server;
   // wether httpServer is standalone
   private standaloneServer = false;
   private expressServer: any;
@@ -54,11 +55,11 @@ export class SocketServer {
     // in case an external server has been set "this.standaloneServer" should be false
     if (this.httpServer && this.standaloneServer) {
       if (!this.smartsocket.options.port) {
-        console.log('there should be a port specifed for smartsocket!');
+        plugins.smartlog.defaultLogger.log('error', 'there should be a port specifed for smartsocket!');
         throw new Error('there should be a port specified for smartsocket');
       }
       this.httpServer.listen(this.smartsocket.options.port, () => {
-        console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
+        plugins.smartlog.defaultLogger.log('success', `Server started in standalone mode on ${this.smartsocket.options.port}`);
         done.resolve();
       });
     } else {

ts/smartsocket.plugins.ts

@@ -1,12 +1,16 @@
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+
+export {typedrequestInterfaces};
+
+// pushrocks scope
 import * as lik from '@pushrocks/lik';
 import * as smartlog from '@pushrocks/smartlog';
 import * as smarthash from '@pushrocks/smarthash';
 import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartexpress from '@pushrocks/smartexpress';
 import * as smartpromise from '@pushrocks/smartpromise';
-import * as shortid from 'shortid';
+
-import socketIo from 'socket.io';
-import socketIoClient from 'socket.io-client';
 
 export {
   lik,
@@ -14,7 +18,15 @@ export {
   smarthash,
   smartdelay,
   smartexpress,
-  smartpromise,
+  smartpromise
+};
+
+// third party scope
+import * as shortid from 'shortid';
+import socketIo from 'socket.io';
+import socketIoClient from 'socket.io-client';
+
+export {
   shortid,
   socketIo,
   socketIoClient