javonet-nodejs-sdk 2.4.4 → 2.4.6

package/Binaries/Ruby/Windows/X64/external_lib/singleton.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: false
+
+# The Singleton module implements the Singleton pattern.
+#
+# == Usage
+#
+# To use Singleton, include the module in your class.
+#
+#    class Klass
+#       include Singleton
+#       # ...
+#    end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#      a,b = Klass.instance, Klass.instance
+#
+#      a == b
+#      # => true
+#
+#      Klass.new
+#      # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#      class OtherKlass
+#        include Singleton
+#        # ...
+#      end
+#
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 0
+#
+#      OtherKlass.instance
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 1
+#
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# == Implementation
+#
+# This above is achieved by:
+#
+# *  Making Klass.new and Klass.allocate private.
+#
+# *  Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#    Singleton properties are kept when inherited and cloned.
+#
+# *  Providing the Klass.instance() method that returns the same object each
+#    time it is called.
+#
+# *  Overriding Klass._load(str) to call Klass.instance().
+#
+# *  Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#    cloning or duping.
+#
+# == Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables from the instance.
+# Classes using Singleton can provide custom _load(str) and _dump(depth) methods
+# to retain some of the previous state of the instance.
+#
+#    require 'singleton'
+#
+#    class Example
+#      include Singleton
+#      attr_accessor :keep, :strip
+#      def _dump(depth)
+#        # this strips the @strip information from the instance
+#        Marshal.dump(@keep, depth)
+#      end
+#
+#      def self._load(str)
+#        instance.keep = Marshal.load(str)
+#        instance
+#      end
+#    end
+#
+#    a = Example.instance
+#    a.keep = "keep this"
+#    a.strip = "get rid of this"
+#
+#    stored_state = Marshal.dump(a)
+#
+#    a.keep = nil
+#    a.strip = nil
+#    b = Marshal.load(stored_state)
+#    p a == b  #  => true
+#    p a.keep  #  => "keep this"
+#    p a.strip #  => nil
+#
+module Singleton
+  VERSION = "0.2.0"
+
+  # Raises a TypeError to prevent cloning.
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  # Raises a TypeError to prevent duping.
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  # By default, do not retain any state when marshalling.
+  def _dump(depth = -1)
+    ''
+  end
+
+  module SingletonClassMethods # :nodoc:
+
+    def clone # :nodoc:
+      Singleton.__init__(super)
+    end
+
+    # By default calls instance(). Override to retain singleton state.
+    def _load(str)
+      instance
+    end
+
+    def instance # :nodoc:
+      @singleton__instance__ || @singleton__mutex__.synchronize { @singleton__instance__ ||= new }
+    end
+
+    private
+
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton # :nodoc:
+    def __init__(klass) # :nodoc:
+      klass.instance_eval {
+        @singleton__instance__ = nil
+        @singleton__mutex__ = Thread::Mutex.new
+      }
+      klass
+    end
+
+    private
+
+    # extending an object with Singleton is a bad idea
+    undef_method :extend_object
+
+    def append_features(mod)
+      #  help out people counting on transitive mixins
+      unless mod.instance_of?(Class)
+        raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      super
+      klass.private_class_method :new, :allocate
+      klass.extend SingletonClassMethods
+      Singleton.__init__(klass)
+    end
+  end
+
+  ##
+  # :singleton-method: _load
+  #  By default calls instance(). Override to retain singleton state.
+
+  ##
+  # :singleton-method: instance
+  #  Returns the singleton instance.
+end

package/Binaries/Ruby/Windows/X64/utils/command_type.rb

@@ -33,6 +33,8 @@ class CommandType
   AS_REF = 31
   AS_OUT = 32
   GET_REF_VALUE = 33
+  ENABLE_NAMESPACE = 34
+  ENABLE_TYPE = 35
 
   def self.get_name(command_number)
     case command_number
@@ -99,11 +101,17 @@ class CommandType
     when 30
       return 'GET_ENUM_VALUE'
     when 31
-	  return 'AS_REF'
+      return 'AS_REF'
     when 32
-	  return 'AS_OUT'
+      return 'AS_OUT'
     when 33
-	  return 'GET_REF_VALUE'
+      return 'GET_REF_VALUE'
+    when 34
+      return 'ENABLE_NAMESPACE'
+    when 35
+      return 'ENABLE_TYPE'
+    else
+      raise 'Unknown command type'
     end
   end
 end

package/Binaries/version.txt

@@ -1 +1 @@
-2.4.4
+2.4.6

package/lib/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/lib/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/lib/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/lib/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/lib/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('../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/lib/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/lib/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/lib/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/lib/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/lib/utils/CommandType.js

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

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "javonet-nodejs-sdk",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/",
   "main": "lib/sdk/Javonet.js",
   "keywords": [],
   "author": "SdNCenter Sp. z o. o.",
   "license": "ISC",
   "devDependencies": {
-    "@jest/globals": "^26.5.3",
-    "jest": "^26.6.1",
+    "@jest/globals": "^29.7.0",
+    "jest": "^29.7.0",
     "jest-junit-reporter": "^1.1.0"
   },
   "dependencies": {
-    "@babel/core": "^7.0.0",
-    "@babel/plugin-proposal-class-properties": "^7.12.1",
-    "@vercel/ncc": "^0.25.1",
-    "node-gyp": "^10.0.1",
+    "@babel/core": "^7.24.7",
+    "@babel/plugin-transform-class-properties": "^7.24.7",
+    "@vercel/ncc": "^0.38.1",
+    "node-gyp": "^10.1.0",
     "reserved-words": "^0.1.2",
     "text-decoding": "^1.0.0",
-    "uuid": "^7.0.0"
+    "uuid": "^10.0.0"
   },
   "scripts": {
     "test": "jest tests/unitTests tests/functionalTests tests/performanceTests  --maxWorkers=3 --colors",

package/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/.meta/ExtUtils-Helpers-0.026/install.json

@@ -1 +0,0 @@
-{"dist":"ExtUtils-Helpers-0.026","version":"0.026","pathname":"L/LE/LEONT/ExtUtils-Helpers-0.026.tar.gz","target":"ExtUtils::Helpers","name":"ExtUtils::Helpers","provides":{"ExtUtils::Helpers::Unix":{"version":"0.026","file":"lib/ExtUtils/Helpers/Unix.pm"},"ExtUtils::Helpers":{"version":"0.026","file":"lib/ExtUtils/Helpers.pm"},"ExtUtils::Helpers::VMS":{"version":"0.026","file":"lib/ExtUtils/Helpers/VMS.pm"},"ExtUtils::Helpers::Windows":{"file":"lib/ExtUtils/Helpers/Windows.pm","version":"0.026"}}}

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/.meta/ExtUtils-Helpers-0.026/install.json

@@ -1 +0,0 @@
-{"name":"ExtUtils::Helpers","target":"ExtUtils::Helpers","provides":{"ExtUtils::Helpers::Unix":{"version":"0.026","file":"lib/ExtUtils/Helpers/Unix.pm"},"ExtUtils::Helpers::VMS":{"file":"lib/ExtUtils/Helpers/VMS.pm","version":"0.026"},"ExtUtils::Helpers":{"file":"lib/ExtUtils/Helpers.pm","version":"0.026"},"ExtUtils::Helpers::Windows":{"version":"0.026","file":"lib/ExtUtils/Helpers/Windows.pm"}},"dist":"ExtUtils-Helpers-0.026","version":"0.026","pathname":"L/LE/LEONT/ExtUtils-Helpers-0.026.tar.gz"}

package/Binaries/Python/Linux/X64/javonet/core/handler/CommandHandler/GetTypeHandler.py

@@ -1,28 +0,0 @@
-from importlib import import_module
-
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
-
-
-class GetTypeHandler(AbstractCommandHandler):
-    def __init__(self):
-        self._required_parameters_count = 1
-
-    def process(self, command):
-        try:
-            if len(command.payload) < self._required_parameters_count:
-                raise Exception("GetTypeHandler parameters mismatch!")
-            if len(command.payload) == 1:
-                type_name = command.payload[0].split(".")
-
-                if len(type_name) == 1:
-                    return import_module(type_name[0])
-                else:
-                    for i in range(len(type_name) - 1):
-                        loaded_module = import_module(".".join(type_name[:i+1]))
-                    return getattr(loaded_module, type_name[-1])
-            else:
-                return import_module(".".join(command.payload[:]))
-        except Exception as e:
-            exc_type, exc_value = type(e), e
-            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
-            raise new_exc from None

package/Binaries/Python/Linux/X64/javonet/core/handler/ReferencesCache.py

@@ -1,35 +0,0 @@
-import uuid
-
-from javonet.utils.CommandType import CommandType
-
-
-class ReferencesCache(object):
-    _instance = None
-    references_cache = dict()
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(ReferencesCache, cls).__new__(cls)
-            # Put any initialization here.
-        return cls._instance
-
-    def cache_reference(self, object_reference):
-        uuid_ = str(uuid.uuid4())
-        self.references_cache[uuid_] = object_reference
-        return uuid_
-
-    def resolve_reference(self, command):
-        if command.command_type != CommandType.Reference:
-            raise Exception(
-                "Trying to dereference Python command with command_type: " + str(command.command_type))
-        try:
-            return self.references_cache[command.payload[0]]
-        except KeyError:
-            raise Exception("Object not found in references")
-
-    def delete_reference(self, reference_guid):
-        try:
-            del self.references_cache[reference_guid]
-            return 0
-        except KeyError:
-            raise Exception("Object not found in references")

package/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/GetTypeHandler.py

@@ -1,28 +0,0 @@
-from importlib import import_module
-
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
-
-
-class GetTypeHandler(AbstractCommandHandler):
-    def __init__(self):
-        self._required_parameters_count = 1
-
-    def process(self, command):
-        try:
-            if len(command.payload) < self._required_parameters_count:
-                raise Exception("GetTypeHandler parameters mismatch!")
-            if len(command.payload) == 1:
-                type_name = command.payload[0].split(".")
-
-                if len(type_name) == 1:
-                    return import_module(type_name[0])
-                else:
-                    for i in range(len(type_name) - 1):
-                        loaded_module = import_module(".".join(type_name[:i+1]))
-                    return getattr(loaded_module, type_name[-1])
-            else:
-                return import_module(".".join(command.payload[:]))
-        except Exception as e:
-            exc_type, exc_value = type(e), e
-            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
-            raise new_exc from None

package/Binaries/Python/MacOs/X64/javonet/core/handler/ReferencesCache.py

@@ -1,35 +0,0 @@
-import uuid
-
-from javonet.utils.CommandType import CommandType
-
-
-class ReferencesCache(object):
-    _instance = None
-    references_cache = dict()
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(ReferencesCache, cls).__new__(cls)
-            # Put any initialization here.
-        return cls._instance
-
-    def cache_reference(self, object_reference):
-        uuid_ = str(uuid.uuid4())
-        self.references_cache[uuid_] = object_reference
-        return uuid_
-
-    def resolve_reference(self, command):
-        if command.command_type != CommandType.Reference:
-            raise Exception(
-                "Trying to dereference Python command with command_type: " + str(command.command_type))
-        try:
-            return self.references_cache[command.payload[0]]
-        except KeyError:
-            raise Exception("Object not found in references")
-
-    def delete_reference(self, reference_guid):
-        try:
-            del self.references_cache[reference_guid]
-            return 0
-        except KeyError:
-            raise Exception("Object not found in references")