javonet-nodejs-sdk 2.5.8 → 2.5.9

package/dist/lib/core/generator/handler/shared/body/SharedInvokeInstanceMethodBodyHandler.js

@@ -0,0 +1,33 @@
+const AbstractGeneratorHandler = require('../../AbstractGeneratorHandler')
+const CommonGenerator = require('../../../internal/CommonGenerator')
+const SharedHandlerType = require('../../../internal/SharedHandlerType')
+const OS = require('os')
+
+class SharedInvokeInstanceMethodBodyHandler extends AbstractGeneratorHandler {
+    generate_code(existing_string_builder, common_command, used_object, handlers) {
+        handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_code(
+            existing_string_builder,
+            common_command,
+            used_object.payload[1],
+            handlers
+        )
+        existing_string_builder.append('this.instance.')
+        existing_string_builder.append('invokeInstanceMethod')
+        existing_string_builder.append('(')
+        existing_string_builder.append('"')
+        existing_string_builder.append(used_object.payload[0])
+        existing_string_builder.append('"')
+        existing_string_builder.append(', ')
+        CommonGenerator.process_method_arguments_names(
+            existing_string_builder,
+            common_command,
+            used_object.payload[4],
+            handlers
+        )
+        existing_string_builder.append(').')
+        existing_string_builder.append('execute().resultValue')
+        existing_string_builder.append(OS.EOL)
+    }
+}
+
+module.exports = SharedInvokeInstanceMethodBodyHandler

package/dist/lib/core/generator/handler/shared/body/SharedInvokeStandaloneMethodBodyHandler.js

@@ -0,0 +1,39 @@
+const OS = require('os')
+const AbstractGeneratorHandler = require('../../AbstractGeneratorHandler')
+const CommonGenerator = require('../../../internal/CommonGenerator')
+const SharedHandlerType = require('../../../internal/SharedHandlerType')
+const StringUtils = require('../../../utils/StringUtils')
+const { RuntimeName } = require('../../../../../..')
+
+class SharedInvokeStandaloneMethodBodyHandler extends AbstractGeneratorHandler {
+    generate_code(existing_string_builder, common_command, used_object, handlers) {
+        handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_code(
+            existing_string_builder,
+            common_command,
+            used_object.payload[1],
+            handlers
+        )
+        existing_string_builder.append('Javonet.inMemory().')
+        existing_string_builder.append(
+            StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName])
+        )
+        existing_string_builder.append('().')
+        existing_string_builder.append('getType("')
+        existing_string_builder.append(used_object.payload[3])
+        existing_string_builder.append('").')
+        existing_string_builder.append('invokeStandaloneMethod("')
+        existing_string_builder.append(used_object.payload[0])
+        existing_string_builder.append('", ')
+        CommonGenerator.process_method_arguments_names(
+            existing_string_builder,
+            common_command,
+            used_object.payload[5],
+            handlers
+        )
+        existing_string_builder.append(').')
+        existing_string_builder.append('execute().resultValue')
+        existing_string_builder.append(OS.EOL)
+    }
+}
+
+module.exports = SharedInvokeStandaloneMethodBodyHandler

package/dist/lib/core/generator/handler/shared/body/SharedInvokeStaticMethodBodyHandler.js

@@ -0,0 +1,39 @@
+const OS = require('os')
+const AbstractGeneratorHandler = require('../../AbstractGeneratorHandler')
+const CommonGenerator = require('../../../internal/CommonGenerator')
+const SharedHandlerType = require('../../../internal/SharedHandlerType')
+const StringUtils = require('../../../utils/StringUtils')
+const { RuntimeName } = require('../../../../../..')
+
+class SharedInvokeStaticMethodBodyHandler extends AbstractGeneratorHandler {
+    generate_code(existing_string_builder, common_command, used_object, handlers) {
+        handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_code(
+            existing_string_builder,
+            common_command,
+            used_object.payload[1],
+            handlers
+        )
+        existing_string_builder.append('Javonet.inMemory().')
+        existing_string_builder.append(
+            StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName])
+        )
+        existing_string_builder.append('().')
+        existing_string_builder.append('getType("')
+        existing_string_builder.append(used_object.payload[3])
+        existing_string_builder.append('").')
+        existing_string_builder.append('invokeStaticMethod("')
+        existing_string_builder.append(used_object.payload[0])
+        existing_string_builder.append('", ')
+        CommonGenerator.process_method_arguments_names(
+            existing_string_builder,
+            common_command,
+            used_object.payload[5],
+            handlers
+        )
+        existing_string_builder.append(').')
+        existing_string_builder.append('execute().resultValue')
+        existing_string_builder.append(OS.EOL)
+    }
+}
+
+module.exports = SharedInvokeStaticMethodBodyHandler

package/dist/lib/core/generator/internal/CommonGenerator.js

@@ -0,0 +1,39 @@
+const SharedHandlerType = require('./SharedHandlerType')
+
+class CommonGenerator {
+    static process_method_arguments(
+        existing_string_builder,
+        common_command,
+        type_array,
+        name_array,
+        handlers
+    ) {
+        for (let i = 0; i < name_array.length; i++) {
+            handlers.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME].generate_code(
+                existing_string_builder,
+                common_command,
+                name_array[i],
+                handlers
+            )
+            if (i < name_array.length - 1) {
+                existing_string_builder.append(', ')
+            }
+        }
+    }
+
+    static process_method_arguments_names(existing_string_builder, common_command, name_array, handlers) {
+        for (let i = 0; i < name_array.length; i++) {
+            handlers.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME].generate_code(
+                existing_string_builder,
+                common_command,
+                name_array[i],
+                handlers
+            )
+            if (i < name_array.length - 1) {
+                existing_string_builder.append(', ')
+            }
+        }
+    }
+}
+
+module.exports = CommonGenerator

package/dist/lib/core/generator/internal/NodejsStringBuilder.js

@@ -0,0 +1,17 @@
+class NodejsStringBuilder {
+    constructor() {
+        this.string = ''
+    }
+
+    string
+
+    append(string) {
+        this.string += string
+    }
+
+    getString() {
+        return this.string
+    }
+}
+
+module.exports = NodejsStringBuilder

package/dist/lib/core/generator/internal/SharedHandlerType.js

@@ -0,0 +1,10 @@
+module.exports = {
+    ARGUMENT_NAME: 0,
+    METHOD_BODY: 1,
+    CLASS_NAME: 2,
+    METHOD_NAME: 3,
+    MODIFIER: 4,
+    TYPE: 5,
+    CLAZZ_INSTANCE: 6,
+    RETURN_TYPE: 7,
+}

package/dist/lib/core/generator/utils/StringUtils.js

@@ -0,0 +1,7 @@
+class StringUtils {
+    static capitalizeFirstLetter(string) {
+        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase()
+    }
+}
+
+module.exports = StringUtils

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

@@ -0,0 +1,41 @@
+const { Command } = require('../../..')
+
+class AbstractHandler {
+    handlers = []
+
+    constructor() {
+        if (new.target === AbstractHandler) throw new TypeError('You cannot instantiate abstract class')
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    process(command) {
+        throw new Error('process must be implemented')
+    }
+
+    handleCommand(command) {
+        this.iterate(command)
+        return this.process(command)
+    }
+
+    iterate(cmd) {
+        for (let i = 0; i < cmd.payload.length; i++) {
+            if (cmd.payload[i] instanceof Command) {
+                let inner = cmd.payload[i]
+                cmd.payload[i] = this.handlers[inner.commandType].handleCommand(inner)
+            }
+        }
+    }
+
+    process_stack_trace(error, class_name) {
+        let stackTraceArray = error.stack.split('\n').map((frame) => frame.trim())
+        stackTraceArray.forEach((str, index) => {
+            if (str.includes(class_name)) {
+                stackTraceArray = stackTraceArray.slice(0, index).filter((s) => !s.includes(class_name))
+            }
+        })
+        error.stack = stackTraceArray.join(' \n ')
+        return error
+    }
+}
+
+module.exports = AbstractHandler

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

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class ArrayGetItemHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Get Item parameters mismatch')
+            }
+            let array = command.payload[0]
+            let indexes
+            if (Array.isArray(command.payload[1])) {
+                indexes = command.payload[1]
+            } else {
+                indexes = command.payload.slice(1)
+            }
+
+            if (indexes.length === 1) {
+                return array[indexes]
+            } else {
+                let array_copy = [...array]
+                for (let i = 0; i < indexes.length; i++) {
+                    array_copy = array_copy[indexes[i]]
+                }
+                return array_copy
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new ArrayGetItemHandler()

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

@@ -0,0 +1,28 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class ArrayGetRankHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Get Rank parameters mismatch')
+            }
+            let array = command.payload[0]
+            let rank = 0
+            while (Array.isArray(array)) {
+                rank = rank + 1
+                array = array[0]
+            }
+
+            return rank
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new ArrayGetRankHandler()

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

@@ -0,0 +1,29 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class ArrayGetSizeHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Get Size parameters mismatch')
+            }
+            let array = command.payload[0]
+            let size = 1
+            while (Array.isArray(array)) {
+                size = size * array.length
+                array = array[0]
+            }
+
+            return size
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new ArrayGetSizeHandler()

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

@@ -0,0 +1,18 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class ArrayHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            let processedArray = command.payload
+            return processedArray
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new ArrayHandler()

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

@@ -0,0 +1,43 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class ArraySetItemHandler extends AbstractHandler {
+    requiredParametersCount = 3
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Set Item parameters mismatch')
+            }
+
+            let array = command.payload[0]
+            let value = command.payload[2]
+            let indexes
+            if (Array.isArray(command.payload[1])) {
+                indexes = command.payload[1]
+            } else {
+                indexes = [command.payload[1]]
+            }
+
+            if (indexes.length === 1) {
+                // one-dimensional array
+                array[indexes] = value
+            } else {
+                // multi-dimensional array
+                for (let i = 0; i < indexes.length - 1; i++) {
+                    array = array[indexes[i]]
+                }
+                array[indexes[indexes.length - 1]] = value
+            }
+
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new ArraySetItemHandler()

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

@@ -0,0 +1,10 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class CastingHandler extends AbstractHandler {
+    // eslint-disable-next-line no-unused-vars
+    process(command) {
+        throw new Error(`Dynamically typed languages are not supporting casting`)
+    }
+}
+
+module.exports = new CastingHandler()

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

@@ -0,0 +1,36 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class CreateClassInstanceHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Create Class Instance parameters mismatch')
+            }
+            let clazz = command.payload[0]
+            let constructorArguments = command.payload.slice(1)
+            let instance = new clazz(...constructorArguments)
+            if (typeof instance === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method 'constructor' not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instance
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new CreateClassInstanceHandler()

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

@@ -0,0 +1,19 @@
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const AbstractHandler = require('./AbstractHandler')
+
+class DestructReferenceHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            let cache = ReferencesCache.getInstance()
+            return cache.deleteReference(command.payload[0])
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new DestructReferenceHandler()

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

@@ -0,0 +1,34 @@
+const NamespaceCache = require('../namespaceCache/NamespaceCache')
+const AbstractHandler = require('./AbstractHandler')
+
+class EnableNamespaceHandler extends AbstractHandler {
+    constructor() {
+        super()
+        this.requiredParametersCount = 1
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error(this.constructor.name + ' parameters mismatch')
+            }
+            const namespace_cache = new NamespaceCache()
+
+            for (let payload of command.payload) {
+                if (typeof payload === 'string') {
+                    namespace_cache.cacheNamespace(payload)
+                }
+                if (Array.isArray(payload)) {
+                    for (let namespace_to_enable of payload) {
+                        namespace_cache.cacheNamespace(namespace_to_enable)
+                    }
+                }
+            }
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new EnableNamespaceHandler()

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

@@ -0,0 +1,35 @@
+const TypeCache = require('../typeCache/TypeCache')
+const AbstractHandler = require('./AbstractHandler')
+
+class EnableTypeHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get Type parameters mismatch')
+            }
+            const typeCache = new TypeCache()
+
+            for (let payload of command.payload) {
+                if (typeof payload === 'string') {
+                    typeCache.cacheType(payload)
+                }
+                if (Array.isArray(payload)) {
+                    for (let namespace_to_enable of payload) {
+                        typeCache.cacheType(namespace_to_enable)
+                    }
+                }
+            }
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new EnableTypeHandler()

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

@@ -0,0 +1,37 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get global static field parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            let fieldToGet
+
+            for (let i = 0; i < splitted.length; i++) {
+                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
+                if (typeof fieldToGet === 'undefined') {
+                    let fields = Object.keys(global)
+                    let message = `Field ${payload[0]} not found in global. Available fields:\n`
+                    fields.forEach((fieldIter) => {
+                        message += `${fieldIter}\n`
+                    })
+                    throw new Error(message)
+                }
+            }
+            return fieldToGet
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetGlobalStaticFieldHandler()

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

@@ -0,0 +1,35 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get Instance Field parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let field = payload[1]
+            let instanceField = instance[field]
+            if (typeof instanceField === 'undefined') {
+                let fields = Object.keys(instance)
+                let message = `Field ${field} not found in object. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instanceField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetInstanceFieldHandler()

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

@@ -0,0 +1,36 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Static Field parameters mismatch')
+            }
+            const { payload } = command
+            let type = payload[0]
+            let field = payload[1]
+
+            let staticField = type[field]
+            if (typeof staticField === 'undefined') {
+                let fields = Object.keys(type)
+                let message = `Field ${field} not found in class. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return staticField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetStaticFieldHandler()