cl-generate/src/lib/commands/setup-postgres.js

A cross-platform CLI tool to generate NestJS clean architecture modules

#!/usr/bin/env node

const fs = require("fs").promises;
const path = require("path");
const { promisify } = require("util");
const exec = promisify(require("child_process").exec);

const {
  COLORS,
  DOMAIN_DIR,
  INFRASTRUCTURE_DIR,
} = require("../constants/index");
const createFile = require("../shares/createFile");
const createDir = require("../shares/createDir");
const { withLoading } = require("../shares/loadingSpinner");

// [Content remains unchanged until module.exports]
const EnvConfigModuleContent = `
import { Module } from '@nestjs/common';
import { EnvironmentConfigService } from './environment-config.service';
import { ConfigService } from '@nestjs/config';

@Module({
  providers: [EnvironmentConfigService, ConfigService],
  exports: [EnvironmentConfigService],
})
export class EnvironmentConfigModule {}\n
`;

const EnvConfigServiceContent = `
import { Injectable } from '@nestjs/common';
import { DatabaseConfigInterface } from '@domain/config/databaseConfig.interface';
import { ConfigService } from '@nestjs/config';
import * as dotenv from 'dotenv';
dotenv.config();

@Injectable()
export class EnvironmentConfigService implements DatabaseConfigInterface {
  constructor(private readonly configService: ConfigService) {}

  getDBHost(): string {
    return this.configService.get<string>('DATABASE_HOST') ?? '';
  }
  getDBName(): string {
    return this.configService.get<string>('DATABASE_DB') ?? '';
  }
  getDBPort(): number {
    return this.configService.get<number>('DATABASE_PORT') ?? 5432;
  }
  getDBUser(): string {
    return this.configService.get<string>('DATABASE_USER') ?? '';
  }
  getDBPass(): string {
    return this.configService.get<string>('DATABASE_PASSWORD') ?? '';
  }
}
`;

const TypeOrmModuleContent = `
import { Module } from '@nestjs/common';
import { EnvironmentConfigService } from '../environment-config/environment-config.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { EnvironmentConfigModule } from '../environment-config/environment-config.module';
import * as dotenv from 'dotenv';
dotenv.config();

export const getTypeOrmModuleOptions = (
  config: EnvironmentConfigService,
): any => ({
  type: 'postgres',
  host: config.getDBHost(),
  port: config.getDBPort(),
  username: config.getDBUser(),
  password: config.getDBPass(),
  database: config.getDBName(),
  entities: [],
  synchronize: true,
});

@Module({
  imports: [
    TypeOrmModule.forRootAsync({
      imports: [EnvironmentConfigModule],
      inject: [EnvironmentConfigService],
      useFactory: getTypeOrmModuleOptions,
    }),
  ],
})
export class TypeOrmConfigModule {}
`;

module.exports = async function setupPostgres(packageManager = "npm") {
  try {
    const configSubDirs = ["environment-config", "typeorm"];

    await withLoading("Creating configuration files", async () => {
      await createFile(
        path.join(DOMAIN_DIR, "config", "databaseConfig.interface.ts"),
        `
  /* eslint-disable prettier/prettier */
  export interface DatabaseConfigInterface {
  getDBHost(): string;
  getDBName(): string;
  getDBPort(): number;
  getDBUser(): string;
  getDBPass(): string;
}
  `
      );

      for (const dir of configSubDirs) {
        await createDir(path.join(INFRASTRUCTURE_DIR, "config", dir));
      }

      const files = {
        "config/environment-config/environment-config.module.ts":
          EnvConfigModuleContent,
        "config/environment-config/environment-config.service.ts":
          EnvConfigServiceContent,
        "config/typeorm/typeorm.module.ts": TypeOrmModuleContent,
      };

      for (const [filePath, content] of Object.entries(files)) {
        await createFile(path.join(INFRASTRUCTURE_DIR, filePath), content);
      }
    });

    await withLoading("Installing dependencies", async () => {
      await exec(
        `${packageManager} ${
          packageManager === "yarn" ? "add" : "install"
        } @nestjs/typeorm typeorm pg --save`,
        {
          stdio: "inherit",
        }
      );
    });

    console.log(
      `${COLORS.GREEN}✓ Postgres setup completed successfully${COLORS.NC}`
    );
  } catch (error) {
    console.log(
      `${COLORS.YELLOW}⚠ Can not setup postgres: ${error.message}${COLORS.NC}`
    );
    throw error;
  }
};