@dismissible/nestjs-api 0.0.2-canary.8976e84.0 → 0.0.2-canary.b0d8bfe.0

package/src/app-test.factory.ts

@@ -1,5 +1,6 @@
 import { Test, TestingModuleBuilder } from '@nestjs/testing';
 import { INestApplication } from '@nestjs/common';
+import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
 import { AppModule, AppModuleOptions } from './app.module';
 import { configureApp } from './app.setup';
 import { PrismaService } from '@dismissible/nestjs-postgres-storage';
@@ -19,10 +20,16 @@ export async function createTestApp(options?: TestAppOptions): Promise<INestAppl
   }
 
   const moduleFixture = await builder.compile();
-  const app = moduleFixture.createNestApplication();
+  const app = moduleFixture.createNestApplication<NestFastifyApplication>(
+    new FastifyAdapter({
+      bodyLimit: 10 * 1024, // 10kb
+    }),
+  );
   await configureApp(app);
   await app.init();
 
+  await app.getHttpAdapter().getInstance().ready();
+
   return app;
 }
 

package/src/app.module.ts

@@ -1,4 +1,4 @@
-import { Module, ModuleMetadata, Type } from '@nestjs/common';
+import { DynamicModule, Module, ModuleMetadata, Type } from '@nestjs/common';
 import { HealthModule } from './health';
 import { ConfigModule } from './config';
 import { AppConfig } from './config/app.config';
@@ -7,11 +7,17 @@ import { DismissibleModule } from '@dismissible/nestjs-dismissible';
 import { IDismissibleLogger } from '@dismissible/nestjs-logger';
 import { DefaultAppConfig } from './config/default-app.config';
 import { PostgresStorageConfig, PostgresStorageModule } from '@dismissible/nestjs-postgres-storage';
+import {
+  JwtAuthHookModule,
+  JwtAuthHook,
+  JwtAuthHookConfig,
+} from '@dismissible/nestjs-jwt-auth-hook';
 
 export type AppModuleOptions = {
   configPath?: string;
   schema?: new () => DefaultAppConfig;
   logger?: Type<IDismissibleLogger>;
+  imports?: DynamicModule[];
 };
 
 @Module({})
@@ -31,8 +37,14 @@ export class AppModule {
           schema: options?.schema ?? AppConfig,
         }),
         HealthModule,
+        ...(options?.imports ?? []),
+        JwtAuthHookModule.forRootAsync({
+          useFactory: (config: JwtAuthHookConfig) => config,
+          inject: [JwtAuthHookConfig],
+        }),
         DismissibleModule.forRoot({
           logger: options?.logger,
+          hooks: [JwtAuthHook],
           storage: PostgresStorageModule.forRootAsync({
             useFactory(config: PostgresStorageConfig) {
               return {

package/src/app.setup.ts

@@ -1,14 +1,49 @@
 import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { NestFastifyApplication } from '@nestjs/platform-fastify';
+import fastifyHelmet from '@fastify/helmet';
 import { SwaggerConfig, configureAppWithSwagger } from './swagger';
+import { CorsConfig } from './cors';
+import { HelmetConfig } from './helmet';
+import { ValidationConfig } from './validation';
 
 export async function configureApp(app: INestApplication): Promise<void> {
-  // Global validation pipe for request validation
+  const fastifyApp = app as NestFastifyApplication;
+
+  const helmetConfig = app.get(HelmetConfig);
+  if (helmetConfig.enabled) {
+    await fastifyApp.register(fastifyHelmet, {
+      contentSecurityPolicy: helmetConfig.contentSecurityPolicy ?? true,
+      crossOriginEmbedderPolicy: helmetConfig.crossOriginEmbedderPolicy ?? true,
+      hsts: {
+        maxAge: helmetConfig.hstsMaxAge ?? 31536000,
+        includeSubDomains: helmetConfig.hstsIncludeSubDomains ?? true,
+        preload: helmetConfig.hstsPreload ?? false,
+      },
+    });
+  }
+
+  const corsConfig = app.get(CorsConfig);
+  if (corsConfig.enabled) {
+    app.enableCors({
+      origin: corsConfig.origins ?? ['http://localhost:3001', 'http://localhost:5173'],
+      methods: corsConfig.methods ?? ['GET', 'POST', 'DELETE', 'OPTIONS'],
+      allowedHeaders: corsConfig.allowedHeaders ?? [
+        'Content-Type',
+        'Authorization',
+        'x-request-id',
+      ],
+      credentials: corsConfig.credentials ?? true,
+      maxAge: corsConfig.maxAge ?? 86400,
+    });
+  }
+
+  const validationConfig = app.get(ValidationConfig);
   app.useGlobalPipes(
     new ValidationPipe({
-      whitelist: true,
-      forbidNonWhitelisted: true,
-      transform: true,
-      disableErrorMessages: false,
+      whitelist: validationConfig.whitelist ?? true,
+      forbidNonWhitelisted: validationConfig.forbidNonWhitelisted ?? true,
+      transform: validationConfig.transform ?? true,
+      disableErrorMessages: validationConfig.disableErrorMessages ?? true,
     }),
   );
 

package/src/bootstrap.ts

@@ -1,4 +1,5 @@
 import { NestFactory } from '@nestjs/core';
+import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
 import { AppModule } from './app.module';
 import { ServerConfig } from './server/server.config';
 import { configureApp } from './app.setup';
@@ -13,12 +14,16 @@ export type IBootstrapOptions = {
 };
 
 export async function bootstrap(options?: IBootstrapOptions) {
-  const app = await NestFactory.create(AppModule.forRoot(options));
-
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule.forRoot(options),
+    new FastifyAdapter({
+      bodyLimit: 10 * 1024, // 10kb
+    }),
+  );
   await configureApp(app);
 
   const serverConfig = app.get(ServerConfig);
   const port = serverConfig.port ?? 3000;
-  await app.listen(port);
+  await app.listen(port, '0.0.0.0');
   console.log(`🚀 Application is running on: http://localhost:${port}`);
 }

package/src/config/app.config.spec.ts

@@ -0,0 +1,117 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { AppConfig } from './app.config';
+import { SwaggerConfig } from '../swagger/swagger.config';
+import { PostgresStorageConfig } from '@dismissible/nestjs-postgres-storage';
+import { JwtAuthHookConfig } from '@dismissible/nestjs-jwt-auth-hook';
+
+describe('AppConfig', () => {
+  describe('transformation', () => {
+    it('should transform all nested configs correctly', () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+
+      expect(config.swagger).toBeInstanceOf(SwaggerConfig);
+      expect(config.swagger.enabled).toBe(true);
+      expect(config.db).toBeInstanceOf(PostgresStorageConfig);
+      expect(config.db.connectionString).toBe('postgresql://localhost:5432/test');
+      expect(config.jwtAuth).toBeInstanceOf(JwtAuthHookConfig);
+      expect(config.jwtAuth.enabled).toBe(true);
+      expect(config.jwtAuth.wellKnownUrl).toBe(
+        'https://auth.example.com/.well-known/openid-configuration',
+      );
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with all required nested configs', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when swagger config has invalid nested property', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true, path: 123 },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const swaggerError = errors.find((e) => e.property === 'swagger');
+      expect(swaggerError).toBeDefined();
+    });
+
+    it('should fail validation when db config is invalid', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 123 },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const dbError = errors.find((e) => e.property === 'db');
+      expect(dbError).toBeDefined();
+    });
+
+    it('should fail validation when jwtAuth config is invalid', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: { enabled: true, wellKnownUrl: 'not-a-valid-url' },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const jwtAuthError = errors.find((e) => e.property === 'jwtAuth');
+      expect(jwtAuthError).toBeDefined();
+    });
+
+    it('should fail validation when jwtAuth enabled is false but wellKnownUrl is required', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: { enabled: false },
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+  });
+});

package/src/config/app.config.ts

@@ -3,6 +3,7 @@ import { Type } from 'class-transformer';
 import { SwaggerConfig } from '../swagger';
 import { DefaultAppConfig } from './default-app.config';
 import { PostgresStorageConfig } from '@dismissible/nestjs-postgres-storage';
+import { JwtAuthHookConfig } from '@dismissible/nestjs-jwt-auth-hook';
 
 export class AppConfig extends DefaultAppConfig {
   @ValidateNested()
@@ -12,4 +13,8 @@ export class AppConfig extends DefaultAppConfig {
   @ValidateNested()
   @Type(() => PostgresStorageConfig)
   public readonly db!: PostgresStorageConfig;
+
+  @ValidateNested()
+  @Type(() => JwtAuthHookConfig)
+  public readonly jwtAuth!: JwtAuthHookConfig;
 }

package/src/config/config.module.spec.ts

@@ -2,7 +2,6 @@ import { ConfigModule } from './config.module';
 import { TypedConfigModule } from 'nest-typed-config';
 import { fileLoader } from 'nest-typed-config';
 
-// Mock nest-typed-config
 jest.mock('nest-typed-config', () => ({
   TypedConfigModule: {
     forRoot: jest.fn(),
@@ -10,7 +9,6 @@ jest.mock('nest-typed-config', () => ({
   fileLoader: jest.fn(),
 }));
 
-// Mock path
 jest.mock('path', () => ({
   join: jest.fn((...args) => args.join('/')),
 }));

package/src/config/default-app.config.spec.ts

@@ -0,0 +1,74 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { DefaultAppConfig } from './default-app.config';
+import { ServerConfig } from '../server/server.config';
+import { CorsConfig } from '../cors/cors.config';
+import { HelmetConfig } from '../helmet/helmet.config';
+
+describe('DefaultAppConfig', () => {
+  describe('transformation', () => {
+    it('should transform all nested configs correctly', () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+
+      expect(config.server).toBeInstanceOf(ServerConfig);
+      expect(config.server.port).toBe(3001);
+      expect(config.cors).toBeInstanceOf(CorsConfig);
+      expect(config.cors.enabled).toBe(true);
+      expect(config.helmet).toBeInstanceOf(HelmetConfig);
+      expect(config.helmet.enabled).toBe(true);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with all required nested configs', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when server config is invalid', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 'not-a-number' },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const serverError = errors.find((e) => e.property === 'server');
+      expect(serverError).toBeDefined();
+    });
+
+    it('should fail validation when cors config has invalid nested property', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true, maxAge: 'not-a-number' },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const corsError = errors.find((e) => e.property === 'cors');
+      expect(corsError).toBeDefined();
+    });
+
+    it('should fail validation when helmet config has invalid nested property', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true, hstsMaxAge: 'not-a-number' },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const helmetError = errors.find((e) => e.property === 'helmet');
+      expect(helmetError).toBeDefined();
+    });
+  });
+});

package/src/config/default-app.config.ts

@@ -1,9 +1,24 @@
 import { ValidateNested } from 'class-validator';
 import { Type } from 'class-transformer';
 import { ServerConfig } from '../server/server.config';
+import { CorsConfig } from '../cors';
+import { HelmetConfig } from '../helmet';
+import { ValidationConfig } from '../validation';
 
 export class DefaultAppConfig {
   @ValidateNested()
   @Type(() => ServerConfig)
   public readonly server!: ServerConfig;
+
+  @ValidateNested()
+  @Type(() => CorsConfig)
+  public readonly cors!: CorsConfig;
+
+  @ValidateNested()
+  @Type(() => HelmetConfig)
+  public readonly helmet!: HelmetConfig;
+
+  @ValidateNested()
+  @Type(() => ValidationConfig)
+  public readonly validation!: ValidationConfig;
 }

package/src/cors/cors.config.spec.ts

@@ -0,0 +1,162 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CorsConfig } from './cors.config';
+
+describe('CorsConfig', () => {
+  describe('enabled', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: 'true' });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: 'false' });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should keep boolean true as true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should keep boolean false as false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: false });
+      expect(config.enabled).toBe(false);
+    });
+  });
+
+  describe('origins', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000,http://localhost:4000',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+
+    it('should trim whitespace from origins', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000 , http://localhost:4000 ',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+
+    it('should handle single origin string', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000']);
+    });
+
+    it('should keep array as array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: ['http://localhost:3000', 'http://localhost:4000'],
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+  });
+
+  describe('methods', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        methods: 'GET,POST,DELETE',
+      });
+      expect(config.methods).toEqual(['GET', 'POST', 'DELETE']);
+    });
+
+    it('should trim whitespace from methods', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        methods: 'GET , POST , DELETE',
+      });
+      expect(config.methods).toEqual(['GET', 'POST', 'DELETE']);
+    });
+  });
+
+  describe('allowedHeaders', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        allowedHeaders: 'Content-Type,Authorization,x-request-id',
+      });
+      expect(config.allowedHeaders).toEqual(['Content-Type', 'Authorization', 'x-request-id']);
+    });
+
+    it('should trim whitespace from headers', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        allowedHeaders: 'Content-Type , Authorization , x-request-id',
+      });
+      expect(config.allowedHeaders).toEqual(['Content-Type', 'Authorization', 'x-request-id']);
+    });
+  });
+
+  describe('credentials', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, credentials: 'true' });
+      expect(config.credentials).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, credentials: 'false' });
+      expect(config.credentials).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(CorsConfig, { enabled: true, credentials: true });
+      const configFalse = plainToInstance(CorsConfig, { enabled: true, credentials: false });
+      expect(configTrue.credentials).toBe(true);
+      expect(configFalse.credentials).toBe(false);
+    });
+  });
+
+  describe('maxAge', () => {
+    it('should transform string to number', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, maxAge: '86400' });
+      expect(config.maxAge).toBe(86400);
+    });
+
+    it('should keep number unchanged', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, maxAge: 3600 });
+      expect(config.maxAge).toBe(3600);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with valid config', async () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: ['http://localhost:3000'],
+        methods: ['GET', 'POST'],
+        allowedHeaders: ['Content-Type'],
+        credentials: true,
+        maxAge: 86400,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation with only required fields', async () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when enabled is missing', async () => {
+      const config = plainToInstance(CorsConfig, {});
+
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+  });
+});

package/src/cors/cors.config.ts

@@ -0,0 +1,37 @@
+import { IsArray, IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
+import { Type } from 'class-transformer';
+import { TransformBoolean, TransformCommaSeparated } from '@dismissible/nestjs-validation';
+
+export class CorsConfig {
+  @IsBoolean()
+  @TransformBoolean()
+  public readonly enabled!: boolean;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly origins?: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly methods?: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly allowedHeaders?: string[];
+
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly credentials?: boolean;
+
+  @IsNumber()
+  @IsOptional()
+  @Type(() => Number)
+  public readonly maxAge?: number;
+}

package/src/cors/index.ts

@@ -0,0 +1 @@
+export * from './cors.config';

package/src/health/health.controller.spec.ts

@@ -1,48 +1,24 @@
-import { mock, Mock } from 'ts-jest-mocker';
 import { HealthController } from './health.controller';
-import { HealthService } from './health.service';
 
 describe('HealthController', () => {
   let controller: HealthController;
-  let healthService: Mock<HealthService>;
 
   beforeEach(() => {
-    healthService = mock<HealthService>({
-      failIfMockNotProvided: false,
-    });
-    controller = new HealthController(healthService);
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2024-01-20T15:30:00.000Z'));
+    controller = new HealthController();
   });
 
-  describe('getHealth', () => {
-    it('should return health status from service', () => {
-      const mockHealth = {
-        status: 'ok',
-        timestamp: '2024-01-15T10:00:00.000Z',
-        uptime: 123.45,
-      };
-
-      healthService.getHealth.mockReturnValue(mockHealth);
-
-      const result = controller.getHealth();
-
-      expect(result).toEqual(mockHealth);
-      expect(healthService.getHealth).toHaveBeenCalledTimes(1);
-    });
+  afterEach(() => {
+    jest.useRealTimers();
+  });
 
+  describe('getHealth', () => {
     it('should return the exact response from service', () => {
-      const mockHealth = {
-        status: 'ok',
-        timestamp: '2024-01-20T15:30:00.000Z',
-        uptime: 999.99,
-      };
-
-      healthService.getHealth.mockReturnValue(mockHealth);
-
       const result = controller.getHealth();
 
       expect(result.status).toBe('ok');
       expect(result.timestamp).toBe('2024-01-20T15:30:00.000Z');
-      expect(result.uptime).toBe(999.99);
     });
   });
 });

package/src/health/health.controller.ts

@@ -1,17 +1,16 @@
 import { Controller, Get, HttpCode, HttpStatus } from '@nestjs/common';
-import { HealthService } from './health.service';
 
 @Controller('health')
 export class HealthController {
-  constructor(private readonly healthService: HealthService) {}
-
   @Get()
   @HttpCode(HttpStatus.OK)
   getHealth(): {
     status: string;
     timestamp: string;
-    uptime: number;
   } {
-    return this.healthService.getHealth();
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+    };
   }
 }