Flowise

1
import { cloneDeep } from 'lodash'
2
import { StatusCodes } from 'http-status-codes'
3
import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
4
import { INodeData } from '../../Interface'
5
import { INodeOptionsValue, ICommonObject, handleEscapeCharacters } from 'flowise-components'
6
import { databaseEntities } from '../../utils'
7
import logger from '../../utils/logger'
8
import { InternalFlowiseError } from '../../errors/internalFlowiseError'
9
import { getErrorMessage } from '../../errors/utils'
10

11
// Get all component nodes
12
const getAllNodes = async () => {
13
    try {
14
        const appServer = getRunningExpressApp()
15
        const dbResponse = []
16
        for (const nodeName in appServer.nodesPool.componentNodes) {
17
            const clonedNode = cloneDeep(appServer.nodesPool.componentNodes[nodeName])
18
            dbResponse.push(clonedNode)
19
        }
20
        return dbResponse
21
    } catch (error) {
22
        throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, `Error: nodesService.getAllNodes - ${getErrorMessage(error)}`)
23
    }
24
}
25

26
// Get all component nodes for a specific category
27
const getAllNodesForCategory = async (category: string) => {
28
    try {
29
        const appServer = getRunningExpressApp()
30
        const dbResponse = []
31
        for (const nodeName in appServer.nodesPool.componentNodes) {
32
            const componentNode = appServer.nodesPool.componentNodes[nodeName]
33
            if (componentNode.category === category) {
34
                const clonedNode = cloneDeep(componentNode)
35
                dbResponse.push(clonedNode)
36
            }
37
        }
38
        return dbResponse
39
    } catch (error) {
40
        throw new InternalFlowiseError(
41
            StatusCodes.INTERNAL_SERVER_ERROR,
42
            `Error: nodesService.getAllNodesForCategory - ${getErrorMessage(error)}`
43
        )
44
    }
45
}
46

47
// Get specific component node via name
48
const getNodeByName = async (nodeName: string) => {
49
    try {
50
        const appServer = getRunningExpressApp()
51
        if (Object.prototype.hasOwnProperty.call(appServer.nodesPool.componentNodes, nodeName)) {
52
            const dbResponse = appServer.nodesPool.componentNodes[nodeName]
53
            return dbResponse
54
        } else {
55
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Node ${nodeName} not found`)
56
        }
57
    } catch (error) {
58
        throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, `Error: nodesService.getAllNodes - ${getErrorMessage(error)}`)
59
    }
60
}
61

62
// Returns specific component node icon via name
63
const getSingleNodeIcon = async (nodeName: string) => {
64
    try {
65
        const appServer = getRunningExpressApp()
66
        if (Object.prototype.hasOwnProperty.call(appServer.nodesPool.componentNodes, nodeName)) {
67
            const nodeInstance = appServer.nodesPool.componentNodes[nodeName]
68
            if (nodeInstance.icon === undefined) {
69
                throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Node ${nodeName} icon not found`)
70
            }
71

72
            if (nodeInstance.icon.endsWith('.svg') || nodeInstance.icon.endsWith('.png') || nodeInstance.icon.endsWith('.jpg')) {
73
                const filepath = nodeInstance.icon
74
                return filepath
75
            } else {
76
                throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, `Node ${nodeName} icon is missing icon`)
77
            }
78
        } else {
79
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Node ${nodeName} not found`)
80
        }
81
    } catch (error) {
82
        throw new InternalFlowiseError(
83
            StatusCodes.INTERNAL_SERVER_ERROR,
84
            `Error: nodesService.getSingleNodeIcon - ${getErrorMessage(error)}`
85
        )
86
    }
87
}
88

89
const getSingleNodeAsyncOptions = async (nodeName: string, requestBody: any): Promise<any> => {
90
    try {
91
        const appServer = getRunningExpressApp()
92
        const nodeData: INodeData = requestBody
93
        if (Object.prototype.hasOwnProperty.call(appServer.nodesPool.componentNodes, nodeName)) {
94
            try {
95
                const nodeInstance = appServer.nodesPool.componentNodes[nodeName]
96
                const methodName = nodeData.loadMethod || ''
97

98
                const dbResponse: INodeOptionsValue[] = await nodeInstance.loadMethods![methodName]!.call(nodeInstance, nodeData, {
99
                    appDataSource: appServer.AppDataSource,
100
                    databaseEntities: databaseEntities
101
                })
102

103
                return dbResponse
104
            } catch (error) {
105
                return []
106
            }
107
        } else {
108
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Node ${nodeName} not found`)
109
        }
110
    } catch (error) {
111
        throw new InternalFlowiseError(
112
            StatusCodes.INTERNAL_SERVER_ERROR,
113
            `Error: nodesService.getSingleNodeAsyncOptions - ${getErrorMessage(error)}`
114
        )
115
    }
116
}
117

118
// execute custom function node
119
const executeCustomFunction = async (requestBody: any) => {
120
    try {
121
        const appServer = getRunningExpressApp()
122
        const body = requestBody
123
        const functionInputVariables = Object.fromEntries(
124
            [...(body?.javascriptFunction ?? '').matchAll(/\$([a-zA-Z0-9_]+)/g)].map((g) => [g[1], undefined])
125
        )
126
        const nodeData = { inputs: { functionInputVariables, ...body } }
127
        if (Object.prototype.hasOwnProperty.call(appServer.nodesPool.componentNodes, 'customFunction')) {
128
            try {
129
                const nodeInstanceFilePath = appServer.nodesPool.componentNodes['customFunction'].filePath as string
130
                const nodeModule = await import(nodeInstanceFilePath)
131
                const newNodeInstance = new nodeModule.nodeClass()
132

133
                const options: ICommonObject = {
134
                    appDataSource: appServer.AppDataSource,
135
                    databaseEntities,
136
                    logger
137
                }
138

139
                const returnData = await newNodeInstance.init(nodeData, '', options)
140
                const dbResponse = typeof returnData === 'string' ? handleEscapeCharacters(returnData, true) : returnData
141

142
                return dbResponse
143
            } catch (error) {
144
                throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, `Error running custom function: ${error}`)
145
            }
146
        } else {
147
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Node customFunction not found`)
148
        }
149
    } catch (error) {
150
        throw new InternalFlowiseError(
151
            StatusCodes.INTERNAL_SERVER_ERROR,
152
            `Error: nodesService.executeCustomFunction - ${getErrorMessage(error)}`
153
        )
154
    }
155
}
156

157
export default {
158
    getAllNodes,
159
    getNodeByName,
160
    getSingleNodeIcon,
161
    getSingleNodeAsyncOptions,
162
    executeCustomFunction,
163
    getAllNodesForCategory
164
}
165