Flowise

1
import 'reflect-metadata'
2
import path from 'path'
3
import * as fs from 'fs'
4
import { DataSource } from 'typeorm'
5
import { getUserHome } from './utils'
6
import { entities } from './database/entities'
7
import { sqliteMigrations } from './database/migrations/sqlite'
8
import { mysqlMigrations } from './database/migrations/mysql'
9
import { postgresMigrations } from './database/migrations/postgres'
10

11
let appDataSource: DataSource
12

13
export const init = async (): Promise<void> => {
14
    let homePath
15
    let flowisePath = path.join(getUserHome(), '.flowise')
16
    if (!fs.existsSync(flowisePath)) {
17
        fs.mkdirSync(flowisePath)
18
    }
19
    switch (process.env.DATABASE_TYPE) {
20
        case 'sqlite':
21
            homePath = process.env.DATABASE_PATH ?? flowisePath
22
            appDataSource = new DataSource({
23
                type: 'sqlite',
24
                database: path.resolve(homePath, 'database.sqlite'),
25
                synchronize: false,
26
                migrationsRun: false,
27
                entities: Object.values(entities),
28
                migrations: sqliteMigrations
29
            })
30
            break
31
        case 'mysql':
32
            appDataSource = new DataSource({
33
                type: 'mysql',
34
                host: process.env.DATABASE_HOST,
35
                port: parseInt(process.env.DATABASE_PORT || '3306'),
36
                username: process.env.DATABASE_USER,
37
                password: process.env.DATABASE_PASSWORD,
38
                database: process.env.DATABASE_NAME,
39
                charset: 'utf8mb4',
40
                synchronize: false,
41
                migrationsRun: false,
42
                entities: Object.values(entities),
43
                migrations: mysqlMigrations,
44
                ssl: getDatabaseSSLFromEnv()
45
            })
46
            break
47
        case 'postgres':
48
            appDataSource = new DataSource({
49
                type: 'postgres',
50
                host: process.env.DATABASE_HOST,
51
                port: parseInt(process.env.DATABASE_PORT || '5432'),
52
                username: process.env.DATABASE_USER,
53
                password: process.env.DATABASE_PASSWORD,
54
                database: process.env.DATABASE_NAME,
55
                ssl: getDatabaseSSLFromEnv(),
56
                synchronize: false,
57
                migrationsRun: false,
58
                entities: Object.values(entities),
59
                migrations: postgresMigrations
60
            })
61
            break
62
        default:
63
            homePath = process.env.DATABASE_PATH ?? flowisePath
64
            appDataSource = new DataSource({
65
                type: 'sqlite',
66
                database: path.resolve(homePath, 'database.sqlite'),
67
                synchronize: false,
68
                migrationsRun: false,
69
                entities: Object.values(entities),
70
                migrations: sqliteMigrations
71
            })
72
            break
73
    }
74
}
75

76
export function getDataSource(): DataSource {
77
    if (appDataSource === undefined) {
78
        init()
79
    }
80
    return appDataSource
81
}
82

83
const getDatabaseSSLFromEnv = () => {
84
    if (process.env.DATABASE_SSL_KEY_BASE64) {
85
        return {
86
            rejectUnauthorized: false,
87
            ca: Buffer.from(process.env.DATABASE_SSL_KEY_BASE64, 'base64')
88
        }
89
    } else if (process.env.DATABASE_SSL === 'true') {
90
        return true
91
    }
92
    return undefined
93
}
94