vrpc 2.4.0 → 3.0.0-alpha.1

package/vrpc/VrpcAdapter.js

@@ -10,9 +10,9 @@ __\/\\\_______\/\\\__/\\\///////\\\___\/\\\/////////\\\____/\\\////////__
        ________\///________\///________\///__\///___________________\/////////__
 
 
-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>.
@@ -42,8 +42,8 @@ const path = require('path')
 const fs = require('fs')
 const Ajv = require('ajv')
 const caller = require('caller')
-const shortid = require('shortid')
 const commentParser = require('./comment-parser')
+const EventEmitter = require('events')
 
 /**
  * Generates an adapter layer for existing code and enables further VRPC-based
@@ -94,7 +94,7 @@ class VrpcAdapter {
    * using the `new` operator
    * @param {Object} [options.schema=null] If provided is used to validate ctor
    * parameters (only works if registered code reflects a single class)
-   * @param {Boolean} options.jsdocPath if provided, parses documentation and
+   * @param {String} options.jsdocPath if provided, parses documentation and
    * provides it as meta information
    *
    * NOTE: This function currently only supports registration of classes (either
@@ -110,7 +110,7 @@ class VrpcAdapter {
     } else {
       const { jsdocPath } = options
       if (jsdocPath) {
-        const absJsdocPath = path.resolve(caller(), '../', jsdocPath, '.js')
+        const absJsdocPath = path.resolve(caller(), '../', `${jsdocPath}.js`)
         this._registerClass(code, absJsdocPath, { ...options, jsdoc: true })
       } else {
         this._registerClass(code, null, options)
@@ -118,6 +118,49 @@ class VrpcAdapter {
     }
   }
 
+  /**
+   * Registers an existing instance and make it (remotely) callable
+   *
+   * @param {Object} obj The instance to be registered
+   * @param {Object} options
+   * @param {String} options.className Class name of the instance
+   * @param {String} options.instance Name of the instance
+   * @param {Boolean} [options.onlyPublic=true] If true, only registers
+   * functions that do not begin with an underscore
+   * @param {String} [options.jsdocPath] if provided, parses documentation and
+   * provides it as meta information
+   */
+  static registerInstance (
+    obj,
+    { className, instance, jsdocPath, onlyPublic = true } = {}
+  ) {
+    let memberFunctions = VrpcAdapter._extractMemberFunctions(obj)
+    if (onlyPublic) {
+      memberFunctions = memberFunctions.filter(f => {
+        return !f.startsWith('_')
+      })
+    }
+    let meta = null
+    if (jsdocPath) {
+      const absJsdocPath = path.resolve(caller(), '../', `${jsdocPath}.js`)
+      const content = fs.readFileSync(absJsdocPath).toString('utf8')
+      meta = this._parseComments(content)
+    }
+    VrpcAdapter._functionRegistry.set(className, {
+      memberFunctions,
+      meta,
+      Klass: {},
+      withNew: false,
+      staticFunctions: [],
+      schema: null
+    })
+    VrpcAdapter._instances.set(instance, {
+      className,
+      instance: obj,
+      isIsolated: false
+    })
+  }
+
   static getClasses () {
     return JSON.stringify(VrpcAdapter._getClassesArray())
   }
@@ -260,14 +303,14 @@ class VrpcAdapter {
    * @typedef {Object.<String, Func>} MetaData Associates meta data to any function
    */
 
-   /**
-    * @typedef Func
-    * @param {String} description Function description
-    * @param {Array.<Param>} params Array of parameter details in order of signature
-    * @param {Ret} ret Object associating further information to return value
-    */
+  /**
+   * @typedef Func
+   * @param {String} description Function description
+   * @param {Array.<Param>} params Array of parameter details in order of signature
+   * @param {Ret} ret Object associating further information to return value
+   */
 
-   /**
+  /**
    * @typedef {Object} Param
    * @param {String} name Parameter name
    * @param {Boolean} optional Whether parameter is optional
@@ -276,23 +319,34 @@ class VrpcAdapter {
    * @param {Any} [default] The default to be injected when not provided
    */
 
-   /**
-    * @typedef {Object} Ret
-    * @param {String} description Return value description
-    * @param {String} [type] Return value type
-    */
+  /**
+   * @typedef {Object} Ret
+   * @param {String} description Return value description
+   * @param {String} [type] Return value type
+   */
+
+  static on (eventName, listener) {
+    VrpcAdapter._emitter.on(eventName, listener)
+  }
+
+  static once (eventName, listener) {
+    VrpcAdapter._emitter.once(eventName, listener)
+  }
+
+  static off (eventName, listener) {
+    VrpcAdapter._emitter.off(eventName, listener)
+  }
+
+  static removeAllListeners (eventName) {
+    VrpcAdapter._emitter.removeAllListeners(eventName)
+  }
 
   // private:
 
   static _registerClass (
     Klass,
     absJsdocPath = null,
-    {
-      onlyPublic = true,
-      withNew = true,
-      schema = null,
-      jsdoc = true
-    } = {}
+    { onlyPublic = true, withNew = true, schema = null, jsdoc = true } = {}
   ) {
     // Get all static static functions
     let staticFunctions = VrpcAdapter._extractStaticFunctions(Klass)
@@ -300,24 +354,29 @@ 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 => !f.startsWith('_'))
+      memberFunctions = memberFunctions.filter(f => {
+        return !f.startsWith('_')
+      })
     }
     let meta = null
     if (jsdoc && absJsdocPath) {
       const content = fs.readFileSync(absJsdocPath).toString('utf8')
       meta = this._parseComments(content)
     }
-    VrpcAdapter._functionRegistry.set(
-      Klass.name,
-      { Klass, withNew, staticFunctions, memberFunctions, schema, meta }
-    )
+    VrpcAdapter._functionRegistry.set(Klass.name, {
+      Klass,
+      withNew,
+      staticFunctions,
+      memberFunctions,
+      schema,
+      meta
+    })
   }
 
   static _parseComments (content) {
@@ -326,7 +385,9 @@ class VrpcAdapter {
     comments.forEach(({ tags, description, functionName }) => {
       if (functionName) {
         if (tags) {
-          let params = tags.filter(({ tag }) => tag === 'param' || tag === 'arg' || tag === 'argument')
+          let params = tags.filter(
+            ({ tag }) => tag === 'param' || tag === 'arg' || tag === 'argument'
+          )
           if (params.length > 0) {
             params = params.map(({ name, optional, description, type }) => {
               return { name, optional, description, type }
@@ -334,10 +395,15 @@ class VrpcAdapter {
           } else {
             params = []
           }
-          let ret = tags.filter(({ tag }) => tag === 'returns' || tag === 'return')
+          let ret = tags.filter(
+            ({ tag }) => tag === 'returns' || tag === 'return'
+          )
           if (ret.length === 1) {
             const { source, type } = ret[0]
-            const description = source.split(' ').splice(2).join(' ')
+            const description = source
+              .split(' ')
+              .splice(2)
+              .join(' ')
             ret = { description, type }
           } else {
             ret = null
@@ -352,7 +418,7 @@ class VrpcAdapter {
               },
               ...params
             ]
-            meta.__createNamed__ = { description, params: modified, ret }
+            meta.__createShared__ = { description, params: modified, ret }
           } else {
             meta[functionName] = { description, params, ret }
           }
@@ -363,120 +429,146 @@ class VrpcAdapter {
   }
 
   static _call (json) {
-    const { context, method, data } = json
-    const wrappedArgs = VrpcAdapter._wrapCallbacks(json)
-    // VrpcAdapter._log.debug(`Calling function: ${method} with payload: ${data}`)
-    switch (method) {
-      // Special case: ctor
-      case '__create__':
-        try {
-          const instance = VrpcAdapter._create(context, ...wrappedArgs)
-          const instanceId = shortid.generate()
-          VrpcAdapter._instances.set(instanceId, { context, instance })
-          data.r = instanceId
-        } catch (err) {
-          data.e = err.message
-        }
+    switch (json.f) {
+      case '__createIsolated__':
+        VrpcAdapter._handleCreateIsolated(json)
+        break
+      case '__createShared__':
+        VrpcAdapter._handleCreateShared(json)
+        break
+      case '__callAll__':
+        VrpcAdapter._handleCallAll(json)
         break
-      // Special case: dtor
       case '__delete__':
-        try {
-          const instanceId = wrappedArgs[0]
-          data.r = VrpcAdapter._delete(instanceId)
-        } catch (err) {
-          data.e = err.message
-        }
+        VrpcAdapter._handleDelete(json)
         break
-        // Special case: named construction
-      case '__createNamed__':
+      default:
+        VrpcAdapter._handleCall(json)
+    }
+  }
+
+  static _handleCreateIsolated (json) {
+    try {
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      const instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: true
+      })
+      json.r = instanceId
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCreateShared (json) {
+    try {
+      const className = json.c
+      const [instanceId, ...args] = json.a
+      const instance = VrpcAdapter._create(className, instanceId, ...args)
+      VrpcAdapter._instances.set(instanceId, {
+        instance,
+        className,
+        isIsolated: false
+      })
+      json.r = instanceId
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCallAll (json) {
+    try {
+      const calls = []
+      for (const [id, { className, instance }] of VrpcAdapter._instances) {
+        if (className !== json.c) continue
+        let v
+        let e = null
         try {
-          VrpcAdapter._createNamed(context, ...wrappedArgs)
-          data.r = wrappedArgs[0] // First argument is instanceId
+          const wrappedArgs = VrpcAdapter._wrapArguments(json, id)
+          const funcName = wrappedArgs[0]
+          v = instance[funcName].apply(instance, wrappedArgs.slice(1))
         } catch (err) {
-          data.e = err.message
+          e = err.message
         }
-        break
-      case '__getNamed__': // Special case: retrieval of known instance
+        if (VrpcAdapter._isPromise(v)) {
+          calls.push(
+            v
+              .then(val => ({ id, val, err: null }))
+              .catch(err => ({ id, err, val: null }))
+          )
+        } else {
+          calls.push({ id, val: v, err: e })
+        }
+      }
+      this._handlePromise(json, Promise.all(calls))
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleDelete (json) {
+    try {
+      const wrappedArgs = VrpcAdapter._wrapArguments(json)
+      const instanceId = wrappedArgs[0]
+      json.r = VrpcAdapter._delete(instanceId)
+      VrpcAdapter._emitter.emit('delete', {
+        className: json.c,
+        instance: wrappedArgs[0]
+      })
+    } catch (err) {
+      json.e = err.message
+    }
+  }
+
+  static _handleCall (json) {
+    const wrappedArgs = VrpcAdapter._wrapArguments(json)
+    // Check whether context is a registered class
+    const entry = VrpcAdapter._functionRegistry.get(json.c)
+    if (entry !== undefined) {
+      // entry is class -> function is static
+      const { Klass } = entry
+      // TODO Think about whether to do live checking (like here) or
+      // 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[json.f])) {
         try {
-          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 ret = Klass[json.f].apply(null, wrappedArgs)
+          // check if function returns promise
+          if (VrpcAdapter._isPromise(ret)) {
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
+          json.e = err.message
         }
-        break
-      case '__callAll__': // Special case: call on all known instances
+      } else throw new Error(`Could not find function: ${json.f}`)
+    } else {
+      // is not static
+      const entry = VrpcAdapter._instances.get(json.c)
+      if (entry === undefined) {
+        throw new Error(`Could not find context: ${json.c}`)
+      }
+      const { instance } = entry
+      if (VrpcAdapter._isFunction(instance[json.f])) {
         try {
-          const funcName = wrappedArgs[0]
-          const calls = []
-          for (const [id, { className, instance }] of VrpcAdapter._instances) {
-            if (className !== context) continue
-            let v
-            let e = null
-            try {
-              v = instance[funcName].apply(instance, wrappedArgs.slice(1))
-            } catch (err) {
-              e = err
-            }
-            // check wether function returned a promise
-            if (VrpcAdapter._isPromise(v)) {
-              calls.push(v
-                .then(val => ({ id, val, err: null }))
-                .catch(err => ({ id, err, val: null })))
-            } else {
-              calls.push({ id, val: v, err: e })
-            }
-          }
-          this._handlePromise(json, method, Promise.all(calls))
+          const ret = instance[json.f].apply(instance, wrappedArgs)
+          // check if function returns promise
+          if (VrpcAdapter._isPromise(ret)) {
+            this._handlePromise(json, ret)
+          } else json.r = ret
         } catch (err) {
-          data.e = err.message
-        }
-        break
-      // Regular function call
-      default: {
-        // Check whether context is a registered class
-        const entry = VrpcAdapter._functionRegistry.get(context)
-        if (entry !== undefined) { // entry is class -> function is static
-          const { Klass } = entry
-          // TODO Think about whether to do live checking (like here) or
-          // 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])) {
-            try {
-              const ret = Klass[method].apply(null, wrappedArgs)
-              // check if function returns promise
-              if (ret && this._isFunction(ret.then)) {
-                this._handlePromise(json, method, ret)
-              } else data.r = ret
-            } catch (err) {
-              data.e = err.message
-            }
-          } else throw new Error(`Could not find function: ${method}`)
-        } else { // is not static
-          const entry = VrpcAdapter._instances.get(context)
-          if (entry === undefined) {
-            throw new Error(`Could not find context: ${context}`)
-          }
-          const { instance } = entry
-          if (VrpcAdapter._isFunction(instance[method])) {
-            try {
-              const ret = instance[method].apply(instance, wrappedArgs)
-              // check if function returns promise
-              if (VrpcAdapter._isPromise(ret)) {
-                this._handlePromise(json, method, ret)
-              } else data.r = ret
-            } catch (err) {
-              data.e = err.message
-            }
-          } else throw new Error(`Could not find function: ${method}`)
+          json.e = err.message
         }
-      }
+      } 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)
@@ -485,16 +577,6 @@ 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) {
@@ -511,6 +593,7 @@ class VrpcAdapter {
         VrpcAdapter.getInstance(i).removeListener(e, f)
       })
     }
+    delete VrpcAdapter._listeners[clientId]
   }
 
   static _validate (schema, params) {
@@ -521,92 +604,71 @@ class VrpcAdapter {
     if (!valid) throw new Error(VrpcAdapter._ajv.errorsText())
   }
 
-  static _wrapCallbacks (json) {
-    const args = VrpcAdapter._extractDataToArray(json.data)
-    const wrappedArgs = []
+  static _wrapArguments (json, instanceId) {
+    const { f: func, s: sender, a: args, c: context } = json
+    const wrapped = []
     args.forEach(arg => {
       // Find those args that actually need to be function callbacks
       if (typeof arg === 'string' && arg.substr(0, 5) === '__f__') {
-        const f = (...innerArgs) => {
-          const data = {}
-          innerArgs.forEach((value, index) => {
-            data[`_${index + 1}`] = value
-          })
-          const callbackJson = Object.assign({}, json, { data, id: arg })
-          const callbackJsonString = VrpcAdapter._stringifySafely(callbackJson)
-          VrpcAdapter._callback(callbackJsonString, callbackJson)
-        }
+        const f = this._generateWrapper(arg, json, instanceId)
+        wrapped.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 (json.method === 'on' && typeof args[0] === 'string') {
+        if (func === 'on' && typeof args[0] === 'string') {
           const e = args[0]
-          const i = json.context
+          const i = context
           const r = arg
-          VrpcAdapter._listeners[json.sender]
-            ? VrpcAdapter._listeners[json.sender].push({ i, e, f, r })
-            : VrpcAdapter._listeners[json.sender] = [{ i, e, f, r }]
+          VrpcAdapter._listeners[sender].push({ i, e, f, r })
         }
-        if ((json.method === 'off' || json.method === 'removeListener') &&
-          typeof args[0] === 'string') {
-          const r = arg
-          const sender = VrpcAdapter._listeners[json.sender]
-          const entry = sender && sender.find(x => x.r === r)
+        if (
+          (func === 'off' || func === 'removeListener') &&
+          typeof args[0] === 'string'
+        ) {
+          const listener = VrpcAdapter._listeners[sender]
+          const entry = listener && listener.find(x => x.r === arg)
           if (entry) {
             const { i, e, f } = entry
             VrpcAdapter.getInstance(i).removeListener(e, f)
           }
         }
-        wrappedArgs.push(f)
-      // Leave the others untouched
       } else {
-        wrappedArgs.push(arg)
+        // Leave the others untouched
+        wrapped.push(arg)
       }
     })
-    return wrappedArgs
+    return wrapped
   }
 
-  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 _generateWrapper (id, json, instanceId) {
+    const wrapper = (...innerArgs) => {
+      // do not even trigger a callback for already offline clients
+      if (json.s && !VrpcAdapter._listeners[json.s]) return
+      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ ...json, a, i: id })
     }
+    return wrapper
   }
 
-  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) {
-    return crypto.createHash('md5').update(JSON.stringify(object)).digest('hex')
+    return crypto
+      .createHash('md5')
+      .update(JSON.stringify(object))
+      .digest('hex')
   }
 
   static _getClassEntry (className) {
@@ -626,11 +688,17 @@ class VrpcAdapter {
   }
 
   static _isClass (obj) {
-    return !!obj && (typeof obj === 'function' && /^\s*class\s+/.test(obj.toString()))
+    return (
+      !!obj && typeof obj === 'function' && /^\s*class\s+/.test(obj.toString())
+    )
   }
 
   static _isPromise (obj) {
-    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'
+    return (
+      !!obj &&
+      (typeof obj === 'object' || typeof obj === 'function') &&
+      typeof obj.then === 'function'
+    )
   }
 
   static _extractMemberFunctions (klass) {
@@ -638,12 +706,20 @@ class VrpcAdapter {
     let fs = []
     do {
       if (klass_.prototype) {
-        fs = [...fs, ...Object.getOwnPropertyNames(klass_.prototype)]
+        const funcs = Object.getOwnPropertyNames(klass_.prototype).filter(
+          x =>
+            !VrpcAdapter._blackList.has(x) &&
+            this._isFunction(klass_.prototype[x])
+        )
+        fs = [...fs, ...funcs]
       } else {
-        fs = [...fs, ...Object.getOwnPropertyNames(klass_)]
+        const funcs = Object.getOwnPropertyNames(klass_).filter(
+          x => !VrpcAdapter._blackList.has(x) && this._isFunction(klass_[x])
+        )
+        fs = [...fs, ...funcs]
       }
       klass_ = Object.getPrototypeOf(klass_)
-    } while (klass_ && klass_.name)
+    } while (klass_)
     // Filter out all duplicates
     return Array.from(new Set(fs))
   }
@@ -652,10 +728,13 @@ class VrpcAdapter {
     let klass_ = klass
     let fs = []
     do {
-      fs = [...fs, ...Object.getOwnPropertyNames(klass_).filter(prop => {
-        const desc = Object.getOwnPropertyDescriptor(klass_, prop)
-        return !!desc && typeof desc.value === 'function'
-      })]
+      fs = [
+        ...fs,
+        ...Object.getOwnPropertyNames(klass_).filter(prop => {
+          const desc = Object.getOwnPropertyDescriptor(klass_, prop)
+          return !!desc && typeof desc.value === 'function'
+        })
+      ]
       klass_ = Object.getPrototypeOf(klass_)
     } while (klass_ && klass_.name)
     // Filter out all duplicates
@@ -668,8 +747,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
   }
@@ -693,10 +772,52 @@ class VrpcAdapter {
   }
 }
 
+/**
+ * Event 'create'
+ *
+ * Emitted on creation of named instance
+ *
+ * @event VrpcAdapter#create
+ * @type {Object}
+ * @property {String} className The class name of the create instance
+ * @property {String} instance The instance name
+ * @property {Array.<Any>} args The constructor arguments
+ */
+
+/**
+ * Event 'delete'
+ *
+ * Emitted on deletion of named instance
+ *
+ * @event VrpcAdapter#delete
+ * @type {Object}
+ * @property {String} className The class name of the deleted instance
+ * @property {String} instance The instance name
+ */
+
 // Initialize static members
 VrpcAdapter._functionRegistry = new Map()
 VrpcAdapter._instances = new Map()
+VrpcAdapter._emitter = new EventEmitter()
 VrpcAdapter._correlationId = 0
 VrpcAdapter._listeners = {}
+VrpcAdapter._blackList = new Set([
+  'caller',
+  'callee',
+  'arguments',
+  'apply',
+  'bind',
+  'call',
+  'toString',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'valueOf',
+  'toLocaleString',
+  '__defineGetter__',
+  '__defineSetter__',
+  '__lookupGetter__',
+  '__lookupSetter__'
+])
 
 module.exports = VrpcAdapter