javonet-nodejs-sdk 2.5.8 → 2.5.10

package/dist/lib/core/handler/PassDelegateHandler.js

@@ -0,0 +1,157 @@
+// 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()

package/dist/lib/core/handler/ResolveReferenceHandler.js

@@ -0,0 +1,13 @@
+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()

package/dist/lib/core/handler/SetGlobalStaticFieldHandler.js

@@ -0,0 +1,38 @@
+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()

package/dist/lib/core/handler/SetInstanceFieldHandler.js

@@ -0,0 +1,35 @@
+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()

package/dist/lib/core/handler/SetStaticFieldHandler.js

@@ -0,0 +1,33 @@
+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()

package/dist/lib/core/handler/ValueHandler.js

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

package/dist/lib/core/interpreter/Interpreter.js

@@ -0,0 +1,142 @@
+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 (
+                command.runtimeName === RuntimeName.Nodejs &&
+                connectionData.connectionType === ConnectionType.WEB_SOCKET
+            ) {
+                try {
+                    // lazy transmitter websocket loading
+                    if (!_TransmitterWebsocket) {
+                        _TransmitterWebsocket = require('../transmitter/TransmitterWebsocket')
+                    }
+                    const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
+                    return promise
+                        .then((_response) => {
+                            if (_response) {
+                                const command = new CommandDeserializer(_response).deserialize()
+                                return command
+                            }
+                        })
+                        .catch((error) => {
+                            throw error
+                        })
+                } catch (error) {
+                    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?
+        }
+    }
+
+    /**
+     *
+     * @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
+                        }
+                    })
+                    .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

package/dist/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 → dist/lib}/core/protocol/CommandDeserializer.js

@@ -1,23 +1,20 @@
-const TypeDeserializer = require("./TypeDeserializer")
-const Command = require("../../utils/Command")
-const Type = require("../../utils/Type")
-const StringEncodingMode = require("../../utils/StringEncodingMode")
-
+const TypeDeserializer = require('./TypeDeserializer')
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
 
 class CommandDeserializer {
     constructor(buffer) {
         this.buffer = buffer
-        this.command = new Command(
-            buffer[0],
-            buffer[10],
-            []
-        )
+        this.command = new Command(buffer[0], buffer[10], [])
         this.position = 11
     }
 
+    /**
+     * @returns {Command}
+     */
     deserialize() {
         while (!this.isAtEnd()) {
-            this.command = this.command.addArgToPayload((this.readObject(this.buffer[this.position])))
+            this.command = this.command.addArgToPayload(this.readObject(this.buffer[this.position]))
         }
         return this.command
     }
@@ -27,7 +24,7 @@ class CommandDeserializer {
     }
 
     readObject(typeNum) {
-        let type = Object.entries(Type).find(entry => entry[1] === typeNum)[0]
+        const type = Object.entries(Type).find((entry) => entry[1] === typeNum)[0]
         switch (type) {
             case 'JAVONET_COMMAND':
                 return this.readCommand()
@@ -36,17 +33,17 @@ class CommandDeserializer {
             case 'JAVONET_INTEGER':
                 return this.readInt()
             case 'JAVONET_BOOLEAN':
-                return this.readBool();
+                return this.readBool()
             case 'JAVONET_FLOAT':
-                return this.readFloat();
+                return this.readFloat()
             case 'JAVONET_BYTE':
-                return this.readByte();
+                return this.readByte()
             case 'JAVONET_CHAR':
-                return this.readChar();
+                return this.readChar()
             case 'JAVONET_LONG_LONG':
-                return this.readLongLong();
+                return this.readLongLong()
             case 'JAVONET_DOUBLE':
-                return this.readDouble();
+                return this.readDouble()
             case 'JAVONET_UNSIGNED_LONG_LONG':
                 return this.readUllong
             case 'JAVONET_UNSIGNED_INTEGER':
@@ -59,112 +56,110 @@ class CommandDeserializer {
     }
 
     readCommand() {
-        let p = this.position
-        let numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
-        let runtime = this.buffer[p + 5]
-        let type = this.buffer[p + 6]
+        const p = this.position
+        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+        const runtime = this.buffer[p + 5]
+        const type = this.buffer[p + 6]
         this.position += 7
-        let command = new Command(runtime, type, [])
+        const command = new Command(runtime, type, [])
         return this.readCommandRecursively(numberOfElementsInPayload, command)
     }
 
     readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
         if (numberOfElementsInPayloadLeft === 0) return cmd
-        let p = this.position
+        const p = this.position
         cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
         return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
     }
 
     readString() {
         let p = this.position
-        let stringEncodingMode = this.buffer[p + 1]
-        let size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
+        const stringEncodingMode = this.buffer[p + 1]
+        const size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
         this.position += 6
         p = this.position
         this.position += size
         return TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size))
-
     }
 
     readInt() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
     }
 
     readBool() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
     }
 
     readFloat() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
     }
 
     readByte() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
     }
 
     readChar() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
     }
 
     readLongLong() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
     }
 
     readDouble() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
     }
 
     readUllong() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
     }
 
     readUInt() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
     }
 
     readNull() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
         this.position += size
         return TypeDeserializer.deserializeNull()
     }
 }
 
-module.exports = CommandDeserializer
+module.exports = CommandDeserializer