1.0.52

.gitignore

@@ -1,6 +1,22 @@
 .nogit/
-node_modules/
-dist/
+
+# 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,4 +1,4 @@
-# gitzone standard
+# gitzone ci_default
 image: hosttoday/ht-docker-node:npmci
 
 cache:
@@ -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
@@ -109,10 +101,10 @@ pages:
   image: hosttoday/ht-docker-node:npmci
   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

@@ -0,0 +1,4 @@
+# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
+version: v1.13.5
+ignore: {}
+patch: {}

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartuniverse",
-  "version": "1.0.42",
+  "version": "1.0.52",
   "private": false,
   "description": "messaging service for your micro services",
   "main": "dist/index.js",
@@ -9,15 +9,16 @@
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
+    "testManual": "(tsrun test/test.ts)",
     "build": "(tsbuild)",
     "format": "(gitzone format)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
-    "@gitzone/tstest": "^1.0.20",
+    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tstest": "^1.0.24",
     "@pushrocks/tapbundle": "^3.0.9",
-    "@types/node": "^11.13.4",
-    "tslint": "^5.15.0",
+    "@types/node": "^12.0.7",
+    "tslint": "^5.17.0",
     "tslint-config-prettier": "^1.18.0"
   },
   "peerDependencies": {
@@ -26,14 +27,24 @@
   "dependencies": {
     "@pushrocks/lik": "^3.0.5",
     "@pushrocks/smartdelay": "^2.0.3",
-    "@pushrocks/smartexpress": "^3.0.18",
+    "@pushrocks/smartexpress": "^3.0.21",
     "@pushrocks/smartfile": "^7.0.2",
     "@pushrocks/smarthash": "^2.0.4",
     "@pushrocks/smartpromise": "^3.0.2",
-    "@pushrocks/smartrequest": "^1.1.14",
+    "@pushrocks/smartrequest": "^1.1.15",
     "@pushrocks/smartrx": "^2.0.3",
-    "@pushrocks/smartsocket": "^1.1.27",
+    "@pushrocks/smartsocket": "^1.1.38",
     "@pushrocks/smarttime": "^3.0.7",
     "@pushrocks/smartunique": "^3.0.1"
-  }
+  },
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

readme.md

@@ -1,16 +1,13 @@
 # @pushrocks/smartuniverse
-
 messaging service for micro services
 
 ## Availabililty and Links
-
-- [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
-- [gitlab.com (source)](https://gitlab.com/pushrocks/smartuniverse)
-- [github.com (source mirror)](https://github.com/pushrocks/smartuniverse)
-- [docs (typedoc)](https://pushrocks.gitlab.io/smartuniverse/)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartuniverse)
+* [github.com (source mirror)](https://github.com/pushrocks/smartuniverse)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartuniverse/)
 
 ## Status for master
-
 [![build status](https://gitlab.com/pushrocks/smartuniverse/badges/master/build.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
 [![coverage report](https://gitlab.com/pushrocks/smartuniverse/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
 [![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartuniverse.svg)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
@@ -28,6 +25,7 @@ Use TypeScript for best in class instellisense.
 Think WhatsApp, but for your microservices architecture. It allows your services to securely talk to each other in **private, shielded channels** without having to expose anything to the outside world. This allows the use of **reactive programming across your entire stack**.
 
 ### Server side
+
 every universe has a server that manages messages.  
 Think Kafka, but without Kafka.
 
@@ -46,11 +44,12 @@ myUniverse.start(8765); // start the server and provide the port on which to lis
 ```
 
 ### Client side
+
 All your microservices represents clients in the universe that may talk to each other using the universe server.
 
 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.html)
 
 [![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -6,8 +6,13 @@ import { Observable } from 'rxjs';
 
 let testUniverse: smartuniverse.Universe;
 let testClientUniverse: smartuniverse.ClientUniverse;
+let testClientUniverse2: smartuniverse.ClientUniverse;
 let testClientChannel: smartuniverse.ClientUniverseChannel;
 
+const testServerData = {
+  serverAddress: 'http://localhost:8765'
+};
+
 const testChannelData = {
   channelName: 'awesomeTestChannel',
   channelPass: 'awesomeChannelPAss'
@@ -26,23 +31,17 @@ tap.test('add a message to the SmartUniverse', async () => {
 // testing message handling
 tap.test('create smartuniverse client', async () => {
   testClientUniverse = new smartuniverse.ClientUniverse({
-    serverAddress: 'http://localhost:8765'
+    serverAddress: testServerData.serverAddress
   });
   expect(testClientUniverse).to.be.instanceof(smartuniverse.ClientUniverse);
 });
 
 tap.test('should add a channel to the universe', async () => {
-  await testUniverse.addChannel(
-    testChannelData.channelName,
-    testChannelData.channelPass
-  );
+  await testUniverse.addChannel(testChannelData.channelName, testChannelData.channelPass);
 });
 
 tap.test('should add the same channel to the client universe in the same way', async () => {
-  await testClientUniverse.addChannel(
-    testChannelData.channelName,
-    testChannelData.channelPass
-  );
+  await testClientUniverse.addChannel(testChannelData.channelName, testChannelData.channelPass);
 });
 
 tap.test('should get a observable correctly', async () => {
@@ -57,6 +56,18 @@ tap.test('should send a message correctly', async () => {
   });
 });
 
+tap.test('universe should contain the sent message', async () => {
+  expect(testUniverse.universeCache.messageMap.getArray()[0].messageText).to.equal('hello');
+});
+
+tap.test('a second client should be able to subscibe', async () => {
+  testClientUniverse2 = new smartuniverse.ClientUniverse({
+    serverAddress: testServerData.serverAddress
+  });
+
+  testClientUniverse2.addChannel(testChannelData.channelName, testChannelData.channelPass);
+});
+
 tap.test('should receive a message correctly', async () => {});
 
 tap.test('should disconnect the client correctly', async () => {

ts/interfaces/http.interfaces.ts

@@ -12,4 +12,4 @@ export interface IServerPutMessageRequestBody {
   passphrase: string;
   message: string;
   payload: any;
-}
+}

ts/interfaces/index.ts

@@ -1,3 +1,4 @@
 export * from './http.interfaces';
 export * from './universechannel.interfaces';
 export * from './universemessage.interfaces';
+export * from './universeactions.interfaces';

ts/interfaces/universeactions.interfaces.ts

@@ -0,0 +1,13 @@
+export type IServerCallActions = 'subscribe' | 'sendmessage' | 'unsubscribe';
+
+/**
+ * the interface for a subscription
+ */
+export interface IServerCallSubscribeActionPayload {
+  name: string;
+  passphrase: string;
+}
+
+export interface IServerUnsubscribeActionPayload {
+  name: string;
+}

ts/interfaces/universeconnection.interfaces.ts

@@ -0,0 +1,4 @@
+export interface IAuthenticationRequest {
+  channelName: string;
+  password: string;
+}

ts/smartuniverse.classes.clientuniverse.ts

@@ -7,10 +7,8 @@ import * as url from 'url';
 
 import * as interfaces from './interfaces';
 
-import {
-  ClientUniverseChannel,
-  UniverseMessage
-} from './';
+import { ClientUniverseChannel, UniverseMessage } from './';
+import { ClientUniverseCache } from './smartuniverse.classes.clientuniversecache';
 
 export interface IClientOptions {
   serverAddress: string;
@@ -22,10 +20,11 @@ export interface IClientOptions {
  */
 export class ClientUniverse {
   public options;
-  public socketClient: plugins.smartsocket.SmartsocketClient;
+  public smartsocketClient: plugins.smartsocket.SmartsocketClient;
   public observableIntake: plugins.smartrx.ObservableIntake<UniverseMessage>;
 
-  public channelCache = new Objectmap<ClientUniverseChannel>();
+  public channelStore = new Objectmap<ClientUniverseChannel>();
+  public clientUniverseCache = new ClientUniverseCache();
 
   constructor(optionsArg: IClientOptions) {
     this.options = optionsArg;
@@ -35,51 +34,57 @@ export class ClientUniverse {
    * adds a channel to the channelcache
    * TODO: verify channel before adding it to the channel cache
    */
-  public async addChannel (channelNameArg: string, passphraseArg: string) {
-    const existingChannel = this.getChannel(channelNameArg);
+  public async addChannel(channelNameArg: string, passphraseArg: string) {
+    const existingChannel = await this.getChannel(channelNameArg);
 
     if (existingChannel) {
       throw new Error('channel exists');
     }
 
     // lets create the channel
-    ClientUniverseChannel.createClientUniverseChannel(
-      this,
-      channelNameArg,
-      passphraseArg
-    );
+    ClientUniverseChannel.createClientUniverseChannel(this, channelNameArg, passphraseArg);
   }
 
   /**
    * gets a channel from the channelcache
    * @param channelName
-   * @param passphraseArg 
+   * @param passphraseArg
    */
   public async getChannel(channelName: string): Promise<ClientUniverseChannel> {
     await this.checkConnection();
-    const clientUniverseChannel = this.channelCache.find(channel => {
+    const clientUniverseChannel = this.channelStore.find(channel => {
       return channel.name === channelName;
-    })
+    });
     return clientUniverseChannel;
   }
 
+  /**
+   * remove a a achannel
+   * @param messageArg
+   */
+  public removeChannel(channelNameArg, notifyServer = true) {
+    const clientUniverseChannel = this.channelStore.findOneAndRemove(channelItemArg => {
+      return channelItemArg.name === channelNameArg;
+    });
+  }
+
+  /**
+   * sends a message towards the server
+   * @param messageArg
+   */
   public async sendMessage(messageArg: interfaces.IMessageCreator) {
+    await this.checkConnection();
     const requestBody: interfaces.IUniverseMessage = {
       id: plugins.smartunique.shortId(),
       timestamp: Date.now(),
       passphrase: (await this.getChannel(messageArg.targetChannelName)).passphrase,
-      ...messageArg,
-
+      ...messageArg
     };
-    const requestBodyString = JSON.stringify(requestBody);
     // TODO: User websocket connection if available
-    const response = await plugins.smartrequest.postJson(`${this.options.serverAddress}/sendmessage` , {
-      requestBody: requestBodyString
-    });
   }
 
   public close() {
-    this.socketClient.disconnect();
+    this.smartsocketClient.disconnect();
   }
 
   /**
@@ -87,17 +92,36 @@ export class ClientUniverse {
    * since password validation is done through other means, a connection should always be possible
    */
   private async checkConnection(): Promise<void> {
-    if (!this.socketClient && !this.observableIntake) {
+    if (!this.smartsocketClient && !this.observableIntake) {
       const parsedURL = url.parse(this.options.serverAddress);
-      this.socketClient = new SmartsocketClient({
+      const socketConfig: plugins.smartsocket.ISmartsocketClientOptions = {
         alias: process.env.SOCKET_ALIAS || 'someclient',
         password: 'UniverseClient',
         port: parseInt(parsedURL.port, 10),
         role: 'UniverseClient',
-        url: parsedURL.hostname
-      });
+        url: parsedURL.protocol + '//' + parsedURL.hostname
+      };
+      console.log(socketConfig);
+      this.smartsocketClient = new SmartsocketClient(socketConfig);
       this.observableIntake = new plugins.smartrx.ObservableIntake();
-      this.socketClient.connect();
+
+      // lets define some basic actions
+
+      /**
+       * should handle a forced unsubscription by the server
+       */
+      const unsubscribe = new plugins.smartsocket.SocketFunction({
+        funcName: 'unsubscribe',
+        allowedRoles: [],
+        funcDef: async (data: interfaces.IServerUnsubscribeActionPayload) => {}
+      });
+
+      /**
+       * should handle a message reception
+       */
+      const receiveMessage = async () => {};
+
+      await this.smartsocketClient.connect();
     }
   }
 }

ts/smartuniverse.classes.clientuniversecache.ts

@@ -0,0 +1,8 @@
+import * as plugins from './smartuniverse.plugins';
+
+/**
+ * a cache for clients
+ * keeps track of which messages have already been received
+ * good for deduplication in mesh environments
+ */
+export class ClientUniverseCache {}

ts/smartuniverse.classes.clientuniversechannel.ts

@@ -10,16 +10,20 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   /**
    * creates a channel and adds it to the cache of clientUniverseArg
    * @param clientUniverseArg
-   * @param channelNameArg 
-   * @param passphraseArg 
+   * @param channelNameArg
+   * @param passphraseArg
    */
   public static async createClientUniverseChannel(
     clientUniverseArg: ClientUniverse,
     channelNameArg: string,
     passphraseArg: string
   ): Promise<ClientUniverseChannel> {
-    const clientChannel = new ClientUniverseChannel(clientUniverseArg, channelNameArg, passphraseArg);
-    clientUniverseArg.channelCache.add(clientChannel);
+    const clientChannel = new ClientUniverseChannel(
+      clientUniverseArg,
+      channelNameArg,
+      passphraseArg
+    );
+    clientUniverseArg.channelStore.add(clientChannel);
     await clientChannel.subscribe();
     return clientChannel;
   }
@@ -31,11 +35,11 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   // properties
   public name: string;
   public passphrase: string;
-  
+
   // refs
   public clientUniverse: ClientUniverse;
-  
-  constructor(clientUniverseArg: ClientUniverse, nameArg: string,  passphraseArg: string) {
+
+  constructor(clientUniverseArg: ClientUniverse, nameArg: string, passphraseArg: string) {
     this.clientUniverse = clientUniverseArg;
     this.name = nameArg;
     this.passphrase = passphraseArg;
@@ -46,6 +50,11 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
    * tells the universe about this instances interest into a channel
    */
   public async subscribe() {
-    this.clientUniverse.socketClient;
+    const serverCallActionName: interfaces.IServerCallActions = 'subscribe';
+    const serverCallActionPayload: interfaces.IServerCallSubscribeActionPayload = {
+      name: this.name,
+      passphrase: this.passphrase
+    };
+    this.clientUniverse.smartsocketClient.serverCall(serverCallActionName, serverCallActionPayload);
   }
 }

ts/smartuniverse.classes.clientuniversemessage.ts

@@ -1,32 +1,34 @@
 import * as plugins from './smartuniverse.plugins';
 
 import * as interfaces from './interfaces';
+import { IUniverseMessage } from './interfaces';
 
 export class ClientUniverseMessage implements interfaces.IUniverseMessage {
   // ======
   // STATIC
   // ======
-  public static createMessageFromPayload(messageDescriptor: interfaces.IUniverseMessage) {
-
-  };
+  public static createMessageFromPayload(messageDescriptor: interfaces.IUniverseMessage) {}
 
   // ========
   // INSTANCE
   // ========
 
+  // properties
   public id: string;
 
   public timestamp: number;
   public smartTimestamp: plugins.smarttime.TimeStamp;
-
   public messageText: string;
   public passphrase: string;
   public payload: any;
   public payloadStringType;
   public targetChannelName: string;
-  constructor(messageArg, payloadArg) {}
-
-  getAsJsonForPayload () {
 
+  constructor(messageArg: IUniverseMessage, payloadArg) {
+    for (const key of Object.keys(messageArg)) {
+      this[key] = messageArg[key];
+    }
   }
+
+  getAsJsonForPayload() {}
 }

ts/smartuniverse.classes.universe.ts

@@ -6,42 +6,24 @@ import { UniverseCache, UniverseChannel, UniverseMessage } from './';
 import * as paths from './smartuniverse.paths';
 
 import * as interfaces from './interfaces';
+import { UniverseConnectionManager } from './smartuniverse.classes.universeconnectionmanager';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection';
 
 export interface ISmartUniverseConstructorOptions {
   messageExpiryInMilliseconds: number;
 }
 
-
-
 /**
  * main class that setsup a Universe
  */
 export class Universe {
   // subinstances
   public universeCache: UniverseCache;
+  public universeConnectionManager: UniverseConnectionManager;
 
   // options
   private options: ISmartUniverseConstructorOptions;
 
-  /**
-   * stores the version of the universe server running
-   * this is done since the version is exposed through the api and multiple fs actions are avoided this way.
-   */
-  private universeVersionStore: string;
-
-  /**
-   * get the currently running version of smartuniverse
-   */
-  public get universeVersion() {
-    if (this.universeVersionStore) {
-      return this.universeVersionStore;
-    } else {
-      const packageJson = plugins.smartfile.fs.toObjectSync(paths.packageJson);
-      this.universeVersionStore = packageJson.version;
-      return this.universeVersionStore;
-    }
-  }
-
   /**
    * the smartexpress server used
    */
@@ -55,6 +37,26 @@ export class Universe {
   constructor(optionsArg: ISmartUniverseConstructorOptions) {
     this.options = optionsArg;
     this.universeCache = new UniverseCache(this.options.messageExpiryInMilliseconds);
+    this.universeConnectionManager = new UniverseConnectionManager();
+  }
+
+  /**
+   * stores the version of the universe server running
+   * this is done since the version is exposed through the api and multiple fs actions are avoided this way.
+   */
+  private universeVersionStore: string;
+
+  /**
+   * get the currently running version of smartuniverse
+   */
+  public getUniverseVersion() {
+    if (this.universeVersionStore) {
+      return this.universeVersionStore;
+    } else {
+      const packageJson = plugins.smartfile.fs.toObjectSync(paths.packageJson);
+      this.universeVersionStore = packageJson.version;
+      return this.universeVersionStore;
+    }
   }
 
   /**
@@ -67,53 +69,51 @@ export class Universe {
   /**
    * initiates a server
    */
-  public async start(portArg: number | string) {
+  public async start(portArg: number) {
     // lets create the base smartexpress server
     this.smartexpressServer = new plugins.smartexpress.Server({
       cors: true,
       defaultAnswer: async () => {
-        return `smartuniverse server ${this.universeVersion}`;
+        return `smartuniverse server ${this.getUniverseVersion()}`;
       },
       forceSsl: false,
       port: portArg
     });
 
-    // lets create the http request route
-    this.smartexpressServer.addRoute('/sendmessage', new Handler('POST', async (req, res) => {
-      const universeMessageInstance = new UniverseMessage(req.body);
-      this.universeCache.addMessage(universeMessageInstance);
-    }));
-
     // add websocket upgrade
-    this.smartsocket = new plugins.smartsocket.Smartsocket({
-      port: 12345 // fix this within smartsocket
-    });
+    this.smartsocket = new plugins.smartsocket.Smartsocket({});
 
     // add a role for the clients
     const ClientRole = new plugins.smartsocket.SocketRole({
-      name: 'clientuniverse',
-      passwordHash: 'clientuniverse' // authentication happens on another level
+      name: 'UniverseClient',
+      passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient') // authentication happens on another level
     });
 
     // add the role to smartsocket
     this.smartsocket.addSocketRoles([ClientRole]);
 
     const SubscriptionSocketFunction = new plugins.smartsocket.SocketFunction({
-      allowedRoles: [ClientRole],
+      allowedRoles: [ClientRole], // there is only one client role, Authentication happens on another level
       funcName: 'channelSubscription',
-      funcDef: () => {
-        console.log('a client connected');
-      } // TODO: implement an action upon connection of clients
+      funcDef: async (dataArg: interfaces.IServerCallSubscribeActionPayload, socketConnectionArg) => {
+        // run in "this context" of this class
+        (() => {
+          // TODO: properly add the connection
+          const universeConnection = new UniverseConnection({
+            socketConnection: socketConnectionArg,
+            authenticationRequests: []
+          })
+          this.universeConnectionManager.addConnection(universeConnection);
+        })();
+      }
     });
 
     // add smartsocket to the running smartexpress app
-    this.smartsocket.setExternalServer('express', this.smartexpressServer as any);
-
-    // start the socket
-    this.smartsocket.start();
-
-    // start the smartexpress instance
+    this.smartsocket.setExternalServer('smartexpress', this.smartexpressServer as any);
+    // start everything
     await this.smartexpressServer.start();
+    await this.smartsocket.start();
+    console.log('started universe');
   }
 
   /**

ts/smartuniverse.classes.universecache.ts

@@ -52,7 +52,10 @@ export class UniverseCache {
   /**
    * Read a message from the UniverseCache
    */
-  public readMessagesYoungerThan(unixTimeArg?: number): Observable<UniverseMessage> {
+  public readMessagesYoungerThan(
+    unixTimeArg?: number,
+    channelName?: string
+  ): Observable<UniverseMessage> {
     const messageObservable = from(this.messageMap.getArray()).pipe(
       filter(messageArg => {
         return messageArg.smartTimestamp.isYoungerThanMilliSeconds(this.destructionTime);

ts/smartuniverse.classes.universeconnection.ts

@@ -0,0 +1,35 @@
+import * as plugins from './smartuniverse.plugins';
+import { UniverseChannel } from './smartuniverse.classes.universechannel';
+
+/**
+ * represents a connection to the universe
+ */
+export class UniverseConnection {
+  public terminatedDeferred = plugins.smartpromise.defer();
+
+
+  /**
+   * the socketClient to ping
+   */
+  public socketConnection: plugins.smartsocket.SocketConnection;
+  public authenticationRequests = [];
+  public subscribedChannels: UniverseChannel[] = [];
+  public authenticatedChannels: UniverseChannel[] = [];
+  public failedToJoinChannels: UniverseChannel[] = [];
+
+  /**
+   * terminates the connection
+   */
+  public terminateConnection () {
+    this.socketConnection.socket.disconnect();
+    this.terminatedDeferred.resolve();
+  }
+
+  constructor(optionsArg: {
+    socketConnection: plugins.smartsocket.SocketConnection;
+    authenticationRequests
+  }) {
+    // TODO: check if this is correct
+    this.socketConnection.socket.disconnect();
+  }
+}

ts/smartuniverse.classes.universeconnectionmanager.ts

@@ -0,0 +1,48 @@
+import * as plugins from './smartuniverse.plugins';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection';
+
+/**
+ * manages connections to a universe
+ */
+export class UniverseConnectionManager {
+  public connectionMap = new plugins.lik.Objectmap<UniverseConnection>();
+
+  public async addConnection(universeConnectionArg: UniverseConnection) {
+    let universeConnection = universeConnectionArg;
+    universeConnection = await this.deduplicateUniverseConnection(universeConnection);
+    universeConnection = await this.authenticateAuthenticationRequests(universeConnection);
+  }
+
+  /**
+   * deduplicates UniverseConnections
+   */
+  public async deduplicateUniverseConnection (universeConnectionArg: UniverseConnection): Promise<UniverseConnection> {
+    let connectionToReturn: UniverseConnection;
+    this.connectionMap.forEach(async existingConnection => {
+      if (existingConnection.socketConnection = universeConnectionArg.socketConnection) {
+        connectionToReturn = await this.mergeUniverseConnections(existingConnection, universeConnectionArg);
+      }
+    });
+    if (!connectionToReturn) {
+      connectionToReturn = universeConnectionArg;
+    }
+    return connectionToReturn;
+
+  }
+
+  /**
+   * authenticate AuthenticationRequests
+   */
+  public authenticateAuthenticationRequests(universeConnectionArg): Promise<UniverseConnection> {
+    // TODO: authenticate connections
+    return universeConnectionArg;
+  }
+
+  /**
+   * merges two UniverseConnections
+   */
+  public mergeUniverseConnections (connectionArg1: UniverseConnection, connectionArg2: UniverseConnection) {
+    // TODO: merge connections
+    return connectionArg1;
+  }
+}

ts/smartuniverse.classes.universemessage.ts

@@ -14,7 +14,6 @@ import { IUniverseMessage } from './interfaces';
  * acts as a container to save message states like authentication status
  */
 export class UniverseMessage implements interfaces.IUniverseMessage {
-  
   public id: string;
 
   public timestamp: number;
@@ -40,7 +39,7 @@ export class UniverseMessage implements interfaces.IUniverseMessage {
    * wether the message is authenticated
    */
   public authenticated: boolean = null;
-  
+
   /**
    * a destruction timer for this message
    */