javonet-ruby-sdk 2.5.8 → 2.5.9

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{utils → lib/utils}/RuntimeName.js

@@ -1,4 +1,5 @@
-module.exports = {
+// @ts-check
+const RuntimeName = /** @type {const} */ ({
     Clr: 0,
     Go: 1,
     Jvm: 2,
@@ -7,5 +8,7 @@ module.exports = {
     Python: 5,
     Ruby: 6,
     Nodejs: 7,
-    Cpp: 8
-}
+    Cpp: 8,
+})
+
+module.exports = RuntimeName

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/RuntimeNameHandler.js

@@ -0,0 +1,34 @@
+const RuntimeName = require('./RuntimeName')
+
+class RuntimeNameHandler {
+    /**
+     * @param {number} runtimeName
+     * @returns {string}
+     */
+    static getName(runtimeName) {
+        switch (runtimeName) {
+            case RuntimeName.Clr:
+                return 'clr'
+            case RuntimeName.Go:
+                return 'go'
+            case RuntimeName.Jvm:
+                return 'jvm'
+            case RuntimeName.Netcore:
+                return 'netcore'
+            case RuntimeName.Perl:
+                return 'perl'
+            case RuntimeName.Python:
+                return 'python'
+            case RuntimeName.Ruby:
+                return 'ruby'
+            case RuntimeName.Nodejs:
+                return 'nodejs'
+            case RuntimeName.Cpp:
+                return 'cpp'
+            default:
+                throw new Error('Invalid runtime name.')
+        }
+    }
+}
+
+module.exports = RuntimeNameHandler

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/StringEncodingMode.js

@@ -0,0 +1,9 @@
+// @ts-check
+const StringEncodingMode = /** @type {const} */ ({
+    ASCII: 0,
+    UTF8: 1,
+    UTF16: 2,
+    UTF32: 3,
+})
+
+module.exports = StringEncodingMode

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{utils → lib/utils}/Type.js

@@ -1,4 +1,5 @@
-module.exports = {
+// @ts-check
+const Type = /** @type {const} */ ({
     JAVONET_COMMAND: 0,
     JAVONET_STRING: 1,
     JAVONET_INTEGER: 2,
@@ -11,4 +12,6 @@ module.exports = {
     JAVONET_UNSIGNED_LONG_LONG: 9,
     JAVONET_UNSIGNED_INTEGER: 10,
     JAVONET_NULL: 11,
-}
+})
+
+module.exports = Type

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{utils → lib/utils}/connectionData/IConnectionData.js

@@ -1,17 +1,15 @@
-const ConnectionType = require('../../utils/ConnectionType');
-
 class IConnectionData {
     get connectionType() {
-        throw new Error('You have to implement the method connectionType!');
+        throw new Error('You have to implement the method connectionType!')
     }
 
     get hostname() {
-        throw new Error('You have to implement the method hostname!');
+        throw new Error('You have to implement the method hostname!')
     }
 
     serializeConnectionData() {
-        throw new Error('You have to implement the method serializeConnectionData!');
+        throw new Error('You have to implement the method serializeConnectionData!')
     }
 }
 
-module.exports = IConnectionData;
+module.exports = IConnectionData

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/connectionData/InMemoryConnectionData.js

@@ -0,0 +1,35 @@
+const ConnectionType = require('../ConnectionType')
+const IConnectionData = require('./IConnectionData')
+
+/**
+ * @extends IConnectionData
+ */
+class InMemoryConnectionData extends IConnectionData {
+    constructor() {
+        super()
+        this._connectionType = ConnectionType.IN_MEMORY
+        this._hostname = ''
+    }
+
+    get connectionType() {
+        return this._connectionType
+    }
+
+    get hostname() {
+        return this._hostname
+    }
+
+    serializeConnectionData() {
+        return [this.connectionType, 0, 0, 0, 0, 0, 0]
+    }
+
+    /**
+     * @param {InMemoryConnectionData} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return other instanceof InMemoryConnectionData
+    }
+}
+
+module.exports = InMemoryConnectionData

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/connectionData/TcpConnectionData.js

@@ -0,0 +1,77 @@
+const { IConnectionData, ConnectionType } = require('../../..')
+const dns = require('dns')
+
+/**
+ * @extends IConnectionData
+ */
+class TcpConnectionData extends IConnectionData {
+    constructor(hostname, port) {
+        super()
+        this._port = port
+        this._hostname = hostname
+        this._connectionType = ConnectionType.TCP
+        if (hostname === 'localhost') {
+            this.ipAddress = '127.0.0.1'
+        } else {
+            this.ipAddress = this.resolveIpAddress(hostname)
+        }
+    }
+
+    get connectionType() {
+        return this._connectionType
+    }
+
+    get hostname() {
+        return this._hostname
+    }
+
+    /**
+     * @param {TcpConnectionData} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (other instanceof TcpConnectionData) {
+            return this.ipAddress === other.ipAddress && this._port === other._port
+        }
+        return false
+    }
+
+    /**
+     * @param {string} hostname
+     * @returns {string|null}
+     */
+    resolveIpAddress(hostname) {
+        // Check if the input is an IP address
+        const ipPattern = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/
+        if (ipPattern.test(hostname)) {
+            // If it's an IP address, return it directly
+            return hostname
+        } else {
+            // If it's not an IP address, try to resolve it as a hostname
+            return dns.resolve4(hostname, (err, addresses) => {
+                if (err) {
+                    console.error(err)
+                    return null
+                }
+                return addresses[0]
+            })
+        }
+    }
+
+    serializeConnectionData() {
+        let result = [this.connectionType]
+        result = result.concat(this.#getAddressBytes())
+        result = result.concat(this.#getPortBytes())
+        return result
+    }
+
+    #getAddressBytes() {
+        return this.ipAddress.split('.').map(Number)
+    }
+
+    #getPortBytes() {
+        return [this._port & 0xff, this._port >> 8]
+    }
+}
+
+module.exports = TcpConnectionData

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/connectionData/WsConnectionData.js

@@ -0,0 +1,50 @@
+const ConnectionType = require('../ConnectionType')
+const IConnectionData = require('./IConnectionData')
+
+/** @typedef {import('../../declarations').ConnectionType} ConnectionType */
+
+/**
+ * Represents WebSocket connection data.
+ * @extends IConnectionData
+ */
+class WsConnectionData extends IConnectionData {
+    /**
+     * @param {string} hostname - The hostname of the connection.
+     */
+    constructor(hostname) {
+        super()
+        /** @private @type {string} */
+        this._hostname = hostname
+        /** @private @type {ConnectionType} */
+        this._connectionType = ConnectionType.WEB_SOCKET
+    }
+
+    /** @type {ConnectionType} */
+    get connectionType() {
+        return this._connectionType
+    }
+
+    /** @type {string} */
+    get hostname() {
+        return this._hostname
+    }
+
+    /** @type {string} */
+    set hostname(value) {
+        this._hostname = value
+    }
+
+    /**
+     * Serializes the connection data.
+     * @returns {number[]} An array of connection data values.
+     */
+    serializeConnectionData() {
+        return [this.connectionType, 0, 0, 0, 0, 0, 0]
+    }
+
+    equals(other) {
+        return other instanceof WsConnectionData && this._hostname === other.hostname
+    }
+}
+
+module.exports = WsConnectionData

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{utils → lib/utils}/exception/ExceptionSerializer.js

@@ -1,18 +1,11 @@
-const CommandType = require("../CommandType");
-const Command = require("../Command");
-const Runtime = require("../RuntimeName");
-const ExceptionType = require("../ExceptionType");
-
+const CommandType = require('../CommandType')
+const Command = require('../Command')
+const Runtime = require('../RuntimeName')
+const ExceptionType = require('../ExceptionType')
 
 class ExceptionSerializer {
-
-
-    static serializeException(exception, command){
-        let exceptionCommand = new Command(
-            Runtime.Nodejs,
-            CommandType.Exception,
-            []
-        )
+    static serializeException(exception, command) {
+        let exceptionCommand = new Command(Runtime.Nodejs, CommandType.Exception, [])
         exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception))
         exceptionCommand = exceptionCommand.addArgToPayload(command.toString())
         exceptionCommand = exceptionCommand.addArgToPayload(exception.name)
@@ -24,21 +17,21 @@ class ExceptionSerializer {
         let stackFiles = []
 
         this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles)
-        exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join("|"))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join("|"))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join("|"))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join('|'))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join('|'))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join('|'))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join('|'))
 
         return exceptionCommand
     }
 
     static getExceptionCode(exception) {
         switch (exception.name) {
-            case "Error":
+            case 'Error':
                 return ExceptionType.EXCEPTION
-            case "TypeError":
+            case 'TypeError':
                 return ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION
-            case "RangeError":
+            case 'RangeError':
                 return ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION
             default:
                 return ExceptionType.EXCEPTION
@@ -46,22 +39,22 @@ class ExceptionSerializer {
     }
 
     static serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles) {
-        const stackTrace = exception.stack.split('\n').slice(1);
+        const stackTrace = exception.stack.split('\n').slice(1)
 
         for (let i = 0; i < stackTrace.length; i++) {
-            const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/);
+            const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/)
             if (parts) {
-                stackClasses.push(parts[1]);
-                stackMethods.push('unknown');
-                stackLines.push(parts[3]);
-                stackFiles.push(parts[2]);
+                stackClasses.push(parts[1])
+                stackMethods.push('unknown')
+                stackLines.push(parts[3])
+                stackFiles.push(parts[2])
             } else {
-                const parts = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/);
+                const parts = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/)
                 if (parts) {
-                    stackClasses.push('unknown');
-                    stackMethods.push('unknown');
-                    stackLines.push(parts[2]);
-                    stackFiles.push(parts[1]);
+                    stackClasses.push('unknown')
+                    stackMethods.push('unknown')
+                    stackLines.push(parts[2])
+                    stackFiles.push(parts[1])
                 }
             }
         }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{utils → lib/utils}/exception/ExceptionThrower.js

@@ -1,37 +1,36 @@
-const ExceptionType = require("../ExceptionType");
-
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-fallthrough */
+const ExceptionType = require('../ExceptionType')
 
 class ExceptionThrower {
-
     static throwException(commandException) {
-
         let exceptionType = ExceptionType.EXCEPTION
-        let javonetStackCommand = ""
-        let exceptionName = "Node.js exception"
-        let exceptionMessage =  "Node.js exception with empty message"
+        let javonetStackCommand = ''
+        let exceptionName = 'Node.js exception'
+        let exceptionMessage = 'Node.js exception with empty message'
 
-        let stackTraceClasses = ""
-        let stackTraceMethods = ""
-        let stackTraceLines = ""
-        let stackTraceFiles = ""
+        let stackTraceClasses = ''
+        let stackTraceMethods = ''
+        let stackTraceLines = ''
+        let stackTraceFiles = ''
 
-        switch(commandException.payload.length) {
+        switch (commandException.payload.length) {
             case 8:
-                stackTraceFiles = commandException.payload[7];
+                stackTraceFiles = commandException.payload[7]
             case 7:
-                stackTraceLines = commandException.payload[6];
+                stackTraceLines = commandException.payload[6]
             case 6:
-                stackTraceMethods = commandException.payload[5];
+                stackTraceMethods = commandException.payload[5]
             case 5:
-                stackTraceClasses = commandException.payload[4];
+                stackTraceClasses = commandException.payload[4]
             case 4:
-                exceptionMessage =  commandException.payload[3];
+                exceptionMessage = commandException.payload[3]
             case 3:
-                exceptionName = commandException.payload[2];
+                exceptionName = commandException.payload[2]
             case 2:
-                javonetStackCommand = commandException.payload[1];
+                javonetStackCommand = commandException.payload[1]
             case 1:
-                exceptionType = commandException.payload[0];
+                exceptionType = commandException.payload[0]
             default:
                 break
         }
@@ -44,15 +43,23 @@ class ExceptionThrower {
             case ExceptionType.RUNTIME_EXCEPTION:
             case ExceptionType.ARITHMETIC_EXCEPTION:
                 error = new Error()
+                break
             case ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION:
             case ExceptionType.NULL_POINTER_EXCEPTION:
                 error = new TypeError()
+                break
             case ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION:
                 error = new RangeError()
+                break
             default:
                 error = new Error()
         }
-        error.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
+        error.stack = this.serializeStack(
+            stackTraceClasses,
+            stackTraceMethods,
+            stackTraceLines,
+            stackTraceFiles
+        )
         error.name = exceptionName
         error.message = exceptionMessage
         //error.path = javonetStackCommand
@@ -65,25 +72,24 @@ class ExceptionThrower {
         let stackTraceLinesArray = stackTraceLines.split('|')
         let stackTraceFilesArray = stackTraceFiles.split('|')
 
-        let stackTrace = "";
+        let stackTrace = ''
 
         for (let i = 0; i < stackTraceClassesArray.length; i++) {
-            if (stackTraceClassesArray[i] != "") {
-                stackTrace += `    at ${stackTraceClassesArray[i]}`;
+            if (stackTraceClassesArray[i] != '') {
+                stackTrace += `    at ${stackTraceClassesArray[i]}`
             }
-            if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != "") {
+            if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != '') {
                 stackTrace += `.${stackTraceMethodsArray[i]}`
             }
-            if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != "") {
+            if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != '') {
                 stackTrace += ` ${stackTraceFilesArray[i]}`
             }
-            if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != "") {
+            if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != '') {
                 stackTrace += `:${stackTraceLinesArray[i]}`
             }
-            stackTrace += "\n"
-
+            stackTrace += '\n'
         }
         return stackTrace
     }
 }
-module.exports = ExceptionThrower
+module.exports = ExceptionThrower

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/uuid/REGEX.js

@@ -0,0 +1,2 @@
+module.exports =
+    /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/uuid/rng.js

@@ -0,0 +1,12 @@
+const crypto = require('crypto')
+
+const rnds8Pool = new Uint8Array(256) // # of random values to pre-allocate
+let poolPtr = rnds8Pool.length
+
+module.exports = function rng() {
+    if (poolPtr > rnds8Pool.length - 16) {
+        crypto.randomFillSync(rnds8Pool)
+        poolPtr = 0
+    }
+    return rnds8Pool.slice(poolPtr, (poolPtr += 16))
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/uuid/stringify.js

@@ -0,0 +1,51 @@
+const validate = require('./validate')
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = []
+
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).substr(1))
+}
+
+function stringify(arr, offset = 0) {
+    // Note: Be careful editing this code!  It's been tuned for performance
+    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+    const uuid = (
+        byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]
+    ).toLowerCase()
+
+    // Consistency check for valid UUID.  If this throws, it's likely due to one
+    // of the following:
+    // - One or more input array values don't map to a hex octet (leading to
+    // "undefined" in the uuid)
+    // - Invalid input values for the RFC `version` or `variant` fields
+    if (!validate(uuid)) {
+        throw TypeError('Stringified UUID is invalid')
+    }
+
+    return uuid
+}
+
+module.exports = stringify

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/uuid/v4.js

@@ -0,0 +1,27 @@
+const rng = require('./rng.js')
+const stringify = require('./stringify.js')
+
+function v4(options, buf, offset) {
+    options = options || {}
+
+    const rnds = options.random || (options.rng || rng)()
+
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = (rnds[6] & 0x0f) | 0x40
+    rnds[8] = (rnds[8] & 0x3f) | 0x80
+
+    // Copy bytes to buffer, if provided
+    if (buf) {
+        offset = offset || 0
+
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = rnds[i]
+        }
+
+        return buf
+    }
+
+    return stringify(rnds)
+}
+
+module.exports = v4

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/utils/uuid/validate.js

@@ -0,0 +1,6 @@
+const REGEX = require('./REGEX')
+
+function validate(uuid) {
+    return typeof uuid === 'string' && REGEX.test(uuid)
+}
+module.exports = validate