Flowise

1
import { omit } from 'lodash'
2
import { StatusCodes } from 'http-status-codes'
3
import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
4
import { Credential } from '../../database/entities/Credential'
5
import { transformToCredentialEntity, decryptCredentialData } from '../../utils'
6
import { ICredentialReturnResponse } from '../../Interface'
7
import { InternalFlowiseError } from '../../errors/internalFlowiseError'
8
import { getErrorMessage } from '../../errors/utils'
9

10
const createCredential = async (requestBody: any) => {
11
    try {
12
        const appServer = getRunningExpressApp()
13
        const newCredential = await transformToCredentialEntity(requestBody)
14
        const credential = await appServer.AppDataSource.getRepository(Credential).create(newCredential)
15
        const dbResponse = await appServer.AppDataSource.getRepository(Credential).save(credential)
16
        return dbResponse
17
    } catch (error) {
18
        throw new InternalFlowiseError(
19
            StatusCodes.INTERNAL_SERVER_ERROR,
20
            `Error: credentialsService.createCredential - ${getErrorMessage(error)}`
21
        )
22
    }
23
}
24

25
// Delete all credentials from chatflowid
26
const deleteCredentials = async (credentialId: string): Promise<any> => {
27
    try {
28
        const appServer = getRunningExpressApp()
29
        const dbResponse = await appServer.AppDataSource.getRepository(Credential).delete({ id: credentialId })
30
        if (!dbResponse) {
31
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Credential ${credentialId} not found`)
32
        }
33
        return dbResponse
34
    } catch (error) {
35
        throw new InternalFlowiseError(
36
            StatusCodes.INTERNAL_SERVER_ERROR,
37
            `Error: credentialsService.deleteCredential - ${getErrorMessage(error)}`
38
        )
39
    }
40
}
41

42
const getAllCredentials = async (paramCredentialName: any) => {
43
    try {
44
        const appServer = getRunningExpressApp()
45
        let dbResponse = []
46
        if (paramCredentialName) {
47
            if (Array.isArray(paramCredentialName)) {
48
                for (let i = 0; i < paramCredentialName.length; i += 1) {
49
                    const name = paramCredentialName[i] as string
50
                    const credentials = await appServer.AppDataSource.getRepository(Credential).findBy({
51
                        credentialName: name
52
                    })
53
                    dbResponse.push(...credentials)
54
                }
55
            } else {
56
                const credentials = await appServer.AppDataSource.getRepository(Credential).findBy({
57
                    credentialName: paramCredentialName as string
58
                })
59
                dbResponse = [...credentials]
60
            }
61
        } else {
62
            const credentials = await appServer.AppDataSource.getRepository(Credential).find()
63
            for (const credential of credentials) {
64
                dbResponse.push(omit(credential, ['encryptedData']))
65
            }
66
        }
67
        return dbResponse
68
    } catch (error) {
69
        throw new InternalFlowiseError(
70
            StatusCodes.INTERNAL_SERVER_ERROR,
71
            `Error: credentialsService.getAllCredentials - ${getErrorMessage(error)}`
72
        )
73
    }
74
}
75

76
const getCredentialById = async (credentialId: string): Promise<any> => {
77
    try {
78
        const appServer = getRunningExpressApp()
79
        const credential = await appServer.AppDataSource.getRepository(Credential).findOneBy({
80
            id: credentialId
81
        })
82
        if (!credential) {
83
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Credential ${credentialId} not found`)
84
        }
85
        // Decrpyt credentialData
86
        const decryptedCredentialData = await decryptCredentialData(
87
            credential.encryptedData,
88
            credential.credentialName,
89
            appServer.nodesPool.componentCredentials
90
        )
91
        const returnCredential: ICredentialReturnResponse = {
92
            ...credential,
93
            plainDataObj: decryptedCredentialData
94
        }
95
        const dbResponse = omit(returnCredential, ['encryptedData'])
96
        return dbResponse
97
    } catch (error) {
98
        throw new InternalFlowiseError(
99
            StatusCodes.INTERNAL_SERVER_ERROR,
100
            `Error: credentialsService.createCredential - ${getErrorMessage(error)}`
101
        )
102
    }
103
}
104

105
const updateCredential = async (credentialId: string, requestBody: any): Promise<any> => {
106
    try {
107
        const appServer = getRunningExpressApp()
108
        const credential = await appServer.AppDataSource.getRepository(Credential).findOneBy({
109
            id: credentialId
110
        })
111
        if (!credential) {
112
            throw new InternalFlowiseError(StatusCodes.NOT_FOUND, `Credential ${credentialId} not found`)
113
        }
114
        const decryptedCredentialData = await decryptCredentialData(credential.encryptedData)
115
        requestBody.plainDataObj = { ...decryptedCredentialData, ...requestBody.plainDataObj }
116
        const updateCredential = await transformToCredentialEntity(requestBody)
117
        await appServer.AppDataSource.getRepository(Credential).merge(credential, updateCredential)
118
        const dbResponse = await appServer.AppDataSource.getRepository(Credential).save(credential)
119
        return dbResponse
120
    } catch (error) {
121
        throw new InternalFlowiseError(
122
            StatusCodes.INTERNAL_SERVER_ERROR,
123
            `Error: credentialsService.updateCredential - ${getErrorMessage(error)}`
124
        )
125
    }
126
}
127

128
export default {
129
    createCredential,
130
    deleteCredentials,
131
    getAllCredentials,
132
    getCredentialById,
133
    updateCredential
134
}
135