feat: setup JSend and config

.env.sample

@@ -3,3 +3,6 @@ DBURL=mongodb://username:password@localhost:27017/?authSource=admin&readPreferen
 
 # Port to run our api on
 PORT=3000
+
+# Access-Control-Allow-Origins CORS header
+CORS_ORIGINS=localhost

.gitignore

@@ -1,3 +1,6 @@
+# environment config
+.env
+
 # compiled output
 /dist
 /node_modules

package.json

@@ -22,8 +22,12 @@
   },
   "dependencies": {
     "@nestjs/common": "^8.0.0",
+    "@nestjs/config": "^1.1.5",
     "@nestjs/core": "^8.0.0",
     "@nestjs/platform-express": "^8.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.13.2",
+    "joi": "^17.5.0",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
     "rxjs": "^7.2.0"

src/app.module.ts

@@ -1,12 +1,22 @@
 import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
 import { AppController } from './app.controller';
+import { AllHttpExceptionsFilter } from './common';
+import { configuration } from './config/configuration';
+import { validationSchema } from './config/validation';
 import { FavoriteModule } from './favorite/favorite.module';
 import { ProfileModule } from './profile/profile.module';
 import { SimulatorModule } from './simulator/simulator.module';
 
 @Module({
-  imports: [FavoriteModule, ProfileModule, SimulatorModule],
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+      validationSchema: validationSchema,
+    }),
+    FavoriteModule, ProfileModule, SimulatorModule],
   controllers: [AppController],
-  providers: [],
+  providers: [AllHttpExceptionsFilter],
 })
 export class AppModule {}

src/common/exceptions/http-validation-exception.ts

@@ -0,0 +1,43 @@
+import {
+  HttpException,
+  HttpStatus,
+  ValidationError as NestValidationError,
+} from '@nestjs/common';
+import { ValidationError } from '../interfaces';
+
+export class HttpValidationException extends HttpException {
+  constructor(validationErrors: NestValidationError[]) {
+    let errors: ValidationError[] = [];
+
+    for (const error of validationErrors) {
+      errors = errors.concat(HttpValidationException.exportErrors(error));
+    }
+
+    super(errors, HttpStatus.OK);
+  }
+
+  private static exportErrors(
+    error: NestValidationError,
+    propertyPrefix = '',
+  ): ValidationError[] {
+    let errors: ValidationError[] = [];
+
+    for (const constraint in error.constraints) {
+      errors.push({
+        property: propertyPrefix + error.property,
+        constraint,
+        error: error.constraints[constraint],
+      });
+    }
+
+    error.children.forEach((child) => {
+      const childErrors = this.exportErrors(
+        child,
+        propertyPrefix + error.property + '.',
+      );
+      errors = errors.concat(childErrors);
+    });
+
+    return errors;
+  }
+}

src/common/exceptions/index.ts

@@ -0,0 +1 @@
+export * from './http-validation-exception';

src/common/filters/all-http-exceptions.filter.ts

@@ -0,0 +1,67 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { HttpValidationException } from '../exceptions';
+import {
+  JSendErrorResponse, JSendFailResponse, ValidationError
+} from '../interfaces';
+
+@Catch()
+export class AllHttpExceptionsFilter implements ExceptionFilter {
+  constructor() {}
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const response = host.switchToHttp().getResponse<Response>();
+    this.handleException(response, exception);
+  }
+
+  private handleException(response: Response, exception: unknown): void {
+    if (exception instanceof HttpValidationException) {
+      // If Validation Error => Respond with JSend Fail
+      const errors = exception.getResponse() as ValidationError[]
+
+      const result: JSendFailResponse<any> = {
+        status: 'fail',
+        data: errors.reduce((previous, current) => {
+          previous[current.property] = current.error
+          return previous
+        }, {})
+      };
+
+      response.status(400).send(result);
+    } else if (exception instanceof HttpException) {
+      const result: JSendErrorResponse = {
+        status: 'error',
+        code: exception.getStatus(),
+        message: exception.message,
+      };
+
+      // Include stack trace
+      // result.data = exception.stack
+
+      response.status(exception.getStatus()).send(result);
+    } else if (typeof (exception as any).message === 'string') {
+      const result: JSendErrorResponse = {
+        status: 'error',
+        message: (exception as any).message,
+      };
+
+      // Include stack trace
+      // result.data = exception
+
+      response.status(500).send(result);
+    } else {
+      const result: JSendErrorResponse = {
+        status: 'error',
+        message: 'Unhandled error occurred',
+        data: exception
+      };
+      response.status(500).send(result);
+    }
+
+  }
+}

src/common/filters/index.ts

@@ -0,0 +1 @@
+export * from './all-http-exceptions.filter';

src/common/index.ts

@@ -0,0 +1,4 @@
+export * from './exceptions'
+export * from './filters';
+export * from './interfaces';
+export * from './interceptors'

src/common/interceptors/index.ts

@@ -0,0 +1 @@
+export * from './jsend.interceptor';

src/common/interceptors/jsend.interceptor.spec.ts

@@ -0,0 +1,7 @@
+import { JsendInterceptor } from './jsend.interceptor';
+
+describe('JsendInterceptor', () => {
+  it('should be defined', () => {
+    expect(new JsendInterceptor()).toBeDefined();
+  });
+});

src/common/interceptors/jsend.interceptor.ts

@@ -0,0 +1,21 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { JSendSuccessResponse } from '../interfaces';
+
+@Injectable()
+export class JsendInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(map((data: unknown) => {
+      if (data === undefined) {
+        data = null
+      }
+
+      const response: JSendSuccessResponse<typeof data> = {
+        status: 'success',
+        data
+      }
+      return response
+    }));
+  }
+}

src/common/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './responses';
+export * from './validation-error.interface'

src/common/interfaces/responses/index.ts

@@ -0,0 +1,2 @@
+export * from './jsend';
+export * from './response-message'

src/common/interfaces/responses/jsend/index.ts

@@ -0,0 +1,4 @@
+export * from './jsend-error-response';
+export * from './jsend-fail-response';
+export * from './jsend-response';
+export * from './jsend-success-response';

src/common/interfaces/responses/jsend/jsend-error-response.ts

@@ -0,0 +1,41 @@
+
+/**
+ * ## Generic JSend Error Response
+ * 
+ * When an API call fails due to an error on the server. For example:
+ * #### GET /posts.json: ####
+ * ```
+ * {
+ *     "status" : "error",
+ *     "message" : "Unable to communicate with database"
+ * }
+ * ```
+ * Required keys:
+ * * status: Should always be set to "error".
+ * * message: A meaningful, end-user-readable (or at the least log-worthy) message, explaining what went wrong.
+ * 
+ * Optional keys:
+ * * code: A numeric code corresponding to the error, if applicable
+ * * data: A generic container for any other information about the error, i.e. the conditions that caused the error, stack traces, etc.
+ */
+export interface JSendErrorResponse {
+    /**
+     * Should always be set to "error"
+     */
+    status: 'error'
+
+    /**
+     * A meaningful, end-user-readable (or at the least log-worthy) message, explaining what went wrong.
+     */
+    message: string
+
+    /**
+     * A numeric code corresponding to the error, if applicable
+     */
+     code?: number
+
+    /**
+     * A generic container for any other information about the error, i.e. the conditions that caused the error, stack traces, etc.
+     */
+     data?: any
+}

src/common/interfaces/responses/jsend/jsend-fail-response.ts

@@ -0,0 +1,27 @@
+/**
+ * Generic JSend Fail Response
+ * When an API call is rejected due to invalid data or call conditions, the JSend object's data key contains an object explaining what went wrong, typically a hash of validation errors. For example:
+ * #### POST /posts.json (with data body: "Trying to creating a blog post"): ####
+ * ```
+ * {
+ *     "status" : "fail",
+ *     "data" : { "title" : "A title is required" }
+ * }
+ * ```
+ * Required keys:
+ * 
+ * * status: Should always be set to "fail".
+ * * data: Provides the wrapper for the details of why the request failed. If the reasons for failure correspond to POST values, the response object's keys SHOULD correspond to those POST values.
+ */
+export interface JSendFailResponse<T> {
+    /**
+     * Should always be set to "fail".
+     */
+    status: 'fail'
+
+    /**
+     * Provides the wrapper for the details of why the request failed.
+     * If the reasons for failure correspond to POST values, the response object's keys SHOULD correspond to those POST values.
+     */
+    data: T
+}

src/common/interfaces/responses/jsend/jsend-response.ts

@@ -0,0 +1,27 @@
+/**
+ * Generic JSend Response
+ * https://github.com/omniti-labs/jsend
+ */
+export interface JSendResponse<T> {
+    /**
+     * success:	All went well, and (usually) some data was returned.
+     * fail: There was a problem with the data submitted, or some pre-condition of the API call wasn't satisfied
+     * error: An error occurred in processing the request, i.e. an exception was thrown
+     */
+    status: 'success' | 'fail' | 'error'
+
+    /**
+     * Acts as the wrapper for any data returned by the API call. If the call returns no data, data should be set to null.
+     */
+    data: T
+
+    /**
+     * Only for error
+     */
+     code: string | undefined
+
+    /**
+     * Only for error
+     */
+    message: string | undefined
+}

src/common/interfaces/responses/jsend/jsend-success-response.ts

@@ -0,0 +1,45 @@
+/**
+ * Generic JSend Success Response
+ * When an API call is successful, the JSend object is used as a simple envelope for the results, using the data key, as in the following:
+ * #### GET /posts.json: ####
+ * ```
+ * {
+ *     status : "success",
+ *     data : {
+ *         "posts" : [
+ *             { "id" : 1, "title" : "A blog post", "body" : "Some useful content" },
+ *             { "id" : 2, "title" : "Another blog post", "body" : "More content" },
+ *         ]
+ *      }
+ * }
+ * ```
+ * #### GET /posts/2.json: ####
+ * ```
+ * {
+ *     status : "success",
+ *     data : { "post" : { "id" : 2, "title" : "Another blog post", "body" : "More content" }}
+ * }
+ * ```
+ * #### DELETE /posts/2.json: ####
+ * ```
+ * {
+ *     status : "success",
+ *     data : null
+ * }
+ * ```
+ * Required keys:
+ * 
+ * * status: Should always be set to "success".
+ * * data: Acts as the wrapper for any data returned by the API call. If the call returns no data (as in the last example), data should be set to null.
+ */
+export interface JSendSuccessResponse<T> {
+    /**
+     * Should always be success
+     */
+    status: 'success'
+
+    /**
+     * Acts as the wrapper for any data returned by the API call. If the call returns no data, data should be set to null.
+     */
+    data: T
+}

src/common/interfaces/responses/response-message.ts

@@ -0,0 +1,3 @@
+export interface ResponseMessage {
+    message: string
+}

src/common/interfaces/validation-error.interface.ts

@@ -0,0 +1,16 @@
+export interface ValidationError {
+  /**
+   * Property which rejected in validation check
+   */
+  property: string;
+
+  /**
+   * Constraint which caused the validation to be rejected
+   */
+  constraint: string;
+
+  /**
+   * Error message
+   */
+  error: string;
+}

src/config/configuration.ts

@@ -0,0 +1,8 @@
+export const configuration = () => {
+  return {
+    environment: process.env.NODE_ENV,
+    port: parseInt(process.env.PORT, 10) || 3000,
+    db_url: process.env.DB_URL,
+    cors_origins: process.env.CORS_ORIGINS
+  }
+}