javonet-nodejs-sdk 2.5.9 → 2.5.10

package/dist/index.js

@@ -4,6 +4,7 @@ const CommandSerializer = require('./lib/core/protocol/CommandSerializer')
 const TypeDeserializer = require('./lib/core/protocol/TypeDeserializer')
 const TypeSerializer = require('./lib/core/protocol/TypeSerializer')
 const Interpreter = require('./lib/core/interpreter/Interpreter')
+const DelegatesCache = require('./lib/core/delegatesCache/DelegatesCache')
 
 // Sdk
 const RuntimeContext = require('./lib/sdk/RuntimeContext')
@@ -36,6 +37,7 @@ module.exports = {
     TypeDeserializer,
     TypeSerializer,
     Interpreter,
+    DelegatesCache,
 
     // Sdk
     InvocationContext,

package/dist/lib/core/delegatesCache/DelegatesCache.js

@@ -0,0 +1,35 @@
+const generateGUID = require('../../utils/guid/generateGuid')
+
+/**
+ * A cache for storing and retrieving delegates.
+ */
+class DelegatesCache {
+    cache = new Map()
+
+    /**
+     * Adds a delegate to the cache and returns its unique ID.
+     * @param {Function} delegateInstance - The delegate function to store.
+     * @returns {string} The unique ID for the delegate.
+     */
+    addDelegate(delegateInstance) {
+        const delegateId = generateGUID()
+        this.cache.set(delegateId, delegateInstance)
+        return delegateId
+    }
+
+    /**
+     * Retrieves a delegate by its unique ID.
+     * @param {string} delegateId - The unique ID of the delegate.
+     * @returns {Function} The delegate function.
+     * @throws {Error} If the delegate is not found.
+     */
+    getDelegate(delegateId) {
+        const delegateInstance = this.cache.get(delegateId)
+        if (!delegateInstance) {
+            throw new Error('Delegate not found')
+        }
+        return delegateInstance
+    }
+}
+
+module.exports = new DelegatesCache()

package/dist/lib/core/handler/ConvertTypeHandler.js

@@ -0,0 +1,38 @@
+const { TypesConverter } = require('../../utils/TypesConverter')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+class ConvertTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Object} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        this.validateCommand(command)
+        return TypesConverter.convertJTypeToType(command.payload[0])
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Object} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('ConvertTypeHandler parameters mismatch')
+        }
+    }
+}
+
+module.exports = ConvertTypeHandler

package/dist/lib/core/handler/GetInstanceMethodAsDelegateHandler.js

@@ -0,0 +1,73 @@
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving an instance method as a delegate.
+ */
+class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+        /** @type {Array<*>} */
+        this.args = []
+        /** @type {Object|null} */
+        this.instance = null
+    }
+
+    /**
+     * Processes a command to retrieve an instance method as a delegate.
+     * @param {Object} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+     * @returns {Function} The delegate for the instance method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        this.instance = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the instance
+        this.method = this.getMethod(this.instance, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(this.instance, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this.instance)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type.prototype).filter(
+            (key) => typeof type.prototype[key] === 'function'
+        )
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available instance public methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetInstanceMethodAsDelegateHandler()

package/dist/lib/core/handler/GetStaticMethodAsDelegateHandler.js

@@ -0,0 +1,74 @@
+// eslint-disable-next-line no-unused-vars
+const { Command } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving a static method as a delegate.
+ */
+class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+    /** @type {Array<*>} */
+    args = []
+
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+    }
+
+    /**
+     * Processes a command to retrieve a static method as a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+     * @returns {Function} The delegate for the static method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const type = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the type
+        this.method = this.getMethod(type, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(type, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @param {Array<Function>} argsType - The argument types.
+     * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.keys(type).filter((key) => typeof type[key] === 'function')
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetStaticMethodAsDelegateHandler()

package/dist/lib/core/handler/Handler.js

@@ -23,6 +23,11 @@ const EnableTypeHandler = require('./EnableTypeHandler')
 const { CommandType, Command, ExceptionSerializer } = require('../../..')
 const ReferencesCache = require('../referenceCache/ReferencesCache')
 const InvokeStandaloneMethodHandler = require('./InvokeStandaloneMethodHandler')
+const GetStaticMethodAsDelegateHandler = require('./GetStaticMethodAsDelegateHandler')
+const GetInstanceMethodAsDelegateHandler = require('./GetInstanceMethodAsDelegateHandler')
+const PassDelegateHandler = require('./PassDelegateHandler')
+const InvokeDelegateHandler = require('./InvokeDelegateHandler')
+const { ConvertTypeHandler } = require('../../utils/TypesConverter')
 
 function isResponseSimpleType(response) {
     let type = typeof response
@@ -56,6 +61,11 @@ const handlers = {
     [CommandType.Array]: ArrayHandler,
     [CommandType.EnableNamespace]: EnableNamespaceHandler,
     [CommandType.EnableType]: EnableTypeHandler,
+    [CommandType.GetStaticMethodAsDelegate]: GetStaticMethodAsDelegateHandler,
+    [CommandType.GetInstanceMethodAsDelegate]: GetInstanceMethodAsDelegateHandler,
+    [CommandType.PassDelegate]: PassDelegateHandler,
+    [CommandType.InvokeDelegate]: InvokeDelegateHandler,
+    [CommandType.ConvertType]: ConvertTypeHandler,
 }
 
 Object.keys(handlers).forEach((commandTypeHandler) => {

package/dist/lib/core/handler/InvokeDelegateHandler.js

@@ -0,0 +1,36 @@
+const { DelegatesCache } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles invoking a delegate by GUID.
+ */
+class InvokeDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {number} */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes a command to invoke a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @returns {*} The result of the delegate invocation.
+     * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+     */
+    process(command) {
+        const payload = command.payload
+        if (payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const guid = payload[0]
+        const delegate = DelegatesCache.getDelegate(guid)
+        if (!delegate) {
+            throw new Error('Delegate not found in cache')
+        }
+
+        return delegate
+    }
+}
+
+module.exports = new InvokeDelegateHandler()

package/dist/lib/core/handler/PassDelegateHandler.js

@@ -0,0 +1,157 @@
+// eslint-disable-next-line no-unused-vars
+const { Interpreter, Command, CommandType, InMemoryConnectionData, DelegatesCache } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+class PassDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+        this.interpreter = new Interpreter()
+    }
+
+    /**
+     * Processes the given command to create and compile a delegate.
+     * @param {Command} command - The command to process.
+     * @returns {Function} The compiled delegate function.
+     */
+    process(command) {
+        this.validateCommand(command)
+
+        const delegateGuid = command.payload[0]
+        const delegate = DelegatesCache.getDelegate(delegateGuid)
+
+        return delegate
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Command} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('PassDelegateHandler parameters mismatch')
+        }
+    }
+
+    /**
+     * Retrieves the arguments from the command payload.
+     * @param {Command} command - The command containing the payload.
+     * @returns {Array} The extracted arguments.
+     */
+    getArguments(command) {
+        return command.payload.length > 2 ? command.payload.slice(2) : []
+    }
+
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Array} The argument types.
+     */
+    getArgumentTypes(args) {
+        return args.slice(0, -1).map((arg) => arg.constructor)
+    }
+
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args) {
+        return args[args.length - 1].constructor
+    }
+
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array} argsTypes - The argument types.
+     * @returns {Array} The parameter expressions.
+     */
+    createParameters(argsTypes) {
+        return argsTypes.map((type, index) => ({ name: `arg${index}`, type }))
+    }
+
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array} parameters - The parameter expressions.
+     * @returns {Array} The arguments array.
+     */
+    createArgsArray(delegateGuid, parameters) {
+        return [delegateGuid, ...parameters.map((param) => param.name)]
+    }
+
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName, payload) {
+        return {
+            runtimeName: callingRuntimeName,
+            type: CommandType.InvokeDelegate,
+            payload,
+        }
+    }
+
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {Object} The response object.
+     */
+    createExecuteCall(command) {
+        return this.interpreter.execute(command, new InMemoryConnectionData())
+    }
+
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object} executeCall - The execution call.
+     * @returns {Array} The response payload.
+     */
+    getResponse(executeCall) {
+        return executeCall.payload
+    }
+
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response, returnType) {
+        return returnType(response[0])
+    }
+
+    /**
+     * Creates a block of expressions for the delegate.
+     * @param {Function} returnType - The return type.
+     * @param {*} convertedFirstElement - The converted first element.
+     * @returns {Object} The block expression.
+     */
+    createBlock(returnType, convertedFirstElement) {
+        return { returnType, body: convertedFirstElement }
+    }
+
+    /**
+     * Creates a delegate type.
+     * @param {Array} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters, returnType) {
+        return (...args) => {
+            if (args.length !== parameters.length) {
+                throw new Error('Invalid argument count.')
+            }
+            return returnType
+        }
+    }
+}
+
+module.exports = new PassDelegateHandler()

package/dist/lib/sdk/InvocationContext.js

@@ -1,8 +1,10 @@
+const DelegatesCache = require('../core/delegatesCache/DelegatesCache')
 const Interpreter = require('../core/interpreter/Interpreter')
 const Command = require('../utils/Command')
 const CommandType = require('../utils/CommandType')
 const ConnectionType = require('../utils/ConnectionType')
 const ExceptionThrower = require('../utils/exception/ExceptionThrower')
+const RuntimeName = require('../utils/RuntimeName')
 
 /**
  * InvocationContext is a class that represents a context for invoking commands.
@@ -338,6 +340,40 @@ class InvocationContext {
         return this.#createInstanceContext(localCommand)
     }
 
+    /**
+     * Creates a null object of a specific type on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * TODO: connect documentation page url
+     * @see [Javonet Guides](https://www.javonet.com/guides/)
+     * @method
+     */
+    getStaticMethodAsDelegate(methodName, ...args) {
+        const localCommand = new Command(this.#runtimeName, CommandType.GetStaticMethodAsDelegate, [
+            methodName,
+            ...args,
+        ])
+        return this.#createInstanceContext(localCommand)
+    }
+
+    /**
+     * Creates a null object of a specific type on the target runtime.
+     * @param {string} methodName - The name of the method to invoke.
+     * @param {...any} args - Method arguments.
+     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * TODO: connect documentation page url
+     * @see [Javonet Guides](https://www.javonet.com/guides/)
+     * @method
+     */
+    getInstanceMethodAsDelegate(methodName, ...args) {
+        const localCommand = new Command(this.#runtimeName, CommandType.GetInstanceMethodAsDelegate, [
+            methodName,
+            ...args,
+        ])
+        return this.#createInstanceContext(localCommand)
+    }
+
     /**
      * Retrieves an array from the target runtime.
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -390,6 +426,13 @@ class InvocationContext {
                 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] = typeof 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])
         }

package/dist/lib/sdk/RuntimeContext.js

@@ -5,6 +5,8 @@ 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.
@@ -251,6 +253,13 @@ class RuntimeContext {
                 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])
         }

package/dist/lib/utils/CommandType.js

@@ -37,7 +37,12 @@ const CommandType = /** @type {const} */ ({
     EnableNamespace: 34,
     EnableType: 35,
     CreateNull: 36,
-    InvokeStandaloneMethod: 37,
+    GetStaticMethodAsDelegate: 37,
+    GetInstanceMethodAsDelegate: 38,
+    PassDelegate: 39,
+    InvokeDelegate: 40,
+    ConvertType: 41,
+    InvokeStandaloneMethod: 42,
 })
 
 module.exports = CommandType

package/dist/lib/utils/TypesConverter.js

@@ -0,0 +1,91 @@
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+class ConvertTypeHandler {
+    constructor() {
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Object} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        this.validateCommand(command)
+        return TypesConverter.convertJTypeToType(command.payload[0])
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Object} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('ConvertTypeHandler parameters mismatch')
+        }
+    }
+}
+
+/**
+ * TypesConverter class provides utilities for converting between types.
+ */
+class TypesConverter {
+    /**
+     * Converts a JavaScript type to a JType equivalent.
+     * @param {Function} type - The JavaScript type.
+     * @returns {number} The corresponding JType.
+     */
+    static convertTypeToJType(type) {
+        switch (type) {
+            case Boolean:
+                return JType.Boolean
+            case Number:
+                return JType.Float // Assuming Number maps to Float
+            case String:
+                return JType.String
+            case Object:
+                return JType.Null // Assuming Object maps to Null
+            default:
+                return JType.Null
+        }
+    }
+
+    /**
+     * Converts a JType to a JavaScript type equivalent.
+     * @param {number} type - The JType to convert.
+     * @returns {Function} The corresponding JavaScript type.
+     */
+    static convertJTypeToType(type) {
+        switch (type) {
+            case JType.Boolean:
+                return Boolean
+            case JType.Float:
+                return Number
+            case JType.String:
+                return String
+            case JType.Null:
+                return null
+            default:
+                return null
+        }
+    }
+}
+
+/**
+ * Enum for JType mappings.
+ * @readonly
+ * @enum {number}
+ */
+const JType = {
+    Boolean: 1,
+    Float: 2,
+    String: 3,
+    Null: 4,
+}
+
+module.exports = { ConvertTypeHandler, TypesConverter, JType }

package/dist/lib/utils/guid/generateGuid.js

@@ -0,0 +1,9 @@
+function generateGUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0
+        const v = c === 'x' ? r : (r & 0x3) | 0x8
+        return v.toString(16)
+    })
+}
+
+module.exports = generateGUID