1.1.62

fix(core): update
1.1.61
2020-09-29 17:21:08 +00:00 · 2020-09-29 17:21:08 +00:00 · 2020-09-29 08:35:27 +00:00 · 2020-09-29 08:35:26 +00:00 · 2020-09-24 18:04:12 +00:00 · 2020-09-24 18:04:11 +00:00
48 changed files with 12734 additions and 1462 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,20 @@
-node_modules/
+.nogit/
 # artifacts
 coverage/
-docs/
+public/
 pages/
 # installs
 node_modules/
 # caches
 .yarn/
 .cache/
 .rpt2_cache
 # builds
 dist/
 dist_*/
 # custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,36 +1,137 @@
-image: hosttoday/ht-docker-node:npmts
+# gitzone ci_default
 image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 cache:
  paths:
    - .npmci_cache/
  key: '$CI_BUILD_STAGE'
 stages:
- test
+  - security
- release
+  - test
  - release
  - metadata
-testLEGACY:
+# ====================
-  stage: test
+# security stage
 # ====================
 mirror:
  stage: security
  script:
-    - npmci test legacy
+    - npmci git mirror
  only:
    - tags
  tags:
    - lossless
    - docker
    - notpriv
 auditProductionDependencies:
  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
  stage: security
  script:
    - npmci npm prepare
    - npmci command npm install --production --ignore-scripts
    - npmci command npm config set registry https://registry.npmjs.org
    - npmci command npm audit --audit-level=high --only=prod --production
  tags:
    - docker
-testLTS:
+auditDevDependencies:
-  stage: test
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
  stage: security
  script:
-    - npmci test lts
+    - npmci npm prepare
    - npmci command npm install --ignore-scripts
    - npmci command npm config set registry https://registry.npmjs.org
    - npmci command npm audit --audit-level=high --only=dev
  tags:
    - docker
-    
+  allow_failure: true
-testSTABLE:
+
 # ====================
 # test stage
 # ====================
 testStable:
  stage: test
  script:
-    - npmci test stable
+    - npmci npm prepare
    - npmci node install stable
    - npmci npm install
    - npmci npm test
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
    - docker
 testBuild:
  stage: test
  script:
    - npmci npm prepare
    - npmci node install stable
    - npmci npm install
    - npmci command npm run build
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
    - docker
 release:
  stage: release
  environment: npmjs-com_registry
  script:
-    - npmci publish
+    - npmci node install stable
    - npmci npm publish
  only:
    - tags
  tags:
    - lossless
    - docker
    - notpriv
 # ====================
 # metadata stage
 # ====================
 codequality:
  stage: metadata
  allow_failure: true
  only:
    - tags
  script:
    - npmci command npm install -g tslint typescript
    - npmci npm prepare
    - npmci npm install
    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
  tags:
    - lossless
    - docker
    - priv
 trigger:
  stage: metadata
  script:
    - npmci trigger
  only:
    - tags
  tags:
    - lossless
    - docker
    - notpriv
 pages:
  stage: metadata
  script:
    - npmci node install lts
    - npmci command npm install -g @gitzone/tsdoc
    - npmci npm prepare
    - npmci npm install
    - npmci command tsdoc
  tags:
    - lossless
    - docker
    - notpriv
  only:
    - tags
  artifacts:
    expire_in: 1 week
    paths:
      - public
  allow_failure: true
--- a/.snyk
+++ b/.snyk
@ -0,0 +1,13 @@
 # Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
 version: v1.13.5
 # ignores vulnerabilities until expiry date; change duration by modifying expiry date
 ignore:
  SNYK-JS-JSYAML-173999:
    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
        reason: None given
        expires: '2019-05-24T15:16:11.291Z'
  SNYK-JS-JSYAML-174129:
    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
        reason: None given
        expires: '2019-05-24T15:16:11.291Z'
 patch: {}
--- a/.vscode/launch.json
+++ 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"
    }
  ]
 }
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,26 @@
 {
  "json.schemas": [
    {
      "fileMatch": ["/npmextra.json"],
      "schema": {
        "type": "object",
        "properties": {
          "npmci": {
            "type": "object",
            "description": "settings for npmci"
          },
          "gitzone": {
            "type": "object",
            "description": "settings for gitzone",
            "properties": {
              "projectType": {
                "type": "string",
                "enum": ["website", "element", "service", "npm", "wcc"]
              }
            }
          }
        }
      }
    }
  ]
 }
--- a/README.md
+++ b/README.md
@ -1,76 +1,111 @@
-# smartsocket
+# @pushrocks/smartsocket
-easy and secure websocket communication, Typescript ready
+easy and secure websocket communication
-## Status
+## Availabililty and Links
 * [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartsocket)
 * [gitlab.com (source)](https://gitlab.com/pushrocks/smartsocket)
 * [github.com (source mirror)](https://github.com/pushrocks/smartsocket)
 * [docs (typedoc)](https://pushrocks.gitlab.io/smartsocket/)
 ## Status for master
 [![build status](https://gitlab.com/pushrocks/smartsocket/badges/master/build.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
 [![coverage report](https://gitlab.com/pushrocks/smartsocket/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
 [![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartsocket.svg)](https://www.npmjs.com/package/@pushrocks/smartsocket)
 [![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartsocket/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartsocket)
 [![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
 [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
 [![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
 ## Usage
-We recommend the use of typescript.
+
 Use TypeScript for best in class instellisense.
 Under the hood we use socket.io and shortid for managed data exchange.
 ### Serverside
 ```typescript
-import * as smartsocket from "smartsocket";
+import * as smartsocket from 'smartsocket';
 import * as q from q; // q is a promise library
 // The "Smartsocket" listens on a port and can receive new "SocketConnection" requests.
 let mySmartsocket = new smartsocket.Smartsocket({
-    port: 3000 // the port smartsocket will listen on
+  port: 3000 // the port smartsocket will listen on
 });
 // optional:
 // run this with anothoer existing server like express
 declare var someExpressServer; // read the express docs about how express actually works
 mySmartsocket.setServer(someExpressServer);
 // A "SocketRole" can be referenced by "SocketFunction"s.
 // All "SocketRequest"s carry authentication data for a specific "SocketRole".
 // "SocketFunction"s know which "SocketRole"s are allowed to execute them
 let mySocketRole = new smartsocket.SocketRole({
-    name: "someRoleName",
+  name: 'someRoleName',
-    passwordHash: "someHashedString"
+  passwordHash: 'someHashedString'
 });
 // A "SocketFunction" executes a referenced function and passes in any data of the corresponding "SocketRequest".
 // The referenced function must return a promise and resolve with data of type any.
 // Any "SocketRequest" carries a unique identifier. If the referenced function's promise resolved any passed on argument will be returned to the requesting party
 let testSocketFunction1 = new smartsocket.SocketFunction({
-    funcName:"testSocketFunction1",
+  funcName: 'testSocketFunction1',
-    funcDef:(data) => {
+  funcDef: data => {
-        
+    console.log('testSocketFunction1 executed successfully!');
-    }, // the function to execute
+  },
-    allowedRoles:[mySocketRole] // all roles that have access to a specific function
+  allowedRoles: [mySocketRole] // all roles that have access to a specific function
 });
-mySmartsocket.clientCall("","restart",data,someTargetConnection)
+// A "Smartsocket" exposes a .clientCall() that gets
-    .then((responseData) => {
+// 1. the name of the "SocketFunction" on the client side
-
+// 2. the data to pass in
-    });
+// 3. And a target "SocketConnection" (there can be multiple connections at once)
 // any unique id association is done internally
 mySmartsocket.clientCall('restart', data, someTargetConnection).then(responseData => {});
 ```
 #### Client side
 ```typescript
-import * as smartsocket from "smartsocket";
+import * as smartsocket from 'smartsocket';
 // A "SmartsocketClient" is different from a "Smartsocket" in that it doesn't expose any public address.
 // Thus any new "SocketConnection"s must be innitiated from a "SmartsocketClient".
 let testSmartsocketClient = new smartsocket.SmartsocketClient({
-    port: testConfig.port,
+  port: testConfig.port,
-    url: "http://localhost",
+  url: 'http://localhost',
-    password: "testPassword",
+  password: 'testPassword',
-    alias: "testClient1",
+  alias: 'testClient1',
-    role: "testRole1"
+  role: 'testRole1'
 });
 testSmartsocketClient.connect()
    .then(() => {
        done();
    });
 // You can .connect() and .disconnect() from a "Smartsocket"
 testSmartsocketClient.connect().then(() => {
  done();
 });
 // The client can also specify "SocketFunction"s. It can also specify "SocketRole"s in case a client connects to multiple servers at once
 let testSocketFunction2 = new smartsocket.SocketFunction({
-    funcName: "testSocketFunction2",
+  funcName: 'testSocketFunction2',
-    funcDef: (data) => {}, // the function to execute, has to return promise
+  funcDef: data => {}, // the function to execute, has to return promise
-    allowedRoles:[]
+  allowedRoles: []
 });
-let functionCalldata = {
+// A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
-    funcName: "",
+mySmartsocketClient.serverCall('function', functionCallData).then(functionResponseData => {
-    funcData: {
+  // the functionResponseData comes from the server... awesome, right?
-        someKey:"someValue"
+});
    }
 }
 mySmartsocketClient.serverCall("function",functionCallData)
    .then((functionResponseData) => { // the functionResponseData comes from the server... awesome, right?
    });;
 ```
 > **NOTE:**  
-you can easily chain dependent requests on either the server or client side with promises.  
+> you can easily chain dependent requests on either the server or client side with promises.  
-`data` is always a js object that you can design for your specific needs.  
+> `data` is always a js object that you can design for your specific needs.  
-It supports buffers for large binary data network exchange.  
+> It supports buffers for large binary data network exchange.
 For further information read the linked docs at the top of this readme.
 > MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
 | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
 [![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
--- a/dist/index.d.ts
+++ b/dist/index.d.ts
@ -1,5 +0,0 @@
 export * from "./smartsocket.classes.smartsocket";
 export * from "./smartsocket.classes.smartsocketclient";
 export * from "./smartsocket.classes.socketfunction";
 export * from "./smartsocket.classes.socketrole";
 export { allSocketConnections } from "./smartsocket.classes.socketconnection";
--- a/dist/index.js
+++ b/dist/index.js
@ -1,14 +0,0 @@
 "use strict";
 function __export(m) {
    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 // export main classes
 __export(require("./smartsocket.classes.smartsocket"));
 __export(require("./smartsocket.classes.smartsocketclient"));
 // export further classes and objects
 __export(require("./smartsocket.classes.socketfunction"));
 __export(require("./smartsocket.classes.socketrole"));
 var smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
 exports.allSocketConnections = smartsocket_classes_socketconnection_1.allSocketConnections;
 // need something more exposed? Create an issue on GitLab!
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsc0JBQXNCO0FBQ3RCLGlCQUFjLG1DQUFtQyxDQUFDLEVBQUE7QUFDbEQsaUJBQWMseUNBQXlDLENBQUMsRUFBQTtBQUV4RCxxQ0FBcUM7QUFDckMsaUJBQWMsc0NBQXNDLENBQUMsRUFBQTtBQUNyRCxpQkFBYyxrQ0FBa0MsQ0FBQyxFQUFBO0FBQ2pELHFEQUFtQyx3Q0FBd0MsQ0FBQztBQUFwRSwyRkFBb0U7QUFFNUUsMERBQTBEIn0=
--- a/dist/smartsocket.classes.smartsocket.d.ts
+++ b/dist/smartsocket.classes.smartsocket.d.ts
@ -1,27 +0,0 @@
 /// <reference types="socket.io" />
 /// <reference types="q" />
 import * as plugins from "./smartsocket.plugins";
 import { Objectmap } from "lik";
 import { SocketConnection } from "./smartsocket.classes.socketconnection";
 export interface ISmartsocketConstructorOptions {
    port: number;
 }
 export declare class Smartsocket {
    options: ISmartsocketConstructorOptions;
    io: SocketIO.Server;
    openSockets: Objectmap<SocketConnection>;
    constructor(optionsArg: ISmartsocketConstructorOptions);
    /**
     * the standard handler for new socket connections
     */
    private _handleSocketConnection(socketArg);
    /**
     * starts listening to incling sockets:
     */
    startServer: () => void;
    closeServer: () => void;
    /**
     * allows call to specific client.
     */
    clientCall(functionNameArg: string, dataArg: any, targetSocketConnectionArg: SocketConnection): plugins.q.Promise<{}>;
 }
--- a/dist/smartsocket.classes.smartsocket.js
+++ b/dist/smartsocket.classes.smartsocket.js
@ -1,76 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 // classes
 const lik_1 = require("lik");
 const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
 const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
 ;
 class Smartsocket {
    constructor(optionsArg) {
        this.openSockets = new lik_1.Objectmap();
        /**
         * starts listening to incling sockets:
         */
        this.startServer = () => {
            this.io = plugins.socketIo(this.options.port);
            this.io.on("connection", (socketArg) => {
                this._handleSocketConnection(socketArg);
            });
        };
        this.closeServer = () => {
            this.openSockets.forEach((socketObjectArg) => {
                plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
                socketObjectArg.socket.disconnect();
            });
            this.openSockets.wipe();
            this.io.close();
        };
        this.options = optionsArg;
    }
    ;
    /**
     * the standard handler for new socket connections
     */
    _handleSocketConnection(socketArg) {
        let socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
            alias: undefined,
            authenticated: false,
            role: undefined,
            side: "server",
            socket: socketArg
        });
        plugins.beautylog.log("Socket connected. Trying to authenticate...");
        this.openSockets.add(socketConnection);
        socketConnection.authenticate()
            .then(() => {
            return socketConnection.listenToFunctionRequests();
        })
            .catch((err) => {
            console.log(err);
        });
    }
    ;
    // communication
    /**
     * allows call to specific client.
     */
    clientCall(functionNameArg, dataArg, targetSocketConnectionArg) {
        let done = plugins.q.defer();
        let socketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
            side: "requesting",
            originSocketConnection: targetSocketConnectionArg,
            shortId: plugins.shortid.generate(),
            funcCallData: {
                funcName: functionNameArg,
                funcDataArg: dataArg
            }
        });
        socketRequest.dispatch()
            .then((dataArg) => {
            done.resolve(dataArg.funcDataArg);
        });
        return done.promise;
    }
 }
 exports.Smartsocket = Smartsocket;
 //# sourceMappingURL=data:application/json;base64,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
--- a/dist/smartsocket.classes.smartsocketclient.d.ts
+++ b/dist/smartsocket.classes.smartsocketclient.d.ts
@ -1,28 +0,0 @@
 /// <reference types="q" />
 import * as plugins from "./smartsocket.plugins";
 import { SocketConnection } from "./smartsocket.classes.socketconnection";
 /**
 * interface for class SmartsocketClient
 */
 export interface ISmartsocketClientOptions {
    port: number;
    url: string;
    alias: string;
    role: string;
    password: string;
 }
 export declare class SmartsocketClient {
    alias: string;
    role: string;
    socketConnection: SocketConnection;
    serverUrl: string;
    serverPort: number;
    serverPassword: string;
    constructor(optionsArg: ISmartsocketClientOptions);
    /**
     * connect the client to the server
     */
    connect(): plugins.q.Promise<{}>;
    disconnect(): plugins.q.Promise<{}>;
    serverCall(functionNameArg: string, dataArg: any): plugins.q.Promise<{}>;
 }
--- a/dist/smartsocket.classes.smartsocketclient.js
+++ b/dist/smartsocket.classes.smartsocketclient.js
@ -1,74 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 // import classes
 const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
 const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
 class SmartsocketClient {
    constructor(optionsArg) {
        this.alias = optionsArg.alias;
        this.role = optionsArg.role;
        this.serverUrl = optionsArg.url;
        this.serverPort = optionsArg.port;
        this.serverPassword = optionsArg.password;
    }
    ;
    /**
     * connect the client to the server
     */
    connect() {
        let done = plugins.q.defer();
        plugins.beautylog.log("trying to connect...");
        let socketUrl = `${this.serverUrl}:${this.serverPort}`;
        this.socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
            alias: this.alias,
            authenticated: false,
            role: undefined,
            side: "client",
            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,
                alias: this.alias
            });
            this.socketConnection.socket.on("authenticated", () => {
                console.log("client is authenticated");
                this.socketConnection.authenticated = true;
                this.socketConnection.listenToFunctionRequests();
                done.resolve();
            });
        });
        return done.promise;
    }
    ;
    disconnect() {
        let done = plugins.q.defer();
        this.socketConnection.socket.disconnect();
        this.socketConnection = undefined;
        plugins.beautylog.ok("disconnected!");
        done.resolve();
        return done.promise;
    }
    serverCall(functionNameArg, dataArg) {
        let done = plugins.q.defer();
        let socketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
            side: "requesting",
            originSocketConnection: this.socketConnection,
            shortId: plugins.shortid.generate(),
            funcCallData: {
                funcName: functionNameArg,
                funcDataArg: dataArg
            }
        });
        socketRequest.dispatch()
            .then((dataArg) => {
            done.resolve(dataArg.funcDataArg);
        });
        return done.promise;
    }
    ;
 }
 exports.SmartsocketClient = SmartsocketClient;
 //# sourceMappingURL=data:application/json;base64,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
--- a/dist/smartsocket.classes.socketconnection.d.ts
+++ b/dist/smartsocket.classes.socketconnection.d.ts
@ -1,48 +0,0 @@
 /// <reference types="socket.io" />
 /// <reference types="socket.io-client" />
 /// <reference types="q" />
 import * as plugins from "./smartsocket.plugins";
 import { Objectmap } from "lik";
 import { SocketRole } from "./smartsocket.classes.socketrole";
 /**
 * defines is a SocketConnection is server or client side. Important for mesh setups.
 */
 export declare type TSocketConnectionSide = "server" | "client";
 /**
 * interface for constructor of class SocketConnection
 */
 export interface ISocketConnectionConstructorOptions {
    alias: string;
    authenticated: boolean;
    role: SocketRole;
    side: TSocketConnectionSide;
    socket: SocketIO.Socket | SocketIOClient.Socket;
 }
 /**
 * interface for authentication data
 */
 export interface ISocketConnectionAuthenticationObject {
    role: "coreflowContainer";
    password: "somePassword";
    alias: "coreflow1";
 }
 export declare let allSocketConnections: Objectmap<SocketConnection>;
 /**
 * class SocketConnection represents a websocket connection
 */
 export declare class SocketConnection {
    alias: string;
    side: TSocketConnectionSide;
    authenticated: boolean;
    role: SocketRole;
    socket: SocketIO.Socket | SocketIOClient.Socket;
    constructor(optionsArg: ISocketConnectionConstructorOptions);
    /**
     * authenticate the socket
     */
    authenticate(): plugins.q.Promise<{}>;
    /**
     * listen to function requests
     */
    listenToFunctionRequests(): plugins.q.Promise<{}>;
 }
--- a/dist/smartsocket.classes.socketconnection.js
+++ b/dist/smartsocket.classes.socketconnection.js
@ -1,105 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 const helpers = require("./smartsocket.helpers");
 const lik_1 = require("lik");
 const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
 ;
 ;
 // export classes
 exports.allSocketConnections = new lik_1.Objectmap();
 /**
 * class SocketConnection represents a websocket connection
 */
 class SocketConnection {
    constructor(optionsArg) {
        this.authenticated = false;
        this.alias = optionsArg.alias;
        this.authenticated = optionsArg.authenticated;
        this.role = optionsArg.role;
        this.side = optionsArg.side;
        this.socket = optionsArg.socket;
        // standard behaviour that is always true
        exports.allSocketConnections.add(this);
        this.socket.on("disconnect", () => {
            plugins.beautylog.info(`SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`);
            exports.allSocketConnections.remove(this);
        });
    }
    ;
    // authenticating --------------------------
    /**
     * authenticate the socket
     */
    authenticate() {
        let done = plugins.q.defer();
        this.socket.on("dataAuth", (dataArg) => {
            plugins.beautylog.log("received authentication data. now hashing and comparing...");
            this.socket.removeListener("dataAuth", () => { });
            if (helpers.checkPasswordForRole(dataArg)) {
                this.alias = dataArg.alias;
                this.authenticated = true;
                this.role = helpers.getSocketRoleByName(dataArg.role);
                this.socket.emit("authenticated");
                plugins.beautylog.ok(`socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
                done.resolve(this);
            }
            else {
                this.authenticated = false;
                this.socket.disconnect();
                done.reject("not authenticated");
            }
            ;
        });
        this.socket.emit("requestAuth");
        return done.promise;
    }
    ;
    // listening -------------------------------
    /**
     * listen to function requests
     */
    listenToFunctionRequests() {
        let done = plugins.q.defer();
        if (this.authenticated) {
            this.socket.on("function", (dataArg) => {
                // check if requested function is available to the socket's scope
                plugins.beautylog.log("function request received");
                let referencedFunction = this.role.allowedFunctions.find((socketFunctionArg) => {
                    return socketFunctionArg.name === dataArg.funcCallData.funcName;
                });
                if (referencedFunction !== undefined) {
                    plugins.beautylog.ok("function in access scope");
                    let localSocketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
                        side: "responding",
                        originSocketConnection: this,
                        shortId: dataArg.shortId,
                        funcCallData: dataArg.funcCallData
                    });
                    localSocketRequest.createResponse(); // takes care of creating response and sending it back 
                }
                else {
                    plugins.beautylog.warn("function not existent or out of access scope");
                }
                ;
            });
            this.socket.on("functionResponse", (dataArg) => {
                plugins.beautylog.info(`received response for request with id ${dataArg.shortId}`);
                let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
                targetSocketRequest.handleResponse(dataArg);
            });
            plugins.beautylog.log(`now listening to function requests for ${this.alias}`);
            done.resolve(this);
        }
        else {
            let errMessage;
            plugins.beautylog.error(errMessage);
            done.reject(errMessage);
        }
        ;
        return done.promise;
    }
    ;
 }
 exports.SocketConnection = SocketConnection;
 ;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRjb25uZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRjb25uZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxNQUFZLE9BQU8sV0FBTSx1QkFBdUIsQ0FBQyxDQUFBO0FBQ2pELE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFFakQsc0JBQXdCLEtBQUssQ0FBQyxDQUFBO0FBSTlCLG9EQUEyRSxxQ0FBcUMsQ0FBQyxDQUFBO0FBbUJoSCxDQUFDO0FBU0QsQ0FBQztBQUVGLGlCQUFpQjtBQUNOLDRCQUFvQixHQUFHLElBQUksZUFBUyxFQUFvQixDQUFDO0FBRXBFOztHQUVHO0FBQ0g7SUFNSSxZQUFZLFVBQStDO1FBSDNELGtCQUFhLEdBQVksS0FBSyxDQUFDO1FBSTNCLElBQUksQ0FBQyxLQUFLLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQztRQUM5QixJQUFJLENBQUMsYUFBYSxHQUFHLFVBQVUsQ0FBQyxhQUFhLENBQUM7UUFDOUMsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDO1FBQzVCLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsTUFBTSxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUM7UUFFaEMseUNBQXlDO1FBQ3pDLDRCQUFvQixDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMvQixJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxZQUFZLEVBQUU7WUFDekIsT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsZ0NBQWdDLElBQUksQ0FBQyxLQUFLLGFBQWEsSUFBSSxDQUFDLElBQUksZUFBZSxDQUFDLENBQUM7WUFDeEcsNEJBQW9CLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3RDLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzs7SUFFRCw0Q0FBNEM7SUFFNUM7O09BRUc7SUFDSCxZQUFZO1FBQ1IsSUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUM3QixJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxPQUE2QztZQUNyRSxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyw0REFBNEQsQ0FBQyxDQUFDO1lBQ3BGLElBQUksQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDO1lBQ2xELEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQ3hDLElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQTtnQkFDMUIsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7Z0JBQzFCLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDdEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7Z0JBQ2xDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLHVCQUF1QixJQUFJLENBQUMsS0FBSyxXQUFXLElBQUksQ0FBQyxJQUFJLG9CQUFvQixDQUFDLENBQUM7Z0JBQ2hHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDdkIsQ0FBQztZQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNKLElBQUksQ0FBQyxhQUFhLEdBQUcsS0FBSyxDQUFDO2dCQUMzQixJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUN6QixJQUFJLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUM7WUFDckMsQ0FBQztZQUFBLENBQUM7UUFDTixDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQ2hDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3hCLENBQUM7O0lBRUQsNENBQTRDO0lBRTVDOztPQUVHO0lBQ0gsd0JBQXdCO1FBQ3BCLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsRUFBRSxDQUFBLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBLENBQUM7WUFDbkIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxFQUFFLENBQUMsT0FBZ0M7Z0JBQ3hELGlFQUFpRTtnQkFDakUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsMkJBQTJCLENBQUMsQ0FBQztnQkFDbkQsSUFBSSxrQkFBa0IsR0FBa0IsSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxpQkFBaUI7b0JBQ3RGLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEtBQUssT0FBTyxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUM7Z0JBQ3BFLENBQUMsQ0FBQyxDQUFDO2dCQUNILEVBQUUsQ0FBQSxDQUFDLGtCQUFrQixLQUFLLFNBQVMsQ0FBQyxDQUFBLENBQUM7b0JBQ2pDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRyxDQUFDLDBCQUEwQixDQUFDLENBQUM7b0JBQ2xELElBQUksa0JBQWtCLEdBQUcsSUFBSSxpREFBYSxDQUFDO3dCQUN2QyxJQUFJLEVBQUMsWUFBWTt3QkFDakIsc0JBQXNCLEVBQUMsSUFBSTt3QkFDM0IsT0FBTyxFQUFDLE9BQU8sQ0FBQyxPQUFPO3dCQUN2QixZQUFZLEVBQUMsT0FBTyxDQUFDLFlBQVk7cUJBQ3BDLENBQUMsQ0FBQztvQkFDSCxrQkFBa0IsQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDLHVEQUF1RDtnQkFDaEcsQ0FBQztnQkFBQyxJQUFJLENBQUMsQ0FBQztvQkFDSixPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyw4Q0FBOEMsQ0FBQyxDQUFDO2dCQUMzRSxDQUFDO2dCQUFBLENBQUM7WUFDTixDQUFDLENBQUMsQ0FBQztZQUNILElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLGtCQUFrQixFQUFFLENBQUMsT0FBZ0M7Z0JBQ2hFLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLHlDQUF5QyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztnQkFDbkYsSUFBSSxtQkFBbUIsR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO2dCQUN4RSxtQkFBbUIsQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDaEQsQ0FBQyxDQUFDLENBQUM7WUFDSCxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQywwQ0FBMEMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDOUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QixDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixJQUFJLFVBQW9ELENBQUM7WUFDekQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDcEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUM1QixDQUFDO1FBQUEsQ0FBQztRQUNGLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3hCLENBQUM7O0FBSUwsQ0FBQztBQTVGWSx3QkFBZ0IsbUJBNEY1QixDQUFBO0FBQUEsQ0FBQyJ9
--- a/dist/smartsocket.classes.socketfunction.d.ts
+++ b/dist/smartsocket.classes.socketfunction.d.ts
@ -1,46 +0,0 @@
 /// <reference types="q" />
 import * as plugins from "./smartsocket.plugins";
 import { Objectmap } from "lik";
 import { SocketRole } from "./smartsocket.classes.socketrole";
 /**
 * interface of the contructor options of class SocketFunction
 */
 export interface ISocketFunctionConstructorOptions {
    funcName: string;
    funcDef: any;
    allowedRoles: SocketRole[];
 }
 /**
 * interface of the Socket Function call, in other words the object that routes a call to a function
 */
 export interface ISocketFunctionCall {
    funcName: string;
    funcDataArg: any;
 }
 /**
 * interface for function definition of SocketFunction
 */
 export interface IFuncDef {
    (dataArg: any): PromiseLike<any>;
 }
 export declare let allSocketFunctions: Objectmap<SocketFunction>;
 /**
 * class that respresents a function that can be transparently called using a SocketConnection
 */
 export declare class SocketFunction {
    name: string;
    funcDef: IFuncDef;
    roles: SocketRole[];
    /**
     * the constructor for SocketFunction
     */
    constructor(optionsArg: ISocketFunctionConstructorOptions);
    /**
     * notifies a role about access to this SocketFunction
     */
    private _notifyRole(socketRoleArg);
    /**
     * invokes the function of this SocketFunction
     */
    invoke(dataArg: ISocketFunctionCall): plugins.q.Promise<any>;
 }
--- a/dist/smartsocket.classes.socketfunction.js
+++ b/dist/smartsocket.classes.socketfunction.js
@ -1,57 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 // import classes
 const lik_1 = require("lik");
 ;
 ;
 // export objects
 exports.allSocketFunctions = new lik_1.Objectmap();
 // export classes
 /**
 * class that respresents a function that can be transparently called using a SocketConnection
 */
 class SocketFunction {
    /**
     * the constructor for SocketFunction
     */
    constructor(optionsArg) {
        this.name = optionsArg.funcName;
        this.funcDef = optionsArg.funcDef;
        this.roles = optionsArg.allowedRoles;
        for (let socketRoleArg of this.roles) {
            this._notifyRole(socketRoleArg);
        }
        ;
        exports.allSocketFunctions.add(this); // map instance with Objectmap
    }
    ;
    /**
     * notifies a role about access to this SocketFunction
     */
    _notifyRole(socketRoleArg) {
        socketRoleArg.addSocketFunction(this);
    }
    /**
     * invokes the function of this SocketFunction
     */
    invoke(dataArg) {
        let done = plugins.q.defer();
        if (dataArg.funcName === this.name) {
            this.funcDef(dataArg.funcDataArg)
                .then((resultData) => {
                let funcResponseData = {
                    funcName: this.name,
                    funcDataArg: resultData
                };
                done.resolve(funcResponseData);
            });
        }
        else {
            throw new Error("SocketFunction.name does not match the data argument's .name!");
        }
        return done.promise;
    }
    ;
 }
 exports.SocketFunction = SocketFunction;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFFakQsaUJBQWlCO0FBQ2pCLHNCQUEwQixLQUFLLENBQUMsQ0FBQTtBQVkvQixDQUFDO0FBUUQsQ0FBQztBQVNGLGlCQUFpQjtBQUNOLDBCQUFrQixHQUFHLElBQUksZUFBUyxFQUFrQixDQUFDO0FBRWhFLGlCQUFpQjtBQUVqQjs7R0FFRztBQUNIO0lBS0k7O09BRUc7SUFDSCxZQUFZLFVBQTZDO1FBQ3JELElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUNoQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQ3JDLEdBQUcsQ0FBQyxDQUFDLElBQUksYUFBYSxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQSxDQUFDO1lBQ2xDLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDcEMsQ0FBQztRQUFBLENBQUM7UUFDRiwwQkFBa0IsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyw4QkFBOEI7SUFDaEUsQ0FBQzs7SUFFRDs7T0FFRztJQUNLLFdBQVcsQ0FBQyxhQUF3QjtRQUN4QyxhQUFhLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLE9BQTJCO1FBQzlCLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsRUFBRSxDQUFBLENBQUMsT0FBTyxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUEsQ0FBQztZQUMvQixJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUM7aUJBQzVCLElBQUksQ0FBQyxDQUFDLFVBQWM7Z0JBQ2pCLElBQUksZ0JBQWdCLEdBQXVCO29CQUN2QyxRQUFRLEVBQUMsSUFBSSxDQUFDLElBQUk7b0JBQ2xCLFdBQVcsRUFBQyxVQUFVO2lCQUN6QixDQUFBO2dCQUNELElBQUksQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQztRQUVYLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLE1BQU0sSUFBSSxLQUFLLENBQUMsK0RBQStELENBQUMsQ0FBQztRQUNyRixDQUFDO1FBQ0QsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDeEIsQ0FBQzs7QUFFTCxDQUFDO0FBOUNZLHNCQUFjLGlCQThDMUIsQ0FBQSJ9
--- a/dist/smartsocket.classes.socketrequest.d.ts
+++ b/dist/smartsocket.classes.socketrequest.d.ts
@ -1,46 +0,0 @@
 /// <reference types="q" />
 import * as plugins from "./smartsocket.plugins";
 import { ISocketFunctionCall } from "./smartsocket.classes.socketfunction";
 import { Objectmap } from "lik";
 import { SocketConnection } from "./smartsocket.classes.socketconnection";
 export declare type TSocketRequestStatus = "new" | "pending" | "finished";
 export declare type TSocketRequestSide = "requesting" | "responding";
 /**
 * interface of constructor of class SocketRequest
 */
 export interface SocketRequestConstructorOptions {
    side: TSocketRequestSide;
    originSocketConnection: SocketConnection;
    shortId: string;
    funcCallData?: ISocketFunctionCall;
 }
 /**
 * request object that is sent initially and may or may not receive a response
 */
 export interface ISocketRequestDataObject {
    funcCallData: ISocketFunctionCall;
    shortId: string;
    responseTimeout?: number;
 }
 export declare let allSocketRequests: Objectmap<SocketRequest>;
 export declare class SocketRequest {
    status: TSocketRequestStatus;
    side: TSocketRequestSide;
    shortid: string;
    originSocketConnection: SocketConnection;
    funcCallData: ISocketFunctionCall;
    done: plugins.q.Deferred<{}>;
    constructor(optionsArg: SocketRequestConstructorOptions);
    /**
     * dispatches a socketrequest from the requesting to the receiving side
     */
    dispatch(): plugins.q.Promise<{}>;
    /**
     * handles the response that is received by the requesting side
     */
    handleResponse(responseDataArg: ISocketRequestDataObject): void;
    /**
     * creates the response on the responding side
     */
    createResponse(): void;
 }
--- a/dist/smartsocket.classes.socketrequest.js
+++ b/dist/smartsocket.classes.socketrequest.js
@ -1,64 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 const helpers = require("./smartsocket.helpers");
 // import classes
 const lik_1 = require("lik");
 ;
 ;
 //export objects
 exports.allSocketRequests = new lik_1.Objectmap();
 // export classes
 class SocketRequest {
    constructor(optionsArg) {
        this.status = "new";
        this.done = plugins.q.defer();
        this.side = optionsArg.side;
        this.shortid = optionsArg.shortId;
        this.funcCallData = optionsArg.funcCallData;
        this.originSocketConnection = optionsArg.originSocketConnection;
        exports.allSocketRequests.add(this);
    }
    ;
    // requesting --------------------------
    /**
     * dispatches a socketrequest from the requesting to the receiving side
     */
    dispatch() {
        let requestData = {
            funcCallData: this.funcCallData,
            shortId: this.shortid
        };
        this.originSocketConnection.socket.emit("function", requestData);
        return this.done.promise;
    }
    ;
    /**
     * handles the response that is received by the requesting side
     */
    handleResponse(responseDataArg) {
        plugins.beautylog.log("handling response!");
        this.done.resolve(responseDataArg.funcCallData);
        exports.allSocketRequests.remove(this);
    }
    // responding --------------------------
    /**
     * creates the response on the responding side
     */
    createResponse() {
        let targetSocketFunction = helpers.getSocketFunctionByName(this.funcCallData.funcName);
        plugins.beautylog.info(`invoking ${targetSocketFunction.name}`);
        targetSocketFunction.invoke(this.funcCallData)
            .then((resultData) => {
            plugins.beautylog.log("got resultData. Sending it to requesting party.");
            let requestData = {
                funcCallData: resultData,
                shortId: this.shortid
            };
            this.originSocketConnection.socket.emit("functionResponse", requestData);
            exports.allSocketRequests.remove(this);
        });
    }
 }
 exports.SocketRequest = SocketRequest;
 ;
 //# sourceMappingURL=data:application/json;base64,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
--- a/dist/smartsocket.classes.socketrole.d.ts
+++ b/dist/smartsocket.classes.socketrole.d.ts
@ -1,20 +0,0 @@
 import { Objectmap } from "lik";
 import { SocketFunction } from "./smartsocket.classes.socketfunction";
 export declare let allSocketRoles: Objectmap<SocketRole>;
 /**
 * interface for class SocketRole
 */
 export interface SocketRoleOptions {
    name: string;
    passwordHash: string;
 }
 /**
 * A socketrole defines access to certain routines.
 */
 export declare class SocketRole {
    name: string;
    passwordHash: string;
    allowedFunctions: Objectmap<SocketFunction>;
    constructor(optionsArg: SocketRoleOptions);
    addSocketFunction(socketFunctionArg: SocketFunction): void;
 }
--- a/dist/smartsocket.classes.socketrole.js
+++ b/dist/smartsocket.classes.socketrole.js
@ -1,21 +0,0 @@
 "use strict";
 // import classes
 const lik_1 = require("lik");
 exports.allSocketRoles = new lik_1.Objectmap();
 /**
 * A socketrole defines access to certain routines.
 */
 class SocketRole {
    constructor(optionsArg) {
        this.allowedFunctions = new lik_1.Objectmap();
        this.name = optionsArg.name;
        this.passwordHash = optionsArg.passwordHash;
        exports.allSocketRoles.add(this);
    }
    ;
    addSocketFunction(socketFunctionArg) {
        this.allowedFunctions.add(socketFunctionArg);
    }
 }
 exports.SocketRole = SocketRole;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFFQSxpQkFBaUI7QUFDakIsc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBSXJCLHNCQUFjLEdBQUcsSUFBSSxlQUFTLEVBQWMsQ0FBQztBQVd4RDs7R0FFRztBQUNIO0lBSUksWUFBWSxVQUE2QjtRQUR6QyxxQkFBZ0IsR0FBRyxJQUFJLGVBQVMsRUFBa0IsQ0FBQztRQUUvQyxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzVDLHNCQUFjLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUM7O0lBQ0QsaUJBQWlCLENBQUMsaUJBQWdDO1FBQzlDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNqRCxDQUFDO0FBQ0wsQ0FBQztBQVpZLGtCQUFVLGFBWXRCLENBQUEifQ==
--- a/dist/smartsocket.helpers.d.ts
+++ b/dist/smartsocket.helpers.d.ts
@ -1,14 +0,0 @@
 import { SocketFunction } from "./smartsocket.classes.socketfunction";
 import { ISocketConnectionAuthenticationObject } from "./smartsocket.classes.socketconnection";
 import { SocketRequest, TSocketRequestSide } from "./smartsocket.classes.socketrequest";
 import { SocketRole } from "./smartsocket.classes.socketrole";
 export declare let checkPasswordForRole: (dataArg: ISocketConnectionAuthenticationObject) => boolean;
 export declare let getSocketFunctionByName: (functionNameArg: string) => SocketFunction;
 /**
 * get corresponding Socketrequest instance by shortId
 */
 export declare let getSocketRequestById: (shortIdArg: string, requestSide?: TSocketRequestSide) => SocketRequest;
 /**
 * get corresponding SocketRole instance by name
 */
 export declare let getSocketRoleByName: (socketRoleNameArg: string) => SocketRole;
--- a/dist/smartsocket.helpers.js
+++ b/dist/smartsocket.helpers.js
@ -1,30 +0,0 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
 const smartsocket_classes_socketfunction_1 = require("./smartsocket.classes.socketfunction");
 const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
 const smartsocket_classes_socketrole_1 = require("./smartsocket.classes.socketrole");
 // SocketConnection helpers
 exports.checkPasswordForRole = (dataArg) => {
    let targetPasswordHash = exports.getSocketRoleByName(dataArg.role).passwordHash;
    let computedCompareHash = plugins.nodehash.sha256FromStringSync(dataArg.password);
    return targetPasswordHash === computedCompareHash;
 };
 // SocketFunction helpers
 exports.getSocketFunctionByName = (functionNameArg) => {
    return smartsocket_classes_socketfunction_1.allSocketFunctions.find((socketFunctionArg) => { return socketFunctionArg.name === functionNameArg; });
 };
 // SocketRequest helpers
 /**
 * get corresponding Socketrequest instance by shortId
 */
 exports.getSocketRequestById = (shortIdArg, requestSide) => {
    return smartsocket_classes_socketrequest_1.allSocketRequests.find((socketRequestArg) => { return socketRequestArg.shortid === shortIdArg; });
 };
 // SocketRole helpers
 /**
 * get corresponding SocketRole instance by name
 */
 exports.getSocketRoleByName = (socketRoleNameArg) => {
    return smartsocket_classes_socketrole_1.allSocketRoles.find((socketRoleArg) => { return socketRoleArg.name === socketRoleNameArg; });
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFJakQscURBQW1ELHNDQUFzQyxDQUFDLENBQUE7QUFFMUYsb0RBQXFFLHFDQUFxQyxDQUFDLENBQUE7QUFDM0csaURBQTJDLGtDQUFrQyxDQUFDLENBQUE7QUFFOUUsMkJBQTJCO0FBQ2hCLDRCQUFvQixHQUFHLENBQUMsT0FBOEM7SUFDN0UsSUFBSSxrQkFBa0IsR0FBRywyQkFBbUIsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsWUFBWSxDQUFDO0lBQ3hFLElBQUksbUJBQW1CLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbEYsTUFBTSxDQUFDLGtCQUFrQixLQUFLLG1CQUFtQixDQUFDO0FBQ3RELENBQUMsQ0FBQTtBQUdELHlCQUF5QjtBQUNkLCtCQUF1QixHQUFHLENBQUMsZUFBdUI7SUFDekQsTUFBTSxDQUFDLHVEQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDLGlCQUFpQixPQUFPLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEtBQUssZUFBZSxDQUFBLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDakgsQ0FBQyxDQUFBO0FBRUQsd0JBQXdCO0FBRXhCOztHQUVHO0FBQ1EsNEJBQW9CLEdBQUcsQ0FBQyxVQUFrQixFQUFFLFdBQWdDO0lBQ25GLE1BQU0sQ0FBQyxxREFBaUIsQ0FBQyxJQUFJLENBQUMsQ0FBQyxnQkFBZ0IsT0FBTyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxLQUFLLFVBQVUsQ0FBQSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQzNHLENBQUMsQ0FBQTtBQUVELHFCQUFxQjtBQUVyQjs7R0FFRztBQUNRLDJCQUFtQixHQUFHLENBQUMsaUJBQXlCO0lBQ3ZELE1BQU0sQ0FBQywrQ0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLGFBQWEsT0FBTyxNQUFNLENBQUMsYUFBYSxDQUFDLElBQUksS0FBSyxpQkFBaUIsQ0FBQSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ3RHLENBQUMsQ0FBQyJ9
--- a/dist/smartsocket.plugins.d.ts
+++ b/dist/smartsocket.plugins.d.ts
@ -1,9 +0,0 @@
 import "typings-global";
 export import beautylog = require("beautylog");
 export import lik = require("lik");
 export import nodehash = require("nodehash");
 export import q = require("q");
 export import shortid = require("shortid");
 export import socketIo = require("socket.io");
 export import socketIoClient = require("socket.io-client");
 export import taskbuffer = require("taskbuffer");
--- a/dist/smartsocket.plugins.js
+++ b/dist/smartsocket.plugins.js
@ -1,11 +0,0 @@
 "use strict";
 require("typings-global");
 exports.beautylog = require("beautylog");
 exports.lik = require("lik");
 exports.nodehash = require("nodehash");
 exports.q = require("q");
 exports.shortid = require("shortid");
 exports.socketIo = require("socket.io");
 exports.socketIoClient = require("socket.io-client");
 exports.taskbuffer = require("taskbuffer");
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLGdCQUFRLFdBQVcsVUFBVSxDQUFDLENBQUM7QUFDL0IsU0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDO0FBQ2pCLGVBQU8sV0FBVyxTQUFTLENBQUMsQ0FBQztBQUM3QixnQkFBUSxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2hDLHNCQUFjLFdBQVcsa0JBQWtCLENBQUMsQ0FBQztBQUM3QyxrQkFBVSxXQUFXLFlBQVksQ0FBQyxDQUFDIn0=
--- a/npmextra.json
+++ b/npmextra.json
@ -1,5 +1,18 @@
 {
-    "npmts":{
+  "gitzone": {
-        "coverageTreshold":50
+    "projectType": "npm",
    "module": {
      "githost": "gitlab.com",
      "gitscope": "pushrocks",
      "gitrepo": "smartsocket",
      "shortDescription": "easy and secure websocket communication",
      "npmPackagename": "@pushrocks/smartsocket",
      "license": "MIT",
      "projectDomain": "push.rocks"
    }
  },
  "npmci": {
    "npmGlobalTools": [],
    "npmAccessLevel": "public"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,11 +1,12 @@
 {
-  "name": "smartsocket",
+  "name": "@pushrocks/smartsocket",
-  "version": "1.1.2",
+  "version": "1.1.62",
-  "description": "easy and secure websocket communication, Typescript ready",
+  "description": "easy and secure websocket communication",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
  "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
    "build": "(tsbuild --web && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)"
  },
  "repository": {
    "type": "git",
@ -18,22 +19,45 @@
  },
  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
  "dependencies": {
-    "@types/q": "0.x.x",
+    "@apiglobal/typedrequest-interfaces": "^1.0.15",
-    "@types/shortid": "0.0.27",
+    "@pushrocks/isohash": "^1.0.2",
-    "@types/socket.io": "^1.4.26",
+    "@pushrocks/isounique": "^1.0.4",
-    "@types/socket.io-client": "^1.4.26",
+    "@pushrocks/lik": "^4.0.17",
-    "beautylog": "^5.0.20",
+    "@pushrocks/smartdelay": "^2.0.10",
-    "lik": "^1.0.15",
+    "@pushrocks/smartenv": "^4.0.11",
-    "nodehash": "^1.0.4",
+    "@pushrocks/smartexpress": "^3.0.76",
-    "q": "^1.4.1",
+    "@pushrocks/smartlog": "^2.0.39",
-    "shortid": "^2.2.6",
+    "@pushrocks/smartpromise": "^3.0.6",
-    "socket.io": "^1.4.8",
+    "@pushrocks/smartrx": "^2.0.19",
-    "socket.io-client": "^1.4.8",
+    "@pushrocks/smarttime": "^3.0.35",
-    "taskbuffer": "^1.0.7"
+    "@types/socket.io": "^2.1.11",
    "@types/socket.io-client": "^1.4.33",
    "socket.io": "^2.3.0",
    "socket.io-client": "^2.3.0"
  },
  "devDependencies": {
-    "npmts-g": "^5.2.8",
+    "@gitzone/tsbuild": "^2.1.25",
-    "should": "^11.0.0",
+    "@gitzone/tsrun": "^1.2.12",
-    "typings-test": "^1.0.1"
+    "@gitzone/tstest": "^1.0.48",
-  }
+    "@pushrocks/tapbundle": "^3.2.9",
    "@types/node": "^14.11.2",
    "tslint": "^6.1.3",
    "tslint-config-prettier": "^1.18.0"
  },
  "private": false,
  "files": [
    "ts/**/*",
    "ts_web/**/*",
    "dist/**/*",
    "dist_*/**/*",
    "dist_ts/**/*",
    "dist_ts_web/**/*",
    "assets/**/*",
    "cli.js",
    "npmextra.json",
    "readme.md"
  ],
  "browserslist": [
    "last 1 chrome versions"
  ]
 }
--- a/test/common/test.ts
+++ b/test/common/test.ts
@ -0,0 +1 @@
 console.log('TODO');
--- a/test/test.d.ts
+++ b/test/test.d.ts
@ -1,2 +0,0 @@
 import "typings-test";
 import "should";
--- a/test/test.expressserver.ts
+++ b/test/test.expressserver.ts
@ -0,0 +1,104 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import { expect, tap } from '@pushrocks/tapbundle';
 import * as smarthash from '@pushrocks/smarthash';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartexpress from '@pushrocks/smartexpress';
 import socketIoClient = require('socket.io-client');
 import smartsocket = require('../ts/index');
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
 let testSocketRole1: smartsocket.SocketRole;
 let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 const testConfig = {
  port: 3000,
 };
 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
 });
 tap.test('Should accept an smartExpressServer as server', async () => {
  myseServer = new smartexpress.Server({
    cors: true,
    forceSsl: false,
    port: testConfig.port,
  });
  testSmartsocket.setExternalServer('smartexpress', myseServer);
  await myseServer.start();
 });
 // class socketrole
 tap.test('should add a socketrole', async () => {
  testSocketRole1 = new smartsocket.SocketRole({
    name: 'testRole1',
    passwordHash: smarthash.sha256FromStringSync('testPassword'),
  });
  testSmartsocket.addSocketRoles([testSocketRole1]);
 });
 // class SocketFunction
 tap.test('should register a new Function', async () => {
  testSocketFunction1 = new smartsocket.SocketFunction({
    allowedRoles: [testSocketRole1],
    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 () => {
  testSmartsocketClient = new smartsocket.SmartsocketClient({
    port: testConfig.port,
    url: 'http://localhost',
    password: 'testPassword',
    alias: 'testClient1',
    role: 'testRole1',
  });
  testSmartsocketClient.addSocketFunction(testSocketFunction1);
  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', {
    value1: 'hello',
  });
  console.log(response);
 });
 tap.test('should be able to make a functionCall from server to client', async () => {});
 // terminate
 tap.test('should close the server', async () => {
  await testSmartsocket.stop();
  await myseServer.stop();
 });
 tap.start();
--- a/test/test.js
+++ b/test/test.js
@ -1,105 +0,0 @@
 "use strict";
 require("typings-test");
 require("should");
 const smartsocket = require("../dist/index");
 const q = require("q");
 const nodehash = require("nodehash");
 let testSmartsocket;
 let testSmartsocketClient;
 let testSocketRole1;
 let testSocketFunction1;
 let testConfig = {
    port: 3000
 };
 describe("smartsocket", function () {
    describe("class Smartsocket", function () {
        it("should create a new smartsocket", function () {
            testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
            testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
        });
        it("should start listening when .started is called", function () {
            testSmartsocket.startServer();
        });
    });
    describe("class SocketRole", function () {
        testSocketRole1 = new smartsocket.SocketRole({
            name: "testRole1",
            passwordHash: nodehash.sha256FromStringSync("testPassword")
        });
    });
    describe("class SocketFunction", function () {
        it("should register a new Function", function () {
            testSocketFunction1 = new smartsocket.SocketFunction({
                funcName: "testFunction1",
                funcDef: (dataArg) => {
                    let done = q.defer();
                    done.resolve(dataArg);
                    return done.promise;
                },
                allowedRoles: [testSocketRole1]
            });
        });
    });
    describe("class SmartsocketClient", function () {
        it("should react to a new websocket connection from client", function (done) {
            this.timeout(10000);
            testSmartsocketClient = new smartsocket.SmartsocketClient({
                port: testConfig.port,
                url: "http://localhost",
                password: "testPassword",
                alias: "testClient1",
                role: "testRole1"
            });
            testSmartsocketClient.connect()
                .then(() => {
                done();
            });
        });
        it("client should disconnect and reconnect", function (done) {
            this.timeout(10000);
            testSmartsocketClient.disconnect()
                .then(() => {
                let done = q.defer();
                setTimeout(() => {
                    testSmartsocketClient.connect()
                        .then(done.resolve);
                }, 0);
                return done.promise;
            })
                .then(() => {
                done();
            });
        });
        it("2 clients should connect in parallel", function () {
        });
        it("should be able to make a functionCall from client to server", function (done) {
            this.timeout(5000);
            testSmartsocketClient.serverCall("testFunction1", {
                value1: "hello"
            }).then((dataArg) => {
                console.log(dataArg);
                done();
            });
        });
        it("should be able to make a functionCall from server to client", function (done) {
            this.timeout(5000);
            let targetSocket = (() => {
                return smartsocket.allSocketConnections.find((socketConnectionArg) => {
                    return socketConnectionArg.alias === "testClient1";
                });
            })();
            testSmartsocket.clientCall("testFunction1", {
                value1: "helloFromServer"
            }, targetSocket).then((dataArg) => {
                console.log(dataArg);
                done();
            });
        });
    });
    describe("terminating smartsocket", function () {
        it("should close the server", function () {
            testSmartsocket.closeServer();
        });
    });
 });
 //# sourceMappingURL=data:application/json;base64,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
--- a/test/test.ts
+++ b/test/test.ts
@ -1,109 +1,133 @@
-import "typings-test";
+// tslint:disable-next-line:no-implicit-dependencies
-import "should";
+import { expect, tap } from '@pushrocks/tapbundle';
-import socketIoClient = require("socket.io-client");
+
-import smartsocket = require("../dist/index");
+import * as smarthash from '@pushrocks/smarthash';
-import q = require("q");
+import * as smartpromise from '@pushrocks/smartpromise';
-import nodehash = require("nodehash");
+
 import socketIoClient = require('socket.io-client');
 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>;
-let testConfig = {
+export interface IReqResClient {
-    port: 3000
+  method: 'testFunction1';
  request: {
    value1: string;
  };
  response: {
    value1: string;
  };
 }
-describe("smartsocket", function () {
+export interface IReqResServer {
-    describe("class Smartsocket", function () {
+  method: 'testFunction2';
-        it("should create a new smartsocket", function () {
+  request: {
-            testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+    hi: string;
-            testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
+  };
-        });
+  response: {
-        it("should start listening when .started is called", function () {
+    hi: string;
-            testSmartsocket.startServer();
+  };
-        });
+}
    });
    describe("class SocketRole", function(){
        testSocketRole1 = new smartsocket.SocketRole({
            name:"testRole1",
            passwordHash:nodehash.sha256FromStringSync("testPassword")
        })
    })
    describe("class SocketFunction", function () {
        it("should register a new Function", function () {
            testSocketFunction1 = new smartsocket.SocketFunction({
                funcName:"testFunction1",
                funcDef: (dataArg) => {
                    let done = q.defer();
                    done.resolve(dataArg);
                    return done.promise;
                },
                allowedRoles:[testSocketRole1]
            });
        });
    });
    describe("class SmartsocketClient", function () {
        it("should react to a new websocket connection from client", function (done) {
            this.timeout(10000);
            testSmartsocketClient = new smartsocket.SmartsocketClient({
                port: testConfig.port,
                url: "http://localhost",
                password: "testPassword",
                alias: "testClient1",
                role: "testRole1"
            });
            testSmartsocketClient.connect()
                .then(() => {
                    done();
                });
        });
        it("client should disconnect and reconnect", function (done) {
            this.timeout(10000);
            testSmartsocketClient.disconnect()
                .then(() => {
                    let done = q.defer();
                    setTimeout(() => {
                        testSmartsocketClient.connect()
                            .then(done.resolve)
                    }, 0)
                    return done.promise;
                })
                .then(() => {
                    done();
                });
        });
        it("2 clients should connect in parallel", function () {
-        });
+const testConfig = {
-        it("should be able to make a functionCall from client to server",function(done){
+  port: 3000,
-            this.timeout(5000);
+};
            testSmartsocketClient.serverCall("testFunction1",{
                value1:"hello"
            }).then((dataArg) => {
                console.log(dataArg);
                done();
            });
        });
        it("should be able to make a functionCall from server to client",function(done){
            this.timeout(5000);
            let targetSocket = (() => {
                return smartsocket.allSocketConnections.find((socketConnectionArg)=>{
                    return socketConnectionArg.alias === "testClient1";
                });
            })();
            testSmartsocket.clientCall("testFunction1",{
                value1:"helloFromServer"
            },targetSocket).then((dataArg) => {
                console.log(dataArg);
                done();
            });
        });
-    });
+// class smartsocket
-    describe("terminating smartsocket", function () {
+tap.test('should create a new smartsocket', async () => {
-        it("should close the server", function () {
+  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
-            testSmartsocket.closeServer();
+  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
-        });
+});
 // class socketrole
 tap.test('should add a socketrole', async () => {
  testSocketRole1 = new smartsocket.SocketRole({
    name: 'testRole1',
    passwordHash: smarthash.sha256FromStringSync('testPassword'),
  });
  testSmartsocket.addSocketRoles([testSocketRole1]);
 });
 // class SocketFunction
 tap.test('should register a new Function', async () => {
  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: 'testFunction2',
  });
  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 () => {
  testSmartsocketClient = new smartsocket.SmartsocketClient({
    port: testConfig.port,
    url: 'http://localhost',
    password: 'testPassword',
    alias: 'testClient1',
    role: 'testRole1',
  });
  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
  console.log(testSmartsocketClient.socketFunctions);
  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<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 testSmartsocket.clientCall<IReqResServer>(
    '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
 tap.test('should close the server', async () => {
  await testSmartsocket.stop();
 });
 tap.start();
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,12 +1,8 @@
 import * as plugins from "./smartsocket.plugins";
 // export main classes
-export * from "./smartsocket.classes.smartsocket";
+export * from './smartsocket.classes.smartsocket';
-export * from "./smartsocket.classes.smartsocketclient";
+export * from './smartsocket.classes.smartsocketclient';
 // export further classes and objects
-export * from "./smartsocket.classes.socketfunction";
+export * from './smartsocket.classes.socketfunction';
-export * from "./smartsocket.classes.socketrole";
+export * from './smartsocket.classes.socketrole';
-export {allSocketConnections} from "./smartsocket.classes.socketconnection";
+export * from './smartsocket.classes.socketconnection';
 // need something more exposed? Create an issue on GitLab!
--- a/ts/interfaces/connection.ts
+++ b/ts/interfaces/connection.ts
@ -0,0 +1,10 @@
 export interface IRequestAuthPayload {
  serverShortId: string;
 }
 export type TConnectionStatus =
  | 'new'
  | 'connecting'
  | 'connected'
  | 'disconnecting'
  | 'disconnected';
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -0,0 +1 @@
 export * from './connection';
--- a/ts/smartsocket.classes.smartsocket.ts
+++ b/ts/smartsocket.classes.smartsocket.ts
@ -1,86 +1,128 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';
-import * as helpers from "./smartsocket.helpers";
+import * as pluginsTyped from './smartsocket.pluginstyped';
 // classes
-import { Objectmap } from "lik";
+import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { SocketFunction,ISocketFunctionCall} from "./smartsocket.classes.socketfunction";
+import {
-import { SocketConnection } from "./smartsocket.classes.socketconnection";
+  ISocketFunctionCallDataRequest,
-import { SocketRequest } from "./smartsocket.classes.socketrequest";
+  SocketFunction,
-import { SocketRole } from "./smartsocket.classes.socketrole";
+  ISocketFunctionCallDataResponse,
 } from './smartsocket.classes.socketfunction';
 import { SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketServer } from './smartsocket.classes.socketserver';
 import { logger } from './smartsocket.logging';
 export interface ISmartsocketConstructorOptions {
-    port: number;
+  port?: number;
-};
+}
 export class Smartsocket {
-    options: ISmartsocketConstructorOptions
+  /**
-    io: SocketIO.Server;
+   * a unique id to detect server restarts
-    openSockets = new Objectmap<SocketConnection>();
+   */
-    constructor(optionsArg: ISmartsocketConstructorOptions) {
+  public shortId = plugins.isounique.uni();
-        this.options = optionsArg;
+  public smartenv = new plugins.smartenv.Smartenv();
-    };
+  public options: ISmartsocketConstructorOptions;
  public io: pluginsTyped.socketIo.Server;
  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
-    /**
+  private socketServer = new SocketServer(this);
     * the standard handler for new socket connections
     */
    private _handleSocketConnection(socketArg) {
        let socketConnection: SocketConnection =  new SocketConnection({
            alias:undefined,
            authenticated:false,
            role:undefined,
            side:"server",
            socket:socketArg
        });
        plugins.beautylog.log("Socket connected. Trying to authenticate...")
        this.openSockets.add(socketConnection);
        socketConnection.authenticate()
            .then(() => {
                return socketConnection.listenToFunctionRequests();
            })
            .catch((err) => {
                console.log(err);
            });
    };
-    /**
+  constructor(optionsArg: ISmartsocketConstructorOptions) {
-     * starts listening to incling sockets:
+    this.options = optionsArg;
-     */
+  }
-    startServer = () => {
+  // tslint:disable-next-line:member-ordering
-        this.io = plugins.socketIo(this.options.port);
+  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
-        this.io.on("connection", (socketArg) => {
+    await this.socketServer.setExternalServer(serverType, serverArg);
-            this._handleSocketConnection(socketArg);
+  }
-        });
+
  /**
   * starts smartsocket
   */
  public async start() {
    const socketIoModule = this.smartenv.getSafeNodeModule('socket.io');
    this.io = socketIoModule(this.socketServer.getServerForSocketIo());
    await this.socketServer.start();
    this.io.on('connection', (socketArg) => {
      this._handleSocketConnection(socketArg);
    });
  }
  /**
   * stops smartsocket
   */
  public async stop() {
    await plugins.smartdelay.delayFor(1000);
    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
      logger.log('info', `disconnect socket with >>alias ${socketObjectArg.alias}`);
      socketObjectArg.socket.disconnect();
    });
    this.socketConnections.wipe();
    this.io.close();
    // stop the corresponging server
    this.socketServer.stop();
  }
  // communication
  /**
   * allows call to specific client.
   */
  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
    functionNameArg: T['method'],
    dataArg: T['request'],
    targetSocketConnectionArg: SocketConnection
  ): Promise<T['response']> {
    const socketRequest = new SocketRequest<T>(this, {
      funcCallData: {
        funcDataArg: dataArg,
        funcName: functionNameArg,
      },
      originSocketConnection: targetSocketConnectionArg,
      shortId: plugins.isounique.uni(),
      side: 'requesting',
    });
    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
    const result = response.funcDataArg;
    return result;
  }
  /**
   * adds socketRoles
   */
  public addSocketRoles(socketRolesArray: SocketRole[]): void {
    for (const socketRole of socketRolesArray) {
      this.socketRoles.add(socketRole);
    }
-    closeServer = () => {
+    return;
-        this.openSockets.forEach((socketObjectArg: SocketConnection) => {
+  }
            plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
            socketObjectArg.socket.disconnect();
        });
        this.openSockets.wipe();
        this.io.close();
    };
-    // communication
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
    this.socketFunctions.add(socketFunction);
  }
-    /**
+  /**
-     * allows call to specific client. 
+   * the standard handler for new socket connections
-     */
+   */
-    clientCall(functionNameArg:string,dataArg:any,targetSocketConnectionArg:SocketConnection){
+  private async _handleSocketConnection(socketArg: pluginsTyped.socketIo.Socket) {
-        let done = plugins.q.defer();
+    const socketConnection: SocketConnection = new SocketConnection({
-        let socketRequest = new SocketRequest({
+      alias: undefined,
-            side:"requesting",
+      authenticated: false,
-            originSocketConnection:targetSocketConnectionArg,
+      role: undefined,
-            shortId:plugins.shortid.generate(),
+      side: 'server',
-            funcCallData:{
+      smartsocketHost: this,
-                funcName: functionNameArg,
+      socket: socketArg,
-                funcDataArg:dataArg
+    });
-            }
+    logger.log('info', 'Socket connected. Trying to authenticate...');
-        });
+    this.socketConnections.add(socketConnection);
-        socketRequest.dispatch()
+    await socketConnection.authenticate();
-            .then((dataArg:ISocketFunctionCall) => {
+    await socketConnection.listenToFunctionRequests();
-                done.resolve(dataArg.funcDataArg);
+  }
-            });
+}
        return done.promise;
    }
 }
--- a/ts/smartsocket.classes.smartsocketclient.ts
+++ b/ts/smartsocket.classes.smartsocketclient.ts
@ -1,94 +1,196 @@
-import * as plugins from "./smartsocket.plugins"
+import * as plugins from './smartsocket.plugins';
 import * as pluginsTyped from './smartsocket.pluginstyped';
 import * as interfaces from './interfaces';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
 import {
  ISocketFunctionCallDataRequest,
  SocketFunction,
 } from './smartsocket.classes.socketfunction';
 import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 import { logger } from './smartsocket.logging';
 // import interfaces
 import { ISocketFunctionCall } from "./smartsocket.classes.socketfunction";
 import { ISocketRequestDataObject } from "./smartsocket.classes.socketrequest"
 // import classes
 import { SocketConnection } from "./smartsocket.classes.socketconnection";
 import { SocketFunction } from "./smartsocket.classes.socketfunction";
 import { SocketRequest } from "./smartsocket.classes.socketrequest";
 /**
 * interface for class SmartsocketClient
 */
 export interface ISmartsocketClientOptions {
-    port: number;
+  port: number;
-    url: string;
+  url: string;
-    alias:string; // an alias makes it easier to identify this client in a multo client environment
+  alias: string; // an alias makes it easier to identify this client in a multo client environment
-    role:string;
+  role: string;
-    password: string; // by setting a password access to functions can be limited
+  password: string; // by setting a password access to functions can be limited
  autoReconnect?: boolean;
 }
 export class SmartsocketClient {
-    alias:string;
+  // a unique id
-    role:string;
+  public shortId = plugins.isounique.uni();
    socketConnection:SocketConnection;
    serverUrl:string;
    serverPort:number;
    serverPassword:string;
    constructor(optionsArg:ISmartsocketClientOptions){
        this.alias = optionsArg.alias;
        this.role = optionsArg.role;
        this.serverUrl = optionsArg.url
        this.serverPort = optionsArg.port;
        this.serverPassword = optionsArg.password
    };
-    /**
+  // the shortId of the remote we connect to
-     * connect the client to the server
+  public remoteShortId: string = null;
-     */
+
-    connect(){
+  public alias: string;
-        let done = plugins.q.defer();
+  public socketRole: SocketRole;
-        plugins.beautylog.log("trying to connect...");
+  public socketConnection: SocketConnection;
-        let socketUrl = `${this.serverUrl}:${this.serverPort}`;
+  public serverUrl: string;
-        this.socketConnection = new SocketConnection({
+  public serverPort: number;
-            alias:this.alias,
+  public autoReconnect: boolean;
-            authenticated:false,
+
-            role:undefined,
+  // status handling
-            side:"client",
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
-            socket: plugins.socketIoClient(socketUrl,{multiplex:false})
+  public eventStatus: interfaces.TConnectionStatus = 'new';
  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
  constructor(optionsArg: ISmartsocketClientOptions) {
    this.alias = optionsArg.alias;
    this.serverUrl = optionsArg.url;
    this.serverPort = optionsArg.port;
    this.socketRole = new SocketRole({
      name: optionsArg.role,
      passwordHash: optionsArg.password,
    });
    this.autoReconnect = optionsArg.autoReconnect;
  }
  public addSocketFunction(socketFunction: SocketFunction<any>) {
    this.socketFunctions.add(socketFunction);
    this.socketRole.allowedFunctions.add(socketFunction);
  }
  /**
   * connect the client to the server
   */
  public connect() {
    const done = plugins.smartpromise.defer();
    logger.log('info', 'trying to connect...');
    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
    this.socketConnection = new SocketConnection({
      alias: this.alias,
      authenticated: false,
      role: this.socketRole,
      side: 'client',
      smartsocketHost: this,
      socket: plugins.socketIoClient(socketUrl, {
        multiplex: false,
        reconnectionAttempts: 5,
      }),
    });
    const timer = new plugins.smarttime.Timer(5000);
    timer.start();
    timer.completed.then(() => {
      logger.log('warn', 'connection to server timed out.');
      this.disconnect();
    });
    // authentication flow
    this.socketConnection.socket.on(
      'requestAuth',
      (requestAuthPayload: interfaces.IRequestAuthPayload) => {
        timer.reset();
        logger.log('info', 'server requested authentication');
        // lets register the authenticated event
        this.socketConnection.socket.on('authenticated', () => {
          this.remoteShortId = requestAuthPayload.serverShortId;
          logger.log('info', 'client is authenticated');
          this.socketConnection.authenticated = true;
          this.socketConnection.listenToFunctionRequests();
          done.resolve();
        });
-        this.socketConnection.socket.on("requestAuth", () => {
+
-            console.log("server requested authentication");
+        // lets register the forbidden event
-            this.socketConnection.socket.emit("dataAuth", {
+        this.socketConnection.socket.on('forbidden', async () => {
-                role: this.role,
+          logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
-                password: this.serverPassword,
+          await this.disconnect();
                alias: this.alias
            });
            this.socketConnection.socket.on("authenticated",() => {
                console.log("client is authenticated");
                this.socketConnection.authenticated = true;
                this.socketConnection.listenToFunctionRequests();
                done.resolve();
            });
        });
-        return done.promise;
+
-    };
+        // lets provide the actual auth data
-    disconnect(){
+        this.socketConnection.socket.emit('dataAuth', {
-        let done = plugins.q.defer();
+          role: this.socketRole.name,
-        this.socketConnection.socket.disconnect();
+          password: this.socketRole.passwordHash,
-        this.socketConnection = undefined;
+          alias: this.alias,
-        plugins.beautylog.ok("disconnected!");
+        });
-        done.resolve();
+      }
-        return done.promise;
+    );
    // handle connection
    this.socketConnection.socket.on('connect', async () => {
      this.updateStatus('connected');
    });
    // handle disconnection and errors
    this.socketConnection.socket.on('disconnect', async () => {
      await this.disconnect();
    });
    this.socketConnection.socket.on('reconnect_failed', async () => {
      await this.disconnect();
    });
    this.socketConnection.socket.on('connect_error', async () => {
      await this.disconnect();
    });
    return done.promise;
  }
  /**
   * disconnect from the server
   */
  public async disconnect() {
    if (this.socketConnection) {
      await this.socketConnection.disconnect();
      this.socketConnection = undefined;
      logger.log('ok', 'disconnected!');
    }
-    serverCall(functionNameArg:string,dataArg:any){
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
-        let done = plugins.q.defer();
+    this.remoteShortId = null;
-        let socketRequest = new SocketRequest({
+    this.updateStatus('disconnected');
-            side:"requesting",
+
-            originSocketConnection:this.socketConnection,
+    if (this.autoReconnect) {
-            shortId:plugins.shortid.generate(),
+      this.tryDebouncedReconnect();
-            funcCallData:{
+    }
-                funcName: functionNameArg,
+  }
-                funcDataArg:dataArg
+
-            }
+  /**
-        });
+   * try a reconnection
-        socketRequest.dispatch()
+   */
-            .then((dataArg:ISocketFunctionCall) => {
+  public async tryDebouncedReconnect() {
-                done.resolve(dataArg.funcDataArg);
+    await plugins.smartdelay.delayForRandom(10000, 60000);
-            });
+    await this.connect();
-        return done.promise;
+  }
-    };
+
-    
+  /**
-}
+   * 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<T>(this, {
      side: 'requesting',
      originSocketConnection: this.socketConnection,
      shortId: plugins.isounique.uni(),
      funcCallData: {
        funcName: functionNameArg,
        funcDataArg: dataArg,
      },
    });
    const response = await socketRequest.dispatch();
    const result = response.funcDataArg;
    return result;
  }
  private updateStatus(statusArg: interfaces.TConnectionStatus) {
    if (this.eventStatus !== statusArg) {
      this.eventSubject.next(statusArg);
    }
    this.eventStatus = statusArg;
  }
 }
--- a/ts/smartsocket.classes.socketconnection.ts
+++ b/ts/smartsocket.classes.socketconnection.ts
@ -1,136 +1,175 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';
-import * as helpers from "./smartsocket.helpers";
+import * as interfaces from './interfaces';
 import {Objectmap} from "lik";
 // import classes
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketRequest, ISocketRequestDataObject, allSocketRequests } from "./smartsocket.classes.socketrequest";
+import { SocketFunction } from './smartsocket.classes.socketfunction';
-import { SocketRole } from "./smartsocket.classes.socketrole";
+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';
 import { logger } from './smartsocket.logging';
 // export interfaces
 /**
 * defines is a SocketConnection is server or client side. Important for mesh setups.
 */
-export type TSocketConnectionSide = "server" | "client";
+export type TSocketConnectionSide = 'server' | 'client';
 /**
 * interface for constructor of class SocketConnection
 */
 export interface ISocketConnectionConstructorOptions {
-    alias: string;
+  alias: string;
-    authenticated: boolean;
+  authenticated: boolean;
-    role: SocketRole;
+  role: SocketRole;
-    side: TSocketConnectionSide;
+  side: TSocketConnectionSide;
-    socket: SocketIO.Socket | SocketIOClient.Socket;
+  smartsocketHost: Smartsocket | SmartsocketClient;
-};
+  socket: SocketIO.Socket | SocketIOClient.Socket;
 }
 /**
 * interface for authentication data
 */
 export interface ISocketConnectionAuthenticationObject {
-    role: "coreflowContainer",
+  role: 'coreflowContainer';
-    password: "somePassword",
+  password: 'somePassword';
-    alias: "coreflow1"
+  alias: 'coreflow1';
-};
+}
 // export classes
-export let allSocketConnections = new Objectmap<SocketConnection>();
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
 /**
 * class SocketConnection represents a websocket connection
 */
 export class SocketConnection {
-    alias: string;
+  public alias: string;
-    side:TSocketConnectionSide;
+  public side: TSocketConnectionSide;
-    authenticated: boolean = false;
+  public authenticated: boolean = false;
-    role: SocketRole;
+  public role: SocketRole;
-    socket: SocketIO.Socket | SocketIOClient.Socket;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
-    constructor(optionsArg: ISocketConnectionConstructorOptions) {
+  public socket: SocketIO.Socket | SocketIOClient.Socket;
-        this.alias = optionsArg.alias;
+
-        this.authenticated = optionsArg.authenticated;
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
-        this.role = optionsArg.role;
+  public eventStatus: interfaces.TConnectionStatus = 'new';
-        this.side = optionsArg.side;
+
-        this.socket = optionsArg.socket;
+  constructor(optionsArg: ISocketConnectionConstructorOptions) {
-        
+    this.alias = optionsArg.alias;
-        // standard behaviour that is always true
+    this.authenticated = optionsArg.authenticated;
-        allSocketConnections.add(this);
+    this.role = optionsArg.role;
-        this.socket.on("disconnect", () => {
+    this.side = optionsArg.side;
-            plugins.beautylog.info(`SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`);
+    this.smartsocketRef = optionsArg.smartsocketHost;
-            allSocketConnections.remove(this);
+    this.socket = optionsArg.socket;
-        });
+
    // standard behaviour that is always true
    allSocketConnections.add(this);
    // handle connection
    this.socket.on('connect', async () => {
      this.updateStatus('connected');
    });
    this.socket.on('disconnect', async () => {
      logger.log(
        'info',
        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
      );
      await this.disconnect();
      allSocketConnections.remove(this);
    });
  }
  // authenticating --------------------------
  /**
   * authenticate the socket
   */
  public authenticate() {
    const done = plugins.smartpromise.defer();
    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
      logger.log('info', 'received authentication data. now hashing and comparing...');
      this.socket.removeListener('dataAuth', () => {});
      if (await SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
        // TODO: authenticate password
        this.alias = dataArg.alias;
        this.authenticated = true;
        this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
        this.socket.emit('authenticated');
        logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
        done.resolve(this);
      } else {
        this.authenticated = false;
        await this.disconnect();
        done.reject('not authenticated');
      }
    });
    const requestAuthPayload: interfaces.IRequestAuthPayload = {
      serverShortId: this.smartsocketRef.shortId,
    };
    this.socket.emit('requestAuth', requestAuthPayload);
    return done.promise;
  }
-    // authenticating --------------------------
+  // listening -------------------------------
-    /**
+  /**
-     * authenticate the socket
+   * listen to function requests
-     */
+   */
-    authenticate() {
+  public listenToFunctionRequests() {
-        let done = plugins.q.defer();
+    const done = plugins.smartpromise.defer();
-        this.socket.on("dataAuth", (dataArg:ISocketConnectionAuthenticationObject) => {
+    if (this.authenticated) {
-            plugins.beautylog.log("received authentication data. now hashing and comparing...");
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
-            this.socket.removeListener("dataAuth", () => { });
+        // check if requested function is available to the socket's scope
-            if (helpers.checkPasswordForRole(dataArg)) { // TODO: authenticate password
+        // logger.log('info', 'function request received');
-                this.alias = dataArg.alias
+        const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.find(
-                this.authenticated = true;
+          (socketFunctionArg) => {
-                this.role = helpers.getSocketRoleByName(dataArg.role);
+            return socketFunctionArg.name === dataArg.funcCallData.funcName;
-                this.socket.emit("authenticated");
+          }
-                plugins.beautylog.ok(`socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
+        );
-                done.resolve(this);
+        if (referencedFunction) {
-            } else {
+          // logger.log('ok', 'function in access scope');
-                this.authenticated = false;
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
-                this.socket.disconnect();
+            side: 'responding',
-                done.reject("not authenticated");
+            originSocketConnection: this,
-            };
+            shortId: dataArg.shortId,
-        });
+            funcCallData: dataArg.funcCallData,
-        this.socket.emit("requestAuth");
+          });
-        return done.promise;
+          localSocketRequest.createResponse(); // takes care of creating response and sending it back
    };
    // listening -------------------------------
    /**
     * listen to function requests
     */
    listenToFunctionRequests(){
        let done = plugins.q.defer();
        if(this.authenticated){
            this.socket.on("function", (dataArg:ISocketRequestDataObject) => {
                // check if requested function is available to the socket's scope
                plugins.beautylog.log("function request received");
                let referencedFunction:SocketFunction = this.role.allowedFunctions.find((socketFunctionArg) => {
                    return socketFunctionArg.name === dataArg.funcCallData.funcName;
                });
                if(referencedFunction !== undefined){
                    plugins.beautylog.ok!("function in access scope");
                    let localSocketRequest = new SocketRequest({
                        side:"responding",
                        originSocketConnection:this,
                        shortId:dataArg.shortId,
                        funcCallData:dataArg.funcCallData
                    });
                    localSocketRequest.createResponse(); // takes care of creating response and sending it back 
                } else {
                    plugins.beautylog.warn("function not existent or out of access scope");
                };
            });
            this.socket.on("functionResponse", (dataArg:ISocketRequestDataObject) => {
                plugins.beautylog.info(`received response for request with id ${dataArg.shortId}`);
                let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
                targetSocketRequest.handleResponse(dataArg);
            });
            plugins.beautylog.log(`now listening to function requests for ${this.alias}`);
            done.resolve(this);
        } else {
-            let errMessage: "socket needs to be authenticated first";
+          logger.log('warn', 'function not existent or out of access scope');
-            plugins.beautylog.error(errMessage);
+        }
-            done.reject(errMessage);
+      });
-        };
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
-        return done.promise;
+        logger.log('info', `received response for request with id ${dataArg.shortId}`);
-    };
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
          this.smartsocketRef,
          dataArg.shortId
        );
        targetSocketRequest.handleResponse(dataArg);
      });
      logger.log('info', `now listening to function requests for ${this.alias}`);
      done.resolve(this);
    } else {
      const errMessage = 'socket needs to be authenticated first';
      logger.log('error', errMessage);
      done.reject(errMessage);
    }
    return done.promise;
  }
-    // sending ----------------------
+  // disconnecting ----------------------
-    
+  public async disconnect() {
-};
+    this.socket.disconnect(true);
    this.updateStatus('disconnected');
  }
  private updateStatus(statusArg: interfaces.TConnectionStatus) {
    if (this.eventStatus !== statusArg) {
      this.eventSubject.next(statusArg);
    }
    this.eventStatus = statusArg;
  }
 }
--- a/ts/smartsocket.classes.socketfunction.ts
+++ b/ts/smartsocket.classes.socketfunction.ts
@ -1,87 +1,107 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';
 // import classes
-import { Objectmap } from "lik";
+import { SocketRole } from './smartsocket.classes.socketrole';
-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
 /**
 * interface of the contructor options of class SocketFunction
 */
-export interface ISocketFunctionConstructorOptions {
+export interface ISocketFunctionConstructorOptions<
-    funcName: string;
+  T extends plugins.typedrequestInterfaces.ITypedRequest
-    funcDef: any;
+> {
-    allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
+  funcName: T['method'];
-};
+  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<
-    funcName:string;
+  T extends plugins.typedrequestInterfaces.ITypedRequest
-    funcDataArg:any;
+> {
-};
+  funcName: T['method'];
  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 interface IFuncDef {
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
-    (dataArg:any):PromiseLike<any>
+  dataArg: T['request'],
-}
+  connectionArg: SocketConnection
-
+) => PromiseLike<T['response']>;
 // 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 {
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-    name: string;
+  // STATIC
-    funcDef: IFuncDef;
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
-    roles: SocketRole[];
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
    functionNameArg: string
  ): SocketFunction<Q> {
    return smartsocketRefArg.socketFunctions.find((socketFunctionArg) => {
      return socketFunctionArg.name === functionNameArg;
    });
  }
-    /**
+  // INSTANCE
-     * the constructor for SocketFunction
+  public name: string;
-     */
+  public funcDef: TFuncDef<T>;
-    constructor(optionsArg: ISocketFunctionConstructorOptions) {
+  public roles: SocketRole[];
        this.name = optionsArg.funcName;
        this.funcDef = optionsArg.funcDef;
        this.roles = optionsArg.allowedRoles;
        for (let socketRoleArg of this.roles){
            this._notifyRole(socketRoleArg);
        };
        allSocketFunctions.add(this); // map instance with Objectmap
    };
-    /** 
+  /**
-     * notifies a role about access to this SocketFunction
+   * the constructor for SocketFunction
-     */
+   */
-    private _notifyRole(socketRoleArg:SocketRole){
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
-        socketRoleArg.addSocketFunction(this);
+    this.name = optionsArg.funcName;
    this.funcDef = optionsArg.funcDef;
    this.roles = optionsArg.allowedRoles;
    for (const socketRoleArg of this.roles) {
      this._notifyRole(socketRoleArg);
    }
-    
+  }
    /**
     * invokes the function of this SocketFunction
     */
    invoke(dataArg:ISocketFunctionCall):plugins.q.Promise<any> {
        let done = plugins.q.defer();
        if(dataArg.funcName === this.name){
            this.funcDef(dataArg.funcDataArg)
                .then((resultData:any) => {
                    let funcResponseData:ISocketFunctionCall = {
                        funcName:this.name,
                        funcDataArg:resultData
                    }
                    done.resolve(funcResponseData);
                });
        } else {
            throw new Error("SocketFunction.name does not match the data argument's .name!");
        }
        return done.promise;        
    };
-}
+  /**
   * invokes the function of this SocketFunction
   */
  public async invoke(
    dataArg: ISocketFunctionCallDataRequest<T>,
    socketConnectionArg: SocketConnection
  ): Promise<ISocketFunctionCallDataResponse<T>> {
    if (dataArg.funcName === this.name) {
      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
        funcName: this.name,
        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
      };
      return funcResponseData;
    } else {
      throw new Error("SocketFunction.name does not match the data argument's .name!");
    }
  }
  /**
   * notifies a role about access to this SocketFunction
   */
  private _notifyRole(socketRoleArg: SocketRole) {
    socketRoleArg.addSocketFunction(this);
  }
 }
--- a/ts/smartsocket.classes.socketrequest.ts
+++ b/ts/smartsocket.classes.socketrequest.ts
@ -1,96 +1,126 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';
 import * as helpers from "./smartsocket.helpers";
 // import interfaces
-import { ISocketFunctionCall } from "./smartsocket.classes.socketfunction";
+import {
  SocketFunction,
  ISocketFunctionCallDataRequest,
  ISocketFunctionCallDataResponse,
 } from './smartsocket.classes.socketfunction';
 // import classes
-import { Objectmap } from "lik";
+import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { logger } from './smartsocket.logging';
-import { SocketConnection } from "./smartsocket.classes.socketconnection";
+import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 // export interfaces
-export type TSocketRequestStatus = "new" | "pending" | "finished";
+export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
-export type TSocketRequestSide = "requesting" | "responding";
+export type TSocketRequestSide = 'requesting' | 'responding';
 /**
 * interface of constructor of class SocketRequest
 */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions<
-    side: TSocketRequestSide;
+  T extends plugins.typedrequestInterfaces.ITypedRequest
-    originSocketConnection: SocketConnection;
+> {
-    shortId: string;
+  side: TSocketRequestSide;
-    funcCallData?: ISocketFunctionCall;
+  originSocketConnection: SocketConnection;
-};
+  shortId: string;
  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;
+  shortId: string;
-    responseTimeout?: number;
+  responseTimeout?: number;
-};
+}
 //export objects
 export let allSocketRequests = new Objectmap<SocketRequest>();
 // export classes
-export class SocketRequest {
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-    status: TSocketRequestStatus = "new";
+  // STATIC
-    side: TSocketRequestSide;
+  public static getSocketRequestById(
-    shortid: string;
+    smartsocketRef: Smartsocket | SmartsocketClient,
-    originSocketConnection: SocketConnection;
+    shortIdArg: string
-    funcCallData: ISocketFunctionCall
+  ): SocketRequest<any> {
-    done = plugins.q.defer();
+    return smartsocketRef.socketRequests.find((socketRequestArg) => {
-    constructor(optionsArg: SocketRequestConstructorOptions) {
+      return socketRequestArg.shortid === shortIdArg;
-        this.side = optionsArg.side;
+    });
-        this.shortid = optionsArg.shortId;
+  }
-        this.funcCallData = optionsArg.funcCallData;
+
-        this.originSocketConnection = optionsArg.originSocketConnection;
+  // INSTANCE
-        allSocketRequests.add(this);
+  public status: TSocketRequestStatus = 'new';
  public side: TSocketRequestSide;
  public shortid: string;
  public originSocketConnection: SocketConnection;
  public funcCallData: ISocketFunctionCallDataRequest<T>;
  public done = plugins.smartpromise.defer<ISocketFunctionCallDataResponse<T>>();
  public smartsocketRef: Smartsocket | SmartsocketClient;
  constructor(
    smartsocketRefArg: Smartsocket | SmartsocketClient,
    optionsArg: ISocketRequestConstructorOptions<T>
  ) {
    this.smartsocketRef = smartsocketRefArg;
    this.side = optionsArg.side;
    this.shortid = optionsArg.shortId;
    this.funcCallData = optionsArg.funcCallData;
    this.originSocketConnection = optionsArg.originSocketConnection;
    this.smartsocketRef.socketRequests.add(this);
  }
  // requesting --------------------------
  /**
   * dispatches a socketrequest from the requesting to the receiving side
   */
  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
    const requestData: ISocketRequestDataObject<T> = {
      funcCallData: this.funcCallData,
      shortId: this.shortid,
    };
    this.originSocketConnection.socket.emit('function', requestData);
    return this.done.promise;
  }
-    // requesting --------------------------
+  /**
   * handles the response that is received by the requesting side
   */
  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
    logger.log('info', 'handling response!');
    this.done.resolve(responseDataArg.funcCallData);
    this.smartsocketRef.socketRequests.remove(this);
  }
-    /**
+  // responding --------------------------
     * dispatches a socketrequest from the requesting to the receiving side
     */
    dispatch() {
        let requestData: ISocketRequestDataObject = {
            funcCallData: this.funcCallData,
            shortId: this.shortid
        }
        this.originSocketConnection.socket.emit("function", requestData);
        return this.done.promise;
    };
-    /**
+  /**
-     * handles the response that is received by the requesting side
+   * creates the response on the responding side
-     */
+   */
-    handleResponse(responseDataArg: ISocketRequestDataObject) {
+  public async createResponse(): Promise<void> {
-        plugins.beautylog.log("handling response!");
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
-        this.done.resolve(responseDataArg.funcCallData);
+      this.smartsocketRef,
-        allSocketRequests.remove(this);
+      this.funcCallData.funcName
    );
    if (!targetSocketFunction) {
      logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
      return;
    }
-
+    logger.log('info', `invoking ${targetSocketFunction.name}`);
-    // responding --------------------------
+    targetSocketFunction
-
+      .invoke(this.funcCallData, this.originSocketConnection)
-    /**
+      .then((resultData) => {
-     * creates the response on the responding side
+        logger.log('info', 'got resultData. Sending it to requesting party.');
-     */
+        const responseData: ISocketRequestDataObject<T> = {
-    createResponse() {
+          funcCallData: resultData,
-        let targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(this.funcCallData.funcName);
+          shortId: this.shortid,
-        plugins.beautylog.info(`invoking ${targetSocketFunction.name}`);
+        };
-        targetSocketFunction.invoke(this.funcCallData)
+        this.originSocketConnection.socket.emit('functionResponse', responseData);
-            .then((resultData) => {
+        this.smartsocketRef.socketRequests.remove(this);
-                plugins.beautylog.log("got resultData. Sending it to requesting party.")
+      });
-                let requestData: ISocketRequestDataObject = {
+  }
-                    funcCallData: resultData,
+}
                    shortId: this.shortid
                };
                this.originSocketConnection.socket.emit("functionResponse",requestData);
                allSocketRequests.remove(this);
            });
    }
 };
--- a/ts/smartsocket.classes.socketrole.ts
+++ b/ts/smartsocket.classes.socketrole.ts
@ -1,34 +1,57 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';
 // import classes
-import { Objectmap } from "lik";
+import { SocketFunction } from './smartsocket.classes.socketfunction';
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { Smartsocket } from './smartsocket.classes.smartsocket';
-
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
-
+import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';
 export let allSocketRoles = new Objectmap<SocketRole>();
 /**
 * interface for class SocketRole
 */
-export interface SocketRoleOptions {
+export interface ISocketRoleOptions {
-    name: string;
+  name: string;
-    passwordHash: string;
+  passwordHash: string;
 }
 /**
 * A socketrole defines access to certain routines.
 */
 export class SocketRole {
-    name: string;
+  // STATIC
-    passwordHash: string;
+  public static getSocketRoleByName(
-    allowedFunctions = new Objectmap<SocketFunction>();
+    referenceSmartsocket: Smartsocket | SmartsocketClient,
-    constructor(optionsArg: SocketRoleOptions) {
+    socketRoleNameArg: string
-        this.name = optionsArg.name;
+  ): SocketRole {
-        this.passwordHash = optionsArg.passwordHash;
+    return referenceSmartsocket.socketRoles.find((socketRoleArg) => {
-        allSocketRoles.add(this);
+      return socketRoleArg.name === socketRoleNameArg;
-    };
+    });
-    addSocketFunction(socketFunctionArg:SocketFunction){
+  }
-        this.allowedFunctions.add(socketFunctionArg);
+
-    }
+  public static async checkPasswordForRole(
-}
+    dataArg: ISocketConnectionAuthenticationObject,
    referenceSmartsocket: Smartsocket | SmartsocketClient
  ): Promise<boolean> {
    const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role)
      .passwordHash;
    const computedCompareHash = await plugins.isohash.sha256FromString(dataArg.password);
    return targetPasswordHash === computedCompareHash;
  }
  // INSTANCE
  public name: string;
  public passwordHash: string;
  public allowedFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
  constructor(optionsArg: ISocketRoleOptions) {
    this.name = optionsArg.name;
    this.passwordHash = optionsArg.passwordHash;
  }
  /**
   * adds the socketfunction to the socketrole
   * @param socketFunctionArg
   */
  public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
    this.allowedFunctions.add(socketFunctionArg);
  }
 }
--- a/ts/smartsocket.classes.socketserver.ts
+++ b/ts/smartsocket.classes.socketserver.ts
@ -0,0 +1,82 @@
 import * as plugins from './smartsocket.plugins';
 import * as pluginsTyped from './smartsocket.pluginstyped';
 // used in case no other server is supplied
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { logger } from './smartsocket.logging';
 /**
 * class socketServer
 * handles the attachment of socketIo to whatever server is in play
 */
 export class SocketServer {
  private smartsocket: Smartsocket;
  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
  // wether httpServer is standalone
  private standaloneServer = false;
  private expressServer: any;
  constructor(smartSocketInstance: Smartsocket) {
    this.smartsocket = smartSocketInstance;
  }
  /**
   * starts the server with another server
   * also works with an express style server
   */
  public async setExternalServer(
    serverType: 'smartexpress',
    serverArg: pluginsTyped.smartexpress.Server
  ) {
    await serverArg.startedPromise;
    this.httpServer = serverArg.httpServer;
  }
  /**
   * gets the server for socket.io
   */
  public getServerForSocketIo() {
    if (this.httpServer) {
      return this.httpServer;
    } else {
      const httpModule = this.smartsocket.smartenv.getSafeNodeModule('http');
      this.httpServer = new httpModule.Server();
      this.standaloneServer = true;
      return this.httpServer;
    }
  }
  /**
   * starts listening to incoming sockets:
   */
  public async start() {
    const done = plugins.smartpromise.defer();
    // handle http servers
    // in case an external server has been set "this.standaloneServer" should be false
    if (this.httpServer && this.standaloneServer) {
      if (!this.smartsocket.options.port) {
        logger.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, () => {
        logger.log(
          'success',
          `Server started in standalone mode on ${this.smartsocket.options.port}`
        );
        done.resolve();
      });
    } else {
      done.resolve();
    }
    // nothing else to do if express server is set
    await done.promise;
    return;
  }
  /**
   * closes the server
   */
  public async stop() {}
 }
--- a/ts/smartsocket.classes.socketstats.ts
+++ b/ts/smartsocket.classes.socketstats.ts
@ -0,0 +1,3 @@
 import * as plugins from './smartsocket.plugins';
 export class SocketStats {}
--- a/ts/smartsocket.helpers.ts
+++ b/ts/smartsocket.helpers.ts
@ -1,40 +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, allSocketRoles } from "./smartsocket.classes.socketrole";
 // SocketConnection helpers
 export let checkPasswordForRole = (dataArg: ISocketConnectionAuthenticationObject): boolean => {
    let targetPasswordHash = getSocketRoleByName(dataArg.role).passwordHash;
    let computedCompareHash = plugins.nodehash.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): SocketRole => {
    return allSocketRoles.find((socketRoleArg) => { return socketRoleArg.name === socketRoleNameArg })
 };
--- a/ts/smartsocket.logging.ts
+++ b/ts/smartsocket.logging.ts
@ -0,0 +1,3 @@
 import * as plugins from './smartsocket.plugins';
 export const logger = new plugins.smartlog.ConsoleLog();
--- a/ts/smartsocket.plugins.ts
+++ b/ts/smartsocket.plugins.ts
@ -1,9 +1,34 @@
-import "typings-global";
+// apiglobal scope
-export import beautylog = require("beautylog");
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
-export import lik  = require("lik");
+
-export import nodehash = require("nodehash");
+export { typedrequestInterfaces };
-export import q = require("q");
+
-export import shortid = require("shortid");
+// pushrocks scope
-export import socketIo = require("socket.io");
+import * as isohash from '@pushrocks/isohash';
-export import socketIoClient = require("socket.io-client");
+import * as isounique from '@pushrocks/isounique';
-export import taskbuffer = require("taskbuffer");
+import * as lik from '@pushrocks/lik';
 import * as smartenv from '@pushrocks/smartenv';
 import * as smartlog from '@pushrocks/smartlog';
 import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smarttime from '@pushrocks/smarttime';
 import * as smartrx from '@pushrocks/smartrx';
 export {
  isohash,
  isounique,
  lik,
  smartenv,
  smartlog,
  smartdelay,
  smartpromise,
  smarttime,
  smartrx,
 };
 // third party
 import socketIoClient from 'socket.io-client';
 export {
  socketIoClient
 };
--- a/ts/smartsocket.pluginstyped.ts
+++ b/ts/smartsocket.pluginstyped.ts
@ -0,0 +1,20 @@
 // node native
 import type http from 'http';
 import type https from 'https';
 export {
  http,
  https
 };
 // pushrocks scope
 import type * as smartexpress from '@pushrocks/smartexpress';
 export {
  smartexpress
 };
 // third party scope
 import type socketIo from 'socket.io';
 export { socketIo };
--- a/tslint.json
+++ b/tslint.json
@ -0,0 +1,17 @@
 {
  "extends": ["tslint:latest", "tslint-config-prettier"],
  "rules": {
    "semicolon": [true, "always"],
    "no-console": false,
    "ordered-imports": false,
    "object-literal-sort-keys": false,
    "member-ordering": {
      "options":{
        "order": [
          "static-method"
        ]
      }
    }
  },
  "defaultSeverity": "warning"
 }
Author	SHA1	Message	Date
Phil Kunz	72196ec383	1.1.62	2020-09-29 17:21:08 +00:00
Phil Kunz	c6ad490a6f	fix(core): update	2020-09-29 17:21:08 +00:00
Phil Kunz	a40a83f0bf	1.1.61	2020-09-29 08:35:27 +00:00
Phil Kunz	82fa029d05	fix(core): update	2020-09-29 08:35:26 +00:00
Phil Kunz	0d76e7f577	1.1.60	2020-09-24 18:04:12 +00:00
Phil Kunz	57e6f058be	fix(core): update	2020-09-24 18:04:11 +00:00
Phil Kunz	b0bf9d7c95	1.1.59	2020-09-24 18:03:02 +00:00
Phil Kunz	1fbc76ef30	fix(core): update	2020-09-24 18:03:01 +00:00
Phil Kunz	424d9cca91	1.1.58	2019-11-08 18:48:39 +01:00
Phil Kunz	d712270946	fix(core): update	2019-11-08 18:48:39 +01:00
Phil Kunz	f98c797ad8	1.1.57	2019-11-08 18:41:09 +01:00
Phil Kunz	a23e7349be	fix(core): update	2019-11-08 18:41:08 +01:00
Phil Kunz	c390881a4e	1.1.56	2019-11-08 17:31:04 +01:00
Phil Kunz	5e64f4ca25	fix(core): update	2019-11-08 17:31:04 +01:00
Phil Kunz	765bc73197	1.1.55	2019-11-08 17:11:41 +01:00
Phil Kunz	105acaf97b	fix(core): update	2019-11-08 17:11:41 +01:00
Phil Kunz	5139136af4	1.1.54	2019-11-07 00:26:47 +01:00
Phil Kunz	bcc4ce9a87	fix(core): update	2019-11-07 00:26:47 +01:00
Phil Kunz	20e7584eb9	1.1.53	2019-11-03 20:23:15 +01:00
Phil Kunz	59cbc343cc	fix(core): update	2019-11-03 20:23:15 +01:00
Phil Kunz	75aa1f6f0d	1.1.52	2019-11-03 19:17:26 +01:00
Phil Kunz	3f073ab9b3	fix(core): update	2019-11-03 19:17:26 +01:00
Phil Kunz	08c1618ea8	1.1.51	2019-11-03 18:33:46 +01:00
Phil Kunz	eb181fa2f6	fix(core): update	2019-11-03 18:33:46 +01:00
Phil Kunz	c901ab75d3	1.1.50	2019-11-03 16:48:35 +01:00
Phil Kunz	075c59ed2c	fix(core): update	2019-11-03 16:48:35 +01:00
Phil Kunz	8d358dd93d	1.1.49	2019-09-10 00:21:48 +02:00
Phil Kunz	e576d6058a	fix(core): update	2019-09-10 00:21:47 +02:00
Phil Kunz	6546da2394	1.1.48	2019-09-09 23:58:32 +02:00
Phil Kunz	29597daba1	fix(core): update	2019-09-09 23:58:32 +02:00
Phil Kunz	c8b647d2fd	1.1.47	2019-09-09 16:20:43 +02:00
Phil Kunz	1fa4aca049	fix(core): update	2019-09-09 16:20:43 +02:00
Phil Kunz	2d4695de22	1.1.46	2019-09-01 18:07:53 +02:00
Phil Kunz	a3f4dcbc2a	fix(core): update	2019-09-01 18:07:52 +02:00
Phil Kunz	d6e81288b4	1.1.45	2019-08-13 15:58:08 +02:00
Phil Kunz	c441d89596	fix(core): update	2019-08-13 15:58:08 +02:00
Phil Kunz	85b69e487a	1.1.44	2019-08-13 11:36:32 +02:00
Phil Kunz	0d94ed9345	fix(core): update	2019-08-13 11:36:31 +02:00
Phil Kunz	e188b18016	1.1.43	2019-08-13 09:37:23 +02:00
Phil Kunz	33c0fa3746	fix(core): update	2019-08-13 09:37:23 +02:00
Phil Kunz	52be1415ee	1.1.42	2019-08-12 22:46:57 +02:00
Phil Kunz	e75d5eabdb	fix(core): update	2019-08-12 22:46:57 +02:00
Phil Kunz	fb99848df1	1.1.41	2019-08-12 22:45:58 +02:00
Phil Kunz	1bd39d0755	fix(core): update	2019-08-12 22:45:58 +02:00
Phil Kunz	d24c5f628c	1.1.40	2019-08-12 22:31:41 +02:00
Phil Kunz	33fbabdd72	fix(core): update	2019-08-12 22:31:40 +02:00
Phil Kunz	9d26fff986	1.1.39	2019-08-12 18:16:26 +02:00
Phil Kunz	41151e5436	fix(core): update	2019-08-12 18:16:25 +02:00
Phil Kunz	109c5197f3	1.1.38	2019-06-07 08:40:24 +02:00
Phil Kunz	c3d47c1f50	fix(core): update	2019-06-07 08:40:24 +02:00
Phil Kunz	1b45fb45e9	1.1.37	2019-06-06 23:11:03 +02:00
Phil Kunz	c22adc9b57	fix(core): update	2019-06-06 23:11:03 +02:00
Phil Kunz	35e87306dd	1.1.36	2019-05-02 11:46:36 +02:00
Phil Kunz	1b20aa5992	fix(core): update	2019-05-02 11:46:36 +02:00
Phil Kunz	a63f14da47	1.1.35	2019-04-26 17:35:15 +02:00
Phil Kunz	86cf94c5dc	fix(core): update	2019-04-26 17:35:15 +02:00
Phil Kunz	0d39d6f237	1.1.34	2019-04-24 18:30:57 +02:00
Phil Kunz	1856ad5cfc	fix(core): update	2019-04-24 18:30:56 +02:00
Phil Kunz	b5dab810e8	1.1.33	2019-04-24 17:57:17 +02:00
Phil Kunz	f145b85b1c	fix(core): update	2019-04-24 17:57:16 +02:00
Phil Kunz	a8c647c5c7	1.1.32	2019-04-24 17:17:36 +02:00
Phil Kunz	22472e0adf	fix(core): update	2019-04-24 17:17:36 +02:00
Phil Kunz	333ddb4d9c	1.1.31	2019-04-24 17:10:52 +02:00
Phil Kunz	126f020bf8	fix(core): update	2019-04-24 17:10:51 +02:00
Phil Kunz	7677b1bb48	1.1.30	2019-04-24 16:09:01 +02:00
Phil Kunz	114379c5b3	fix(core): update	2019-04-24 16:09:01 +02:00
Phil Kunz	79ae7d2039	1.1.29	2019-04-24 15:47:29 +02:00
Phil Kunz	d2cb6a3045	fix(core): update	2019-04-24 15:47:28 +02:00
Phil Kunz	963619b2ed	1.1.28	2019-04-23 17:28:46 +02:00
Phil Kunz	976abaaed7	fix(core): update	2019-04-23 17:28:46 +02:00
Phil Kunz	ef322c32ac	1.1.27	2019-01-31 02:32:52 +01:00
Phil Kunz	475911a968	fix(build): now building with tsbuild	2019-01-31 02:32:52 +01:00
Phil Kunz	5530e29da4	1.1.26	2019-01-31 00:54:40 +01:00
Phil Kunz	5f1d2c83c6	fix(core): update	2019-01-31 00:54:39 +01:00
Phil Kunz	b84dd36885	1.1.25	2019-01-31 00:46:42 +01:00
Phil Kunz	c2d64ba39a	fix(readme): update	2019-01-31 00:46:42 +01:00
Phil Kunz	85a5d7cdaf	1.1.24	2019-01-30 10:55:52 +01:00
Phil Kunz	69380a2dbc	fix(npmextra): adjust access level	2019-01-30 10:55:51 +01:00
Phil Kunz	fc292d83b9	1.1.23	2019-01-30 10:55:17 +01:00
Phil Kunz	b29961df95	fix(scope): switch to @pushrocks	2019-01-30 10:55:16 +01:00
Phil Kunz	f774a82ad5	1.1.22	2019-01-30 03:21:15 +01:00
Phil Kunz	5a45f4750b	fix(package.json): private setting	2019-01-30 03:21:14 +01:00
Phil Kunz	fc6227ef96	1.1.21	2019-01-30 03:15:22 +01:00
Phil Kunz	873aba3e0b	fix(snyk): add .snyk file	2019-01-30 03:15:21 +01:00
Phil Kunz	f9bed9da8a	1.1.20	2019-01-30 03:14:03 +01:00
Phil Kunz	d296064bfa	fix(structure): update to latest standards	2019-01-30 03:14:02 +01:00
Phil Kunz	1b0922759a	1.1.19	2018-03-19 10:00:14 +01:00
Phil Kunz	aef4f9c591	now working as expected	2018-03-19 10:00:11 +01:00
Phil Kunz	abf546eec3	1.1.18	2018-03-18 17:50:39 +01:00
Phil Kunz	483cb38175	start transitioning to better SocketFunction handling	2018-03-18 17:50:37 +01:00
Phil Kunz	b2bd66a6a6	1.1.17	2018-03-18 16:40:42 +01:00
Phil Kunz	cfc3e8788d	add @types/node	2018-03-18 16:40:40 +01:00
Phil Kunz	23c14c032c	1.1.16	2018-03-17 17:52:36 +01:00
Phil Kunz	c92dae809f	format README	2018-03-17 17:52:31 +01:00
Phil Kunz	7200464e4b	1.1.15	2018-03-17 17:52:07 +01:00
Phil Kunz	eaa97f0598	update readme	2018-03-17 17:52:01 +01:00
Phil Kunz	cde8270313	1.1.14	2018-03-17 17:18:59 +01:00
Phil Kunz	1b073ac8f6	update readme	2018-03-17 17:18:53 +01:00
Phil Kunz	3f3857df1e	1.1.13	2018-03-15 02:29:44 +01:00
Phil Kunz	02e17a52c3	update to latest standards	2018-03-15 02:29:40 +01:00
Phil Kunz	287c2a73c5	1.1.12	2017-10-09 16:46:24 +02:00
Phil Kunz	dea3746bb0	allow setting of specific server	2017-10-09 10:40:59 +02:00
Phil Kunz	fc2a55bb0d	fix not ending error correctly	2017-10-09 10:28:18 +02:00
Phil Kunz	99eca912d3	1.1.11	2017-10-09 03:06:14 +02:00
Phil Kunz	0b6929af8f	update to newest version	2017-10-09 03:06:09 +02:00
Phil Kunz	0aa073f2a7	1.1.10	2017-07-15 23:16:26 +02:00
Phil Kunz	7170e58457	update smartsocket class to use standard class method definition	2017-07-15 23:16:22 +02:00
Phil Kunz	cccee35f2c	1.1.9	2017-07-07 22:38:14 +02:00
Phil Kunz	118ec84ec5	update docs	2017-07-07 22:38:10 +02:00
Phil Kunz	dd31eea263	update tests	2017-07-07 22:10:03 +02:00
Phil Kunz	477429143d	1.1.8	2017-07-07 22:03:22 +02:00
Phil Kunz	ea6fa14133	remove taskbuffer	2017-07-07 22:03:18 +02:00
Phil Kunz	02065e36a6	update to latest standards	2017-07-07 22:02:19 +02:00
PhilKunz	f34358db81	update README	2016-09-26 16:59:06 +02:00
PhilKunz	fddf54b2b1	1.1.7	2016-09-26 00:28:45 +02:00
PhilKunz	e1dbdc1a15	improve README	2016-09-26 00:28:39 +02:00
PhilKunz	f3031a1d4e	1.1.6	2016-09-26 00:23:28 +02:00
PhilKunz	47ca497d48	improve README	2016-09-26 00:23:17 +02:00
PhilKunz	c7e3c4537b	1.1.5	2016-09-05 00:34:13 +02:00
PhilKunz	62b36ab859	fix scoping of socket roles	2016-09-05 00:34:09 +02:00
PhilKunz	4563aade16	small syntax fix	2016-09-04 22:20:33 +02:00
PhilKunz	47596bfa59	1.1.4	2016-09-03 16:21:00 +02:00
PhilKunz	6543d60019	added docs	2016-09-03 16:03:57 +02:00
PhilKunz	f0aba45cec	1.1.3	2016-09-03 00:41:52 +02:00
PhilKunz	f327fa2784	updated dependencies and exported socketConnection	2016-09-03 00:41:49 +02:00
		`@ -0,0 +1,3 @@`
							`import * as plugins from './smartsocket.plugins';`

							`export class SocketStats {}`
		`@ -0,0 +1,3 @@`
							`import * as plugins from './smartsocket.plugins';`

							`export const logger = new plugins.smartlog.ConsoleLog();`