javonet-ruby-sdk 2.5.14 → 2.5.16

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

@@ -1,73 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,74 +0,0 @@
-// 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/lib/core/handler/GetTypeHandler.js

@@ -1,63 +0,0 @@
-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()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error('Get Type parameters mismatch')
-            }
-            const { payload } = command
-            let typeName = payload[0]
-            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')
-                throw new Error(message)
-            }
-
-            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 {
-                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)
-        }
-    }
-
-    getAvailableTypes() {
-        let availableTypes = []
-        LoadLibraryHandler.getLoadedLibraries().forEach((lib) => {
-            const moduleExports = require(lib)
-            availableTypes.push(moduleExports.name)
-            Object.keys(moduleExports).forEach((key) => {
-                availableTypes.push(key)
-            })
-        })
-        return availableTypes
-    }
-}
-
-module.exports = new GetTypeHandler()

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

@@ -1,98 +0,0 @@
-const { CommandType, Command, ExceptionSerializer } = require('../../..')
-const ReferencesCache = require('../referenceCache/ReferencesCache')
-
-const ValueHandler = require('./ValueHandler')
-const LoadLibraryHandler = require('./LoadLibraryHandler')
-const GetTypeHandler = require('./GetTypeHandler')
-const InvokeStaticMethodHandler = require('./InvokeStaticMethodHandler')
-const GetStaticFieldHandler = require('./GetStaticFieldHandler')
-const SetStaticFieldHandler = require('./SetStaticFieldHandler')
-const ResolveReferenceHandler = require('./ResolveReferenceHandler')
-const CreateClassInstanceHandler = require('./CreateClassInstanceHandler')
-const GetInstanceFieldHandler = require('./GetInstanceFieldHandler')
-const SetInstanceFieldHandler = require('./SetInstanceFieldHandler')
-const InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReferenceHandler = require('./DestructReferenceHandler')
-const CastHandler = require('./CastingHandler')
-const ArrayGetItemHandler = require('./ArrayGetItemHandler')
-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 GetStaticMethodAsDelegateHandler = require('./GetStaticMethodAsDelegateHandler')
-const GetInstanceMethodAsDelegateHandler = require('./GetInstanceMethodAsDelegateHandler')
-const PassDelegateHandler = require('./PassDelegateHandler')
-const InvokeDelegateHandler = require('./InvokeDelegateHandler')
-const InvokeGlobalFunctionHandler = require('./InvokeGlobalFunctionHandler')
-
-function isResponseSimpleType(response) {
-    let type = typeof response
-    return ['string', 'boolean', 'number'].includes(type)
-}
-
-function isResponseNull(response) {
-    return response === null
-}
-
-const handlers = {
-    [CommandType.Value]: ValueHandler,
-    [CommandType.LoadLibrary]: LoadLibraryHandler,
-    [CommandType.InvokeStaticMethod]: InvokeStaticMethodHandler,
-    [CommandType.GetType]: GetTypeHandler,
-    [CommandType.GetStaticField]: GetStaticFieldHandler,
-    [CommandType.SetStaticField]: SetStaticFieldHandler,
-    [CommandType.CreateClassInstance]: CreateClassInstanceHandler,
-    [CommandType.Reference]: ResolveReferenceHandler,
-    [CommandType.Cast]: CastHandler,
-    [CommandType.GetInstanceField]: GetInstanceFieldHandler,
-    [CommandType.SetInstanceField]: SetInstanceFieldHandler,
-    [CommandType.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
-    [CommandType.DestructReference]: DestructReferenceHandler,
-    [CommandType.ArrayGetItem]: ArrayGetItemHandler,
-    [CommandType.ArrayGetSize]: ArrayGetSizeHandler,
-    [CommandType.ArrayGetRank]: ArrayGetRankHandler,
-    [CommandType.ArraySetItem]: ArraySetItemHandler,
-    [CommandType.Array]: ArrayHandler,
-    [CommandType.EnableNamespace]: EnableNamespaceHandler,
-    [CommandType.EnableType]: EnableTypeHandler,
-    [CommandType.GetStaticMethodAsDelegate]: GetStaticMethodAsDelegateHandler,
-    [CommandType.GetInstanceMethodAsDelegate]: GetInstanceMethodAsDelegateHandler,
-    [CommandType.PassDelegate]: PassDelegateHandler,
-    [CommandType.InvokeDelegate]: InvokeDelegateHandler,
-    // [CommandType.ConvertType]: ConvertTypeHandler,
-    [CommandType.InvokeGlobalFunction]: InvokeGlobalFunctionHandler,
-}
-
-Object.keys(handlers).forEach((commandTypeHandler) => {
-    handlers[commandTypeHandler].handlers = handlers
-})
-
-class Handler {
-    handleCommand(command) {
-        try {
-            if (command.commandType === CommandType.RetrieveArray) {
-                let responseArray = handlers[CommandType.Reference].handleCommand(command.payload[0])
-                return Command.createArrayResponse(responseArray, command.runtimeName)
-            }
-            let response = handlers[command.commandType].handleCommand(command)
-            return this.parseCommand(response, command.runtimeName)
-        } catch (error) {
-            return ExceptionSerializer.serializeException(error, command)
-        }
-    }
-
-    parseCommand(response, runtimeName) {
-        if (isResponseNull(response) || isResponseSimpleType(response)) {
-            return Command.createResponse(response, runtimeName)
-        } else {
-            let cache = ReferencesCache.getInstance()
-            let uuid = cache.cacheReference(response)
-            return Command.createReference(uuid, runtimeName)
-        }
-    }
-}
-
-module.exports.Handler = Handler
-module.exports.handlers = handlers

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

@@ -1,36 +0,0 @@
-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/InvokeGlobalFunctionHandler.js

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

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

@@ -1,38 +0,0 @@
-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/InvokeStaticMethodHandler.js

@@ -1,38 +0,0 @@
-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/lib/core/handler/LoadLibraryHandler.js

@@ -1,48 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class LoadLibraryHandler extends AbstractHandler {
-    requiredParametersCount = 1
-    static loadedLibraries = []
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        if (command.payload.length < this.requiredParametersCount) {
-            throw new Error('Load Library parameters mismatch')
-        }
-        let { payload } = command
-        let [lib] = payload
-        let pathArray = lib.split(/[/\\]/)
-        let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
-        libraryName = libraryName.replace('.js', '')
-
-        let moduleExports
-
-        try {
-            moduleExports = require(lib)
-            LoadLibraryHandler.loadedLibraries.push(lib)
-            // eslint-disable-next-line no-unused-vars
-        } catch (error) {
-            try {
-                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
-    }
-
-    getLoadedLibraries() {
-        return LoadLibraryHandler.loadedLibraries
-    }
-}
-
-module.exports = new LoadLibraryHandler()