javonet-nodejs-sdk 2.6.6 → 2.6.8

package/lib/sdk/tools/ComplexTypeResolver.js

@@ -1,13 +1,14 @@
 //@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'
 import { NetcoreTypeParsingFunctions } from './typeParsingFunctions/NetcoreTypeParsingFunctions.js'
 import { NodejsTypeParsingFunctions } from './typeParsingFunctions/NodejsTypeParsingFunctions.js'
 import { PythonTypeParsingFunctions } from './typeParsingFunctions/PythonTypeParsingFunctions.js'
-import * as util from 'node:util'
 
 const dynamicImport = getRequire(import.meta.url)
 
@@ -15,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
@@ -43,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)
     }
 
     /**
@@ -117,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/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.6",
+    "version": "2.6.8",
     "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.",
@@ -30,17 +30,6 @@
             "default": "./lib/utils/CreateRequire.node.js"
         }
     },
-    "jest": {
-        "verbose": true,
-        "testResultsProcessor": "./node_modules/jest-junit-reporter",
-        "coverageReporters": [
-            "json",
-            "lcov",
-            "text",
-            "clover",
-            "cobertura"
-        ]
-    },
     "scripts": {
         "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/unitTests tests/functional -t=\"(Unit|Functional)\" --maxWorkers=3 --colors --coverage",
         "webserviceTests": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/webSocketClientTests --maxWorkers=3 --colors",