@nestjs/common#DynamicModule TypeScript Examples

static forRoot(options: FirebaseAdminModuleOptions): DynamicModule {
    const firebaseAdminModuleOptions = {
      provide: FIREBASE_ADMIN_MODULE_OPTIONS,
      useValue: options,
    };

    const app = admin.apps.length === 0 ? admin.initializeApp(options) : admin.apps[0];

    const providers = this.createProviders(app);

    return {
      module: FirebaseAdminCoreModule,
      providers: [firebaseAdminModuleOptions, ...providers],
      exports: [...EXPORTS],
    };
  }

static withConfig(options: GCloudStorageOptions): DynamicModule {
    const gcsModuleOptions = {
      provide: GCLOUD_STORAGE_MODULE_OPTIONS,
      useValue: options,
    };

    const gcsServiceProvider = {
      provide: GCloudStorageService,
      useFactory: (options: GCloudStorageOptions) => new GCloudStorageService(options),
      inject: [GCLOUD_STORAGE_MODULE_OPTIONS],
    };

    return {
      module: GCloudStorageCoreModule,
      providers: [gcsModuleOptions, GCloudMulterStorageService, gcsServiceProvider],
      exports: [...EXPORTS],
    };
  }

static forRoot<T>(config: IConsulConfig<T>): DynamicModule {
		const consulServiceProvider: Provider = {
			provide: ConsulService,
			useFactory: async () => {
				const consulService = new ConsulService<T>(config, new HttpService());
				if (config.keys) {
					await consulService.update();
				}
				return consulService;
			},
		};
		return {
			module: ConsulModule,
			providers: [consulServiceProvider],
			exports: [consulServiceProvider],
		};
	}

static forRoot(options: FcmOptions): DynamicModule {
    const optionsProvider: ValueProvider = {
      provide: FCM_OPTIONS,
      useValue: options,
    };
    const logger = options.logger ? options.logger : new Logger('FcmService');
    return {
      module: FcmModule,
      providers: [
        { provide: Logger, useValue: logger },
        FcmService,
        optionsProvider,
      ],
      exports: [FcmService],
    };
  }

static forRoot(options: MercuriusGatewayModuleOptions): DynamicModule {
    return {
      module: MercuriusGatewayModule,
      providers: [
        {
          provide: GRAPHQL_GATEWAY_MODULE_OPTIONS,
          useValue: options,
        },
      ],
    };
  }

/**
 * 테스트 MySQL 가져오기
 *
 * @returns {DynamicModule}
 */
export function getTestMysqlModule(): DynamicModule {
  return TypeOrmModule.forRoot({
    type: 'mysql',
    host: 'localhost',
    port: 3306,
    username: 'test',
    password: 'test',
    database: 'test',
    entities: ['src/api/**/*.entity.ts'],
    synchronize: true,
  });
}

static forFeature(
    options: TypeGraphQLFeatureFedarationModuleOptions = {},
  ): DynamicModule {
    const token = `${TYPEGRAPHQL_FEATURE_FEDERATION_MODULE_OPTIONS}_${this
      .forFeatureIndex++}`;
    return {
      module: TypeGraphQLFederationModule,
      providers: [{ provide: token, useValue: options }],
      exports: [token],
    };
  }

static register(
    eventStoreConfig: EventStoreConnectionConfig,
    eventStoreSubsystems: IEventStoreSubsystems = {
      onConnectionFail: (e) => console.log('e : ', e),
    },
    eventBusConfig: EventBusConfigType = {},
  ): DynamicModule {
    return {
      module: CqrsEventStoreModule,
      imports: [
        EventStoreModule.register(eventStoreConfig, eventStoreSubsystems),
      ],
      providers: [
        { provide: READ_EVENT_BUS_CONFIG, useValue: eventBusConfig.read },
        {
          provide: WRITE_EVENT_BUS_CONFIG,
          useValue: { ...getDefaultEventBusConfiguration, ...eventBusConfig },
        },
      ],
      exports: [EventStoreModule],
    };
  }

/**
   * Creates admin in a synchronous way
   * 
   * @param {AdminModuleOptions} options
   * @memberof module:@adminjs/nestjs~AdminModule
   * @method
   * @name createAdmin
   * @example
   * import { Module } from '@nestjs/common';
   * import { AdminModule } from '@adminjs/nestjs';
   * 
   * \@Module({
   *   imports: [
   *     AdminModule.createAdmin({
   *        rootPath: '/admin',
   *        resources: [],
   *     }),
   *   ],
   * })
   * export class AppModule {}
   * 
   */
  // This is needed by JSDoc which cannot parse this statement
  public static createAdmin(options: AdminModuleOptions & CustomLoader): DynamicModule {
    return {
      module: AdminModule,
      providers: [
        {
          provide: CONFIG_TOKEN,
          useValue: options,
        },
        options.customLoader ? {
          provide: AbstractLoader,
          useClass: options.customLoader,
        } : serveStaticProvider,
      ],
    }
  }

static forRoot(options: ContainerBuilderModuleOptions): DynamicModule {
    return {
      module: ContainerBuilderModule,
      providers: [
        {
          provide: CONTAINER_BUILDER_OPTIONS,
          useValue: { ...options, providers: {} },
        },
        ContainerBuilderService,
      ],
      exports: [ContainerBuilderService],
    };
  }

public static registerAsync(options: KeycloakModuleAsyncOptions): DynamicModule {
    const customOptions = this.getCustomOptions(options)

    return {
      module: KeycloakModule,
      imports: options.imports || [],
      providers: [customOptions, this.keycloakProvider],
      exports: [customOptions, this.keycloakProvider],
    }
  }

static register({
    session,
    remixHandlerPath,
  }: {
    session: SessionIdStorageStrategy["cookie"];
    remixHandlerPath: string;
  }): DynamicModule {
    const MailerClass = process.env.SENDGRID_API_KEY
      ? SendGridMailer
      : FakeMailer;

    return {
      module: ApplicationModule,
      providers: [
        {
          provide: MAILER,
          useClass: MailerClass,
        },
        {
          provide: SESSION_CONFIG,
          useValue: session,
        },
        {
          provide: REMIX_HANDLER,
          useValue: remixHandlerPath,
        },
      ],
      imports: [],
    };
  }

static register(config: HttpModuleOptions): DynamicModule {
    return {
      module: HttpModule,
      providers: [
        {
          provide: AXIOS_INSTANCE_TOKEN,
          useValue: createAxiosInstance(config),
        },
        {
          provide: HTTP_MODULE_ID,
          useValue: randomStringGenerator(),
        },
      ],
    };
  }

static forRoot(options: GoogleRecaptchaModuleOptions): DynamicModule {
        const providers: Provider[] = [
            GoogleRecaptchaGuard,
            GoogleRecaptchaValidator,
            RecaptchaRequestResolver,
            {
                provide: RECAPTCHA_OPTIONS,
                useValue: options,
            },
        ];

        const httpModule = this.resolveHttpModule();

        const internalProviders: Provider[] = [
            Reflector,
            {
                provide: RECAPTCHA_HTTP_SERVICE,
                useFactory: (axiosInstance: axios.AxiosInstance) => new httpModule.HttpService(axiosInstance),
                inject: [
                    RECAPTCHA_AXIOS_INSTANCE,
                ],
            },
            {
                provide: RECAPTCHA_AXIOS_INSTANCE,
                useFactory: () => axios.default.create(this.transformAxiosConfig(options.axiosConfig)),
            },
        ];

        return {
            global: true,
            module: GoogleRecaptchaModule,
            imports: [
                httpModule.HttpModule,
            ],
            providers: providers.concat(internalProviders),
            exports: providers,
        }
    }

static config(config: FormDataInterceptorConfig): DynamicModule {
    return {
      module: NestjsFormDataModule,
      providers: [
        {
          provide: GLOBAL_CONFIG_INJECT_TOKEN,
          useValue: checkConfig(config),
        },
      ],
    };
  }

static forRoot(options: TracingModuleOptions): DynamicModule {
    const providers: Provider[] = [];
    TracingModule.tracerProvider = TracerProvider.getInstance(options);
    TracingModule.tracer = TracingModule.tracerProvider.getTracer();
    const optionsProvider: Provider<TracingModuleOptions> = {
      provide: TRACING_MODULE_OPTIONS,
      useValue: options,
    };
    const tracerProvider: Provider = {
      provide: TRACER,
      useValue: TracingModule.tracer,
    };
    const tracerProviderFactory: Provider = {
      provide: TRACER_PROVIDER,
      useValue: TracingModule.tracerProvider,
    };
    providers.push(optionsProvider);
    providers.push(tracerProvider);
    providers.push(tracerProviderFactory);
    return {
      module: TracingModule,
      providers: [
        ...providers,
        {
          provide: APP_INTERCEPTOR,
          useClass: TracingInterceptor,
        },
      ],
      exports: [...providers],
    };
  }

static register(options: SeederModuleOptions): DynamicModule {
    return {
      module: SeederModule,
      imports: options.imports || [],
      providers: [
        ...(options.providers || []),
        ...options.seeders,
        {
          provide: SeederService,
          useFactory: (...seeders: Seeder[]): SeederService => {
            return new SeederService(seeders);
          },
          inject: options.seeders as Type<any>[],
        },
      ],
    };
  }

/**
   * Registers a globally available configuration under a specified "configKey".
   *
   * @param configKey a key under which the configuration should be available
   * @param sharedBullConfig shared bull configuration object
   */
  static forRoot(
    configKey: string,
    bullConfig: Bull.QueueOptions,
  ): DynamicModule;

/**
   * Register the `KeycloakConnect` module.
   * @param opts `keycloak.json` path in string or {@link NestKeycloakConfig} object.
   * @param config {@link NestKeycloakConfig} when using `keycloak.json` path, optional
   * @returns
   */
  public static register(
    opts: KeycloakConnectOptions,
    config?: NestKeycloakConfig,
  ): DynamicModule {
    const keycloakConnectProviders = [
      createKeycloakConnectOptionProvider(opts, config),
      loggerProvider,
      keycloakProvider,
      KeycloakMultiTenantService,
    ];
    return {
      module: KeycloakConnectModule,
      providers: keycloakConnectProviders,
      exports: keycloakConnectProviders,
    };
  }

static foorRoot(setting: any): DynamicModule {
    return {
      module: AppModule,
      imports: [
        DomainModule,
        ApplicationModule,
        InfrastructureModule.foorRoot(setting),
      ],
    };
  }

static forFeature<Roles extends string = string, Subjects = SubjectType, Actions extends string = DefaultActions, User extends AuthorizableUser = AuthorizableUser<Roles>>(options: OptionsForFeature<Roles, Subjects, Actions, User>): DynamicModule {
    return {
      module: CaslModule,
      imports: [],
      // exports: [AccessService],
      providers: [
        AccessService,
        AbilityFactory,
        {
          provide: CASL_FEATURE_OPTIONS,
          useValue: options,
        },
      ],
    };
  }

static forRoot(options: DynamooseModuleOptions = {}): DynamicModule {
    const initialProvider = {
      provide: DYNAMOOSE_INITIALIZATION,
      useFactory: () => initialization(options),
    };
    return {
      module: DynamooseCoreModule,
      providers: [initialProvider],
      exports: [initialProvider],
    };
  }

public static forRootAsync(options: MqttModuleAsyncOptions): DynamicModule {
    return {
      module: MqttModule,
      providers: [
        ...createOptionProviders(options),
        createLoggerProvider(options),
        createClientProvider(),
        MqttExplorer,
        MqttService,
      ],
    };
  }

static async forRoot(options?: MikroOrmModuleSyncOptions): Promise<DynamicModule> {
    const contextName = this.setContextName(options?.contextName);
    const knex = await tryRequire(() => import('@mikro-orm/knex'));
    const mongo = await tryRequire(() => import('@mikro-orm/mongodb'));

    return {
      module: MikroOrmCoreModule,
      providers: [
        { provide: MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
        createMikroOrmProvider(contextName),
        createEntityManagerProvider(options?.scope, EntityManager, contextName),
        ...(knex ? [createEntityManagerProvider(options?.scope, knex.SqlEntityManager, contextName)] : []),
        ...(mongo ? [createEntityManagerProvider(options?.scope, mongo.MongoEntityManager, contextName)] : []),
      ],
      exports: [
        contextName ? getMikroORMToken(contextName) : MikroORM,
        contextName ? getEntityManagerToken(contextName) : EntityManager,
        ...(knex ? (contextName ? [] : [knex.SqlEntityManager as any]) : []),
        ...(mongo ? (contextName ? [] : [mongo.MongoEntityManager as any]) : []),
      ],
    };
  }

public static forRoot(options: TracingConfig): DynamicModule {
    return {
      // Make TracingService available in the whole app
      global: true,
      module: TracingModule,
      imports: [TracingCoreModule.forRoot(options)],
      exports: [TracingCoreModule],
    };
  }

static register(models: ModelDefinition[]): DynamicModule {
        const providers = createTenancyProviders(models);

        return {
            module: TenancyFeatureModule,
            providers,
            exports: providers,
        };
    }

static register(config: ISystemModuleConfig = {}): DynamicModule {
        const {defaultEnvironmentNameOrId} = config;
        const systemExtensions = loadExtensionsFor(EXTENSION_TYPES.SYSTEM, defaultEnvironmentNameOrId);

        return {
            imports: [...systemExtensions],
            module: SystemModule,
            exports: [...systemExtensions],
        };
    }

/* forRoot */
  static forRoot(options: RedisModuleOptions, connection?: string): DynamicModule {

    const redisOptionsProvider: Provider = {
      provide: getRedisOptionsToken(connection),
      useValue: options,
    };

    const redisConnectionProvider: Provider = {
      provide: getRedisConnectionToken(connection),
      useValue: createRedisConnection(options),
    };

    return {
      module: RedisCoreModule,
      providers: [
        redisOptionsProvider,
        redisConnectionProvider,
      ],
      exports: [
        redisOptionsProvider,
        redisConnectionProvider,
      ],
    };
  }

public static register(options: PactConsumerOverallOptions): DynamicModule {
    const consumerOptProvider = ProviderFactory.create(PactModuleProviders.ConsumerOptions, options.consumer);
    const publisherOptProvider = ProviderFactory.create(PactModuleProviders.PublicationOptions, options.publication);

    return {
      module: PactConsumerCoreModule,
      exports: [PactFactory, PactPublisherProvider],
      providers: [consumerOptProvider, publisherOptProvider, PactProvider, PactPublisherProvider, PactFactory],
    };
  }