Feat/reworked dependency injection (#24)

Author: Yehonal

app/src/__tests__/base-app-module.helper.spec.ts

@@ -5,10 +5,11 @@ import {
   registerSingletonDynamicModule,
   envFilePathList,
   yalcBaseAppModuleMetadataFactory,
+  YalcDefaultAppModule,
 } from '../base-app-module.helper.js';
 import { LifeCycleHandler } from '../life-cycle-handler.service.js';
 import { DynamicModule, Module } from '@nestjs/common';
-import { IBaseAppOptions } from '../base-app.interface.js';
+import { IYalcBaseAppOptions } from '../base-app.interface.js';
 import { createMock } from '@golevelup/ts-jest';
 import { AppContextService } from '../app-context.service.js';
 
@@ -17,13 +18,14 @@ let appContextService: AppContextService = createMock<AppContextService>({
 });
 
 class DummyDynamicModule extends YalcBaseAppModule {
-  static forRoot(options?: IBaseAppOptions): DynamicModule {
+  static forRoot(options?: IYalcBaseAppOptions): DynamicModule {
     return this.assignDynamicProperties(
       yalcBaseAppModuleMetadataFactory(this, 'appAlias', {
         ...this.assignDynamicProperties({}),
         configFactory: () => ({}),
         logger: true,
         isSingleton: true,
+        imports: [YalcDefaultAppModule.forRoot('appAlias', [])],
         ...options,
       }),
       options,
@@ -123,7 +125,7 @@ describe('base-app', () => {
 
   describe('registerSingletonDynamicModule', () => {
     class TestModule extends DummyDynamicModule {
-      static forRoot(options?: IBaseAppOptions | undefined): DynamicModule {
+      static forRoot(options?: IYalcBaseAppOptions | undefined): DynamicModule {
         return this._forRoot('test', options);
       }
     }

app/src/__tests__/tsconfig.json

@@ -1,3 +1,3 @@
 {
   "extends": "../../../tsconfig.test.json"
-}
+}

app/src/app-bootstrap-base.helper.ts

@@ -1,21 +1,36 @@
-import { INestApplicationContext, LoggerService, Type } from '@nestjs/common';
+import {
+  DynamicModule,
+  INestApplicationContext,
+  LoggerService,
+  Type,
+} from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 // import { GqlExceptionFilter } from '@nestjs/graphql';
 import { NestFastifyApplication } from '@nestjs/platform-fastify';
 import type { IServiceConf } from './conf.type.js';
 import { SYSTEM_LOGGER_SERVICE } from './def.const.js';
+import { YalcDefaultAppModule } from './base-app-module.helper.js';
+import { IGlobalOptions } from './app-bootstrap.helper.js';
 
 export abstract class BaseAppBootstrap<
   TAppType extends NestFastifyApplication | INestApplicationContext,
-  TGlobalOptions = unknown,
+  TGlobalOptions = IGlobalOptions,
 > {
   protected app?: TAppType;
   protected loggerService!: LoggerService;
+  protected module: Type<any> | DynamicModule;
 
   constructor(
     protected appAlias: string,
-    protected readonly module: Type<any>,
-  ) {}
+    protected readonly appModule: Type<any>,
+    options?: { globalsOptions?: IGlobalOptions },
+  ) {
+    this.module = YalcDefaultAppModule.forRoot(
+      this.appAlias,
+      [appModule, ...(options?.globalsOptions?.extraImports ?? [])],
+      options?.globalsOptions,
+    );
+  }
 
   setApp(app: TAppType) {
     this.app = app;
@@ -36,6 +51,18 @@ export abstract class BaseAppBootstrap<
     return this.app;
   }
 
+  /**
+   *
+   * @returns The main module of the business logic (the one that is passed in the constructor)
+   */
+  getAppModule() {
+    return this.appModule;
+  }
+
+  /**
+   *
+   * @returns The global module that is used to bootstrap the app (YalcDefaultAppModule)
+   */
   getModule() {
     return this.module;
   }

app/src/app-bootstrap-standalone.helper.ts

@@ -5,14 +5,15 @@ import { FastifyInstance } from 'fastify';
 import { envIsTrue } from '@nestjs-yalc/utils/env.helper.js';
 import clc from 'cli-color';
 import { BaseAppBootstrap } from './app-bootstrap-base.helper.js';
+import { IGlobalOptions } from './app-bootstrap.helper.js';
 
 export class StandaloneAppBootstrap extends BaseAppBootstrap<INestApplicationContext> {
-  constructor(appAlias: string, readonly module: any) {
+  constructor(appAlias: string, module: any) {
     super(appAlias, module);
   }
 
   async initApp(options?: {
-    globalsOptions?: unknown;
+    globalsOptions?: IGlobalOptions;
     fastifyInstance?: FastifyInstance;
   }) {
     await this.createApp({
@@ -33,7 +34,7 @@ export class StandaloneAppBootstrap extends BaseAppBootstrap<INestApplicationCon
   }
 
   async createApp(_options?: {
-    globalsOptions?: unknown;
+    globalsOptions?: IGlobalOptions;
     fastifyInstance?: FastifyInstance;
   }) {
     let app: INestApplicationContext;

app/src/app-bootstrap.helper.ts

@@ -1,6 +1,7 @@
 import { SystemExceptionFilter } from '@nestjs-yalc/errors/filters/index.js';
 import {
   BadRequestException,
+  DynamicModule,
   ExceptionFilter,
   ValidationPipe,
   ValidationPipeOptions,
@@ -28,13 +29,15 @@ export interface IGlobalOptions {
   abortOnError?: boolean;
   enableSwagger?: boolean;
   validationPipeOptions?: ValidationPipeOptions;
+  appAlias: string;
+  extraImports?: NonNullable<DynamicModule['imports']>;
 }
 
 export class AppBootstrap extends BaseAppBootstrap<NestFastifyApplication> {
   private fastifyInstance?: FastifyInstance;
   protected isSwaggerEnabled: boolean = false;
 
-  constructor(appAlias: string, readonly module: any) {
+  constructor(appAlias: string, module: any) {
     super(appAlias, module);
   }
 

app/src/base-app-module.helper.ts

@@ -21,9 +21,10 @@ import {
 } from './app-config.service.js';
 import { AppContextModule } from './app-context.module.js';
 import { NODE_ENV } from '@nestjs-yalc/types/global.enum.js';
-import { ConfigModule, registerAs } from '@nestjs/config';
+import { ConfigModule, ConfigService, registerAs } from '@nestjs/config';
 import Joi from 'joi';
 import { MODULE_OPTIONS_TOKEN } from '@nestjs/common/cache/cache.module-definition.js';
+import { IGlobalOptions } from './app-bootstrap.helper.js';
 
 const singletonDynamicModules = new Map<any, any>();
 
@@ -68,11 +69,15 @@ export function envFilePathList(dirname: string = '.') {
   return envFilePath;
 }
 
-function _metadataFactory(
+/**
+ * Used for applications with controller/resolver support
+ * you should override it
+ */
+export function yalcBaseAppModuleMetadataFactory(
   module: any,
   appAlias: string,
   options?: Omit<IYalcBaseAppOptions, 'module'>,
-) {
+): IYalcBaseStaticModule {
   const _options = {
     // default values
     isSingleton: false,
@@ -100,9 +105,7 @@ function _metadataFactory(
   ];
 
   if (options?.logger) {
-    _providers.push(
-      LoggerServiceFactory(appAlias, APP_LOGGER_SERVICE, appAlias),
-    );
+    _providers.push(LoggerServiceFactory(APP_LOGGER_SERVICE, appAlias));
   }
 
   const hasConfig = _options.extraConfigs || _options.configFactory;
@@ -196,7 +199,7 @@ function _metadataFactory(
 
   const _controllers: DynamicModule['controllers'] = [];
 
-  if (controllers && _options.isStandalone !== true) {
+  if (controllers) {
     _controllers.push(...controllers);
   }
 
@@ -212,24 +215,6 @@ function _metadataFactory(
   return config;
 }
 
-/**
- * Used for applications with controller/resolver support
- * you should override it
- */
-export function yalcBaseAppModuleMetadataFactory(
-  module: any,
-  appAlias: string,
-  options?: Omit<IYalcBaseAppOptions, 'module'>,
-): IYalcBaseStaticModule {
-  const config = _metadataFactory(module, appAlias, options);
-
-  if (!options || !options.skipDefaultApp) {
-    config.imports.push(YalcDefaultAppModule.forRoot(appAlias, options));
-  }
-
-  return config;
-}
-
 /**
  * Util class that can be extended to create a NestJS application
  */
@@ -294,11 +279,13 @@ export class YalcBaseAppModule {
 export class YalcDefaultAppModule {
   static forRoot(
     appAlias: string,
-    options?: Omit<IYalcBaseAppOptions, 'module'>,
+    imports: NonNullable<DynamicModule['imports']>,
+    options?: IGlobalOptions,
   ) {
-    const imports: NonNullable<DynamicModule['imports']> = [
+    const _imports: NonNullable<DynamicModule['imports']> = [
       EventEmitterModule.forRoot(),
       AppContextModule,
+      ...imports,
     ];
 
     const providers: NonNullable<DynamicModule['providers']> = [
@@ -312,59 +299,35 @@ export class YalcDefaultAppModule {
       },
     ];
 
-    if (options?.logger) {
-      providers.push(
-        LoggerServiceFactory(appAlias, APP_LOGGER_SERVICE, appAlias),
-        {
-          provide: SYSTEM_LOGGER_SERVICE,
-          useFactory: (logger) => logger,
-          inject: [APP_LOGGER_SERVICE],
+    providers.push(
+      LoggerServiceFactory(APP_LOGGER_SERVICE, appAlias),
+      {
+        provide: AppConfigService,
+        useFactory: (config: ConfigService) => {
+          return new AppConfigService(config, appAlias);
         },
-      );
-    }
+        inject: [ConfigService],
+      },
+      {
+        provide: SYSTEM_LOGGER_SERVICE,
+        useFactory: (logger) => logger,
+        inject: [APP_LOGGER_SERVICE],
+      },
+    );
 
     const exports: NonNullable<DynamicModule['exports']> = [
       APP_OPTION_TOKEN,
       APP_ALIAS_TOKEN,
     ];
 
-    if (options?.logger) {
-      exports.push(APP_LOGGER_SERVICE, SYSTEM_LOGGER_SERVICE);
-    }
+    exports.push(APP_LOGGER_SERVICE, SYSTEM_LOGGER_SERVICE);
 
-    /**
-     * This is a workaround to make sure that the DefaultAppModule is always injected
-     * with the last configurations, basically the ones defined from the app itself
-     *
-     * NOTE: The best way is to use the isApp flag to always identify when a module is an App
-     */
-    const config = registerSingletonDynamicModule(
-      true,
-      YalcDefaultAppModule,
-      {},
-    );
-    const newConfig = yalcBaseAppModuleMetadataFactory(
-      YalcDefaultAppModule,
-      `YalcDef-${appAlias}`,
-      {
-        global: true,
-        isSingleton: false,
-        logger: false,
-        isStandalone: options?.isStandalone,
-        skipDefaultApp: true,
-        skipDuplicateAppCheck: true,
-        imports,
-        providers,
-        exports,
-      },
-    ) as IYalcBaseDynamicModule;
-
-    Object.assign(config, newConfig);
-
-    config.module = YalcDefaultAppModule;
-    config.global = true;
-    config.isSingleton = true;
-
-    return config;
+    return {
+      exports,
+      providers,
+      imports: _imports,
+      module: YalcDefaultAppModule,
+      global: true,
+    };
   }
 }

app/src/base-app.interface.ts

@@ -10,7 +10,9 @@ export interface ISingletonOption {
   /**
    * This is used to make sure that the module is not instantiated multiple times
    * This is useful when you have a dynamic module that is imported in multiple other modules
-   * If you use static modules, this is not needed
+   * If you use static modules, this is not needed. Please use it with caution because it might
+   * cause unexpected behavior
+   *
    * NOTE: should be used in conjunction with the `global` property
    */
   isSingleton?: boolean;
@@ -31,16 +33,6 @@ export interface IYalcBaseAppOptions extends Partial<ISingletonDynamicModule> {
   envDir?: string;
   migrations?: ClassType[];
   skipDuplicateAppCheck?: boolean;
-  skipGlobalInterceptors?: boolean;
-  /**
-   * used internally, probably you don't wan to set thi
-   */
-  skipDefaultApp?: boolean;
-  isStandalone?: boolean;
-  /**
-   * used to define when a module is used as an application or loaded within an application
-   */
-  isApp?: boolean;
   logger?: boolean;
 }