Flowise

1
import { FindOptionsWhere } from 'typeorm'
2
import { StatusCodes } from 'http-status-codes'
3
import { chatType, IChatMessage } from '../../Interface'
4
import { utilGetChatMessage } from '../../utils/getChatMessage'
5
import { utilAddChatMessage } from '../../utils/addChatMesage'
6
import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
7
import { ChatMessageFeedback } from '../../database/entities/ChatMessageFeedback'
8
import { removeFilesFromStorage } from 'flowise-components'
9
import logger from '../../utils/logger'
10
import { ChatMessage } from '../../database/entities/ChatMessage'
11
import { InternalFlowiseError } from '../../errors/internalFlowiseError'
12
import { getErrorMessage } from '../../errors/utils'
13

14
// Add chatmessages for chatflowid
15
const createChatMessage = async (chatMessage: Partial<IChatMessage>) => {
16
    try {
17
        const dbResponse = await utilAddChatMessage(chatMessage)
18
        return dbResponse
19
    } catch (error) {
20
        throw new InternalFlowiseError(
21
            StatusCodes.INTERNAL_SERVER_ERROR,
22
            `Error: chatMessagesService.createChatMessage - ${getErrorMessage(error)}`
23
        )
24
    }
25
}
26

27
// Get all chatmessages from chatflowid
28
const getAllChatMessages = async (
29
    chatflowId: string,
30
    chatTypeFilter: chatType | undefined,
31
    sortOrder: string = 'ASC',
32
    chatId?: string,
33
    memoryType?: string,
34
    sessionId?: string,
35
    startDate?: string,
36
    endDate?: string,
37
    messageId?: string,
38
    feedback?: boolean
39
): Promise<any> => {
40
    try {
41
        const dbResponse = await utilGetChatMessage(
42
            chatflowId,
43
            chatTypeFilter,
44
            sortOrder,
45
            chatId,
46
            memoryType,
47
            sessionId,
48
            startDate,
49
            endDate,
50
            messageId,
51
            feedback
52
        )
53
        return dbResponse
54
    } catch (error) {
55
        throw new InternalFlowiseError(
56
            StatusCodes.INTERNAL_SERVER_ERROR,
57
            `Error: chatMessagesService.getAllChatMessages - ${getErrorMessage(error)}`
58
        )
59
    }
60
}
61

62
// Get internal chatmessages from chatflowid
63
const getAllInternalChatMessages = async (
64
    chatflowId: string,
65
    chatTypeFilter: chatType | undefined,
66
    sortOrder: string = 'ASC',
67
    chatId?: string,
68
    memoryType?: string,
69
    sessionId?: string,
70
    startDate?: string,
71
    endDate?: string,
72
    messageId?: string,
73
    feedback?: boolean
74
): Promise<any> => {
75
    try {
76
        const dbResponse = await utilGetChatMessage(
77
            chatflowId,
78
            chatTypeFilter,
79
            sortOrder,
80
            chatId,
81
            memoryType,
82
            sessionId,
83
            startDate,
84
            endDate,
85
            messageId,
86
            feedback
87
        )
88
        return dbResponse
89
    } catch (error) {
90
        throw new InternalFlowiseError(
91
            StatusCodes.INTERNAL_SERVER_ERROR,
92
            `Error: chatMessagesService.getAllInternalChatMessages - ${getErrorMessage(error)}`
93
        )
94
    }
95
}
96

97
const removeAllChatMessages = async (chatId: string, chatflowid: string, deleteOptions: FindOptionsWhere<ChatMessage>): Promise<any> => {
98
    try {
99
        const appServer = getRunningExpressApp()
100

101
        // Remove all related feedback records
102
        const feedbackDeleteOptions: FindOptionsWhere<ChatMessageFeedback> = { chatId }
103
        await appServer.AppDataSource.getRepository(ChatMessageFeedback).delete(feedbackDeleteOptions)
104

105
        // Delete all uploads corresponding to this chatflow/chatId
106
        if (chatId) {
107
            try {
108
                await removeFilesFromStorage(chatflowid, chatId)
109
            } catch (e) {
110
                logger.error(`[server]: Error deleting file storage for chatflow ${chatflowid}, chatId ${chatId}: ${e}`)
111
            }
112
        }
113
        const dbResponse = await appServer.AppDataSource.getRepository(ChatMessage).delete(deleteOptions)
114
        return dbResponse
115
    } catch (error) {
116
        throw new InternalFlowiseError(
117
            StatusCodes.INTERNAL_SERVER_ERROR,
118
            `Error: chatMessagesService.removeAllChatMessages - ${getErrorMessage(error)}`
119
        )
120
    }
121
}
122

123
export default {
124
    createChatMessage,
125
    getAllChatMessages,
126
    getAllInternalChatMessages,
127
    removeAllChatMessages
128
}
129