1.1.39

.gitignore

@@ -1,4 +1,22 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
+public/
 pages/
 
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -1,5 +1,5 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
@@ -49,14 +49,14 @@ testLTS:
   tags:
   - docker
   - notpriv
-    
-testSTABLE:
+
+testBuild:
   stage: test
   script:
   - npmci npm prepare
-  - npmci node install stable
+  - npmci node install lts
   - npmci npm install
-  - npmci npm test
+  - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
   - docker
@@ -65,7 +65,7 @@ testSTABLE:
 release:
   stage: release
   script:
-  - npmci node install stable
+  - npmci node install lts
   - npmci npm publish
   only:
   - tags
@@ -78,19 +78,11 @@ release:
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
-    - docker:stable-dind
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
   - docker
   - priv
@@ -106,13 +98,15 @@ trigger:
   - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:18-dind
   stage: metadata
   script:
-    - npmci command npm install -g typedoc typescript
+    - npmci command npm install -g @gitzone/tsdoc
     - npmci npm prepare
     - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
+    - npmci command tsdoc
   tags:
     - docker
     - notpriv

.snyk

@@ -1,4 +1,13 @@
 # Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.3
-ignore: {}
+version: v1.13.5
+# ignores vulnerabilities until expiry date; change duration by modifying expiry date
+ignore:
+  SNYK-JS-JSYAML-173999:
+    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
+        reason: None given
+        expires: '2019-05-24T15:16:11.291Z'
+  SNYK-JS-JSYAML-174129:
+    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
+        reason: None given
+        expires: '2019-05-24T15:16:11.291Z'
 patch: {}

README.md

@@ -106,6 +106,6 @@ mySmartsocketClient.serverCall('function', functionCallData).then(functionRespon
 For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
 
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.31",
+  "version": "1.1.39",
   "description": "easy and secure websocket communication",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,10 +19,10 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.5",
+    "@pushrocks/lik": "^3.0.10",
     "@pushrocks/smartdelay": "^2.0.3",
-    "@pushrocks/smartexpress": "^3.0.18",
-    "@pushrocks/smarthash": "^2.0.4",
+    "@pushrocks/smartexpress": "^3.0.38",
+    "@pushrocks/smarthash": "^2.0.6",
     "@pushrocks/smartlog": "^2.0.19",
     "@pushrocks/smartpromise": "^3.0.2",
     "@types/shortid": "0.0.29",
@@ -33,11 +33,24 @@
     "socket.io-client": "^2.2.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
-    "@gitzone/tsrun": "^1.2.5",
-    "@gitzone/tstest": "^1.0.20",
-    "@pushrocks/tapbundle": "^3.0.9",
-    "@types/node": "^11.13.7"
+    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tstest": "^1.0.24",
+    "@pushrocks/tapbundle": "^3.0.11",
+    "@types/node": "^12.7.1",
+    "tslint": "^5.18.0",
+    "tslint-config-prettier": "^1.18.0"
   },
-  "private": false
+  "private": false,
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "dist_ts_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

test/test.expressserver.ts

@@ -0,0 +1,139 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, tap } from '@pushrocks/tapbundle';
+
+import * as smarthash from '@pushrocks/smarthash';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartexpress from '@pushrocks/smartexpress';
+
+import socketIoClient = require('socket.io-client');
+import smartsocket = require('../ts/index');
+
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketRole1: smartsocket.SocketRole;
+let testSocketFunction1: smartsocket.SocketFunction;
+let myseServer: smartexpress.Server;
+
+const testConfig = {
+  port: 3000
+};
+
+// class smartsocket
+tap.test('should create a new smartsocket', async () => {
+  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
+});
+
+tap.test('Should accept an smartExpressServer as server', async () => {
+  myseServer = new smartexpress.Server({
+    cors: true,
+    forceSsl: false,
+    port: testConfig.port
+  });
+
+  testSmartsocket.setExternalServer('smartexpress', myseServer);
+
+  await myseServer.start();
+});
+
+tap.test('should start listening when .started is called', async () => {
+  await testSmartsocket.start();
+});
+
+// class socketrole
+tap.test('should add a socketrole', async () => {
+  testSocketRole1 = new smartsocket.SocketRole({
+    name: 'testRole1',
+    passwordHash: smarthash.sha256FromStringSync('testPassword')
+  });
+  testSmartsocket.addSocketRoles([testSocketRole1]);
+});
+
+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunction1 = new smartsocket.SocketFunction({
+    allowedRoles: [testSocketRole1],
+    funcDef: async dataArg => {
+      return dataArg;
+    },
+    funcName: 'testFunction1'
+  });
+});
+
+// class SmartsocketClient
+tap.test('should react to a new websocket connection from client', async () => {
+  const done = smartpromise.defer();
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    password: 'testPassword',
+    alias: 'testClient1',
+    role: 'testRole1'
+  });
+  testSmartsocketClient.connect().then(() => {
+    done.resolve();
+  });
+  await done.promise;
+});
+tap.test('client should disconnect and reconnect', async () => {
+  let done = smartpromise.defer();
+  testSmartsocketClient
+    .disconnect()
+    .then(() => {
+      let done = smartpromise.defer();
+      setTimeout(() => {
+        testSmartsocketClient.connect().then(done.resolve);
+      }, 0);
+      return done.promise;
+    })
+    .then(() => {
+      done.resolve();
+    });
+  await done.promise;
+});
+
+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 () => {
+  let done = smartpromise.defer();
+  testSmartsocketClient
+    .serverCall('testFunction1', {
+      value1: 'hello'
+    })
+    .then(dataArg => {
+      console.log(dataArg);
+      done.resolve();
+    });
+  await done.promise;
+});
+
+tap.test('should be able to make a functionCall from server to client', async () => {
+  let done = smartpromise.defer();
+  let targetSocket = (() => {
+    return smartsocket.allSocketConnections.find(socketConnectionArg => {
+      return socketConnectionArg.alias === 'testClient1';
+    });
+  })();
+  testSmartsocket
+    .clientCall(
+      'testFunction1',
+      {
+        value1: 'helloFromServer'
+      },
+      targetSocket
+    )
+    .then(dataArg => {
+      console.log(dataArg);
+      done.resolve();
+    });
+});
+
+// terminate
+tap.test('should close the server', async () => {
+  await testSmartsocket.stop();
+  await myseServer.stop();
+});
+
+tap.start();

test/test.ts

@@ -1,8 +1,8 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import { expect, tap } from '@pushrocks/tapbundle';
 
-import * as nodehash from '@pushrocks/smarthash';
-import * as smartq from '@pushrocks/smartpromise';
+import * as smarthash from '@pushrocks/smarthash';
+import * as smartpromise from '@pushrocks/smartpromise';
 
 import socketIoClient = require('socket.io-client');
 import smartsocket = require('../ts/index');
@@ -30,7 +30,7 @@ tap.test('should start listening when .started is called', async () => {
 tap.test('should add a socketrole', async () => {
   testSocketRole1 = new smartsocket.SocketRole({
     name: 'testRole1',
-    passwordHash: nodehash.sha256FromStringSync('testPassword')
+    passwordHash: smarthash.sha256FromStringSync('testPassword')
   });
   testSmartsocket.addSocketRoles([testSocketRole1]);
 });
@@ -39,7 +39,7 @@ tap.test('should add a socketrole', async () => {
 tap.test('should register a new Function', async () => {
   testSocketFunction1 = new smartsocket.SocketFunction({
     allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
+    funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
     funcName: 'testFunction1'
@@ -48,7 +48,7 @@ tap.test('should register a new Function', async () => {
 
 // class SmartsocketClient
 tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartq.defer();
+  const done = smartpromise.defer();
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
@@ -62,11 +62,11 @@ tap.test('should react to a new websocket connection from client', async () => {
   await done.promise;
 });
 tap.test('client should disconnect and reconnect', async () => {
-  let done = smartq.defer();
+  let done = smartpromise.defer();
   testSmartsocketClient
     .disconnect()
     .then(() => {
-      let done = smartq.defer();
+      let done = smartpromise.defer();
       setTimeout(() => {
         testSmartsocketClient.connect().then(done.resolve);
       }, 0);
@@ -83,7 +83,7 @@ tap.test('2 clients should connect in parallel', async () => {
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartq.defer();
+  let done = smartpromise.defer();
   testSmartsocketClient
     .serverCall('testFunction1', {
       value1: 'hello'
@@ -96,7 +96,7 @@ tap.test('should be able to make a functionCall from client to server', async ()
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {
-  let done = smartq.defer();
+  let done = smartpromise.defer();
   let targetSocket = (() => {
     return smartsocket.allSocketConnections.find(socketConnectionArg => {
       return socketConnectionArg.alias === 'testClient1';

ts/smartsocket.classes.smartsocket.ts

@@ -29,7 +29,7 @@ export class Smartsocket {
   }
 
   // tslint:disable-next-line:member-ordering
-  public async setExternalServer (serverType: 'smartexpress', serverArg: any) {
+  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
     await this.socketServer.setExternalServer(serverType, serverArg);
   }
 
@@ -83,8 +83,8 @@ export class Smartsocket {
       shortId: plugins.shortid.generate(),
       side: 'requesting'
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
-      done.resolve(dataArg.funcDataArg);
+    socketRequest.dispatch().then((dataArg2: ISocketFunctionCall) => {
+      done.resolve(dataArg2.funcDataArg);
     });
     const result = await done.promise;
     return result;

ts/smartsocket.classes.socketconnection.ts

@@ -51,12 +51,12 @@ export let allSocketConnections = new Objectmap<SocketConnection>();
  * class SocketConnection represents a websocket connection
  */
 export class SocketConnection {
-  alias: string;
-  side: TSocketConnectionSide;
-  authenticated: boolean = false;
-  role: SocketRole;
-  smartsocketHost: Smartsocket;
-  socket: any; // SocketIO.Socket | SocketIOClient.Socket
+  public alias: string;
+  public side: TSocketConnectionSide;
+  public authenticated: boolean = false;
+  public role: SocketRole;
+  public smartsocketHost: Smartsocket;
+  public socket: SocketIO.Socket | SocketIOClient.Socket;
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;

ts/smartsocket.classes.socketfunction.ts

@@ -3,6 +3,7 @@ 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';
 
 // export interfaces
 
@@ -11,7 +12,7 @@ import { SocketRole } from './smartsocket.classes.socketrole';
  */
 export interface ISocketFunctionConstructorOptions {
   funcName: string;
-  funcDef: any;
+  funcDef: TFuncDef;
   allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
 }
 
@@ -26,9 +27,7 @@ export interface ISocketFunctionCall {
 /**
  * interface for function definition of SocketFunction
  */
-export interface IFuncDef {
-  (dataArg: any): PromiseLike<any>;
-}
+export type TFuncDef = (dataArg: any, connectionArg: SocketConnection) => PromiseLike<any>;
 
 // export objects
 export let allSocketFunctions = new Objectmap<SocketFunction>();
@@ -40,7 +39,7 @@ export let allSocketFunctions = new Objectmap<SocketFunction>();
  */
 export class SocketFunction {
   name: string;
-  funcDef: IFuncDef;
+  funcDef: TFuncDef;
   roles: SocketRole[];
 
   /**
@@ -59,10 +58,10 @@ export class SocketFunction {
   /**
    * invokes the function of this SocketFunction
    */
-  invoke(dataArg: ISocketFunctionCall): Promise<any> {
+  invoke(dataArg: ISocketFunctionCall, socketConnectionArg: SocketConnection): Promise<any> {
     let done = plugins.smartpromise.defer();
     if (dataArg.funcName === this.name) {
-      this.funcDef(dataArg.funcDataArg).then((resultData: any) => {
+      this.funcDef(dataArg.funcDataArg, socketConnectionArg).then((resultData: any) => {
         let funcResponseData: ISocketFunctionCall = {
           funcName: this.name,
           funcDataArg: resultData

ts/smartsocket.classes.socketrequest.ts

@@ -8,6 +8,7 @@ import { ISocketFunctionCall } from './smartsocket.classes.socketfunction';
 import { Objectmap } from '@pushrocks/lik';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { defaultLogger } from '@pushrocks/smartlog';
 
 // export interfaces
 export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
@@ -37,12 +38,12 @@ export let allSocketRequests = new Objectmap<SocketRequest>();
 
 // export classes
 export class SocketRequest {
-  status: TSocketRequestStatus = 'new';
-  side: TSocketRequestSide;
-  shortid: string;
-  originSocketConnection: SocketConnection;
-  funcCallData: ISocketFunctionCall;
-  done = plugins.smartpromise.defer();
+  public status: TSocketRequestStatus = 'new';
+  public side: TSocketRequestSide;
+  public shortid: string;
+  public originSocketConnection: SocketConnection;
+  public funcCallData: ISocketFunctionCall;
+  public done = plugins.smartpromise.defer();
   constructor(optionsArg: SocketRequestConstructorOptions) {
     this.side = optionsArg.side;
     this.shortid = optionsArg.shortId;
@@ -56,7 +57,7 @@ export class SocketRequest {
   /**
    * dispatches a socketrequest from the requesting to the receiving side
    */
-  dispatch() {
+  public dispatch() {
     let requestData: ISocketRequestDataObject = {
       funcCallData: this.funcCallData,
       shortId: this.shortid
@@ -68,7 +69,7 @@ export class SocketRequest {
   /**
    * handles the response that is received by the requesting side
    */
-  handleResponse(responseDataArg: ISocketRequestDataObject) {
+  public handleResponse(responseDataArg: ISocketRequestDataObject) {
     plugins.smartlog.defaultLogger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
     allSocketRequests.remove(this);
@@ -79,12 +80,20 @@ export class SocketRequest {
   /**
    * creates the response on the responding side
    */
-  createResponse() {
-    let targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(
+  public async createResponse(): Promise<void> {
+    const targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(
       this.funcCallData.funcName
     );
+    if (!targetSocketFunction) {
+      defaultLogger.log(
+        'warn',
+        `There is no SocketFunction defined for ${this.funcCallData.funcName}`
+      );
+      defaultLogger.log('warn', `So now response is being sent.`);
+      return;
+    }
     plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`);
-    targetSocketFunction.invoke(this.funcCallData).then(resultData => {
+    targetSocketFunction.invoke(this.funcCallData, this.originSocketConnection).then(resultData => {
       plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.');
       let requestData: ISocketRequestDataObject = {
         funcCallData: resultData,

ts/smartsocket.classes.socketserver.ts

@@ -23,7 +23,10 @@ export class SocketServer {
    * starts the server with another server
    * also works with an express style server
    */
-  public async setExternalServer(serverType: 'smartexpress', serverArg: plugins.smartexpress.Server) {
+  public async setExternalServer(
+    serverType: 'smartexpress',
+    serverArg: plugins.smartexpress.Server
+  ) {
     await serverArg.startedPromise;
     this.httpServer = serverArg.httpServer;
   }
@@ -51,8 +54,8 @@ 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!')
-        throw new Error('there should be a port specified for smartsocket')
+        console.log('there should be a port specifed for smartsocket!');
+        throw new Error('there should be a port specified for smartsocket');
       }
       this.httpServer.listen(this.smartsocket.options.port, () => {
         console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);

ts/smartsocket.plugins.ts

@@ -5,7 +5,17 @@ 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 socketIo from 'socket.io';
-import * as socketIoClient from 'socket.io-client';
+import socketIo from 'socket.io';
+import socketIoClient from 'socket.io-client';
 
-export { lik, smartlog, smarthash, smartdelay, smartexpress, smartpromise, shortid, socketIo, socketIoClient };
+export {
+  lik,
+  smartlog,
+  smarthash,
+  smartdelay,
+  smartexpress,
+  smartpromise,
+  shortid,
+  socketIo,
+  socketIoClient
+};