javonet-nodejs-sdk 2.5.16 → 2.5.18

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 }

package/lib/types.d.ts

@@ -0,0 +1,57 @@
+export interface ConnectionData {
+    readonly connectionType: ConnectionType
+    readonly hostname: string
+    serializeConnectionData(): string
+}
+
+export enum RuntimeName {
+    Clr = 0,
+    Go = 1,
+    Jvm = 2,
+    Netcore = 3,
+    Perl = 4,
+    Python = 5,
+    Ruby = 6,
+    Nodejs = 7,
+    Cpp = 8,
+    Php = 9,
+    Python27 = 10,
+}
+
+export type RuntimeType =
+    | 'clr'
+    | 'go'
+    | 'jvm'
+    | 'netcore'
+    | 'perl'
+    | 'python'
+    | 'ruby'
+    | 'nodejs'
+    | 'cpp'
+    | 'php'
+    | 'python27'
+export type RuntimeChannelType = 'inMemory' | 'tcp' | 'webSocket'
+
+export interface RuntimeChannel {
+    type: RuntimeChannelType
+    host?: string
+    port?: number
+}
+
+export interface Runtime {
+    name: string
+    customOptions: string
+    modules: string
+    channel: RuntimeChannel
+    runtimeName: RuntimeName
+}
+
+export type Runtimes = {
+    [Key in keyof typeof RuntimeType]: Runtime[] | Runtime
+}
+
+export interface ConfigSource {
+    [key: string]: any
+    licenseKey: string
+    runtimes: Partial<Runtimes>
+}

package/lib/utils/Command.js

@@ -1,9 +1,14 @@
+// @ts-check
 import { CommandType } from './CommandType.js'
 
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeName
+ */
+
 export class Command {
     /**
      * Constructs a new Command instance.
-     * @param {number} runtimeName - The runtime name associated with the command.
+     * @param {RuntimeName} 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
@@ -15,27 +20,27 @@ export class Command {
     }
 
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
+     * @returns {Command}
      */
     static createResponse(response, runtimeName) {
         return new Command(runtimeName, CommandType.Value, [response])
     }
 
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
-     * @method
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
+     * @returns {Command}
      */
     static createReference(response, runtimeName) {
         return new Command(runtimeName, CommandType.Reference, [response])
     }
 
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
      * @returns {Command}
-     * @method
      */
     static createArrayResponse(response, runtimeName) {
         return new Command(runtimeName, CommandType.Array, response)

package/lib/utils/CreateRequire.browser.js

@@ -0,0 +1,5 @@
+const createRequire = () => {
+    return new Error('createRequire is not supported in the browser')
+}
+
+export { createRequire }

package/lib/utils/CreateRequire.node.js

@@ -0,0 +1,3 @@
+import { createRequire } from 'module'
+
+export { createRequire }

package/lib/utils/CustomError.js

@@ -1,4 +1,9 @@
+// @ts-check
 export class CustomError extends Error {
+    /**
+     * @param {string} message
+     * @param {string} cause
+     */
     constructor(message, cause) {
         super(`${message}: ${cause}`)
         this.name = 'CustomError'

package/lib/utils/Runtime.js

@@ -1,6 +1,11 @@
-import { createRequire } from 'module'
-import path from 'path'
-import { fileURLToPath, pathToFileURL } from 'url'
+import { createRequire } from './CreateRequire.node.js'
+
+/** @type {import('url').pathToFileURL | null} */
+let pathToFileURL = null
+/** @type {import('url').fileURLToPath | null} */
+let fileURLToPath = null
+/** @type {import('path').path | null} */
+let path = null
 
 /**
  * Validate if the runtime is Node.js
@@ -37,7 +42,7 @@ export function getRuntimeExtension() {
 /**
  * Get the require function
  * @param {string} callerPath - The path to the caller
- * @returns {import('module').createRequire}
+ * @returns {any}
  */
 export const getRequire = (callerPath) => {
     try {
@@ -45,11 +50,9 @@ export const getRequire = (callerPath) => {
             if (typeof require !== 'undefined') {
                 return require
             }
-
             if (callerPath === undefined) {
                 return createRequire(import.meta.url)
             }
-
             const baseUrl = callerPath?.startsWith('file:') ? callerPath : pathToFileURL(callerPath).href
             return createRequire(baseUrl)
         }
@@ -60,6 +63,9 @@ export const getRequire = (callerPath) => {
 }
 
 export const getDirname = () => {
+    if (isBrowserRuntime()) {
+        return new Error('Runtime not supported')
+    }
     // when esm runtime, __dirname is undefined
     if (isEsmRuntime()) {
         const __filename = fileURLToPath(import.meta.url)
@@ -92,3 +98,16 @@ export const getDependency = (dependencyName, callerPathOrUrl) => {
         )
     }
 }
+
+if (isNodejsRuntime()) {
+    const requireDynamic = getRequire(import.meta.url)
+    if (fileURLToPath === null) {
+        fileURLToPath = requireDynamic('url').fileURLToPath
+    }
+    if (path === null) {
+        path = requireDynamic('path')
+    }
+    if (pathToFileURL === null) {
+        pathToFileURL = requireDynamic('url').pathToFileURL
+    }
+}

package/lib/utils/RuntimeLogger.js

@@ -1,6 +1,9 @@
+// @ts-check
 import { getRequire, isNodejsRuntime } from './Runtime.js'
 
+/** @type {any | null} */
 let os = null
+/** @type {any | null} */
 let process = null
 
 const requireDynamic = getRequire(import.meta.url)

package/lib/utils/RuntimeNameHandler.js

@@ -1,9 +1,14 @@
+// @ts-check
 import { RuntimeName } from './RuntimeName.js'
 
+/**
+ * @typedef {import('../types.d.ts').RuntimeType} RuntimeType
+ */
+
 class RuntimeNameHandler {
     /**
      * @param {number} runtimeName
-     * @returns {string}
+     * @returns {RuntimeType}
      */
     static getName(runtimeName) {
         switch (runtimeName) {

package/lib/utils/Type.js

@@ -12,4 +12,5 @@ export const Type = /** @type {const} */ ({
     JAVONET_UNSIGNED_LONG_LONG: 9,
     JAVONET_UNSIGNED_INTEGER: 10,
     JAVONET_NULL: 11,
-})
+    JAVONET_VOID: 12,
+})

package/lib/utils/TypesHandler.js

@@ -0,0 +1,35 @@
+// @ts-check
+/**
+ * TypesHandler class provides utilities for converting between types.
+ */
+class TypesHandler {
+    /**
+     * Converts a JavaScript type to a JType equivalent.
+     * @param {Function} type - The JavaScript type.
+     * @returns {string} The corresponding type name
+     */
+    static convertTypeToJType(type) {
+        switch (type) {
+            case Boolean:
+                return "JType.Boolean"
+            case Number:
+                return "JType.Float"
+            case String:
+                return "JType.String"
+            case Object:
+                return typeof type
+            default:
+                return typeof type
+        }
+    }
+
+    /**
+     * @param {unknown} value
+     * @returns {boolean}
+     */
+    static isPrimitiveOrNullOrUndefined(value) {
+        return value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+    }
+}
+
+export {TypesHandler}

package/lib/utils/UtilsConst.js

@@ -0,0 +1,88 @@
+// @ts-check
+import { getRequire, isNodejsRuntime } from './Runtime.js'
+
+/** @type {any | null} */
+let fs = null
+/** @type {any | null} */
+let path = null
+
+const requireDynamic = getRequire(import.meta.url)
+
+class UtilsConst {
+    /** @type {string} */
+    static _javonetWorkingDirectory = '.'
+    /** @type {string} */
+    static _configSource = ''
+    /** @type {string} */
+    static _licenseKey = ''
+
+    /**
+     * @param {string} inputPath
+     */
+    static setJavonetWorkingDirectory(inputPath) {
+        if (!inputPath) {
+            return
+        }
+        let normalizedPath = inputPath.replace(/\\/g, '/')
+
+        if (!normalizedPath.endsWith('/')) {
+            normalizedPath += '/'
+        }
+        if (isNodejsRuntime()) {
+            if (!fs) {
+                fs = requireDynamic('fs')
+            }
+            if (!fs.existsSync(normalizedPath)) {
+                fs.mkdirSync(normalizedPath, { recursive: true })
+                fs.chmodSync(normalizedPath, 0o700)
+            }
+        }
+        UtilsConst._javonetWorkingDirectory = normalizedPath
+    }
+
+    /**
+     * @returns {string}
+     */
+    static getJavonetWorkingDirectory() {
+        if (isNodejsRuntime() && !UtilsConst._javonetWorkingDirectory) {
+            if (!path) {
+                path = requireDynamic('path')
+            }
+            UtilsConst._javonetWorkingDirectory = path.resolve() + '/'
+        }
+        return UtilsConst._javonetWorkingDirectory
+    }
+
+    /**
+     * @param {string} value
+     */
+    static setConfigSource(value) {
+        UtilsConst._configSource = value
+    }
+
+    /**
+     * @returns {string}
+     */
+    static getConfigSource() {
+        return UtilsConst._configSource
+    }
+
+    /**
+     * @param {string} value
+     */
+    static setLicenseKey(value) {
+        if (!value || value === 'your-license-key') {
+            return
+        }
+        UtilsConst._licenseKey = value
+    }
+
+    /**
+     * @returns {string}
+     */
+    static getLicenseKey() {
+        return UtilsConst._licenseKey
+    }
+}
+
+export { UtilsConst }

package/lib/utils/connectionData/IConnectionData.js

@@ -1,12 +1,26 @@
+// @ts-check
+
+/**
+ * @typedef {import('../ConnectionType.js').ConnectionType} ConnectionType
+ */
 export class IConnectionData {
+    /**
+     * @returns {ConnectionType}
+     */
     get connectionType() {
         throw new Error('You have to implement the method connectionType!')
     }
 
+    /**
+     * @returns {string}
+     */
     get hostname() {
         throw new Error('You have to implement the method hostname!')
     }
 
+    /**
+     * @returns {number[]}
+     */
     serializeConnectionData() {
         throw new Error('You have to implement the method serializeConnectionData!')
     }

package/lib/utils/connectionData/InMemoryConnectionData.js

@@ -1,6 +1,11 @@
+// @ts-check
 import { ConnectionType } from '../ConnectionType.js'
 import { IConnectionData } from './IConnectionData.js'
 
+/**
+ * @typedef {import('../ConnectionType.js').ConnectionType} ConnectionType
+ */
+
 /**
  * @extends IConnectionData
  */
@@ -11,14 +16,24 @@ class InMemoryConnectionData extends IConnectionData {
         this._hostname = ''
     }
 
+    /**
+     * @returns {ConnectionType}
+     */
     get connectionType() {
         return this._connectionType
     }
 
+    /**
+     * @returns {string}
+     */
     get hostname() {
         return this._hostname
     }
 
+    /**
+     * Serializes the connection data.
+     * @returns {number[]} An array of connection data values.
+     */
     serializeConnectionData() {
         return [this.connectionType, 0, 0, 0, 0, 0, 0]
     }