fix(core): update

test/common/test.ts

@@ -1 +0,0 @@
-console.log('TODO');

test/test.expressserver.ts

@@ -8,7 +8,6 @@ import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
 let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 
@@ -18,7 +17,7 @@ const testConfig = {
 
 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver', port: testConfig.port });
   expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
 });
 
@@ -34,19 +33,10 @@ tap.test('Should accept an smartExpressServer as server', async () => {
   await myseServer.start();
 });
 
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: await isohash.sha256FromString('testPassword'),
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
   testSocketFunction1 = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
@@ -65,12 +55,9 @@ tap.test('should react to a new websocket connection from client', async () => {
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
-    password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1',
   });
   testSmartsocketClient.addSocketFunction(testSocketFunction1);
-  console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 

test/test.tagging.ts

@@ -7,7 +7,6 @@ import * as isohash from '@pushrocks/isohash';
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
 let testSocketConnection: smartsocket.SocketConnection;
-let testSocketRole1: smartsocket.SocketRole;
 let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
 let testSocketFunctionClient: smartsocket.SocketFunction<any>;
 
@@ -37,23 +36,13 @@ const testConfig = {
 
 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
   expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
 });
 
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: await isohash.sha256FromString('testPassword'),
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
-
 // class SocketFunction
 tap.test('should register a new Function', async () => {
   testSocketFunctionForServer = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
@@ -62,7 +51,6 @@ tap.test('should register a new Function', async () => {
   testSmartsocket.addSocketFunction(testSocketFunctionForServer);
 
   testSocketFunctionClient = new smartsocket.SocketFunction({
-    allowedRoles: [],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
@@ -81,9 +69,7 @@ tap.test('should react to a new websocket connection from client', async () => {
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
-    password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1',
   });
   testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
   console.log(testSmartsocketClient.socketFunctions);

ts/index.ts

@@ -4,5 +4,4 @@ export * from './smartsocket.classes.smartsocketclient';
 
 // export further classes and objects
 export * from './smartsocket.classes.socketfunction';
-export * from './smartsocket.classes.socketrole';
 export * from './smartsocket.classes.socketconnection';

ts/interfaces/connection.ts

@@ -1,5 +1,5 @@
 export interface IRequestAuthPayload {
-  serverShortId: string;
+  serverAlias: string;
 }
 
 export type TConnectionStatus =

ts/smartsocket.classes.smartsocket.ts

@@ -9,12 +9,12 @@ import {
   ISocketFunctionCallDataResponse,
 } from './smartsocket.classes.socketfunction';
 import { SocketRequest } from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketServer } from './smartsocket.classes.socketserver';
 
 import { logger } from './smartsocket.logging';
 
 export interface ISmartsocketConstructorOptions {
+  alias: string;
   port?: number;
 }
 
@@ -22,12 +22,11 @@ export class Smartsocket {
   /**
    * a unique id to detect server restarts
    */
-  public shortId = plugins.isounique.uni();
+  public alias: string;
   public smartenv = new plugins.smartenv.Smartenv();
   public options: ISmartsocketConstructorOptions;
   public io: pluginsTyped.socketIo.Server;
   public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
-  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
   public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
   public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
 
@@ -35,6 +34,7 @@ export class Smartsocket {
 
   constructor(optionsArg: ISmartsocketConstructorOptions) {
     this.options = optionsArg;
+    this.alias = plugins.isounique.uni(this.options.alias);
   }
 
   // tslint:disable-next-line:member-ordering
@@ -96,16 +96,6 @@ export class Smartsocket {
     return result;
   }
 
-  /**
-   * adds socketRoles
-   */
-  public addSocketRoles(socketRolesArray: SocketRole[]): void {
-    for (const socketRole of socketRolesArray) {
-      this.socketRoles.add(socketRole);
-    }
-    return;
-  }
-
   public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
   }
@@ -117,7 +107,6 @@ export class Smartsocket {
     const socketConnection: SocketConnection = new SocketConnection({
       alias: undefined,
       authenticated: false,
-      role: undefined,
       side: 'server',
       smartsocketHost: this,
       socket: socketArg,

ts/smartsocket.classes.smartsocketclient.ts

@@ -8,7 +8,6 @@ import {
   SocketFunction,
 } from './smartsocket.classes.socketfunction';
 import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
 import { logger } from './smartsocket.logging';
 
 /**
@@ -18,8 +17,6 @@ export interface ISmartsocketClientOptions {
   port: number;
   url: string;
   alias: string; // an alias makes it easier to identify this client in a multo client environment
-  role: string;
-  password: string; // by setting a password access to functions can be limited
   autoReconnect?: boolean;
 }
 
@@ -31,7 +28,6 @@ export class SmartsocketClient {
   public remoteShortId: string = null;
 
   public alias: string;
-  public socketRole: SocketRole;
   public socketConnection: SocketConnection;
   public serverUrl: string;
   public serverPort: number;
@@ -43,7 +39,6 @@ export class SmartsocketClient {
 
   public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
   public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
-  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
 
   // tagStore
   private tagStore: { [key: string]: interfaces.ITag } = {};
@@ -83,16 +78,11 @@ export class SmartsocketClient {
     this.alias = optionsArg.alias;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.socketRole = new SocketRole({
-      name: optionsArg.role,
-      passwordHash: optionsArg.password,
-    });
     this.autoReconnect = optionsArg.autoReconnect;
   }
 
   public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
-    this.socketRole.allowedFunctions.add(socketFunction);
   }
 
   /**
@@ -113,7 +103,6 @@ export class SmartsocketClient {
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: this.socketRole,
       side: 'client',
       smartsocketHost: this,
       socket: await socketIoClient.connect(socketUrl, {
@@ -139,7 +128,7 @@ export class SmartsocketClient {
 
         // lets register the authenticated event
         this.socketConnection.socket.on('authenticated', async () => {
-          this.remoteShortId = requestAuthPayload.serverShortId;
+          this.remoteShortId = requestAuthPayload.serverAlias;
           logger.log('info', 'client is authenticated');
           this.socketConnection.authenticated = true;
           await this.socketConnection.listenToFunctionRequests();
@@ -172,8 +161,6 @@ export class SmartsocketClient {
 
         // lets provide the actual auth data
         this.socketConnection.socket.emit('dataAuth', {
-          role: this.socketRole.name,
-          password: this.socketRole.passwordHash,
           alias: this.alias,
         });
       }

ts/smartsocket.classes.socketconnection.ts

@@ -5,7 +5,6 @@ import * as interfaces from './interfaces';
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
 import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
 import * as pluginsTyped from './smartsocket.pluginstyped';
@@ -25,7 +24,6 @@ export type TSocketConnectionSide = 'server' | 'client';
 export interface ISocketConnectionConstructorOptions {
   alias: string;
   authenticated: boolean;
-  role: SocketRole;
   side: TSocketConnectionSide;
   smartsocketHost: Smartsocket | SmartsocketClient;
   socket: SocketIO.Socket | SocketIOClient.Socket;
@@ -35,9 +33,7 @@ export interface ISocketConnectionConstructorOptions {
  * interface for authentication data
  */
 export interface ISocketConnectionAuthenticationObject {
-  role: 'coreflowContainer';
+  alias: string;
-  password: 'somePassword';
-  alias: 'coreflow1';
 }
 
 // export classes
@@ -50,7 +46,6 @@ export class SocketConnection {
   public alias: string;
   public side: TSocketConnectionSide;
   public authenticated: boolean = false;
-  public role: SocketRole;
   public smartsocketRef: Smartsocket | SmartsocketClient;
   public socket: SocketIO.Socket | SocketIOClient.Socket;
 
@@ -64,7 +59,6 @@ export class SocketConnection {
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;
-    this.role = optionsArg.role;
     this.side = optionsArg.side;
     this.smartsocketRef = optionsArg.smartsocketHost;
     this.socket = optionsArg.socket;
@@ -134,24 +128,23 @@ export class SocketConnection {
   public authenticate() {
     const done = plugins.smartpromise.defer();
     this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
-      logger.log('info', 'received authentication data. now hashing and comparing...');
+      logger.log('info', 'received authentication data...');
       this.socket.removeAllListeners('dataAuth');
-      if (await SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
+      if (dataArg.alias) {
         // TODO: authenticate password
         this.alias = dataArg.alias;
         this.authenticated = true;
-        this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
         this.socket.emit('authenticated');
-        logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
+        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
         done.resolve(this);
       } else {
         this.authenticated = false;
         await this.disconnect();
-        done.reject('not authenticated');
+        done.reject('a socket tried to connect, but could not authenticated.');
       }
     });
     const requestAuthPayload: interfaces.IRequestAuthPayload = {
-      serverShortId: this.smartsocketRef.shortId,
+      serverAlias: this.smartsocketRef.alias,
     };
     this.socket.emit('requestAuth', requestAuthPayload);
     return done.promise;
@@ -168,7 +161,7 @@ export class SocketConnection {
       this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
         // check if requested function is available to the socket's scope
         // logger.log('info', 'function request received');
-        const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.findSync(
+        const referencedFunction: SocketFunction<any> = this.smartsocketRef.socketFunctions.findSync(
           (socketFunctionArg) => {
             return socketFunctionArg.name === dataArg.funcCallData.funcName;
           }

ts/smartsocket.classes.socketfunction.ts

@@ -1,7 +1,6 @@
 import * as plugins from './smartsocket.plugins';
 
 // import classes
-import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
@@ -16,7 +15,6 @@ export interface ISocketFunctionConstructorOptions<
 > {
   funcName: T['method'];
   funcDef: TFuncDef<T>;
-  allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
 }
 
 /**
@@ -66,7 +64,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
   // INSTANCE
   public name: string;
   public funcDef: TFuncDef<T>;
-  public roles: SocketRole[];
 
   /**
    * the constructor for SocketFunction
@@ -74,10 +71,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
   constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
     this.name = optionsArg.funcName;
     this.funcDef = optionsArg.funcDef;
-    this.roles = optionsArg.allowedRoles;
-    for (const socketRoleArg of this.roles) {
-      this._notifyRole(socketRoleArg);
-    }
   }
 
   /**
@@ -97,11 +90,4 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
       throw new Error("SocketFunction.name does not match the data argument's .name!");
     }
   }
-
-  /**
-   * notifies a role about access to this SocketFunction
-   */
-  private _notifyRole(socketRoleArg: SocketRole) {
-    socketRoleArg.addSocketFunction(this);
-  }
 }

ts/smartsocket.classes.socketrole.ts

@@ -1,59 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// import classes
-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 class SocketRole {
-  // STATIC
-  public static getSocketRoleByName(
-    referenceSmartsocket: Smartsocket | SmartsocketClient,
-    socketRoleNameArg: string
-  ): SocketRole {
-    return referenceSmartsocket.socketRoles.findSync((socketRoleArg) => {
-      return socketRoleArg.name === socketRoleNameArg;
-    });
-  }
-
-  public static async checkPasswordForRole(
-    dataArg: ISocketConnectionAuthenticationObject,
-    referenceSmartsocket: Smartsocket | SmartsocketClient
-  ): Promise<boolean> {
-    const targetPasswordHash = SocketRole.getSocketRoleByName(
-      referenceSmartsocket,
-      dataArg.role
-    ).passwordHash;
-    const computedCompareHash = await plugins.isohash.sha256FromString(dataArg.password);
-    return targetPasswordHash === computedCompareHash;
-  }
-
-  // INSTANCE
-  public name: string;
-  public passwordHash: string;
-  public allowedFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
-  constructor(optionsArg: ISocketRoleOptions) {
-    this.name = optionsArg.name;
-    this.passwordHash = optionsArg.passwordHash;
-  }
-
-  /**
-   * adds the socketfunction to the socketrole
-   * @param socketFunctionArg
-   */
-  public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
-    this.allowedFunctions.add(socketFunctionArg);
-  }
-}