1.1.7

README.md

@@ -23,25 +23,38 @@ Under the hood we use socket.io and shortid for managed data exchange.
 ### Serverside
 ```typescript
 import * as smartsocket from "smartsocket";
+import * as q from q // q is a promise library
 
+// The "Smartsocket" listens on a port and can receive new "SocketConnection" requests.
 let mySmartsocket = new smartsocket.Smartsocket({
     port: 3000 // the port smartsocket will listen on
 });
 
+// A "SocketRole" can be referenced by "SocketFunction"s.
+// All "SocketRequest"s carry authentication data for a specific "SocketRole".
+// "SocketFunction"s know which "SocketRole"s are allowed to execute them
 let mySocketRole = new smartsocket.SocketRole({
     name: "someRoleName",
     passwordHash: "someHashedString"
 });
 
+// A "SocketFunction" executes a referenced function and passes in any data of the corresponding "SocketRequest".
+// The referenced function must return a promise and resolve with data of type any.
+// Any "SocketRequest" carries a unique identifier. If the referenced function's promise resolved any passed on argument will be returned to the requesting party 
 let testSocketFunction1 = new smartsocket.SocketFunction({
     funcName:"testSocketFunction1",
     funcDef:(data) => {
-        
-    }, // the function to execute
+        console.log('testSocketFunction1 executed successfully!')
+    },
     allowedRoles:[mySocketRole] // all roles that have access to a specific function
 });
 
-mySmartsocket.clientCall("","restart",data,someTargetConnection)
+// A "Smartsocket" exposes a .clientCall() that gets
+// 1. the name of the "SocketFunction" on the client side
+// 2. the data to pass in
+// 3. And a target "SocketConnection" (there can be multiple connections at once)
+// any unique id association is done internally
+mySmartsocket.clientCall("restart",data,someTargetConnection)
     .then((responseData) => {
 
     });
@@ -51,6 +64,8 @@ mySmartsocket.clientCall("","restart",data,someTargetConnection)
 ```typescript
 import * as smartsocket from "smartsocket";
 
+// A "SmartsocketClient" is different from a "Smartsocket" in that it doesn't expose any public address.
+// Thus any new "SocketConnection"s must be innitiated from a "SmartsocketClient".
 let testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: "http://localhost",
@@ -58,24 +73,22 @@ let testSmartsocketClient = new smartsocket.SmartsocketClient({
     alias: "testClient1",
     role: "testRole1"
 });
+
+// You can .connect() and .disconnect() from a "Smartsocket"
 testSmartsocketClient.connect()
     .then(() => {
         done();
     });
 
+// The client can also specify "SocketFunction"s. It can also specify "SocketRole"s in case a client connects to multiple servers at once
 let testSocketFunction2 = new smartsocket.SocketFunction({
     funcName: "testSocketFunction2",
     funcDef: (data) => {}, // the function to execute, has to return promise
     allowedRoles:[]
 });
 
-let functionCalldata = {
-    funcName: "",
-    funcData: {
-        someKey:"someValue"
-    }
-}
 
+// A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
 mySmartsocketClient.serverCall("function",functionCallData)
     .then((functionResponseData) => { // the functionResponseData comes from the server... awesome, right?
         

package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartsocket",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "easy and secure websocket communication, Typescript ready",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

test/test.ts

@@ -3,12 +3,12 @@ import should = require("should");
 import socketIoClient = require("socket.io-client");
 import smartsocket = require("../dist/index");
 import q = require("q");
-import nodehash = require("nodehash");
+import nodehash = require("nodehash")
 
-let testSmartsocket: smartsocket.Smartsocket;
-let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSmartsocket: smartsocket.Smartsocket
+let testSmartsocketClient: smartsocket.SmartsocketClient
+let testSocketRole1: smartsocket.SocketRole
+let testSocketFunction1: smartsocket.SocketFunction
 
 let testConfig = {
     port: 3000