javonet-nodejs-sdk 2.5.8 → 2.5.10

package/dist/lib/utils/RuntimeName.js

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

package/dist/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

package/dist/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

package/{lib → dist/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

package/dist/lib/utils/TypesConverter.js

@@ -0,0 +1,91 @@
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+class ConvertTypeHandler {
+    constructor() {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Object} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        this.validateCommand(command)
+        return TypesConverter.convertJTypeToType(command.payload[0])
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Object} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('ConvertTypeHandler parameters mismatch')
+        }
+    }
+}
+
+/**
+ * TypesConverter class provides utilities for converting between types.
+ */
+class TypesConverter {
+    /**
+     * Converts a JavaScript type to a JType equivalent.
+     * @param {Function} type - The JavaScript type.
+     * @returns {number} The corresponding JType.
+     */
+    static convertTypeToJType(type) {
+        switch (type) {
+            case Boolean:
+                return JType.Boolean
+            case Number:
+                return JType.Float // Assuming Number maps to Float
+            case String:
+                return JType.String
+            case Object:
+                return JType.Null // Assuming Object maps to Null
+            default:
+                return JType.Null
+        }
+    }
+
+    /**
+     * Converts a JType to a JavaScript type equivalent.
+     * @param {number} type - The JType to convert.
+     * @returns {Function} The corresponding JavaScript type.
+     */
+    static convertJTypeToType(type) {
+        switch (type) {
+            case JType.Boolean:
+                return Boolean
+            case JType.Float:
+                return Number
+            case JType.String:
+                return String
+            case JType.Null:
+                return null
+            default:
+                return null
+        }
+    }
+}
+
+/**
+ * Enum for JType mappings.
+ * @readonly
+ * @enum {number}
+ */
+const JType = {
+    Boolean: 1,
+    Float: 2,
+    String: 3,
+    Null: 4,
+}
+
+module.exports = { ConvertTypeHandler, TypesConverter, JType }

package/{lib → dist/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

package/dist/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

package/dist/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

package/dist/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

package/{lib → dist/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])
                 }
             }
         }

package/{Binaries/Nodejs → dist/lib}/utils/exception/ExceptionThrower.js

@@ -1,89 +1,95 @@
-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 stackTraceClasses = ""
-        let stackTraceMethods = ""
-        let stackTraceLines = ""
-        let stackTraceFiles = ""
-
-        switch(commandException.payload.length) {
-            case 8:
-                stackTraceFiles = commandException.payload[7];
-            case 7:
-                stackTraceLines = commandException.payload[6];
-            case 6:
-                stackTraceMethods = commandException.payload[5];
-            case 5:
-                stackTraceClasses = commandException.payload[4];
-            case 4:
-                exceptionMessage =  commandException.payload[3];
-            case 3:
-                exceptionName = commandException.payload[2];
-            case 2:
-                javonetStackCommand = commandException.payload[1];
-            case 1:
-                exceptionType = commandException.payload[0];
-            default:
-                break
-        }
-
-        let error
-        switch (exceptionType) {
-            case ExceptionType.EXCEPTION:
-            case ExceptionType.IO_EXCEPTION:
-            case ExceptionType.FILE_NOT_FOUND_EXCEPTION:
-            case ExceptionType.RUNTIME_EXCEPTION:
-            case ExceptionType.ARITHMETIC_EXCEPTION:
-                error = new Error()
-            case ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION:
-            case ExceptionType.NULL_POINTER_EXCEPTION:
-                error = new TypeError()
-            case ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION:
-                error = new RangeError()
-            default:
-                error = new Error()
-        }
-        error.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
-        error.name = exceptionName
-        error.message = exceptionMessage
-        //error.path = javonetStackCommand
-        return error
-    }
-
-    static serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles) {
-        let stackTraceClassesArray = stackTraceClasses.split('|')
-        let stackTraceMethodsArray = stackTraceMethods.split('|')
-        let stackTraceLinesArray = stackTraceLines.split('|')
-        let stackTraceFilesArray = stackTraceFiles.split('|')
-
-        let stackTrace = "";
-
-        for (let i = 0; i < stackTraceClassesArray.length; i++) {
-            if (stackTraceClassesArray[i] != "") {
-                stackTrace += `    at ${stackTraceClassesArray[i]}`;
-            }
-            if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != "") {
-                stackTrace += `.${stackTraceMethodsArray[i]}`
-            }
-            if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != "") {
-                stackTrace += ` ${stackTraceFilesArray[i]}`
-            }
-            if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != "") {
-                stackTrace += `:${stackTraceLinesArray[i]}`
-            }
-            stackTrace += "\n"
-
-        }
-        return stackTrace
-    }
-}
-module.exports = ExceptionThrower
+/* 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 stackTraceClasses = ''
+        let stackTraceMethods = ''
+        let stackTraceLines = ''
+        let stackTraceFiles = ''
+
+        switch (commandException.payload.length) {
+            case 8:
+                stackTraceFiles = commandException.payload[7]
+            case 7:
+                stackTraceLines = commandException.payload[6]
+            case 6:
+                stackTraceMethods = commandException.payload[5]
+            case 5:
+                stackTraceClasses = commandException.payload[4]
+            case 4:
+                exceptionMessage = commandException.payload[3]
+            case 3:
+                exceptionName = commandException.payload[2]
+            case 2:
+                javonetStackCommand = commandException.payload[1]
+            case 1:
+                exceptionType = commandException.payload[0]
+            default:
+                break
+        }
+
+        let error
+        switch (exceptionType) {
+            case ExceptionType.EXCEPTION:
+            case ExceptionType.IO_EXCEPTION:
+            case ExceptionType.FILE_NOT_FOUND_EXCEPTION:
+            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.name = exceptionName
+        error.message = exceptionMessage
+        //error.path = javonetStackCommand
+        return error
+    }
+
+    static serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles) {
+        let stackTraceClassesArray = stackTraceClasses.split('|')
+        let stackTraceMethodsArray = stackTraceMethods.split('|')
+        let stackTraceLinesArray = stackTraceLines.split('|')
+        let stackTraceFilesArray = stackTraceFiles.split('|')
+
+        let stackTrace = ''
+
+        for (let i = 0; i < stackTraceClassesArray.length; i++) {
+            if (stackTraceClassesArray[i] != '') {
+                stackTrace += `    at ${stackTraceClassesArray[i]}`
+            }
+            if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != '') {
+                stackTrace += `.${stackTraceMethodsArray[i]}`
+            }
+            if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != '') {
+                stackTrace += ` ${stackTraceFilesArray[i]}`
+            }
+            if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != '') {
+                stackTrace += `:${stackTraceLinesArray[i]}`
+            }
+            stackTrace += '\n'
+        }
+        return stackTrace
+    }
+}
+module.exports = ExceptionThrower

package/dist/lib/utils/guid/generateGuid.js

@@ -0,0 +1,9 @@
+function generateGUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0
+        const v = c === 'x' ? r : (r & 0x3) | 0x8
+        return v.toString(16)
+    })
+}
+
+module.exports = generateGUID

package/dist/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

package/dist/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))
+}