javonet-ruby-sdk 2.5.14 → 2.5.16

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/referenceCache/ReferencesCache.js

@@ -1,30 +0,0 @@
-const v4 = require('../../utils/uuid/v4')
-
-let _cache = {}
-let _instance = null
-
-class ReferencesCache {
-    static getInstance() {
-        if (_instance === null) {
-            _instance = new ReferencesCache()
-        }
-        return _instance
-    }
-
-    cacheReference(reference) {
-        let id = v4()
-        _cache[id] = reference
-        return id
-    }
-
-    resolveReference(id) {
-        return _cache[id]
-    }
-
-    deleteReference(referenceGuid) {
-        delete _cache[referenceGuid]
-        return 0
-    }
-}
-
-module.exports = ReferencesCache

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/Transmitter.js

@@ -1,21 +0,0 @@
-const wrapper = require('./TransmitterWrapper')
-
-class Transmitter {
-    static sendCommand(messageArray) {
-        return wrapper.sendCommand(messageArray)
-    }
-
-    static activate = function (licenseKey) {
-        return wrapper.activate(licenseKey)
-    }
-
-    static setConfigSource(configSource) {
-        return wrapper.setConfigSource(configSource)
-    }
-
-    static setJavonetWorkingDirectory(workingDirectory) {
-        return wrapper.setJavonetWorkingDirectory(workingDirectory)
-    }
-}
-
-module.exports = Transmitter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/TransmitterWebsocket.js

@@ -1,33 +0,0 @@
-const WebSocketClient = require('../webSocketClient/WebSocketClient')
-
-/** @typedef {import('../../../../core/lib/declarations').WsConnectionData} WsConnectionData */
-
-class TransmitterWebsocket {
-    /**
-     * @returns {void}
-     */
-    static initialize() {}
-
-    /**
-     * @returns {void}
-     */
-    static setConfigSource() {}
-
-    /**
-     * @returns {void}
-     */
-    static activate() {}
-
-    /**
-     * @async
-     * @param {number[]} messageByteArray
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<number[]>} responseByteArray
-     */
-    static async sendCommand(messageByteArray, connectionData) {
-        const { hostname } = connectionData
-        return new WebSocketClient(hostname).send(messageByteArray)
-    }
-}
-
-module.exports = TransmitterWebsocket

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/TransmitterWrapper.js

@@ -1,47 +0,0 @@
-let library
-
-class TransmitterWrapper {
-
-    static isNativeLibraryLoaded() {
-        return library !== undefined
-    }
-
-    static loadNativeLibrary() {
-        if (this.isNativeLibraryLoaded()) {
-            return
-        }
-
-        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
-
-        const nativeAddonPath = `${binariesRootPath}/build/Release/JavonetNodejsRuntimeAddon.node`
-
-        library = require(nativeAddonPath)
-
-        library.initializeTransmitter(binariesRootPath)
-        // eslint-disable-next-line no-unused-vars
-        const ReceiverNative = require('../receiver/ReceiverNative')
-        library.setReceiverNative(global.ReceiverNative)
-    }
-
-    static activate(licenseKey) {
-        this.loadNativeLibrary()
-        return library.activate(licenseKey)
-    }
-
-    static sendCommand(messageArray) {
-        this.loadNativeLibrary()
-        return library.sendCommand(messageArray)
-    }
-
-    static setConfigSource(configSource) {
-        this.loadNativeLibrary()
-        return library.setConfigSource(configSource)
-    }
-
-    static setJavonetWorkingDirectory(path) {
-        this.loadNativeLibrary()
-        library.setJavonetWorkingDirectory(path)
-    }
-}
-
-module.exports = TransmitterWrapper

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/typeCache/TypeCache.js

@@ -1,39 +0,0 @@
-class TypeCache {
-    static _instance = null
-    typeCache = []
-
-    constructor() {
-        if (TypeCache._instance === null) {
-            TypeCache._instance = this
-        }
-        return TypeCache._instance
-    }
-
-    cacheType(typRegex) {
-        this.typeCache.push(typRegex)
-    }
-
-    isTypeCacheEmpty() {
-        return this.typeCache.length === 0
-    }
-
-    isTypeAllowed(typeToCheck) {
-        for (let pattern of this.typeCache) {
-            if (new RegExp(pattern).test(typeToCheck.name)) {
-                return true
-            }
-        }
-        return false
-    }
-
-    getCachedTypes() {
-        return this.typeCache
-    }
-
-    clearCache() {
-        this.typeCache = []
-        return 0
-    }
-}
-
-module.exports = TypeCache

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/webSocketClient/WebSocketClient.js

@@ -1,136 +0,0 @@
-const WebSocket = require('ws')
-
-/**
- * Enum for WebSocket states.
- * @readonly
- * @enum {string}
- */
-const WebSocketStateEnum = {
-    OPEN: 'open',
-    CLOSE: 'close',
-    ERROR: 'error',
-}
-
-/**
- * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
- */
-class WebSocketClient {
-    /**
-     * @param {string} url
-     * @param {object} options
-     */
-    constructor(url, options) {
-        /**
-         * @type {string}
-         */
-        this.url = url
-
-        /**
-         * @type {WebSocket | null}
-         */
-        this.instance = null
-
-        /**
-         * @type {boolean} isConnected indicates whether the WebSocket is connected.
-         */
-        this.isConnected = false
-
-        /**
-         * @type {boolean}
-         */
-        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true
-    }
-
-    /**
-     * Connects to the WebSocket server.
-     * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
-     */
-    connect() {
-        return new Promise((resolve, reject) => {
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.instance = client;
-                resolve(client);
-            })
-
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
-                reject(error)
-            })
-
-            client.on(WebSocketStateEnum.CLOSE, () => {
-                reject(new Error("Connection closed before receiving message"))
-            })
-        });
-    }
-
-    /**
-     * Sends messageArray through websocket connection
-     * @async
-     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
-     */
-    send(messageArray) {
-        return new Promise((resolve, reject) => {
-            (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
-                client.send(messageArray, (err) => {
-                    if (err) {
-                        reject(err)
-                    }
-                })
-
-                client.on('message', (message) => {
-                    resolve(message)
-
-                    if (this.isDisconnectedAfterMessage) {
-                        this.disconnect()
-                    }
-                })
-            }).catch((error) => {
-                reject(error)
-            })
-        })
-    }
-
-    /**
-     * Disconnects the WebSocket by terminating the connection.
-     */
-    disconnect() {
-        if (this.instance) {
-            this.instance.close()
-            this.instance = null
-        }
-        this.isConnected = false
-    }
-
-    /**
-     * Connects to the WebSocket server.
-     * @private
-     * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
-     */
-    _connect() {
-        return new Promise((resolve, reject) => {
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.isConnected = true
-                this.instance = client;
-                resolve(client)
-            })
-
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
-                reject(error)
-            })
-
-            client.on(WebSocketStateEnum.CLOSE, () => {
-                reject(new Error("Connection closed before receiving message"))
-            })
-        })
-    }
-}
-
-module.exports = WebSocketClient

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/declarations.d.ts

@@ -1,64 +0,0 @@
-/**
- * Represents WebSocket connection data.
- */
-export class WsConnectionData {
-    /**
-     * Constructs a new WsConnectionData instance.
-     * @param hostname - The hostname of the connection.
-     */
-    constructor(hostname: string)
-
-    readonly connectionType: any
-
-    /** The hostname of the connection. */
-    hostname: any
-
-    /**
-     * Serializes the connection data.
-     * @returns An array of connection data values.
-     */
-    serializeConnectionData(): number[]
-
-    /**
-     * Checks equality with another WsConnectionData object.
-     * @param other - The object to compare with.
-     * @returns `true` if equal, otherwise `false`.
-     */
-    equals(other: any): boolean
-}
-
-declare enum RuntimeName {
-    Clr = 0,
-    Go = 1,
-    Jvm = 2,
-    Netcore = 3,
-    Perl = 4,
-    Python = 5,
-    Ruby = 6,
-    Nodejs = 7,
-    Cpp = 8,
-}
-
-interface RuntimeChannel {
-    type: 'inMemory' | 'tcp' | 'webSocket'
-    host?: string
-    port?: number
-}
-
-interface Runtime {
-    name: string
-    customOptions: string
-    modules: string
-    channel: RuntimeChannel
-    runtimeName: RuntimeName
-}
-
-type Runtimes = {
-    [Key in keyof typeof RuntimeName]: Runtime[]
-}
-
-export interface ConfigSource {
-    [key: string]: any
-    licenseKey: string
-    runtimes: Partial<Runtimes>
-}