vrpc 2.6.0 → 3.0.0

package/vrpc/VrpcAdapter.js

@@ -10,13 +10,13 @@ __\/\\\_______\/\\\__/\\\///////\\\___\/\\\/////////\\\____/\\\////////__
        ________\///________\///________\///__\///___________________\/////////__
 
 
-Non-intrusively binds code and provides access in form of asynchronous remote
+Non-intrusively adapts code and provides access in form of asynchronous remote
 procedure calls (RPC).
-Author: Dr. Burkhard C. Heisen (https://github.com/bheisen/vrpc)
+Author: Dr. Burkhard C. Heisen (https://github.com/heisenware/vrpc)
 
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-Copyright (c) 2018 - 2021 Dr. Burkhard C. Heisen <burkhard.heisen@heisenware.com>.
+Copyright (c) 2018 - 2022 Dr. Burkhard C. Heisen <burkhard.heisen@heisenware.com>.
 
 Permission is hereby  granted, free of charge, to any  person obtaining a copy
 of this software and associated  documentation files (the "Software"), to deal
@@ -42,9 +42,9 @@ const path = require('path')
 const fs = require('fs')
 const Ajv = require('ajv')
 const caller = require('caller')
-const { nanoid } = require('nanoid')
 const commentParser = require('./comment-parser')
 const EventEmitter = require('events')
+const { nanoid } = require('nanoid')
 
 /**
  * Generates an adapter layer for existing code and enables further VRPC-based
@@ -101,17 +101,20 @@ class VrpcAdapter {
    * NOTE: This function currently only supports registration of classes (either
    * when provided as object or when exported on the provided module path)
    */
-  static register (code, options = {}) {
+   static register (code, options = {}) {
     if (typeof code === 'string') {
       const absPath = path.resolve(caller(), '../', code)
       const relPath = path.relative(__dirname, absPath)
-      const absJsdocPath = `${absPath}.js`
+      const absJsdocPath =
+        absPath && absPath.endsWith('.js') ? absPath : `${absPath}.js`
       const Klass = require(relPath)
       this._registerClass(Klass, absJsdocPath, options)
     } else {
       const { jsdocPath } = options
+      const sJsdocPath =
+        jsdocPath && jsdocPath.endsWith('.js') ? jsdocPath : `${jsdocPath}.js`
       if (jsdocPath) {
-        const absJsdocPath = path.resolve(caller(), '../', `${jsdocPath}.js`)
+        const absJsdocPath = path.resolve(caller(), '../', sJsdocPath)
         this._registerClass(code, absJsdocPath, { ...options, jsdoc: true })
       } else {
         this._registerClass(code, null, options)
@@ -147,92 +150,73 @@ class VrpcAdapter {
       const content = fs.readFileSync(absJsdocPath).toString('utf8')
       meta = this._parseComments(content)
     }
-    VrpcAdapter._functionRegistry.set(className, {
-      memberFunctions,
-      meta,
-      Klass: {},
-      withNew: false,
-      staticFunctions: ['__getNamed__'],
-      schema: null
+    if (!VrpcAdapter._functionRegistry.has(className)) {
+      VrpcAdapter._functionRegistry.set(className, {
+        memberFunctions,
+        meta,
+        Klass: {},
+        withNew: false,
+        staticFunctions: [],
+        schema: null
+      })
+    }
+    VrpcAdapter._instances.set(instance, {
+      className,
+      instance: obj,
+      isIsolated: false
     })
-    VrpcAdapter._instances.set(instance, { className, instance: obj })
-  }
-
-  static getClasses () {
-    return JSON.stringify(VrpcAdapter._getClassesArray())
-  }
-
-  static getMemberFunctions (className) {
-    return JSON.stringify(VrpcAdapter._getMemberFunctionsArray(className))
-  }
-
-  static getStaticFunctions (className) {
-    return JSON.stringify(VrpcAdapter._getStaticFunctionsArray(className))
-  }
-
-  static getMetaData (className) {
-    return JSON.stringify(VrpcAdapter._getMetaData(className))
-  }
-
-  static getInstances (className) {
-    return JSON.stringify(VrpcAdapter._getInstancesArray(className))
-  }
-
-  static call (jsonString) {
-    const json = JSON.parse(jsonString)
-    VrpcAdapter._call(json)
-    return JSON.stringify(json)
   }
 
-  static onCallback (callback) {
-    VrpcAdapter._callback = callback
-  }
-
-  // convenience interface if used in parallel - as local factory and from remote
-
-  /**
-   * Creates an un-managed, anonymous instance
-   *
-   * @param {String} className Name of the class to create an instance of
-   * @param  {...any} args  Arguments to provide to the constructor
-   * @returns {Object} The real instance (not a proxy!)
-   */
-  static create (className, ...args) {
-    if (typeof className === 'string') {
-      return VrpcAdapter._create(className, ...args)
-    }
-    if (typeof className === 'object') {
-      if (className.instance) {
-        return VrpcAdapter._createNamed(
-          className.className,
-          className.instance,
-          ...className.args
-        )
-      }
-      return VrpcAdapter._create(className.className, ...className.args)
-    }
-  }
+  /*****************************************************
+   * convenience interface if used as plug-able factory *
+   ******************************************************/
 
   /**
-   * Creates a managed named instance
+   * Creates a new instance
    *
-   * @param {String} className Name of the class to create an instance of
-   * @param {String} instance Name of the instance
-   * @param  {...any} args Arguments to provide to the constructor
+   * @param {Object} options
+   * @param {String} options.className Name of the class which should be
+   * instantiated
+   * @param {String} [options.instance] Name of the created instance. If not
+   * provided an id will be generated
+   * @param {Array} [options.args] Positional arguments for the constructor call
+   * @param {bool} [options.isIsolated=false] If true the created instance will
+   * be visible only to the client who created it
    * @returns {Object} The real instance (not a proxy!)
    */
-  static createNamed (className, instance, ...args) {
-    return VrpcAdapter._createNamed(className, instance, ...args)
+  static create ({
+    className,
+    instance = nanoid(8),
+    args = [],
+    isIsolated = false
+  } = {}) {
+    const json = { c: className, a: [instance, ...args] }
+    const obj = isIsolated
+      ? VrpcAdapter._handleCreateIsolated(json)
+      : VrpcAdapter._handleCreateShared(json)
+    if (json.e) throw new Error(json.e)
+    return obj
   }
 
   /**
-   * Deletes a managed instance
+   * Deletes an instance
    *
-   * @param {String} instance Name of the instance to be deleted
+   * @param {String|Object} instance Instance (name or object itself) to be deleted
    * @returns {Boolean} True in case of success, false otherwise
    */
   static delete (instance) {
-    return VrpcAdapter._delete(instance)
+    if (typeof instance === 'string') {
+      return VrpcAdapter._delete(instance)
+    }
+    if (typeof instance === 'object') {
+      for (const [k, v] of VrpcAdapter._instances) {
+        if (v.instance === instance) {
+          VrpcAdapter._instances.delete(k)
+          return true
+        }
+      }
+      return false
+    }
   }
 
   /**
@@ -266,34 +250,14 @@ class VrpcAdapter {
     return VrpcAdapter._getInstancesArray(className)
   }
 
-  /**
-   * Provides all available member functions of the specified class.
-   *
-   * @param {String} className Name of class to provide member functions for
-   * @return {Array.<String>} Array of member function names
-   */
-  static getAvailableMemberFunctions (className) {
-    return VrpcAdapter._getMemberFunctionsArray(className)
-  }
-
-  /**
-   * Provides all available static functions of a registered class.
-   *
-   * @param {String} className Name of class to provide static functions for
-   * @returns {Array.<String>} Array of static function names
-   */
-  static getAvailableStaticFunctions (className) {
-    return VrpcAdapter._getStaticFunctionsArray(className)
+  static call (jsonString) {
+    const json = JSON.parse(jsonString)
+    VrpcAdapter._call(json)
+    return JSON.stringify(json)
   }
 
-  /**
-   * Provides all available meta data of the registered class.
-   *
-   * @param {String} className Name of class to provide meta data for
-   * @returns {MetaData} Meta Data
-   */
-  static getAvailableMetaData (className) {
-    return VrpcAdapter._getMetaData(className)
+  static onCallback (callback) {
+    VrpcAdapter._callback = callback
   }
 
   /**
@@ -351,11 +315,10 @@ class VrpcAdapter {
       staticFunctions = staticFunctions.filter(f => !f.startsWith('_'))
     }
     // Inject constructor and destructor
-    staticFunctions.push('__create__')
-    staticFunctions.push('__delete__')
-    staticFunctions.push('__createNamed__')
-    staticFunctions.push('__getNamed__')
+    staticFunctions.push('__createIsolated__')
+    staticFunctions.push('__createShared__')
     staticFunctions.push('__callAll__')
+    staticFunctions.push('__delete__')
     let memberFunctions = VrpcAdapter._extractMemberFunctions(Klass)
     if (onlyPublic) {
       memberFunctions = memberFunctions.filter(f => {
@@ -416,7 +379,7 @@ class VrpcAdapter {
               },
               ...params
             ]
-            meta.__createNamed__ = { description, params: modified, ret }
+            meta.__createShared__ = { description, params: modified, ret }
           } else {
             meta[functionName] = { description, params, ret }
           }
@@ -427,99 +390,98 @@ class VrpcAdapter {
   }
 
   static _call (json) {
-    const { method } = json
-    switch (method) {
-      case '__create__':
-        VrpcAdapter._handleCreate(json)
+    const before = Object.keys(VrpcAdapter._listeners).length
+    switch (json.f) {
+      case '__createIsolated__':
+        VrpcAdapter._handleCreateIsolated(json)
         break
-      case '__delete__':
-        VrpcAdapter._handleDelete(json)
-        break
-      case '__createNamed__':
-        VrpcAdapter._handleCreateNamed(json)
-        break
-      case '__getNamed__':
-        VrpcAdapter._handleGetNamed(json)
+      case '__createShared__':
+        VrpcAdapter._handleCreateShared(json)
         break
       case '__callAll__':
         VrpcAdapter._handleCallAll(json)
         break
+      case '__delete__':
+        VrpcAdapter._handleDelete(json)
+        break
       default:
+        // this call may have the side-effect of taking a listener on board
         VrpcAdapter._handleCall(json)
     }
+    const after = Object.keys(VrpcAdapter._listeners).length
+    // if we took a listener on board we must tell our caller such that
+    // things can be cleaned up later.
+    return after > before
   }
 
-  static _handleCreate (json) {
-    const { context, data } = json
+  static _handleCreateIsolated (json) {
+    let instance
     try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      const instance = VrpcAdapter._create(context, ...wrappedArgs)
-      const instanceId = nanoid(9)
-      VrpcAdapter._instances.set(instanceId, { context, instance })
-      data.r = instanceId
-    } catch (err) {
-      data.e = err.message
-    }
-  }
-
-  static _handleDelete (json) {
-    const { context, data } = json
-    try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      const instanceId = wrappedArgs[0]
-      data.r = VrpcAdapter._delete(instanceId)
-      VrpcAdapter._emitter.emit('delete', {
-        className: context,
-        instance: wrappedArgs[0]
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: true
       })
-    } catch (err) {
-      data.e = err.message
-    }
-  }
-
-  static _handleCreateNamed (json) {
-    const { context, data } = json
-    try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      VrpcAdapter._createNamed(context, ...wrappedArgs)
-      data.r = wrappedArgs[0] // First argument is instanceId
       VrpcAdapter._emitter.emit('create', {
-        className: context,
-        instance: wrappedArgs[0],
-        args: wrappedArgs.slice(1)
+        args,
+        className,
+        isIsolated: true,
+        instance: instanceId
       })
+      json.r = instanceId
     } catch (err) {
-      data.e = err.message
+      json.e = err.message
     }
+    return instance
   }
 
-  static _handleGetNamed (json) {
-    const { data } = json
+  static _handleCreateShared (json) {
+    let instance
     try {
-      const wrappedArgs = VrpcAdapter._wrapArguments(json)
-      const instanceId = wrappedArgs[0]
-      const entry = VrpcAdapter._instances.get(instanceId)
-      if (entry) data.r = instanceId
-      else data.e = `Instance with id: ${instanceId} does not exist`
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: false
+      })
+      json.r = instanceId
+      VrpcAdapter._emitter.emit('create', {
+        args,
+        className,
+        isIsolated: false,
+        instance: instanceId
+      })
     } catch (err) {
-      data.e = err.message
+      json.e = err.message
     }
+    return instance
   }
 
   static _handleCallAll (json) {
-    const { context, method, data } = json
     try {
       const calls = []
-      for (const [id, { className, instance }] of VrpcAdapter._instances) {
-        if (className !== context) continue
-        let v
+      for (const [
+        id,
+        { className, instance, isIsolated }
+      ] of VrpcAdapter._instances) {
+        // TODO Think about a configurable behavior w.r.t. isolated instances...
+        if (className !== json.c || isIsolated) continue
+        let v = true
         let e = null
         try {
-          const wrappedArgs = VrpcAdapter._wrapArguments(json, id)
-          const funcName = wrappedArgs[0]
-          v = instance[funcName].apply(instance, wrappedArgs.slice(1))
+          const unwrapped = VrpcAdapter._unwrapArguments(json, id)
+          if (unwrapped) {
+            const funcName = unwrapped[0]
+            v = instance[funcName].apply(instance, unwrapped.slice(1))
+            v = VrpcAdapter.sanitizeEventListenerReturnValues(v)
+          }
         } catch (err) {
-          e = err
+          e = err.message
         }
         if (VrpcAdapter._isPromise(v)) {
           calls.push(
@@ -531,17 +493,48 @@ class VrpcAdapter {
           calls.push({ id, val: v, err: e })
         }
       }
-      this._handlePromise(json, method, Promise.all(calls))
+      this._handlePromise(json, Promise.all(calls))
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static sanitizeEventListenerReturnValues (ret) {
+    return typeof ret === 'object' &&
+      ret._events !== undefined &&
+      ret._eventsCount !== undefined
+      ? true
+      : ret
+  }
+
+  static _handleDelete (json) {
+    try {
+      const instance = json.a[0] // first arg is instance to be deleted
+      json.r = VrpcAdapter._delete(instance)
+      VrpcAdapter._emitter.emit('delete', {
+        instance,
+        className: json.c
+      })
     } catch (err) {
-      data.e = err.message
+      json.e = err.message
     }
   }
 
   static _handleCall (json) {
-    const { context, method, data } = json
-    const wrappedArgs = VrpcAdapter._wrapArguments(json)
+    // special case: removeAllListeners
+    if (json.f === 'removeAllListeners') {
+      VrpcAdapter._removeAllListeners(json.a[0], json.s, json.c)
+      json.r = true
+      return
+    }
+    const unwrapped = VrpcAdapter._unwrapArguments(json)
+    if (!unwrapped) {
+      // this call must be skipped (event emitter stuff)
+      json.r = true
+      return
+    }
     // Check whether context is a registered class
-    const entry = VrpcAdapter._functionRegistry.get(context)
+    const entry = VrpcAdapter._functionRegistry.get(json.c)
     if (entry !== undefined) {
       // entry is class -> function is static
       const { Klass } = entry
@@ -549,39 +542,42 @@ class VrpcAdapter {
       // rather sticking to those functions registered before...
       // TODO This is even more important now as the agent does a wildcard
       // subscription against all functions
-      if (VrpcAdapter._isFunction(Klass[method])) {
+      if (VrpcAdapter._isFunction(Klass[json.f])) {
         try {
-          const ret = Klass[method].apply(null, wrappedArgs)
+          const ret = Klass[json.f].apply(null, unwrapped)
           // check if function returns promise
           if (VrpcAdapter._isPromise(ret)) {
-            this._handlePromise(json, method, ret)
-          } else data.r = ret
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-      } else throw new Error(`Could not find function: ${method}`)
+      } else throw new Error(`Could not find function: ${json.f}`)
     } else {
       // is not static
-      const entry = VrpcAdapter._instances.get(context)
+      const entry = VrpcAdapter._instances.get(json.c)
       if (entry === undefined) {
-        throw new Error(`Could not find context: ${context}`)
+        throw new Error(`Could not find context: ${json.c}`)
       }
       const { instance } = entry
-      if (VrpcAdapter._isFunction(instance[method])) {
+      if (VrpcAdapter._isFunction(instance[json.f])) {
         try {
-          const ret = instance[method].apply(instance, wrappedArgs)
+          let ret = instance[json.f].apply(instance, unwrapped)
+          ret = VrpcAdapter.sanitizeEventListenerReturnValues(ret)
           // check if function returns promise
           if (VrpcAdapter._isPromise(ret)) {
-            this._handlePromise(json, method, ret)
-          } else data.r = ret
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-      } else throw new Error(`Could not find function: ${method}`)
+      } else throw new Error(`Could not find function: ${json.f}`)
     }
   }
 
-  static _create (className, ...args) {
+  static _create (className, instanceId, ...args) {
+    const entry = VrpcAdapter._instances.get(instanceId)
+    if (entry) return entry.instance
     const { Klass, withNew, schema } = VrpcAdapter._getClassEntry(className)
     if (schema !== null) {
       VrpcAdapter._validate(schema, ...args)
@@ -590,33 +586,39 @@ class VrpcAdapter {
     return Klass(...args)
   }
 
-  static _createNamed (className, instanceId, ...args) {
-    const entry = VrpcAdapter._instances.get(instanceId)
-    if (!entry) {
-      const instance = VrpcAdapter._create(className, ...args)
-      VrpcAdapter._instances.set(instanceId, { className, instance })
-      return instance
-    }
-    return entry.instance
-  }
-
   static _delete (instanceId) {
     const entry = VrpcAdapter._instances.get(instanceId)
     if (entry) {
+      // in case the instance was an EventEmitter, free all registered listeners
+      if (VrpcAdapter._isFunction(entry.removeAllListeners)) {
+        entry.removeAllListeners()
+      }
+      for (const [key, { clients, instance }] of Object.entries(
+        VrpcAdapter._listeners
+      )) {
+        if (instance === instanceId) {
+          VrpcAdapter._listeners[key] = { clients }
+        }
+      }
       VrpcAdapter._instances.delete(instanceId)
       return true
     }
     return false
   }
 
-  static _unregisterEventListeners (clientId) {
-    const listeners = VrpcAdapter._listeners[clientId]
-    if (listeners) {
-      listeners.forEach(({ i, e, f }) => {
-        VrpcAdapter.getInstance(i).removeListener(e, f)
-      })
+  static _unregisterClient (clientId) {
+    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
+      const { instance, event, listener, clients } = value
+      const filteredClients = clients.filter(x => x !== clientId)
+      if (filteredClients.length === 0) {
+        if (event) {
+          VrpcAdapter.getInstance(instance).removeListener(event, listener)
+        }
+        delete VrpcAdapter._listeners[key]
+      } else {
+        VrpcAdapter._listeners[key].clients = filteredClients
+      }
     }
-    delete VrpcAdapter._listeners[clientId]
   }
 
   static _validate (schema, params) {
@@ -627,119 +629,99 @@ class VrpcAdapter {
     if (!valid) throw new Error(VrpcAdapter._ajv.errorsText())
   }
 
-  static _wrapArguments (json, instanceId) {
-    const { method, sender, data, context } = json
-    const args = VrpcAdapter._extractDataToArray(data)
-    const wrappedArgs = []
-    args.forEach(arg => {
-      // Find those args that actually need to be function callbacks
-      if (typeof arg === 'string' && arg.substr(0, 5) === '__f__') {
-        const f = this._generateWrapper(arg, json, instanceId)
-        wrappedArgs.push(f)
-        if (!sender) return
-        // Register this client to later know when he is dead and skip callbacks
-        if (!VrpcAdapter._listeners[sender]) VrpcAdapter._listeners[sender] = []
-        // Check whether injected callback is an EventEmitter registration
-        if (method === 'on' && typeof args[0] === 'string') {
-          const e = args[0]
-          const i = context
-          const r = arg
-          VrpcAdapter._listeners[sender].push({ i, e, f, r })
+  static _unwrapArguments (json, instanceId) {
+    const { f: func, s: sender, a: args, c: context } = json
+    const unwrapped = []
+    for (const arg of args) {
+      // find those args that actually need to be functions
+      if (typeof arg === 'string' && arg.slice(0, 5) === '__f__') {
+        const callback = this._generateCallback(arg, json, instanceId)
+        unwrapped.push(callback)
+      } else if (typeof arg === 'string' && arg.slice(0, 5) === '__e__') {
+        const listener = this._generateListener(arg, json, instanceId)
+        unwrapped.push(listener)
+        // start tracking clients that are registering event listeners
+        if (!VrpcAdapter._listeners[arg]) {
+          VrpcAdapter._listeners[arg] = {
+            listener,
+            clients: [sender],
+            instance: context,
+            event: null
+          }
+        } else {
+          VrpcAdapter._listeners[arg].clients.push(sender)
         }
-        if (
-          (method === 'off' || method === 'removeListener') &&
-          typeof args[0] === 'string'
-        ) {
-          const r = arg
-          const s = VrpcAdapter._listeners[sender]
-          const entry = s && s.find(x => x.r === r)
-          if (entry) {
-            const { i, e, f } = entry
-            VrpcAdapter.getInstance(i).removeListener(e, f)
+        // see whether the requested listener is an EventEmitter registration
+        if (func === 'on' || func === 'addListener') {
+          // if this event is already registered avoid a second registration
+          if (VrpcAdapter._listeners[arg].event) {
+            return null // means that this call won't be forwarded
           }
+          VrpcAdapter._listeners[arg].event = args[0]
+        }
+        if (func === 'off' || func === 'removeListener') {
+          const { clients, listener, event } = VrpcAdapter._listeners[arg]
+          const filteredClients = clients.filter(x => x !== sender)
+          // don't unregister this event, as other clients are still listening
+          if (filteredClients.length > 0) {
+            VrpcAdapter._listeners[arg].clients = filteredClients
+          } else {
+            delete VrpcAdapter._listeners[arg]
+            VrpcAdapter.getInstance(context).off(event, listener)
+          }
+          return null // means that this call won't be forwarded
         }
       } else {
-        // Leave the others untouched
-        wrappedArgs.push(arg)
+        // default behavior is to not touch
+        unwrapped.push(arg)
       }
-    })
-    return wrappedArgs
-  }
-
-  static _generateWrapper (id, json, instanceId) {
-    const { sender } = json
-    if (instanceId) {
-      const wrapper = (...innerArgs) => {
-        // do not even trigger a callback for already offline clients
-        if (sender && !VrpcAdapter._listeners[sender]) return
-        const data = { _1: instanceId }
-        innerArgs.forEach((x, i) => {
-          data[`_${i + 2}`] = x
-        })
-        // TODO Heal that crazy API !!
-        const callbackJson = { ...json, data, id }
-        const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-        VrpcAdapter._callback(callbackJsonString, callbackJson)
+    }
+    return unwrapped
+  }
+
+  static _removeAllListeners (event, sender, context) {
+    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
+      if (value.event === event) {
+        const filteredClients = value.clients.filter(x => x !== sender)
+        if (filteredClients.length > 0) {
+          VrpcAdapter._listeners[key].clients = filteredClients
+        } else {
+          delete VrpcAdapter._listeners[key]
+          VrpcAdapter.getInstance(context).off(event, value.listener)
+        }
       }
-      return wrapper
     }
-    const wrapper = (...innerArgs) => {
-      // do not even trigger a callback for already offline clients
-      if (sender && !VrpcAdapter._listeners[sender]) return
-      const data = {}
-      innerArgs.forEach((x, i) => {
-        data[`_${i + 1}`] = x
-      })
-      // TODO Heal that crazy API !!
-      const callbackJson = { ...json, data, id }
-      const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-      VrpcAdapter._callback(callbackJsonString, callbackJson)
+  }
+
+  static _generateCallback (id, json, instanceId) {
+    return (...innerArgs) => {
+      // callAll expects the instanceId as first argument
+      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ a, s: json.s, i: id })
     }
-    return wrapper
   }
 
-  static _handlePromise (json, method, promise) {
-    try {
-      const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER
-      const id = `__p__${method}-${cid}`
-      json.data.r = id
-      promise
-        .then(value => {
-          const data = { r: value }
-          const promiseJson = Object.assign({}, json, { data, id })
-          const promiseJsonString = VrpcAdapter._stringifySafely(promiseJson)
-          VrpcAdapter._callback(promiseJsonString, promiseJson)
-        })
-        .catch(err => {
-          const data = { e: err.message }
-          const promiseJson = Object.assign({}, json, { data, id })
-          const promiseJsonString = VrpcAdapter._stringifySafely(promiseJson)
-          VrpcAdapter._callback(promiseJsonString, promiseJson)
-        })
-    } catch (err) {
-      json.data.e = err.message
+  static _generateListener (id, json, instanceId) {
+    return (...innerArgs) => {
+      // do not even emit for already offline clients
+      if (!VrpcAdapter._listeners[id]) return
+      // callAll expects the instanceId as first argument
+      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ a, s: json.s, i: id })
     }
   }
 
-  static _stringifySafely (json) {
-    let jsonString
+  static _handlePromise (json, promise) {
     try {
-      jsonString = JSON.stringify(json)
+      const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER
+      const id = `__p__${json.f}-${cid}`
+      json.r = id
+      promise
+        .then(r => VrpcAdapter._callback({ ...json, r, i: id }))
+        .catch(err => VrpcAdapter._callback({ ...json, e: err.message, i: id }))
     } catch (err) {
-      this._log.debug(
-        `Failed serialization of return value for: ${json.context}::${json.method}, because: ${err.message}`
-      )
-      json.data.r = '__vrpc::not-serializable__'
-      jsonString = JSON.stringify(json)
+      json.data.e = err.message
     }
-    return jsonString
-  }
-
-  static _extractDataToArray (data) {
-    return Object.keys(data)
-      .sort()
-      .filter(value => value[0] === '_')
-      .map(key => data[key])
   }
 
   static _generateId (object) {
@@ -825,8 +807,8 @@ class VrpcAdapter {
 
   static _getInstancesArray (className) {
     const instances = []
-    VrpcAdapter._instances.forEach((value, key) => {
-      if (value.className === className) instances.push(key)
+    VrpcAdapter._instances.forEach((v, k) => {
+      if (v.className === className && !v.isIsolated) instances.push(k)
     })
     return instances
   }
@@ -853,7 +835,7 @@ class VrpcAdapter {
 /**
  * Event 'create'
  *
- * Emitted on creation of named instance
+ * Emitted on creation of shared instance
  *
  * @event VrpcAdapter#create
  * @type {Object}
@@ -865,7 +847,7 @@ class VrpcAdapter {
 /**
  * Event 'delete'
  *
- * Emitted on deletion of named instance
+ * Emitted on deletion of shared instance
  *
  * @event VrpcAdapter#delete
  * @type {Object}