javonet-nodejs-sdk 2.5.8 → 2.5.10

package/dist/lib/sdk/RuntimeContext.js

@@ -0,0 +1,275 @@
+/* eslint-disable valid-typeof */
+const Interpreter = require('../core/interpreter/Interpreter')
+const Command = require('../utils/Command')
+const CommandType = require('../utils/CommandType')
+const { InvocationContext, InvocationWsContext } = require('./InvocationContext')
+const ConnectionType = require('../utils/ConnectionType')
+const ExceptionThrower = require('../utils/exception/ExceptionThrower')
+const DelegatesCache = require('../core/delegatesCache/DelegatesCache')
+const RuntimeName = require('../utils/RuntimeName')
+
+/**
+ * Represents a single context which allows interaction with a selected technology.
+ * Refers to a single instance of the called runtime within a particular target OS process.
+ * This can be either the local currently running process (inMemory) or a particular remote process identified by the IP Address and PORT of the target Javonet instance.
+ * Multiple Runtime Contexts can be initialized within one process.
+ * Calling the same technology on inMemory communication channel will return the existing instance of runtime context.
+ * Calling the same technology on TCP channel but on different nodes will result in unique Runtime Contexts.
+ * Within the runtime context, any number of libraries can be loaded and any objects from the target technology can be interacted with, as they are aware of each other due to sharing the same memory space and same runtime instance.
+ * @see [Javonet Guides]{@link https://www.javonet.com/guides/v2/javascript/foundations/runtime-context}
+ * @class
+ */
+class RuntimeContext {
+    static memoryRuntimeContexts = new Map()
+    static networkRuntimeContexts = new Map()
+    static webSocketRuntimeContexts = new Map()
+    #currentCommand
+    #responseCommand
+    #interpreter
+    // eslint-disable-next-line no-unused-private-class-members
+    #generatorHandler
+
+    constructor(runtimeName, connectionData) {
+        this.runtimeName = runtimeName
+        this.connectionData = connectionData
+        this.#currentCommand = null
+        this.#responseCommand = null
+        this.#interpreter = new Interpreter()
+        this.#generatorHandler = RuntimeContext.getGeneratorHandler()
+    }
+
+    static getGeneratorHandler() {
+        try {
+            const GeneratorHandler = require(require.resolve('../core/generator/handler/GeneratorHandler'))
+            if (GeneratorHandler) {
+                return new GeneratorHandler()
+            }
+            // eslint-disable-next-line no-unused-vars
+        } catch (error) {
+            // TODO: handle evnvs switch
+        }
+    }
+
+    static getInstance(runtimeName, connectionData) {
+        switch (connectionData.connectionType) {
+            case ConnectionType.IN_MEMORY:
+                if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
+                    let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName]
+                    runtimeCtx.currentCommand = null
+                    return runtimeCtx
+                } else {
+                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.memoryRuntimeContexts[runtimeName] = runtimeCtx
+                    return runtimeCtx
+                }
+            case ConnectionType.TCP: {
+                let key1 = runtimeName + JSON.stringify(connectionData)
+                if (key1 in RuntimeContext.networkRuntimeContexts) {
+                    let runtimeCtx = RuntimeContext.networkRuntimeContexts[key1]
+                    runtimeCtx.currentCommand = null
+                    return runtimeCtx
+                } else {
+                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.networkRuntimeContexts[key1] = runtimeCtx
+                    return runtimeCtx
+                }
+            }
+            case ConnectionType.WEB_SOCKET: {
+                let key2 = runtimeName + JSON.stringify(connectionData)
+                if (key2 in RuntimeContext.webSocketRuntimeContexts) {
+                    let runtimeCtx = RuntimeContext.webSocketRuntimeContexts[key2]
+                    runtimeCtx.currentCommand = null
+                    return runtimeCtx
+                } else {
+                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx
+                    return runtimeCtx
+                }
+            }
+            default:
+                throw new Error('Invalid connection type')
+        }
+    }
+
+    /**
+     * Executes the current command. The initial state of RuntimeContext is non-materialized,
+     * wrapping either a single command or a chain of recursively nested commands.
+     * Commands become nested through each invocation of methods on RuntimeContext.
+     * Each invocation triggers the creation of a new RuntimeContext instance wrapping the current command with a new parent command.
+     * The developer can decide at any moment of the materialization for the context, taking full control of the chunks of the expression being transferred and processed on the target runtime.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @method
+     */
+    execute() {
+        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData)
+        this.#currentCommand = null
+        if (this.#responseCommand.commandType === CommandType.Exception) {
+            throw ExceptionThrower.throwException(this.#responseCommand)
+        }
+    }
+
+    /**
+     * Adds a reference to a library. Javonet allows you to reference and use modules or packages written in various languages.
+     * This method allows you to use any library from all supported technologies. The necessary libraries need to be referenced.
+     * The argument is a relative or full path to the library. If the library has dependencies on other libraries, the latter needs to be added first.
+     * After referencing the library, any objects stored in this package can be used. Use static classes, create instances, call methods, use fields and properties, and much more.
+     * @param {string} libraryPath - The relative or full path to the library.
+     * @returns {RuntimeContext} RuntimeContext instance.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
+     * @method
+     */
+    loadLibrary(libraryPath) {
+        let localCommand = new Command(this.runtimeName, CommandType.LoadLibrary, [libraryPath])
+        this.#currentCommand = this.#buildCommand(localCommand)
+        this.execute()
+        return this
+    }
+
+    /**
+     * Retrieves a reference to a specific type. The type can be a class, interface or enum. The type can be retrieved from any referenced library.
+     * @param {string} typeName - The full name of the type.
+     * @param {...any} args - The arguments to be passed, if needed
+     * @returns {InvocationContext} InvocationContext instance, that wraps the command to get the type.
+     * @method
+     */
+    getType(typeName, ...args) {
+        let localCommand = new Command(this.runtimeName, CommandType.GetType, [typeName, ...args])
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
+    /**
+     * Casts the provided value to a specific type. This method is used when invoking methods that require specific types of arguments.
+     * The arguments include the target type and the value to be cast. The target type must be retrieved from the called runtime using the getType method.
+     * After casting the value, it can be used as an argument when invoking methods.
+     * @param {...any} args - The target type and the value to be cast.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to cast the value.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/casting/casting)
+     * @method
+     */
+    cast(...args) {
+        let localCommand = new Command(this.runtimeName, CommandType.Cast, args)
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
+    /**
+     * Retrieves a specific item from an enum type. This method is used when working with enums from the called runtime.
+     * The arguments include the enum type and the name of the item. The enum type must be retrieved from the called runtime using the getType method.
+     * After retrieving the item, it can be used as an argument when invoking methods or for other operations.
+     * @param {...any} args - The enum type and the name of the item.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to get the enum item.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
+     * @method
+     */
+    getEnumItem(...args) {
+        let localCommand = new Command(this.runtimeName, CommandType.GetEnumItem, args)
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
+    /**
+     * Creates a reference type argument that can be passed to a method with a ref parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
+     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
+     * After creating the reference, it can be used as an argument when invoking methods.
+     * @param {...any} args - The value and optionally the type of the reference.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as ref.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-ref-keyword)
+     * @method
+     */
+    asRef(...args) {
+        let localCommand = new Command(this.runtimeName, CommandType.AsRef, args)
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
+    /**
+     * Creates a reference type argument that can be passed to a method with an out parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
+     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
+     * After creating the reference, it can be used as an argument when invoking methods.
+     * @param {...any} args - The value and optionally the type of the reference.
+     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
+     * @method
+     */
+    asOut(...args) {
+        let localCommand = new Command(this.runtimeName, CommandType.AsOut, args)
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
+    #buildCommand = function (command) {
+        for (let i = 0; i < command.payload.length; i++) {
+            command.payload[i] = this.#encapsulatePayloadItem(command.payload[i])
+        }
+        return command.prependArgToPayload(this.#currentCommand)
+    }
+
+    #encapsulatePayloadItem = function (payloadItem) {
+        if (typeof payloadItem === 'Command' || payloadItem instanceof Command) {
+            for (let i = 0; i < payloadItem.payload.length; i++) {
+                payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i])
+            }
+            return payloadItem
+        } else if (typeof payloadItem === 'InvocationContext' || payloadItem instanceof InvocationContext) {
+            return payloadItem.get_current_command()
+        } else if (payloadItem instanceof Array) {
+            for (let i = 0; i < payloadItem.length; i++) {
+                payloadItem[i] = this.#encapsulatePayloadItem(payloadItem[i])
+            }
+            return new Command(this.runtimeName, CommandType.Array, payloadItem)
+        } else if (typeof payloadItem === 'function') {
+            let newArray = new Array(payloadItem.length + 1)
+            for (let i = 0; i < newArray.length; i++) {
+                newArray[i] = 'object'
+            }
+            const args = [DelegatesCache.addDelegate(payloadItem), RuntimeName.Nodejs].push(...newArray);
+            return new Command(this.runtimeName, CommandType.PassDelegate, args)
+        } else {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
+        }
+    }
+
+    healthCheck() {
+        let localCommand = new Command(this.runtimeName, CommandType.Value, ['health_check'])
+        this.#currentCommand = this.#buildCommand(localCommand)
+        this.execute()
+    }
+}
+
+module.exports = RuntimeContext

package/dist/lib/sdk/RuntimeFactory.js

@@ -0,0 +1,78 @@
+const Runtime = require('../utils/RuntimeName')
+const RuntimeContext = require('./RuntimeContext')
+
+/**
+ * The RuntimeFactory class provides methods for creating runtime contexts.
+ * Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
+ * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+ */
+class RuntimeFactory {
+    constructor(connectionData) {
+        this.connectionData = connectionData
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the .NET Framework runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the .NET Framework runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    clr() {
+        return RuntimeContext.getInstance(Runtime.Clr, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the JVM runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the JVM runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    jvm() {
+        return RuntimeContext.getInstance(Runtime.Jvm, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the .NET runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the .NET runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    netcore() {
+        return RuntimeContext.getInstance(Runtime.Netcore, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Perl runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the Perl runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    perl() {
+        return RuntimeContext.getInstance(Runtime.Perl, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Python runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    python() {
+        return RuntimeContext.getInstance(Runtime.Python, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Ruby runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the Ruby runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    ruby() {
+        return RuntimeContext.getInstance(Runtime.Ruby, this.connectionData)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with Node.js runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the Node.js runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    nodejs() {
+        return RuntimeContext.getInstance(Runtime.Nodejs, this.connectionData)
+    }
+}
+
+module.exports = RuntimeFactory

package/dist/lib/sdk/tools/JsonFileResolver.js

@@ -0,0 +1,101 @@
+const fs = require('fs')
+
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+class JsonFileResolver {
+    constructor(path) {
+        this.path = path
+        try {
+            const data = fs.readFileSync(this.path, 'utf8')
+            this.jsonObject = JSON.parse(data)
+            // eslint-disable-next-line no-unused-vars
+        } catch (err) {
+            throw new Error(
+                `Configuration file ${this.path} not found. Please check your configuration file.`
+            )
+        }
+    }
+    getLicenseKey() {
+        if (!hasOwnProperty(this.jsonObject, 'licenseKey')) {
+            throw new Error(
+                'License key not found in configuration file. Please check your configuration file.'
+            )
+        }
+        return this.jsonObject.licenseKey
+    }
+
+    getRuntimes() {
+        return this.jsonObject.runtimes
+    }
+
+    getRuntime(runtimeName, configName) {
+        const runtimes = this.getRuntimes()
+        if (hasOwnProperty(runtimes, runtimeName)) {
+            const runtime = runtimes[runtimeName]
+            if (Array.isArray(runtime)) {
+                for (let item of runtime) {
+                    if (item.name === configName) {
+                        return item
+                    }
+                }
+            } else if (runtime.name === configName) {
+                return runtime
+            }
+        }
+        throw new Error(
+            `Runtime config ${configName} not found in configuration file for runtime ${runtimeName}. Please check your configuration file.`
+        )
+    }
+
+    getChannel(runtimeName, configName) {
+        const runtime = this.getRuntime(runtimeName, configName)
+        if (!hasOwnProperty(runtime, 'channel')) {
+            throw new Error(
+                `Channel key not found in configuration file for config ${configName}. Please check your configuration file.`
+            )
+        }
+        return runtime.channel
+    }
+
+    getChannelType(runtimeName, configName) {
+        const channel = this.getChannel(runtimeName, configName)
+        if (!hasOwnProperty(channel, 'type')) {
+            throw new Error(
+                `Channel type not found in configuration file for config ${configName}. Please check your configuration file.`
+            )
+        }
+        return channel.type
+    }
+
+    getChannelHost(runtimeName, configName) {
+        const channel = this.getChannel(runtimeName, configName)
+        if (!hasOwnProperty(channel, 'host')) {
+            throw new Error(
+                `Channel host not found in configuration file for config ${configName}. Please check your configuration file.`
+            )
+        }
+        return channel.host
+    }
+
+    getChannelPort(runtimeName, configName) {
+        const channel = this.getChannel(runtimeName, configName)
+        if (!hasOwnProperty(channel, 'port')) {
+            throw new Error(
+                `Channel port not found in configuration file for config ${configName}. Please check your configuration file.`
+            )
+        }
+        return channel.port
+    }
+
+    getModules(runtimeName, configName) {
+        const runtime = this.getRuntime(runtimeName, configName)
+        if (hasOwnProperty(runtime, 'modules')) {
+            return runtime.modules
+        }
+        return ''
+    }
+}
+
+module.exports = JsonFileResolver

package/dist/lib/sdk/tools/SdkExceptionHelper.js

@@ -0,0 +1,79 @@
+const https = require('https')
+const os = require('os')
+// const packageJson = require('../../../package.json')
+
+const address = 'https://dc.services.visualstudio.com/v2/track'
+
+/**
+ *
+ * @param {any} e
+ * @param {string} licenseKey
+ */
+function sendExceptionToAppInsights(e, licenseKey) {
+    return new Promise((resolve, reject) => {
+        try {
+            const instrumentationKey = '2c751560-90c8-40e9-b5dd-534566514723'
+            // const javonetVersion = packageJson.version ? packageJson.version : '2.0.0'
+            const javonetVersion = '2.0.0'
+            const nodeName = os.hostname()
+            const operationName = 'JavonetSdkException'
+            const osName = os.platform()
+            const callingRuntimeName = 'Nodejs'
+            const eventMessage = e.message
+
+            const nowGMT = new Date().toISOString()
+            const jsonPayload = JSON.stringify({
+                name: 'AppEvents',
+                time: nowGMT,
+                iKey: instrumentationKey,
+                tags: {
+                    'ai.application.ver': javonetVersion,
+                    'ai.cloud.roleInstance': nodeName,
+                    'ai.operation.id': '0',
+                    'ai.operation.parentId': '0',
+                    'ai.operation.name': operationName,
+                    'ai.internal.sdkVersion': 'javonet:' + javonetVersion,
+                    'ai.internal.nodeName': nodeName,
+                },
+                data: {
+                    baseType: 'EventData',
+                    baseData: {
+                        ver: 2,
+                        name: eventMessage,
+                        properties: {
+                            OperatingSystem: osName,
+                            LicenseKey: licenseKey,
+                            CallingTechnology: callingRuntimeName,
+                        },
+                    },
+                },
+            })
+
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': jsonPayload.length,
+                },
+            }
+
+            const req = https.request(address, options, (res) => {
+                console.log('POST Response Code ::', res.statusCode)
+                resolve(res.statusCode)
+            })
+
+            req.on('error', (error) => {
+                console.error(error)
+                reject(error)
+            })
+
+            req.write(jsonPayload)
+            req.end()
+        } catch (error) {
+            console.error(error)
+            reject(error)
+        }
+    })
+}
+
+module.exports = sendExceptionToAppInsights

package/dist/lib/utils/Command.js

@@ -0,0 +1,69 @@
+const CommandType = require('./CommandType')
+
+class Command {
+    /**
+     * Constructs a new Command instance.
+     * @param {number} runtimeName - The runtime name associated with the command.
+     * @param {number} commandType - The type of the command.
+     * @param {any} [payload] - The optional payload of the command.
+     * @method
+     */
+    constructor(runtimeName, commandType, payload = []) {
+        this.runtimeName = runtimeName
+        this.commandType = commandType
+        this.payload = payload
+    }
+
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     */
+    static createResponse(response, runtimeName) {
+        return new Command(runtimeName, CommandType.Value, [response])
+    }
+
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     * @method
+     */
+    static createReference(response, runtimeName) {
+        return new Command(runtimeName, CommandType.Reference, [response])
+    }
+
+    /**
+     * @param {any} [response]
+     * @param {number} runtimeName
+     * @returns {Command}
+     * @method
+     */
+    static createArrayResponse(response, runtimeName) {
+        return new Command(runtimeName, CommandType.Array, response)
+    }
+
+    dropFirstPayloadArg() {
+        return new Command(this.runtimeName, this.commandType, this.payload.slice(1))
+    }
+
+    /**
+     * @param {any} arg
+     * @returns {Command}
+     */
+    addArgToPayload(arg) {
+        return new Command(this.runtimeName, this.commandType, this.payload.concat(arg))
+    }
+
+    /**
+     * @param {Command|null} current_command
+     * @returns {Command}
+     */
+    prependArgToPayload(current_command) {
+        if (current_command == null) {
+            return new Command(this.runtimeName, this.commandType, this.payload)
+        } else {
+            return new Command(this.runtimeName, this.commandType, [current_command].concat(this.payload))
+        }
+    }
+}
+
+module.exports = Command

package/{lib → dist/lib}/utils/CommandType.js

@@ -1,4 +1,5 @@
-module.exports = {
+// @ts-check
+const CommandType = /** @type {const} */ ({
     Value: 0,
     LoadLibrary: 1,
     InvokeStaticMethod: 2,
@@ -36,4 +37,12 @@ module.exports = {
     EnableNamespace: 34,
     EnableType: 35,
     CreateNull: 36,
-}
+    GetStaticMethodAsDelegate: 37,
+    GetInstanceMethodAsDelegate: 38,
+    PassDelegate: 39,
+    InvokeDelegate: 40,
+    ConvertType: 41,
+    InvokeStandaloneMethod: 42,
+})
+
+module.exports = CommandType

package/dist/lib/utils/ConnectionType.js

@@ -0,0 +1,8 @@
+// @ts-check
+const ConnectionType = /** @type {const} */ ({
+    IN_MEMORY: 0,
+    TCP: 1,
+    WEB_SOCKET: 2,
+})
+
+module.exports = ConnectionType

package/{lib → dist/lib}/utils/ExceptionType.js

@@ -1,4 +1,5 @@
-module.exports = {
+// @ts-check
+const ExceptionType = /** @type {const} */ ({
     EXCEPTION: 0,
     IO_EXCEPTION: 1,
     FILE_NOT_FOUND_EXCEPTION: 2,
@@ -6,5 +7,7 @@ module.exports = {
     ARITHMETIC_EXCEPTION: 4,
     ILLEGAL_ARGUMENT_EXCEPTION: 5,
     INDEX_OUT_OF_BOUNDS_EXCEPTION: 6,
-    NULL_POINTER_EXCEPTION: 7
-}
+    NULL_POINTER_EXCEPTION: 7,
+})
+
+module.exports = ExceptionType

package/dist/lib/utils/RuntimeLogger.js

@@ -0,0 +1,30 @@
+const os = require('os')
+const process = require('process')
+
+class RuntimeLogger {
+    static notLoggedYet = true
+
+    static getRuntimeInfo() {
+        try {
+            return (
+                `JavaScript Managed Runtime Info:\n` +
+                `Node.js Version: ${process.version}\n` +
+                `OS Version: ${os.type()} ${os.release()}\n` +
+                `Process Architecture: ${os.arch()}\n` +
+                `Current Directory: ${process.cwd()}\n`
+            )
+            // eslint-disable-next-line no-unused-vars
+        } catch (e) {
+            return 'JavaScript Managed Runtime Info: Error while fetching runtime info'
+        }
+    }
+
+    static printRuntimeInfo() {
+        if (this.notLoggedYet) {
+            console.log(this.getRuntimeInfo())
+            this.notLoggedYet = false
+        }
+    }
+}
+
+module.exports = RuntimeLogger