Merge pull request #118 from ayomidearegbeshola29-dev/feature/database-module-issue-104

feat: database module for issue #104

Author: memplethee-lab

src/common/database/database.config.spec.ts

@@ -0,0 +1,42 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { DataSource } from "typeorm";
+import { DatabaseConfigService } from "./database.config";
+
+describe("DatabaseConfigService", () => {
+  let service: DatabaseConfigService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [ConfigModule.forRoot({ isGlobal: true, ignoreEnvVars: true })],
+      providers: [DatabaseConfigService],
+    }).compile();
+
+    service = module.get<DatabaseConfigService>(DatabaseConfigService);
+    jest.clearAllMocks();
+  });
+
+  describe("getConnectionOptions", () => {
+    it("returns development config by default", () => {
+      const config = service.getConnectionOptions();
+      expect(config).toBeDefined();
+      expect(config.pool).toBeDefined();
+      expect(config.pool.max).toBeGreaterThan(0);
+    });
+
+    it("returns test config for test environment", () => {
+      process.env.NODE_ENV = "test";
+      const config = service.getConnectionOptions();
+      expect(config.database).toBe(":memory:");
+      process.env.NODE_ENV = "development";
+    });
+  });
+
+  describe("getDataSourceOptions", () => {
+    it("returns TypeORM DataSourceOptions", () => {
+      const options = service.getDataSourceOptions();
+      expect(options).toBeDefined();
+      expect((options as any).pool).toBeDefined();
+    });
+  });
+});

src/common/database/database.config.ts

@@ -0,0 +1,198 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { DataSource, DataSourceOptions } from "typeorm";
+
+export interface ConnectionPoolConfig {
+  max: number;
+  min: number;
+  idleTimeoutMillis: number;
+  connectionTimeoutMillis: number;
+  acquireTimeoutMillis?: number;
+  createTimeoutMillis?: number;
+  destroyTimeoutMillis?: number;
+  reapIntervalMillis?: number;
+  createRetryIntervalMillis?: number;
+}
+
+export interface DatabaseConfig {
+  type: "postgres" | "sqlite";
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database: string;
+  url?: string;
+  pool: ConnectionPoolConfig;
+  ssl?: boolean | { rejectUnauthorized?: boolean };
+  synchronize?: boolean;
+  logging?: boolean | string[];
+  migrations?: string[];
+  entities: string[];
+}
+
+@Injectable()
+export class DatabaseConfigService {
+  private readonly logger = new Logger(DatabaseConfigService.name);
+  private readonly environment: string;
+
+  constructor(private readonly configService: ConfigService) {
+    this.environment = this.configService.get<string>("NODE_ENV") ?? "development";
+  }
+
+  getConnectionOptions(): DatabaseConfig {
+    const configs: Record<string, () => DatabaseConfig> = {
+      development: () => this.getDevelopmentConfig(),
+      staging: () => this.getStagingConfig(),
+      production: () => this.getProductionConfig(),
+      test: () => this.getTestConfig(),
+    };
+
+    const envConfig = configs[this.environment] || configs.development;
+    return envConfig();
+  }
+
+  getDataSourceOptions(): DataSourceOptions {
+    const config = this.getConnectionOptions();
+    return {
+      type: config.type,
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      password: config.password,
+      database: config.database,
+      url: config.url,
+      entities: config.entities,
+      synchronize: config.synchronize,
+      logging: this.getLoggingLevel(config.logging),
+      pool: config.pool,
+      ssl: config.ssl,
+      migrations: config.migrations,
+    } as DataSourceOptions;
+  }
+
+  private getLoggingLevel(
+    logging?: boolean | string[],
+  ): boolean | string[] {
+    if (this.environment === "production") {
+      return ["error", "warn", "migration", "query-slow"];
+    }
+    if (this.environment === "development") {
+      return ["query", "schema", "error", "warn", "migration"];
+    }
+    return logging ?? true;
+  }
+
+  private getDevelopmentConfig(): DatabaseConfig {
+    const databaseUrl = this.configService.get<string>("DATABASE_URL");
+    if (databaseUrl) {
+      return {
+        type: "postgres",
+        url: databaseUrl,
+        database: "alian-structure",
+        pool: {
+          max: 10,
+          min: 2,
+          idleTimeoutMillis: 30000,
+          connectionTimeoutMillis: 10000,
+          acquireTimeoutMillis: 10000,
+          createTimeoutMillis: 5000,
+          destroyTimeoutMillis: 5000,
+          reapIntervalMillis: 10000,
+          createRetryIntervalMillis: 200,
+        },
+        ssl: false,
+        synchronize: false,
+        logging: false,
+        migrations: ["src/migrations/**/*.ts"],
+        entities: ["src/common/database/entities/**/*.entity.ts"],
+      };
+    }
+    return {
+      type: "sqlite",
+      database: "data/dev.db",
+      pool: {
+        max: 5,
+        min: 1,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 10000,
+      },
+      synchronize: true,
+      logging: false,
+      migrations: [],
+      entities: ["src/common/database/entities/**/*.entity.ts"],
+    };
+  }
+
+  private getStagingConfig(): DatabaseConfig {
+    const databaseUrl = this.configService.get<string>("DATABASE_URL");
+    if (!databaseUrl) {
+      throw new Error("DATABASE_URL is required for staging environment");
+    }
+    return {
+      type: "postgres",
+      url: databaseUrl,
+      database: "alian-structure-staging",
+      pool: {
+        max: 20,
+        min: 5,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 5000,
+        acquireTimeoutMillis: 8000,
+        createTimeoutMillis: 5000,
+        destroyTimeoutMillis: 5000,
+        reapIntervalMillis: 5000,
+        createRetryIntervalMillis: 200,
+      },
+      ssl: { rejectUnauthorized: false },
+      synchronize: false,
+      logging: true,
+      migrations: ["src/migrations/**/*.ts"],
+      entities: ["src/common/database/entities/**/*.entity.ts"],
+    };
+  }
+
+  private getProductionConfig(): DatabaseConfig {
+    const databaseUrl = this.configService.get<string>("DATABASE_URL");
+    if (!databaseUrl) {
+      throw new Error("DATABASE_URL is required for production environment");
+    }
+    return {
+      type: "postgres",
+      url: databaseUrl,
+      database: "alian-structure-production",
+      pool: {
+        max: 50,
+        min: 10,
+        idleTimeoutMillis: 60000,
+        connectionTimeoutMillis: 10000,
+        acquireTimeoutMillis: 15000,
+        createTimeoutMillis: 10000,
+        destroyTimeoutMillis: 10000,
+        reapIntervalMillis: 5000,
+        createRetryIntervalMillis: 1000,
+      },
+      ssl: { rejectUnauthorized: true },
+      synchronize: false,
+      logging: true,
+      migrations: ["dist/migrations/**/*.js"],
+      entities: ["dist/common/database/entities/**/*.entity.js"],
+    };
+  }
+
+  private getTestConfig(): DatabaseConfig {
+    return {
+      type: "sqlite",
+      database: ":memory:",
+      pool: {
+        max: 5,
+        min: 1,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 10000,
+      },
+      synchronize: true,
+      logging: false,
+      migrations: [],
+      entities: ["src/common/database/entities/**/*.entity.ts"],
+    };
+  }
+}

src/common/database/database.module.spec.ts

@@ -0,0 +1,21 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { DataSource } from "typeorm";
+import { DatabaseModule } from "./database.module";
+
+describe("DatabaseModule", () => {
+  let moduleRef: TestingModule;
+
+  beforeEach(async () => {
+    moduleRef = await Test.createTestingModule({
+      imports: [],
+    }).compile();
+  });
+
+  afterEach(async () => {
+    await moduleRef.close();
+  });
+
+  it("should compile", () => {
+    expect(moduleRef).toBeDefined();
+  });
+});

src/common/database/database.module.ts

@@ -0,0 +1,61 @@
+import { DynamicModule, Module, Provider } from "@nestjs/common";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
+import { DataSource, DataSourceOptions } from "typeorm";
+import { SnakeNamingStrategy } from "./strategies/snake-naming.strategy";
+
+export const DATABASE_CONFIG = "DATABASE_CONFIG";
+export const DATABASE_DATA_SOURCE = "DATABASE_DATA_SOURCE";
+
+export interface DatabaseModuleOptions {
+  configName?: string;
+}
+
+@Module({})
+export class DatabaseModule {
+  static forRootAsync(options: {
+    imports?: any[];
+    inject?: any[];
+    useFactory: (...args: any[]) => Promise<TypeOrmModuleOptions> | TypeOrmModuleOptions;
+  }): DynamicModule {
+    const dataSourceProvider: Provider = {
+      provide: DATABASE_DATA_SOURCE,
+      useFactory: async (configService: ConfigService) => {
+        const config: TypeOrmModuleOptions = await options.useFactory(configService);
+        const dataSource = new DataSource(config as any);
+        try {
+          await dataSource.initialize();
+        } catch (error) {
+          throw new Error(`Failed to initialize database: ${error.message}`);
+        }
+        return dataSource;
+      },
+      inject: options.inject || [],
+    };
+
+    return {
+      module: DatabaseModule,
+      imports: [
+        ConfigModule,
+        TypeOrmModule.forRootAsync({
+          imports: options.imports || [],
+          inject: options.inject || [],
+          useFactory: options.useFactory,
+        }),
+      ],
+      providers: [dataSourceProvider],
+      exports: [DATABASE_DATA_SOURCE, TypeOrmModule],
+    };
+  }
+
+  static forFeature(options: { entities?: any[]; imports?: any[] }): DynamicModule {
+    return {
+      module: DatabaseModule,
+      imports: [
+        ...(options.imports || []),
+        TypeOrmModule.forFeature(options.entities || []),
+      ],
+      exports: [TypeOrmModule],
+    };
+  }
+}