@nest-yalc-2/app 1.3.3

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

@@ -0,0 +1,231 @@
+import { describe, expect, it } from '@jest/globals';
+import { Test } from '@nestjs/testing';
+import {
+  YalcBaseAppModule,
+  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 { IYalcBaseAppOptions } from '../base-app.interface.js';
+import { createMock } from '@golevelup/ts-jest';
+import { AppContextService } from '../app-context.service.js';
+
+let appContextService: AppContextService = createMock<AppContextService>({
+  initializedApps: new Set(),
+});
+
+class DummyDynamicModule extends YalcBaseAppModule {
+  static forRoot(options?: IYalcBaseAppOptions): DynamicModule {
+    return this.assignDynamicProperties(
+      yalcBaseAppModuleMetadataFactory(this, 'appAlias', {
+        ...this.assignDynamicProperties({}),
+        configFactory: () => ({}),
+        logger: true,
+        isSingleton: true,
+        imports: [YalcDefaultAppModule.forRoot('appAlias', [])],
+        ...options,
+      }),
+      options,
+    );
+  }
+}
+
+@Module({
+  imports: [
+    DummyDynamicModule.forRoot({
+      providers: [
+        {
+          provide: 'test1',
+          useValue: 'test',
+        },
+      ],
+    }),
+  ],
+})
+class DummyStaticModule1 {}
+
+@Module({
+  imports: [
+    DummyDynamicModule.forRoot({
+      providers: [
+        {
+          provide: 'test2',
+          useValue: 'test',
+        },
+      ],
+    }),
+  ],
+})
+class DummyStaticModule2 {}
+
+describe('base-app', () => {
+  describe('actual Nest module instantiation', () => {
+    it('should create dynamic module', async () => {
+      const module = await Test.createTestingModule({
+        imports: [DummyStaticModule2, DummyStaticModule1],
+      })
+        .overrideProvider(AppContextService)
+        .useValue(appContextService);
+
+      const moduleRef = await module.compile();
+
+      const lifeCycleHandler = moduleRef.get(LifeCycleHandler);
+
+      expect(module).toBeDefined();
+      expect(lifeCycleHandler).toBeDefined();
+    });
+  });
+
+  describe('YalcBaseAppModule', () => {
+    it('should be defined', () => {
+      expect(YalcBaseAppModule).toBeDefined();
+    });
+
+    it('should create dynamic properties', () => {
+      const dynamicProperties = YalcBaseAppModule.assignDynamicProperties({});
+      expect(dynamicProperties).toEqual({
+        module: YalcBaseAppModule,
+        global: true,
+        isSingleton: false,
+      });
+    });
+
+    it('should create dynamic properties with options', () => {
+      const dynamicProperties = YalcBaseAppModule.assignDynamicProperties(
+        {},
+        {
+          global: false,
+          isSingleton: true,
+        },
+      );
+      expect(dynamicProperties).toEqual({
+        module: YalcBaseAppModule,
+        global: false,
+        isSingleton: true,
+      });
+    });
+
+    it('should create dynamic module for standalone', () => {
+      const dynamicModule = YalcBaseAppModule._forRootStandalone('appAlias');
+      expect(dynamicModule).toBeDefined();
+      expect(dynamicModule.global).toBe(true);
+      expect(dynamicModule.isSingleton).toBe(false);
+    });
+
+    it('should create dynamic module', () => {
+      const dynamicModule = YalcBaseAppModule._forRoot('appAlias');
+      expect(dynamicModule).toBeDefined();
+      expect(dynamicModule.global).toBe(true);
+      expect(dynamicModule.isSingleton).toBe(false);
+    });
+  });
+
+  describe('registerSingletonDynamicModule', () => {
+    class TestModule extends DummyDynamicModule {
+      static forRoot(options?: IYalcBaseAppOptions | undefined): DynamicModule {
+        return this._forRoot('test', options);
+      }
+    }
+
+    it('should register singleton dynamic module', () => {
+      const config = TestModule.forRoot();
+      const result = registerSingletonDynamicModule(true, TestModule, config);
+      expect(result).toBe(config);
+    });
+
+    it('should not register the same singleton dynamic module twice', () => {
+      const result = registerSingletonDynamicModule(
+        true,
+        TestModule,
+        TestModule.forRoot(),
+      );
+      expect(result).not.toBe(true);
+    });
+  });
+
+  describe('envFilePathList', () => {
+    it('should create env file path list', () => {
+      const paths = envFilePathList('.');
+      expect(paths).toContain('./.env');
+      if (process.env.NODE_ENV) {
+        expect(paths).toContain(`./.env.${process.env.NODE_ENV}`);
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        expect(paths).toContain('./.env.dist');
+      }
+    });
+
+    it('should create env file path list for production', () => {
+      process.env.NODE_ENV = 'production';
+      const paths = envFilePathList('.');
+      expect(paths).toContain('./.env');
+      expect(paths).toContain(`./.env.production`);
+      expect(paths).not.toContain('./.env.dist');
+      process.env.NODE_ENV = 'test';
+    });
+  });
+
+  describe('baseAppModuleMetadataFactory', () => {
+    it('should create base app module metadata', () => {
+      const metadata = yalcBaseAppModuleMetadataFactory({}, 'appAlias', {
+        logger: true,
+        global: true,
+      });
+      expect(metadata).toBeDefined();
+      expect(metadata.controllers).toEqual([]);
+    });
+
+    it('should create base app module metadata with options', () => {
+      const metadata = yalcBaseAppModuleMetadataFactory({}, 'appAlias', {
+        envPath: ['./.env.test'],
+        extraConfigs: [],
+        providers: [],
+        imports: [],
+        exports: [],
+        controllers: [],
+      });
+      expect(metadata).toBeDefined();
+      expect(metadata.controllers).toEqual([]);
+    });
+
+    it('should create base app module metadata with options and controllers, with envPath as a string', () => {
+      class TestController {}
+
+      const metadata = yalcBaseAppModuleMetadataFactory(
+        DummyStaticModule1,
+        'appAlias',
+        {
+          envPath: './.env.test',
+          extraConfigs: [],
+          providers: [],
+          imports: [],
+          exports: [],
+          controllers: [TestController],
+        },
+      );
+      expect(metadata).toBeDefined();
+      expect(metadata.controllers).toEqual([TestController]);
+    });
+
+    it('should create base app module metadata without envPath', () => {
+      class TestController {}
+
+      const metadata = yalcBaseAppModuleMetadataFactory(
+        DummyStaticModule1,
+        'appAlias',
+        {
+          extraConfigs: [],
+          providers: [],
+          imports: [],
+          exports: [],
+          controllers: [TestController],
+        },
+      );
+      expect(metadata).toBeDefined();
+      expect(metadata.controllers).toEqual([TestController]);
+    });
+  });
+});

package/src/__tests__/base-app.controller.spec.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it, jest, beforeEach, afterEach } from '@jest/globals';
+import { ConfigService } from '@nestjs/config';
+import { BaseAppController } from '../base-app.controller.js';
+import { BaseAppService } from '../base-app.service.js';
+
+class TestAppController extends BaseAppController {}
+
+describe('BaseAppController', () => {
+  const getHello = jest.fn();
+  const appService = {
+    getHello,
+  } as unknown as BaseAppService;
+
+  const configGet = jest.fn();
+  const configService = {
+    get: configGet,
+  } as unknown as ConfigService;
+
+  let controller: TestAppController;
+  let exitSpy: jest.SpyInstance;
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    controller = new TestAppController(appService, configService);
+    exitSpy = jest
+      .spyOn(process, 'exit')
+      .mockImplementation((() => undefined) as any);
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should call BaseAppService with configured app name', () => {
+    configGet.mockReturnValue({ appName: 'sample-app' });
+    getHello.mockReturnValue('Hello World from sample-app!');
+
+    const result = controller.getHello();
+
+    expect(result).toBe('Hello World from sample-app!');
+    expect(getHello).toHaveBeenCalledWith('sample-app');
+  });
+
+  it('should fallback to default app name when missing', () => {
+    configGet.mockReturnValue(undefined);
+    getHello.mockReturnValue('Hello World from no-name!');
+
+    controller.getHello();
+
+    expect(getHello).toHaveBeenCalledWith('no-name');
+  });
+
+  it('should terminate when shutdown is called in dev/test env', () => {
+    configGet.mockReturnValue({ isDev: true });
+
+    controller.shutdown();
+
+    expect(logSpy).toHaveBeenCalledWith('Bye bye!');
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('should ignore shutdown when not in dev/test env', () => {
+    configGet.mockReturnValue({ isDev: false, isTest: false });
+
+    controller.shutdown();
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/base-app.service.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { ExecutionContext, LoggerService } from '@nestjs/common';
+import { BaseAppService } from '../base-app.service.js';
+
+describe('BaseAppService', () => {
+  const logger: LoggerService = {
+    debug: jest.fn(),
+  };
+  const service = new BaseAppService(logger);
+
+  it('should format hello message with app name', () => {
+    expect(service.getHello('test-app')).toBe('Hello World from test-app!');
+  });
+
+  it('should log handler names containing underscore and not starting with "_"', () => {
+    const ctx = {
+      getHandler: () => ({ name: 'test_handler' }),
+    } as unknown as ExecutionContext;
+
+    service.handleBeforeAllRoutes(ctx);
+
+    expect(logger.debug).toHaveBeenCalledWith('Running Handler: test_handler');
+  });
+
+  it('should ignore handlers without underscore or starting with "_"', () => {
+    (logger.debug as jest.Mock).mockClear();
+    const ctxWithoutUnderscore = {
+      getHandler: () => ({ name: 'handler' }),
+    } as unknown as ExecutionContext;
+    const ctxInternal = {
+      getHandler: () => ({ name: '_internal_handler' }),
+    } as unknown as ExecutionContext;
+
+    service.handleBeforeAllRoutes(ctxWithoutUnderscore);
+    service.handleBeforeAllRoutes(ctxInternal);
+
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/cls.module.spec.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import 'reflect-metadata';
+import {
+  YalcAlsService,
+  YalcClsModule,
+  YalcGlobalClsService,
+} from '../cls.module.js';
+
+describe('YalcClsModule', () => {
+  it('should expose YalcGlobalClsService in module exports', () => {
+    const exportedProviders =
+      (Reflect.getMetadata('exports', YalcClsModule) as any[]) ?? [];
+    expect(exportedProviders).toContain(YalcGlobalClsService);
+  });
+
+  it('should configure a CLS module import', async () => {
+    const imports =
+      (Reflect.getMetadata('imports', YalcClsModule) as any[]) ?? [];
+    expect(imports.length).toBeGreaterThan(0);
+  });
+
+  it('YalcAlsService should persist store within the async context', () => {
+    const als = new YalcAlsService();
+    const store = { placeholder: 'value' };
+    let seen;
+
+    als.run(store, () => {
+      seen = als.getStore();
+    });
+
+    expect(seen).toEqual(store);
+  });
+});

package/src/__tests__/life-cycle-handler.service.spec.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { LifeCycleHandler } from '../life-cycle-handler.service.js';
+import { AppContextService } from '../app-context.service.js';
+import { createMock } from '@golevelup/ts-jest';
+
+describe('LifeCycleHandler', () => {
+  let loggerService: any = { debug: jest.fn() };
+  let lifeCycleHandler: LifeCycleHandler;
+  let appContextService: AppContextService = createMock<AppContextService>({
+    initializedApps: new Set(),
+  });
+
+  it('should initialize app', () => {
+    lifeCycleHandler = new LifeCycleHandler(
+      loggerService,
+      'TestApp',
+      appContextService,
+    );
+    expect(loggerService.debug).toHaveBeenCalledWith(
+      '====================== Init TestApp ======================',
+    );
+  });
+
+  it('should not initialize the same app twice', () => {
+    expect(
+      () => new LifeCycleHandler(loggerService, 'TestApp', appContextService),
+    ).toThrow('Cannot initialize the same app (TestApp) twice');
+  });
+
+  it('should initialize the same app twice if skipDuplicateAppCheck is true', () => {
+    new LifeCycleHandler(loggerService, 'TestApp', appContextService, {
+      skipDuplicateAppCheck: true,
+    });
+    expect(
+      () =>
+        new LifeCycleHandler(loggerService, 'TestApp', appContextService, {
+          skipDuplicateAppCheck: true,
+        }),
+    ).not.toThrow();
+  });
+
+  it('should handle module destroy', () => {
+    lifeCycleHandler.onModuleDestroy();
+    expect(loggerService.debug).toHaveBeenCalledWith(
+      '====================== Close TestApp ======================',
+    );
+  });
+});

package/src/__tests__/tsconfig.json

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

package/src/__tests__/unwrap-result.interceptor.spec.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from '@jest/globals';
+import { CallHandler, ExecutionContext } from '@nestjs/common';
+import { firstValueFrom, of } from 'rxjs';
+import { UnwrapResultInterceptor } from '../unwrap-result.interceptor.js';
+
+const ctx = {
+  switchToHttp: () => ({
+    getRequest: () => ({}),
+  }),
+} as unknown as ExecutionContext;
+
+describe('UnwrapResultInterceptor', () => {
+  const interceptor = new UnwrapResultInterceptor();
+
+  it('should unwrap successful Result-like objects', async () => {
+    const next: CallHandler = {
+      handle: () =>
+        of({
+          isOk: () => true,
+          isErr: () => false,
+          value: 'payload',
+        }),
+    };
+
+    const result = await firstValueFrom(interceptor.intercept(ctx, next));
+    expect(result).toBe('payload');
+  });
+
+  it('should throw when Result-like object contains error', async () => {
+    const error = new Error('boom');
+    const next: CallHandler = {
+      handle: () =>
+        of({
+          isOk: () => false,
+          isErr: () => true,
+          error,
+        }),
+    };
+
+    await expect(firstValueFrom(interceptor.intercept(ctx, next))).rejects.toThrow('boom');
+  });
+
+  it('should pass through non Result objects', async () => {
+    const payload = { ok: true };
+    const next: CallHandler = {
+      handle: () => of(payload),
+    };
+
+    const result = await firstValueFrom(interceptor.intercept(ctx, next));
+    expect(result).toBe(payload);
+  });
+});

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

@@ -0,0 +1,41 @@
+import { DynamicModule, INestApplicationContext, LoggerService, Type } from '@nestjs/common';
+import { NestFastifyApplication } from '@nestjs/platform-fastify';
+import type { IServiceConf } from './conf.type.js';
+import { ICreateOptions, INestCreateOptions } from './app-bootstrap.helper.js';
+import { EventModule } from '@nest-yalc-2/event-manager/event.module.js';
+import { LoggerServiceFactory } from '@nest-yalc-2/logger/logger.service.js';
+import { FastifyInstance } from 'fastify';
+export interface IGlobalOptions {
+    extraImports?: NonNullable<DynamicModule['imports']>;
+    eventModuleClass?: typeof EventModule;
+    logger?: typeof LoggerServiceFactory;
+    skipMultiServerCheck?: boolean;
+}
+export declare const getBootstrappedApps: () => Set<any>;
+export declare const getMainBootstrappedApp: <TApp extends BaseAppBootstrap<NestFastifyApplication | INestApplicationContext>>() => TApp | null;
+export declare abstract class BaseAppBootstrap<TAppType extends NestFastifyApplication | INestApplicationContext> {
+    protected appAlias: string;
+    protected readonly appModule: Type<any>;
+    protected app?: TAppType;
+    protected loggerService: LoggerService;
+    protected module: Type<any> | DynamicModule;
+    protected isClosed: boolean;
+    constructor(appAlias: string, appModule: Type<any>, options?: {
+        globalsOptions?: IGlobalOptions;
+    });
+    initApp(options?: {
+        createOptions?: INestCreateOptions;
+        fastifyInstance?: FastifyInstance;
+    }): Promise<this>;
+    setApp(app: TAppType): this;
+    closeCleanup(): void;
+    isAppClosed(): boolean;
+    getAppAlias(): string;
+    getConf(): IServiceConf | undefined;
+    getApp(): TAppType;
+    closeApp(): Promise<void>;
+    cleanup(): Promise<void>;
+    getAppModule(): Type<any>;
+    getModule(): Type<any> | DynamicModule;
+    applyBootstrapGlobals(_options?: ICreateOptions): Promise<this>;
+}

package/src/app-bootstrap-base.helper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAppBootstrap = exports.getMainBootstrappedApp = exports.getBootstrappedApps = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const def_const_js_1 = require("./def.const.js");
+const base_app_module_helper_js_1 = require("./base-app-module.helper.js");
+const logger_helper_js_1 = require("@nest-yalc-2/logger/logger.helper.js");
+const promise_helper_js_1 = require("@nest-yalc-2/utils/promise.helper.js");
+common_1.Logger.overrideLogger((0, logger_helper_js_1.getEnvLoggerLevels)());
+const bootstrappedApps = new Set();
+const getBootstrappedApps = () => {
+    return bootstrappedApps;
+};
+exports.getBootstrappedApps = getBootstrappedApps;
+const getMainBootstrappedApp = () => {
+    if ((0, exports.getBootstrappedApps)().size === 0) {
+        return null;
+    }
+    return (0, exports.getBootstrappedApps)().values().next().value;
+};
+exports.getMainBootstrappedApp = getMainBootstrappedApp;
+class BaseAppBootstrap {
+    constructor(appAlias, appModule, options) {
+        this.appAlias = appAlias;
+        this.appModule = appModule;
+        this.isClosed = false;
+        this.module = base_app_module_helper_js_1.YalcDefaultAppModule.forRoot(this.appAlias, [appModule, ...(options?.globalsOptions?.extraImports ?? [])], options?.globalsOptions);
+        const bootstrappedApp = (0, exports.getMainBootstrappedApp)();
+        if (bootstrappedApp &&
+            !options?.globalsOptions?.skipMultiServerCheck &&
+            process.env.APP_SKIP_MULTISERVER_CHECK !== 'true') {
+            throw new Error(`You are trying to bootstrap multiple servers (${bootstrappedApp.appAlias}) in the same process. This is not allowed. Use a different process for each server`);
+        }
+        (0, exports.getBootstrappedApps)().add(this);
+    }
+    async initApp(options) {
+        options;
+        return this;
+    }
+    setApp(app) {
+        this.app = app;
+        const originalCloseFn = this.app.close.bind(this.app);
+        this.app.close = async () => {
+            const closeRes = await originalCloseFn();
+            this.closeCleanup();
+            return closeRes;
+        };
+        const originalInitFn = this.app.init.bind(this.app);
+        this.app.init = async () => {
+            this.isClosed = false;
+            (0, exports.getBootstrappedApps)().add(this);
+            let initRes;
+            try {
+                initRes = await originalInitFn();
+            }
+            catch (error) {
+                this.closeCleanup();
+                throw error;
+            }
+            return initRes;
+        };
+        return this;
+    }
+    closeCleanup() {
+        this.isClosed = true;
+        (0, exports.getBootstrappedApps)().delete(this);
+    }
+    isAppClosed() {
+        return this.isClosed;
+    }
+    getAppAlias() {
+        return this.appAlias;
+    }
+    getConf() {
+        const configService = this.getApp().get(config_1.ConfigService);
+        return configService.get(this.appAlias);
+    }
+    getApp() {
+        if (!this.app) {
+            throw new Error('This app is not initialized yet');
+        }
+        return this.app;
+    }
+    async closeApp() {
+        await this.cleanup();
+        await this.app?.close();
+        this.closeCleanup();
+    }
+    async cleanup() {
+        await promise_helper_js_1.globalPromiseTracker.waitForAll();
+    }
+    getAppModule() {
+        return this.appModule;
+    }
+    getModule() {
+        return this.module;
+    }
+    async applyBootstrapGlobals(_options) {
+        this.loggerService = this.getApp().get(def_const_js_1.SYSTEM_LOGGER_SERVICE);
+        this.loggerService.debug?.('Setting logger service...');
+        this.getApp().useLogger(this.loggerService);
+        common_1.Logger.overrideLogger(this.loggerService);
+        return this;
+    }
+}
+exports.BaseAppBootstrap = BaseAppBootstrap;
+//# sourceMappingURL=app-bootstrap-base.helper.js.map

package/src/app-bootstrap-base.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-bootstrap-base.helper.js","sourceRoot":"","sources":["app-bootstrap-base.helper.ts"],"names":[],"mappings":"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"}