javonet-ruby-sdk 2.5.15 → 2.5.17

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()

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

@@ -1,157 +0,0 @@
-// eslint-disable-next-line no-unused-vars
-const { Interpreter, Command, CommandType, InMemoryConnectionData, DelegatesCache } = require('../../..')
-const AbstractHandler = require('./AbstractHandler')
-
-/**
- * PassDelegateHandler class responsible for processing a command to create a delegate.
- */
-class PassDelegateHandler extends AbstractHandler {
-    constructor() {
-        super()
-        /**
-         * Minimum required parameters count for the command.
-         * @type {number}
-         */
-        this.requiredParametersCount = 1
-        this.interpreter = new Interpreter()
-    }
-
-    /**
-     * Processes the given command to create and compile a delegate.
-     * @param {Command} command - The command to process.
-     * @returns {Function} The compiled delegate function.
-     */
-    process(command) {
-        this.validateCommand(command)
-
-        const delegateGuid = command.payload[0]
-        const delegate = DelegatesCache.getDelegate(delegateGuid)
-
-        return delegate
-    }
-
-    /**
-     * Validates the command to ensure it has enough parameters.
-     * @param {Command} command - The command to validate.
-     */
-    validateCommand(command) {
-        if (command.payload.length < this.requiredParametersCount) {
-            throw new Error('PassDelegateHandler parameters mismatch')
-        }
-    }
-
-    /**
-     * Retrieves the arguments from the command payload.
-     * @param {Command} command - The command containing the payload.
-     * @returns {Array} The extracted arguments.
-     */
-    getArguments(command) {
-        return command.payload.length > 2 ? command.payload.slice(2) : []
-    }
-
-    /**
-     * Extracts argument types from the arguments array.
-     * @param {Array} args - The arguments array.
-     * @returns {Array} The argument types.
-     */
-    getArgumentTypes(args) {
-        return args.slice(0, -1).map((arg) => arg.constructor)
-    }
-
-    /**
-     * Retrieves the return type from the arguments array.
-     * @param {Array} args - The arguments array.
-     * @returns {Function} The return type.
-     */
-    getReturnType(args) {
-        return args[args.length - 1].constructor
-    }
-
-    /**
-     * Creates parameter expressions from argument types.
-     * @param {Array} argsTypes - The argument types.
-     * @returns {Array} The parameter expressions.
-     */
-    createParameters(argsTypes) {
-        return argsTypes.map((type, index) => ({ name: `arg${index}`, type }))
-    }
-
-    /**
-     * Creates an array of arguments for the delegate.
-     * @param {string} delegateGuid - The delegate identifier.
-     * @param {Array} parameters - The parameter expressions.
-     * @returns {Array} The arguments array.
-     */
-    createArgsArray(delegateGuid, parameters) {
-        return [delegateGuid, ...parameters.map((param) => param.name)]
-    }
-
-    /**
-     * Creates a command expression.
-     * @param {string} callingRuntimeName - The runtime name.
-     * @param {Array} payload - The arguments array.
-     * @returns {Object} The command object.
-     */
-    createCommand(callingRuntimeName, payload) {
-        return {
-            runtimeName: callingRuntimeName,
-            type: CommandType.InvokeDelegate,
-            payload,
-        }
-    }
-
-    /**
-     * Creates a method call to execute the command.
-     * @param {Command} command - The command object.
-     * @returns {Object} The response object.
-     */
-    createExecuteCall(command) {
-        return this.interpreter.execute(command, new InMemoryConnectionData())
-    }
-
-    /**
-     * Retrieves the response payload from the execution call.
-     * @param {Object} executeCall - The execution call.
-     * @returns {Array} The response payload.
-     */
-    getResponse(executeCall) {
-        return executeCall.payload
-    }
-
-    /**
-     * Converts the first element of the response to the return type.
-     * @param {Array} response - The response payload.
-     * @param {Function} returnType - The return type.
-     * @returns {*} The converted first element.
-     */
-    convertFirstElement(response, returnType) {
-        return returnType(response[0])
-    }
-
-    /**
-     * Creates a block of expressions for the delegate.
-     * @param {Function} returnType - The return type.
-     * @param {*} convertedFirstElement - The converted first element.
-     * @returns {Object} The block expression.
-     */
-    createBlock(returnType, convertedFirstElement) {
-        return { returnType, body: convertedFirstElement }
-    }
-
-    /**
-     * Creates a delegate type.
-     * @param {Array} parameters - The parameter expressions.
-     * @param {Function} returnType - The return type.
-     * @returns {Function} The delegate type.
-     */
-    createDelegateType(parameters, returnType) {
-        return (...args) => {
-            if (args.length !== parameters.length) {
-                throw new Error('Invalid argument count.')
-            }
-            return returnType
-        }
-    }
-}
-
-module.exports = new PassDelegateHandler()

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

@@ -1,13 +0,0 @@
-const ReferencesCache = require('../referenceCache/ReferencesCache')
-const AbstractHandler = require('./AbstractHandler')
-class ResolveReferenceHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        return ReferencesCache.getInstance().resolveReference(command.payload[0])
-    }
-}
-
-module.exports = new ResolveReferenceHandler()

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

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

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

@@ -1,35 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class SetInstanceFieldHandler extends AbstractHandler {
-    requiredParametersCount = 3
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error('Set Instance Field parameters mismatch')
-            }
-            const { payload } = command
-            let instance = payload[0]
-            let field = payload[1]
-            let value = payload[2]
-            if (typeof instance[field] === '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)
-            }
-            instance[field] = value
-            return 0
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
-    }
-}
-
-module.exports = new SetInstanceFieldHandler()

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

@@ -1,33 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class SetStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 3
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error('Set static field parameters mismatch')
-            }
-            const { payload } = command
-            let [obj, field, value] = payload
-            if (typeof obj[field] === 'undefined') {
-                let fields = Object.keys(obj)
-                let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:\n`
-                fields.forEach((fieldIter) => {
-                    message += `${fieldIter}\n`
-                })
-                throw new Error(message)
-            }
-            obj[field] = value
-            return 0
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
-    }
-}
-
-module.exports = new SetStaticFieldHandler()

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

@@ -1,13 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class ValueHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-    process(command) {
-        const { payload } = command
-        return payload[0]
-    }
-}
-
-module.exports = new ValueHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/interpreter/Interpreter.js

@@ -1,142 +0,0 @@
-const ConnectionType = require('../../utils/ConnectionType')
-const RuntimeName = require('../../utils/RuntimeName')
-const CommandDeserializer = require('../protocol/CommandDeserializer')
-const CommandSerializer = require('../protocol/CommandSerializer')
-
-/** @typedef {import('../../../../core/lib/declarations').WsConnectionData} WsConnectionData */
-
-let _Receiver
-let _Transmitter
-let _TransmitterWebsocket
-
-class Interpreter {
-    handler
-    /**
-     *
-     * @param {Command} command
-     * @param {IConnectionData} connectionData
-     * @returns
-     */
-    async executeAsync(command, connectionData) {
-        try {
-            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            let responseByteArray
-
-            if (
-                command.runtimeName === RuntimeName.Nodejs &&
-                connectionData.connectionType === ConnectionType.IN_MEMORY
-            ) {
-                // lazy receiver loading
-                if (!_Receiver) {
-                    _Receiver = require(require.resolve('../receiver/Receiver'))
-                }
-                responseByteArray = _Receiver.sendCommand(messageByteArray)
-            } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-                try {
-                    // lazy transmitter websocket loading
-                    if (!_TransmitterWebsocket) {
-                        _TransmitterWebsocket = require('../transmitter/TransmitterWebsocket')
-                    }
-                    const _response = await _TransmitterWebsocket.sendCommand(
-                        messageByteArray,
-                        connectionData
-                    )
-                    if (_response) {
-                        const command = new CommandDeserializer(_response).deserialize()
-                        return command
-                    } else {
-                        throw new Error('Response not received from TransmitterWebsocket')
-                    }
-                } catch (error) {
-                    // TODO: handle error exception log?
-                    console.log(error)
-                }
-            } else {
-                // lazy transmitter loading
-                if (!_Transmitter) {
-                    _Transmitter = require(require.resolve('../transmitter/Transmitter'))
-                }
-                responseByteArray = await _Transmitter.sendCommand(messageByteArray)
-            }
-            return new CommandDeserializer(responseByteArray).deserialize()
-            // eslint-disable-next-line no-unused-vars
-        } catch (error) {
-            // TODO: handle error exception log?
-            console.log(error)
-        }
-    }
-
-    /**
-     *
-     * @param {Command} command
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<Command>}
-     */
-    execute(command, connectionData) {
-        try {
-            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            let responseByteArray
-
-            if (
-                command.runtimeName === RuntimeName.Nodejs &&
-                connectionData.connectionType === ConnectionType.IN_MEMORY
-            ) {
-                // lazy receiver loading
-                if (!_Receiver) {
-                    _Receiver = require(require.resolve('../receiver/Receiver'))
-                }
-                responseByteArray = _Receiver.sendCommand(messageByteArray)
-            } else if (
-                command.runtimeName === RuntimeName.Nodejs &&
-                connectionData.connectionType === ConnectionType.WEB_SOCKET
-            ) {
-                // lazy transmitter websocket loading
-                if (!_TransmitterWebsocket) {
-                    _TransmitterWebsocket = require(require.resolve('../transmitter/TransmitterWebsocket'))
-                }
-                const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
-                return promise
-                    .then((_response) => {
-                        if (_response) {
-                            const command = new CommandDeserializer(_response).deserialize()
-                            return command
-                        } else {
-                            throw new Error('Response not received from TransmitterWebsocket')
-                        }
-                    })
-                    .catch((error) => {
-                        throw error
-                    })
-            } else {
-                // lazy transmitter loading
-                if (!_Transmitter) {
-                    _Transmitter = require(require.resolve('../transmitter/Transmitter'))
-                }
-                responseByteArray = _Transmitter.sendCommand(messageByteArray)
-            }
-            return new CommandDeserializer(responseByteArray).deserialize()
-            // eslint-disable-next-line no-unused-vars
-        } catch (error) {
-            // TODO: handle error exception log?
-        }
-    }
-
-    /**
-     *
-     * @param {number[]} messageByteArray
-     * @returns {Command}
-     */
-    process(messageByteArray) {
-        if (!this.handler) {
-            const baseHandler = require(require.resolve('../handler/Handler'))
-            if (baseHandler) {
-                const { Handler } = baseHandler
-                this.handler = new Handler()
-            }
-        }
-        const receivedCommand = new CommandDeserializer(messageByteArray).deserialize()
-        return this.handler.handleCommand(receivedCommand)
-    }
-}
-
-module.exports = Interpreter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/namespaceCache/NamespaceCache.js

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