Merge pull request #94 from pharindoko/feat/add-pre-validation

Feat/add pre validation

Author: pharindoko

README.md

@@ -171,6 +171,7 @@ curl -H "x-api-key: {API-KEY}" -H "Content-Type: application/json" https://xxxxx
 | enableSwagger  | Enable swagger and swagger UI support  | string | true |
 | enableApiKeyAuth  | Make your routes private by using an additional ApiKey | boolean | false |
 | jsonFile  | path of json file that will be used  | string | db.json |
+| enableJSONValidation  | validate JSON file at start | boolean | true |
 
 ## Used Packages
 

src/server/app/app.config.ts

@@ -3,6 +3,7 @@ export class AppConfig {
   enableSwagger = true;
   enableApiKeyAuth = false;
   jsonFile = 'db.json';
+  enableJSONValidation = true;
 
   static merge = <T, U>(t: T, u: U) => Object.assign({}, t, u);
 }

src/server/app/cloud.app.ts

@@ -1,17 +1,17 @@
 import { CoreApp } from './core.app';
-
+import { Output } from '../utils/output';
 export class CloudApp extends CoreApp {
   request = async () => {
     try {
       const { middlewares, router } = await this.initializeLayers();
       this.setupServer(middlewares, router);
     } catch (e) {
       if (e.code === 'ExpiredToken') {
-        this.logger.error(
+        Output.setError(
           `Please add valid credentials for AWS. Error: ${e.message}`
         );
       } else {
-        this.logger.error(e);
+        Output.setError(e.message);
       }
     }
   };

src/server/app/core.app.ts

@@ -5,9 +5,13 @@ import express from 'express';
 import jsonServer = require('json-server');
 import { StorageAdapter } from '../storage/storage';
 import { ApiSpecification } from '../specifications/apispecification';
+import { JSONValidator } from '../validations/json.validator';
+import { Output } from '../utils/output';
+
 export class CoreApp {
   storageAdapter: StorageAdapter;
   static storage = {} as lowdb.AdapterAsync;
+  static adapter = {} as lowdb.LowdbAsync<{}>;
   logger = new Logger().logger;
   appConfig: AppConfig;
   protected server: express.Express;
@@ -27,19 +31,38 @@ export class CoreApp {
 
   async setup(): Promise<void> {
     await this.setupStorage();
-    const json = await this.setupApp();
-    await this.setupSwagger(json);
-    await this.setupRoutes();
+    const json = await this.getJSON();
+    const isValid = this.validateJSON(json);
+    if (isValid) {
+      await this.setupApp();
+      this.setupSwagger(json);
+      await this.setupRoutes();
+    } else {
+      Output.setError('provided json is not valid - see validation checks');
+      throw Error('provided json is not valid - see validation checks');
+    }
   }
 
   protected async setupStorage() {
     CoreApp.storage = await this.storageAdapter.init();
+    CoreApp.adapter = await lowdb.default(CoreApp.storage);
   }
 
-  protected async setupApp(): Promise<object> {
-    const { middlewares, router, adapter } = await this.initializeLayers();
+  protected async setupApp(): Promise<void> {
+    const { middlewares, router } = await this.initializeLayers();
     this.setupServer(middlewares, router);
-    const json = await adapter.getState();
+  }
+
+  protected validateJSON(db: {}): boolean {
+    let isValid = true;
+    if (this.appConfig.enableJSONValidation) {
+      isValid = JSONValidator.validate(db);
+    }
+    return isValid;
+  }
+
+  protected async getJSON(): Promise<object> {
+    const json = await CoreApp.adapter.getState();
     return json;
   }
 
@@ -56,13 +79,18 @@ export class CoreApp {
   }
 
   protected async initializeLayers() {
-    this.logger.trace('initLayer: ' + JSON.stringify(CoreApp.storage));
-    const adapter = await lowdb.default(CoreApp.storage);
-    const router = jsonServer.router(adapter);
+    if (
+      CoreApp.adapter &&
+      Object.entries(CoreApp.adapter).length === 0 &&
+      CoreApp.adapter.constructor === Object
+    ) {
+      CoreApp.adapter = await lowdb.default(CoreApp.storage);
+    }
+    const router = jsonServer.router(CoreApp.adapter);
     const middlewares = jsonServer.defaults({
       readOnly: this.appConfig.readOnly,
     });
-    return { middlewares, router, adapter };
+    return { middlewares, router };
   }
 
   protected setupServer(

src/server/specifications/swagger/swagger.ts

@@ -6,6 +6,7 @@ import express from 'express';
 import { Spec, ApiKeySecurity } from 'swagger-schema-official';
 import { SwaggerConfig } from './swagger.config';
 import { ApiSpecification } from '../apispecification';
+import { Output } from '../../utils/output';
 
 export class Swagger implements ApiSpecification {
   private swaggerSpec = new SwaggerSpec();
@@ -27,7 +28,7 @@ export class Swagger implements ApiSpecification {
 
   generateSpecification = (json: object, regenerate: boolean) => {
     if (!this.spec || regenerate) {
-      this.logger.info('init Swagger ');
+      Output.setInfo('Init Swagger');
       const swaggerSchemaDefinitions = this.swaggerDefGen.generateDefinitions(
         json
       );

src/server/utils/logger.ts

@@ -1,7 +1,7 @@
 export class Logger {
   logger = require('pino')(
     {
-      prettyPrint: true,
+      prettyPrint: { colorize: true },
     },
     process.stderr
   );

src/server/utils/output.ts

@@ -1,5 +1,13 @@
-function output(data: {}) {
-  console.log('Received Stack Output', data);
-}
+import { Logger } from './logger';
 
-module.exports = { output };
+export class Output {
+  static setWarning(message: string) {
+    new Logger().logger.warning(message);
+  }
+  static setError(message: string) {
+    new Logger().logger.error(message);
+  }
+  static setInfo(message: string) {
+    new Logger().logger.info(message);
+  }
+}

src/server/validations/json.validator.ts

@@ -0,0 +1,40 @@
+import {
+  HasIdAttributeRule,
+  HasObjectKeyRule,
+  IsObjectRule,
+  ValidationRule,
+} from './validationrule';
+import { RuleResultSeverity } from './ruleevent';
+import { Output } from '../utils/output';
+export class JSONValidator {
+  static validate(json: {}): boolean {
+    let isValid = true;
+    const rules = new Array<ValidationRule>();
+    rules.push(new IsObjectRule(json));
+    rules.push(new HasObjectKeyRule(json));
+    rules.push(new HasIdAttributeRule(json));
+
+    Output.setInfo(
+      'ValidationRule:' +
+        'Result'.padStart(60 - 'ValidationRule'.length) +
+        'Message'.padStart(80)
+    );
+    for (const rule of rules) {
+      const results = rule.executeValidation();
+      for (const result of results.events) {
+        Output.setInfo(
+          results.validationRule +
+            ':' +
+            result.result
+              .toString()
+              .padStart(60 - results.validationRule!.length) +
+            result.message.padStart(80)
+        );
+        if (result.result === RuleResultSeverity.ALERT) {
+          isValid = false;
+        }
+      }
+    }
+    return isValid;
+  }
+}

src/server/validations/ruleevent.ts

@@ -0,0 +1,20 @@
+export class RuleEventList {
+  validationRule?: string;
+  events = new Array<RuleEvent>();
+}
+
+export class RuleEvent {
+  result: RuleResultSeverity;
+  message = '' as string;
+
+  constructor(result: RuleResultSeverity, message?: string) {
+    this.result = result;
+    this.message = message !== undefined ? message : '';
+  }
+}
+
+export enum RuleResultSeverity {
+  OK = 'OK',
+  WARNING = 'WARNING',
+  ALERT = 'ALERT',
+}

src/server/validations/validationrule.ts

@@ -0,0 +1,94 @@
+import { RuleEvent, RuleResultSeverity, RuleEventList } from './ruleevent';
+
+export abstract class ValidationRule {
+  protected jsonObject = {} as object;
+  ruleEvents = new Array<RuleEvent>();
+  constructor(jsonObject: {}) {
+    this.jsonObject = jsonObject;
+  }
+  events = new Array<string>();
+  executeValidation(): RuleEventList {
+    const ruleEventList = new RuleEventList();
+    const result = this.validate();
+    ruleEventList.events = ruleEventList.events.concat(result);
+    ruleEventList.validationRule = this.constructor.name;
+    return ruleEventList;
+  }
+
+  protected abstract validate(): RuleEvent[];
+}
+
+export class IsObjectRule extends ValidationRule {
+  validate(): RuleEvent[] {
+    let ruleSeverity = RuleResultSeverity.OK;
+    let message = '';
+    try {
+      if (
+        this.jsonObject &&
+        typeof this.jsonObject === 'object' &&
+        this.jsonObject.constructor !== Object
+      ) {
+        ruleSeverity = RuleResultSeverity.ALERT;
+        message = 'root level of json content must be a json object';
+      }
+    } catch (e) {
+      ruleSeverity = RuleResultSeverity.ALERT;
+      message = e.message;
+    }
+    this.ruleEvents.push(new RuleEvent(ruleSeverity, message));
+    return this.ruleEvents;
+  }
+}
+
+export class HasObjectKeyRule extends ValidationRule {
+  validate(): RuleEvent[] {
+    let ruleSeverity = RuleResultSeverity.OK;
+    let message = '';
+    try {
+      if (this.jsonObject && typeof this.jsonObject === 'object') {
+        if (Object.keys(this.jsonObject).length === 0) {
+          ruleSeverity = RuleResultSeverity.ALERT;
+          message = 'no root properties found - no endpoints can be created';
+        }
+      }
+    } catch (e) {
+      ruleSeverity = RuleResultSeverity.ALERT;
+      message = e.message;
+    }
+    this.ruleEvents.push(new RuleEvent(ruleSeverity, message));
+    return this.ruleEvents;
+  }
+}
+
+export class HasIdAttributeRule extends ValidationRule {
+  validate(): RuleEvent[] {
+    try {
+      if (
+        this.jsonObject &&
+        typeof this.jsonObject === 'object' &&
+        Object.keys(this.jsonObject).length !== 0
+      ) {
+        Object.keys(this.jsonObject).forEach(item => {
+          let ruleSeverity = RuleResultSeverity.OK;
+          let message = '';
+          if (
+            Array.isArray(this.jsonObject[item]) &&
+            this.jsonObject[item].length > 0 &&
+            !this.jsonObject[item][0].hasOwnProperty('id')
+          ) {
+            (ruleSeverity = RuleResultSeverity.WARNING),
+              (message =
+                item +
+                ' is missing id attribute - not possible to do POST, PUT, PATCH');
+          }
+          this.ruleEvents.push(new RuleEvent(ruleSeverity, message));
+        });
+      }
+    } catch (e) {
+      const ruleSeverityError = RuleResultSeverity.ALERT;
+      const messageError = e.message;
+      this.ruleEvents.push(new RuleEvent(ruleSeverityError, messageError));
+    }
+    return this.ruleEvents;
+  }
+}