feat: Adding the mysql and postgresql config part and removin non-using *.txt file.

Author: deadislove

src/infra/database/database.config.ts

@@ -1,16 +1,18 @@
 import { ConfigService } from "@nestjs/config";
 import { TypeOrmModuleOptions } from "@nestjs/typeorm";
 import { SQLiteDatabase } from "./database.sqlite";
+import { PostgresDatabase } from "./database.postgresql";
+import { MySQLDatabase } from "./database.mysql";
 
 export class DatabaseFactory {
     static createDatabaseConnection(dbType: string, configService: ConfigService): TypeOrmModuleOptions {
         switch(dbType) {
             case 'sqlite':
                 return new SQLiteDatabase(configService).getConnection()
-            // case 'postgres':
-            //     return new PostgresDatabase(configService).getConnection()
-            // case 'mysql':
-            //     return new MySQLDatabase(configService).getConnection()
+            case 'postgres':
+                return new PostgresDatabase(configService).getConnection()
+            case 'mysql':
+                return new MySQLDatabase(configService).getConnection()
             default:
                 throw new Error('Unsupported database type')
         }

src/infra/database/database.mysql.ts

@@ -0,0 +1,82 @@
+import { ConfigService } from "@nestjs/config";
+import { TypeOrmModuleOptions } from "@nestjs/typeorm";
+import { join } from 'path';
+import { readdirSync, statSync } from 'fs';
+
+export class MySQLDatabase {
+    constructor(private readonly configService: ConfigService) { }
+
+    getConnection(): TypeOrmModuleOptions {
+        const entities = MySQLDatabase.loadEntities()
+        return {
+            type: 'mysql',
+            host: this.configService.get<string>('DB_HOST', 'localhost'),
+            port: this.configService.get<number>('DB_PORT', 3306),
+            username: this.configService.get<string>('DB_USERNAME', 'root'),
+            password: this.configService.get<string>('DB_PASSWORD', 'password'),
+            database: this.configService.get<string>('DB_NAME', 'database'),
+            entities,
+            synchronize: false, // Set to false in production
+            logging: false, // Disable logging in production
+        }
+    }
+
+    private static loadEntitiesFromDirectory(directoryPath: string): any[] {
+        let entities: any[] = []
+
+        try {
+            const files = readdirSync(directoryPath)
+            files.forEach((file) => {
+                const fullPath = join(directoryPath, file)
+                const fileStat = statSync(fullPath)
+
+                // If it's a directory, recursively look for entities
+                if (fileStat.isDirectory()) {
+                    entities = [...entities, ...this.loadEntitiesFromDirectory(fullPath)]
+                } else if (file.endsWith('.orm-entity.ts') || file.endsWith('.orm-entity.js')) {
+                    // If it matches the entity file format, load it
+                    entities.push(require(fullPath).default)
+                }
+            })
+        } catch (error) {
+            console.error(`Error reading directory ${directoryPath}: `, error)
+        }
+
+        return entities
+    }
+
+    private static loadEntities(): any[] {
+        const rootPath = join(__dirname, '../../')
+
+        console.log('Root path: ', rootPath)
+        const entities: any[] = []
+
+        // Traverse the entire directory, looking for all entities folders
+        const traverseDir = (dir: string) => {
+            const files = readdirSync(dir)
+
+            files.forEach((file) => {
+                const fullPath = join(dir, file)
+                const fileStat = statSync(fullPath)
+
+                if (fileStat.isDirectory()) {
+
+                    if (file.toLowerCase() === 'entities') {
+                        // If it's an entities folder, load the entities inside
+                        const entityFiles = this.loadEntitiesFromDirectory(fullPath)
+
+                        entities.push(...entityFiles)
+                    } else {
+                        traverseDir(fullPath) // If it's not an entities folder, continue recursion
+                    }
+                }
+            })
+        }
+
+        // Start traversing the src or dist folder
+        traverseDir(rootPath)
+
+        console.log('Loaded Entities: ', entities)
+        return entities
+    }
+}

src/infra/database/database.postgresql.ts

@@ -0,0 +1,82 @@
+import { ConfigService } from "@nestjs/config";
+import { TypeOrmModuleOptions } from "@nestjs/typeorm";
+import { join } from 'path';
+import { readdirSync, statSync } from 'fs';
+
+export class PostgresDatabase {
+    constructor(private readonly configService: ConfigService) { }
+
+    getConnection(): TypeOrmModuleOptions {
+        const entities = PostgresDatabase.loadEntities()
+        return {
+            type: 'postgres',
+            host: this.configService.get<string>('DB_HOST', 'localhost'),
+            port: this.configService.get<number>('DB_PORT', 5432),
+            username: this.configService.get<string>('DB_USERNAME', 'user'),
+            password: this.configService.get<string>('DB_PASSWORD', 'password'),
+            database: this.configService.get<string>('DB_NAME', 'my_database'),
+            entities,
+            synchronize: false, // Set to false in production
+            logging: false, // Disable logging in production
+        }
+    }
+
+    private static loadEntitiesFromDirectory(directoryPath: string): any[] {
+        let entities: any[] = []
+
+        try {
+            const files = readdirSync(directoryPath)
+            files.forEach((file) => {
+                const fullPath = join(directoryPath, file)
+                const fileStat = statSync(fullPath)
+
+                // If it's a directory, recursively look for entities
+                if (fileStat.isDirectory()) {
+                    entities = [...entities, ...this.loadEntitiesFromDirectory(fullPath)]
+                } else if (file.endsWith('.orm-entity.ts') || file.endsWith('.orm-entity.js')) {
+                    // If it matches the entity file format, load it
+                    entities.push(require(fullPath).default)
+                }
+            })
+        } catch (error) {
+            console.error(`Error reading directory ${directoryPath}: `, error)
+        }
+
+        return entities
+    }
+
+    private static loadEntities(): any[] {
+        const rootPath = join(__dirname, '../../')
+
+        console.log('Root path: ', rootPath)
+        const entities: any[] = []
+
+        // Traverse the entire directory, looking for all entities folders
+        const traverseDir = (dir: string) => {
+            const files = readdirSync(dir)
+
+            files.forEach((file) => {
+                const fullPath = join(dir, file)
+                const fileStat = statSync(fullPath)
+
+                if (fileStat.isDirectory()) {
+
+                    if (file.toLowerCase() === 'entities') {
+                        // If it's an entities folder, load the entities inside
+                        const entityFiles = this.loadEntitiesFromDirectory(fullPath)
+
+                        entities.push(...entityFiles)
+                    } else {
+                        traverseDir(fullPath) // If it's not an entities folder, continue recursion
+                    }
+                }
+            })
+        }
+
+        // Start traversing the src or dist folder
+        traverseDir(rootPath)
+
+        console.log('Loaded Entities: ', entities)
+        return entities
+    }
+}