Multiple Database Support

packages/server/.env.example

@@ -2,8 +2,20 @@ PORT=3000
 # FLOWISE_USERNAME=user
 # FLOWISE_PASSWORD=1234
 # DEBUG=true
-# DATABASE_PATH=/your_database_path/.flowise
 # APIKEY_PATH=/your_api_key_path/.flowise
 # LOG_PATH=/your_log_path/logs
 # LOG_LEVEL=debug (error | warn | info | verbose | debug)
 # EXECUTION_MODE=main (child | main)
+
+OVERRIDE_DATABASE="true"
+DATABASE_TYPE="sqlite" # sqlite, mysql, postgres
+
+# When database is sqlite
+# DATABASE_PATH=/your_database_path/.flowise
+
+# When database is not sqlite
+# DATABASE_PORT="3306"
+# DATABASE_HOST="127.0.0.1"
+# DATABASE_NAME="flowise"
+# DATABASE_USER="root"
+# DATABASE_PASSWORD="atish123"

packages/server/README.md

@@ -41,9 +41,16 @@ Flowise support different environment variables to configure your instance. You
 | DEBUG            | Print logs from components                                       | Boolean                                          |
 | LOG_PATH         | Location where log files are stored                              | String                                           | `your-path/Flowise/logs`            |
 | LOG_LEVEL        | Different levels of logs                                         | Enum String: `error`, `info`, `verbose`, `debug` | `info`                              |
-| DATABASE_PATH    | Location where database is saved                                 | String                                           | `your-home-dir/.flowise`            |
 | APIKEY_PATH      | Location where api keys are saved                                | String                                           | `your-path/Flowise/packages/server` |
 | EXECUTION_MODE   | Whether predictions run in their own process or the main process | Enum String: `child`, `main`                     | `main`                              |
+| OVERRIDE_DATABASE| Override current database with default                           | Enum String: `true`, `false`                     | `true`                              |
+| DATABASE_TYPE    | Type of database to store the flowise data                       | Enum String: `sqlite`, `mysql`, `postgres`       | `sqlite`                            |
+| DATABASE_PATH    | Location where database is saved (When DATABASE_TYPE is sqlite)  | String                                           | `your-home-dir/.flowise`            |
+| DATABASE_HOST    | Host URL or IP address (When DATABASE_TYPE is not sqlite)        | String                                           |                                     |
+| DATABASE_PORT    | Database port (When DATABASE_TYPE is not sqlite)                 | String                                           |                                     |
+| DATABASE_USERNAME| Database username (When DATABASE_TYPE is not sqlite)             | String                                           |                                     |
+| DATABASE_PASSWORD| Database password (When DATABASE_TYPE is not sqlite)             | String                                           |                                     |
+| DATABASE_NAME    | Database name (When DATABASE_TYPE is not sqlite)                 | String                                           |                                     |
 
 You can also specify the env variables when using `npx`. For example:
 

packages/server/package.json

@@ -55,6 +55,8 @@
         "flowise-ui": "*",
         "moment-timezone": "^0.5.34",
         "multer": "^1.4.5-lts.1",
+        "mysql": "^2.18.1",
+        "pg": "^8.11.1",
         "reflect-metadata": "^0.1.13",
         "socket.io": "^4.6.1",
         "sqlite3": "^5.1.6",

packages/server/src/ChildProcess.ts

@@ -142,14 +142,58 @@ export class ChildProcess {
  * @returns {DataSource}
  */
 async function initDB() {
-    const homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
+    let childAppDataSource;
-    const childAppDataSource = new DataSource({
+    let homePath;
-        type: 'sqlite',
+    switch (process.env.DATABASE_TYPE) {
-        database: path.resolve(homePath, 'database.sqlite'),
+        case 'sqlite':
-        synchronize: true,
+            homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
-        entities: [ChatFlow, ChatMessage, Tool],
+            childAppDataSource = new DataSource({
-        migrations: []
+                type: 'sqlite',
-    })
+                database: path.resolve(homePath, 'database.sqlite'),
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        case 'mysql':
+            childAppDataSource = new DataSource({
+                type: 'mysql',
+                host: process.env.DATABASE_HOST,
+                port: parseInt(process.env.DATABASE_PORT || '3306'),
+                username: process.env.DATABASE_USER,
+                password: process.env.DATABASE_PASSWORD,
+                database: process.env.DATABASE_NAME,
+                charset: 'utf8mb4',
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        case 'postgres':
+            childAppDataSource = new DataSource({
+                type: 'postgres',
+                host: process.env.DATABASE_HOST,
+                port: parseInt(process.env.DATABASE_PORT || '5432'),
+                username: process.env.DATABASE_USER,
+                password: process.env.DATABASE_PASSWORD,
+                database: process.env.DATABASE_NAME,
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        default:
+            homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
+            childAppDataSource = new DataSource({
+                type: 'sqlite',
+                database: path.resolve(homePath, 'database.sqlite'),
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+    }
+
     return await childAppDataSource.initialize()
 }
 

packages/server/src/DataSource.ts

@@ -9,15 +9,56 @@ import { getUserHome } from './utils'
 let appDataSource: DataSource
 
 export const init = async (): Promise<void> => {
-    const homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
+    let homePath;
-
+    switch (process.env.DATABASE_TYPE) {
-    appDataSource = new DataSource({
+        case 'sqlite':
-        type: 'sqlite',
+            homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
-        database: path.resolve(homePath, 'database.sqlite'),
+            appDataSource = new DataSource({
-        synchronize: true,
+                type: 'sqlite',
-        entities: [ChatFlow, ChatMessage, Tool],
+                database: path.resolve(homePath, 'database.sqlite'),
-        migrations: []
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
-    })
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        case 'mysql':
+            appDataSource = new DataSource({
+                type: 'mysql',
+                host: process.env.DATABASE_HOST,
+                port: parseInt(process.env.DATABASE_PORT || '3306'),
+                username: process.env.DATABASE_USER,
+                password: process.env.DATABASE_PASSWORD,
+                database: process.env.DATABASE_NAME,
+                charset: 'utf8mb4',
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        case 'postgres':
+            appDataSource = new DataSource({
+                type: 'postgres',
+                host: process.env.DATABASE_HOST,
+                port: parseInt(process.env.DATABASE_PORT || '5432'),
+                username: process.env.DATABASE_USER,
+                password: process.env.DATABASE_PASSWORD,
+                database: process.env.DATABASE_NAME,
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+        default:
+            homePath = process.env.DATABASE_PATH ?? path.join(getUserHome(), '.flowise')
+            appDataSource = new DataSource({
+                type: 'sqlite',
+                database: path.resolve(homePath, 'database.sqlite'),
+                synchronize: (process.env.OVERRIDE_DATABASE == 'true'),
+                entities: [ChatFlow, ChatMessage, Tool],
+                migrations: []
+            })
+            break;
+    }
 }
 
 export function getDataSource(): DataSource {

packages/server/src/entity/ChatFlow.ts

@@ -10,7 +10,7 @@ export class ChatFlow implements IChatFlow {
     @Column()
     name: string
 
-    @Column()
+    @Column({ type: "text" })
     flowData: string
 
     @Column({ nullable: true })

packages/server/src/entity/ChatMessage.ts

@@ -14,7 +14,7 @@ export class ChatMessage implements IChatMessage {
     @Column()
     chatflowid: string
 
-    @Column()
+    @Column({ type: "text" })
     content: string
 
     @Column({ nullable: true })

packages/server/src/entity/Tool.ts

@@ -10,7 +10,7 @@ export class Tool implements ITool {
     @Column()
     name: string
 
-    @Column()
+    @Column({ type: "text" })
     description: string
 
     @Column()