javonet-nodejs-sdk 2.5.8 → 2.5.9

package/lib/core/handler/CreateClassInstanceHandler.js

@@ -1,38 +1,36 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class CreateClassInstanceHandler extends AbstractHandler {
-  requiredParametersCount = 1;
+    requiredParametersCount = 1
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Create Class Instance parameters mismatch");
-      }
-      let clazz = command.payload[0];
-      let constructorArguments = command.payload.slice(1);
-      let instance = new clazz(...constructorArguments);
-      if (typeof instance === "undefined") {
-        let methods = Object.getOwnPropertyNames(type).filter(function (
-          property
-        ) {
-          return typeof type[property] === "function";
-        });
-        let message = `Method 'constructor' not found in class. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return instance;
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Create Class Instance parameters mismatch')
+            }
+            let clazz = command.payload[0]
+            let constructorArguments = command.payload.slice(1)
+            let instance = new clazz(...constructorArguments)
+            if (typeof instance === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method 'constructor' not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instance
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new CreateClassInstanceHandler();
+module.exports = new CreateClassInstanceHandler()

package/lib/core/handler/DestructReferenceHandler.js

@@ -1,8 +1,7 @@
-const AbstractHandler = require("./AbstractHandler");
-const ReferencesCache = require("../referenceCache/ReferencesCache")
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class DestructReferenceHandler extends AbstractHandler {
-
     constructor() {
         super()
     }
@@ -17,4 +16,4 @@ class DestructReferenceHandler extends AbstractHandler {
     }
 }
 
-module.exports = new DestructReferenceHandler()
+module.exports = new DestructReferenceHandler()

package/lib/core/handler/EnableNamespaceHandler.js

@@ -1,8 +1,7 @@
-const AbstractHandler = require("./AbstractHandler");
-const NamespaceCache = require("../namespaceCache/NamespaceCache");
+const NamespaceCache = require('../namespaceCache/NamespaceCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class EnableNamespaceHandler extends AbstractHandler {
-
     constructor() {
         super()
         this.requiredParametersCount = 1
@@ -11,27 +10,25 @@ class EnableNamespaceHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error(this.constructor.name + " parameters mismatch")
+                throw new Error(this.constructor.name + ' parameters mismatch')
             }
-            const namespace_cache = new NamespaceCache();
+            const namespace_cache = new NamespaceCache()
 
             for (let payload of command.payload) {
                 if (typeof payload === 'string') {
-                    namespace_cache.cacheNamespace(payload);
+                    namespace_cache.cacheNamespace(payload)
                 }
                 if (Array.isArray(payload)) {
                     for (let namespace_to_enable of payload) {
-                        namespace_cache.cacheNamespace(namespace_to_enable);
+                        namespace_cache.cacheNamespace(namespace_to_enable)
                     }
                 }
             }
-            return 0;
-
+            return 0
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }
-
     }
 }
 
-module.exports = new EnableNamespaceHandler()
+module.exports = new EnableNamespaceHandler()

package/lib/core/handler/EnableTypeHandler.js

@@ -1,5 +1,5 @@
-const AbstractHandler = require("./AbstractHandler");
-const TypeCache = require("../typeCache/TypeCache");
+const TypeCache = require('../typeCache/TypeCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class EnableTypeHandler extends AbstractHandler {
     requiredParametersCount = 1
@@ -11,27 +11,25 @@ class EnableTypeHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Get Type parameters mismatch")
+                throw new Error('Get Type parameters mismatch')
             }
-            const typeCache = new TypeCache();
+            const typeCache = new TypeCache()
 
             for (let payload of command.payload) {
                 if (typeof payload === 'string') {
-                    typeCache.cacheType(payload);
+                    typeCache.cacheType(payload)
                 }
                 if (Array.isArray(payload)) {
                     for (let namespace_to_enable of payload) {
-                        typeCache.cacheType(namespace_to_enable);
+                        typeCache.cacheType(namespace_to_enable)
                     }
                 }
             }
-            return 0;
-
+            return 0
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }
-
     }
 }
 
-module.exports = new EnableTypeHandler()
+module.exports = new EnableTypeHandler()

package/lib/core/handler/GetGlobalStaticFieldHandler.js

@@ -1,39 +1,37 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class GetGlobalStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 1;
+    requiredParametersCount = 1
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Get global static field parameters mismatch");
-      }
-      const { payload } = command;
-      const splitted = payload[0].split(".");
-      let fieldToGet;
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get global static field parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            let fieldToGet
 
-      for (let i = 0; i < splitted.length; i++) {
-        fieldToGet = !fieldToGet
-          ? global[splitted[i]]
-          : fieldToGet[splitted[i]];
-        if (typeof fieldToGet === "undefined") {
-          let fields = Object.keys(global);
-          let message = `Field ${payload[0]} not found in global. Available fields:\n`;
-          fields.forEach((fieldIter) => {
-            message += `${fieldIter}\n`;
-          });
-          throw new Error(message);
+            for (let i = 0; i < splitted.length; i++) {
+                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
+                if (typeof fieldToGet === 'undefined') {
+                    let fields = Object.keys(global)
+                    let message = `Field ${payload[0]} not found in global. Available fields:\n`
+                    fields.forEach((fieldIter) => {
+                        message += `${fieldIter}\n`
+                    })
+                    throw new Error(message)
+                }
+            }
+            return fieldToGet
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
         }
-      }
-      return fieldToGet;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
     }
-  }
 }
 
-module.exports = new GetGlobalStaticFieldHandler();
+module.exports = new GetGlobalStaticFieldHandler()

package/lib/core/handler/GetInstanceFieldHandler.js

@@ -1,35 +1,35 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class GetInstanceFieldHandler extends AbstractHandler {
-  requiredParametersCount = 2;
+    requiredParametersCount = 2
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Get Instance Field parameters mismatch");
-      }
-      const { payload } = command;
-      let instance = payload[0];
-      let field = payload[1];
-      let instanceField = instance[field];
-      if (typeof instanceField === "undefined") {
-        let fields = Object.keys(instance);
-        let message = `Field ${field} not found in object. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return instanceField;
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get Instance Field parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let field = payload[1]
+            let instanceField = instance[field]
+            if (typeof instanceField === 'undefined') {
+                let fields = Object.keys(instance)
+                let message = `Field ${field} not found in object. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instanceField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new GetInstanceFieldHandler();
+module.exports = new GetInstanceFieldHandler()

package/lib/core/handler/GetStaticFieldHandler.js

@@ -1,36 +1,36 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class GetStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 2;
+    requiredParametersCount = 2
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Array Static Field parameters mismatch");
-      }
-      const { payload } = command;
-      let type = payload[0];
-      let field = payload[1];
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Static Field parameters mismatch')
+            }
+            const { payload } = command
+            let type = payload[0]
+            let field = payload[1]
 
-      let staticField = type[field];
-      if (typeof staticField === "undefined") {
-        let fields = Object.keys(type);
-        let message = `Field ${field} not found in class. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return staticField;
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+            let staticField = type[field]
+            if (typeof staticField === 'undefined') {
+                let fields = Object.keys(type)
+                let message = `Field ${field} not found in class. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return staticField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new GetStaticFieldHandler();
+module.exports = new GetStaticFieldHandler()

package/lib/core/handler/GetTypeHandler.js

@@ -1,30 +1,29 @@
-const AbstractHandler = require("./AbstractHandler");
-const LoadLibraryHandler = require("./LoadLibraryHandler");
-const NamespaceCache = require("../namespaceCache/NamespaceCache");
-const TypeCache = require("../typeCache/TypeCache");
+const AbstractHandler = require('./AbstractHandler')
+const LoadLibraryHandler = require('./LoadLibraryHandler')
+const NamespaceCache = require('../namespaceCache/NamespaceCache')
+const TypeCache = require('../typeCache/TypeCache')
 
 class GetTypeHandler extends AbstractHandler {
-
     constructor() {
         super()
         this.requiredParametersCount = 1
-        this.namespaceCache = new NamespaceCache();
-        this.typeCache = new TypeCache();
+        this.namespaceCache = new NamespaceCache()
+        this.typeCache = new TypeCache()
     }
 
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Get Type parameters mismatch")
+                throw new Error('Get Type parameters mismatch')
             }
-            const {payload} = command
+            const { payload } = command
             let typeName = payload[0]
-            typeName = typeName.replace(".js", "")
+            typeName = typeName.replace('.js', '')
             let typeToReturn = global[typeName]
             if (typeToReturn === undefined) {
                 let message = `Type ${typeName} not found\n`
-                message += "Available types:\n"
-                message += this.getAvailableTypes().join("\n")
+                message += 'Available types:\n'
+                message += this.getAvailableTypes().join('\n')
                 throw new Error(message)
             }
 
@@ -35,9 +34,11 @@ class GetTypeHandler extends AbstractHandler {
             ) {
                 // continue - type is allowed
             } else {
-                let allowed_namespaces = this.namespaceCache.getCachedNamespaces().join(", ");
-                let allowed_types = this.typeCache.getCachedTypes().join(", ");
-                throw new Error(`Type ${typeToReturn.name} not allowed. \nAllowed namespaces: ${allowed_namespaces}\nAllowed types: ${allowed_types}`);
+                let allowed_namespaces = this.namespaceCache.getCachedNamespaces().join(', ')
+                let allowed_types = this.typeCache.getCachedTypes().join(', ')
+                throw new Error(
+                    `Type ${typeToReturn.name} not allowed. \nAllowed namespaces: ${allowed_namespaces}\nAllowed types: ${allowed_types}`
+                )
             }
 
             return typeToReturn
@@ -47,15 +48,15 @@ class GetTypeHandler extends AbstractHandler {
     }
 
     getAvailableTypes() {
-        let availableTypes = [];
+        let availableTypes = []
         LoadLibraryHandler.getLoadedLibraries().forEach((lib) => {
-            const moduleExports = require(lib);
+            const moduleExports = require(lib)
             availableTypes.push(moduleExports.name)
             Object.keys(moduleExports).forEach((key) => {
-                availableTypes.push(key);
-            });
-        });
-        return availableTypes;
+                availableTypes.push(key)
+            })
+        })
+        return availableTypes
     }
 }
 

package/lib/core/handler/Handler.js

@@ -1,8 +1,3 @@
-const CommandType = require('../../utils/CommandType')
-const Command = require("../../utils/Command");
-const ReferenceCache = require('../referenceCache/ReferencesCache')
-const ExceptionSerializer = require('../../utils/exception/ExceptionSerializer')
-
 const ValueHandler = require('./ValueHandler')
 const LoadLibraryHandler = require('./LoadLibraryHandler')
 const GetTypeHandler = require('./GetTypeHandler')
@@ -14,7 +9,7 @@ const CreateClassInstanceHandler = require('./CreateClassInstanceHandler')
 const GetInstanceFieldHandler = require('./GetInstanceFieldHandler')
 const SetInstanceFieldHandler = require('./SetInstanceFieldHandler')
 const InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReferenceHandler = require("./DestructReferenceHandler");
+const DestructReferenceHandler = require('./DestructReferenceHandler')
 const CastHandler = require('./CastingHandler')
 const InvokeGlobalMethodHandler = require('./InvokeGlobalMethodHandler')
 const ArrayGetItemHandler = require('./ArrayGetItemHandler')
@@ -25,9 +20,12 @@ const ArrayHandler = require('./ArrayHandler')
 const EnableNamespaceHandler = require('./EnableNamespaceHandler')
 const EnableTypeHandler = require('./EnableTypeHandler')
 
+const { CommandType, Command, ExceptionSerializer } = require('@javonet/core')
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const InvokeStandaloneMethodHandler = require('./InvokeStandaloneMethodHandler')
 
 function isResponseSimpleType(response) {
-    let type = typeof (response)
+    let type = typeof response
     return ['string', 'boolean', 'number'].includes(type)
 }
 
@@ -35,7 +33,6 @@ function isResponseNull(response) {
     return response === null
 }
 
-
 const handlers = {
     [CommandType.Value]: ValueHandler,
     [CommandType.LoadLibrary]: LoadLibraryHandler,
@@ -49,6 +46,7 @@ const handlers = {
     [CommandType.GetInstanceField]: GetInstanceFieldHandler,
     [CommandType.SetInstanceField]: SetInstanceFieldHandler,
     [CommandType.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
+    [CommandType.InvokeStandaloneMethod]: InvokeStandaloneMethodHandler,
     [CommandType.InvokeGlobalMethod]: InvokeGlobalMethodHandler,
     [CommandType.DestructReference]: DestructReferenceHandler,
     [CommandType.ArrayGetItem]: ArrayGetItemHandler,
@@ -57,9 +55,13 @@ const handlers = {
     [CommandType.ArraySetItem]: ArraySetItemHandler,
     [CommandType.Array]: ArrayHandler,
     [CommandType.EnableNamespace]: EnableNamespaceHandler,
-    [CommandType.EnableType]: EnableTypeHandler
+    [CommandType.EnableType]: EnableTypeHandler,
 }
 
+Object.keys(handlers).forEach((commandTypeHandler) => {
+    handlers[commandTypeHandler].handlers = handlers
+})
+
 class Handler {
     handleCommand(command) {
         try {
@@ -78,7 +80,7 @@ class Handler {
         if (isResponseNull(response) || isResponseSimpleType(response)) {
             return Command.createResponse(response, runtimeName)
         } else {
-            let cache = ReferenceCache.getInstance()
+            let cache = ReferencesCache.getInstance()
             let uuid = cache.cacheReference(response)
             return Command.createReference(uuid, runtimeName)
         }
@@ -87,4 +89,3 @@ class Handler {
 
 module.exports.Handler = Handler
 module.exports.handlers = handlers
-

package/lib/core/handler/InvokeGlobalMethodHandler.js

@@ -1,47 +1,43 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class InvokeGlobalMethodHandler extends AbstractHandler {
-  requiredParametersCount = 1;
+    requiredParametersCount = 1
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Global Method parameters mismatch");
-      }
-      const { payload } = command;
-      const splitted = payload[0].split(".");
-      let methodToInvoke;
-      for (let i = 0; i < splitted.length; i++) {
-        methodToInvoke = !methodToInvoke
-          ? global[splitted[i]]
-          : methodToInvoke[splitted[i]];
-      }
-      if (typeof methodToInvoke === "undefined") {
-        let methods = Object.getOwnPropertyNames(global).filter(function (
-          property
-        ) {
-          return typeof global[property] === "function";
-        });
-        let message = `Method ${payload[0]} not found in global. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      }
-      if (payload.length > 1) {
-        const args = payload.slice(1);
-        return methodToInvoke(args);
-      } else {
-        return methodToInvoke();
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Global Method parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            let methodToInvoke
+            for (let i = 0; i < splitted.length; i++) {
+                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
+            }
+            if (typeof methodToInvoke === 'undefined') {
+                let methods = Object.getOwnPropertyNames(global).filter(function (property) {
+                    return typeof global[property] === 'function'
+                })
+                let message = `Method ${payload[0]} not found in global. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            }
+            if (payload.length > 1) {
+                const args = payload.slice(1)
+                return methodToInvoke(args)
+            } else {
+                return methodToInvoke()
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new InvokeGlobalMethodHandler();
+module.exports = new InvokeGlobalMethodHandler()