1.0.41

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartuniverse",
-  "version": "1.0.38",
+  "version": "1.0.41",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartuniverse",
-  "version": "1.0.38",
+  "version": "1.0.41",
   "private": false,
   "description": "messaging service for your micro services",
   "main": "dist/index.js",

test/test.ts

@@ -5,13 +5,13 @@ import * as smartuniverse from '../ts/index';
 import { Observable } from 'rxjs';
 
 let testUniverse: smartuniverse.Universe;
-let testUniverseClient: smartuniverse.ClientUniverse;
+let testClientUniverse: smartuniverse.ClientUniverse;
 let testClientChannel: smartuniverse.ClientUniverseChannel;
 
 const testChannelData = {
   channelName: 'awesomeTestChannel',
   channelPass: 'awesomeChannelPAss'
-}
+};
 
 tap.test('first test', async () => {
   testUniverse = new smartuniverse.Universe({
@@ -25,10 +25,10 @@ tap.test('add a message to the SmartUniverse', async () => {
 
 // testing message handling
 tap.test('create smartuniverse client', async () => {
-  testUniverseClient = new smartuniverse.ClientUniverse({
+  testClientUniverse = new smartuniverse.ClientUniverse({
     serverAddress: 'http://localhost:8765'
   });
-  expect(testUniverseClient).to.be.instanceof(smartuniverse.ClientUniverse);
+  expect(testClientUniverse).to.be.instanceof(smartuniverse.ClientUniverse);
 });
 
 tap.test('should add a channel to the universe', async () => {
@@ -36,23 +36,21 @@ tap.test('should add a channel to the universe', async () => {
 });
 
 tap.test('should get a observable correctly', async () => {
-  testClientChannel = await testUniverseClient.getChannel(testChannelData.channelName, testChannelData.channelPass);
+  testClientChannel = await testClientUniverse.getChannel(testChannelData.channelName);
   expect(testClientChannel).to.be.instanceof(smartuniverse.ClientUniverseChannel);
 });
 
 tap.test('should send a message correctly', async () => {
-  await testUniverseClient.sendMessage({
+  await testClientUniverse.sendMessage({
     messageText: 'hello',
-    passphrase: 'wowza',
-    targetChannelName: 'channel1',
-    
+    targetChannelName: 'channel1'
   });
 });
 
 tap.test('should receive a message correctly', async () => {});
 
 tap.test('should disconnect the client correctly', async () => {
-  testUniverseClient.close();
+  testClientUniverse.close();
 });
 
 tap.test('should end the server correctly', async tools => {

ts/smartuniverse.classes.clientuniverse.ts

@@ -31,11 +31,43 @@ export class ClientUniverse {
     this.options = optionsArg;
   }
 
+  /**
+   * 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);
+
+    if (existingChannel) {
+      throw new Error('channel exists');
+    }
+
+    // lets create the channel
+    ClientUniverseChannel.createClientUniverseChannel(
+      this,
+      channelNameArg,
+      passphraseArg
+    );
+  }
+
+  /**
+   * gets a channel from the channelcache
+   * @param channelName
+   * @param passphraseArg 
+   */
+  public async getChannel(channelName: string): Promise<ClientUniverseChannel> {
+    await this.checkConnection();
+    const clientUniverseChannel = this.channelCache.find(channel => {
+      return channel.name === channelName;
+    })
+    return clientUniverseChannel;
+  }
+
   public async sendMessage(messageArg: interfaces.IMessageCreator) {
     const requestBody: interfaces.IUniverseMessage = {
       id: plugins.smartunique.shortId(),
       timestamp: Date.now(),
-      passphrase: (await this.getChannel(messageArg.targetChannelName)).,
+      passphrase: (await this.getChannel(messageArg.targetChannelName)).passphrase,
       ...messageArg,
 
     };
@@ -46,21 +78,15 @@ export class ClientUniverse {
     });
   }
 
-  public async getChannel(channelName: string, passphraseArg?: string): Promise<ClientUniverseChannel> {
-    await this.checkConnection();
-    const clientUniverseChannel = await ClientUniverseChannel.createClientUniverseChannel(
-      this,
-      channelName
-    );
-    this.channelCache.add(clientUniverseChannel);
-    return clientUniverseChannel;
-  }
-
   public close() {
     this.socketClient.disconnect();
   }
 
-  private async checkConnection() {
+  /**
+   * checks the connection towards a universe server
+   * since password validation is done through other means, a connection should always be possible
+   */
+  private async checkConnection(): Promise<void> {
     if (!this.socketClient && !this.observableIntake) {
       const parsedURL = url.parse(this.options.serverAddress);
       this.socketClient = new SmartsocketClient({

ts/smartuniverse.classes.clientuniversechannel.ts

@@ -7,13 +7,20 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   // ======
   // STATIC
   // ======
+  /**
+   * creates a channel and adds it to the cache of clientUniverseArg
+   * @param clientUniverseArg
+   * @param channelNameArg 
+   * @param passphraseArg 
+   */
   public static async createClientUniverseChannel(
     clientUniverseArg: ClientUniverse,
-    channelName: string,
+    channelNameArg: string,
     passphraseArg: string
   ): Promise<ClientUniverseChannel> {
-    const clientChannel = new ClientUniverseChannel(clientUniverseArg, passphraseArg);
-    await clientChannel.transmitSubscription();
+    const clientChannel = new ClientUniverseChannel(clientUniverseArg, channelNameArg, passphraseArg);
+    clientUniverseArg.channelCache.add(clientChannel);
+    await clientChannel.subscribe();
     return clientChannel;
   }
 
@@ -21,18 +28,24 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   // INSTANCE
   // ========
 
-  public clientUniverse: ClientUniverse;
+  // properties
+  public name: string;
   public passphrase: string;
-
-  constructor(clientUniverseArg: ClientUniverse, passphraseArg: string) {
+  
+  // refs
+  public clientUniverse: ClientUniverse;
+  
+  constructor(clientUniverseArg: ClientUniverse, nameArg: string,  passphraseArg: string) {
     this.clientUniverse = clientUniverseArg;
-    this.passphrase = passphraseArg
+    this.name = nameArg;
+    this.passphrase = passphraseArg;
   }
 
   /**
+   * subscribes to a channel
    * tells the universe about this instances interest into a channel
    */
-  public async transmitSubscription() {
+  public async subscribe() {
     this.clientUniverse.socketClient;
   }
 }

ts/smartuniverse.classes.universe.ts

@@ -101,7 +101,9 @@ export class Universe {
     const SubscriptionSocketFunction = new plugins.smartsocket.SocketFunction({
       allowedRoles: [ClientRole],
       funcName: 'channelSubscription',
-      funcDef: () => {} // TODO: implement an action upon connection of clients
+      funcDef: () => {
+        console.log('a client connected');
+      } // TODO: implement an action upon connection of clients
     });
 
     // add smartsocket to the running smartexpress app

ts/smartuniverse.classes.universechannel.ts

@@ -83,8 +83,8 @@ export class UniverseChannel {
    */
   public authenticate(universeMessageArg: UniverseMessage): boolean {
     return (
-      this.name === universeMessageArg.requestedChannelName &&
-      this.passphrase === universeMessageArg.requestedChannelPassphrase
+      this.name === universeMessageArg.targetChannelName &&
+      this.passphrase === universeMessageArg.passphrase
     );
   }