Is there a way to store my Typeorm data source configuration in a separate variable?

Question

Is there a way to store my Typeorm data source configuration in a separate variable?

I am currently working with NestJS 10 and TypeORM 0.3.17. In my src/config/data-source.ts file, I have the following code snippet...

import * as dotenv from 'dotenv';
import * as dotenvExpand from 'dotenv-expand';
import { DataSource } from 'typeorm';

dotenvExpand.expand(dotenv.config());

export default new DataSource({
  type: 'postgres',
  host: process.env.DATABASE_HOST,
  port: Number(process.env.DATABASE_PORT) || 5432,
  database: process.env.DATABASE_NAME,
  username: process.env.DATABASE_USERNAME,
  password: process.env.DATABASE_PASSWORD,
  entities: ['dist/**/*.entity.js'],
  migrations: ['dist/database/migrations/*.js'],
  extra: {
    charset: 'utf8mb4_unicode_ci',
  },
 });

I am looking to refactor the configuration by separating the arguments into a variable for export in my src/config/typeorm.ts file, which currently contains duplicate code...

import { ConfigModule, ConfigService } from '@nestjs/config';
import {
  TypeOrmModuleAsyncOptions,
  TypeOrmModuleOptions,
} from '@nestjs/typeorm';

export const typeOrmAsyncConfig: TypeOrmModuleAsyncOptions = {
  imports: [ConfigModule],
  inject: [ConfigService],
  useFactory: async (): Promise<TypeOrmModuleOptions> => {
    return {
      type: 'postgres',
      host: process.env.DATABASE_HOST,
      port: Number(process.env.DATABASE_PORT) || 5432,
      database: process.env.DATABASE_NAME,
      username: process.env.DATABASE_USERNAME,
      password: process.env.DATABASE_PASSWORD,
      synchronize: false,
      logging: true,
    };
  },
};

export const typeOrmConfig: TypeOrmModuleOptions = {
    type: 'postgres',
    host: process.env.DB_HOST,
    port: parseInt(process.env.DB_PORT, 10),
    username: process.env.DB_USERNAME,
    database: process.env.DB_NAME,
    password: process.env.DB_PASSWORD,
    entities: ['dist/**/*.entity.js'],
    migrations: ['dist/migrations/**/*.js'],
    extra: {
      charset: 'utf8mb4_unicode_ci',
    },
    logging: true,
};

However, when I try to refactor my src/config/data-source.ts file in the following way...

export const dsConfig = {
    type: 'postgres',
    host: process.env.DATABASE_HOST,
    port: Number(process.env.DATABASE_PORT) || 5432,
    database: process.env.DATABASE_NAME,
    username: process.env.DATABASE_USERNAME,
    password: process.env.DATABASE_PASSWORD,
    entities: ['dist/**/*.entity.js'],
    migrations: ['dist/database/migrations/*.js'],
    extra: {
      charset: 'utf8mb4_unicode_ci',
    },
   };

export default new DataSource(dsConfig);

I encounter the error

Argument of type '{ type: string; host: string; port: number; database: string; username: string; password: string; entities: string[]; migrations: string[]; extra: { charset: string; }; }' is not assignable to parameter of type 'DataSourceOptions'.
  Type '{ type: string; host: string; port: number; database: string; username: string; password: string; entities: string[]; migrations: string[]; extra: { charset: string; }; }' is missing the following properties from type 'AuroraMysqlConnectionOptions': region, secretArn, resourceArn

While trying to export new DataSource(dsConfig). How can I correctly refactor my data source configuration file?

typescript nestjs datasource typeorm

Answer 1

Answer №1

To access the configuration data source file in my repository, simply visit this link. It helps to separate the configuration data in the app.module.ts file:

    TypeOrmModule.forRootAsync(typeOrmAsyncConfig),

Your configuration file should look something like this:

const config: ConfigService = new ConfigService();
const dbConfig = {
type: 'postgres' as const,
  host: config.get<string>('DATABASE_HOST'),
  port: config.get<number>('DATABASE_PORT'),
  database: config.get<string>('DATABASE_NAME'),
  username: config.get<string>('DATABASE_USER'),
  password: config.get<string>('DATABASE_PASS'),
  entities: ['dist/**/*.entity.{ts,js}'],
  migrations: ['dist/migrations/*.{ts,js}'],
  migrationsRun: true,
  migrationsTableName: 'typeorm_migrations',
  synchronize: false,
  ssl: config.get('SSL_MODE', false),
  cli: {
    migrationsDir: 'src/migrations',
  },
  logging: true,
}

export const typeOrmAsyncConfig: TypeOrmModuleAsyncOptions = {
  useFactory: async (): Promise<TypeOrmModuleOptions> => {
    return dbConfig;
  },
};
export default new DataSource(dbConfig);

In your package.json file, ensure the following configurations are set in place:

    "typeorm": "ts-node ./node_modules/typeorm/cli.js -d src/utils/config/database/config.service.ts",
    "migration:generate": "npm run build && npm run typeorm -- migration:generate ./src/migrations/$npm_config_name",
    "migration:run": "npm run typeorm -- migration:run",
    "migration:create": "ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli migration:create ./src/migrations/$npm_config_name",
    "migration:revert": "npm run typeorm -- migration:revert"

Once you have set up the configurations, use the following commands:

npm run migration:generate --name=<your_migration_name> //auto generate migration with entities
npm run migration:create --name=<your_migration_name> //create empty migration file
npm run migration:revert    //revert your last migration
npm run migration:run // in case you set `migrationsRun: false` in your config and run it manually

Answer 2

To access the configuration data source file in my repository, simply visit this link. It helps to separate the configuration data in the app.module.ts file:

    TypeOrmModule.forRootAsync(typeOrmAsyncConfig),

Your configuration file should look something like this:

const config: ConfigService = new ConfigService();
const dbConfig = {
type: 'postgres' as const,
  host: config.get<string>('DATABASE_HOST'),
  port: config.get<number>('DATABASE_PORT'),
  database: config.get<string>('DATABASE_NAME'),
  username: config.get<string>('DATABASE_USER'),
  password: config.get<string>('DATABASE_PASS'),
  entities: ['dist/**/*.entity.{ts,js}'],
  migrations: ['dist/migrations/*.{ts,js}'],
  migrationsRun: true,
  migrationsTableName: 'typeorm_migrations',
  synchronize: false,
  ssl: config.get('SSL_MODE', false),
  cli: {
    migrationsDir: 'src/migrations',
  },
  logging: true,
}

export const typeOrmAsyncConfig: TypeOrmModuleAsyncOptions = {
  useFactory: async (): Promise<TypeOrmModuleOptions> => {
    return dbConfig;
  },
};
export default new DataSource(dbConfig);

In your package.json file, ensure the following configurations are set in place:

    "typeorm": "ts-node ./node_modules/typeorm/cli.js -d src/utils/config/database/config.service.ts",
    "migration:generate": "npm run build && npm run typeorm -- migration:generate ./src/migrations/$npm_config_name",
    "migration:run": "npm run typeorm -- migration:run",
    "migration:create": "ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli migration:create ./src/migrations/$npm_config_name",
    "migration:revert": "npm run typeorm -- migration:revert"

Once you have set up the configurations, use the following commands:

npm run migration:generate --name=<your_migration_name> //auto generate migration with entities
npm run migration:create --name=<your_migration_name> //create empty migration file
npm run migration:revert    //revert your last migration
npm run migration:run // in case you set `migrationsRun: false` in your config and run it manually

Answer 3

Answer №2

In my approach to working with TypeORM and NestJS, I have come up with a straightforward strategy. I utilize named exports for my DataSource instance, create a DatabaseService that implements TypeormOptionsFactory from @nestjs/typeorm, and then return the dataSource options within the createTypeormOptions method.

@Injectable()
export class DatabaseService implements TypeOrmOptionsFactory {
    public createTypeOrmOptions(): TypeOrmModuleOptions {
        return dataSource.options;
    }
}

Following this, I set up a DatabaseModule, configure TypeOrmModule with .forRootAsync, and utilize dataSourceFactory to initialize the DataSource instance.

@Module({
    imports: [
        TypeOrmModule.forRootAsync({
            useClass: DatabaseService,
            dataSourceFactory: async (
                options?: DataSourceOptions,
            ): Promise<DataSource> => {
                if (!options) {
                    throw new Error('No DataSource options provided');
                }

                return dataSource.initialize();
            },
        }),
    ],
})
export class DatabaseModule {}

If you're interested in seeing how this setup works, you can check out my github repository.

Answer 4

In my approach to working with TypeORM and NestJS, I have come up with a straightforward strategy. I utilize named exports for my DataSource instance, create a DatabaseService that implements TypeormOptionsFactory from @nestjs/typeorm, and then return the dataSource options within the createTypeormOptions method.

@Injectable()
export class DatabaseService implements TypeOrmOptionsFactory {
    public createTypeOrmOptions(): TypeOrmModuleOptions {
        return dataSource.options;
    }
}

Following this, I set up a DatabaseModule, configure TypeOrmModule with .forRootAsync, and utilize dataSourceFactory to initialize the DataSource instance.

@Module({
    imports: [
        TypeOrmModule.forRootAsync({
            useClass: DatabaseService,
            dataSourceFactory: async (
                options?: DataSourceOptions,
            ): Promise<DataSource> => {
                if (!options) {
                    throw new Error('No DataSource options provided');
                }

                return dataSource.initialize();
            },
        }),
    ],
})
export class DatabaseModule {}

If you're interested in seeing how this setup works, you can check out my github repository.

Is there a way to store my Typeorm data source configuration in a separate variable?

Answer №1

Answer №2

Similar questions

Can TypeScript support passing named rest arguments within the type declaration?

Transpilation appears to dissect a function

Injecting services with an abstract class is a common practice in Angular library modules

"Creating a sleek and efficient AI chess game using chess.js with Angular's

What could be causing the malfunction of my button's event handlers?

Setting up React Context API with TypeScript: A Step-by-Step Guide

Signing in to a Discord.js account from a React application with Typescript

Add the list of information during the looping process (map)

Issue encountered when transitioning from Angular 8 to Angular 9: Value discrepancy at index 0

Combining individual TypeScript files together

Unlocking the power of module augmentation in Typescript: Enhancing library models within your app domain

Preserve the checkbox state upon refreshing the page

When invoking an external API within a Firebase Cloud Function, it may result in a

Angular 4 Filtering Pipe: Simplify Data Filtering in Angular

Angular2: Error - trying to access 'this.' which is not defined

The implementation of the "setValue" function from react-hook-form resulted in the generation of over 358,000 TypeScript diagnostics for various types

Encountering difficulties importing an NPM library into StackBlitz

Using TypeScript with Watermelondb

"Encountering issues with importing Splitpanes while using VueJs and TypeScript combination

Array of generic types in Typescript