How to use the @nestjs/typeorm.TypeOrmModule.forRoot function in @nestjs/typeorm

import { Invitation } from './invitaions/invitaions.entity';
import { MemberService } from './members/members.service';
import { RedisService } from './redis/redis.service';
import { DateScalar } from './scalars';
import { ChannelEventResolver } from './events/events.resolver';
import { EventService } from './events/events.service';
import { MediaService } from './media/media.service';
import { MediaResolver } from './media/media.resolver';
import { Media } from './media/media.entity';
import { MediaController } from './media/media.controller';
import { AuthResolver } from './auth/auth.resolver';
import { RandomService } from './random/random.service';

const imports = [
  PassportModule.register({ defaultStrategy: 'jwt' }),
  TypeOrmModule.forRoot({
    type: 'postgres',
    host: POSTGRES_HOST,
    port: POSTGRES_PORT,
    username: POSTGRES_USERNAME,
    password: POSTGRES_PASSWORD,
    database: POSTGRES_DATABASE,
    entities: [__dirname + '/**/*.entity{.ts,.js}'],
    synchronize: true,
  }),
  GraphQLModule.forRoot({
    autoSchemaFile: '../schema.graphql',
    // GraphQL Subscriptions authentication https://github.com/nestjs/docs.nestjs.com/issues/394
    context: ({ req, connection }) => (connection ? { req: { headers: connection.context } } : { req }),
    installSubscriptionHandlers: true,
    debug: DEBUG,
  }),

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Connection } from 'typeorm';
import { ProductModule } from './product/product.module';
import { HealthModule } from './health/health.module';
import { LoggerModule } from './logger/logger.module';
import { RedisModule } from './redis/redis.module';
import { ElasticSearchModule } from './elasticsearch/elasticsearch.module';
import { UserModule } from './user/user.module';
import { ConfigModule } from './config/config.module';
import { ConfigService } from './config/config.service';

@Module({
  imports: [
    TypeOrmModule.forRoot(),
    HealthModule,
    ConfigModule,
    // RedisModule,
    // ElasticSearchModule.registerAsync({
    //   imports:[ConfigModule],
    //   useFactory:async (ConfigService:ConfigService)=>(ConfigService.getESConfig()),
    //   inject:[ConfigService]
    // }), 
    LoggerModule,
    UserModule,
    ProductModule
  ],
  controllers: [
    AppController 
  ],
  providers: []

import { Inject, Module, OnModuleInit } from '@nestjs/common';
import { ModulesContainer } from '@nestjs/core/injector/modules-container';
import { MetadataScanner } from '@nestjs/core/metadata-scanner';
import { InjectRepository, TypeOrmModule } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

import { PERMISSION_DEFINITION } from './decorators/permission.decorator.test';
import { RESOURCE_DEFINITION } from './decorators/resource.decorator.test';
import { Permission } from './entities/permission.entity';
import { Resource } from './entities/resource.entity';
import { UserModule } from './modules/user.module';

@Module({
    imports: [
        TypeOrmModule.forFeature([Resource, Permission]),
        TypeOrmModule.forRoot({
            type: 'postgres',
            host: 'localhost',
            port: 5432,
            username: 'postgres',
            password: '123456',
            database: 'postgres',
            entities: [__dirname + '/./*/*.entity.ts'],
            synchronize: true,
            dropSchema: true,
            logging: true
        }),
        UserModule
    ]
})
export class AppModule implements OnModuleInit {
    private readonly metadataScanner: MetadataScanner;

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import {TypeOrmModule} from '@nestjs/typeorm';
import { config } from './config';
import { ContactsModule } from './contacts/contacts.module';

@Module({
  imports: [
    TypeOrmModule.forRoot(config.database),
    ContactsModule,
  ],
  controllers: [AppController]
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UsersModule } from './users/users.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ORMConfig } from "./ormconfig";

@Module({
    imports: [UsersModule, TypeOrmModule.forRoot(ORMConfig)],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigurationService } from './shared/configuration/configuration.service';
import { Configuration } from './shared/configuration/configuration.enum';
import { SharedModule } from './shared/shared.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UserModule } from './management/user/user.module';
import { ImageModule } from './management/image/image.module';
import { DishModule } from './management/dish/dish.module';
import { OrderModule } from './management/order/order.module';
import * as winston from 'winston';
import { BookingModule } from 'management/booking/booking.module';
@Module({
  imports: [
    TypeOrmModule.forRoot(),
    SharedModule,
    UserModule,
    ImageModule,
    DishModule,
    OrderModule,
    BookingModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {
  static host: string | undefined;
  static port: string | number;
  static isDev: boolean;
  static appName: string | undefined;
  static appVersion: string | undefined;

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ProjectController } from './projects/project.controller';
import { ContactController } from './contact/contact.controller';
import { MailService } from './mail/mail.service';
import { AppConfig, MailConfigProvider } from './app.config';
import { DataInitializerService } from './initialization/data-initializer.service';
import { ChatGateway } from './chat/chat.gateway';
import { Project } from './projects/project.model';

@Module({
  imports: [TypeOrmModule.forRoot(AppConfig.mongoConnectionOptions), TypeOrmModule.forFeature([Project])],
  controllers: [ProjectController, ContactController],
  providers: [MailService, DataInitializerService, MailConfigProvider, ChatGateway],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from './auth';
import { CoreModule } from './core';
import { CommerceModule } from './commerce';
import { CmsModule } from './cms';
import { MONGODB_URI } from './utils';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    TypeOrmModule.forRoot(),
    MongooseModule.forRoot(MONGODB_URI, {
      useCreateIndex: true,
      useNewUrlParser: true,
    }),
    AuthModule,
    CoreModule,
    CmsModule,
    CommerceModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Bucket } from "./plugin/upyun/entities/bucket.entity";
import { ConfigService } from "./plugin/upyun/services/config.service";
import { RestfulUtil } from "./plugin/upyun/util/restful.util";
import { KindUtil } from "./plugin/upyun/util/kind.util";
import { ProcessStringUtil } from "./plugin/upyun/util/process.string.util";
import { AuthUtil } from "./plugin/upyun/util/auth.util";
import { Image } from "./plugin/upyun/entities/image.entity";
import { FileUtil } from "./plugin/upyun/util/file.util";
import { ImageConfig } from "./plugin/upyun/entities/image.config.entity";
import { VideoConfig } from "./plugin/upyun/entities/video.config.entity";
import { AudioConfig } from "./plugin/upyun/entities/audio.config.entity";

@Global()
@Module({
    imports: [
        TypeOrmModule.forRoot({

        }),
        TypeOrmModule.forFeature([
            Classify, ClassifyItem, Message, UserMessage, Article, ArtInfo, Item, PageSort, Page, Content, Discuss, VideoConfig,
            CommentProperties, MessageBoard, Leaveword, BoardItem, LeavewordInfo, Bucket,Image,ImageConfig,AudioConfig
        ]),
    ],
    controllers: [
        ArticleController,
        ClassifyController,
        ClassifyItemController,
        MessageController,
        UserMessageController,
        ItemController,
        PageSortController,
        PageController,

import { AppService } from './app.service';
import { GraphQLModule } from '@nestjs/graphql';
import { CatsModule } from './cats/cats.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { NodesModule } from './nodes/nodes.module';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    CatsModule,
    UsersModule,
    NodesModule,
    GraphQLModule.forRoot({
      autoSchemaFile: 'schema.graphql',
    }),
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: '127.0.0.1',
      port: 33306,
      username: 'root',
      password: 'root',
      database: 'test',
      synchronize: true,
      charset: 'utf8mb4',
      entities: [__dirname + '/**/models/*.model.{js,ts}'],
      logging: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}