1.1.4

starting with updating tests to use both server and client side to mimic operation

.gitignore

@@ -1,3 +1,4 @@
 node_modules/
 coverage/
-docs/
+pages/
+

README.md

@@ -1,8 +1,20 @@
 # smartsocket
 easy and secure websocket communication, Typescript ready
 
-## Status
+## Availabililty
+[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartsocket)
+[![git](https://push.rocks/assets/repo-button-git.svg)](https://gitlab.com/pushrocks/smartsocket)
+[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartsocket)
+[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smartsocket/docs)
+
+## 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)
+[![Dependency Status](https://david-dm.org/pushrocks/smartsocket.svg)](https://david-dm.org/pushrocks/smartsocket)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartsocket/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartsocket/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/smartsocket/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartsocket)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
 
 ## Usage
 We recommend the use of typescript.
@@ -21,16 +33,15 @@ let mySocketRole = new smartsocket.SocketRole({
     passwordHash: "someHashedString"
 });
 
-let mySocketFunction = new smartsocket.SocketFunction({
-    name:"newService",
-    func:(data) => {
+let testSocketFunction1 = new smartsocket.SocketFunction({
+    funcName:"testSocketFunction1",
+    funcDef:(data) => {
         
-    }, the function to execute
-    roles:[mySocketRole] // all roles that have access to a specific function
+    }, // the function to execute
+    allowedRoles:[mySocketRole] // all roles that have access to a specific function
 });
 
-mySmartsocket.registerRole(mySocketRole);
-mySmartsocket.clientCall.select("client1","restart",data)
+mySmartsocket.clientCall("","restart",data,someTargetConnection)
     .then((responseData) => {
 
     });
@@ -40,28 +51,38 @@ mySmartsocket.clientCall.select("client1","restart",data)
 ```typescript
 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"
+let testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: "http://localhost",
+    password: "testPassword",
+    alias: "testClient1",
+    role: "testRole1"
+});
+testSmartsocketClient.connect()
+    .then(() => {
+        done();
+    });
+
+let testSocketFunction2 = new smartsocket.SocketFunction({
+    funcName: "testSocketFunction2",
+    funcDef: (data) => {}, // the function to execute, has to return promise
+    allowedRoles:[]
 });
 
-let mySocketFunction2 = new smartsocket.SocketFunction({
-    name:"restart",
-    func:(data) => {}, the function to execute
-});
+let functionCalldata = {
+    funcName: "",
+    funcData: {
+        someKey:"someValue"
+    }
+}
 
-mySmartsocketClient.registerFunction(mySocketFunction2);
-
-mySmartsocketClient.serverCall("newService",data)
-    .then((responseData) => {
+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.  
+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.  

dist/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./smartsocket.classes.smartsocket";
 export * from "./smartsocket.classes.smartsocketclient";
+export * from "./smartsocket.classes.socketfunction";
+export * from "./smartsocket.classes.socketrole";
+export * from "./smartsocket.classes.socketconnection";

dist/index.js

@@ -2,6 +2,12 @@
 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"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsbUNBQW1DLENBQUMsRUFBQTtBQUNsRCxpQkFBYyx5Q0FBeUMsQ0FBQyxFQUFBIn0=
+// export further classes and objects
+__export(require("./smartsocket.classes.socketfunction"));
+__export(require("./smartsocket.classes.socketrole"));
+__export(require("./smartsocket.classes.socketconnection"));
+// need something more exposed? Create an issue on GitLab!
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsc0JBQXNCO0FBQ3RCLGlCQUFjLG1DQUFtQyxDQUFDLEVBQUE7QUFDbEQsaUJBQWMseUNBQXlDLENBQUMsRUFBQTtBQUV4RCxxQ0FBcUM7QUFDckMsaUJBQWMsc0NBQXNDLENBQUMsRUFBQTtBQUNyRCxpQkFBYyxrQ0FBa0MsQ0FBQyxFQUFBO0FBQ2pELGlCQUFjLHdDQUF3QyxDQUFDLEVBQUE7QUFFdkQsMERBQTBEIn0=

dist/smartsocket.classes.smartsocket.d.ts

@@ -1,29 +1,27 @@
 /// <reference types="socket.io" />
+/// <reference types="q" />
+import * as plugins from "./smartsocket.plugins";
 import { Objectmap } from "lik";
-import { SocketRole } from "./smartsocket.classes.socketrole";
-export interface ISocketObject {
-    alias?: string;
-    authenticated: boolean;
-    role?: string;
-    socket: SocketIO.Socket;
-}
+import { SocketConnection } from "./smartsocket.classes.socketconnection";
 export interface ISmartsocketConstructorOptions {
     port: number;
 }
 export declare class Smartsocket {
     options: ISmartsocketConstructorOptions;
     io: SocketIO.Server;
-    openSockets: Objectmap;
-    registeredRoles: Objectmap;
+    openSockets: Objectmap<SocketConnection>;
     constructor(optionsArg: ISmartsocketConstructorOptions);
     /**
      * the standard handler for new socket connections
      */
-    private _handleSocket(socket);
-    registerFunctions(socketRoleArg: SocketRole): void;
+    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<{}>;
 }

dist/smartsocket.classes.smartsocket.js

@@ -1,21 +1,20 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
-const helpers = require("./smartsocket.helpers");
 // 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();
-        this.registeredRoles = 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.io.on("connection", (socketArg) => {
+                this._handleSocketConnection(socketArg);
             });
         };
         this.closeServer = () => {
@@ -32,20 +31,46 @@ class Smartsocket {
     /**
      * the standard handler for new socket connections
      */
-    _handleSocket(socket) {
-        let socketObject = {
-            socket: socket,
-            authenticated: false
-        };
+    _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(socketObject);
-        helpers.authenticateSocket(socketObject)
-            .then();
-    }
-    registerFunctions(socketRoleArg) {
-        this.registeredRoles.add(socketRoleArg);
+        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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFDakQsTUFBWSxPQUFPLFdBQU0sdUJBQXVCLENBQUMsQ0FBQTtBQUVqRCxVQUFVO0FBQ1Ysc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBVS9CLENBQUM7QUFLRCxDQUFDO0FBRUY7SUFLSSxZQUFZLFVBQTBDO1FBRnRELGdCQUFXLEdBQUcsSUFBSSxlQUFTLEVBQUUsQ0FBQztRQUM5QixvQkFBZSxHQUFHLElBQUksZUFBUyxFQUFFLENBQUM7UUF3QmxDOztXQUVHO1FBRUgsZ0JBQVcsR0FBRztZQUNWLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzlDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxDQUFDLFNBQVM7Z0JBQy9CLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDbEMsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUE7UUFDRCxnQkFBVyxHQUFHO1lBQ1YsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxlQUE4QjtnQkFDcEQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsa0NBQWtDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO2dCQUNqRixlQUFlLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1lBQ0gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN4QixJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQTtRQXZDRyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM5QixDQUFDOztJQUVEOztPQUVHO0lBQ0ssYUFBYSxDQUFDLE1BQU07UUFDeEIsSUFBSSxZQUFZLEdBQWtCO1lBQzlCLE1BQU0sRUFBRSxNQUFNO1lBQ2QsYUFBYSxFQUFFLEtBQUs7U0FDdkIsQ0FBQztRQUNGLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLDZDQUE2QyxDQUFDLENBQUE7UUFDcEUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDbkMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLFlBQVksQ0FBQzthQUNuQyxJQUFJLEVBQUUsQ0FBQztJQUNoQixDQUFDO0lBRUQsaUJBQWlCLENBQUMsYUFBd0I7UUFDdEMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7QUFxQkwsQ0FBQztBQTlDWSxtQkFBVyxjQThDdkIsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.smartsocketclient.d.ts

@@ -1,10 +1,28 @@
+/// <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 {
-    constructor();
+    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<{}>;
 }

dist/smartsocket.classes.smartsocketclient.js

@@ -1,7 +1,74 @@
 "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() {
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldGNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXRjbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVVBO0lBQ0k7SUFFQSxDQUFDO0FBQ0wsQ0FBQztBQUpZLHlCQUFpQixvQkFJN0IsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.socketconnection.d.ts

@@ -0,0 +1,48 @@
+/// <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<{}>;
+}

dist/smartsocket.classes.socketconnection.js

@@ -0,0 +1,105 @@
+"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,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

dist/smartsocket.classes.socketfunction.d.ts

@@ -1,12 +1,46 @@
+/// <reference types="q" />
+import * as plugins from "./smartsocket.plugins";
+import { Objectmap } from "lik";
 import { SocketRole } from "./smartsocket.classes.socketrole";
-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: 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;
-    func: any;
+    funcDef: IFuncDef;
     roles: SocketRole[];
-    constructor(optionsArg: SocketFunctionOptions);
+    /**
+     * 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>;
 }

dist/smartsocket.classes.socketfunction.js

@@ -1,12 +1,57 @@
 "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.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
+        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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVlDLENBQUM7QUFFRjtJQUlJLFlBQVksVUFBaUM7UUFDekMsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDO1FBQzVCLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsS0FBSyxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUM7SUFDbEMsQ0FBQzs7QUFDTCxDQUFDO0FBVFksc0JBQWMsaUJBUzFCLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFFakQsaUJBQWlCO0FBQ2pCLHNCQUEwQixLQUFLLENBQUMsQ0FBQTtBQVkvQixDQUFDO0FBUUQsQ0FBQztBQVNGLGlCQUFpQjtBQUNOLDBCQUFrQixHQUFHLElBQUksZUFBUyxFQUFrQixDQUFDO0FBRWhFLGlCQUFpQjtBQUVqQjs7R0FFRztBQUNIO0lBS0k7O09BRUc7SUFDSCxZQUFZLFVBQTZDO1FBQ3JELElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUNoQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQ3JDLEdBQUcsQ0FBQyxDQUFDLElBQUksYUFBYSxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQSxDQUFDO1lBQ2xDLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDcEMsQ0FBQztRQUFBLENBQUM7UUFDRiwwQkFBa0IsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyw4QkFBOEI7SUFDaEUsQ0FBQzs7SUFFRDs7T0FFRztJQUNLLFdBQVcsQ0FBQyxhQUF3QjtRQUN4QyxhQUFhLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLE9BQTJCO1FBQzlCLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsRUFBRSxDQUFBLENBQUMsT0FBTyxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUEsQ0FBQztZQUMvQixJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUM7aUJBQzVCLElBQUksQ0FBQyxDQUFDLFVBQWM7Z0JBQ2pCLElBQUksZ0JBQWdCLEdBQXVCO29CQUN2QyxRQUFRLEVBQUMsSUFBSSxDQUFDLElBQUk7b0JBQ2xCLFdBQVcsRUFBQyxVQUFVO2lCQUN6QixDQUFBO2dCQUNELElBQUksQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQztRQUVYLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLE1BQU0sSUFBSSxLQUFLLENBQUMsK0RBQStELENBQUMsQ0FBQztRQUNyRixDQUFDO1FBQ0QsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDeEIsQ0FBQzs7QUFFTCxDQUFDO0FBOUNZLHNCQUFjLGlCQThDMUIsQ0FBQSJ9

dist/smartsocket.classes.socketrequest.d.ts

@@ -0,0 +1,46 @@
+/// <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;
+}

dist/smartsocket.classes.socketrequest.js

@@ -0,0 +1,64 @@
+"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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

dist/smartsocket.classes.socketrole.d.ts

@@ -1,3 +1,6 @@
+import { Objectmap } from "lik";
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+export declare let allSocketRoles: Objectmap<SocketRole>;
 /**
  * interface for class SocketRole
  */
@@ -11,5 +14,7 @@ export interface SocketRoleOptions {
 export declare class SocketRole {
     name: string;
     passwordHash: string;
+    allowedFunctions: Objectmap<SocketFunction>;
     constructor(optionsArg: SocketRoleOptions);
+    addSocketFunction(socketFunctionArg: SocketFunction): void;
 }

dist/smartsocket.classes.socketrole.js

@@ -1,12 +1,21 @@
 "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFjQTs7R0FFRztBQUNIO0lBR0ksWUFBWSxVQUE0QjtRQUNwQyxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO0lBQ2hELENBQUM7QUFDTCxDQUFDO0FBUFksa0JBQVUsYUFPdEIsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFFQSxpQkFBaUI7QUFDakIsc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBSXJCLHNCQUFjLEdBQUcsSUFBSSxlQUFTLEVBQWMsQ0FBQztBQVd4RDs7R0FFRztBQUNIO0lBSUksWUFBWSxVQUE2QjtRQUR6QyxxQkFBZ0IsR0FBRyxJQUFJLGVBQVMsRUFBa0IsQ0FBQztRQUUvQyxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzVDLHNCQUFjLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUM7O0lBQ0QsaUJBQWlCLENBQUMsaUJBQWdDO1FBQzlDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNqRCxDQUFDO0FBQ0wsQ0FBQztBQVpZLGtCQUFVLGFBWXRCLENBQUEifQ==

dist/smartsocket.helpers.d.ts

@@ -1,7 +1,14 @@
-/// <reference types="q" />
-import * as plugins from "./smartsocket.plugins";
-import { ISocketObject } from "./smartsocket.classes.smartsocket";
+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;
 /**
- * authenticate a socket
+ * get corresponding Socketrequest instance by shortId
  */
-export declare let authenticateSocket: (socketObjectArg: ISocketObject) => plugins.q.Promise<{}>;
+export declare let getSocketRequestById: (shortIdArg: string, requestSide?: TSocketRequestSide) => SocketRequest;
+/**
+ * get corresponding SocketRole instance by name
+ */
+export declare let getSocketRoleByName: (socketRoleNameArg: string) => SocketRole;

dist/smartsocket.helpers.js

@@ -1,28 +1,30 @@
 "use strict";
 const plugins = require("./smartsocket.plugins");
-/**
- * authenticate a socket
- */
-exports.authenticateSocket = (socketObjectArg) => {
-    let done = plugins.q.defer();
-    socketObjectArg.socket.on("dataAuth", dataArg => {
-        plugins.beautylog.log("received authentication data. now hashing and comparing...");
-        socketObjectArg.socket.removeListener("dataAuth", () => { });
-        if ((true)) {
-            socketObjectArg.alias = dataArg.alias;
-            socketObjectArg.authenticated = true;
-            socketObjectArg.role = dataArg.role;
-            socketObjectArg.socket.emit("authenticated");
-            plugins.beautylog.ok(`socket with >>alias ${socketObjectArg.alias} >>role ${socketObjectArg.role} is authenticated!`);
-            done.resolve(socketObjectArg);
-        }
-        else {
-            socketObjectArg.socket.disconnect();
-            done.reject("not authenticated");
-        }
-        ;
-    });
-    socketObjectArg.socket.emit("requestAuth");
-    return done.promise;
+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;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFRakQ7O0dBRUc7QUFDUSwwQkFBa0IsR0FBRyxDQUFDLGVBQThCO0lBQzNELElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDN0IsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxFQUFFLE9BQU87UUFDekMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsNERBQTRELENBQUMsQ0FBQztRQUNwRixlQUFlLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUM3RCxFQUFFLENBQUEsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUEsQ0FBQztZQUNQLGVBQWUsQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQTtZQUNyQyxlQUFlLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQztZQUNyQyxlQUFlLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUM7WUFDcEMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDN0MsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsdUJBQXVCLGVBQWUsQ0FBQyxLQUFLLFdBQVcsZUFBZSxDQUFDLElBQUksb0JBQW9CLENBQUMsQ0FBQTtZQUNySCxJQUFJLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ2xDLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLGVBQWUsQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDcEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1FBQ3JDLENBQUM7UUFBQSxDQUFDO0lBQ04sQ0FBQyxDQUFDLENBQUM7SUFDSCxlQUFlLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUMzQyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztBQUN4QixDQUFDLENBQUMifQ==
+// 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

dist/smartsocket.plugins.d.ts

@@ -1,7 +1,9 @@
 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");

dist/smartsocket.plugins.js

@@ -2,8 +2,10 @@
 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixnQkFBUSxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2hDLHNCQUFjLFdBQVcsa0JBQWtCLENBQUMsQ0FBQztBQUM3QyxrQkFBVSxXQUFXLFlBQVksQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLGdCQUFRLFdBQVcsVUFBVSxDQUFDLENBQUM7QUFDL0IsU0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDO0FBQ2pCLGVBQU8sV0FBVyxTQUFTLENBQUMsQ0FBQztBQUM3QixnQkFBUSxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2hDLHNCQUFjLFdBQVcsa0JBQWtCLENBQUMsQ0FBQztBQUM3QyxrQkFBVSxXQUFXLFlBQVksQ0FBQyxDQUFDIn0=

docs/book.json

@@ -0,0 +1,15 @@
+{
+    "structure": {
+        "readme": "index.md"
+    },
+    "plugins": [
+        "tonic",
+        "edit-link"
+    ],
+    "pluginsConfig": {
+        "edit-link": {
+            "base": "https://gitlab.com/pushrocks/npmts/edit/master/docs/",
+            "label": "Edit on GitLab"
+        }
+    }
+}

docs/index.md

@@ -0,0 +1,88 @@
+# smartsocket
+easy and secure websocket communication, Typescript ready
+
+## Availabililty
+[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartsocket)
+[![git](https://push.rocks/assets/repo-button-git.svg)](https://gitlab.com/pushrocks/smartsocket)
+[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartsocket)
+[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smartsocket/docs)
+
+## 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)
+[![Dependency Status](https://david-dm.org/pushrocks/smartsocket.svg)](https://david-dm.org/pushrocks/smartsocket)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartsocket/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartsocket/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/smartsocket/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartsocket)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+
+## Usage
+We recommend the use of typescript.
+Under the hood we use socket.io and shortid for managed data exchange.
+
+### Serverside
+```typescript
+import * as smartsocket from "smartsocket";
+
+let mySmartsocket = new smartsocket.Smartsocket({
+    port: 3000 // the port smartsocket will listen on
+});
+
+let mySocketRole = new smartsocket.SocketRole({
+    name: "someRoleName",
+    passwordHash: "someHashedString"
+});
+
+let testSocketFunction1 = new smartsocket.SocketFunction({
+    funcName:"testSocketFunction1",
+    funcDef:(data) => {
+        
+    }, // the function to execute
+    allowedRoles:[mySocketRole] // all roles that have access to a specific function
+});
+
+mySmartsocket.clientCall("","restart",data,someTargetConnection)
+    .then((responseData) => {
+
+    });
+```
+
+#### Client side
+```typescript
+import * as smartsocket from "smartsocket";
+
+let testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: "http://localhost",
+    password: "testPassword",
+    alias: "testClient1",
+    role: "testRole1"
+});
+testSmartsocketClient.connect()
+    .then(() => {
+        done();
+    });
+
+let testSocketFunction2 = new smartsocket.SocketFunction({
+    funcName: "testSocketFunction2",
+    funcDef: (data) => {}, // the function to execute, has to return promise
+    allowedRoles:[]
+});
+
+let functionCalldata = {
+    funcName: "",
+    funcData: {
+        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.  
+`data` is always a js object that you can design for your specific needs.  
+It supports buffers for large binary data network exchange.  

npmextra.json

@@ -0,0 +1,5 @@
+{
+    "npmts":{
+        "coverageTreshold":50
+    }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartsocket",
-  "version": "1.0.4",
+  "version": "1.1.4",
   "description": "easy and secure websocket communication, Typescript ready",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,18 +19,21 @@
   "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.10",
+    "beautylog": "^5.0.23",
+    "lik": "^1.0.15",
+    "nodehash": "^1.0.4",
     "q": "^1.4.1",
+    "shortid": "^2.2.6",
     "socket.io": "^1.4.8",
     "socket.io-client": "^1.4.8",
-    "taskbuffer": "^1.0.7"
+    "taskbuffer": "^1.0.8"
   },
   "devDependencies": {
     "npmts-g": "^5.2.8",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
+    "should": "^11.1.0",
+    "typings-test": "^1.0.2"
   }
 }

test/test.js

@@ -1,37 +1,105 @@
 "use strict";
 require("typings-test");
 require("should");
-const socketIoClient = require("socket.io-client");
 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 () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
+    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();
+        });
     });
-    it("should register a new Function", function () {
+    describe("class SocketRole", function () {
+        testSocketRole1 = new smartsocket.SocketRole({
+            name: "testRole1",
+            passwordHash: nodehash.sha256FromStringSync("testPassword")
+        });
     });
-    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"
+    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]
             });
-            socket.on("authenticated", () => {
-                console.log("client is authenticated");
+        });
+    });
+    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();
             });
         });
     });
-    it("should close the server", function () {
-        testSmartsocket.closeServer();
+    describe("terminating smartsocket", function () {
+        it("should close the server", function () {
+            testSmartsocket.closeServer();
+        });
     });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUNoQixNQUFPLGNBQWMsV0FBVyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3BELE1BQU8sV0FBVyxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTlDLElBQUksZUFBd0MsQ0FBQztBQUU3QyxRQUFRLENBQUMsYUFBYSxFQUFFO0lBQ3BCLEVBQUUsQ0FBQyxpQ0FBaUMsRUFBRTtRQUNsQyxlQUFlLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDLENBQUMsQ0FBQztJQUNILEVBQUUsQ0FBQyxnQ0FBZ0MsRUFBQztJQUVwQyxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQyxnREFBZ0QsRUFBQztRQUNoRCxlQUFlLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbEMsQ0FBQyxDQUFDLENBQUE7SUFDRixFQUFFLENBQUMsNENBQTRDLEVBQUUsVUFBVSxJQUFJO1FBQzNELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEIsSUFBSSxNQUFNLEdBQUcsY0FBYyxDQUFDLHVCQUF1QixFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3pELE1BQU0sQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUMvQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRTtnQkFDcEIsSUFBSSxFQUFFLG1CQUFtQjtnQkFDekIsUUFBUSxFQUFFLGNBQWM7Z0JBQ3hCLEtBQUssRUFBRSxXQUFXO2FBQ3JCLENBQUMsQ0FBQztZQUNILE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxFQUFDO2dCQUN0QixPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixDQUFDLENBQUM7Z0JBQ3ZDLElBQUksRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ0gsRUFBRSxDQUFDLHlCQUF5QixFQUFDO1FBQ3pCLGVBQWUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

test/test.ts

@@ -2,37 +2,108 @@ import "typings-test";
 import "should";
 import socketIoClient = require("socket.io-client");
 import smartsocket = require("../dist/index");
+import q = require("q");
+import nodehash = require("nodehash");
 
 let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketRole1: smartsocket.SocketRole;
+let testSocketFunction1:smartsocket.SocketFunction;
+
+let testConfig = {
+    port: 3000
+}
 
 describe("smartsocket", function () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
+    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();
+        });
     });
-    it("should register a new Function",function(){
-        
+    describe("class SocketRole", function(){
+        testSocketRole1 = new smartsocket.SocketRole({
+            name:"testRole1",
+            passwordHash:nodehash.sha256FromStringSync("testPassword")
+        })
     })
-    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();
+    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]
             });
         });
     });
-    it("should close the server",function(){
-        testSmartsocket.closeServer();
+    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();
+        });
     })
 });

ts/index.ts

@@ -1,4 +1,12 @@
 import * as plugins from "./smartsocket.plugins";
 
+// 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";
+
+// need something more exposed? Create an issue on GitLab!

ts/smartsocket.classes.smartsocket.ts

@@ -3,27 +3,19 @@ import * as helpers from "./smartsocket.helpers";
 
 // classes
 import { Objectmap } from "lik";
-import {SocketRole} from "./smartsocket.classes.socketrole";
-import {SocketFunction} from "./smartsocket.classes.socketfunction";
-
-
-export interface ISocketObject {
-    alias?:string;
-    authenticated: boolean
-    role?:string,
-    socket: SocketIO.Socket,
-};
+import { SocketFunction,ISocketFunctionCall} from "./smartsocket.classes.socketfunction";
+import { SocketConnection } from "./smartsocket.classes.socketconnection";
+import { SocketRequest } from "./smartsocket.classes.socketrequest";
+import { SocketRole } from "./smartsocket.classes.socketrole";
 
 export interface ISmartsocketConstructorOptions {
     port: number;
-
 };
 
 export class Smartsocket {
-    options:ISmartsocketConstructorOptions
+    options: ISmartsocketConstructorOptions
     io: SocketIO.Server;
-    openSockets = new Objectmap();
-    registeredRoles = new Objectmap();
+    openSockets = new Objectmap<SocketConnection>();
     constructor(optionsArg: ISmartsocketConstructorOptions) {
         this.options = optionsArg;
     };
@@ -31,38 +23,64 @@ export class Smartsocket {
     /**
      * the standard handler for new socket connections
      */
-    private _handleSocket(socket) {
-        let socketObject: ISocketObject = {
-            socket: socket,
-            authenticated: false
-        };
+    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(socketObject);
-        helpers.authenticateSocket(socketObject)
-            .then();
-    }
-
-    registerFunctions(socketRoleArg:SocketRole){
-        this.registeredRoles.add(socketRoleArg);
+        this.openSockets.add(socketConnection);
+        socketConnection.authenticate()
+            .then(() => {
+                return socketConnection.listenToFunctionRequests();
+            })
+            .catch((err) => {
+                console.log(err);
+            });
     };
 
-
     /**
      * starts listening to incling sockets:
      */
 
     startServer = () => {
         this.io = plugins.socketIo(this.options.port);
-        this.io.on('connection', (socketArg) => {
-            this._handleSocket(socketArg);
+        this.io.on("connection", (socketArg) => {
+            this._handleSocketConnection(socketArg);
         });
     }
     closeServer = () => {
-        this.openSockets.forEach((socketObjectArg: ISocketObject) => {
+        this.openSockets.forEach((socketObjectArg: SocketConnection) => {
             plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
             socketObjectArg.socket.disconnect();
         });
         this.openSockets.wipe();
         this.io.close();
+    };
+
+    // communication
+
+    /**
+     * allows call to specific client. 
+     */
+    clientCall(functionNameArg:string,dataArg:any,targetSocketConnectionArg:SocketConnection){
+        let done = plugins.q.defer();
+        let socketRequest = new SocketRequest({
+            side:"requesting",
+            originSocketConnection:targetSocketConnectionArg,
+            shortId:plugins.shortid.generate(),
+            funcCallData:{
+                funcName: functionNameArg,
+                funcDataArg:dataArg
+            }
+        });
+        socketRequest.dispatch()
+            .then((dataArg:ISocketFunctionCall) => {
+                done.resolve(dataArg.funcDataArg);
+            });
+        return done.promise;
     }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,15 +1,94 @@
 import * as plugins from "./smartsocket.plugins"
 
+
+// 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;
-    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(){
+    alias:string;
+    role:string;
+    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
+    };
 
+    /**
+     * 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 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:string,dataArg:any){
+        let done = plugins.q.defer();
+        let socketRequest = new SocketRequest({
+            side:"requesting",
+            originSocketConnection:this.socketConnection,
+            shortId:plugins.shortid.generate(),
+            funcCallData:{
+                funcName: functionNameArg,
+                funcDataArg:dataArg
+            }
+        });
+        socketRequest.dispatch()
+            .then((dataArg:ISocketFunctionCall) => {
+                done.resolve(dataArg.funcDataArg);
+            });
+        return done.promise;
+    };
+    
 }

ts/smartsocket.classes.socketconnection.ts

@@ -0,0 +1,136 @@
+import * as plugins from "./smartsocket.plugins";
+import * as helpers from "./smartsocket.helpers";
+
+import {Objectmap} from "lik";
+
+// import classes
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { SocketRequest, ISocketRequestDataObject, allSocketRequests } from "./smartsocket.classes.socketrequest";
+import { SocketRole } from "./smartsocket.classes.socketrole";
+
+// 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 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 classes
+export let allSocketConnections = new Objectmap<SocketConnection>();
+
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export class SocketConnection {
+    alias: string;
+    side:TSocketConnectionSide;
+    authenticated: boolean = false;
+    role: SocketRole;
+    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.socket = optionsArg.socket;
+        
+        // standard behaviour that is always true
+        allSocketConnections.add(this);
+        this.socket.on("disconnect", () => {
+            plugins.beautylog.info(`SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`);
+            allSocketConnections.remove(this);
+        });
+    };
+
+    // authenticating --------------------------
+
+    /**
+     * authenticate the socket
+     */
+    authenticate() {
+        let done = plugins.q.defer();
+        this.socket.on("dataAuth", (dataArg:ISocketConnectionAuthenticationObject) => {
+            plugins.beautylog.log("received authentication data. now hashing and comparing...");
+            this.socket.removeListener("dataAuth", () => { });
+            if (helpers.checkPasswordForRole(dataArg)) { // TODO: authenticate password
+                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: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";
+            plugins.beautylog.error(errMessage);
+            done.reject(errMessage);
+        };
+        return done.promise;
+    };
+
+    // sending ----------------------
+    
+};

ts/smartsocket.classes.socketfunction.ts

@@ -1,24 +1,87 @@
 import * as plugins from "./smartsocket.plugins";
 
 // import classes
-import { Stringmap } from "lik";
+import { Objectmap } from "lik";
 import { SocketRole } from "./smartsocket.classes.socketrole";
 
+// export interfaces
 
-
-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions {
+    funcName: string;
+    funcDef: any;
+    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 {
+    funcName:string;
+    funcDataArg:any;
+};
+
+/**
+ * interface for function definition of SocketFunction
+ */
+export interface IFuncDef {
+    (dataArg:any):PromiseLike<any>
+}
+
+// export objects
+export let allSocketFunctions = new Objectmap<SocketFunction>();
+
+// export classes
+
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
 export class SocketFunction {
     name: string;
-    func: any;
+    funcDef: IFuncDef;
     roles: SocketRole[];
-    constructor(optionsArg: SocketFunctionOptions) {
-        this.name = optionsArg.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
+
+    /**
+     * the constructor for SocketFunction
+     */
+    constructor(optionsArg: ISocketFunctionConstructorOptions) {
+        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
+     */
+    private _notifyRole(socketRoleArg:SocketRole){
+        socketRoleArg.addSocketFunction(this);
+    }
+    
+    /**
+     * 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;        
+    };
+
 }

ts/smartsocket.classes.socketrequest.ts

@@ -0,0 +1,96 @@
+import * as plugins from "./smartsocket.plugins";
+import * as helpers from "./smartsocket.helpers";
+
+// import interfaces
+import { ISocketFunctionCall } from "./smartsocket.classes.socketfunction";
+
+// import classes
+import { Objectmap } from "lik";
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { SocketConnection } from "./smartsocket.classes.socketconnection";
+
+// export interfaces
+export type TSocketRequestStatus = "new" | "pending" | "finished";
+export 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 objects
+export let allSocketRequests = new Objectmap<SocketRequest>();
+
+// export classes
+export class SocketRequest {
+    status: TSocketRequestStatus = "new";
+    side: TSocketRequestSide;
+    shortid: string;
+    originSocketConnection: SocketConnection;
+    funcCallData: ISocketFunctionCall
+    done = plugins.q.defer();
+    constructor(optionsArg: SocketRequestConstructorOptions) {
+        this.side = optionsArg.side;
+        this.shortid = optionsArg.shortId;
+        this.funcCallData = optionsArg.funcCallData;
+        this.originSocketConnection = optionsArg.originSocketConnection;
+        allSocketRequests.add(this);
+    };
+
+    // requesting --------------------------
+
+    /**
+     * 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
+     */
+    handleResponse(responseDataArg: ISocketRequestDataObject) {
+        plugins.beautylog.log("handling response!");
+        this.done.resolve(responseDataArg.funcCallData);
+        allSocketRequests.remove(this);
+    }
+
+    // responding --------------------------
+
+    /**
+     * creates the response on the responding side
+     */
+    createResponse() {
+        let targetSocketFunction: SocketFunction = 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: ISocketRequestDataObject = {
+                    funcCallData: resultData,
+                    shortId: this.shortid
+                };
+                this.originSocketConnection.socket.emit("functionResponse",requestData);
+                allSocketRequests.remove(this);
+            });
+    }
+};

ts/smartsocket.classes.socketrole.ts

@@ -1,25 +1,34 @@
 import * as plugins from "./smartsocket.plugins";
 
 // import classes
-import { Stringmap } from "lik";
+import { Objectmap } from "lik";
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+
+
+export let allSocketRoles = new Objectmap<SocketRole>();
+
 
 /**
  * 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;
-    constructor(optionsArg:SocketRoleOptions){
+    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);
     }
 }

ts/smartsocket.helpers.ts

@@ -1,31 +1,40 @@
 import * as plugins from "./smartsocket.plugins";
 
-// interfaces
-import {ISocketObject} from "./smartsocket.classes.smartsocket";
+// 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
 
 /**
- * authenticate a socket
+ * get corresponding Socketrequest instance by shortId
  */
-export let authenticateSocket = (socketObjectArg: ISocketObject) => {
-    let done = plugins.q.defer();
-    socketObjectArg.socket.on("dataAuth", dataArg => {
-        plugins.beautylog.log("received authentication data. now hashing and comparing...");
-        socketObjectArg.socket.removeListener("dataAuth", () => { });
-        if((true)){ // TODO: authenticate password
-            socketObjectArg.alias = dataArg.alias 
-            socketObjectArg.authenticated = true;
-            socketObjectArg.role = dataArg.role;
-            socketObjectArg.socket.emit("authenticated");
-            plugins.beautylog.ok(`socket with >>alias ${socketObjectArg.alias} >>role ${socketObjectArg.role} is authenticated!`)
-            done.resolve(socketObjectArg);
-        } else {
-            socketObjectArg.socket.disconnect();
-            done.reject("not authenticated");
-        };
-    });
-    socketObjectArg.socket.emit("requestAuth");
-    return done.promise;
-};
+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 })
+};
+

ts/smartsocket.plugins.ts

@@ -1,7 +1,9 @@
 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");