1.0.5

README.md

@@ -1,16 +1,17 @@
 # smartsocket
-easy and secure websocket communication
+easy and secure websocket communication, Typescript ready
 
 ## Status
 [![build status](https://gitlab.com/pushrocks/smartsocket/badges/master/build.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
 
 ## 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";
 
-import * as smartsocket from "smartsocket"
 let mySmartsocket = new smartsocket.Smartsocket({
     port: 3000 // the port smartsocket will listen on
 });
@@ -37,6 +38,8 @@ mySmartsocket.clientCall.select("client1","restart",data)
 
 #### Client side
 ```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
@@ -48,7 +51,6 @@ let mySmartsocketClient = new smartsocket.SmartsocketClient({
 let mySocketFunction2 = new smartsocket.SocketFunction({
     name:"restart",
     func:(data) => {}, the function to execute
-    roles: [mySocketRole] // all roles that have access to a specific function
 });
 
 mySmartsocketClient.registerFunction(mySocketFunction2);
@@ -57,4 +59,9 @@ mySmartsocketClient.serverCall("newService",data)
     .then((responseData) => {
         
     });;
-```
+```
+
+> **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.  

dist/index.d.ts

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

dist/index.js

@@ -3,4 +3,5 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 __export(require("./smartsocket.classes.smartsocket"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsbUNBQW1DLENBQUMsRUFBQSJ9
+__export(require("./smartsocket.classes.smartsocketclient"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsbUNBQW1DLENBQUMsRUFBQTtBQUNsRCxpQkFBYyx5Q0FBeUMsQ0FBQyxFQUFBIn0=

dist/smartsocket.classes.smartsocket.d.ts

@@ -1,19 +1,21 @@
 /// <reference types="socket.io" />
-/// <reference types="q" />
-import * as plugins from "./smartsocket.plugins";
 import { Objectmap } from "lik";
-export interface ISocketObject {
-    socket: SocketIO.Socket;
-    authenticated: boolean;
-}
+import { SocketConnection } from "./smartsocket.classes.socketconnection";
 export interface ISmartsocketConstructorOptions {
     port: number;
 }
 export declare class Smartsocket {
+    options: ISmartsocketConstructorOptions;
     io: SocketIO.Server;
-    openSockets: Objectmap;
-    constructor(options: ISmartsocketConstructorOptions);
-    startListening: any;
-    authenticateSocket(socketObjectArg: ISocketObject): plugins.q.Promise<{}>;
+    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;
 }

dist/smartsocket.classes.smartsocket.js

@@ -2,38 +2,45 @@
 const plugins = require("./smartsocket.plugins");
 // classes
 const lik_1 = require("lik");
+const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
 ;
 class Smartsocket {
-    constructor(options) {
+    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.io.close();
             this.openSockets.forEach((socketObjectArg) => {
+                plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
                 socketObjectArg.socket.disconnect();
             });
             this.openSockets.wipe();
+            this.io.close();
         };
-        this.io = plugins.socketIo(options.port);
-        this.io.on('connection', (socket) => {
-            let socketObject = {
-                socket: socket,
-                authenticated: false
-            };
-            this.openSockets.add(socketObject);
-            this.authenticateSocket(socketObject);
-        });
+        this.options = optionsArg;
     }
     ;
-    authenticateSocket(socketObjectArg) {
-        let done = plugins.q.defer();
-        socketObjectArg.socket.on("dataAuth", data => {
-            socketObjectArg.socket.removeListener("dataAuth", () => { });
-            done.resolve();
+    /**
+     * the standard handler for new socket connections
+     */
+    _handleSocket(socketArg) {
+        let socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
+            authenticated: false,
+            socket: socketArg
         });
-        socketObjectArg.socket.emit("requestAuth");
-        return done.promise;
+        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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFHakQsVUFBVTtBQUNWLHNCQUEwQixLQUFLLENBQUMsQ0FBQTtBQUsvQixDQUFDO0FBT0Y7SUFHSSxZQUFZLE9BQXVDO1FBRG5ELGdCQUFXLEdBQUcsSUFBSSxlQUFTLEVBQUUsQ0FBQztRQXNCOUIsZ0JBQVcsR0FBRztZQUNWLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxlQUE4QjtnQkFDcEQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUN4QyxDQUFDLENBQUMsQ0FBQztZQUNILElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDNUIsQ0FBQyxDQUFBO1FBMUJHLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsWUFBWSxFQUFFLENBQUMsTUFBTTtZQUM1QixJQUFJLFlBQVksR0FBa0I7Z0JBQzlCLE1BQU0sRUFBRSxNQUFNO2dCQUNkLGFBQWEsRUFBRSxLQUFLO2FBQ3ZCLENBQUM7WUFDRixJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQztZQUNuQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDMUMsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDOztJQUVELGtCQUFrQixDQUFDLGVBQThCO1FBQzdDLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxFQUFFLElBQUk7WUFDdEMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDN0QsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ25CLENBQUMsQ0FBQyxDQUFDO1FBQ0gsZUFBZSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDM0MsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDeEIsQ0FBQzs7QUFRTCxDQUFDO0FBL0JZLG1CQUFXLGNBK0J2QixDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFHakQsVUFBVTtBQUNWLHNCQUEwQixLQUFLLENBQUMsQ0FBQTtBQUdoQyx1REFBaUMsd0NBQXdDLENBQUMsQ0FBQTtBQUt6RSxDQUFDO0FBRUY7SUFJSSxZQUFZLFVBQTBDO1FBRHRELGdCQUFXLEdBQUcsSUFBSSxlQUFTLEVBQW9CLENBQUM7UUFtQmhEOztXQUVHO1FBRUgsZ0JBQVcsR0FBRztZQUNWLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzlDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxDQUFDLFNBQVM7Z0JBQy9CLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDbEMsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUE7UUFDRCxnQkFBVyxHQUFHO1lBQ1YsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxlQUFpQztnQkFDdkQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsa0NBQWtDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO2dCQUNqRixlQUFlLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1lBQ0gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN4QixJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQTtRQWxDRyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM5QixDQUFDOztJQUVEOztPQUVHO0lBQ0ssYUFBYSxDQUFDLFNBQVM7UUFDM0IsSUFBSSxnQkFBZ0IsR0FBc0IsSUFBSSx1REFBZ0IsQ0FBQztZQUMzRCxhQUFhLEVBQUMsS0FBSztZQUNuQixNQUFNLEVBQUMsU0FBUztTQUNuQixDQUFDLENBQUM7UUFDSCxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFBO1FBQ3BFLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDdkMsZ0JBQWdCLENBQUMsWUFBWSxFQUFFO2FBQzFCLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQ3pELENBQUM7O0FBb0JMLENBQUM7QUF4Q1ksbUJBQVcsY0F3Q3ZCLENBQUEifQ==

dist/smartsocket.classes.smartsocketclient.d.ts

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

dist/smartsocket.classes.smartsocketclient.js

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

dist/smartsocket.classes.socketconnection.d.ts

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

dist/smartsocket.classes.socketconnection.js

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

dist/smartsocket.classes.socketfunction.d.ts

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

dist/smartsocket.classes.socketfunction.js

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

dist/smartsocket.classes.socketrequest.d.ts

@@ -0,0 +1,18 @@
+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();
+}

dist/smartsocket.classes.socketrequest.js

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

dist/smartsocket.classes.socketrole.d.ts

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

dist/smartsocket.classes.socketrole.js

@@ -0,0 +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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFFQSxpQkFBaUI7QUFDakIsc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBSXJCLHNCQUFjLEdBQUcsSUFBSSxlQUFTLEVBQWMsQ0FBQztBQVd4RDs7R0FFRztBQUNIO0lBSUksWUFBWSxVQUE2QjtRQUR6QyxxQkFBZ0IsR0FBRyxJQUFJLGVBQVMsRUFBa0IsQ0FBQztRQUUvQyxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzVDLHNCQUFjLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUM7O0lBQ0QsaUJBQWlCLENBQUMsaUJBQWdDO1FBQzlDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNqRCxDQUFDO0FBQ0wsQ0FBQztBQVpZLGtCQUFVLGFBWXRCLENBQUEifQ==

dist/smartsocket.helpers.d.ts

@@ -0,0 +1,2 @@
+import { SocketRole } from "./smartsocket.classes.socketrole";
+export declare let findSocketRoleByString: (socketRoleNameArg: string) => SocketRole;

dist/smartsocket.helpers.js

@@ -1,2 +1,7 @@
 "use strict";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+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

dist/smartsocket.plugins.d.ts

@@ -2,5 +2,7 @@ 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");

dist/smartsocket.plugins.js

@@ -3,6 +3,8 @@ 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixnQkFBUSxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2hDLGtCQUFVLFdBQVcsWUFBWSxDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixlQUFPLFdBQVcsU0FBUyxDQUFDLENBQUM7QUFDN0IsZ0JBQVEsV0FBVyxXQUFXLENBQUMsQ0FBQztBQUNoQyxzQkFBYyxXQUFXLGtCQUFrQixDQUFDLENBQUM7QUFDN0Msa0JBQVUsV0FBVyxZQUFZLENBQUMsQ0FBQyJ9

package.json

@@ -1,7 +1,7 @@
 {
   "name": "smartsocket",
-  "version": "1.0.1",
-  "description": "easy and secure websocket communication",
+  "version": "1.0.5",
+  "description": "easy and secure websocket communication, Typescript ready",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -19,16 +19,19 @@
   "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.9",
+    "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"
   },
   "devDependencies": {
+    "npmts-g": "^5.2.8",
     "should": "^10.0.0",
     "typings-test": "^1.0.1"
   }

test/test.js

@@ -9,16 +9,29 @@ describe("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", {
-                secret: "hello"
+                role: "coreflowContainer",
+                password: "somePassword",
+                alias: "coreflow1"
+            });
+            socket.on("authenticated", () => {
+                console.log("client is authenticated");
+                done();
             });
-            done();
         });
     });
+    it("should close the server", function () {
+        testSmartsocket.closeServer();
+    });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUNoQixNQUFPLGNBQWMsV0FBVyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3BELE1BQU8sV0FBVyxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTlDLElBQUksZUFBd0MsQ0FBQztBQUU3QyxRQUFRLENBQUMsYUFBYSxFQUFFO0lBQ3BCLEVBQUUsQ0FBQyxpQ0FBaUMsRUFBRTtRQUNsQyxlQUFlLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDLENBQUMsQ0FBQztJQUNILEVBQUUsQ0FBQyw0Q0FBNEMsRUFBRSxVQUFVLElBQUk7UUFDM0QsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNwQixJQUFJLE1BQU0sR0FBRyxjQUFjLENBQUMsdUJBQXVCLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDekQsTUFBTSxDQUFDLEVBQUUsQ0FBQyxhQUFhLEVBQUU7WUFDckIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1lBQy9DLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFO2dCQUNwQixNQUFNLEVBQUUsT0FBTzthQUNsQixDQUFDLENBQUM7WUFDSCxJQUFJLEVBQUUsQ0FBQztRQUNYLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQyxDQUFDLENBQUE7QUFDTixDQUFDLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUNoQixNQUFPLGNBQWMsV0FBVyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3BELE1BQU8sV0FBVyxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTlDLElBQUksZUFBd0MsQ0FBQztBQUU3QyxRQUFRLENBQUMsYUFBYSxFQUFFO0lBQ3BCLEVBQUUsQ0FBQyxpQ0FBaUMsRUFBRTtRQUNsQyxlQUFlLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDLENBQUMsQ0FBQztJQUNILEVBQUUsQ0FBQyxnQ0FBZ0MsRUFBQztJQUVwQyxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQyxnREFBZ0QsRUFBQztRQUNoRCxlQUFlLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbEMsQ0FBQyxDQUFDLENBQUE7SUFDRixFQUFFLENBQUMsNENBQTRDLEVBQUUsVUFBVSxJQUFJO1FBQzNELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEIsSUFBSSxNQUFNLEdBQUcsY0FBYyxDQUFDLHVCQUF1QixFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3pELE1BQU0sQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUMvQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRTtnQkFDcEIsSUFBSSxFQUFFLG1CQUFtQjtnQkFDekIsUUFBUSxFQUFFLGNBQWM7Z0JBQ3hCLEtBQUssRUFBRSxXQUFXO2FBQ3JCLENBQUMsQ0FBQztZQUNILE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxFQUFDO2dCQUN0QixPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixDQUFDLENBQUM7Z0JBQ3ZDLElBQUksRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ0gsRUFBRSxDQUFDLHlCQUF5QixFQUFDO1FBQ3pCLGVBQWUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFDIn0=

test/test.ts

@@ -10,15 +10,29 @@ describe("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", {
-                secret: "hello"
+                role: "coreflowContainer",
+                password: "somePassword",
+                alias: "coreflow1"
+            });
+            socket.on("authenticated",() => {
+                console.log("client is authenticated");
+                done();
             });
-            done();
         });
+    });
+    it("should close the server",function(){
+        testSmartsocket.closeServer();
     })
 });

ts/smartsocket.classes.smartsocket.ts

@@ -3,48 +3,53 @@ import * as helpers from "./smartsocket.helpers";
 
 // classes
 import { Objectmap } from "lik";
-
-export interface ISocketObject {
-    group?:string,
-    socket: SocketIO.Socket,
-    authenticated: boolean
-};
+import { SocketRole } from "./smartsocket.classes.socketrole";
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+import { SocketConnection } from "./smartsocket.classes.socketconnection";
 
 export interface ISmartsocketConstructorOptions {
     port: number;
 
-}
+};
 
 export class Smartsocket {
+    options: ISmartsocketConstructorOptions
     io: SocketIO.Server;
-    openSockets = new Objectmap();
-    constructor(options: ISmartsocketConstructorOptions) {
-        this.io = plugins.socketIo(options.port);
-        this.io.on('connection', this._handleSocket);
+    openSockets = new Objectmap<SocketConnection>();
+    constructor(optionsArg: ISmartsocketConstructorOptions) {
+        this.options = optionsArg;
     };
 
     /**
      * the standard handler for new socket connections
      */
-    private _handleSocket(socket) {
-        let socketObject: ISocketObject = {
-            socket: socket,
-            authenticated: false
-        };
-        this.openSockets.add(socketObject);
-        helpers.authenticateSocket(socketObject)
-            .then();
-    }
+    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);
+    };
 
-    registerGroup(string){
-        
-    }
+    /**
+     * starts listening to incling sockets:
+     */
 
+    startServer = () => {
+        this.io = plugins.socketIo(this.options.port);
+        this.io.on('connection', (socketArg) => {
+            this._handleSocket(socketArg);
+        });
+    }
     closeServer = () => {
-        this.io.close();
-        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();
     }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,15 +1,28 @@
 import * as plugins from "./smartsocket.plugins"
 
+
+// import interfaces
+import { ISocketFunctionRequestObject, ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
+
+// import classes
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+
 /**
  * interface for class SmartsocketClient
  */
 export interface ISmartsocketClientOptions {
-    port:number;
-    url:string;
+    port: number;
+    url: string;
 }
 
 export class SmartsocketClient {
-    constructor(){
+    constructor() {
 
     }
+    dispatchFunctionRequest(dataArg:ISocketFunctionRequestObject): plugins.q.Promise<ISocketFunctionResponseObject> {
+        let done = plugins.q.defer<ISocketFunctionResponseObject>();
+        let responseData:ISocketFunctionResponseObject;
+        done.resolve(responseData);
+        return done.promise;
+    };
 }

ts/smartsocket.classes.socketconnection.ts

@@ -0,0 +1,91 @@
+import * as plugins from "./smartsocket.plugins";
+import * as helpers from "./smartsocket.helpers";
+
+// import classes
+import { SocketFunction, ISocketFunctionRequestObject } from "./smartsocket.classes.socketfunction";
+import { SocketRequest } from "./smartsocket.classes.socketrequest";
+import { SocketRole } from "./smartsocket.classes.socketrole";
+
+// export interfaces
+
+/**
+ * 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"
+}
+
+// export classes
+
+/**
+ * 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;
+    };
+
+    /**
+     * 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");
+                };
+            })
+        } else {
+            done.reject("socket needs to be authenticated first");
+        };
+        return done.promise;
+    }
+};

ts/smartsocket.classes.socketfunction.ts

@@ -0,0 +1,63 @@
+import * as plugins from "./smartsocket.plugins";
+
+// import classes
+import { Stringmap } from "lik";
+import { SocketRole } from "./smartsocket.classes.socketrole";
+
+// export interfaces
+
+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[]; // all roles that are allowed to execute a SocketFunction
+};
+
+// export classes
+
+/**
+ * class SocketFunction respresents a function that can be transparently called using a SocketConnection
+ */
+export class SocketFunction {
+    name: string;
+    func: any;
+    roles: SocketRole[];
+
+    /**
+     * 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);
+        }
+    };
+
+    /** 
+     * notifies a role about access to this SocketFunction
+     */
+    private _notifyRole(socketRoleArg:SocketRole){
+        socketRoleArg.addSocketFunction(this);
+    }
+    
+    /**
+     * invokes the function of this SocketFunction
+     */
+    invoke(dataArg:ISocketFunctionRequestObject){
+        
+    };
+
+}

ts/smartsocket.classes.socketrequest.ts

@@ -0,0 +1,43 @@
+import * as plugins from "./smartsocket.plugins";
+
+// import interfaces
+import { ISocketFunctionRequestObject, ISocketFunctionResponseObject } from "./smartsocket.classes.socketfunction";
+
+// import classes
+import { Objectmap } from "lik";
+import { SocketFunction } from "./smartsocket.classes.socketfunction";
+
+// export interfaces
+export type TSocketRequestStatus = "new" | "pending" | "finished";
+export type TSocketRequestSide = "requesting" | "responding";
+
+export interface SocketRequestConstructorOptions {
+    side: TSocketRequestSide;
+    shortid: string;
+};
+
+//export objects
+export let allRequestingSocketRequests = new Objectmap<SocketRequest>();
+export let allRespondingSocketRequests = new Objectmap<SocketRequest>();
+
+// 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){
+
+    }
+    private _dispatch(){ // note: dispatch is private as it will be fired from the constructor
+        
+    }
+};

ts/smartsocket.classes.socketrole.ts

@@ -1,10 +1,34 @@
 import * as plugins from "./smartsocket.plugins";
 
+// import classes
+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;
+}
+
 /**
  * A socketrole defines access to certain routines.
  */
-class Role {
-    constructor(){
-
+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);
     }
 }

ts/smartsocket.helpers.ts

@@ -1,20 +1,14 @@
 import * as plugins from "./smartsocket.plugins";
 
-// interfaces
-import {ISocketObject} from "./smartsocket.classes.smartsocket";
+// 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 })
+};
 
-
-/**
- * authenticate a socket
- */
-export let authenticateSocket = (socketObjectArg: ISocketObject) => {
-    let done = plugins.q.defer();
-    socketObjectArg.socket.on("dataAuth", data => {
-        socketObjectArg.socket.removeListener("dataAuth", () => { });
-        done.resolve();
-    });
-    socketObjectArg.socket.emit("requestAuth");
-    return done.promise;
-};

ts/smartsocket.plugins.ts

@@ -2,6 +2,7 @@ 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");