feat: add functionality to register plugins via http

Also:

- Add functionality for serving the responses from plugins
- Add tests for related methods and routes

Closes #2, #37

src/app.ts

@@ -25,15 +25,17 @@ import * as cors from 'cors';
 import * as express from 'express';
 import * as morgan from 'morgan';
 import {join} from 'path';
-import {configFile, isTestEnvironment, mailer, validator} from './common';
+import {configFile, isTestEnvironment, mailer, plugins, validator} from './common';
 import {MailQueue} from './notification/mail-queue';
 import {bulkAddRouter} from './routes/bulk-add-route';
 import {bulkDoneRouter} from './routes/bulk-done-route';
 import {bulkRouter} from './routes/bulk-route';
 import {indexRouter} from './routes/index-route';
 import {multiSearchRouter} from './routes/multi-search-route';
+import {pluginRegisterRouter} from './routes/plugin-register-route';
 import {searchRouter} from './routes/search-route';
 import {thingUpdateRouter} from './routes/thing-update-route';
+import {virtualPluginRoute} from './routes/virtual-plugin-route';
 import {BulkStorage} from './storage/bulk-storage';
 import {DatabaseConstructor} from './storage/database';
 import {Elasticsearch} from './storage/elasticsearch/elasticsearch';
@@ -193,16 +195,32 @@ export async function configureApp() {
     bulkRouter,
     indexRouter,
     multiSearchRouter,
+    pluginRegisterRouter,
     searchRouter,
     thingUpdateRouter,
   );
 
+  // for plugins, as Express doesn't really want you to unregister routes (and doesn't offer any method to do so at all)
+  app.all('*', async (req, res, next) => {
+    // if the route exists then call virtual route on the plugin that registered that route
+    if (plugins.has(req.originalUrl)) {
+      try {
+        res.json(await virtualPluginRoute(req, plugins.get(req.originalUrl)!));
+      } catch (e) {
+        // in case of error send an error response
+        res.status(e.statusCode);
+        res.json(e);
+      }
+    } else {
+      // pass to the next matching route (which is 404)
+      next();
+    }
+  });
+
   // add a route for a missing resource (404)
   app.use((_req, res) => {
     const errorResponse = new SCNotFoundErrorResponse(isTestEnvironment);
     res.status(errorResponse.statusCode);
     res.json(errorResponse);
   });
-
-  // TODO: implement a route to register plugins
 }

src/common.ts

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import {SCConfigFile} from '@openstapps/core';
+import {SCConfigFile, SCPluginMetaData} from '@openstapps/core';
 import {Validator} from '@openstapps/core-tools/lib/validate';
 import * as config from 'config';
 import {BackendTransport} from './notification/backend-transport';
@@ -37,3 +37,8 @@ export const validator = new Validator();
  * Provides information if the backend is executed in the "test" (non-production) environment
  */
 export const isTestEnvironment = process.env.NODE_ENV !== 'production';
+
+/*
+ * Stores a ("key-value") list of plugins where key is route and value is plugin information
+ */
+export const plugins = new Map<string, SCPluginMetaData>();

src/routes/plugin-register-route.ts

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import {
+  SCPluginAlreadyRegisteredErrorResponse,
+  SCPluginMetaData,
+  SCPluginRegisterRequest,
+  SCPluginRegisterResponse,
+  SCPluginRegisterRoute,
+} from '@openstapps/core';
+import {deepStrictEqual} from 'assert';
+import {isTestEnvironment, plugins} from '../common';
+import {createRoute} from './route';
+
+/**
+ * Contains information for using the route for registering routes
+ */
+const pluginRegisterRouteModel = new SCPluginRegisterRoute();
+
+/**
+ * Implementation of the plugin registration route (SCPluginRegisterRoute)
+ */
+export const pluginRegisterRouter = createRoute(
+  pluginRegisterRouteModel, pluginRegisterHandler);
+
+/**
+ * Handles requests on route for registering plugins
+ *
+ * @param request Request received for registering or unregistering a plugin
+ * @param _app Express application
+ */
+export async function pluginRegisterHandler(request: SCPluginRegisterRequest, _app: Express.Application):
+  Promise<SCPluginRegisterResponse> {
+  switch (request.action) {
+    case 'add':
+      return addPlugin(request.plugin);
+    case 'remove':
+      return removePlugin(request.route);
+  }
+}
+
+/**
+ * Adds a plugin to the list (map) of registered plugins
+ *
+ * @param plugin Meta data of the plugin
+ */
+function addPlugin(plugin: SCPluginMetaData): SCPluginRegisterResponse {
+  // check if plugin (its route) has already been registered
+  if (plugins.has(plugin.route)) {
+    const previouslyRegistered = plugins.get(plugin.route);
+    try {
+      deepStrictEqual(previouslyRegistered, plugin);
+
+      return {success: true};
+    } catch (error) {
+      throw new SCPluginAlreadyRegisteredErrorResponse(
+        'Plugin already registered',
+        plugins.get(plugin.route)!,
+        isTestEnvironment,
+      );
+    }
+  }
+  // it's a new plugin so it can be added to the map of plugins
+  plugins.set(plugin.route, plugin);
+
+  return {success: true};
+}
+
+/**
+ * Removes a plugin from the list (map) of registered plugins using the provided route
+ *
+ * @param route Route of the plugin which needs to be unregistered
+ */
+function removePlugin(route: string): SCPluginRegisterResponse {
+  if (!plugins.has(route)) {
+    // TODO: throw error when plugin that is to be removed is not already registered (after @openstapps/core update)
+    // throw new SCNotFoundErrorResponse(
+    //   isTestEnvironment,
+    // );
+    return {success: false};
+  }
+  // remove the plugin information using its route as a key
+  plugins.delete(route);
+
+  return {success: true};
+}

src/routes/route.ts

@@ -149,6 +149,5 @@ export function createRoute<REQUESTTYPE, RETURNTYPE>(
     Logger.warn(error);
   });
 
-  // return router
   return router;
 }

src/routes/virtual-plugin-route.ts

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {
+  SCInternalServerErrorResponse,
+  SCPluginMetaData,
+  SCValidationErrorResponse,
+} from '@openstapps/core';
+import {Request} from 'express';
+import * as got from 'got';
+import {isTestEnvironment, validator} from '../common';
+
+/**
+ * Number of milliseconds after which external request will fail
+ */
+export const EXTERNAL_REQUEST_TIMEOUT = 5000;
+
+/**
+ * Generic route function used to proxy actual requests to plugins
+ *
+ * @param req The request for a plugin resource
+ * @param plugin Meta data of the plugin
+ * @throws {SCInternalServerErrorResponse} On request/response validation or response from the plugin errors
+ */
+export async function virtualPluginRoute(req: Request, plugin: SCPluginMetaData): Promise<object> {
+  let responseBody: object;
+  try {
+    const requestValidation = validator.validate(req.body, plugin.requestSchema);
+    if (requestValidation.errors.length > 0) {
+      throw new SCValidationErrorResponse(requestValidation.errors, isTestEnvironment);
+    }
+    // send the request to the plugin (forward the body) and save the response
+    const pluginResponse = await got.post(
+      plugin.route,
+      {
+        baseUrl: plugin.address,
+        body: req.body,
+        json: true,
+        timeout: EXTERNAL_REQUEST_TIMEOUT,
+      },
+    );
+    responseBody = pluginResponse.body;
+    const responseValidation = validator.validate(responseBody, plugin.responseSchema);
+    if (responseValidation.errors.length > 0) {
+      throw new SCValidationErrorResponse(responseValidation.errors, isTestEnvironment);
+    }
+  } catch (e) {
+    // wrap exact error inside of the internal server error response
+    throw new SCInternalServerErrorResponse(e, isTestEnvironment);
+  }
+
+  return responseBody;
+}

src/storage/elasticsearch/elasticsearch.ts

@@ -174,7 +174,6 @@ export class Elasticsearch implements Database {
   constructor(private readonly config: SCConfigFile, mailQueue?: MailQueue) {
 
     if (typeof config.internal.database === 'undefined'
-      || typeof config.internal.database.version === 'undefined'
       || typeof config.internal.database.version !== 'string') {
       throw new Error('Database version is undefined. Check your config file');
     }
@@ -182,14 +181,10 @@ export class Elasticsearch implements Database {
     const options: ES.ConfigOptions = {
       apiVersion: config.internal.database.version,
       host: Elasticsearch.getElasticsearchUrl(),
-      log: 'error',
+      // enable verbose logging for all request to elasticsearch
+      log:  process.env.ES_DEBUG === 'true' ? 'trace' : 'error',
     };
 
-    // enable verbose logging for all request to elasticsearch
-    if (process.env.ES_DEBUG === 'true') {
-      options.log = 'trace';
-    }
-
     this.client = new ES.Client(options);
     this.aliasMap = {};
     this.ready = false;