Flowise

1
import { Request, Response, NextFunction } from 'express'
2
import chatflowsService from '../../services/chatflows'
3
import { ChatFlow } from '../../database/entities/ChatFlow'
4
import { createRateLimiter } from '../../utils/rateLimit'
5
import { getApiKey } from '../../utils/apiKey'
6
import { InternalFlowiseError } from '../../errors/internalFlowiseError'
7
import { StatusCodes } from 'http-status-codes'
8

9
const checkIfChatflowIsValidForStreaming = async (req: Request, res: Response, next: NextFunction) => {
10
    try {
11
        if (typeof req.params === 'undefined' || !req.params.id) {
12
            throw new InternalFlowiseError(
13
                StatusCodes.PRECONDITION_FAILED,
14
                `Error: chatflowsRouter.checkIfChatflowIsValidForStreaming - id not provided!`
15
            )
16
        }
17
        const apiResponse = await chatflowsService.checkIfChatflowIsValidForStreaming(req.params.id)
18
        return res.json(apiResponse)
19
    } catch (error) {
20
        next(error)
21
    }
22
}
23

24
const checkIfChatflowIsValidForUploads = async (req: Request, res: Response, next: NextFunction) => {
25
    try {
26
        if (typeof req.params === 'undefined' || !req.params.id) {
27
            throw new InternalFlowiseError(
28
                StatusCodes.PRECONDITION_FAILED,
29
                `Error: chatflowsRouter.checkIfChatflowIsValidForUploads - id not provided!`
30
            )
31
        }
32
        const apiResponse = await chatflowsService.checkIfChatflowIsValidForUploads(req.params.id)
33
        return res.json(apiResponse)
34
    } catch (error) {
35
        next(error)
36
    }
37
}
38

39
const deleteChatflow = async (req: Request, res: Response, next: NextFunction) => {
40
    try {
41
        if (typeof req.params === 'undefined' || !req.params.id) {
42
            throw new InternalFlowiseError(StatusCodes.PRECONDITION_FAILED, `Error: chatflowsRouter.deleteChatflow - id not provided!`)
43
        }
44
        const apiResponse = await chatflowsService.deleteChatflow(req.params.id)
45
        return res.json(apiResponse)
46
    } catch (error) {
47
        next(error)
48
    }
49
}
50

51
const getAllChatflows = async (req: Request, res: Response, next: NextFunction) => {
52
    try {
53
        const apiResponse = await chatflowsService.getAllChatflows()
54
        return res.json(apiResponse)
55
    } catch (error) {
56
        next(error)
57
    }
58
}
59

60
// Get specific chatflow via api key
61
const getChatflowByApiKey = async (req: Request, res: Response, next: NextFunction) => {
62
    try {
63
        if (typeof req.params === 'undefined' || !req.params.apiKey) {
64
            throw new InternalFlowiseError(
65
                StatusCodes.PRECONDITION_FAILED,
66
                `Error: chatflowsRouter.getChatflowByApiKey - apiKey not provided!`
67
            )
68
        }
69
        const apiKey = await getApiKey(req.params.apiKey)
70
        if (!apiKey) {
71
            return res.status(401).send('Unauthorized')
72
        }
73
        const apiResponse = await chatflowsService.getChatflowByApiKey(apiKey.id)
74
        return res.json(apiResponse)
75
    } catch (error) {
76
        next(error)
77
    }
78
}
79

80
const getChatflowById = async (req: Request, res: Response, next: NextFunction) => {
81
    try {
82
        if (typeof req.params === 'undefined' || !req.params.id) {
83
            throw new InternalFlowiseError(StatusCodes.PRECONDITION_FAILED, `Error: chatflowsRouter.getChatflowById - id not provided!`)
84
        }
85
        const apiResponse = await chatflowsService.getChatflowById(req.params.id)
86
        return res.json(apiResponse)
87
    } catch (error) {
88
        next(error)
89
    }
90
}
91

92
const saveChatflow = async (req: Request, res: Response, next: NextFunction) => {
93
    try {
94
        if (!req.body) {
95
            throw new InternalFlowiseError(StatusCodes.PRECONDITION_FAILED, `Error: chatflowsRouter.saveChatflow - body not provided!`)
96
        }
97
        const body = req.body
98
        const newChatFlow = new ChatFlow()
99
        Object.assign(newChatFlow, body)
100
        const apiResponse = await chatflowsService.saveChatflow(newChatFlow)
101
        return res.json(apiResponse)
102
    } catch (error) {
103
        next(error)
104
    }
105
}
106

107
const updateChatflow = async (req: Request, res: Response, next: NextFunction) => {
108
    try {
109
        if (typeof req.params === 'undefined' || !req.params.id) {
110
            throw new InternalFlowiseError(StatusCodes.PRECONDITION_FAILED, `Error: chatflowsRouter.updateChatflow - id not provided!`)
111
        }
112
        const chatflow = await chatflowsService.getChatflowById(req.params.id)
113
        if (!chatflow) {
114
            return res.status(404).send(`Chatflow ${req.params.id} not found`)
115
        }
116

117
        const body = req.body
118
        const updateChatFlow = new ChatFlow()
119
        Object.assign(updateChatFlow, body)
120

121
        updateChatFlow.id = chatflow.id
122
        createRateLimiter(updateChatFlow)
123

124
        const apiResponse = await chatflowsService.updateChatflow(chatflow, updateChatFlow)
125
        return res.json(apiResponse)
126
    } catch (error) {
127
        next(error)
128
    }
129
}
130

131
const getSinglePublicChatflow = async (req: Request, res: Response, next: NextFunction) => {
132
    try {
133
        if (typeof req.params === 'undefined' || !req.params.id) {
134
            throw new InternalFlowiseError(
135
                StatusCodes.PRECONDITION_FAILED,
136
                `Error: chatflowsRouter.getSinglePublicChatflow - id not provided!`
137
            )
138
        }
139
        const apiResponse = await chatflowsService.getSinglePublicChatflow(req.params.id)
140
        return res.json(apiResponse)
141
    } catch (error) {
142
        next(error)
143
    }
144
}
145

146
const getSinglePublicChatbotConfig = async (req: Request, res: Response, next: NextFunction) => {
147
    try {
148
        if (typeof req.params === 'undefined' || !req.params.id) {
149
            throw new InternalFlowiseError(
150
                StatusCodes.PRECONDITION_FAILED,
151
                `Error: chatflowsRouter.getSinglePublicChatbotConfig - id not provided!`
152
            )
153
        }
154
        const apiResponse = await chatflowsService.getSinglePublicChatbotConfig(req.params.id)
155
        return res.json(apiResponse)
156
    } catch (error) {
157
        next(error)
158
    }
159
}
160

161
export default {
162
    checkIfChatflowIsValidForStreaming,
163
    checkIfChatflowIsValidForUploads,
164
    deleteChatflow,
165
    getAllChatflows,
166
    getChatflowByApiKey,
167
    getChatflowById,
168
    saveChatflow,
169
    updateChatflow,
170
    getSinglePublicChatflow,
171
    getSinglePublicChatbotConfig
172
}
173