@nest-yalc-2/app 2.2.1 → 2.2.4

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

@@ -1,90 +1,90 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { BaseAppController } from '../base-app.controller.js';
-import { BaseAppService } from '../base-app.service.js';
-import { ConfigService } from '@nestjs/config';
-import { Controller } from '@nestjs/common';
-
-@Controller()
-class TestAppController extends BaseAppController {}
-
-describe('BaseAppController', () => {
-  let controller: TestAppController;
-  let mockAppService: any;
-  let mockConfigService: any;
-
-  beforeEach(async () => {
-    mockAppService = {
-      getHello: jest.fn().mockReturnValue('Hello World'),
-    };
-    mockConfigService = {
-      get: jest.fn(),
-    };
-
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [TestAppController],
-      providers: [
-        { provide: BaseAppService, useValue: mockAppService },
-        { provide: ConfigService, useValue: mockConfigService },
-      ],
-    }).compile();
-
-    controller = module.get<TestAppController>(TestAppController);
-  });
-
-  describe('getHello', () => {
-    it('should return hello with app name', () => {
-      mockConfigService.get.mockReturnValue({ appName: 'test-app' });
-      expect(controller.getHello()).toBe('Hello World');
-      expect(mockAppService.getHello).toHaveBeenCalledWith('test-app');
-    });
-
-    it('should return hello with default name when conf is missing', () => {
-      mockConfigService.get.mockReturnValue(undefined);
-      expect(controller.getHello()).toBe('Hello World');
-      expect(mockAppService.getHello).toHaveBeenCalledWith('no-name');
-    });
-  });
-
-  describe('shutdown', () => {
-    let mockExit: jest.SpyInstance;
-    let mockLog: jest.SpyInstance;
-
-    beforeEach(() => {
-      mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
-      mockLog = jest.spyOn(console, 'log').mockImplementation((() => {}) as any);
-    });
-
-    afterEach(() => {
-      mockExit.mockRestore();
-      mockLog.mockRestore();
-    });
-
-    it('should shutdown in dev mode', () => {
-      mockConfigService.get.mockReturnValue({ isDev: true });
-      controller.shutdown();
-      expect(mockExit).toHaveBeenCalledWith(0);
-      expect(mockLog).toHaveBeenCalledWith('Bye bye!');
-    });
-
-    it('should shutdown in test mode', () => {
-      mockConfigService.get.mockReturnValue({ isTest: true });
-      controller.shutdown();
-      expect(mockExit).toHaveBeenCalledWith(0);
-      expect(mockLog).toHaveBeenCalledWith('Bye bye!');
-    });
-
-    it('should not shutdown if neither dev nor test', () => {
-      mockConfigService.get.mockReturnValue({ isDev: false, isTest: false });
-      controller.shutdown();
-      expect(mockExit).not.toHaveBeenCalled();
-      expect(mockLog).not.toHaveBeenCalled();
-    });
-
-    it('should not shutdown if conf is missing', () => {
-      mockConfigService.get.mockReturnValue(undefined);
-      controller.shutdown();
-      expect(mockExit).not.toHaveBeenCalled();
-      expect(mockLog).not.toHaveBeenCalled();
-    });
-  });
-});
+import { Test, TestingModule } from '@nestjs/testing';
+import { BaseAppController } from '../base-app.controller.js';
+import { BaseAppService } from '../base-app.service.js';
+import { ConfigService } from '@nestjs/config';
+import { Controller } from '@nestjs/common';
+
+@Controller()
+class TestAppController extends BaseAppController {}
+
+describe('BaseAppController', () => {
+  let controller: TestAppController;
+  let mockAppService: any;
+  let mockConfigService: any;
+
+  beforeEach(async () => {
+    mockAppService = {
+      getHello: jest.fn().mockReturnValue('Hello World'),
+    };
+    mockConfigService = {
+      get: jest.fn(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TestAppController],
+      providers: [
+        { provide: BaseAppService, useValue: mockAppService },
+        { provide: ConfigService, useValue: mockConfigService },
+      ],
+    }).compile();
+
+    controller = module.get<TestAppController>(TestAppController);
+  });
+
+  describe('getHello', () => {
+    it('should return hello with app name', () => {
+      mockConfigService.get.mockReturnValue({ appName: 'test-app' });
+      expect(controller.getHello()).toBe('Hello World');
+      expect(mockAppService.getHello).toHaveBeenCalledWith('test-app');
+    });
+
+    it('should return hello with default name when conf is missing', () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      expect(controller.getHello()).toBe('Hello World');
+      expect(mockAppService.getHello).toHaveBeenCalledWith('no-name');
+    });
+  });
+
+  describe('shutdown', () => {
+    let mockExit: jest.SpyInstance;
+    let mockLog: jest.SpyInstance;
+
+    beforeEach(() => {
+      mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+      mockLog = jest.spyOn(console, 'log').mockImplementation((() => {}) as any);
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+      mockLog.mockRestore();
+    });
+
+    it('should shutdown in dev mode', () => {
+      mockConfigService.get.mockReturnValue({ isDev: true });
+      controller.shutdown();
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(mockLog).toHaveBeenCalledWith('Bye bye!');
+    });
+
+    it('should shutdown in test mode', () => {
+      mockConfigService.get.mockReturnValue({ isTest: true });
+      controller.shutdown();
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(mockLog).toHaveBeenCalledWith('Bye bye!');
+    });
+
+    it('should not shutdown if neither dev nor test', () => {
+      mockConfigService.get.mockReturnValue({ isDev: false, isTest: false });
+      controller.shutdown();
+      expect(mockExit).not.toHaveBeenCalled();
+      expect(mockLog).not.toHaveBeenCalled();
+    });
+
+    it('should not shutdown if conf is missing', () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      controller.shutdown();
+      expect(mockExit).not.toHaveBeenCalled();
+      expect(mockLog).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -1,39 +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();
-  });
-});
+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

@@ -1,33 +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);
-  });
-});
+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

@@ -1,48 +1,57 @@
-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 ======================',
-    );
-  });
-});
+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 ======================',
+    );
+  });
+
+  it('should have onModuleInit', () => {
+    const loggerMock = { debug: jest.fn() } as any;
+    const appContextServiceMock = { initializedApps: new Set() } as any;
+    const handler = new LifeCycleHandler(loggerMock, 'test', appContextServiceMock);
+    handler.onModuleInit();
+    expect(handler).toBeDefined();
+  });
+});

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

@@ -1,52 +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);
-  });
-});
+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);
+  });
+});