Merge pull request #12 from alkem-io/develop

Release v0.1.1

package.json

@@ -1,6 +1,6 @@
 {
   "name": "file-service",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A file serving microservice for the Alkemio platform",
   "main": "main.ts",
   "scripts": {

src/app.module.ts

@@ -2,10 +2,10 @@ import { WinstonModule } from 'nest-winston';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { WinstonConfigService } from './config';
-import { AppController } from './app.controller';
 import configuration from './config/configuration';
 import { FileModule } from './services/file-reader';
 import { BaseExceptionFilterProvider } from './core/filters';
+import { HealthModule } from './services/health';
 
 @Module({
   imports: [
@@ -18,8 +18,8 @@ import { BaseExceptionFilterProvider } from './core/filters';
       useClass: WinstonConfigService,
     }),
     FileModule,
+    HealthModule,
   ],
-  controllers: [AppController],
   providers: [BaseExceptionFilterProvider],
 })
 export class AppModule {}

src/main.ts

@@ -29,8 +29,18 @@ const isProd = process.env.NODE_ENV === 'production';
   const logger = app.get(WINSTON_MODULE_NEST_PROVIDER);
   app.useLogger(logger);
 
+  app.enableCors({
+    origin: '*',
+    allowedHeaders: [
+      'Origin,X-Requested-With',
+      'Content-Type,Accept',
+      'Authorization',
+    ],
+    methods: ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'],
+  });
+
   await app.register(fastifyCookie);
-  await app.register(helmet);
+  await app.register(helmet, { contentSecurityPolicy: false });
 
   const configService: ConfigService<ConfigType, true> = app.get(ConfigService);
   const port = configService.get('settings.application.port', { infer: true });

src/services/file-reader/file.adapter.service.ts

@@ -3,19 +3,20 @@ import { firstValueFrom, map, timeInterval, timeout } from 'rxjs';
 import { Inject, Injectable, LoggerService } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import {
-  ClientProxy,
   ClientProxyFactory,
   RmqOptions,
   Transport,
 } from '@nestjs/microservices';
 import { ConfigType } from 'src/config';
 import { FileMessagePatternEnum } from './file.message.pattern.enum';
 import { FileInfoInputData } from './inputs';
-import { FileInfoOutputData } from './outputs';
+import { FileInfoOutputData, HealthCheckOutputData } from './outputs';
+import { ClientRMQ } from '@nestjs/microservices/client/client-rmq';
+import { RMQConnectionError } from './types';
 
 @Injectable()
 export class FileAdapterService {
-  private readonly client: ClientProxy | undefined;
+  private readonly client: ClientRMQ | undefined;
   private readonly timeoutMs: number;
 
   constructor(
@@ -49,14 +50,29 @@ export class FileAdapterService {
           'Client proxy successfully connected to RabbitMQ',
         );
       })
-      .catch(this.logger.error);
+      .catch(({ err }: RMQConnectionError) =>
+        this.logger.error(err, err.stack),
+      );
 
     this.timeoutMs = this.configService.get(
       'settings.application.response_timeout',
       { infer: true },
     );
   }
 
+  /**
+   * Is there a healthy connection to the queue
+   */
+  public async isConnected(): Promise<boolean> {
+    return this.sendWithResponse<HealthCheckOutputData, string>(
+      FileMessagePatternEnum.HEALTH_CHECK,
+      'healthy?',
+      { timeoutMs: 3000 },
+    )
+      .then((resp) => resp.healthy)
+      .catch(() => false);
+  }
+
   /**
    * Give information about a file. Access of the requester to that file and metadata.
    * This method sends a request to the queue and waits for a response.
@@ -79,16 +95,20 @@ export class FileAdapterService {
    * Each consumer needs to manually handle failures, returning the proper type.
    * @param pattern
    * @param data
+   * @param options
    * @throws Error
    */
   private sendWithResponse = async <TResult, TInput>(
     pattern: FileMessagePatternEnum,
     data: TInput,
+    options?: { timeoutMs?: number },
   ): Promise<TResult | never> => {
     if (!this.client) {
       throw new Error(`Connection was not established. Send failed.`);
     }
 
+    const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
+
     const result$ = this.client.send<TResult, TInput>(pattern, data).pipe(
       timeInterval(),
       map((x) => {
@@ -100,17 +120,17 @@ export class FileAdapterService {
         });
         return x.value;
       }),
-      timeout({ each: this.timeoutMs }),
+      timeout({ each: timeoutMs }),
     );
 
-    return firstValueFrom(result$).catch((err) => {
+    return firstValueFrom(result$).catch(({ err }: RMQConnectionError) => {
       this.logger.error(
-        err?.message ?? err,
-        err?.stack,
+        err.message,
+        err.stack,
         JSON.stringify({
           pattern,
           data,
-          timeout: this.timeoutMs,
+          timeout: timeoutMs,
         }),
       );
 
@@ -129,7 +149,7 @@ const authQueueClientProxyFactory = (
     queue: string;
   },
   logger: LoggerService,
-): ClientProxy | undefined => {
+): ClientRMQ | undefined => {
   const { host, port, user, password, heartbeat: _heartbeat, queue } = config;
   const heartbeat =
     process.env.NODE_ENV === 'production' ? _heartbeat : _heartbeat * 3;
@@ -153,7 +173,7 @@ const authQueueClientProxyFactory = (
         noAck: true,
       },
     };
-    return ClientProxyFactory.create(options);
+    return ClientProxyFactory.create(options) as ClientRMQ;
   } catch (err) {
     logger.error(`Could not connect to RabbitMQ: ${err}`);
     return undefined;

src/services/file-reader/file.message.pattern.enum.ts

@@ -1,3 +1,4 @@
 export enum FileMessagePatternEnum {
   FILE_INFO = 'file-info',
+  HEALTH_CHECK = 'health-check',
 }

src/services/file-reader/file.service.ts

@@ -42,6 +42,10 @@ export class FileService {
     this.logger.verbose?.(`Serving files from ${this.storagePath}`);
   }
 
+  public isConnected(): Promise<boolean> {
+    return this.adapter.isConnected();
+  }
+
   public async fileInfo(
     docId: string,
     auth: {

src/services/file-reader/outputs/base.output.data.ts

@@ -0,0 +1,3 @@
+export class BaseOutputData {
+  constructor(public event: string) {}
+}

src/services/file-reader/outputs/health.check.output.data.ts

@@ -0,0 +1,7 @@
+import { BaseOutputData } from './base.output.data';
+
+export class HealthCheckOutputData extends BaseOutputData {
+  constructor(public healthy: boolean) {
+    super('health-check-output');
+  }
+}

src/services/file-reader/outputs/index.ts

@@ -1 +1,2 @@
 export * from './file.info.output.data';
+export * from './health.check.output.data';

src/services/file-reader/types/index.ts

@@ -1,2 +1,3 @@
 export * from './document.data';
 export * from './file.info.error.code';
+export * from './rmq.connection.error';

src/services/file-reader/types/rmq.connection.error.ts

@@ -0,0 +1,14 @@
+export type RMQConnectionError = {
+  err: {
+    stack: string;
+    message: string;
+  };
+  url: {
+    protocol: string;
+    hostname: string;
+    username: string;
+    password: string;
+    port: number;
+    heartbeat: number;
+  };
+};

src/services/health/health.controller.ts

@@ -0,0 +1,15 @@
+import { Controller, Get, HttpException, HttpStatus } from '@nestjs/common';
+import { FileService } from '../file-reader';
+
+@Controller('/health')
+export class HealthController {
+  constructor(private readonly fileService: FileService) {}
+  @Get('/')
+  public async getHello(): Promise<string> {
+    if (!(await this.fileService.isConnected())) {
+      throw new HttpException('unhealthy!', HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+
+    return 'healthy!';
+  }
+}

src/services/health/health.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { FileModule } from '../file-reader';
+import { HealthController } from './health.controller';
+
+@Module({
+  imports: [FileModule],
+  controllers: [HealthController],
+})
+export class HealthModule {}

src/services/health/index.ts

@@ -0,0 +1 @@
+export * from './health.module';