javonet-ruby-sdk 2.5.15 → 2.5.16

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/CommandDeserializer.js

@@ -1,181 +0,0 @@
-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.position = 11
-    }
-
-    /**
-     * @returns {Command}
-     */
-    deserialize() {
-        while (!this.isAtEnd()) {
-            this.command = this.command.addArgToPayload(this.readObject(this.buffer[this.position]))
-        }
-        return this.command
-    }
-
-    isAtEnd() {
-        return this.position === this.buffer.length
-    }
-
-    readObject(typeNum) {
-        const type = Object.entries(Type).find((entry) => entry[1] === typeNum)[0]
-        switch (type) {
-            case 'JAVONET_COMMAND':
-                return this.readCommand()
-            case 'JAVONET_STRING':
-                return this.readString()
-            case 'JAVONET_INTEGER':
-                return this.readInt()
-            case 'JAVONET_BOOLEAN':
-                return this.readBool()
-            case 'JAVONET_FLOAT':
-                return this.readFloat()
-            case 'JAVONET_BYTE':
-                return this.readByte()
-            case 'JAVONET_CHAR':
-                return this.readChar()
-            case 'JAVONET_LONG_LONG':
-                return this.readLongLong()
-            case 'JAVONET_DOUBLE':
-                return this.readDouble()
-            case 'JAVONET_UNSIGNED_LONG_LONG':
-                return this.readUllong
-            case 'JAVONET_UNSIGNED_INTEGER':
-                return this.readUInt()
-            case 'JAVONET_NULL':
-                return this.readNull()
-            default:
-                throw 'Unknown type - not supported in JavaScript'
-        }
-    }
-
-    readCommand() {
-        const p = this.position;
-        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5));
-        const runtime = this.buffer[p + 5];
-        const commandType = this.buffer[p + 6];
-        this.position += 7;
-
-        const payload = new Array(numberOfElementsInPayload);
-        for (let i = 0; i < numberOfElementsInPayload; i++) {
-            payload[i] = this.readObject(this.buffer[this.position]);
-        }
-
-        return new Command(runtime, commandType, payload);
-    }
-
-    // old implementation
-    // readCommand() {
-    //     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
-    //     const command = new Command(runtime, type, [])
-    //     return this.readCommandRecursively(numberOfElementsInPayload, command)
-    // }
-    //
-    // readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
-    //     if (numberOfElementsInPayloadLeft === 0) return cmd
-    //     const p = this.position
-    //     cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
-    //     return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
-    // }
-
-    readString() {
-        let p = this.position
-        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() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
-    }
-
-    readBool() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
-    }
-
-    readFloat() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
-    }
-
-    readByte() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
-    }
-
-    readChar() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
-    }
-
-    readLongLong() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
-    }
-
-    readDouble() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
-    }
-
-    readUllong() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
-    }
-
-    readUInt() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
-    }
-
-    readNull() {
-        const size = 1
-        this.position += 2
-        this.position += size
-        return TypeDeserializer.deserializeNull()
-    }
-}
-
-module.exports = CommandDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/CommandSerializer.js

@@ -1,50 +0,0 @@
-
-const Command = require('../../utils/Command');
-const TypeSerializer = require('./TypeSerializer');
-const RuntimeName = require('../../utils/RuntimeName');
-
-class CommandSerializer {
-    serialize(rootCommand, connectionData) {
-        const buffers = [];
-        // Write runtime name and a zero byte for runtime version.
-        buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
-
-        if (connectionData) {
-            buffers.push(connectionData.serializeConnectionData());
-        } else {
-
-            buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
-        }
-
-        buffers.push(Uint8Array.of(RuntimeName.Nodejs, rootCommand.commandType));
-
-        this.serializeRecursively(rootCommand, buffers);
-
-        return concatenateUint8Arrays(buffers);
-    }
-
-    serializeRecursively(command, buffers) {
-        for (const item of command.payload) {
-            if (item instanceof Command) {
-                buffers.push(TypeSerializer.serializeCommand(item));
-                this.serializeRecursively(item, buffers);
-            } else {
-                buffers.push(TypeSerializer.serializePrimitive(item));
-            }
-        }
-    }
-}
-
-function concatenateUint8Arrays(arrays) {
-    let totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-
-    let offset = 0;
-    for (const arr of arrays) {
-        result.set(arr, offset);
-        offset += arr.length;
-    }
-    return result;
-}
-
-module.exports = CommandSerializer;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/TypeDeserializer.js

@@ -1,83 +0,0 @@
-const Command = require('../../utils/Command')
-const StringEncodingMode = require('../../utils/StringEncodingMode')
-const { Buffer } = require('buffer')
-
-class TypeDeserializer {
-    static deserializeCommand(encodedCommand) {
-        return new Command(encodedCommand[0], encodedCommand[1], [])
-    }
-
-    static deserializeString(stringEncodingMode, encodedString) {
-        switch (stringEncodingMode) {
-            case StringEncodingMode.ASCII:
-                return String.fromCharCode(...encodedString)
-            case StringEncodingMode.UTF8: {
-                const decoder = new TextDecoder('UTF-8')
-                return decoder.decode(new Uint8Array(encodedString))
-            }
-            case StringEncodingMode.UTF16: {
-                let str = ''
-                let newBuffer = new Uint8Array(encodedString)
-                for (let i = 0; i < newBuffer.length; i++) {
-                    newBuffer[i] = encodedString[i]
-                }
-                for (let i = 0; i < encodedString.length; i = i + 2) {
-                    str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1])
-                }
-                return str
-            }
-            case StringEncodingMode.UTF32:
-                throw 'Type utf32-encoded string not supported in JavaScript'
-            default:
-                throw 'Unknown string encoding - not supported in JavaScript'
-        }
-    }
-
-    static deserializeInt(encodedInt) {
-        return (
-            (encodedInt[0] & 0xff) |
-            ((encodedInt[1] & 0xff) << 8) |
-            ((encodedInt[2] & 0xff) << 16) |
-            ((encodedInt[3] & 0xff) << 24)
-        )
-    }
-
-    static deserializeBool(encodedBool) {
-        return encodedBool[0] === 1
-    }
-
-    static deserializeFloat(encodedFloat) {
-        return Buffer.from(encodedFloat).readFloatLE()
-    }
-
-    static deserializeByte(encodedByte) {
-        return Buffer.from(encodedByte).readUint8()
-    }
-
-    static deserializeChar(encodedChar) {
-        return Buffer.from(encodedChar).readUint8()
-    }
-
-    static deserializeLongLong(encodedLongLong) {
-        return Buffer.from(encodedLongLong).readBigInt64LE()
-    }
-
-    static deserializeDouble(encodedDouble) {
-        return Buffer.from(encodedDouble).readDoubleLE()
-    }
-
-    static deserializeULLong(encodedULLong) {
-        return Buffer.from(encodedULLong).readBigUInt64LE()
-    }
-
-    static deserializeUInt(encodedUInt) {
-        return Buffer.from(encodedUInt).readUIntLE(0, 4)
-    }
-
-    // eslint-disable-next-line no-unused-vars
-    static deserializeNull(encodedNull = null) {
-        return null
-    }
-}
-
-module.exports = TypeDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/TypeSerializer.js

@@ -1,143 +0,0 @@
-const Command = require('../../utils/Command')
-const Type = require('../../utils/Type')
-const StringEncodingMode = require('../../utils/StringEncodingMode')
-const { Buffer } = require('buffer')
-const CustomError = require('../../utils/CustomError')
-
-const encoder = new TextEncoder()
-
-class TypeSerializer {
-    static serializePrimitive(payload_item) {
-        if (payload_item === null) {
-            return TypeSerializer.serializeNull()
-        }
-        if (payload_item instanceof Command) {
-            return TypeSerializer.serializeCommand(payload_item)
-        } else if (typeof payload_item === 'number' || payload_item instanceof Number) {
-            if (Number.isInteger(payload_item)) {
-                return TypeSerializer.serializeInt(payload_item)
-            } else {
-                return TypeSerializer.serializeDouble(payload_item)
-            }
-        } else if (typeof payload_item === 'string' || payload_item instanceof String) {
-            return TypeSerializer.serializeString(payload_item)
-        } else if (typeof payload_item === 'boolean' || payload_item instanceof Boolean) {
-            return TypeSerializer.serializeBool(payload_item)
-        } else {
-            if (payload_item instanceof Promise) {
-                throw new CustomError('Type not supported - Promise', JSON.stringify(payload_item))
-            }
-            if (payload_item === undefined) {
-                throw 'Type not supported - undefined'
-            }
-            throw 'Unknown type - not supported in JavaScript'
-        }
-    }
-
-    static serializeCommand(command) {
-        const buffer = Buffer.alloc(7)
-        buffer.writeUInt8(Type.JAVONET_COMMAND, 0)
-        buffer.fill(Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5)
-        buffer.writeUInt8(command.runtime, 5)
-        buffer.writeUInt8(command.commandType, 6)
-        return buffer
-    }
-
-    static serializeString(string_value) {
-        let bytes = encoder.encode(string_value)
-        const buffer = Buffer.alloc(6 + bytes.length)
-        buffer.writeUInt8(Type.JAVONET_STRING, 0)
-        buffer.writeUInt8(StringEncodingMode.UTF8, 1)
-        buffer.fill(Buffer.from(this.serializeIntValue(bytes.length)), 2, 6)
-        buffer.fill(Buffer.from(bytes), 6, 6 + bytes.length)
-        return buffer
-    }
-
-    static serializeInt(int_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_INTEGER, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeInt32LE(int_value, 2)
-        return buffer
-    }
-
-    static serializeBool(bool_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_BOOLEAN, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(bool_value ? 1 : 0, 2)
-        return buffer
-    }
-
-    static serializeFloat(float_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_FLOAT, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeFloatLE(float_value, 2)
-        return buffer
-    }
-
-    static serializeByte(byte_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_BYTE, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(byte_value, 2)
-        return buffer
-    }
-
-    static serializeChar(char_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_CHAR, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(char_value, 2)
-        return buffer
-    }
-
-    static serializeLongLong(longlong_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_LONG_LONG, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeBigInt64LE(BigInt(longlong_value), 2)
-        return buffer
-    }
-
-    static serializeDouble(double_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_DOUBLE, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeDoubleLE(double_value, 2)
-        return buffer
-    }
-
-    static serializeULLong(ullong_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_UNSIGNED_LONG_LONG, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeBigUInt64LE(ullong_value, 2)
-        return buffer
-    }
-
-    static serializeUInt(uint_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_UNSIGNED_INTEGER, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeUInt32LE(uint_value, 2)
-        return buffer
-    }
-
-    static serializeNull() {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_NULL, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(0, 2)
-        return buffer
-    }
-
-    static serializeIntValue(int_value) {
-        const buffer = Buffer.alloc(4)
-        buffer.writeInt32LE(int_value, 0)
-        return buffer
-    }
-}
-
-module.exports = TypeSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/receiver/Receiver.js

@@ -1,32 +0,0 @@
-const { InMemoryConnectionData, CommandSerializer, Interpreter } = require('../../..')
-
-let RuntimeLogger
-
-class Receiver {
-    static connectionData = new InMemoryConnectionData()
-    Receiver() {
-        if (!RuntimeLogger) {
-            RuntimeLogger = require('../../utils/RuntimeLogger')
-        }
-        RuntimeLogger.printRuntimeInfo()
-    }
-
-    /**
-     * @param {number[]} messageByteArray
-     */
-    static sendCommand(messageByteArray) {
-        return new CommandSerializer().serialize(
-            new Interpreter().process(messageByteArray),
-            this.connectionData
-        )
-    }
-
-    static heartBeat(messageByteArray) {
-        let response = new Int8Array(2)
-        response[0] = messageByteArray[11]
-        response[1] = messageByteArray[12] - 2
-        return response
-    }
-}
-
-module.exports = Receiver

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/receiver/ReceiverNative.js

@@ -1,13 +0,0 @@
-const Receiver = require('./Receiver')
-
-class ReceiverNative {
-    static sendCommand(messageByteArray) {
-        return Receiver.sendCommand(messageByteArray)
-    }
-
-    static heartBeat(messageByteArray) {
-        return Receiver.heartBeat(messageByteArray)
-    }
-}
-
-global.ReceiverNative = ReceiverNative