diff --git a/packages/resolver/index.js b/packages/resolver/index.js
index 560a7b7da82bb51cf9fcc007be8d85c716043489..4cd1a01b973f17409ee051c025c7ca5f05c0f6ea 100644
--- a/packages/resolver/index.js
+++ b/packages/resolver/index.js
@@ -8,7 +8,8 @@ const {
 } = require('./src/resolve-methods')
 const {
   getLocalValidator,
-  handleAuthMethods
+  handleAuthMethods,
+  getSocketAuthInterceptor
 } = require('./src/handle-auth-methods')
 // for 1.0.0 release (first on 0.9.8)
 // we also export the node client generator parts
@@ -33,8 +34,11 @@ module.exports = {
   searchResolvers,
   validateAndCall,
   getResolver,
+  
   handleAuthMethods,
   getLocalValidator,
+  getSocketAuthInterceptor,
+
   executeResolver,
   resolverRenderHandler,
   // for node clients
diff --git a/packages/resolver/package.json b/packages/resolver/package.json
index 444179166eb5be1989473d0a0fc7ac1056c2e437..1f16f799ed88746b1b6011a762833edecea926e5 100644
--- a/packages/resolver/package.json
+++ b/packages/resolver/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jsonql-resolver",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "This is NOT for general use, please do not install it directly. This module is part of the jsonql tools supporting modules.",
   "main": "index.js",
   "files": [
@@ -10,6 +10,7 @@
   "scripts": {
     "test": "ava",
     "prepare": "npm run test",
+    "test:socket": "DEBUG=jsonql-resolver* ava ./tests/socket.test.js",
     "test:base": "DEBUG=jsonql* ava  ./tests/base.test.js",
     "test:clients": "DEBUG=jsonql* ava  ./tests/clients.test.js",
     "test:throw": "DEBUG=jsonql-resolver* ava  ./tests/throw.test.js",
@@ -28,17 +29,17 @@
   },
   "dependencies": {
     "debug": "^4.1.1",
-    "jsonql-constants": "^1.9.1",
+    "jsonql-constants": "^1.9.8",
     "jsonql-errors": "^1.1.10",
     "jsonql-jwt": "^1.3.9",
     "jsonql-node-client": "^1.3.1",
     "jsonql-params-validator": "^1.5.2",
-    "jsonql-utils": "^1.0.0",
+    "jsonql-utils": "^1.0.6",
     "lodash.merge": "^4.6.2"
   },
   "devDependencies": {
     "ava": "^3.5.0",
-    "jsonql-contract": "^1.8.7",
+    "jsonql-contract": "^1.8.8",
     "jsonql-koa": "^1.6.2",
     "server-io-core": "^1.3.1"
   },
diff --git a/packages/resolver/src/handle-auth-methods.js b/packages/resolver/src/handle-auth-methods.js
index 9884b0c2b2c774a9f8b1038d49358f8ed4b37f6e..9ad23fa3b02a441184986021915b2e516535eeca 100644
--- a/packages/resolver/src/handle-auth-methods.js
+++ b/packages/resolver/src/handle-auth-methods.js
@@ -1,5 +1,14 @@
 // Auth methods handler
+const { join } = require('path')
 const {
+  SOCKET_NAME,
+  LOGIN_EVENT_NAME,
+  SWITCH_USER_EVENT_NAME,
+  LOGOUT_EVENT_NAME,
+  SA_LOGIN_EVENT_NAME,
+  CONNECTED_EVENT_NAME,
+  DISCONNECT_EVENT_NAME,
+  
   AUTH_TYPE,
   QUERY_ARG_NAME,
   UNAUTHORIZED_STATUS
@@ -85,7 +94,50 @@ const handleAuthMethods = async function(ctx, payload, opts, contract) {
   }
 }
 
+/**
+ * Construct the search path to find interceptors 
+ * @param {string} evtName type of event  
+ * @param {object} opts configuration
+ * @return {string} path to interceptor 
+ */
+function getPathByInterceptorType(evtName, opts) {
+  const { resolverDir } = opts
+  const basePath = join(resolverDir, SOCKET_NAME, AUTH_TYPE)
+
+  switch(evtName) {
+    case LOGIN_EVENT_NAME:
+    case SA_LOGIN_EVENT_NAME:
+      return join(basePath, opts.loginHandlerName)
+    case LOGOUT_EVENT_NAME:
+      return join(basePath, opts.logoutHandlerName)
+    case CONNECTED_EVENT_NAME:
+      // @TBC this should be an internal event handler
+    case DISCONNECT_EVENT_NAME:
+    case SWITCH_USER_EVENT_NAME:
+    default: 
+      // @TODO this feature is not going to implement until a few versions later 
+      throw new Error(`SWITCH_USER_EVENT_NAME is not implement`)
+  }
+}
+
+
+/**
+ * @TODO for socket to add auth interceptors
+ * @param {string} evtName of the interceptor
+ * @param {object} contract full contract
+ * @param {object} opts configuration 
+ * @return {function} the interceptor method to handle the callback 
+ */
+function getSocketAuthInterceptor(evtName, contract, opts) {
+  let pathToResolver = getSocketAuthInterceptor(evtName, opts)
+  
+  return pathToResolver
+}
+
+
 module.exports = {
   getLocalValidator,
-  handleAuthMethods
+  handleAuthMethods,
+  getPathByInterceptorType,
+  getSocketAuthInterceptor
 }
diff --git a/packages/resolver/tests/fixtures/contract/es/contract.json b/packages/resolver/tests/fixtures/contract/es/contract.json
index f81955d727e9bc096fe29099691ad605a0b49a80..37457228e9202379cadf75d9bd9fef47acaa85b9 100644
--- a/packages/resolver/tests/fixtures/contract/es/contract.json
+++ b/packages/resolver/tests/fixtures/contract/es/contract.json
@@ -43,6 +43,6 @@
     }
   },
   "auth": {},
-  "timestamp": 1583299808,
+  "timestamp": 1583902632,
   "sourceType": "module"
 }
diff --git a/packages/resolver/tests/socket.test.js b/packages/resolver/tests/socket.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..2624b13d7572d983532554a415605229e46a7ba1
--- /dev/null
+++ b/packages/resolver/tests/socket.test.js
@@ -0,0 +1,12 @@
+const test = require('ava')
+const { 
+  getPathByInterceptorType,
+  getSocketAuthInterceptor 
+} = require('../src/handle-auth-methods')
+
+test(`Just stub it here for the time being`, t => {
+  t.true(typeof getPathByInterceptorType === 'function')
+  t.true(typeof getSocketAuthInterceptor === 'function')
+})
+
+test.todo(`It should able to find socket auth interceptors`)
\ No newline at end of file
diff --git a/packages/ws-server-core/src/handles/get-socket-handler.js b/packages/ws-server-core/src/handles/get-socket-handler.js
index 1e4f5d32c386a6203502b01b93ac6513ea4a6d0c..05b11a5364347c99d3285c61a95a45d4aafc75c4 100644
--- a/packages/ws-server-core/src/handles/get-socket-handler.js
+++ b/packages/ws-server-core/src/handles/get-socket-handler.js
@@ -3,16 +3,15 @@ const {
   SA_LOGIN_EVENT_NAME,
   INTER_COM_EVENT_NAME
 } = require('jsonql-constants')
-const { SOCKET_STATE_KEY } = require('../options/constants')
-
+// const { SOCKET_STATE_KEY } = require('../options/constants')
+const { getNameFromPayload } = require('jsonql-utils')
 const { handleInterCom } = require('./handle-intercom')
 const { handleLogout } = require('./handle-logout')
 const { handleStandaloneLogin } = require('./handle-standalone-login')
 const { handleNspResolvers } = require('./handle-nsp-resolvers')
-// @TBC do we need this const { handleUnknownPayload } = require('./handle-unknown-payload')
 const { getRainbowDebug } = require('../share/helpers')
 
-const debug = getRainbowDebug('handles:get-socket-handler')
+const debug = getRainbowDebug('handles:get-socket-handler', 'whatever')
 
 /**
  * Make sure the resolver is belongs to this namespace
@@ -52,23 +51,30 @@ function getSocketHandler(config, ws, deliverFn, req, connectedNamespace, payloa
   const args = payload[resolverName]
   // it might be the special internal event?
   switch (true) {
-
     case resolverName === LOGOUT_EVENT_NAME:
+      debug('getSocketHandler:logout')
       // we don't need to send anything back @TBC do we need the config
       return handleLogout(ws, req, args, config)
 
     case resolverName === SA_LOGIN_EVENT_NAME:
+      debug('getSocketHandler:standaloneLogin')
       return handleStandaloneLogin(deliverFn, ws, req, args, config)
 
     case resolverName === INTER_COM_EVENT_NAME:
+      debug('getSocketHandler:intercom')
       // We don't need to send anything back // @TBC do we need the config
       return handleInterCom(config, ws, req, args, userdata)
 
     default:
 
-      const params = matchResolverByNamespace(resolverName, namespace, nspGroup)
-
-      handleNspResolvers(deliverFn, ws, resolverName, args, params, config, userdata)
+      const contractParam = matchResolverByNamespace(resolverName, connectedNamespace, nspGroup)
+      if (contractParam === false) {
+        return // exit
+      }
+      debug('getSocketHandler:default', contractParam)
+      handleNspResolvers(deliverFn, ws, resolverName, args, contractParam.params, config, userdata)
+      
   }
-
 }
+
+module.exports = { getSocketHandler }
\ No newline at end of file
diff --git a/packages/ws-server-core/src/handles/handle-nsp-resolvers.js b/packages/ws-server-core/src/handles/handle-nsp-resolvers.js
index 6d1335415d27dcf0d5d80ef7586466cf1cb9be4c..f854ec21a9f5d68e79ddf0dcaa3d9eb2a6658dde 100644
--- a/packages/ws-server-core/src/handles/handle-nsp-resolvers.js
+++ b/packages/ws-server-core/src/handles/handle-nsp-resolvers.js
@@ -2,10 +2,10 @@
 // @TODO this property still not create correctly
 // const { TIMESTAMP_PARAM_NAME } = require('jsonql-constants')
 // get the resolver to handle the request
-const { validateInput, deliverMsg } = require('../share/resolver-methods')
+const { validateInput, deliverMsg, handleError } = require('../share/resolver-methods')
 const { resolveSocketMethod } = require('../share/resolve-socket-method')
-const { getDebug } = require('./helpers')
-const debug = getDebug('share:get-resolver')
+const { getRainbowDebug } = require('../share/helpers')
+const debug = getRainbowDebug('handles:handle-nsp-resolver', 'x')
 
 /**
  * handle resolvers
@@ -19,6 +19,7 @@ const debug = getDebug('share:get-resolver')
  * @return {promise} resolve the result
  */
 const handleNspResolvers = (deliverFn, ws, resolverName, args, params, opts, userdata) => {
+  debug('handleNspResolvers', resolverName, args, params)
   // debug('TIMESTAMP_PARAM_NAME', json[TIMESTAMP_PARAM_NAME], TIMESTAMP_PARAM_NAME)
   // const ts = json[TIMESTAMP_PARAM_NAME] // keep this for use later
   // @NOTE the params.params is from the contract
@@ -27,15 +28,20 @@ const handleNspResolvers = (deliverFn, ws, resolverName, args, params, opts, use
         deliverFn,
         resolverName,
         args, // this is the clean value from validateAsync
-        params,
         opts,
         ws,
         userdata
       )
     )
-    .then(
-      result => deliveryMsg(deliverFn, result, resolverName)
-    )
+    .then(result => {
+      debug(`${resolverName} return result`, result)
+      return deliverMsg(deliverFn, resolverName, result)
+    })
+    .catch(err => {
+      // By the time the error gets here already become JsonqlError???
+      // rdebug('in the catch', err)
+      handleError(deliverFn, resolverName, err)
+    })
 }
 
 module.exports = { handleNspResolvers }
diff --git a/packages/ws-server-core/src/share/add-property.js b/packages/ws-server-core/src/share/add-property.js
index 68d379842461831195df3854d01f6f6de1c5b9a7..1d0ff2e71ea268d8e7469245468502c04f2418a1 100644
--- a/packages/ws-server-core/src/share/add-property.js
+++ b/packages/ws-server-core/src/share/add-property.js
@@ -1,17 +1,15 @@
 // add required properties to the resolver
 const {
-  EMIT_REPLY_TYPE,
-  SEND_MSG_FN_NAME,
   SOCKET_NAME,
   INIT_CLIENT_PROP_KEY
 } = require('jsonql-constants')
 // @BUG it's weird this file is not here but no error was throw
-const { objDefineProps, injectToFn } = require('jsonql-utils')
+const { injectToFn } = require('jsonql-utils')
 const { provideUserdata } = require('jsonql-jwt')
 const { injectNodeClient } = require('jsonql-resolver')
 const { createSend } = require('./create-send')
-const { nil, createWsReply, getDebug } = require('../share/helpers')
-const debug = getDebug(`addProperty`)
+const { getDebug } = require('../share/helpers')
+const debug = getDebug(`share:addProperty`)
 
 /**
  * using the serverType to provide different addProperty method to this
diff --git a/packages/ws-server-core/src/share/create-send.js b/packages/ws-server-core/src/share/create-send.js
index 9e047cba1a0103227eac55596d26230e56ff1cd3..6146ab8e35667c562a2d13fd7546b9e8ddae9f41 100644
--- a/packages/ws-server-core/src/share/create-send.js
+++ b/packages/ws-server-core/src/share/create-send.js
@@ -1,6 +1,6 @@
 const { SEND_MSG_FN_NAME } = require('jsonql-constants')
 const { objDefineProps } = require('jsonql-utils')
-const { deliveryMsg } = require('./resolver-methods')
+const { deliverMsg } = require('./resolver-methods')
 const { nil, getDebug } = require('./helpers')
 const debug = getDebug('create-send')
 
@@ -10,11 +10,10 @@ const debug = getDebug('create-send')
  * @param {function} deliveryFn framework specific to deliver message to client
  * @param {function} resolver the function itself
  * @param {string} resolverName the name of this resolver
- * @param {object} opts configuration
  * @return {function} resolver with a `send` method property
  */
-const createSend = function(deliveryFn, resolver, resolverName, opts) {
-  const params = opts.contract.socket[resolverName]
+const createSend = function(deliverFn, resolver, resolverName) {
+  // const params = opts.contract.socket[resolverName]
   
   return objDefineProps(
     resolver,
@@ -25,7 +24,7 @@ const createSend = function(deliveryFn, resolver, resolverName, opts) {
       // we should validate it against the return params
       return function sendCallback(...args) {
         debug('sendCallback', args)
-        deliveryMsg(deliverFn, args, resolverName)
+        deliverMsg(deliverFn, resolverName, args)
       }
     }
   )
diff --git a/packages/ws-server-core/src/share/helpers.js b/packages/ws-server-core/src/share/helpers.js
index 9ff343c0601811fefd04a13a389011cabc435dbc..526bbe93025285c2d73a883531d2c048c36c1fdc 100644
--- a/packages/ws-server-core/src/share/helpers.js
+++ b/packages/ws-server-core/src/share/helpers.js
@@ -1,7 +1,6 @@
 // Helpers methods
 // jsonql libraries
 const {
-  JSONQL_PATH,
   WS_REPLY_TYPE,
   WS_EVT_NAME,
   WS_DATA_NAME,
@@ -25,7 +24,6 @@ const {
   chainFns,
   objDefineProps,
   objHasProp,
-  groupByNamespace,
   getNspInfoByConfig
 } = require('jsonql-utils')
 const { isString } = require('jsonql-params-validator')
@@ -46,8 +44,6 @@ const getResolverFromPayload = payload => {
   return keys.filter(key => key !== TIMESTAMP_PARAM_NAME)[0]
 }
 
-
-
 /**
  * Create the debug instance
  * @param {string} name
@@ -59,12 +55,14 @@ const getDebug = name => debug(MODULE_NAME).extend(name)
  * Create a rainbow effect debug on the first string
  * help to id where the hell things coming from
  * @param {string} name the extended name
+ * @param {string} type just a switch to change color 
  * @return {function} the debug function
  */
-const getRainbowDebug = name => {
+const getRainbowDebug = (name, type = 'rainbow') => {
   const fn = getDebug(name)
+  const method = type === 'rainbow' ? colors.rainbow : colors.black.bgBrightYellow
   return (str, ...args) => {
-    Reflect.apply(fn, null, [colors.rainbow(str+'')].concat(args))
+    Reflect.apply(fn, null, [method(str+'')].concat(args))
   }
 }
 
diff --git a/packages/ws-server-core/src/share/resolve-socket-method.js b/packages/ws-server-core/src/share/resolve-socket-method.js
index 06ab183a262f95e8b13b85e49a1a592699a952f1..730c551500d7e62f88172385ee1ca3c11d3abbf5 100644
--- a/packages/ws-server-core/src/share/resolve-socket-method.js
+++ b/packages/ws-server-core/src/share/resolve-socket-method.js
@@ -4,35 +4,38 @@ const { SOCKET_NAME } = require('jsonql-constants')
 const { getResolver } = require('jsonql-resolver')
 const { getRainbowDebug } = require('./helpers')
 const { addProperty } = require('./add-property')
-const debug = getRainbowDebug('resolve-method')
+const debug = getRainbowDebug('share:resolve-method')
 
 /**
  * similiar to the one in Koa-middleware without the ctx
  * @param {function} deliverFn framework specific method
  * @param {string} resolverName name to call
  * @param {array} args arguments
- * @param {object} params from contract.json <-- why is this NOT IN USE?
  * @param {object} opts for search later
  * @param {object} ws the WebSocket instance
  * @param {object} [userdata=false] userdata
  * @return {promise} depends on the contract
  */
-const resolveSocketMethod = function(deliverFn, resolverName, args, params, opts, ws, userdata = false) {
-  // debug('wsServerCore.resolveSocketMethod', params) // check what is this then decided what to do later
-  // debug(`resolveMethod userdata`, userdata)
-  // the contract is always part of the options here
+const resolveSocketMethod = function(deliverFn, resolverName, args, opts, ws, userdata) {
+  debug('resolverSocketMethod')
   const { contract } = opts
+  
   const fn = getResolver(resolverName, SOCKET_NAME, contract, opts)
 
   return addProperty(deliverFn, fn, resolverName, ws, userdata, opts)
     .then(resolver =>  {
+      debug(`calling ${resolver} with`, args)
       try {
         return Reflect.apply(resolver, null, args)
       } catch(e) {
-        debug(`resolveMethod Error`, e)
+        debug(`resolveSocketMethod Error`, e)
         throw new JsonqlResolverAppError(resolverName, e)
       }
     })
+    .catch(err => {
+      debug(`catch error in catch phrase here`, err)
+      throw new JsonqlResolverAppError(resolverName, e)
+    })
 }
 
 // we only need to export one method
diff --git a/packages/ws-server-core/src/share/resolver-methods.js b/packages/ws-server-core/src/share/resolver-methods.js
index 0b5120bfa655f090ee96fece2909abff1bd0acc6..34bd8ae8edcb56d2bb1be66d85521090c19432d6 100644
--- a/packages/ws-server-core/src/share/resolver-methods.js
+++ b/packages/ws-server-core/src/share/resolver-methods.js
@@ -1,12 +1,12 @@
 // Take the code out from the run-resolver to share between other method
 const { packError } = require('jsonql-utils')
 const { isNotEmpty, validateAsync } = require('jsonql-params-validator')
-const { getDebug, createWsReply } = require('./helpers')
+const { getRainbowDebug, createWsReply } = require('./helpers')
 const {
   ACKNOWLEDGE_REPLY_TYPE,
   ERROR_TYPE
 } = require('jsonql-constants')
-const debug = getDebug('share:resolver-methods')
+const debug = getRainbowDebug('share:resolver-methods')
 
 
 /**
@@ -23,11 +23,11 @@ function validateInput(args, params) {
 /**
  * the final step to delivery the result to the client
  * @param {function} deliverFn framework specific method to delivery
- * @param {*} result from the resolver process
  * @param {string} resolverName that perform this method
+ * @param {*} result from the resolver process
  * @return {void}
  */
-function handleResult(deliverFn, result, resolverName) {
+function handleResult(deliverFn, resolverName, result) {
   debug('resolver return result', result)
   // decide if we need to call the cb or not here
   if (isNotEmpty(result)) {
@@ -40,12 +40,12 @@ function handleResult(deliverFn, result, resolverName) {
 /**
  * the final step to delivery the error to the client
  * @param {function} deliverFn framework specific method to delivery
- * @param {*} result from the resolver process
  * @param {string} resolverName that perform this method
+ * @param {*} err the error 
  * @return {void}
  */
-function handleError(deliverFn, result, resolverName) {
-  debug('CATCH RESOLVER ERROR', err)
+function handleError(deliverFn, resolverName, err) {
+  debug('--> CATCH RESOLVER ERROR <--', err)
   deliverFn(createWsReply(ERROR_TYPE, resolverName, packError(err)))
 }
 
@@ -53,19 +53,19 @@ function handleError(deliverFn, result, resolverName) {
 /**
  * The final step to delivery the message
  * @param {function} deliverFn framework specific method to delivery
- * @param {*} result from the resolver process
  * @param {string} resolverName that perform this method
+ * @param {*} result from the resolver process
  * @return {void}
  */
-function deliverMsg(deliverFn, result, resolverName) {
+function deliverMsg(deliverFn, resolverName, result) {
   return Promise
     .resolve(result)
-    .then(result => handleResult(deliverFn, result, resolverName))
-    .catch(err => handleError(deliverFn, err, resolverName))
+    .then(result => handleResult(deliverFn, resolverName, result))
 }
 
 
 module.exports = {
   validateInput,
-  deliverMsg
+  deliverMsg,
+  handleError
 }
diff --git a/packages/ws-server/package.json b/packages/ws-server/package.json
index b34e5944a4ccc7d4789cbc9ceba4c835cac7925c..5507ea81aa89b82ea6285ef0d158bd14709d9cb8 100755
--- a/packages/ws-server/package.json
+++ b/packages/ws-server/package.json
@@ -12,7 +12,7 @@
     "prepare": "npm run test",
     "test:basic": "DEBUG=jsonql-ws-server* ava ./tests/basic.test.js",
     "test:ws": "DEBUG=jsonql-ws-server* ava ./tests/ws-connect.test.js",
-    "test:error": "DEBUG=jsonql-ws-server* ava ./tests/ws-connect-error.test.js",
+    "test:error": "DEBUG=jsonql-* ava ./tests/ws-connect-error.test.js",
     "test:es6": "DEBUG=jsonql-ws-server* ava ./tests/ws-connect-es6.test.js",
     "test:jwt": "DEBUG=jsonql-ws-* ava ./tests/ws-jwt-auth.test.js",
     "contract": "node ./node_modules/jsonql-contract/cmd.js configFile ./tests/fixtures/contract-config.js",
diff --git a/packages/ws-server/src/core/create-ws-server.js b/packages/ws-server/src/core/create-ws-server.js
index c99ef00ae955d4640d08ecc321201da3841ab673..1850229df03f1f4a8b815103039d7002db8be80c 100644
--- a/packages/ws-server/src/core/create-ws-server.js
+++ b/packages/ws-server/src/core/create-ws-server.js
@@ -14,7 +14,7 @@ const colors = require('colors/safe')
 const generateNsp = config => {
   const namespaces = getNamespace(config)
   return namespaces
-    .map((name, i) => {
+    .map(name => {
       const verifyClient = createVerifyClient(name, config, config.publicKey)
       const opt = Object.assign({}, config.serverInitOption, { noServer: true, verifyClient })
       // How do we pass more options here
diff --git a/packages/ws-server/src/core/setup-socket-server.js b/packages/ws-server/src/core/setup-socket-server.js
index 2b51a25ce1fe5f5f15c856b5da95f010b9f1a76f..80f5fad97a9eedaba2cca9a6da12a2b985622115 100644
--- a/packages/ws-server/src/core/setup-socket-server.js
+++ b/packages/ws-server/src/core/setup-socket-server.js
@@ -1,94 +1,40 @@
 // ws setup all the listener to handle the incoming calls
-// const { finalCatch } = require('jsonql-errors')
 const { parseJson } = require('jsonql-utils')
 const {
-  LOGOUT_EVENT_NAME,
-  SA_LOGIN_EVENT_NAME,
-  INTER_COM_EVENT_NAME
-} = require('jsonql-constants')
-const {
-  handleNspResolvers,
-  handleInterCom,
-  handleLogout,
-  handleStandaloneLogin,
-  handleUnknownPayload,
-  getDebug,
+  getSocketHandler,
   getRainbowDebug,
-  getUserdata,
-  SOCKET_STATE_KEY
+  getUserdata
 } = require('../modules')
-
-const debug = getDebug('ws-setup')
 const rdebug = getRainbowDebug('ws-setup')
-
 const { createWsServer } = require('./create-ws-server')
 
 /**
- * This method get pass back to the ws-server-core to finish the setup
+ * This is the core of the communicaton engine 
+ * and this method get pass back to the ws-server-core to finish the setup
  * @param {object} opts configuration
  * @param {object} server the http server instance
  * @return {object} nspObj itself with addtional properties
  */
 function setupSocketServer(opts, server) {
-  const nspObj = createWsServer(opts, server)
-  const socketFns = opts.contract.socket
-  const { publicNamespace, nspGroup } = opts.nspInfo
-  // rdebug('nspInfo', nspInfo)
-  let deliverFn
-  // nspObj is coming from the ws-create-server
-  // it contains the namespace --> WebSocket instance
-  for (let namespace in nspObj) {
-    let userdata
-    nspObj[namespace].on('connection', (ws, req) => {
-      deliverFn = msg => ws.send(msg)
-
+  const nsps = createWsServer(opts, server)
+  // nsps[namespace] contains the namespace --> WebSocket instance
+  for (let namespace in nsps) {
+    nsps[namespace].on('connection', (ws, req) => {
+      let deliverFn = msg => ws.send(msg)
+      let userdata = getUserdata(req)
       rdebug(namespace, 'connected')
       // @TODO need to redo here the nspGroup can be empty???
       ws.on('message', data => {
-        let json = parseJson(data)
-        debug('ws.on.message called with: ', json)
-        // need to rethink about how this should get handle when it's mix with public and private methods
-        // 1) extract the resolver name and it should ONLY be in this particular obj
-        
-
-        if (nspGroup) {
-          let methodsInNsp = nspGroup[namespace]
-          // debug('nspGroup', namespace, methodsInNsp)
-          for (let resolverName in json) {
-            debug('inside the loop', resolverName, json)
-            switch (true) {
-              case resolverName === LOGOUT_EVENT_NAME:
-                return handleLogout(ws, req, json, opts)
-              case resolverName === SA_LOGIN_EVENT_NAME:
-                return handleStandaloneLogin(ws, req, json, opts)
-              case resolverName === INTER_COM_EVENT_NAME:
-                return handleInterCom(ws, req, json, socketFns, opts, getUserdata(req))
-              case methodsInNsp[resolverName] !== undefined:
-                debug('methodsInNsp[resolverName]', methodsInNsp[resolverName])
-                // only the private one will get a userdata property
-                if (namespace !== publicNamespace) {
-                  debug(`call get userdata`, req[SOCKET_STATE_KEY])
-                  userdata = getUserdata(req)
-                }
-                // this parameter is problematic too
-                handleNspResolvers(deliverFn, ws, json, socketFns, opts, userdata)
-                break
-              default:
-                handleUnknownPayload(ws, req, json, socketFns, opts, getUserdata(req))
-            }
-          }
-        } else { // just public nsp
-          // the bug is here but how come the client disconnect and reconnect can affect
-          // the server setup?
-          debug(`using public nsp`, namespace)
-          handleNspResolvers(deliverFn, ws, json, socketFns, opts)
-        }
+        let payload = parseJson(data)
+        rdebug(`${namespace} --> message`, payload)
+        // we now wrap everything in one generic method
+        getSocketHandler(opts, ws, deliverFn, req, namespace, payload, userdata)
       })
     })
   }
-  return nspObj
-}
 
+  return nsps 
+}
 
 
 module.exports = { setupSocketServer }
diff --git a/packages/ws-server/src/modules.js b/packages/ws-server/src/modules.js
index d2ce1cf6d9649341b57a746efcb67388f4641c1b..7fddab51f788d221ff9b243b35089d6672236b95 100644
--- a/packages/ws-server/src/modules.js
+++ b/packages/ws-server/src/modules.js
@@ -12,18 +12,14 @@ const {
   getRainbowDebug,
 
   createWsReply,
-  resolveSocketMethod,
+  // resolveSocketMethod,
 
   getUserdata,
   isUserdata,
   prepareUserdata,
 
   SOCKET_STATE_KEY,
-  handleInterCom,
-  handleLogout,
-  handleStandaloneLogin,
-  handleUnknownPayload,
-  handleNspResolvers
+  getSocketHandler
 } = require('../../ws-server-core')
 // require('jsonql-ws-server-core')
 module.exports = {
@@ -40,7 +36,7 @@ module.exports = {
   getRainbowDebug,
 
   createWsReply,
-  resolveSocketMethod,
+  // resolveSocketMethod,
 
   getUserdata,
   isUserdata,
@@ -48,9 +44,5 @@ module.exports = {
 
   SOCKET_STATE_KEY,
 
-  handleInterCom,
-  handleLogout,
-  handleStandaloneLogin,
-  handleUnknownPayload,
-  handleNspResolvers
+  getSocketHandler
 }
diff --git a/packages/ws-server/tests/basic.test.js b/packages/ws-server/tests/basic.test.js
index 4e66e8898e24db8b9a6a61ca33481c3f0262f15a..4e78be3ee2854d866dd56001e7831623ab56e7c6 100644
--- a/packages/ws-server/tests/basic.test.js
+++ b/packages/ws-server/tests/basic.test.js
@@ -65,8 +65,8 @@ test.cb('It should able to connect to public namespace without a token', t => {
 
   client.on('message', data => {
     let json = extractWsPayload(data)
-    // debug('reply', json)
-    t.truthy(json.data)
+    debug('reply', json)
+    t.is(json.data, 'You get a public message')
     // client.close()
     t.end()
   })
diff --git a/packages/ws-server/tests/ws-connect-error.test.js b/packages/ws-server/tests/ws-connect-error.test.js
index 19631b46775c0697d87a8a23016b2239fdc8014d..b24809d9b52ab6f5cc711d06bd184e28fd19e08f 100644
--- a/packages/ws-server/tests/ws-connect-error.test.js
+++ b/packages/ws-server/tests/ws-connect-error.test.js
@@ -56,8 +56,10 @@ test.cb(`It should able to extract the error object when error throw from the se
       debug('json decoded from msg: %O', data)
       // data.error = typeof data.error === 'string' ? JSON.parse(data.error) : data.error;
 
-      t.truthy(data.error, 'causeError should have error field')
+
       t.is(data.error.className, 'JsonqlResolverAppError')
+
+      t.truthy(data.error, 'causeError should have error field')
       t.is(json.type, ERROR_TYPE)
 
       // The same problem happens again