javonet-nodejs-sdk 2.5.10 → 2.5.12

package/lib/core/handler/InvokeGlobalMethodHandler.js

@@ -1,43 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class InvokeGlobalMethodHandler extends AbstractHandler {
-    requiredParametersCount = 1
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error('Invoke Global Method parameters mismatch')
-            }
-            const { payload } = command
-            const splitted = payload[0].split('.')
-            let methodToInvoke
-            for (let i = 0; i < splitted.length; i++) {
-                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
-            }
-            if (typeof methodToInvoke === 'undefined') {
-                let methods = Object.getOwnPropertyNames(global).filter(function (property) {
-                    return typeof global[property] === 'function'
-                })
-                let message = `Method ${payload[0]} not found in global. Available methods:\n`
-                methods.forEach((methodIter) => {
-                    message += `${methodIter}\n`
-                })
-                throw new Error(message)
-            }
-            if (payload.length > 1) {
-                const args = payload.slice(1)
-                return methodToInvoke(args)
-            } else {
-                return methodToInvoke()
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
-    }
-}
-
-module.exports = new InvokeGlobalMethodHandler()

package/lib/core/handler/InvokeStandaloneMethodHandler.js

@@ -1,56 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class InvokeStandaloneMethodHandler extends AbstractHandler {
-    requiredParametersCount = 2
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error('Invoke standalone Method parameters mismatch')
-            }
-
-            const { payload } = command
-            const type = payload[0]
-            const methodName = payload[1]
-            const args = payload.slice(2)
-
-            if (typeof type === 'function') {
-                // assuming that function is exported as single (default)
-                return Reflect.apply(type, undefined, args)
-            }
-
-            if (typeof type === 'object') {
-                // assuming that function inside of multiple exports
-                const method = type[methodName]
-
-                if (typeof method === 'function') {
-                    return Reflect.apply(method, undefined, args)
-                }
-                return this.throwError(type, methodName)
-            } else {
-                throw new Error(`Function ${methodName} not found in libary.`)
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
-    }
-
-    throwError(type, methodName) {
-        const methods = Object.getOwnPropertyNames(type).filter(
-            (property) => typeof type[property] === 'function'
-        )
-
-        let message = `Function ${methodName} not found in libary. Available standalone methods:\n`
-        methods.forEach((methodIter) => {
-            message += `${methodIter}\n`
-        })
-
-        throw new Error(message)
-    }
-}
-
-module.exports = new InvokeStandaloneMethodHandler()

package/lib/sdk/RuntimeContext.js

@@ -1,36 +0,0 @@
-/* eslint-disable no-unused-private-class-members */
-const { Interpreter, RuntimeContext: RuntimeContextCore } = require('@javonet/core')
-const GeneratorHandler = require('../core/generator/handler/GeneratorHandler')
-
-/**
- * Represents a single context which allows interaction with a selected technology.
- * Refers to a single instance of the called runtime within a particular target OS process.
- * This can be either the local currently running process (inMemory) or a particular remote process identified by the IP Address and PORT of the target Javonet instance.
- * Multiple Runtime Contexts can be initialized within one process.
- * Calling the same technology on inMemory communication channel will return the existing instance of runtime context.
- * Calling the same technology on TCP channel but on different nodes will result in unique Runtime Contexts.
- * Within the runtime context, any number of libraries can be loaded and any objects from the target technology can be interacted with, as they are aware of each other due to sharing the same memory space and same runtime instance.
- * @see [Javonet Guides]{@link https://www.javonet.com/guides/v2/javascript/foundations/runtime-context}
- * @class
- */
-class RuntimeContext extends RuntimeContextCore {
-    static memoryRuntimeContexts = new Map()
-    static networkRuntimeContexts = new Map()
-    static webSocketRuntimeContexts = new Map()
-    #currentCommand
-    #responseCommand
-    #interpreter
-    #generatorHandler
-
-    constructor(runtimeName, connectionData) {
-        super()
-        this.runtimeName = runtimeName
-        this.connectionData = connectionData
-        this.#currentCommand = null
-        this.#responseCommand = null
-        this.#interpreter = new Interpreter()
-        this.#generatorHandler = new GeneratorHandler()
-    }
-}
-
-module.exports = RuntimeContext