javonet-ruby-sdk 2.5.8 → 2.5.10

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetInstanceMethodAsDelegateHandler.js

@@ -0,0 +1,73 @@
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving an instance method as a delegate.
+ */
+class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+        /** @type {Array<*>} */
+        this.args = []
+        /** @type {Object|null} */
+        this.instance = null
+    }
+
+    /**
+     * Processes a command to retrieve an instance method as a delegate.
+     * @param {Object} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+     * @returns {Function} The delegate for the instance method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        this.instance = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the instance
+        this.method = this.getMethod(this.instance, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(this.instance, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this.instance)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type.prototype).filter(
+            (key) => typeof type.prototype[key] === 'function'
+        )
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available instance public methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetInstanceMethodAsDelegateHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetStaticFieldHandler.js

@@ -0,0 +1,36 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    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]
+
+            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()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetStaticMethodAsDelegateHandler.js

@@ -0,0 +1,74 @@
+// eslint-disable-next-line no-unused-vars
+const { Command } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving a static method as a delegate.
+ */
+class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+    /** @type {Array<*>} */
+    args = []
+
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+    }
+
+    /**
+     * Processes a command to retrieve a static method as a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+     * @returns {Function} The delegate for the static method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const type = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the type
+        this.method = this.getMethod(type, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(type, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @param {Array<Function>} argsType - The argument types.
+     * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.keys(type).filter((key) => typeof type[key] === 'function')
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetStaticMethodAsDelegateHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → 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
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → 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,17 @@ const ArrayHandler = require('./ArrayHandler')
 const EnableNamespaceHandler = require('./EnableNamespaceHandler')
 const EnableTypeHandler = require('./EnableTypeHandler')
 
+const { CommandType, Command, ExceptionSerializer } = require('../../..')
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const InvokeStandaloneMethodHandler = require('./InvokeStandaloneMethodHandler')
+const GetStaticMethodAsDelegateHandler = require('./GetStaticMethodAsDelegateHandler')
+const GetInstanceMethodAsDelegateHandler = require('./GetInstanceMethodAsDelegateHandler')
+const PassDelegateHandler = require('./PassDelegateHandler')
+const InvokeDelegateHandler = require('./InvokeDelegateHandler')
+const { ConvertTypeHandler } = require('../../utils/TypesConverter')
 
 function isResponseSimpleType(response) {
-    let type = typeof (response)
+    let type = typeof response
     return ['string', 'boolean', 'number'].includes(type)
 }
 
@@ -35,7 +38,6 @@ function isResponseNull(response) {
     return response === null
 }
 
-
 const handlers = {
     [CommandType.Value]: ValueHandler,
     [CommandType.LoadLibrary]: LoadLibraryHandler,
@@ -49,6 +51,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 +60,18 @@ const handlers = {
     [CommandType.ArraySetItem]: ArraySetItemHandler,
     [CommandType.Array]: ArrayHandler,
     [CommandType.EnableNamespace]: EnableNamespaceHandler,
-    [CommandType.EnableType]: EnableTypeHandler
+    [CommandType.EnableType]: EnableTypeHandler,
+    [CommandType.GetStaticMethodAsDelegate]: GetStaticMethodAsDelegateHandler,
+    [CommandType.GetInstanceMethodAsDelegate]: GetInstanceMethodAsDelegateHandler,
+    [CommandType.PassDelegate]: PassDelegateHandler,
+    [CommandType.InvokeDelegate]: InvokeDelegateHandler,
+    [CommandType.ConvertType]: ConvertTypeHandler,
 }
 
+Object.keys(handlers).forEach((commandTypeHandler) => {
+    handlers[commandTypeHandler].handlers = handlers
+})
+
 class Handler {
     handleCommand(command) {
         try {
@@ -78,7 +90,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 +99,3 @@ class Handler {
 
 module.exports.Handler = Handler
 module.exports.handlers = handlers
-

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeDelegateHandler.js

@@ -0,0 +1,36 @@
+const { DelegatesCache } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles invoking a delegate by GUID.
+ */
+class InvokeDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {number} */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes a command to invoke a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @returns {*} The result of the delegate invocation.
+     * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+     */
+    process(command) {
+        const payload = command.payload
+        if (payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const guid = payload[0]
+        const delegate = DelegatesCache.getDelegate(guid)
+        if (!delegate) {
+            throw new Error('Delegate not found in cache')
+        }
+
+        return delegate
+    }
+}
+
+module.exports = new InvokeDelegateHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeGlobalMethodHandler.js

@@ -0,0 +1,43 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeGlobalMethodHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    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)
+        }
+    }
+}
+
+module.exports = new InvokeGlobalMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeInstanceMethodHandler.js

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeInstanceMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Instance Method parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            let method = instance[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(instance.__proto__).filter(function (property) {
+                    return typeof instance.__proto__[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in object. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, instance, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new InvokeInstanceMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeStandaloneMethodHandler.js

@@ -0,0 +1,56 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStandaloneMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke standalone Method parameters mismatch')
+            }
+
+            const { payload } = command
+            const type = payload[0]
+            const methodName = payload[1]
+            const args = payload.slice(2)
+
+            if (typeof type === 'function') {
+                // assuming that function is exported as single (default)
+                return Reflect.apply(type, undefined, args)
+            }
+
+            if (typeof type === 'object') {
+                // assuming that function inside of multiple exports
+                const method = type[methodName]
+
+                if (typeof method === 'function') {
+                    return Reflect.apply(method, undefined, args)
+                }
+                return this.throwError(type, methodName)
+            } else {
+                throw new Error(`Function ${methodName} not found in libary.`)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+
+    throwError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type).filter(
+            (property) => typeof type[property] === 'function'
+        )
+
+        let message = `Function ${methodName} not found in libary. Available standalone methods:\n`
+        methods.forEach((methodIter) => {
+            message += `${methodIter}\n`
+        })
+
+        throw new Error(message)
+    }
+}
+
+module.exports = new InvokeStandaloneMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeStaticMethodHandler.js

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStaticMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Static Method parameters mismatch')
+            }
+            const { payload } = command
+            let type = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            let method = type[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, undefined, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new InvokeStaticMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/LoadLibraryHandler.js

@@ -2,7 +2,7 @@ const AbstractHandler = require('./AbstractHandler')
 
 class LoadLibraryHandler extends AbstractHandler {
     requiredParametersCount = 1
-    static loadedLibraries = [];
+    static loadedLibraries = []
 
     constructor() {
         super()
@@ -10,9 +10,9 @@ class LoadLibraryHandler extends AbstractHandler {
 
     process(command) {
         if (command.payload.length < this.requiredParametersCount) {
-            throw new Error("Load Library parameters mismatch")
+            throw new Error('Load Library parameters mismatch')
         }
-        let {payload} = command
+        let { payload } = command
         let [lib] = payload
         let pathArray = lib.split(/[/\\]/)
         let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
@@ -23,6 +23,7 @@ class LoadLibraryHandler extends AbstractHandler {
         try {
             moduleExports = require(lib)
             LoadLibraryHandler.loadedLibraries.push(lib)
+            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             try {
                 moduleExports = require(`${process.cwd()}/${lib}`)