javonet-nodejs-sdk 2.6.7 → 2.6.9

package/lib/sdk/RuntimeContext.js

@@ -144,11 +144,12 @@ class 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)
+     * @returns {Promise<void>}
      * @method
      */
-    execute() {
+    async execute() {
         // @ts-expect-error
-        this.#responseCommand = this.#interpreter?.execute(this.#currentCommand, this.connectionData)
+        this.#responseCommand = await 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')
@@ -164,14 +165,14 @@ class RuntimeContext {
      * 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.
+     * @returns {Promise<RuntimeContext>} RuntimeContext instance.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
      * @method
      */
-    loadLibrary(libraryPath) {
+    async loadLibrary(libraryPath) {
         let localCommand = new Command(this.runtimeName, CommandType.LoadLibrary, [libraryPath])
         this.#currentCommand = this.#buildCommand(localCommand)
-        this.execute()
+        await this.execute()
         return this
     }
 
@@ -316,9 +317,8 @@ class RuntimeContext {
             for (let i = 0; i < newArray.length; i++) {
                 newArray[i] = 'object'
             }
-            const args = [delegatesCacheInstance.addDelegate(payloadItem), RuntimeName.Nodejs].push(
-                ...newArray
-            )
+            const args = [delegatesCacheInstance.addDelegate(payloadItem), RuntimeName.Nodejs]
+            args.push(...newArray)
             return new Command(this.runtimeName, CommandType.PassDelegate, args)
         } else if (TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
             return new Command(this.runtimeName, CommandType.Value, [payloadItem])

package/lib/sdk/configuration/ConfigSourceResolver.js

@@ -1,20 +1,36 @@
-// lib/sdk/configuration/ConfigSourceResolver.js
-// lib/sdk/configuration/ConfigSourceResolver.js
-import fs from 'fs'
-import process from 'process'
+// @ts-check
 
 import { ConfigsDictionary } from './ConfigsDictionary.js'
 import { JsonConfigResolver } from './configResolvers/JsonConfigResolver.js'
 import { YamlConfigResolver } from './configResolvers/YamlConfigResolver.js'
 import { ConnectionStringConfigResolver } from './configResolvers/ConnectionStringConfigResolver.js'
+import { getRequire, isNodejsRuntime } from '../../utils/Runtime.js'
 
+/** @type {typeof import('fs') | null} */
+let fs = null
+/** @type {typeof import('process') | null} */
+let process = null
+
+const requireDynamic = getRequire(import.meta.url)
 class ConfigSourceResolver {
+    /**
+     * @param {import('./ConfigPriority.js').ConfigPriority} priority
+     * @param {string | any} configSource
+     */
     static addConfigs(priority, configSource) {
         console.log(`Adding config from source: ${configSource} with priority '${priority}'`)
-        const configString = ConfigSourceResolver._getConfigSourceAsString(configSource)
-        ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString)
+        if (configSource && typeof configSource === 'object') {
+            JsonConfigResolver.addConfigs(priority, configSource)
+        } else {
+            const configString = ConfigSourceResolver._getConfigSourceAsString(configSource)
+            ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString)
+        }
     }
 
+    /**
+     * @param {string} configName
+     * @returns {*}
+     */
     static getConfig(configName) {
         console.log(`Retrieving config ${configName}`)
         return ConfigsDictionary.getConfig(configName)
@@ -24,23 +40,39 @@ class ConfigSourceResolver {
         ConfigsDictionary.clearConfigs()
     }
 
+    /**
+     * @param {string} configSource
+     * @returns {string}
+     */
     static _getConfigSourceAsString(configSource) {
         if (!configSource || configSource.trim() === '') {
             throw new Error('Config source cannot be null or whitespace.')
         }
 
-        const envValue = process.env[configSource]
-        if (envValue && envValue.trim() !== '') {
-            configSource = envValue
-        }
+        if (isNodejsRuntime()) {
+            if (!process) {
+                process = requireDynamic('process')
+            }
+            if (!fs) {
+                fs = requireDynamic('fs')
+            }
 
-        if (fs.existsSync(configSource) && fs.statSync(configSource).isFile()) {
-            configSource = fs.readFileSync(configSource, { encoding: 'utf-8' })
+            const envValue = process?.env[configSource]
+            if (envValue && envValue.trim() !== '') {
+                configSource = envValue
+            }
+            if (fs?.existsSync(configSource) && fs?.statSync(configSource).isFile()) {
+                configSource = fs.readFileSync(configSource, { encoding: 'utf-8' })
+            }
         }
-
         return configSource.trim()
     }
 
+    /**
+     * @param {import('./ConfigPriority.js').ConfigPriority} priority
+     * @param {string} configString
+     * @returns
+     */
     static _parseConfigsAndAddToCollection(priority, configString) {
         // JSON
         try {
@@ -60,7 +92,8 @@ class ConfigSourceResolver {
             YamlConfigResolver.addConfigs(priority, configString)
             return
         } catch (ex) {
-            if (ex.name === 'SyntaxError') {
+            // @ts-expect-error
+            if (ex?.name === 'SyntaxError') {
                 // not YAML
             } else {
                 console.log('Failed to parse config source as YAML: ' + ex)

package/lib/sdk/tools/ComplexTypeResolver.js

@@ -1,6 +1,8 @@
 //@ts-check
+import { PrimitiveSet } from '../../utils/Primitives.js'
 import { getRequire } from '../../utils/Runtime.js'
 import { RuntimeName } from '../../utils/RuntimeName.js'
+import { Activator } from '../Activator.js'
 import { ActivatorDetails } from '../ActivatorDetails.js'
 import { InvocationContext } from '../InvocationContext.js'
 import { JavaTypeParsingFunctions } from './typeParsingFunctions/JavaTypeParsingFunctions.js'
@@ -14,19 +16,23 @@ const dynamicImport = getRequire(import.meta.url)
  * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName
  */
 
+/** @type {Map<number, Map<string, Function>>} */
+const typeParsingFunctions = new Map([
+    [RuntimeName.Netcore, NetcoreTypeParsingFunctions],
+    [RuntimeName.Jvm, JavaTypeParsingFunctions],
+    [RuntimeName.Nodejs, NodejsTypeParsingFunctions],
+    [RuntimeName.Python, PythonTypeParsingFunctions],
+    [RuntimeName.Python27, PythonTypeParsingFunctions],
+])
+
 class ComplexTypeResolver {
     /** @type {Map<string, ActivatorDetails>} */
-    #typeMap = new Map()
-
-    /** @type {Map<number, Map<string, Function>>} */
-    #typeParsingFunctions = new Map([
-        [RuntimeName.Netcore, NetcoreTypeParsingFunctions],
-        [RuntimeName.Jvm, JavaTypeParsingFunctions],
-        [RuntimeName.Nodejs, NodejsTypeParsingFunctions],
-        [RuntimeName.Python, PythonTypeParsingFunctions],
-        [RuntimeName.Python27, PythonTypeParsingFunctions],
-    ])
-
+    #typeMap
+    
+    constructor() {
+        this.#typeMap = new Map()
+    }
+    
     /**
      * Register a custom type mapping
      * @param {string} resultType - The type name from the target runtime
@@ -42,46 +48,47 @@ class ComplexTypeResolver {
     /**
      * Convert InvocationContext result to appropriate JavaScript type
      * @param {InvocationContext} ic - The invocation context
-     * @returns {Promise<any> | any} The converted result
+     * @returns {Promise<any>} The converted result
      */
-    convertResult(ic) {
+    async convertResult(ic) {
         const runtimeName = ic.getRuntimeName()
-        const resultType = ic.getResultType()
-
-        // Try built-in type parsing functions first
-        const runtimeDict = this.#typeParsingFunctions.get(runtimeName)
-        if (runtimeDict) {
-            let parsingFunc = null;
-            if (resultType instanceof Promise) {
-                parsingFunc = resultType.then(result => {
-                    parsingFunc = runtimeDict.get(result);
-                })
-            } else {
-                parsingFunc = runtimeDict.get(resultType);
-            }
+        const resultType = await ic.getResultType()
 
-            if (parsingFunc) {
-                // @ts-ignore
-                return parsingFunc(ic)
-            }
+        if (!resultType) {
+            throw new Error('resultType is not valid')
+        }
+
+        let underlyingType = ComplexTypeResolver.tryGetUnderlyingArrayType(resultType)
+        if (underlyingType !== null) {
+            const { Type } = /** @type {ActivatorDetails} */ (this.#typeMap.get(underlyingType))
+
+            const complexTypesArray = await ic.retrieveArray()
+            return complexTypesArray.map((item) => Activator.createInstance(Type, item))
         }
 
-        // Try registered custom types
-        let activatorDetails = null;
-        if (resultType instanceof Promise) {
-            activatorDetails = resultType.then(result => {
-                activatorDetails = this.#typeMap.get(result);
-            })
-        } else {
-            activatorDetails = this.#typeMap.get(resultType);
+        const parsingFunction = ComplexTypeResolver.tryGetTypeParsingFunction(runtimeName, resultType)
+        if (parsingFunction) {
+            return parsingFunction(ic)
         }
 
+        const activatorDetails = this.tryGetValueFromTypeMap(resultType)
         if (!activatorDetails) {
             throw new Error(`No type registered for key '${resultType}'.`)
         }
-
-        // @ts-ignore
-        return new /** @type {any} */ (activatorDetails.type)(...activatorDetails.arguments)
+        
+        // For nodejs inmemory, getValue() returns the actual JS object
+        if (runtimeName === RuntimeName.Nodejs) {
+            const value = await ic.getValue()
+            if (value) {
+                // If it's already an instance of the registered type, return it directly
+                if (value instanceof activatorDetails.Type) {
+                    return value
+                }
+            }
+        }
+        
+        // Create new instance with stored default arguments
+        return Activator.createInstance(activatorDetails.Type, activatorDetails.arguments ?? null)
     }
 
     /**
@@ -116,6 +123,61 @@ class ComplexTypeResolver {
         }
         return typeObj
     }
-}
 
+    /**
+     * Attempts to extract the underlying element type from an array type string
+     * @param {string} type - The type string to parse (e.g., "MyType[]")
+     * @returns {string | null} Object indicating success and the element type
+     * @throws {Error} If the array element type is a primitive type
+     */
+    static tryGetUnderlyingArrayType(type) {
+        // Validate input type
+        if (typeof type !== 'string' || !type.includes('[')) {
+            return null
+        }
+
+        let trimmedType = type.trim()
+        if (!trimmedType) return null
+
+        // If assembly-qualified, remove everything after the first comma
+        const commaIndex = trimmedType.indexOf(',')
+        if (commaIndex > 0) {
+            trimmedType = trimmedType.substring(0, commaIndex).trim()
+        }
+
+        // Find the first '[' — everything before it is the base type
+        const bracketIndex = trimmedType.indexOf('[')
+        if (bracketIndex > 0) {
+            trimmedType = trimmedType.substring(0, bracketIndex).trim()
+        }
+
+        // Check if base type is a primitive (primitives are not supported as array elements)
+        if (PrimitiveSet.has(trimmedType)) {
+            throw new Error('Primitive array element types are not supported.')
+        }
+
+        return trimmedType
+    }
+
+    /**
+     * @param {RuntimeName} runtimeName
+     * @param {string} resultType
+     * @returns {any}
+     */
+    static tryGetTypeParsingFunction(runtimeName, resultType) {
+        const runtimeDict = typeParsingFunctions.get(runtimeName)
+        return runtimeDict ? (runtimeDict.get(resultType) ?? null) : null
+    }
+
+    /**
+     * @param {string} resultType
+     * @returns {ActivatorDetails | null}
+     */
+    tryGetValueFromTypeMap(resultType) {
+        if (!resultType) {
+            throw new Error('resultType is not valid')
+        }
+        return this.#typeMap.get(resultType) ?? null
+    }
+}
 export { ComplexTypeResolver }

package/lib/utils/CommandType.js

@@ -48,4 +48,5 @@ export const CommandType = /** @type {const} */ ({
     AsKwargs: 45,
     GetResultType: 46,
     GetGlobalField: 47,
+    UpdateInvocationContext: 48,
 })

package/lib/utils/Primitives.js

@@ -0,0 +1,193 @@
+// @ts-check
+/**
+ * Set of primitive type names that are not supported as array element types
+ * @type {Set<string>}
+ */
+export const PrimitiveSet = new Set(
+    [
+        // --- JavaScript / TypeScript ---
+        'string',
+        'number',
+        'boolean',
+        'bigint',
+        'symbol',
+        'undefined',
+        'null',
+
+        // --- .NET / C# ---
+        'bool',
+        'boolean',
+        'byte',
+        'sbyte',
+        'char',
+        'decimal',
+        'double',
+        'float',
+        'single',
+        'int',
+        'int32',
+        'uint',
+        'uint32',
+        'long',
+        'int64',
+        'ulong',
+        'uint64',
+        'short',
+        'int16',
+        'ushort',
+        'uint16',
+        'object',
+        'string',
+        'system.boolean',
+        'system.byte',
+        'system.sbyte',
+        'system.char',
+        'system.decimal',
+        'system.double',
+        'system.single',
+        'system.int',
+        'system.int32',
+        'system.uint',
+        'system.uint32',
+        'system.int64',
+        'system.uint64',
+        'system.int16',
+        'system.uint16',
+        'system.object',
+        'system.string',
+
+        // --- Java ---
+        'byte',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+        'char',
+        'boolean',
+        'java.lang.string',
+
+        // --- Python ---
+        'str',
+        'int',
+        'float',
+        'bool',
+        'bytes',
+        'bytearray',
+
+        // --- Go ---
+        'rune',
+        'byte',
+        'bool',
+        'string',
+        'int',
+        'int8',
+        'int16',
+        'int32',
+        'int64',
+        'uint',
+        'uint8',
+        'uint16',
+        'uint32',
+        'uint64',
+        'float32',
+        'float64',
+
+        // --- C / C++ ---
+        'char',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+        'signed char',
+        'unsigned char',
+        'unsigned short',
+        'unsigned int',
+        'unsigned long',
+
+        // --- Rust ---
+        'bool',
+        'u8',
+        'i8',
+        'u16',
+        'i16',
+        'u32',
+        'i32',
+        'u64',
+        'i64',
+        'f32',
+        'f64',
+        'usize',
+        'isize',
+        'str',
+
+        // --- Kotlin ---
+        'boolean',
+        'byte',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+        'char',
+        'string',
+
+        // --- Swift ---
+        'bool',
+        'int',
+        'uint',
+        'float',
+        'double',
+        'string',
+        'character',
+
+        // --- PHP ---
+        'int',
+        'integer',
+        'float',
+        'double',
+        'string',
+        'bool',
+        'boolean',
+        'mixed',
+
+        // --- Ruby ---
+        'string',
+        'integer',
+        'fixnum',
+        'float',
+        'symbol',
+        'boolean',
+
+        // --- Dart ---
+        'int',
+        'double',
+        'num',
+        'bool',
+        'string',
+
+        // --- Scala ---
+        'int',
+        'long',
+        'double',
+        'float',
+        'char',
+        'boolean',
+        'string',
+
+        // --- Haskell ---
+        'int',
+        'float',
+        'double',
+        'char',
+        'bool',
+        'integer',
+
+        // --- Generic aliases ---
+        'text',
+        'primitive',
+        'any',
+        'void',
+    ].map((x) => x.toLowerCase())
+)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.6.7",
+    "version": "2.6.9",
     "description": "Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/",
     "keywords": [],
     "author": "SdNCenter Sp. z o. o.",
@@ -40,12 +40,13 @@
         "format": "prettier --write ."
     },
     "dependencies": {
+        "@types/uuid": "^10.0.0",
         "@types/ws": "^8.18.1",
         "buffer": "^6.0.3",
         "glob": "^10.4.5",
         "js-yaml": "^4.1.0",
         "uuid": "^10.0.0",
-        "ws": "^8.13.0"
+        "ws": "^8.18.1"
     },
     "devDependencies": {
         "@babel/cli": "^7.25.9",
@@ -58,7 +59,7 @@
         "@types/js-yaml": "^4.0.9",
         "babel-loader": "^9.2.1",
         "cross-env": "^7.0.3",
-        "esbuild": "^0.24.0",
+        "esbuild": "^0.27.0",
         "eslint": "^9.15.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-jest": "^28.9.0",