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/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;
+}