javonet-nodejs-sdk 2.5.17 → 2.5.18

package/lib/sdk/Javonet.js

@@ -1,3 +1,4 @@
+//@ts-check
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js'
 import { RuntimeFactory } from './RuntimeFactory.js'
 import { InMemoryConnectionData } from '../utils/connectionData/InMemoryConnectionData.js'
@@ -7,10 +8,14 @@ import { CommandDeserializer } from '../core/protocol/CommandDeserializer.js'
 import { RuntimeLogger } from '../utils/RuntimeLogger.js'
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js'
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js'
+import { ActivationHelper } from './tools/ActivationHelper.js'
+import { UtilsConst } from '../utils/UtilsConst.js'
+
+/** @typedef {import('../types.d.ts').ConfigSource} ConfigSource */
 
 const requireDynamic = getRequire(import.meta.url)
 
-/** @type {import('../core/transmitter/Transmitter') | null} */
+/** @type {typeof import('../core/transmitter/Transmitter.js').Transmitter | null} */
 let _Transmitter = null
 
 if (isNodejsRuntime()) {
@@ -64,28 +69,28 @@ class Javonet {
     /**
      * Initializes Javonet with a custom configuration file taken from external source.
      * Currentyl supported: Configuration file in JSON format
-     * @param config - Path to a configuration file.
+     * @param {string|ConfigSource} config - Path to a configuration file.
      * @returns {ConfigRuntimeFactory} A ConfigRuntimeFactory instance with configuration data.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
      */
     static withConfig(config) {
-        return new ConfigRuntimeFactory(config, _Transmitter)
+        return new ConfigRuntimeFactory(config)
     }
 
     /**
      * Activates Javonet with the provided license key.
      * @param {string} licenseKey - The license key to activate Javonet.
-     * @returns {number} The activation status code.
+     * @returns {void} The activation status code.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
     static activate(licenseKey) {
-        if (isNodejsRuntime()) {
-            return _Transmitter?.activate(licenseKey)
-        } else {
-            throw new Error('Javonet.activate is allowed only to run in nodejs runtime')
-        }
+        UtilsConst.setLicenseKey(licenseKey)
     }
 
+    /**
+     * Gets the runtime information.
+     * @returns {string} The runtime information.
+     */
     static getRuntimeInfo() {
         if (isNodejsRuntime()) {
             return RuntimeLogger.getRuntimeInfo()
@@ -96,43 +101,20 @@ class Javonet {
 
     /**
      * Sets the configuration source for the Javonet SDK.
-     *
      * @param {string} configSource - The configuration source.
+     * @returns {void}
      */
     static setConfigSource(configSource) {
-        if (isNodejsRuntime()) {
-            return _Transmitter?.setConfigSource(configSource)
-        } else {
-            throw new Error('Javonet.setConfigSource is allowed only to run in nodejs runtime')
-        }
+        UtilsConst.setConfigSource(configSource)
     }
 
     /**
      * Sets the working directory for the Javonet SDK.
-     *
      * @param {string} path - The working directory.
+     * @returns {void}
      */
     static setJavonetWorkingDirectory(path) {
-        try {
-            if (isNodejsRuntime()) {
-                const { mkdirSync } = requireDynamic('fs')
-
-                path = path.replace(/\\/g, '/')
-                if (!path.endsWith('/')) {
-                    path += '/'
-                }
-
-                mkdirSync(path, { recursive: true, mode: 0o700 })
-                _Transmitter?.setJavonetWorkingDirectory(path)
-            } else {
-                throw new Error('Javonet.setJavonetWorkingDirectory is allowed only to run in nodejs runtime')
-            }
-        } catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND') {
-                throw new Error('fs module not found. Please install it using npm install fs')
-            }
-            throw error
-        }
+        UtilsConst.setJavonetWorkingDirectory(path)
     }
 }
 

package/lib/sdk/RuntimeContext.js

@@ -1,4 +1,4 @@
-/* eslint-disable valid-typeof */
+// @ts-check
 import { Command } from '../utils/Command.js'
 import { CommandType } from '../utils/CommandType.js'
 import { InvocationContext, InvocationWsContext } from './InvocationContext.js'
@@ -7,6 +7,20 @@ import { ExceptionThrower } from '../utils/exception/ExceptionThrower.js'
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { Interpreter } from '../core/interpreter/Interpreter.js'
 import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js'
+import { TypesHandler } from '../utils/TypesHandler.js'
+import { UtilsConst } from '../utils/UtilsConst.js'
+import { getRequire } from '../utils/Runtime.js'
+
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ * @typedef {typeof import('../core/transmitter/Transmitter.js').Transmitter} Transmitter
+ */
+
+/** @type {typeof import('../core/transmitter/Transmitter.js').Transmitter | null} */
+let _Transmitter = null
+
+const requireDynamic = getRequire(import.meta.url)
 
 /**
  * Represents a single context which allows interaction with a selected technology.
@@ -20,54 +34,93 @@ import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js
  * @class
  */
 class RuntimeContext {
+    /** @type {Map<string, RuntimeContext>} */
     static memoryRuntimeContexts = new Map()
+    /** @type {Map<string, RuntimeContext>} */
     static networkRuntimeContexts = new Map()
+    /** @type {Map<string, RuntimeContext>} */
     static webSocketRuntimeContexts = new Map()
-    #currentCommand
-    #responseCommand
-    #interpreter
 
+    /** @type {Command | null} */
+    #currentCommand = null
+    /** @type {Command | null} */
+    #responseCommand = null
+    /** @type {Interpreter | null} */
+    #interpreter = null
+
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     */
     constructor(runtimeName, connectionData) {
+        this._isExecuted = false
         this.runtimeName = runtimeName
         this.connectionData = connectionData
-        this.#currentCommand = null
-        this.#responseCommand = null
         this.#interpreter = new Interpreter()
+
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return
+        }
+        if (
+            this.runtimeName === RuntimeName.Nodejs &&
+            this.connectionData.connectionType === ConnectionType.IN_MEMORY
+        ) {
+            return
+        }
+
+        _Transmitter?.setJavonetWorkingDirectory(UtilsConst.getJavonetWorkingDirectory())
+        if (UtilsConst.getConfigSource() !== '') {
+            _Transmitter?.setConfigSource(UtilsConst.getConfigSource())
+        }
+        _Transmitter?.activate(UtilsConst.getLicenseKey())
     }
 
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @returns {RuntimeContext}
+     */
     static getInstance(runtimeName, connectionData) {
+        if (!_Transmitter) {
+            const { Transmitter } = requireDynamic('../core/transmitter/Transmitter.js')
+            _Transmitter = Transmitter
+        }
         switch (connectionData.connectionType) {
             case ConnectionType.IN_MEMORY:
-                if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
-                    let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName]
-                    runtimeCtx.currentCommand = null
+                const key = String(runtimeName)
+                if (RuntimeContext.memoryRuntimeContexts.has(key)) {
+                    const runtimeCtx = RuntimeContext.memoryRuntimeContexts.get(key)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.memoryRuntimeContexts[runtimeName] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.memoryRuntimeContexts.set(key, 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
+                const key1 = String(runtimeName) + JSON.stringify(connectionData)
+                if (RuntimeContext.networkRuntimeContexts.has(key1)) {
+                    const runtimeCtx = RuntimeContext.networkRuntimeContexts.get(key1)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.networkRuntimeContexts[key1] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.networkRuntimeContexts.set(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
+                const key2 = String(runtimeName) + JSON.stringify(connectionData)
+                if (RuntimeContext.webSocketRuntimeContexts.has(key2)) {
+                    const runtimeCtx = RuntimeContext.webSocketRuntimeContexts.get(key2)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.webSocketRuntimeContexts.set(key2, runtimeCtx)
                     return runtimeCtx
                 }
             }
@@ -86,12 +139,13 @@ class RuntimeContext {
      * @method
      */
     execute() {
-        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData)
+        // @ts-expect-error
+        this.#responseCommand = this.#interpreter?.execute(this.#currentCommand, this.connectionData)
         this.#currentCommand = null
         if (this.#responseCommand === undefined) {
             throw new Error('responseCommand is undefined in Runtime Context execute method')
         }
-        if (this.#responseCommand.commandType === CommandType.Exception) {
+        if (this.#responseCommand?.commandType === CommandType.Exception) {
             throw ExceptionThrower.throwException(this.#responseCommand)
         }
     }
@@ -124,6 +178,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.GetType, [typeName, ...args])
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -146,6 +201,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.Cast, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -168,6 +224,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.GetEnumItem, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -190,6 +247,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.AsRef, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -212,6 +270,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.AsOut, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -238,6 +297,7 @@ class RuntimeContext {
         ])
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -247,22 +307,35 @@ class RuntimeContext {
         return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
     }
 
-    #buildCommand = function (command) {
+    /**
+     * @param {Command} command
+     * @returns {Command}
+     */
+    #buildCommand(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) {
+    /**
+     * @param {unknown} payloadItem
+     * @returns {Command}
+     */
+    #encapsulatePayloadItem(payloadItem) {
         if (payloadItem instanceof Command) {
             for (let i = 0; i < payloadItem.payload.length; i++) {
                 payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i])
             }
             return payloadItem
         } else if (payloadItem instanceof InvocationContext) {
-            return payloadItem.get_current_command()
+            const command = payloadItem?.get_current_command()
+            if (!command) {
+                throw new Error('Command not found')
+            }
+            return command
         } else if (payloadItem instanceof Array) {
+            /** @type {Command[]} */
             const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item))
             return new Command(this.runtimeName, CommandType.Array, copiedArray)
         } else if (typeof payloadItem === 'function') {
@@ -274,8 +347,15 @@ class RuntimeContext {
                 ...newArray
             )
             return new Command(this.runtimeName, CommandType.PassDelegate, args)
-        } else {
+        } else if (TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
             return new Command(this.runtimeName, CommandType.Value, [payloadItem])
+        } else {
+            throw Error(
+                'Unsupported payload item type: ' +
+                    (payloadItem?.constructor?.name || typeof payloadItem) +
+                    ' for payload item: ' +
+                    payloadItem
+            )
         }
     }
 

package/lib/sdk/RuntimeFactory.js

@@ -1,12 +1,19 @@
+//@ts-check
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { RuntimeContext } from './RuntimeContext.js'
 
+/**
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 /**
  * 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)
  */
 export class RuntimeFactory {
+    /**
+     * @param {IConnectionData} connectionData 
+     */
     constructor(connectionData) {
         this.connectionData = connectionData
     }

package/lib/sdk/tools/ActivationHelper.js

@@ -0,0 +1,51 @@
+// @ts-check
+import { isBrowserRuntime } from '../../utils/Runtime.js'
+
+class ActivationHelper {
+    /** @type {string} */
+    static temporaryLicenseKey = 'License key not set'
+
+    /**
+     * @param {string} value
+     */
+    static setTemporaryLicenseKey(value) {
+        if (!value || value === 'your-license-key') {
+            return
+        }
+        // TODO: Uncomment this when we have a way to send messages to App Insights
+        // if (ActivationHelper.temporaryLicenseKey !== value) {
+        //   SdkMessageHelper.sendExceptionToAppInsights('SdkMessage', 'Activation');
+        // }
+        ActivationHelper.temporaryLicenseKey = value
+    }
+
+    /**
+     * @returns {string}
+     */
+    static getTemporaryLicenseKey() {
+        return ActivationHelper.temporaryLicenseKey
+    }
+
+    /**
+     * @returns {Promise<string>}
+     */
+    static async getLicenseKey() {
+        try {
+            return ActivationHelper._getLicenseKeyFromFile()
+        } catch {
+            return ActivationHelper.temporaryLicenseKey
+        }
+    }
+
+    /**
+     * @returns {string}
+     */
+    static _getLicenseKeyFromFile() {
+        if (!isBrowserRuntime()) {
+            throw new Error('ActivationHelper is not supported in the browser runtime.')
+        }
+        return ""
+    }
+}
+
+export { ActivationHelper }

package/lib/sdk/tools/JsonResolver.js

@@ -0,0 +1,226 @@
+//@ts-check
+import { isNodejsRuntime, getRequire } from '../../utils/Runtime.js'
+
+/**
+ * @typedef {import('../../types.d.ts').RuntimeChannelType} RuntimeChannelType
+ * @typedef {import('../../types.d.ts').ConfigSource} ConfigSource
+ * @typedef {import('../../types.d.ts').RuntimeChannel} RuntimeChannel
+ * @typedef {import('../../types.d.ts').Runtime} Runtime
+ * @typedef {import('../../types.d.ts').Runtimes} Runtimes
+ * @typedef {import('../../types.d.ts').RuntimeType} RuntimeType
+ */
+
+/**
+ * @param {any} param
+ * @returns {boolean}
+ */
+function isValidObject(param) {
+    return typeof param === 'object' && param !== null && !Array.isArray(param)
+}
+
+/**
+ * @param {string | ConfigSource} param
+ * @returns {boolean}
+ */
+function isValidJson(param) {
+    try {
+        if (typeof param === 'string') {
+            const parsed = JSON.parse(param)
+            return typeof parsed === 'object' && parsed !== null
+        }
+        return false
+    } catch (e) {
+        return false
+    }
+}
+
+const requireDynamic = getRequire(import.meta.url)
+
+/** @type {any | null} */
+let fs = null
+
+class JsonResolver {
+    /** @type {ConfigSource} */
+    jsonObject
+    /** @type {string | ConfigSource} */
+    configSource
+
+    /**
+     * @param {string | ConfigSource} configSource
+     */
+    constructor(configSource) {
+        this.configSource = JSON.stringify(configSource)
+        this.jsonObject = this._getJsonObject(configSource)
+    }
+
+    /**
+     * @returns {Partial<Runtimes>}
+     */
+    get runtimes() {
+        return this.jsonObject?.runtimes || {}
+    }
+
+    /**
+     * @returns {string}
+     */
+    get licenseKey() {
+        return this.jsonObject?.licenseKey || 'your-license-key'
+    }
+
+    /**
+     * @returns {string}
+     */
+    get workingDirectory() {
+        return this.jsonObject?.workingDirectory || ''
+    }
+
+    /**
+     * @returns {string}
+     */
+    getLicenseKey() {
+        if (!this.licenseKey) {
+            throw new Error('License key not found in configuration source. Check your configuration source.')
+        }
+        return this.licenseKey
+    }
+
+    /**
+     * @returns {string}
+     */
+    getWorkingDirectory() {
+        return this.workingDirectory
+    }
+
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {RuntimeChannelType}
+     */
+    getChannelType(runtimeName, configName) {
+        const channel = this._getChannel(runtimeName, configName)
+        return channel.type
+    }
+
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    getChannelHost(runtimeName, configName) {
+        const channel = this._getChannel(runtimeName, configName)
+        if (channel.host === undefined) {
+            throw new Error(`Host not found for channel in runtime ${runtimeName}, config ${configName}`)
+        }
+        return channel.host
+    }
+
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {number|string}
+     */
+    getChannelPort(runtimeName, configName) {
+        const channel = this._getChannel(runtimeName, configName)
+        if (channel.port === undefined) {
+            throw new Error(`Port not found for channel in runtime ${runtimeName}, config ${configName}`)
+        }
+        return channel.port
+    }
+
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    getModules(runtimeName, configName) {
+        const runtime = this._getRuntime(runtimeName, configName)
+        return runtime.modules || ''
+    }
+
+    /**
+     * @private
+     * @param {string | ConfigSource} configSource
+     * @returns {ConfigSource}
+     */
+    _getJsonObject(configSource) {
+        if (isValidObject(configSource)) {
+            return /** @type {ConfigSource} */ (configSource)
+        }
+        if (typeof configSource === 'string' && isValidJson(configSource)) {
+            const parsedJson = JSON.parse(configSource)
+            if (isValidObject(parsedJson)) {
+                return parsedJson
+            }
+        }
+        if (isNodejsRuntime()) {
+            if (!fs) {
+                fs = requireDynamic('fs')
+            }
+            if (fs?.existsSync(configSource)) {
+                const jsonText = fs.readFileSync(configSource, 'utf8')
+                if (isValidJson(jsonText)) {
+                    const parsedFromFile = JSON.parse(jsonText)
+                    if (isValidObject(parsedFromFile)) {
+                        return parsedFromFile
+                    }
+                }
+            }
+        }
+
+        throw new Error(
+            `Configuration source is not valid. Check your configuration:${String(this.configSource)}`
+        )
+    }
+
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {Runtime}
+     */
+    _getRuntime(runtimeName, configName) {
+        const runtimeList = this.runtimes[runtimeName]
+
+        if (Array.isArray(runtimeList)) {
+            const runtime = runtimeList.find((item) => item.name === configName)
+            if (runtime) {
+                return runtime
+            }
+        } else if (typeof runtimeList?.name === 'string' && runtimeList?.name === configName) {
+            return runtimeList
+        }
+
+        throw new Error(
+            `Runtime config '${configName}' not found in configuration source for runtime '${runtimeName}'. Check your configuration source.`
+        )
+    }
+
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    _getRuntimeName(runtimeName, configName) {
+        const runtime = this._getRuntime(runtimeName, configName)
+        return runtime.name
+    }
+
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {RuntimeChannel}
+     */
+    _getChannel(runtimeName, configName) {
+        const runtime = this._getRuntime(runtimeName, configName)
+        if (!runtime.channel) {
+            throw new Error(
+                `Channel not found for runtime config '${configName}' and runtime '${runtimeName}'. Check your configuration source.`
+            )
+        }
+        return runtime.channel
+    }
+}
+
+export { JsonResolver }