1.1.60

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
+dist_*/
-dist_serve/
-dist_ts_web/
 
 # custom

.gitlab-ci.yml

@@ -4,7 +4,7 @@ image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 cache:
   paths:
     - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+  key: '$CI_BUILD_STAGE'
 
 stages:
   - security
@@ -19,57 +19,71 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
+    - lossless
     - docker
     - notpriv
 
-snyk:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
-    - npmci command npm install -g snyk
+    - npmci command npm install --production --ignore-scripts
-    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command snyk test
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
     - docker
-  - notpriv
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=dev
+  tags:
+    - docker
+  allow_failure: true
 
 # ====================
 # test stage
 # ====================
 
-testLTS:
+testStable:
   stage: test
   script:
     - npmci npm prepare
-  - npmci node install lts
+    - npmci node install stable
     - npmci npm install
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
     - docker
-  - notpriv
 
 testBuild:
   stage: test
   script:
     - npmci npm prepare
-  - npmci node install lts
+    - npmci node install stable
     - npmci npm install
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
     - docker
-  - notpriv
 
 release:
   stage: release
   script:
-  - npmci node install lts
+    - npmci node install stable
     - npmci npm publish
   only:
     - tags
   tags:
+    - lossless
     - docker
     - notpriv
 
@@ -79,11 +93,15 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
     - npmci command npm install -g tslint typescript
+    - npmci npm prepare
     - npmci npm install
     - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
+    - lossless
     - docker
     - priv
 
@@ -94,20 +112,20 @@ trigger:
   only:
     - tags
   tags:
+    - lossless
     - docker
     - notpriv
 
 pages:
-  image: hosttoday/ht-docker-dbase:npmci
-  services:
-   - docker:18-dind
   stage: metadata
   script:
+    - npmci node install lts
     - npmci command npm install -g @gitzone/tsdoc
     - npmci npm prepare
     - npmci npm install
     - npmci command tsdoc
   tags:
+    - lossless
     - docker
     - notpriv
   only:

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

dist_ts/index.d.ts

@@ -0,0 +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_ts/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export main classes
+__exportStar(require("./smartsocket.classes.smartsocket"), exports);
+__exportStar(require("./smartsocket.classes.smartsocketclient"), exports);
+// export further classes and objects
+__exportStar(require("./smartsocket.classes.socketfunction"), exports);
+__exportStar(require("./smartsocket.classes.socketrole"), exports);
+__exportStar(require("./smartsocket.classes.socketconnection"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxzQkFBc0I7QUFDdEIsb0VBQWtEO0FBQ2xELDBFQUF3RDtBQUV4RCxxQ0FBcUM7QUFDckMsdUVBQXFEO0FBQ3JELG1FQUFpRDtBQUNqRCx5RUFBdUQifQ==

dist_ts/interfaces/connection.d.ts

@@ -0,0 +1,4 @@
+export interface IRequestAuthPayload {
+    serverShortId: string;
+}
+export declare type TConnectionStatus = 'new' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected';

dist_ts/interfaces/connection.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2ludGVyZmFjZXMvY29ubmVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

dist_ts/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './connection';

dist_ts/interfaces/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connection"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLCtDQUE2QiJ9

dist_ts/smartsocket.classes.smartsocket.d.ts

@@ -0,0 +1,45 @@
+import * as plugins from './smartsocket.plugins';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import * as SocketIO from 'socket.io';
+export interface ISmartsocketConstructorOptions {
+    port?: number;
+}
+export declare class Smartsocket {
+    /**
+     * a unique id to detect server restarts
+     */
+    shortId: string;
+    options: ISmartsocketConstructorOptions;
+    io: SocketIO.Server;
+    socketConnections: plugins.lik.ObjectMap<SocketConnection>;
+    socketRoles: plugins.lik.ObjectMap<SocketRole>;
+    socketFunctions: plugins.lik.ObjectMap<SocketFunction<any>>;
+    socketRequests: plugins.lik.ObjectMap<SocketRequest<any>>;
+    private socketServer;
+    constructor(optionsArg: ISmartsocketConstructorOptions);
+    setExternalServer(serverType: 'smartexpress', serverArg: any): Promise<void>;
+    /**
+     * starts smartsocket
+     */
+    start(): Promise<void>;
+    /**
+     * stops smartsocket
+     */
+    stop(): Promise<void>;
+    /**
+     * allows call to specific client.
+     */
+    clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(functionNameArg: T['method'], dataArg: T['request'], targetSocketConnectionArg: SocketConnection): Promise<T['response']>;
+    /**
+     * adds socketRoles
+     */
+    addSocketRoles(socketRolesArray: SocketRole[]): void;
+    addSocketFunction(socketFunction: SocketFunction<any>): void;
+    /**
+     * the standard handler for new socket connections
+     */
+    private _handleSocketConnection;
+}

dist_ts/smartsocket.classes.smartsocket.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Smartsocket = void 0;
+const plugins = __importStar(require("./smartsocket.plugins"));
+// classes
+const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
+const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
+const smartsocket_classes_socketserver_1 = require("./smartsocket.classes.socketserver");
+const smartsocket_logging_1 = require("./smartsocket.logging");
+class Smartsocket {
+    constructor(optionsArg) {
+        /**
+         * a unique id to detect server restarts
+         */
+        this.shortId = plugins.smartunique.shortId();
+        this.socketConnections = new plugins.lik.ObjectMap();
+        this.socketRoles = new plugins.lik.ObjectMap();
+        this.socketFunctions = new plugins.lik.ObjectMap();
+        this.socketRequests = new plugins.lik.ObjectMap();
+        this.socketServer = new smartsocket_classes_socketserver_1.SocketServer(this);
+        this.options = optionsArg;
+    }
+    // tslint:disable-next-line:member-ordering
+    async setExternalServer(serverType, serverArg) {
+        await this.socketServer.setExternalServer(serverType, serverArg);
+    }
+    /**
+     * starts smartsocket
+     */
+    async start() {
+        this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
+        await this.socketServer.start();
+        this.io.on('connection', socketArg => {
+            this._handleSocketConnection(socketArg);
+        });
+    }
+    /**
+     * stops smartsocket
+     */
+    async stop() {
+        await plugins.smartdelay.delayFor(1000);
+        this.socketConnections.forEach((socketObjectArg) => {
+            smartsocket_logging_1.logger.log('info', `disconnect socket with >>alias ${socketObjectArg.alias}`);
+            socketObjectArg.socket.disconnect();
+        });
+        this.socketConnections.wipe();
+        this.io.close();
+        // stop the corresponging server
+        this.socketServer.stop();
+    }
+    // communication
+    /**
+     * allows call to specific client.
+     */
+    async clientCall(functionNameArg, dataArg, targetSocketConnectionArg) {
+        const socketRequest = new smartsocket_classes_socketrequest_1.SocketRequest(this, {
+            funcCallData: {
+                funcDataArg: dataArg,
+                funcName: functionNameArg
+            },
+            originSocketConnection: targetSocketConnectionArg,
+            shortId: plugins.smartunique.shortId(),
+            side: 'requesting'
+        });
+        const response = await socketRequest.dispatch();
+        const result = response.funcDataArg;
+        return result;
+    }
+    /**
+     * adds socketRoles
+     */
+    addSocketRoles(socketRolesArray) {
+        for (const socketRole of socketRolesArray) {
+            this.socketRoles.add(socketRole);
+        }
+        return;
+    }
+    addSocketFunction(socketFunction) {
+        this.socketFunctions.add(socketFunction);
+    }
+    /**
+     * the standard handler for new socket connections
+     */
+    async _handleSocketConnection(socketArg) {
+        const socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
+            alias: undefined,
+            authenticated: false,
+            role: undefined,
+            side: 'server',
+            smartsocketHost: this,
+            socket: socketArg
+        });
+        smartsocket_logging_1.logger.log('info', 'Socket connected. Trying to authenticate...');
+        this.socketConnections.add(socketConnection);
+        await socketConnection.authenticate();
+        await socketConnection.listenToFunctionRequests();
+    }
+}
+exports.Smartsocket = Smartsocket;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/smartsocket.classes.smartsocketclient.d.ts

@@ -0,0 +1,53 @@
+import * as plugins from './smartsocket.plugins';
+import * as interfaces from './interfaces';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';
+/**
+ * interface for class SmartsocketClient
+ */
+export interface ISmartsocketClientOptions {
+    port: number;
+    url: string;
+    alias: string;
+    role: string;
+    password: string;
+    autoReconnect?: boolean;
+}
+export declare class SmartsocketClient {
+    shortId: string;
+    remoteShortId: string;
+    alias: string;
+    socketRole: SocketRole;
+    socketConnection: SocketConnection;
+    serverUrl: string;
+    serverPort: number;
+    autoReconnect: boolean;
+    eventSubject: plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>;
+    eventStatus: interfaces.TConnectionStatus;
+    socketFunctions: plugins.lik.ObjectMap<SocketFunction<any>>;
+    socketRequests: plugins.lik.ObjectMap<SocketRequest<any>>;
+    socketRoles: plugins.lik.ObjectMap<SocketRole>;
+    constructor(optionsArg: ISmartsocketClientOptions);
+    addSocketFunction(socketFunction: SocketFunction<any>): void;
+    /**
+     * connect the client to the server
+     */
+    connect(): Promise<unknown>;
+    /**
+     * disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * try a reconnection
+     */
+    tryDebouncedReconnect(): Promise<void>;
+    /**
+     * dispatches a server call
+     * @param functionNameArg
+     * @param dataArg
+     */
+    serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(functionNameArg: T['method'], dataArg: T['request']): Promise<T['response']>;
+    private updateStatus;
+}

dist_ts/smartsocket.classes.socketconnection.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="socket.io-client" />
+import * as plugins from './smartsocket.plugins';
+import * as interfaces from './interfaces';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+/**
+ * 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;
+    smartsocketHost: Smartsocket | SmartsocketClient;
+    socket: SocketIO.Socket | SocketIOClient.Socket;
+}
+/**
+ * interface for authentication data
+ */
+export interface ISocketConnectionAuthenticationObject {
+    role: 'coreflowContainer';
+    password: 'somePassword';
+    alias: 'coreflow1';
+}
+export declare let allSocketConnections: plugins.lik.ObjectMap<SocketConnection>;
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export declare class SocketConnection {
+    alias: string;
+    side: TSocketConnectionSide;
+    authenticated: boolean;
+    role: SocketRole;
+    smartsocketRef: Smartsocket | SmartsocketClient;
+    socket: SocketIO.Socket | SocketIOClient.Socket;
+    eventSubject: plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>;
+    eventStatus: interfaces.TConnectionStatus;
+    constructor(optionsArg: ISocketConnectionConstructorOptions);
+    /**
+     * authenticate the socket
+     */
+    authenticate(): Promise<unknown>;
+    /**
+     * listen to function requests
+     */
+    listenToFunctionRequests(): Promise<unknown>;
+    disconnect(): Promise<void>;
+    private updateStatus;
+}

dist_ts/smartsocket.classes.socketfunction.d.ts

@@ -0,0 +1,52 @@
+import * as plugins from './smartsocket.plugins';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDef: TFuncDef<T>;
+    allowedRoles: SocketRole[];
+}
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDataArg: T['request'];
+}
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDataArg: T['response'];
+}
+/**
+ * interface for function definition of SocketFunction
+ */
+export declare type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (dataArg: T['request'], connectionArg: SocketConnection) => PromiseLike<T['response']>;
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+export declare class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(smartsocketRefArg: Smartsocket | SmartsocketClient, functionNameArg: string): SocketFunction<Q>;
+    name: string;
+    funcDef: TFuncDef<T>;
+    roles: SocketRole[];
+    /**
+     * the constructor for SocketFunction
+     */
+    constructor(optionsArg: ISocketFunctionConstructorOptions<T>);
+    /**
+     * invokes the function of this SocketFunction
+     */
+    invoke(dataArg: ISocketFunctionCallDataRequest<T>, socketConnectionArg: SocketConnection): Promise<ISocketFunctionCallDataResponse<T>>;
+    /**
+     * notifies a role about access to this SocketFunction
+     */
+    private _notifyRole;
+}

dist_ts/smartsocket.classes.socketfunction.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketFunction = void 0;
+// export classes
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+class SocketFunction {
+    /**
+     * the constructor for SocketFunction
+     */
+    constructor(optionsArg) {
+        this.name = optionsArg.funcName;
+        this.funcDef = optionsArg.funcDef;
+        this.roles = optionsArg.allowedRoles;
+        for (const socketRoleArg of this.roles) {
+            this._notifyRole(socketRoleArg);
+        }
+    }
+    // STATIC
+    static getSocketFunctionByName(smartsocketRefArg, functionNameArg) {
+        return smartsocketRefArg.socketFunctions.find(socketFunctionArg => {
+            return socketFunctionArg.name === functionNameArg;
+        });
+    }
+    /**
+     * invokes the function of this SocketFunction
+     */
+    async invoke(dataArg, socketConnectionArg) {
+        if (dataArg.funcName === this.name) {
+            const funcResponseData = {
+                funcName: this.name,
+                funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg)
+            };
+            return funcResponseData;
+        }
+        else {
+            throw new Error("SocketFunction.name does not match the data argument's .name!");
+        }
+    }
+    /**
+     * notifies a role about access to this SocketFunction
+     */
+    _notifyRole(socketRoleArg) {
+        socketRoleArg.addSocketFunction(this);
+    }
+}
+exports.SocketFunction = SocketFunction;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBd0NBLGlCQUFpQjtBQUVqQjs7R0FFRztBQUNILE1BQWEsY0FBYztJQWdCekI7O09BRUc7SUFDSCxZQUFZLFVBQWdEO1FBQzFELElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUNoQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQ3JDLEtBQUssTUFBTSxhQUFhLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRTtZQUN0QyxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1NBQ2pDO0lBQ0gsQ0FBQztJQXpCRCxTQUFTO0lBQ0YsTUFBTSxDQUFDLHVCQUF1QixDQUNuQyxpQkFBa0QsRUFDbEQsZUFBdUI7UUFFdkIsT0FBTyxpQkFBaUIsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEVBQUU7WUFDaEUsT0FBTyxpQkFBaUIsQ0FBQyxJQUFJLEtBQUssZUFBZSxDQUFDO1FBQ3BELENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQW1CRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBMEMsRUFBRSxtQkFBcUM7UUFDbkcsSUFBSSxPQUFPLENBQUMsUUFBUSxLQUFLLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDbEMsTUFBTSxnQkFBZ0IsR0FBdUM7Z0JBQzNELFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSTtnQkFDbkIsV0FBVyxFQUFFLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsV0FBVyxFQUFFLG1CQUFtQixDQUFDO2FBQzFFLENBQUM7WUFDRixPQUFPLGdCQUFnQixDQUFDO1NBQ3pCO2FBQU07WUFDTCxNQUFNLElBQUksS0FBSyxDQUFDLCtEQUErRCxDQUFDLENBQUM7U0FDbEY7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxXQUFXLENBQUMsYUFBeUI7UUFDM0MsYUFBYSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hDLENBQUM7Q0FDRjtBQWpERCx3Q0FpREMifQ==

dist_ts/smartsocket.classes.socketrequest.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from './smartsocket.plugins';
+import { ISocketFunctionCallDataRequest, ISocketFunctionCallDataResponse } from './smartsocket.classes.socketfunction';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+export declare type TSocketRequestStatus = 'new' | 'pending' | 'finished';
+export declare type TSocketRequestSide = 'requesting' | 'responding';
+/**
+ * interface of constructor of class SocketRequest
+ */
+export interface ISocketRequestConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    side: TSocketRequestSide;
+    originSocketConnection: SocketConnection;
+    shortId: string;
+    funcCallData?: ISocketFunctionCallDataRequest<T>;
+}
+/**
+ * request object that is sent initially and may or may not receive a response
+ */
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
+    shortId: string;
+    responseTimeout?: number;
+}
+export declare class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    static getSocketRequestById(smartsocketRef: Smartsocket | SmartsocketClient, shortIdArg: string): SocketRequest<any>;
+    status: TSocketRequestStatus;
+    side: TSocketRequestSide;
+    shortid: string;
+    originSocketConnection: SocketConnection;
+    funcCallData: ISocketFunctionCallDataRequest<T>;
+    done: plugins.smartpromise.Deferred<ISocketFunctionCallDataResponse<T>>;
+    smartsocketRef: Smartsocket | SmartsocketClient;
+    constructor(smartsocketRefArg: Smartsocket | SmartsocketClient, optionsArg: ISocketRequestConstructorOptions<T>);
+    /**
+     * dispatches a socketrequest from the requesting to the receiving side
+     */
+    dispatch(): Promise<ISocketFunctionCallDataResponse<T>>;
+    /**
+     * handles the response that is received by the requesting side
+     */
+    handleResponse(responseDataArg: ISocketRequestDataObject<T>): Promise<void>;
+    /**
+     * creates the response on the responding side
+     */
+    createResponse(): Promise<void>;
+}

dist_ts/smartsocket.classes.socketrequest.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketRequest = void 0;
+const plugins = __importStar(require("./smartsocket.plugins"));
+// import interfaces
+const smartsocket_classes_socketfunction_1 = require("./smartsocket.classes.socketfunction");
+const smartsocket_logging_1 = require("./smartsocket.logging");
+// export classes
+class SocketRequest {
+    constructor(smartsocketRefArg, optionsArg) {
+        // INSTANCE
+        this.status = 'new';
+        this.done = plugins.smartpromise.defer();
+        this.smartsocketRef = smartsocketRefArg;
+        this.side = optionsArg.side;
+        this.shortid = optionsArg.shortId;
+        this.funcCallData = optionsArg.funcCallData;
+        this.originSocketConnection = optionsArg.originSocketConnection;
+        this.smartsocketRef.socketRequests.add(this);
+    }
+    // STATIC
+    static getSocketRequestById(smartsocketRef, shortIdArg) {
+        return smartsocketRef.socketRequests.find(socketRequestArg => {
+            return socketRequestArg.shortid === shortIdArg;
+        });
+    }
+    // requesting --------------------------
+    /**
+     * dispatches a socketrequest from the requesting to the receiving side
+     */
+    dispatch() {
+        const 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
+     */
+    async handleResponse(responseDataArg) {
+        smartsocket_logging_1.logger.log('info', 'handling response!');
+        this.done.resolve(responseDataArg.funcCallData);
+        this.smartsocketRef.socketRequests.remove(this);
+    }
+    // responding --------------------------
+    /**
+     * creates the response on the responding side
+     */
+    async createResponse() {
+        const targetSocketFunction = smartsocket_classes_socketfunction_1.SocketFunction.getSocketFunctionByName(this.smartsocketRef, this.funcCallData.funcName);
+        if (!targetSocketFunction) {
+            smartsocket_logging_1.logger.log('warn', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
+            smartsocket_logging_1.logger.log('warn', `So now response is being sent.`);
+            return;
+        }
+        smartsocket_logging_1.logger.log('info', `invoking ${targetSocketFunction.name}`);
+        targetSocketFunction.invoke(this.funcCallData, this.originSocketConnection).then(resultData => {
+            smartsocket_logging_1.logger.log('info', 'got resultData. Sending it to requesting party.');
+            const responseData = {
+                funcCallData: resultData,
+                shortId: this.shortid
+            };
+            this.originSocketConnection.socket.emit('functionResponse', responseData);
+            this.smartsocketRef.socketRequests.remove(this);
+        });
+    }
+}
+exports.SocketRequest = SocketRequest;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/smartsocket.classes.socketrole.d.ts

@@ -0,0 +1,28 @@
+import * as plugins from './smartsocket.plugins';
+import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';
+/**
+ * interface for class SocketRole
+ */
+export interface ISocketRoleOptions {
+    name: string;
+    passwordHash: string;
+}
+/**
+ * A socketrole defines access to certain routines.
+ */
+export declare class SocketRole {
+    static getSocketRoleByName(referenceSmartsocket: Smartsocket | SmartsocketClient, socketRoleNameArg: string): SocketRole;
+    static checkPasswordForRole(dataArg: ISocketConnectionAuthenticationObject, referenceSmartsocket: Smartsocket | SmartsocketClient): boolean;
+    name: string;
+    passwordHash: string;
+    allowedFunctions: plugins.lik.ObjectMap<SocketFunction<any>>;
+    constructor(optionsArg: ISocketRoleOptions);
+    /**
+     * adds the socketfunction to the socketrole
+     * @param socketFunctionArg
+     */
+    addSocketFunction(socketFunctionArg: SocketFunction<any>): void;
+}

dist_ts/smartsocket.classes.socketrole.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketRole = void 0;
+const plugins = __importStar(require("./smartsocket.plugins"));
+/**
+ * A socketrole defines access to certain routines.
+ */
+class SocketRole {
+    constructor(optionsArg) {
+        this.allowedFunctions = new plugins.lik.ObjectMap();
+        this.name = optionsArg.name;
+        this.passwordHash = optionsArg.passwordHash;
+    }
+    // STATIC
+    static getSocketRoleByName(referenceSmartsocket, socketRoleNameArg) {
+        return referenceSmartsocket.socketRoles.find(socketRoleArg => {
+            return socketRoleArg.name === socketRoleNameArg;
+        });
+    }
+    static checkPasswordForRole(dataArg, referenceSmartsocket) {
+        const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role)
+            .passwordHash;
+        const computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password);
+        return targetPasswordHash === computedCompareHash;
+    }
+    /**
+     * adds the socketfunction to the socketrole
+     * @param socketFunctionArg
+     */
+    addSocketFunction(socketFunctionArg) {
+        this.allowedFunctions.add(socketFunctionArg);
+    }
+}
+exports.SocketRole = SocketRole;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwrREFBaUQ7QUFnQmpEOztHQUVHO0FBQ0gsTUFBYSxVQUFVO0lBeUJyQixZQUFZLFVBQThCO1FBRG5DLHFCQUFnQixHQUFHLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxTQUFTLEVBQXVCLENBQUM7UUFFekUsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDO1FBQzVCLElBQUksQ0FBQyxZQUFZLEdBQUcsVUFBVSxDQUFDLFlBQVksQ0FBQztJQUM5QyxDQUFDO0lBM0JELFNBQVM7SUFDRixNQUFNLENBQUMsbUJBQW1CLENBQy9CLG9CQUFxRCxFQUNyRCxpQkFBeUI7UUFFekIsT0FBTyxvQkFBb0IsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxFQUFFO1lBQzNELE9BQU8sYUFBYSxDQUFDLElBQUksS0FBSyxpQkFBaUIsQ0FBQztRQUNsRCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTSxNQUFNLENBQUMsb0JBQW9CLENBQ2hDLE9BQThDLEVBQzlDLG9CQUFxRDtRQUVyRCxNQUFNLGtCQUFrQixHQUFHLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxvQkFBb0IsRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDO2FBQzFGLFlBQVksQ0FBQztRQUNoQixNQUFNLG1CQUFtQixHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3JGLE9BQU8sa0JBQWtCLEtBQUssbUJBQW1CLENBQUM7SUFDcEQsQ0FBQztJQVdEOzs7T0FHRztJQUNJLGlCQUFpQixDQUFDLGlCQUFzQztRQUM3RCxJQUFJLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDL0MsQ0FBQztDQUNGO0FBckNELGdDQXFDQyJ9

dist_ts/smartsocket.classes.socketserver.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import * as plugins from './smartsocket.plugins';
+import * as http from 'http';
+import * as https from 'https';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export declare class SocketServer {
+    private smartsocket;
+    private httpServer;
+    private standaloneServer;
+    private expressServer;
+    constructor(smartSocketInstance: Smartsocket);
+    /**
+     * starts the server with another server
+     * also works with an express style server
+     */
+    setExternalServer(serverType: 'smartexpress', serverArg: plugins.smartexpress.Server): Promise<void>;
+    /**
+     * gets the server for socket.io
+     */
+    getServerForSocketIo(): http.Server | https.Server;
+    /**
+     * starts listening to incoming sockets:
+     */
+    start(): Promise<void>;
+    /**
+     * closes the server
+     */
+    stop(): Promise<void>;
+}

dist_ts/smartsocket.classes.socketserver.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketServer = void 0;
+const plugins = __importStar(require("./smartsocket.plugins"));
+// used in case no other server is supplied
+const http = __importStar(require("http"));
+const smartsocket_logging_1 = require("./smartsocket.logging");
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+class SocketServer {
+    constructor(smartSocketInstance) {
+        // wether httpServer is standalone
+        this.standaloneServer = false;
+        this.smartsocket = smartSocketInstance;
+    }
+    /**
+     * starts the server with another server
+     * also works with an express style server
+     */
+    async setExternalServer(serverType, serverArg) {
+        await serverArg.startedPromise;
+        this.httpServer = serverArg.httpServer;
+    }
+    /**
+     * gets the server for socket.io
+     */
+    getServerForSocketIo() {
+        if (this.httpServer) {
+            return this.httpServer;
+        }
+        else {
+            this.httpServer = new http.Server();
+            this.standaloneServer = true;
+            return this.httpServer;
+        }
+    }
+    /**
+     * starts listening to incoming sockets:
+     */
+    async start() {
+        const done = plugins.smartpromise.defer();
+        // handle http servers
+        // in case an external server has been set "this.standaloneServer" should be false
+        if (this.httpServer && this.standaloneServer) {
+            if (!this.smartsocket.options.port) {
+                smartsocket_logging_1.logger.log('error', 'there should be a port specifed for smartsocket!');
+                throw new Error('there should be a port specified for smartsocket');
+            }
+            this.httpServer.listen(this.smartsocket.options.port, () => {
+                smartsocket_logging_1.logger.log('success', `Server started in standalone mode on ${this.smartsocket.options.port}`);
+                done.resolve();
+            });
+        }
+        else {
+            done.resolve();
+        }
+        // nothing else to do if express server is set
+        await done.promise;
+        return;
+    }
+    /**
+     * closes the server
+     */
+    async stop() { }
+}
+exports.SocketServer = SocketServer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRzZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHNvY2tldC5jbGFzc2VzLnNvY2tldHNlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0RBQWlEO0FBRWpELDJDQUEyQztBQUMzQywyQ0FBNkI7QUFHN0IsK0RBQStDO0FBRS9DOzs7R0FHRztBQUNILE1BQWEsWUFBWTtJQU92QixZQUFZLG1CQUFnQztRQUo1QyxrQ0FBa0M7UUFDMUIscUJBQWdCLEdBQUcsS0FBSyxDQUFDO1FBSS9CLElBQUksQ0FBQyxXQUFXLEdBQUcsbUJBQW1CLENBQUM7SUFDekMsQ0FBQztJQUVEOzs7T0FHRztJQUNJLEtBQUssQ0FBQyxpQkFBaUIsQ0FDNUIsVUFBMEIsRUFDMUIsU0FBc0M7UUFFdEMsTUFBTSxTQUFTLENBQUMsY0FBYyxDQUFDO1FBQy9CLElBQUksQ0FBQyxVQUFVLEdBQUcsU0FBUyxDQUFDLFVBQVUsQ0FBQztJQUN6QyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxvQkFBb0I7UUFDekIsSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ25CLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztTQUN4QjthQUFNO1lBQ0wsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNwQyxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDO1lBQzdCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztTQUN4QjtJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFMUMsc0JBQXNCO1FBQ3RCLGtGQUFrRjtRQUNsRixJQUFJLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFO1lBQzVDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUU7Z0JBQ2xDLDRCQUFNLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxrREFBa0QsQ0FBQyxDQUFDO2dCQUN4RSxNQUFNLElBQUksS0FBSyxDQUFDLGtEQUFrRCxDQUFDLENBQUM7YUFDckU7WUFDRCxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFO2dCQUN6RCw0QkFBTSxDQUFDLEdBQUcsQ0FBQyxTQUFTLEVBQUUsd0NBQXdDLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7Z0JBQy9GLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNqQixDQUFDLENBQUMsQ0FBQztTQUNKO2FBQU07WUFDTCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7U0FDaEI7UUFFRCw4Q0FBOEM7UUFDOUMsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDO1FBQ25CLE9BQU87SUFDVCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsSUFBSSxLQUFJLENBQUM7Q0FDdkI7QUFsRUQsb0NBa0VDIn0=

dist_ts/smartsocket.logging.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './smartsocket.plugins';
+export declare const logger: plugins.smartlog.ConsoleLog;

dist_ts/smartsocket.logging.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const plugins = __importStar(require("./smartsocket.plugins"));
+exports.logger = new plugins.smartlog.ConsoleLog();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQubG9nZ2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmxvZ2dpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtEQUFpRDtBQUVwQyxRQUFBLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUMifQ==

dist_ts/smartsocket.plugins.d.ts

@@ -0,0 +1,15 @@
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+export { typedrequestInterfaces };
+import * as lik from '@pushrocks/lik';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smarthash from '@pushrocks/smarthash';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartunique from '@pushrocks/smartunique';
+import * as smartrx from '@pushrocks/smartrx';
+export { lik, smartlog, smarthash, smartdelay, smartexpress, smartpromise, smarttime, smartunique, smartrx };
+import socketIo from 'socket.io';
+import socketIoClient from 'socket.io-client';
+export { socketIo, socketIoClient };

dist_ts/smartsocket.plugins.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketIoClient = exports.socketIo = exports.smartrx = exports.smartunique = exports.smarttime = exports.smartpromise = exports.smartexpress = exports.smartdelay = exports.smarthash = exports.smartlog = exports.lik = exports.typedrequestInterfaces = void 0;
+// apiglobal scope
+const typedrequestInterfaces = __importStar(require("@apiglobal/typedrequest-interfaces"));
+exports.typedrequestInterfaces = typedrequestInterfaces;
+// pushrocks scope
+const lik = __importStar(require("@pushrocks/lik"));
+exports.lik = lik;
+const smartlog = __importStar(require("@pushrocks/smartlog"));
+exports.smartlog = smartlog;
+const smarthash = __importStar(require("@pushrocks/smarthash"));
+exports.smarthash = smarthash;
+const smartdelay = __importStar(require("@pushrocks/smartdelay"));
+exports.smartdelay = smartdelay;
+const smartexpress = __importStar(require("@pushrocks/smartexpress"));
+exports.smartexpress = smartexpress;
+const smartpromise = __importStar(require("@pushrocks/smartpromise"));
+exports.smartpromise = smartpromise;
+const smarttime = __importStar(require("@pushrocks/smarttime"));
+exports.smarttime = smarttime;
+const smartunique = __importStar(require("@pushrocks/smartunique"));
+exports.smartunique = smartunique;
+const smartrx = __importStar(require("@pushrocks/smartrx"));
+exports.smartrx = smartrx;
+// third party scope
+const socket_io_1 = __importDefault(require("socket.io"));
+exports.socketIo = socket_io_1.default;
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+exports.socketIoClient = socket_io_client_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGtCQUFrQjtBQUNsQiwyRkFBNkU7QUFFckUsd0RBQXNCO0FBRTlCLGtCQUFrQjtBQUNsQixvREFBc0M7QUFZcEMsa0JBQUc7QUFYTCw4REFBZ0Q7QUFZOUMsNEJBQVE7QUFYVixnRUFBa0Q7QUFZaEQsOEJBQVM7QUFYWCxrRUFBb0Q7QUFZbEQsZ0NBQVU7QUFYWixzRUFBd0Q7QUFZdEQsb0NBQVk7QUFYZCxzRUFBd0Q7QUFZdEQsb0NBQVk7QUFYZCxnRUFBa0Q7QUFZaEQsOEJBQVM7QUFYWCxvRUFBc0Q7QUFZcEQsa0NBQVc7QUFYYiw0REFBOEM7QUFZNUMsMEJBQU87QUFHVCxvQkFBb0I7QUFDcEIsMERBQWlDO0FBSS9CLG1CQUpLLG1CQUFRLENBSUw7QUFIVix3RUFBOEM7QUFJNUMseUJBSkssMEJBQWMsQ0FJTCJ9

npmextra.json

@@ -1,5 +1,6 @@
 {
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package.json

@@ -1,12 +1,12 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.41",
+  "version": "1.1.60",
   "description": "easy and secure websocket communication",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "tstest test/",
+    "test": "(tstest test/)",
-    "build": "tsbuild"
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",
@@ -19,38 +19,43 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.10",
+    "@apiglobal/typedrequest-interfaces": "^1.0.15",
-    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/lik": "^4.0.17",
-    "@pushrocks/smartexpress": "^3.0.38",
+    "@pushrocks/smartdelay": "^2.0.10",
-    "@pushrocks/smarthash": "^2.0.6",
+    "@pushrocks/smartexpress": "^3.0.76",
-    "@pushrocks/smartlog": "^2.0.19",
+    "@pushrocks/smarthash": "^2.1.6",
-    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartlog": "^2.0.39",
-    "@types/shortid": "0.0.29",
+    "@pushrocks/smartpromise": "^3.0.6",
-    "@types/socket.io": "^2.1.2",
+    "@pushrocks/smartrx": "^2.0.19",
-    "@types/socket.io-client": "^1.4.32",
+    "@pushrocks/smartunique": "^3.0.3",
-    "shortid": "^2.2.14",
+    "@types/socket.io": "^2.1.11",
-    "socket.io": "^2.2.0",
+    "@types/socket.io-client": "^1.4.33",
-    "socket.io-client": "^2.2.0"
+    "socket.io": "^2.3.0",
+    "socket.io-client": "^2.3.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tsrun": "^1.2.12",
-    "@gitzone/tstest": "^1.0.24",
+    "@gitzone/tstest": "^1.0.44",
-    "@pushrocks/tapbundle": "^3.0.11",
+    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^12.7.1",
+    "@types/node": "^14.11.2",
-    "tslint": "^5.18.0",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "private": false,
   "files": [
-    "ts/*",
+    "ts/**/*",
-    "ts_web/*",
+    "ts_web/**/*",
-    "dist/*",
+    "dist/**/*",
-    "dist_web/*",
+    "dist_*/**/*",
-    "dist_ts_web/*",
+    "dist_ts/**/*",
-    "assets/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

test/test.expressserver.ts

@@ -11,11 +11,11 @@ import smartsocket = require('../ts/index');
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 
 const testConfig = {
-  port: 3000
+  port: 3000,
 };
 
 // class smartsocket
@@ -28,7 +28,7 @@ tap.test('Should accept an smartExpressServer as server', async () => {
   myseServer = new smartexpress.Server({
     cors: true,
     forceSsl: false,
-    port: testConfig.port
+    port: testConfig.port,
   });
 
   testSmartsocket.setExternalServer('smartexpress', myseServer);
@@ -40,7 +40,7 @@ tap.test('Should accept an smartExpressServer as server', async () => {
 tap.test('should add a socketrole', async () => {
   testSocketRole1 = new smartsocket.SocketRole({
     name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
+    passwordHash: smarthash.sha256FromStringSync('testPassword'),
   });
   testSmartsocket.addSocketRoles([testSocketRole1]);
 });
@@ -52,7 +52,7 @@ tap.test('should register a new Function', async () => {
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
-    funcName: 'testFunction1'
+    funcName: 'testFunction1',
   });
   testSmartsocket.addSocketFunction(testSocketFunction1);
   console.log(testSmartsocket.socketFunctions);
@@ -69,14 +69,14 @@ tap.test('should react to a new websocket connection from client', async () => {
     url: 'http://localhost',
     password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1'
+    role: 'testRole1',
   });
   testSmartsocketClient.addSocketFunction(testSocketFunction1);
   console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 
-tap.test('client should disconnect and reconnect', async tools => {
+tap.test('client should disconnect and reconnect', async (tools) => {
   await testSmartsocketClient.disconnect();
   await tools.delayFor(100);
   await testSmartsocketClient.connect();
@@ -88,14 +88,12 @@ tap.test('2 clients should connect in parallel', async () => {
 
 tap.test('should be able to make a functionCall from client to server', async () => {
   const response = await testSmartsocketClient.serverCall('testFunction1', {
-    value1: 'hello'
+    value1: 'hello',
   });
   console.log(response);
 });
 
-tap.test('should be able to make a functionCall from server to client', async () => {
+tap.test('should be able to make a functionCall from server to client', async () => {});
-  
-});
 
 // terminate
 tap.test('should close the server', async () => {

test/test.ts

@@ -9,11 +9,33 @@ import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketConnection: smartsocket.SocketConnection;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
+let testSocketFunctionClient: smartsocket.SocketFunction<any>;
+
+export interface IReqResClient {
+  method: 'testFunction1';
+  request: {
+    value1: string;
+  };
+  response: {
+    value1: string;
+  };
+}
+
+export interface IReqResServer {
+  method: 'testFunction2';
+  request: {
+    hi: string;
+  };
+  response: {
+    hi: string;
+  };
+}
 
 const testConfig = {
-  port: 3000
+  port: 3000,
 };
 
 // class smartsocket
@@ -26,21 +48,30 @@ tap.test('should create a new smartsocket', async () => {
 tap.test('should add a socketrole', async () => {
   testSocketRole1 = new smartsocket.SocketRole({
     name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
+    passwordHash: smarthash.sha256FromStringSync('testPassword'),
   });
   testSmartsocket.addSocketRoles([testSocketRole1]);
 });
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
     allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
-    funcName: 'testFunction1'
+    funcName: 'testFunction1',
   });
-  testSmartsocket.addSocketFunction(testSocketFunction1);
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    allowedRoles: [],
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction2',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
   console.log(testSmartsocket.socketFunctions);
 });
 
@@ -55,35 +86,43 @@ tap.test('should react to a new websocket connection from client', async () => {
     url: 'http://localhost',
     password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1'
+    role: 'testRole1',
   });
-  testSmartsocketClient.addSocketFunction(testSocketFunction1);
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
   console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 
-tap.test('client should disconnect and reconnect', async tools => {
-  await testSmartsocketClient.disconnect();
-  await tools.delayFor(100);
-  await testSmartsocketClient.connect();
-});
-
 tap.test('2 clients should connect in parallel', async () => {
   // TODO: implement parallel test
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  const response = await testSmartsocketClient.serverCall('testFunction1', {
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
-    value1: 'hello'
+    value1: 'hello',
   });
   console.log(response);
+  expect(response.value1).to.equal('hello');
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {
-  const response = await testSmartsocketClient.serverCall('testFunction1', {
+  const response = await testSmartsocket.clientCall<IReqResServer>(
-    hi: 'hi there from client'
+    'testFunction2',
-  });
+    {
+      hi: 'hi there from server',
+    },
+    testSmartsocket.socketConnections.find((socketConnection) => {
+      return true;
+    })
+  );
   console.log(response);
+  expect(response.hi).to.equal('hi there from server');
+});
+
+tap.test('client should disconnect and reconnect', async (tools) => {
+  await testSmartsocketClient.disconnect();
+  await tools.delayFor(100);
+  await testSmartsocketClient.connect();
 });
 
 // terminate

ts/index.ts

@@ -1,5 +1,3 @@
-import * as plugins from './smartsocket.plugins';
-
 // export main classes
 export * from './smartsocket.classes.smartsocket';
 export * from './smartsocket.classes.smartsocketclient';

ts/interfaces/connection.ts

@@ -0,0 +1,10 @@
+export interface IRequestAuthPayload {
+  serverShortId: string;
+}
+
+export type TConnectionStatus =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected';

ts/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './connection';

ts/smartsocket.classes.smartsocket.ts

@@ -1,27 +1,35 @@
 import * as plugins from './smartsocket.plugins';
 
 // classes
-import { Objectmap } from '@pushrocks/lik';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction';
 import { SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketServer } from './smartsocket.classes.socketserver';
 
 // socket.io
 import * as SocketIO from 'socket.io';
+import { logger } from './smartsocket.logging';
 
 export interface ISmartsocketConstructorOptions {
   port?: number;
 }
 
 export class Smartsocket {
+  /**
+   * a unique id to detect server restarts
+   */
+  public shortId = plugins.smartunique.shortId();
   public options: ISmartsocketConstructorOptions;
   public io: SocketIO.Server;
-  public openSockets = new Objectmap<SocketConnection>();
+  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
-  public socketRoles = new Objectmap<SocketRole>();
+  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
-  public socketFunctions = new Objectmap<SocketFunction>();
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
-  public socketRequests = new Objectmap<SocketRequest>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
 
   private socketServer = new SocketServer(this);
 
@@ -40,7 +48,7 @@ export class Smartsocket {
   public async start() {
     this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
     await this.socketServer.start();
-    this.io.on('connection', socketArg => {
+    this.io.on('connection', (socketArg) => {
       this._handleSocketConnection(socketArg);
     });
   }
@@ -50,14 +58,11 @@ export class Smartsocket {
    */
   public async stop() {
     await plugins.smartdelay.delayFor(1000);
-    this.openSockets.forEach((socketObjectArg: SocketConnection) => {
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', `disconnect socket with >>alias ${socketObjectArg.alias}`);
-        'info',
-        `disconnect socket with >>alias ${socketObjectArg.alias}`
-      );
       socketObjectArg.socket.disconnect();
     });
-    this.openSockets.wipe();
+    this.socketConnections.wipe();
     this.io.close();
 
     // stop the corresponging server
@@ -69,25 +74,22 @@ export class Smartsocket {
   /**
    * allows call to specific client.
    */
-  public async clientCall(
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
-    functionNameArg: string,
+    functionNameArg: T['method'],
-    dataArg: any,
+    dataArg: T['request'],
     targetSocketConnectionArg: SocketConnection
-  ) {
+  ): Promise<T['response']> {
-    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
-    const socketRequest = new SocketRequest(this, {
       funcCallData: {
         funcDataArg: dataArg,
-        funcName: functionNameArg
+        funcName: functionNameArg,
       },
       originSocketConnection: targetSocketConnectionArg,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.smartunique.shortId(),
-      side: 'requesting'
+      side: 'requesting',
     });
-    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
-      done.resolve(dataArg2.funcDataArg);
+    const result = response.funcDataArg;
-    });
-    const result = await done.promise;
     return result;
   }
 
@@ -101,31 +103,25 @@ export class Smartsocket {
     return;
   }
 
-  public addSocketFunction(socketFunction: SocketFunction) {
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
   }
 
   /**
    * the standard handler for new socket connections
    */
-  private _handleSocketConnection(socketArg) {
+  private async _handleSocketConnection(socketArg: plugins.socketIo.Socket) {
     const socketConnection: SocketConnection = new SocketConnection({
       alias: undefined,
       authenticated: false,
       role: undefined,
       side: 'server',
       smartsocketHost: this,
-      socket: socketArg
+      socket: socketArg,
-    });
-    plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
-    socketConnection
-      .authenticate()
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
     });
+    logger.log('info', 'Socket connected. Trying to authenticate...');
+    this.socketConnections.add(socketConnection);
+    await socketConnection.authenticate();
+    await socketConnection.listenToFunctionRequests();
   }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,9 +1,14 @@
 import * as plugins from './smartsocket.plugins';
+import * as interfaces from './interfaces';
 
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction';
 import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
+import { logger } from './smartsocket.logging';
 
 /**
  * interface for class SmartsocketClient
@@ -14,30 +19,45 @@ export interface ISmartsocketClientOptions {
   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
+  autoReconnect?: boolean;
 }
 
 export class SmartsocketClient {
+  // a unique id
+  public shortId = plugins.smartunique.shortId();
+
+  // the shortId of the remote we connect to
+  public remoteShortId: string = null;
+
   public alias: string;
-  public role: string;
+  public socketRole: SocketRole;
   public socketConnection: SocketConnection;
   public serverUrl: string;
   public serverPort: number;
-  public serverPassword: string;
+  public autoReconnect: boolean;
 
-  public socketFunctions = new plugins.lik.Objectmap<SocketFunction>();
+  // status handling
-  public socketRequests = new plugins.lik.Objectmap<SocketRequest>();
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
-  public socketRoles = new plugins.lik.Objectmap<SocketRole>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
 
   constructor(optionsArg: ISmartsocketClientOptions) {
     this.alias = optionsArg.alias;
-    this.role = optionsArg.role;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.serverPassword = optionsArg.password;
+    this.socketRole = new SocketRole({
+      name: optionsArg.role,
+      passwordHash: optionsArg.password,
+    });
+    this.autoReconnect = optionsArg.autoReconnect;
   }
 
-  public addSocketFunction(socketFunction: SocketFunction) {
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
+    this.socketRole.allowedFunctions.add(socketFunction);
   }
 
   /**
@@ -45,56 +65,131 @@ export class SmartsocketClient {
    */
   public connect() {
     const done = plugins.smartpromise.defer();
-    plugins.smartlog.defaultLogger.log('info', 'trying to connect...');
+    logger.log('info', 'trying to connect...');
     const socketUrl = `${this.serverUrl}:${this.serverPort}`;
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: undefined,
+      role: this.socketRole,
       side: 'client',
       smartsocketHost: this,
-      socket: plugins.socketIoClient(socketUrl, { multiplex: false })
+      socket: plugins.socketIoClient(socketUrl, {
+        multiplex: false,
+        reconnectionAttempts: 5,
+      }),
     });
-    this.socketConnection.socket.on('requestAuth', () => {
+
-      console.log('server requested authentication');
+    const timer = new plugins.smarttime.Timer(5000);
-      this.socketConnection.socket.emit('dataAuth', {
+    timer.start();
-        role: this.role,
+    timer.completed.then(() => {
-        password: this.serverPassword,
+      logger.log('warn', 'connection to server timed out.');
-        alias: this.alias
+      this.disconnect();
     });
+
+    // authentication flow
+    this.socketConnection.socket.on(
+      'requestAuth',
+      (requestAuthPayload: interfaces.IRequestAuthPayload) => {
+        timer.reset();
+        logger.log('info', 'server requested authentication');
+
+        // lets register the authenticated event
         this.socketConnection.socket.on('authenticated', () => {
-        console.log('client is authenticated');
+          this.remoteShortId = requestAuthPayload.serverShortId;
+          logger.log('info', 'client is authenticated');
           this.socketConnection.authenticated = true;
           this.socketConnection.listenToFunctionRequests();
           done.resolve();
         });
+
+        // lets register the forbidden event
+        this.socketConnection.socket.on('forbidden', async () => {
+          logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
+          await this.disconnect();
+        });
+
+        // lets provide the actual auth data
+        this.socketConnection.socket.emit('dataAuth', {
+          role: this.socketRole.name,
+          password: this.socketRole.passwordHash,
+          alias: this.alias,
+        });
+      }
+    );
+
+    // handle connection
+    this.socketConnection.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+
+    // handle disconnection and errors
+    this.socketConnection.socket.on('disconnect', async () => {
+      await this.disconnect();
+    });
+
+    this.socketConnection.socket.on('reconnect_failed', async () => {
+      await this.disconnect();
+    });
+    this.socketConnection.socket.on('connect_error', async () => {
+      await this.disconnect();
     });
     return done.promise;
   }
 
-  public disconnect() {
+  /**
-    const done = plugins.smartpromise.defer();
+   * disconnect from the server
-    this.socketConnection.socket.disconnect();
+   */
+  public async disconnect() {
+    if (this.socketConnection) {
+      await this.socketConnection.disconnect();
       this.socketConnection = undefined;
-    plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
+      logger.log('ok', 'disconnected!');
-    done.resolve();
+    }
-    return done.promise;
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
+    this.remoteShortId = null;
+    this.updateStatus('disconnected');
+
+    if (this.autoReconnect) {
+      this.tryDebouncedReconnect();
+    }
   }
 
-  public serverCall(functionNameArg: string, dataArg: any) {
+  /**
+   * try a reconnection
+   */
+  public async tryDebouncedReconnect() {
+    await plugins.smartdelay.delayForRandom(10000, 60000);
+    await this.connect();
+  }
+
+  /**
+   * dispatches a server call
+   * @param functionNameArg
+   * @param dataArg
+   */
+  public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request']
+  ): Promise<T['response']> {
     const done = plugins.smartpromise.defer();
-    const socketRequest = new SocketRequest(this, {
+    const socketRequest = new SocketRequest<T>(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.smartunique.shortId(),
       funcCallData: {
         funcName: functionNameArg,
-        funcDataArg: dataArg
+        funcDataArg: dataArg,
-      }
+      },
     });
-    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+    const response = await socketRequest.dispatch();
-      done.resolve(dataArg2.funcDataArg);
+    const result = response.funcDataArg;
-    });
+    return result;
-    return done.promise;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
   }
 }

ts/smartsocket.classes.socketconnection.ts

@@ -1,19 +1,16 @@
 import * as plugins from './smartsocket.plugins';
-
+import * as interfaces from './interfaces';
-import { Objectmap } from '@pushrocks/lik';
 
 // import classes
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
-import {
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
-  SocketRequest,
-  ISocketRequestDataObject,
-} from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
 import * as SocketIO from 'socket.io';
 import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { logger } from './smartsocket.logging';
 
 // export interfaces
 
@@ -44,7 +41,7 @@ export interface ISocketConnectionAuthenticationObject {
 }
 
 // export classes
-export let allSocketConnections = new Objectmap<SocketConnection>();
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
 
 /**
  * class SocketConnection represents a websocket connection
@@ -56,6 +53,10 @@ export class SocketConnection {
   public role: SocketRole;
   public smartsocketRef: Smartsocket | SmartsocketClient;
   public socket: SocketIO.Socket | SocketIOClient.Socket;
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;
@@ -66,12 +67,17 @@ export class SocketConnection {
 
     // standard behaviour that is always true
     allSocketConnections.add(this);
-    this.socket.on('disconnect', () => {
+
-      plugins.smartlog.defaultLogger.log(
+    // handle connection
+    this.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+    this.socket.on('disconnect', async () => {
+      logger.log(
         'info',
         `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
       );
-      this.socket.disconnect();
+      await this.disconnect();
       allSocketConnections.remove(this);
     });
   }
@@ -83,11 +89,8 @@ export class SocketConnection {
    */
   public authenticate() {
     const done = plugins.smartpromise.defer();
-    this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => {
+    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', 'received authentication data. now hashing and comparing...');
-        'info',
-        'received authentication data. now hashing and comparing...'
-      );
       this.socket.removeListener('dataAuth', () => {});
       if (SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
         // TODO: authenticate password
@@ -95,18 +98,18 @@ export class SocketConnection {
         this.authenticated = true;
         this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
         this.socket.emit('authenticated');
-        plugins.smartlog.defaultLogger.log(
+        logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
-          'ok',
-          `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`
-        );
         done.resolve(this);
       } else {
         this.authenticated = false;
-        this.socket.disconnect();
+        await this.disconnect();
         done.reject('not authenticated');
       }
     });
-    this.socket.emit('requestAuth');
+    const requestAuthPayload: interfaces.IRequestAuthPayload = {
+      serverShortId: this.smartsocketRef.shortId,
+    };
+    this.socket.emit('requestAuth', requestAuthPayload);
     return done.promise;
   }
 
@@ -118,50 +121,55 @@ export class SocketConnection {
   public listenToFunctionRequests() {
     const done = plugins.smartpromise.defer();
     if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
         // check if requested function is available to the socket's scope
-        plugins.smartlog.defaultLogger.log('info', 'function request received');
+        logger.log('info', 'function request received');
-        const referencedFunction: SocketFunction = this.role.allowedFunctions.find(
+        const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.find(
-          socketFunctionArg => {
+          (socketFunctionArg) => {
             return socketFunctionArg.name === dataArg.funcCallData.funcName;
           }
         );
-        if (referencedFunction !== undefined) {
+        if (referencedFunction) {
-          plugins.smartlog.defaultLogger.log('ok', 'function in access scope');
+          logger.log('ok', 'function in access scope');
           const localSocketRequest = new SocketRequest(this.smartsocketRef, {
             side: 'responding',
             originSocketConnection: this,
             shortId: dataArg.shortId,
-            funcCallData: dataArg.funcCallData
+            funcCallData: dataArg.funcCallData,
           });
           localSocketRequest.createResponse(); // takes care of creating response and sending it back
         } else {
-          plugins.smartlog.defaultLogger.log(
+          logger.log('warn', 'function not existent or out of access scope');
-            'warn',
-            'function not existent or out of access scope'
-          );
         }
       });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
-        plugins.smartlog.defaultLogger.log(
+        logger.log('info', `received response for request with id ${dataArg.shortId}`);
-          'info',
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
-          `received response for request with id ${dataArg.shortId}`
+          this.smartsocketRef,
+          dataArg.shortId
         );
-        const targetSocketRequest = SocketRequest.getSocketRequestById(this.smartsocketRef, dataArg.shortId);
         targetSocketRequest.handleResponse(dataArg);
       });
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', `now listening to function requests for ${this.alias}`);
-        'info',
-        `now listening to function requests for ${this.alias}`
-      );
       done.resolve(this);
     } else {
       const errMessage = 'socket needs to be authenticated first';
-      plugins.smartlog.defaultLogger.log('error', errMessage);
+      logger.log('error', errMessage);
       done.reject(errMessage);
     }
     return done.promise;
   }
 
-  // sending ----------------------
+  // disconnecting ----------------------
+  public async disconnect() {
+    this.socket.disconnect(true);
+    this.updateStatus('disconnected');
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
 }

ts/smartsocket.classes.socketfunction.ts

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

ts/smartsocket.classes.socketrequest.ts

@@ -1,12 +1,15 @@
 import * as plugins from './smartsocket.plugins';
 
 // import interfaces
-import { SocketFunction, ISocketFunctionCall } from './smartsocket.classes.socketfunction';
+import {
+  SocketFunction,
+  ISocketFunctionCallDataRequest,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction';
 
 // import classes
-import { Objectmap } from '@pushrocks/lik';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { defaultLogger } from '@pushrocks/smartlog';
+import { logger } from './smartsocket.logging';
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 
@@ -17,30 +20,32 @@ export type TSocketRequestSide = 'requesting' | 'responding';
 /**
  * interface of constructor of class SocketRequest
  */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
   side: TSocketRequestSide;
   originSocketConnection: SocketConnection;
   shortId: string;
-  funcCallData?: ISocketFunctionCall;
+  funcCallData?: ISocketFunctionCallDataRequest<T>;
 }
 
 /**
  * request object that is sent initially and may or may not receive a response
  */
-export interface ISocketRequestDataObject {
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  funcCallData: ISocketFunctionCall;
+  funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
   shortId: string;
   responseTimeout?: number;
 }
 
 // export classes
-export class SocketRequest {
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   // STATIC
   public static getSocketRequestById(
     smartsocketRef: Smartsocket | SmartsocketClient,
     shortIdArg: string
-  ): SocketRequest {
+  ): SocketRequest<any> {
-    return smartsocketRef.socketRequests.find(socketRequestArg => {
+    return smartsocketRef.socketRequests.find((socketRequestArg) => {
       return socketRequestArg.shortid === shortIdArg;
     });
   }
@@ -50,13 +55,15 @@ export class SocketRequest {
   public side: TSocketRequestSide;
   public shortid: string;
   public originSocketConnection: SocketConnection;
-  public funcCallData: ISocketFunctionCall;
+  public funcCallData: ISocketFunctionCallDataRequest<T>;
-  public done = plugins.smartpromise.defer();
+  public done = plugins.smartpromise.defer<ISocketFunctionCallDataResponse<T>>();
 
   public smartsocketRef: Smartsocket | SmartsocketClient;
 
-
+  constructor(
-  constructor(smartsocketRefArg: Smartsocket | SmartsocketClient, optionsArg: SocketRequestConstructorOptions) {
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: ISocketRequestConstructorOptions<T>
+  ) {
     this.smartsocketRef = smartsocketRefArg;
     this.side = optionsArg.side;
     this.shortid = optionsArg.shortId;
@@ -70,10 +77,10 @@ export class SocketRequest {
   /**
    * dispatches a socketrequest from the requesting to the receiving side
    */
-  public dispatch() {
+  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
-    const requestData: ISocketRequestDataObject = {
+    const requestData: ISocketRequestDataObject<T> = {
       funcCallData: this.funcCallData,
-      shortId: this.shortid
+      shortId: this.shortid,
     };
     this.originSocketConnection.socket.emit('function', requestData);
     return this.done.promise;
@@ -82,8 +89,8 @@ export class SocketRequest {
   /**
    * handles the response that is received by the requesting side
    */
-  public handleResponse(responseDataArg: ISocketRequestDataObject) {
+  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
-    plugins.smartlog.defaultLogger.log('info', 'handling response!');
+    logger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
     this.smartsocketRef.socketRequests.remove(this);
   }
@@ -94,27 +101,26 @@ export class SocketRequest {
    * creates the response on the responding side
    */
   public async createResponse(): Promise<void> {
-    const targetSocketFunction: SocketFunction = SocketFunction.getSocketFunctionByName(
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
       this.smartsocketRef,
       this.funcCallData.funcName
     );
 
     if (!targetSocketFunction) {
-      defaultLogger.log(
+      logger.log('warn', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
-        'warn',
+      logger.log('warn', `So now response is being sent.`);
-        `There is no SocketFunction defined for ${this.funcCallData.funcName}`
-      );
-      defaultLogger.log('warn', `So now response is being sent.`);
       return;
     }
-    plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`);
+    logger.log('info', `invoking ${targetSocketFunction.name}`);
-    targetSocketFunction.invoke(this.funcCallData, this.originSocketConnection).then(resultData => {
+    targetSocketFunction
-      plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.');
+      .invoke(this.funcCallData, this.originSocketConnection)
-      const requestData: ISocketRequestDataObject = {
+      .then((resultData) => {
+        logger.log('info', 'got resultData. Sending it to requesting party.');
+        const responseData: ISocketRequestDataObject<T> = {
           funcCallData: resultData,
-        shortId: this.shortid
+          shortId: this.shortid,
         };
-      this.originSocketConnection.socket.emit('functionResponse', requestData);
+        this.originSocketConnection.socket.emit('functionResponse', responseData);
         this.smartsocketRef.socketRequests.remove(this);
       });
   }

ts/smartsocket.classes.socketrole.ts

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

ts/smartsocket.classes.socketserver.ts

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

ts/smartsocket.logging.ts

@@ -0,0 +1,3 @@
+import * as plugins from './smartsocket.plugins';
+
+export const logger = new plugins.smartlog.ConsoleLog();

ts/smartsocket.plugins.ts

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