1.1.43

fix(core): update
1.1.42
2019-08-13 09:37:23 +02:00 · 2019-08-13 09:37:23 +02:00 · 2019-08-12 22:46:57 +02:00 · 2019-08-12 22:46:57 +02:00 · 2019-08-12 22:45:58 +02:00 · 2019-08-12 22:45:58 +02:00
42 changed files with 4494 additions and 799 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,22 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
-docs/
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,36 +1,119 @@
-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:
+- security
 - test
 - release
+- metadata

-testLEGACY:
-  stage: test
+# ====================
+# security stage
+# ====================
+mirror:
+  stage: security
  script:
-    - npmci test legacy
+  - npmci git mirror
  tags:
-    - docker
+  - docker
+  - notpriv
+
+snyk:
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
+    - npmci command snyk test
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# test stage
+# ====================

 testLTS:
  stage: test
  script:
-    - npmci test lts
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
-    - docker
-    
-testSTABLE:
+  - docker
+  - notpriv
+
+testBuild:
  stage: test
  script:
-    - npmci test stable
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci command npm run build
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
-    - docker
+  - docker
+  - notpriv

 release:
  stage: release
-  environment: npmjs-com_registry
  script:
-    - npmci publish
+  - npmci node install lts
+  - npmci npm publish
  only:
-    - tags
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  script:
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
+  tags:
+  - docker
+  - priv
+
+trigger:
+  stage: metadata
+  script:
+  - npmci trigger
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+pages:
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:18-dind
+  stage: metadata
+  script:
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
  tags:
    - 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/README.md
+++ b/README.md
@ -1,67 +1,111 @@
-# smartsocket
-easy and secure websocket communication, Typescript ready
+# @pushrocks/smartsocket
+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",
-    passwordHash: "someHashedString"
+  name: 'someRoleName',
+  passwordHash: 'someHashedString'
 });

-let mySocketFunction = new smartsocket.SocketFunction({
-    name:"newService",
-    func:(data) => {
-        
-    }, the function to execute
-    roles:[mySocketRole] // all roles that have access to a specific function
+// 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',
+  funcDef: data => {
+    console.log('testSocketFunction1 executed successfully!');
+  },
+  allowedRoles: [mySocketRole] // all roles that have access to a specific function
 });

-mySmartsocket.registerRole(mySocketRole);
-mySmartsocket.clientCall.select("client1","restart",data)
-    .then((responseData) => {
-
-    });
+// A "Smartsocket" exposes a .clientCall() that gets
+// 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';

-let mySmartsocketClient = new smartsocket.SmartsocketClient({
-    url: "somedomain.com", // url, note: will only work over https, no http supported.
-    port: 3000
-    role:"dockerhost", // some role, in this example a dockerhost vm,
-    password:"somePassword",
-    alias:"client1"
+// 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,
+  url: 'http://localhost',
+  password: 'testPassword',
+  alias: 'testClient1',
+  role: 'testRole1'
 });

-let mySocketFunction2 = new smartsocket.SocketFunction({
-    name:"restart",
-    func:(data) => {}, the function to execute
+// You can .connect() and .disconnect() from a "Smartsocket"
+testSmartsocketClient.connect().then(() => {
+  done();
 });

-mySmartsocketClient.registerFunction(mySocketFunction2);
+// 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',
+  funcDef: data => {}, // the function to execute, has to return promise
+  allowedRoles: []
+});

-mySmartsocketClient.serverCall("newService",data)
-    .then((responseData) => {
-        
-    });;
+// A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
+mySmartsocketClient.serverCall('function', functionCallData).then(functionResponseData => {
+  // the functionResponseData comes from the server... awesome, right?
+});
 ```

 > **NOTE:**  
-you can easily chain dependent requests on eiter the server or client side with promises.  
-`data` is always a js object that you can design for your specific needs.  
-It supports buffers for large binary data network exchange.  
+> 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.  
+> 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,2 +0,0 @@
-export * from "./smartsocket.classes.smartsocket";
-export * from "./smartsocket.classes.smartsocketclient";
--- a/dist/index.js
+++ b/dist/index.js
@ -1,7 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require("./smartsocket.classes.smartsocket"));
-__export(require("./smartsocket.classes.smartsocketclient"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsbUNBQW1DLENBQUMsRUFBQTtBQUNsRCxpQkFBYyx5Q0FBeUMsQ0FBQyxFQUFBIn0=
--- a/dist/smartsocket.classes.smartsocket.d.ts
+++ b/dist/smartsocket.classes.smartsocket.d.ts
@ -1,21 +0,0 @@
-/// <reference types="socket.io" />
-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 _handleSocket(socketArg);
-    /**
-     * starts listening to incling sockets:
-     */
-    startServer: () => void;
-    closeServer: () => void;
-}
--- a/dist/smartsocket.classes.smartsocket.js
+++ b/dist/smartsocket.classes.smartsocket.js
@ -1,46 +0,0 @@
-"use strict";
-const plugins = require("./smartsocket.plugins");
-// classes
-const lik_1 = require("lik");
-const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
-;
-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._handleSocket(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
-     */
-    _handleSocket(socketArg) {
-        let socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
-            authenticated: false,
-            socket: socketArg
-        });
-        plugins.beautylog.log("Socket connected. Trying to authenticate...");
-        this.openSockets.add(socketConnection);
-        socketConnection.authenticate()
-            .then(socketConnection.listenToFunctionRequests);
-    }
-    ;
-}
-exports.Smartsocket = Smartsocket;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFHakQsVUFBVTtBQUNWLHNCQUEwQixLQUFLLENBQUMsQ0FBQTtBQUdoQyx1REFBaUMsd0NBQXdDLENBQUMsQ0FBQTtBQUt6RSxDQUFDO0FBRUY7SUFJSSxZQUFZLFVBQTBDO1FBRHRELGdCQUFXLEdBQUcsSUFBSSxlQUFTLEVBQW9CLENBQUM7UUFtQmhEOztXQUVHO1FBRUgsZ0JBQVcsR0FBRztZQUNWLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzlDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxDQUFDLFNBQVM7Z0JBQy9CLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDbEMsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUE7UUFDRCxnQkFBVyxHQUFHO1lBQ1YsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxlQUFpQztnQkFDdkQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsa0NBQWtDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO2dCQUNqRixlQUFlLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1lBQ0gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN4QixJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQTtRQWxDRyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM5QixDQUFDOztJQUVEOztPQUVHO0lBQ0ssYUFBYSxDQUFDLFNBQVM7UUFDM0IsSUFBSSxnQkFBZ0IsR0FBc0IsSUFBSSx1REFBZ0IsQ0FBQztZQUMzRCxhQUFhLEVBQUMsS0FBSztZQUNuQixNQUFNLEVBQUMsU0FBUztTQUNuQixDQUFDLENBQUM7UUFDSCxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFBO1FBQ3BFLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDdkMsZ0JBQWdCLENBQUMsWUFBWSxFQUFFO2FBQzFCLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQ3pELENBQUM7O0FBb0JMLENBQUM7QUF4Q1ksbUJBQVcsY0F3Q3ZCLENBQUEifQ==
--- a/dist/smartsocket.classes.smartsocketclient.d.ts
+++ b/dist/smartsocket.classes.smartsocketclient.d.ts
@ -1,14 +0,0 @@
-/// <reference types="q" />
-import * as plugins from "./smartsocket.plugins";
-import { ISocketFunctionRequestObject, ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
-/**
- * interface for class SmartsocketClient
- */
-export interface ISmartsocketClientOptions {
-    port: number;
-    url: string;
-}
-export declare class SmartsocketClient {
-    constructor();
-    dispatchFunctionRequest(dataArg: ISocketFunctionRequestObject): plugins.q.Promise<ISocketFunctionResponseObject>;
-}
--- a/dist/smartsocket.classes.smartsocketclient.js
+++ b/dist/smartsocket.classes.smartsocketclient.js
@ -1,15 +0,0 @@
-"use strict";
-const plugins = require("./smartsocket.plugins");
-class SmartsocketClient {
-    constructor() {
-    }
-    dispatchFunctionRequest(dataArg) {
-        let done = plugins.q.defer();
-        let responseData;
-        done.resolve(responseData);
-        return done.promise;
-    }
-    ;
-}
-exports.SmartsocketClient = SmartsocketClient;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldGNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXRjbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUl6QixDQUFDLENBSitDO0FBaUJoRDtJQUNJO0lBRUEsQ0FBQztJQUNELHVCQUF1QixDQUFDLE9BQW9DO1FBQ3hELElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFpQyxDQUFDO1FBQzVELElBQUksWUFBMEMsQ0FBQztRQUMvQyxJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzNCLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3hCLENBQUM7O0FBQ0wsQ0FBQztBQVZZLHlCQUFpQixvQkFVN0IsQ0FBQSJ9
--- a/dist/smartsocket.classes.socketconnection.d.ts
+++ b/dist/smartsocket.classes.socketconnection.d.ts
@ -1,39 +0,0 @@
-/// <reference types="socket.io" />
-/// <reference types="q" />
-import * as plugins from "./smartsocket.plugins";
-import { SocketRole } from "./smartsocket.classes.socketrole";
-/**
- * interface for constructor of class SocketConnection
- */
-export interface ISocketConnectionOptions {
-    alias?: string;
-    authenticated: boolean;
-    role?: SocketRole;
-    socket: SocketIO.Socket;
-}
-/**
- * interface for authentication data
- */
-export interface ISocketConnectionAuthenticationObject {
-    role: "coreflowContainer";
-    password: "somePassword";
-    alias: "coreflow1";
-}
-/**
- * class SocketConnection represents a websocket connection
- */
-export declare class SocketConnection {
-    alias?: string;
-    authenticated: boolean;
-    role?: SocketRole;
-    socket: SocketIO.Socket;
-    constructor(optionsArg: ISocketConnectionOptions);
-    /**
-     * 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,70 +0,0 @@
-"use strict";
-const plugins = require("./smartsocket.plugins");
-const helpers = require("./smartsocket.helpers");
-;
-// export classes
-/**
- * class SocketConnection represents a websocket connection
- */
-class SocketConnection {
-    constructor(optionsArg) {
-        this.alias = optionsArg.alias;
-        this.authenticated = optionsArg.authenticated;
-        this.role = optionsArg.role;
-        this.socket = optionsArg.socket;
-    }
-    /**
-     * 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 ((true)) {
-                this.alias = dataArg.alias;
-                this.authenticated = true;
-                this.role = helpers.findSocketRoleByString(dataArg.role);
-                this.socket.emit("authenticated");
-                plugins.beautylog.ok(`socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
-                done.resolve(this);
-            }
-            else {
-                this.socket.disconnect();
-                done.reject("not authenticated");
-            }
-            ;
-        });
-        this.socket.emit("requestAuth");
-        return done.promise;
-    }
-    ;
-    /**
-     * listen to function requests
-     */
-    listenToFunctionRequests() {
-        let done = plugins.q.defer();
-        if (this.authenticated) {
-            this.socket.on("function", (dataArg) => {
-                let referencedFunction = this.role.allowedFunctions.find((socketFunctionArg) => {
-                    return socketFunctionArg.name === dataArg.functionName;
-                });
-                if (referencedFunction !== undefined) {
-                    referencedFunction.invoke(dataArg);
-                }
-                else {
-                    plugins.beautylog.warn("function not existent or out of access scope");
-                }
-                ;
-            });
-        }
-        else {
-            done.reject("socket needs to be authenticated first");
-        }
-        ;
-        return done.promise;
-    }
-}
-exports.SocketConnection = SocketConnection;
-;
-//# sourceMappingURL=data:application/json;base64,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
--- a/dist/smartsocket.classes.socketfunction.d.ts
+++ b/dist/smartsocket.classes.socketfunction.d.ts
@ -1,36 +0,0 @@
-import { SocketRole } from "./smartsocket.classes.socketrole";
-export interface ISocketFunctionRequestObject {
-    functionName: string;
-    argumentObject: any;
-    shortId: string;
-    responseTimeout?: number;
-}
-export interface ISocketFunctionResponseObject {
-    shortId: string;
-    argumentObject: any;
-}
-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: SocketRole[];
-}
-/**
- * class SocketFunction respresents a function that can be transparently called using a SocketConnection
- */
-export declare class SocketFunction {
-    name: string;
-    func: any;
-    roles: SocketRole[];
-    /**
-     * the constructor for SocketFunction
-     */
-    constructor(optionsArg: SocketFunctionOptions);
-    /**
-     * notifies a role about access to this SocketFunction
-     */
-    private _notifyRole(socketRoleArg);
-    /**
-     * invokes the function of this SocketFunction
-     */
-    invoke(dataArg: ISocketFunctionRequestObject): void;
-}
--- a/dist/smartsocket.classes.socketfunction.js
+++ b/dist/smartsocket.classes.socketfunction.js
@ -1,36 +0,0 @@
-"use strict";
-;
-;
-;
-// export classes
-/**
- * class SocketFunction respresents a function that can be transparently called using a SocketConnection
- */
-class SocketFunction {
-    /**
-     * the constructor for SocketFunction
-     */
-    constructor(optionsArg) {
-        this.name = optionsArg.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
-        for (let socketRoleArg of this.roles) {
-            this._notifyRole(socketRoleArg);
-        }
-    }
-    ;
-    /**
-     * notifies a role about access to this SocketFunction
-     */
-    _notifyRole(socketRoleArg) {
-        socketRoleArg.addSocketFunction(this);
-    }
-    /**
-     * invokes the function of this SocketFunction
-     */
-    invoke(dataArg) {
-    }
-    ;
-}
-exports.SocketFunction = SocketFunction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQWFDLENBQUM7QUFLRCxDQUFDO0FBTUQsQ0FBQztBQUVGLGlCQUFpQjtBQUVqQjs7R0FFRztBQUNIO0lBS0k7O09BRUc7SUFDSCxZQUFZLFVBQWlDO1FBQ3pDLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO1FBQzlCLEdBQUcsQ0FBQyxDQUFDLElBQUksYUFBYSxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQSxDQUFDO1lBQ2xDLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDcEMsQ0FBQztJQUNMLENBQUM7O0lBRUQ7O09BRUc7SUFDSyxXQUFXLENBQUMsYUFBd0I7UUFDeEMsYUFBYSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU0sQ0FBQyxPQUFvQztJQUUzQyxDQUFDOztBQUVMLENBQUM7QUEvQlksc0JBQWMsaUJBK0IxQixDQUFBIn0=
--- a/dist/smartsocket.classes.socketrequest.d.ts
+++ b/dist/smartsocket.classes.socketrequest.d.ts
@ -1,18 +0,0 @@
-import { ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
-import { Objectmap } from "lik";
-export declare type TSocketRequestStatus = "new" | "pending" | "finished";
-export declare type TSocketRequestSide = "requesting" | "responding";
-export interface SocketRequestConstructorOptions {
-    side: TSocketRequestSide;
-    shortid: string;
-}
-export declare let allRequestingSocketRequests: Objectmap<SocketRequest>;
-export declare let allRespondingSocketRequests: Objectmap<SocketRequest>;
-export declare class SocketRequest {
-    status: TSocketRequestStatus;
-    side: TSocketRequestSide;
-    shortid: string;
-    constructor(optionsArg: SocketRequestConstructorOptions);
-    respond(dataArg: ISocketFunctionResponseObject): void;
-    private _dispatch();
-}
--- a/dist/smartsocket.classes.socketrequest.js
+++ b/dist/smartsocket.classes.socketrequest.js
@ -1,30 +0,0 @@
-"use strict";
-// import classes
-const lik_1 = require("lik");
-;
-//export objects
-exports.allRequestingSocketRequests = new lik_1.Objectmap();
-exports.allRespondingSocketRequests = new lik_1.Objectmap();
-// export classes
-class SocketRequest {
-    constructor(optionsArg) {
-        this.status = "new";
-        this.side = optionsArg.side;
-        this.shortid = optionsArg.shortid;
-        if (this.side === "requesting") {
-            exports.allRequestingSocketRequests.add(this);
-        }
-        else {
-            exports.allRespondingSocketRequests.add(this);
-        }
-        ;
-    }
-    ;
-    respond(dataArg) {
-    }
-    _dispatch() {
-    }
-}
-exports.SocketRequest = SocketRequest;
-;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFLQSxpQkFBaUI7QUFDakIsc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBVS9CLENBQUM7QUFFRixnQkFBZ0I7QUFDTCxtQ0FBMkIsR0FBRyxJQUFJLGVBQVMsRUFBaUIsQ0FBQztBQUM3RCxtQ0FBMkIsR0FBRyxJQUFJLGVBQVMsRUFBaUIsQ0FBQztBQUV4RSxpQkFBaUI7QUFDakI7SUFJSSxZQUFZLFVBQTJDO1FBSHZELFdBQU0sR0FBeUIsS0FBSyxDQUFDO1FBSWpDLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDbEMsRUFBRSxDQUFBLENBQUMsSUFBSSxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsQ0FBQSxDQUFDO1lBQzNCLG1DQUEyQixDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMxQyxDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixtQ0FBMkIsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUMsQ0FBQztRQUFBLENBQUM7SUFDTixDQUFDOztJQUNELE9BQU8sQ0FBQyxPQUFxQztJQUU3QyxDQUFDO0lBQ08sU0FBUztJQUVqQixDQUFDO0FBQ0wsQ0FBQztBQW5CWSxxQkFBYSxnQkFtQnpCLENBQUE7QUFBQSxDQUFDIn0=
--- 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,2 +0,0 @@
-import { SocketRole } from "./smartsocket.classes.socketrole";
-export declare let findSocketRoleByString: (socketRoleNameArg: string) => SocketRole;
--- a/dist/smartsocket.helpers.js
+++ b/dist/smartsocket.helpers.js
@ -1,7 +0,0 @@
-"use strict";
-const smartsocket_classes_socketrole_1 = require("./smartsocket.classes.socketrole");
-// SocketRole helpers
-exports.findSocketRoleByString = (socketRoleNameArg) => {
-    return smartsocket_classes_socketrole_1.allSocketRoles.find((socketRoleArg) => { return socketRoleArg.name === socketRoleNameArg; });
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQU1BLGlEQUEyQyxrQ0FBa0MsQ0FBQyxDQUFBO0FBRzlFLHFCQUFxQjtBQUNWLDhCQUFzQixHQUFHLENBQUMsaUJBQXlCO0lBQzFELE1BQU0sQ0FBQywrQ0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLGFBQWEsT0FBTyxNQUFNLENBQUMsYUFBYSxDQUFDLElBQUksS0FBSyxpQkFBaUIsQ0FBQSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ3RHLENBQUMsQ0FBQyJ9
--- a/dist/smartsocket.plugins.d.ts
+++ b/dist/smartsocket.plugins.d.ts
@ -1,8 +0,0 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export import lik = require("lik");
-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,10 +0,0 @@
-"use strict";
-require("typings-global");
-exports.beautylog = require("beautylog");
-exports.lik = require("lik");
-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixlQUFPLFdBQVcsU0FBUyxDQUFDLENBQUM7QUFDN0IsZ0JBQVEsV0FBVyxXQUFXLENBQUMsQ0FBQztBQUNoQyxzQkFBYyxXQUFXLGtCQUFrQixDQUFDLENBQUM7QUFDN0Msa0JBQVUsV0FBVyxZQUFZLENBQUMsQ0FBQyJ9
--- a/npmextra.json
+++ b/npmextra.json
@ -0,0 +1,17 @@
+{
+  "gitzone": {
+    "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",
-  "version": "1.0.5",
-  "description": "easy and secure websocket communication, Typescript ready",
+  "name": "@pushrocks/smartsocket",
+  "version": "1.1.43",
+  "description": "easy and secure websocket communication",
  "main": "dist/index.js",
  "typings": "dist/index.d.ts",
  "scripts": {
-    "test": "(npmts)"
+    "test": "tstest test/",
+    "build": "tsbuild"
  },
  "repository": {
    "type": "git",
@ -18,21 +19,38 @@
  },
  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
  "dependencies": {
-    "@types/q": "0.x.x",
-    "@types/shortid": "0.0.27",
-    "@types/socket.io": "^1.4.26",
-    "@types/socket.io-client": "^1.4.26",
-    "beautylog": "^5.0.20",
-    "lik": "^1.0.15",
-    "q": "^1.4.1",
-    "shortid": "^2.2.6",
-    "socket.io": "^1.4.8",
-    "socket.io-client": "^1.4.8",
-    "taskbuffer": "^1.0.7"
+    "@pushrocks/lik": "^3.0.10",
+    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/smartexpress": "^3.0.38",
+    "@pushrocks/smarthash": "^2.0.6",
+    "@pushrocks/smartlog": "^2.0.19",
+    "@pushrocks/smartpromise": "^3.0.2",
+    "@types/shortid": "0.0.29",
+    "@types/socket.io": "^2.1.2",
+    "@types/socket.io-client": "^1.4.32",
+    "shortid": "^2.2.14",
+    "socket.io": "^2.2.0",
+    "socket.io-client": "^2.2.0"
  },
  "devDependencies": {
-    "npmts-g": "^5.2.8",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
-  }
+    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tstest": "^1.0.24",
+    "@pushrocks/tapbundle": "^3.0.11",
+    "@types/node": "^12.7.1",
+    "tslint": "^5.18.0",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "private": false,
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "dist_ts_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }
--- 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;
+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,37 +0,0 @@
-"use strict";
-require("typings-test");
-require("should");
-const socketIoClient = require("socket.io-client");
-const smartsocket = require("../dist/index");
-let testSmartsocket;
-describe("smartsocket", function () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
-    });
-    it("should register a new Function", function () {
-    });
-    it("should start listening when .started is called", function () {
-        testSmartsocket.startServer();
-    });
-    it("should react to a new websocket connection", function (done) {
-        this.timeout(10000);
-        let socket = socketIoClient("http://localhost:3000", {});
-        socket.on("requestAuth", function () {
-            console.log("server requested authentication");
-            socket.emit("dataAuth", {
-                role: "coreflowContainer",
-                password: "somePassword",
-                alias: "coreflow1"
-            });
-            socket.on("authenticated", () => {
-                console.log("client is authenticated");
-                done();
-            });
-        });
-    });
-    it("should close the server", function () {
-        testSmartsocket.closeServer();
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUNoQixNQUFPLGNBQWMsV0FBVyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3BELE1BQU8sV0FBVyxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTlDLElBQUksZUFBd0MsQ0FBQztBQUU3QyxRQUFRLENBQUMsYUFBYSxFQUFFO0lBQ3BCLEVBQUUsQ0FBQyxpQ0FBaUMsRUFBRTtRQUNsQyxlQUFlLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDLENBQUMsQ0FBQztJQUNILEVBQUUsQ0FBQyxnQ0FBZ0MsRUFBQztJQUVwQyxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQyxnREFBZ0QsRUFBQztRQUNoRCxlQUFlLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbEMsQ0FBQyxDQUFDLENBQUE7SUFDRixFQUFFLENBQUMsNENBQTRDLEVBQUUsVUFBVSxJQUFJO1FBQzNELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEIsSUFBSSxNQUFNLEdBQUcsY0FBYyxDQUFDLHVCQUF1QixFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3pELE1BQU0sQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUMvQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRTtnQkFDcEIsSUFBSSxFQUFFLG1CQUFtQjtnQkFDekIsUUFBUSxFQUFFLGNBQWM7Z0JBQ3hCLEtBQUssRUFBRSxXQUFXO2FBQ3JCLENBQUMsQ0FBQztZQUNILE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxFQUFDO2dCQUN0QixPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixDQUFDLENBQUM7Z0JBQ3ZDLElBQUksRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ0gsRUFBRSxDQUFDLHlCQUF5QixFQUFDO1FBQ3pCLGVBQWUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFDIn0=
--- a/test/test.ts
+++ b/test/test.ts
@ -1,38 +1,104 @@
-import "typings-test";
-import "should";
-import socketIoClient = require("socket.io-client");
-import smartsocket = require("../dist/index");
+// 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 socketIoClient = require('socket.io-client');
+import smartsocket = require('../ts/index');

 let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketRole1: smartsocket.SocketRole;
+let testSocketFunctionServer: smartsocket.SocketFunction;
+let testSocketFunctionClient: smartsocket.SocketFunction;

-describe("smartsocket", function () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
-    });
-    it("should register a new Function",function(){
-        
-    })
-    it("should start listening when .started is called",function(){
-        testSmartsocket.startServer();
-    })
-    it("should react to a new websocket connection", function (done) {
-        this.timeout(10000);
-        let socket = socketIoClient("http://localhost:3000", {});
-        socket.on("requestAuth", function () {
-            console.log("server requested authentication");
-            socket.emit("dataAuth", {
-                role: "coreflowContainer",
-                password: "somePassword",
-                alias: "coreflow1"
-            });
-            socket.on("authenticated",() => {
-                console.log("client is authenticated");
-                done();
-            });
-        });
-    });
-    it("should close the server",function(){
-        testSmartsocket.closeServer();
-    })
-});
+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);
+});
+
+// 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 () => {
+  testSocketFunctionServer = new smartsocket.SocketFunction({
+    allowedRoles: [testSocketRole1],
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1'
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    allowedRoles: [],
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1'
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionServer);
+  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('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 () => {
+  const response = await testSmartsocketClient.serverCall('testFunction1', {
+    hi: 'hi there from client'
+  });
+  console.log(response);
+});
+
+// terminate
+tap.test('should close the server', async () => {
+  await testSmartsocket.stop();
+});
+
+tap.start();
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,4 +1,10 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';

-export * from "./smartsocket.classes.smartsocket";
-export * from "./smartsocket.classes.smartsocketclient";
+// export main classes
+export * from './smartsocket.classes.smartsocket';
+export * from './smartsocket.classes.smartsocketclient';
+
+// export further classes and objects
+export * from './smartsocket.classes.socketfunction';
+export * from './smartsocket.classes.socketrole';
+export * from './smartsocket.classes.socketconnection';
--- a/ts/smartsocket.classes.smartsocket.ts
+++ b/ts/smartsocket.classes.smartsocket.ts
@ -1,55 +1,131 @@
-import * as plugins from "./smartsocket.plugins";
-import * as helpers from "./smartsocket.helpers";
+import * as plugins from './smartsocket.plugins';

 // classes
-import { Objectmap } from "lik";
-import { SocketRole } from "./smartsocket.classes.socketrole";
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
-import { SocketConnection } from "./smartsocket.classes.socketconnection";
+import { Objectmap } from '@pushrocks/lik';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketServer } from './smartsocket.classes.socketserver';
+
+// socket.io
+import * as SocketIO from 'socket.io';

 export interface ISmartsocketConstructorOptions {
-    port: number;
-
-};
+  port?: number;
+}

 export class Smartsocket {
-    options: ISmartsocketConstructorOptions
-    io: SocketIO.Server;
-    openSockets = new Objectmap<SocketConnection>();
-    constructor(optionsArg: ISmartsocketConstructorOptions) {
-        this.options = optionsArg;
-    };
+  public options: ISmartsocketConstructorOptions;
+  public io: SocketIO.Server;
+  public openSockets = new Objectmap<SocketConnection>();
+  public socketRoles = new Objectmap<SocketRole>();
+  public socketFunctions = new Objectmap<SocketFunction>();
+  public socketRequests = new Objectmap<SocketRequest>();

-    /**
-     * the standard handler for new socket connections
-     */
-    private _handleSocket(socketArg) {
-        let socketConnection: SocketConnection =  new SocketConnection({
-            authenticated:false,
-            socket:socketArg
-        });
-        plugins.beautylog.log("Socket connected. Trying to authenticate...")
-        this.openSockets.add(socketConnection);
-        socketConnection.authenticate()
-            .then(socketConnection.listenToFunctionRequests);
-    };
+  private socketServer = new SocketServer(this);

-    /**
-     * starts listening to incling sockets:
-     */
+  constructor(optionsArg: ISmartsocketConstructorOptions) {
+    this.options = optionsArg;
+  }

-    startServer = () => {
-        this.io = plugins.socketIo(this.options.port);
-        this.io.on('connection', (socketArg) => {
-            this._handleSocket(socketArg);
-        });
+  // tslint:disable-next-line:member-ordering
+  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
+    await this.socketServer.setExternalServer(serverType, serverArg);
+  }
+
+  /**
+   * starts smartsocket
+   */
+  public async start() {
+    this.io = plugins.socketIo(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.openSockets.forEach((socketObjectArg: SocketConnection) => {
+      plugins.smartlog.defaultLogger.log(
+        'info',
+        `disconnect socket with >>alias ${socketObjectArg.alias}`
+      );
+      socketObjectArg.socket.disconnect();
+    });
+    this.openSockets.wipe();
+    this.io.close();
+
+    // stop the corresponging server
+    this.socketServer.stop();
+  }
+
+  // communication
+
+  /**
+   * allows call to specific client.
+   */
+  public async clientCall(
+    functionNameArg: string,
+    dataArg: any,
+    targetSocketConnectionArg: SocketConnection
+  ) {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest(this, {
+      funcCallData: {
+        funcDataArg: dataArg,
+        funcName: functionNameArg
+      },
+      originSocketConnection: targetSocketConnectionArg,
+      shortId: plugins.shortid.generate(),
+      side: 'requesting'
+    });
+    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+      done.resolve(dataArg2.funcDataArg);
+    });
+    const result = await done.promise;
+    return result;
+  }
+
+  /**
+   * adds socketRoles
+   */
+  public addSocketRoles(socketRolesArray: SocketRole[]): void {
+    for (const socketRole of socketRolesArray) {
+      this.socketRoles.add(socketRole);
    }
-    closeServer = () => {
-        this.openSockets.forEach((socketObjectArg: SocketConnection) => {
-            plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
-            socketObjectArg.socket.disconnect();
-        });
-        this.openSockets.wipe();
-        this.io.close();
-    }
-}
+    return;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * the standard handler for new socket connections
+   */
+  private _handleSocketConnection(socketArg) {
+    const socketConnection: SocketConnection = new SocketConnection({
+      alias: undefined,
+      authenticated: false,
+      role: undefined,
+      side: 'server',
+      smartsocketHost: this,
+      socket: socketArg
+    });
+    plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
+    this.openSockets.add(socketConnection);
+    socketConnection
+      .authenticate()
+      .then(() => {
+        return socketConnection.listenToFunctionRequests();
+      })
+      .catch(err => {
+        console.log(err);
+      });
+  }
+}
--- a/ts/smartsocket.classes.smartsocketclient.ts
+++ b/ts/smartsocket.classes.smartsocketclient.ts
@ -1,28 +1,100 @@
-import * as plugins from "./smartsocket.plugins"
+import * as plugins from './smartsocket.plugins';

-
-// import interfaces
-import { ISocketFunctionRequestObject, ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
-
-// import classes
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';

 /**
 * interface for class SmartsocketClient
 */
 export interface ISmartsocketClientOptions {
-    port: number;
-    url: string;
+  port: number;
+  url: string;
+  alias: string; // an alias makes it easier to identify this client in a multo client environment
+  role: string;
+  password: string; // by setting a password access to functions can be limited
 }

 export class SmartsocketClient {
-    constructor() {
+  public alias: string;
+  public role: string;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+  public serverPassword: string;

-    }
-    dispatchFunctionRequest(dataArg:ISocketFunctionRequestObject): plugins.q.Promise<ISocketFunctionResponseObject> {
-        let done = plugins.q.defer<ISocketFunctionResponseObject>();
-        let responseData:ISocketFunctionResponseObject;
-        done.resolve(responseData);
-        return done.promise;
-    };
-}
+  public socketFunctions = new plugins.lik.Objectmap<SocketFunction>();
+  public socketRequests = new plugins.lik.Objectmap<SocketRequest>();
+  public socketRoles = new plugins.lik.Objectmap<SocketRole>();
+
+  constructor(optionsArg: ISmartsocketClientOptions) {
+    this.alias = optionsArg.alias;
+    this.role = optionsArg.role;
+    this.serverUrl = optionsArg.url;
+    this.serverPort = optionsArg.port;
+    this.serverPassword = optionsArg.password;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * connect the client to the server
+   */
+  public connect() {
+    const done = plugins.smartpromise.defer();
+    plugins.smartlog.defaultLogger.log('info', 'trying to connect...');
+    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
+    this.socketConnection = new SocketConnection({
+      alias: this.alias,
+      authenticated: false,
+      role: undefined,
+      side: 'client',
+      smartsocketHost: this,
+      socket: plugins.socketIoClient(socketUrl, { multiplex: false })
+    });
+    this.socketConnection.socket.on('requestAuth', () => {
+      console.log('server requested authentication');
+      this.socketConnection.socket.emit('dataAuth', {
+        role: this.role,
+        password: this.serverPassword,
+        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;
+  }
+
+  public disconnect() {
+    const done = plugins.smartpromise.defer();
+    this.socketConnection.socket.disconnect();
+    this.socketConnection = undefined;
+    plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
+    done.resolve();
+    return done.promise;
+  }
+
+  public serverCall(functionNameArg: string, dataArg: any) {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest(this, {
+      side: 'requesting',
+      originSocketConnection: this.socketConnection,
+      shortId: plugins.shortid.generate(),
+      funcCallData: {
+        funcName: functionNameArg,
+        funcDataArg: dataArg
+      }
+    });
+    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+      done.resolve(dataArg2.funcDataArg);
+    });
+    return done.promise;
+  }
+}
--- a/ts/smartsocket.classes.socketconnection.ts
+++ b/ts/smartsocket.classes.socketconnection.ts
@ -1,91 +1,167 @@
-import * as plugins from "./smartsocket.plugins";
-import * as helpers from "./smartsocket.helpers";
+import * as plugins from './smartsocket.plugins';
+
+import { Objectmap } from '@pushrocks/lik';

 // import classes
-import { SocketFunction, ISocketFunctionRequestObject } from "./smartsocket.classes.socketfunction";
-import { SocketRequest } from "./smartsocket.classes.socketrequest";
-import { SocketRole } from "./smartsocket.classes.socketrole";
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';
+
+// socket.io
+import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';

 // export interfaces

+/**
+ * defines is a SocketConnection is server or client side. Important for mesh setups.
+ */
+export type TSocketConnectionSide = 'server' | 'client';
+
 /**
 * interface for constructor of class SocketConnection
 */
-export interface ISocketConnectionOptions {
-    alias?: string;
-    authenticated: boolean;
-    role?: SocketRole;
-    socket: SocketIO.Socket;
-};
+export interface ISocketConnectionConstructorOptions {
+  alias: string;
+  authenticated: boolean;
+  role: SocketRole;
+  side: TSocketConnectionSide;
+  smartsocketHost: Smartsocket | SmartsocketClient;
+  socket: SocketIO.Socket | SocketIOClient.Socket;
+}

 /**
 * interface for authentication data
 */
 export interface ISocketConnectionAuthenticationObject {
-    role: "coreflowContainer",
-    password: "somePassword",
-    alias: "coreflow1"
+  role: 'coreflowContainer';
+  password: 'somePassword';
+  alias: 'coreflow1';
 }

 // export classes
+export let allSocketConnections = new Objectmap<SocketConnection>();

 /**
 * class SocketConnection represents a websocket connection
 */
 export class SocketConnection {
-    alias?: string;
-    authenticated: boolean;
-    role?: SocketRole;
-    socket: SocketIO.Socket;
-    constructor(optionsArg: ISocketConnectionOptions) {
-        this.alias = optionsArg.alias;
-        this.authenticated = optionsArg.authenticated;
-        this.role = optionsArg.role;
-        this.socket = optionsArg.socket;
-    }
-    /**
-     * 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 ((true)) { // TODO: authenticate password
-                this.alias = dataArg.alias
-                this.authenticated = true;
-                this.role = helpers.findSocketRoleByString(dataArg.role);
-                this.socket.emit("authenticated");
-                plugins.beautylog.ok(`socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
-                done.resolve(this);
-            } else {
-                this.socket.disconnect();
-                done.reject("not authenticated");
-            };
-        });
-        this.socket.emit("requestAuth");
-        return done.promise;
-    };
+  public alias: string;
+  public side: TSocketConnectionSide;
+  public authenticated: boolean = false;
+  public role: SocketRole;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+  public socket: SocketIO.Socket | SocketIOClient.Socket;
+  constructor(optionsArg: ISocketConnectionConstructorOptions) {
+    this.alias = optionsArg.alias;
+    this.authenticated = optionsArg.authenticated;
+    this.role = optionsArg.role;
+    this.side = optionsArg.side;
+    this.smartsocketRef = optionsArg.smartsocketHost;
+    this.socket = optionsArg.socket;

-    /**
-     * listen to function requests
-     */
-    listenToFunctionRequests() {
-        let done = plugins.q.defer();
-        if(this.authenticated){
-            this.socket.on("function", (dataArg:ISocketFunctionRequestObject) => {
-                let referencedFunction:SocketFunction = this.role.allowedFunctions.find((socketFunctionArg) => {
-                    return socketFunctionArg.name === dataArg.functionName
-                });
-                if(referencedFunction !== undefined){
-                    referencedFunction.invoke(dataArg);
-                } else {
-                    plugins.beautylog.warn("function not existent or out of access scope");
-                };
-            })
+    // standard behaviour that is always true
+    allSocketConnections.add(this);
+    this.socket.on('disconnect', () => {
+      plugins.smartlog.defaultLogger.log(
+        'info',
+        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
+      );
+      this.socket.disconnect();
+      allSocketConnections.remove(this);
+    });
+  }
+
+  // authenticating --------------------------
+
+  /**
+   * authenticate the socket
+   */
+  public authenticate() {
+    const done = plugins.smartpromise.defer();
+    this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => {
+      plugins.smartlog.defaultLogger.log(
+        'info',
+        'received authentication data. now hashing and comparing...'
+      );
+      this.socket.removeListener('dataAuth', () => {});
+      if (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');
+        plugins.smartlog.defaultLogger.log(
+          '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
+   */
+  public listenToFunctionRequests() {
+    const done = plugins.smartpromise.defer();
+    if (this.authenticated) {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+        // check if requested function is available to the socket's scope
+        plugins.smartlog.defaultLogger.log('info', 'function request received');
+        const referencedFunction: SocketFunction = this.role.allowedFunctions.find(
+          socketFunctionArg => {
+            return socketFunctionArg.name === dataArg.funcCallData.funcName;
+          }
+        );
+        if (referencedFunction !== undefined) {
+          plugins.smartlog.defaultLogger.log('ok', 'function in access scope');
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+            side: 'responding',
+            originSocketConnection: this,
+            shortId: dataArg.shortId,
+            funcCallData: dataArg.funcCallData
+          });
+          localSocketRequest.createResponse(); // takes care of creating response and sending it back
        } else {
-            done.reject("socket needs to be authenticated first");
-        };
-        return done.promise;
+          plugins.smartlog.defaultLogger.log(
+            'warn',
+            'function not existent or out of access scope'
+          );
+        }
+      });
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
+        plugins.smartlog.defaultLogger.log(
+          'info',
+          `received response for request with id ${dataArg.shortId}`
+        );
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
+          this.smartsocketRef,
+          dataArg.shortId
+        );
+        targetSocketRequest.handleResponse(dataArg);
+      });
+      plugins.smartlog.defaultLogger.log(
+        'info',
+        `now listening to function requests for ${this.alias}`
+      );
+      done.resolve(this);
+    } else {
+      const errMessage = 'socket needs to be authenticated first';
+      plugins.smartlog.defaultLogger.log('error', errMessage);
+      done.reject(errMessage);
    }
-};
+    return done.promise;
+  }
+
+  // sending ----------------------
+}
--- a/ts/smartsocket.classes.socketfunction.ts
+++ b/ts/smartsocket.classes.socketfunction.ts
@ -1,63 +1,93 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';

 // import classes
-import { Stringmap } from "lik";
-import { SocketRole } from "./smartsocket.classes.socketrole";
+import { Objectmap } from '@pushrocks/lik';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';

 // export interfaces

-export interface ISocketFunctionRequestObject {
-    functionName:string,
-    argumentObject:any,
-    shortId:string,
-    responseTimeout?:number
-};
+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions {
+  funcName: string;
+  funcDef: TFuncDef;
+  allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
+}

-export interface ISocketFunctionResponseObject {
-    shortId:string;
-    argumentObject:any;
-};
+/**
+ * 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;
+}

-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
-};
+/**
+ * interface for function definition of SocketFunction
+ */
+export type TFuncDef = (dataArg: any, connectionArg: SocketConnection) => PromiseLike<any>;

 // export classes

 /**
- * class SocketFunction respresents a function that can be transparently called using a SocketConnection
+ * class that respresents a function that can be transparently called using a SocketConnection
 */
 export class SocketFunction {
-    name: string;
-    func: any;
-    roles: SocketRole[];
+  // STATIC
+  public static getSocketFunctionByName(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction {
+    console.log(smartsocketRefArg.socketFunctions);
+    return smartsocketRefArg.socketFunctions.find(socketFunctionArg => {
+      return socketFunctionArg.name === functionNameArg;
+    });
+  }

-    /**
-     * the constructor for SocketFunction
-     */
-    constructor(optionsArg: SocketFunctionOptions) {
-        this.name = optionsArg.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
-        for (let socketRoleArg of this.roles){
-            this._notifyRole(socketRoleArg);
-        }
-    };
+  // INSTANCE
+  public name: string;
+  public funcDef: TFuncDef;
+  public roles: SocketRole[];

-    /** 
-     * notifies a role about access to this SocketFunction
-     */
-    private _notifyRole(socketRoleArg:SocketRole){
-        socketRoleArg.addSocketFunction(this);
+  /**
+   * the constructor for SocketFunction
+   */
+  constructor(optionsArg: ISocketFunctionConstructorOptions) {
+    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:ISocketFunctionRequestObject){
-        
-    };
+  }

-}
+  /**
+   * invokes the function of this SocketFunction
+   */
+  public invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise<any> {
+    const done = plugins.smartpromise.defer();
+    if (dataArg.funcName === this.name) {
+      this.funcDef(dataArg.funcDataArg, socketConnectionArg).then((resultData: any) => {
+        const 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;
+  }
+
+  /**
+   * 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,43 +1,123 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';

 // import interfaces
-import { ISocketFunctionRequestObject, ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
+import { SocketFunction, ISocketFunctionCall } from './smartsocket.classes.socketfunction';

 // import classes
-import { Objectmap } from "lik";
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { Objectmap } from '@pushrocks/lik';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { defaultLogger } from '@pushrocks/smartlog';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';

 // export interfaces
-export type TSocketRequestStatus = "new" | "pending" | "finished";
-export type TSocketRequestSide = "requesting" | "responding";
+export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
+export type TSocketRequestSide = 'requesting' | 'responding';

+/**
+ * interface of constructor of class SocketRequest
+ */
 export interface SocketRequestConstructorOptions {
-    side: TSocketRequestSide;
-    shortid: string;
-};
+  side: TSocketRequestSide;
+  originSocketConnection: SocketConnection;
+  shortId: string;
+  funcCallData?: ISocketFunctionCall;
+}

-//export objects
-export let allRequestingSocketRequests = new Objectmap<SocketRequest>();
-export let allRespondingSocketRequests = new Objectmap<SocketRequest>();
+/**
+ * request object that is sent initially and may or may not receive a response
+ */
+export interface ISocketRequestDataObject {
+  funcCallData: ISocketFunctionCall;
+  shortId: string;
+  responseTimeout?: number;
+}

 // export classes
 export class SocketRequest {
-    status: TSocketRequestStatus = "new";
-    side: TSocketRequestSide;
-    shortid: string;
-    constructor(optionsArg: SocketRequestConstructorOptions) {
-        this.side = optionsArg.side;
-        this.shortid = optionsArg.shortid;
-        if(this.side === "requesting"){
-            allRequestingSocketRequests.add(this);
-        } else {
-            allRespondingSocketRequests.add(this);
-        };
-    };
-    respond(dataArg:ISocketFunctionResponseObject){
+  // STATIC
+  public static getSocketRequestById(
+    smartsocketRef: Smartsocket | SmartsocketClient,
+    shortIdArg: string
+  ): SocketRequest {
+    return smartsocketRef.socketRequests.find(socketRequestArg => {
+      return socketRequestArg.shortid === shortIdArg;
+    });
+  }

+  // INSTANCE
+  public status: TSocketRequestStatus = 'new';
+  public side: TSocketRequestSide;
+  public shortid: string;
+  public originSocketConnection: SocketConnection;
+  public funcCallData: ISocketFunctionCall;
+  public done = plugins.smartpromise.defer();
+
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+
+  constructor(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: SocketRequestConstructorOptions
+  ) {
+    this.smartsocketRef = smartsocketRefArg;
+    this.side = optionsArg.side;
+    this.shortid = optionsArg.shortId;
+    this.funcCallData = optionsArg.funcCallData;
+    this.originSocketConnection = optionsArg.originSocketConnection;
+    this.smartsocketRef.socketRequests.add(this);
+  }
+
+  // requesting --------------------------
+
+  /**
+   * dispatches a socketrequest from the requesting to the receiving side
+   */
+  public dispatch() {
+    const 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
+   */
+  public handleResponse(responseDataArg: ISocketRequestDataObject) {
+    plugins.smartlog.defaultLogger.log('info', 'handling response!');
+    this.done.resolve(responseDataArg.funcCallData);
+    this.smartsocketRef.socketRequests.remove(this);
+  }
+
+  // responding --------------------------
+
+  /**
+   * creates the response on the responding side
+   */
+  public async createResponse(): Promise<void> {
+    const targetSocketFunction: SocketFunction = SocketFunction.getSocketFunctionByName(
+      this.smartsocketRef,
+      this.funcCallData.funcName
+    );
+
+    if (!targetSocketFunction) {
+      defaultLogger.log(
+        'warn',
+        `There is no SocketFunction defined for ${this.funcCallData.funcName}`
+      );
+      defaultLogger.log('warn', `So now response is being sent.`);
+      return;
    }
-    private _dispatch(){ // note: dispatch is private as it will be fired from the constructor
-        
-    }
-};
+    plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`);
+    targetSocketFunction.invoke(this.funcCallData, this.originSocketConnection).then(resultData => {
+      plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.');
+      const requestData: ISocketRequestDataObject = {
+        funcCallData: resultData,
+        shortId: this.shortid
+      };
+      this.originSocketConnection.socket.emit('functionResponse', requestData);
+      this.smartsocketRef.socketRequests.remove(this);
+    });
+  }
+}
--- a/ts/smartsocket.classes.socketrole.ts
+++ b/ts/smartsocket.classes.socketrole.ts
@ -1,34 +1,53 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins';

 // import classes
-import { Objectmap } from "lik";
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
-
-
-export let allSocketRoles = new Objectmap<SocketRole>();
-
+import { Objectmap } from '@pushrocks/lik';
+import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';

 /**
 * interface for class SocketRole
 */
 export interface SocketRoleOptions {
-    name: string;
-    passwordHash: string;
+  name: string;
+  passwordHash: string;
 }

 /**
 * A socketrole defines access to certain routines.
 */
 export class SocketRole {
-    name: string;
-    passwordHash: string;
-    allowedFunctions = new Objectmap<SocketFunction>();
-    constructor(optionsArg: SocketRoleOptions) {
-        this.name = optionsArg.name;
-        this.passwordHash = optionsArg.passwordHash;
-        allSocketRoles.add(this);
-    };
-    addSocketFunction(socketFunctionArg:SocketFunction){
-        this.allowedFunctions.add(socketFunctionArg);
-    }
-}
+  // STATIC
+  public static getSocketRoleByName(
+    referenceSmartsocket: Smartsocket | SmartsocketClient,
+    socketRoleNameArg: string
+  ): SocketRole {
+    return referenceSmartsocket.socketRoles.find(socketRoleArg => {
+      return socketRoleArg.name === socketRoleNameArg;
+    });
+  }
+
+  public static checkPasswordForRole(
+    dataArg: ISocketConnectionAuthenticationObject,
+    referenceSmartsocket: Smartsocket | SmartsocketClient
+  ): boolean {
+    const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role)
+      .passwordHash;
+    const computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password);
+    return targetPasswordHash === computedCompareHash;
+  }
+
+  // INSTANCE
+  public name: string;
+  public passwordHash: string;
+  public allowedFunctions = new Objectmap<SocketFunction>();
+  constructor(optionsArg: SocketRoleOptions) {
+    this.name = optionsArg.name;
+    this.passwordHash = optionsArg.passwordHash;
+  }
+  public addSocketFunction(socketFunctionArg: SocketFunction) {
+    this.allowedFunctions.add(socketFunctionArg);
+  }
+}
--- a/ts/smartsocket.classes.socketserver.ts
+++ b/ts/smartsocket.classes.socketserver.ts
@ -0,0 +1,77 @@
+import * as plugins from './smartsocket.plugins';
+
+// used in case no other server is supplied
+import * as http from 'http';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export class SocketServer {
+  private smartsocket: Smartsocket;
+  private httpServer: http.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: plugins.smartexpress.Server
+  ) {
+    await serverArg.startedPromise;
+    this.httpServer = serverArg.httpServer;
+  }
+
+  /**
+   * gets the server for socket.io
+   */
+  public getServerForSocketIo() {
+    if (this.httpServer) {
+      return this.httpServer;
+    } else {
+      this.httpServer = new http.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) {
+        console.log('there should be a port specifed for smartsocket!');
+        throw new Error('there should be a port specified for smartsocket');
+      }
+      this.httpServer.listen(this.smartsocket.options.port, () => {
+        console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
+        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.helpers.ts
+++ b/ts/smartsocket.helpers.ts
@ -1,14 +0,0 @@
-import * as plugins from "./smartsocket.plugins";
-
-// classes
-import { Smartsocket } from "./smartsocket.classes.smartsocket";
-import { SocketFunction } from "./smartsocket.classes.socketfunction";
-import { SocketConnection } from "./smartsocket.classes.socketconnection";
-import { SocketRole, allSocketRoles } from "./smartsocket.classes.socketrole";
-
-
-// SocketRole helpers
-export let findSocketRoleByString = (socketRoleNameArg: string): SocketRole => {
-    return allSocketRoles.find((socketRoleArg) => { return socketRoleArg.name === socketRoleNameArg })
-};
-
--- a/ts/smartsocket.plugins.ts
+++ b/ts/smartsocket.plugins.ts
@ -1,8 +1,21 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export import lik  = require("lik");
-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");
+import * as lik from '@pushrocks/lik';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smarthash from '@pushrocks/smarthash';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as shortid from 'shortid';
+import socketIo from 'socket.io';
+import socketIoClient from 'socket.io-client';
+
+export {
+  lik,
+  smartlog,
+  smarthash,
+  smartdelay,
+  smartexpress,
+  smartpromise,
+  shortid,
+  socketIo,
+  socketIoClient
+};
--- 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	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
philkunz	983b4672fd	1.1.2	2016-08-16 04:48:47 +02:00
philkunz	c81a41b365	now authenticating sockets by checking the password hash	2016-08-16 04:48:42 +02:00
philkunz	abe4d22226	1.1.1	2016-08-15 03:47:36 +02:00
philkunz	87cc238345	update README	2016-08-15 03:47:32 +02:00
philkunz	475cd12904	1.1.0	2016-08-15 02:36:24 +02:00
philkunz	84f33fa447	now working in both directions so mesh setups work.	2016-08-15 02:36:17 +02:00
philkunz	180ae23c9a	1.0.7	2016-08-15 01:38:38 +02:00
philkunz	7f0fff0bf4	updated tests. Data now flows correctly between socket endpoints	2016-08-15 01:38:28 +02:00
philkunz	24310b6709	1.0.6	2016-08-14 22:18:09 +02:00
philkunz	bd8697ac6e	reconnect is now working	2016-08-14 22:17:55 +02:00
philkunz	7b2b2bd151	updated structure	2016-08-14 03:25:26 +02:00
PhilKunz	8dfc39be75	update tests	2016-08-12 05:57:32 +02:00
PhilKunz	ab2196fd5f	update tests: starting with updating tests to use both server and client side to mimic operation	2016-08-12 05:56:40 +02:00
PhilKunz	3afede95fc	now handling responses	2016-08-12 05:17:13 +02:00
PhilKunz	da510eb87a	more structure updates	2016-08-12 03:22:36 +02:00
PhilKunz	cb3d7f4d7b	update structure	2016-08-12 01:32:57 +02:00
PhilKunz	19a883c641	structure update	2016-08-09 23:37:25 +02:00
PhilKunz	1f8e1fc7cb	some heavy internal refactoring	2016-08-09 18:22:30 +02:00
PhilKunz	5109964247	some more logic request/response abstraction to make transparent function calls happen	2016-08-09 16:33:56 +02:00