javonet-nodejs-sdk 2.4.5 → 2.4.7

package/Binaries/Native/Linux/X64/version.txt

@@ -1 +1 @@
-2.4.5
+2.4.7

package/Binaries/Native/MacOs/X64/version.txt

@@ -1 +1 @@
-2.4.5
+2.4.7

package/Binaries/Native/Windows/X64/version.txt

@@ -1 +1 @@
-'2.4.5' 
+'2.4.7' 

package/Binaries/Nodejs/Linux/X64/core/handler/DestructReferenceHandler.js

@@ -1,5 +1,5 @@
 const AbstractHandler = require("./AbstractHandler");
-const ReferencesCache = require("./ReferencesCache")
+const ReferencesCache = require("../referenceCache/ReferencesCache")
 
 class DestructReferenceHandler extends AbstractHandler {
 

package/Binaries/Nodejs/Linux/X64/core/handler/EnableNamespaceHandler.js

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

package/Binaries/Nodejs/Linux/X64/core/handler/EnableTypeHandler.js

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

package/Binaries/Nodejs/Linux/X64/core/handler/GetTypeHandler.js

@@ -1,10 +1,14 @@
 const AbstractHandler = require("./AbstractHandler");
+const NamespaceCache = require("../namespaceCache/NamespaceCache");
+const TypeCache = require("../typeCache/TypeCache");
 
 class GetTypeHandler extends AbstractHandler {
-    requiredParametersCount = 1
 
     constructor() {
         super()
+        this.requiredParametersCount = 1
+        this.namespaceCache = new NamespaceCache();
+        this.typeCache = new TypeCache();
     }
 
     process(command) {
@@ -15,12 +19,24 @@ class GetTypeHandler extends AbstractHandler {
             const {payload} = command
             let typeName = payload[0]
             typeName = typeName.replace(".js", "")
-            let type = global[typeName]
-            if (type === undefined) {
-                throw new Error(`Cannot load ${typeName}`)
+            let typeToReturn = global[typeName]
+            if (typeToReturn === undefined) {
+                throw new Error(`Type ${typeName} not found`)
+            }
+
+            if (
+                (this.namespaceCache.isNamespaceCacheEmpty() && this.typeCache.isTypeCacheEmpty()) || // both caches are empty
+                this.namespaceCache.isTypeAllowed(typeToReturn) || // namespace is allowed
+                this.typeCache.isTypeAllowed(typeToReturn) // type is allowed
+            ) {
+                // continue - type is allowed
             } else {
-                return type
+                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
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }

package/Binaries/Nodejs/Linux/X64/core/handler/Handler.js

@@ -1,4 +1,8 @@
 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')
@@ -18,13 +22,10 @@ const ArrayGetSizeHandler = require('./ArrayGetSizeHandler')
 const ArrayGetRankHandler = require('./ArrayGetRankHandler')
 const ArraySetItemHandler = require('./ArraySetItemHandler')
 const ArrayHandler = require('./ArrayHandler')
+const EnableNamespaceHandler = require('./EnableNamespaceHandler')
+const EnableTypeHandler = require('./EnableTypeHandler')
 
 
-const ExceptionSerializer = require('../exception/ExceptionSerializer')
-
-const ReferenceCache = require('./ReferencesCache')
-const Command = require("../../utils/Command");
-
 function isResponseSimpleType(response) {
     let type = typeof (response)
     return ['string', 'boolean', 'number'].includes(type)
@@ -53,13 +54,15 @@ const handlers = {
     [CommandType.ArrayGetSize]: ArrayGetSizeHandler,
     [CommandType.ArrayGetRank]: ArrayGetRankHandler,
     [CommandType.ArraySetItem]: ArraySetItemHandler,
-    [CommandType.Array]: ArrayHandler
+    [CommandType.Array]: ArrayHandler,
+    [CommandType.EnableNamespace]: EnableNamespaceHandler,
+    [CommandType.EnableType]: EnableTypeHandler
 }
 
 class Handler {
     handleCommand(command) {
         try {
-            if (command.commandType == CommandType.RetrieveArray) {
+            if (command.commandType === CommandType.RetrieveArray) {
                 let responseArray = handlers[CommandType.Reference].handleCommand(command.payload[0])
                 return Command.createArrayResponse(responseArray, command.runtimeName)
             }

package/Binaries/Nodejs/Linux/X64/core/handler/LoadLibraryHandler.js

@@ -16,15 +16,24 @@ class LoadLibraryHandler extends AbstractHandler {
         let pathArray = lib.split(/[/\\]/)
         let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
         libraryName = libraryName.replace('.js', '')
+
+        let moduleExports
+
         try {
-            global[libraryName] = require(lib)
+            moduleExports = require(lib)
         } catch (error) {
             try {
-                global[libraryName] = require(`${process.cwd()}/${lib}`)
+                moduleExports = require(`${process.cwd()}/${lib}`)
             } catch (error) {
                 throw this.process_stack_trace(error, this.constructor.name)
             }
         }
+        global[libraryName] = moduleExports
+
+        for (const [key, value] of Object.entries(moduleExports)) {
+            // Here, `key` is the name of the export, and `value` is the exported type itself.
+            global[key] = value
+        }
         return 0
     }
 }

package/Binaries/Nodejs/Linux/X64/core/handler/ResolveReferenceHandler.js

@@ -1,5 +1,5 @@
 const AbstractHandler = require("./AbstractHandler");
-const ReferenceCache = require("./ReferencesCache")
+const ReferenceCache = require("../referenceCache/ReferencesCache")
 
 class ResolveReferenceHandler extends AbstractHandler {
     constructor() {

package/Binaries/Nodejs/Linux/X64/core/namespaceCache/NamespaceCache.js

@@ -0,0 +1,39 @@
+class NamespaceCache {
+    static _instance = null;
+    namespaceCache = [];
+
+    constructor() {
+        if (NamespaceCache._instance === null) {
+            NamespaceCache._instance = this;
+        }
+        return NamespaceCache._instance;
+    }
+
+    cacheNamespace(namespaceRegex) {
+        this.namespaceCache.push(namespaceRegex);
+    }
+
+    isNamespaceCacheEmpty() {
+        return this.namespaceCache.length === 0;
+    }
+
+    isTypeAllowed(typeToCheck) {
+        for (let pattern of this.namespaceCache) {
+            if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    getCachedNamespaces() {
+        return this.namespaceCache;
+    }
+
+    clearCache() {
+        this.namespaceCache = [];
+        return 0;
+    }
+}
+
+module.exports = NamespaceCache;

package/Binaries/Nodejs/Linux/X64/core/protocol/TypeSerializer.js

@@ -26,7 +26,7 @@ class TypeSerializer {
     }
 
     static serializeCommand(command) {
-        const buffer = Buffer.alloc(7, command)
+        const buffer = Buffer.alloc(7)
         buffer.writeUInt8(Type.JAVONET_COMMAND, 0)
         buffer.fill(Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5)
         buffer.writeUInt8(command.runtime, 5)

package/Binaries/Nodejs/Linux/X64/core/receiver/Receiver.js

@@ -2,11 +2,14 @@ const Interpreter = require('../interpreter/Interpreter')
 const interpreter = new Interpreter()
 
 class Receiver {
-    static sendCommand(byteArray) {
-        return interpreter.process(byteArray)
+    static sendCommand(messageByteArray) {
+        return interpreter.process(messageByteArray)
     }
-    static heartBeat(byteArray) {
-        return Int8Array.from([49, 48])
+    static heartBeat(messageByteArray) {
+        let response = new Int8Array(2)
+        response[0] = messageByteArray[11]
+        response[1] = messageByteArray[12]-2
+        return response
     }
 }
 

package/Binaries/Nodejs/Linux/X64/core/receiver/ReceiverNative.js

@@ -9,3 +9,5 @@ class ReceiverNative {
         return Receiver.heartBeat(messageByteArray)
     }
 }
+
+global.ReceiverNative = ReceiverNative;

package/Binaries/Nodejs/Linux/X64/core/typeCache/TypeCache.js

@@ -0,0 +1,39 @@
+class TypeCache {
+    static _instance = null;
+    typeCache = [];
+
+    constructor() {
+        if (TypeCache._instance === null) {
+            TypeCache._instance = this;
+        }
+        return TypeCache._instance;
+    }
+
+    cacheType(typRegex) {
+        this.typeCache.push(typRegex);
+    }
+
+    isTypeCacheEmpty() {
+        return this.typeCache.length === 0;
+    }
+
+    isTypeAllowed(typeToCheck) {
+        for (let pattern of this.typeCache) {
+            if (new RegExp(pattern).test(typeToCheck.name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    getCachedTypes() {
+        return this.typeCache;
+    }
+
+    clearCache() {
+        this.typeCache = [];
+        return 0;
+    }
+}
+
+module.exports = TypeCache;

package/Binaries/Nodejs/Linux/X64/utils/CommandType.js

@@ -32,5 +32,7 @@ module.exports = {
     GetEnumValue: 30,
     AsRef: 31,
     AsOut: 32,
-    GetRefValue: 33
+    GetRefValue: 33,
+    EnableNamespace: 34,
+    EnableType: 35,
 }

package/Binaries/Nodejs/Linux/X64/{core → utils}/exception/ExceptionSerializer.js

@@ -1,7 +1,7 @@
-const CommandType = require("../../utils/CommandType");
-const Command = require("../../utils/Command");
-const Runtime = require("../../utils/RuntimeName");
-const ExceptionType = require("../../utils/ExceptionType");
+const CommandType = require("../CommandType");
+const Command = require("../Command");
+const Runtime = require("../RuntimeName");
+const ExceptionType = require("../ExceptionType");
 
 
 class ExceptionSerializer {

package/Binaries/Nodejs/Linux/X64/{core → utils}/exception/ExceptionThrower.js

@@ -1,4 +1,4 @@
-const ExceptionType = require("../../utils/ExceptionType");
+const ExceptionType = require("../ExceptionType");
 
 
 class ExceptionThrower {

package/Binaries/Nodejs/MacOs/X64/core/handler/DestructReferenceHandler.js

@@ -1,5 +1,5 @@
 const AbstractHandler = require("./AbstractHandler");
-const ReferencesCache = require("./ReferencesCache")
+const ReferencesCache = require("../referenceCache/ReferencesCache")
 
 class DestructReferenceHandler extends AbstractHandler {
 

package/Binaries/Nodejs/MacOs/X64/core/handler/EnableNamespaceHandler.js

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

package/Binaries/Nodejs/MacOs/X64/core/handler/EnableTypeHandler.js

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

package/Binaries/Nodejs/MacOs/X64/core/handler/GetTypeHandler.js

@@ -1,10 +1,14 @@
 const AbstractHandler = require("./AbstractHandler");
+const NamespaceCache = require("../namespaceCache/NamespaceCache");
+const TypeCache = require("../typeCache/TypeCache");
 
 class GetTypeHandler extends AbstractHandler {
-    requiredParametersCount = 1
 
     constructor() {
         super()
+        this.requiredParametersCount = 1
+        this.namespaceCache = new NamespaceCache();
+        this.typeCache = new TypeCache();
     }
 
     process(command) {
@@ -15,12 +19,24 @@ class GetTypeHandler extends AbstractHandler {
             const {payload} = command
             let typeName = payload[0]
             typeName = typeName.replace(".js", "")
-            let type = global[typeName]
-            if (type === undefined) {
-                throw new Error(`Cannot load ${typeName}`)
+            let typeToReturn = global[typeName]
+            if (typeToReturn === undefined) {
+                throw new Error(`Type ${typeName} not found`)
+            }
+
+            if (
+                (this.namespaceCache.isNamespaceCacheEmpty() && this.typeCache.isTypeCacheEmpty()) || // both caches are empty
+                this.namespaceCache.isTypeAllowed(typeToReturn) || // namespace is allowed
+                this.typeCache.isTypeAllowed(typeToReturn) // type is allowed
+            ) {
+                // continue - type is allowed
             } else {
-                return type
+                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
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }