refactor: remove legacy callbacks from bulk storage

src/routes/bulk-add-route.ts

@@ -32,7 +32,7 @@ export const bulkAddRouter = createRoute<SCBulkAddRequest, SCBulkAddResponse>(
   async (request, app, params) => {
 
     const bulkMemory: BulkStorage = app.get('bulk');
-    const bulk = await bulkMemory.read(params.UID);
+    const bulk = bulkMemory.read(params.UID);
 
     if (typeof bulk === 'undefined') {
       Logger.warn(`Bulk with ${params.UID} not found.`);

src/routes/bulk-done-route.ts

@@ -32,7 +32,7 @@ export const bulkDoneRouter = createRoute<SCBulkDoneRequest, SCBulkDoneResponse>
   async (_request, app, params) => {
 
     const bulkMemory: BulkStorage = app.get('bulk');
-    const bulk = await bulkMemory.read(params.UID);
+    const bulk = bulkMemory.read(params.UID);
 
     if (typeof bulk === 'undefined') {
       Logger.warn(`Bulk with ${params.UID} not found.`);

src/routes/virtual-plugin-route.ts

@@ -39,14 +39,15 @@ export async function virtualPluginRoute(req: Request, plugin: SCPluginMetaData)
     }
     // send the request to the plugin (forward the body) and save the response
     const pluginResponse = await got.post(
-      plugin.route,
+      plugin.route.replace(/^\//gi, ''),
       {
         prefixUrl: plugin.address,
         json: req.body,
         timeout: configFile.backend.externalRequestTimeout,
+        responseType: 'json',
       },
     );
-    responseBody = JSON.parse(pluginResponse.body);
+    responseBody = pluginResponse.body as object;
     const responseValidation = validator.validate(responseBody, plugin.responseSchema);
     if (responseValidation.errors.length > 0) {
       throw new SCValidationErrorResponse(responseValidation.errors, isTestEnvironment);

src/storage/bulk-storage.ts

@@ -17,7 +17,6 @@ import {SCBulkRequest, SCThingType} from '@openstapps/core';
 import {Logger} from '@openstapps/logger';
 import moment from 'moment';
 import NodeCache from 'node-cache';
-import {promisify} from 'util';
 import {v4} from 'uuid';
 import {Database} from './database';
 
@@ -125,14 +124,14 @@ export class BulkStorage {
    * @param bulk the bulk process to save
    * @returns the bulk process that was saved
    */
-  private async save(bulk: Bulk): Promise<Bulk> {
+  private save(bulk: Bulk): Bulk {
     const expirationInSeconds = moment(bulk.expiration)
     // tslint:disable-next-line: no-magic-numbers
     .diff(moment.now()) / 1000;
     Logger.info('Bulk expires in ', expirationInSeconds, 'seconds');
 
     // save the item in the cache with it's expected expiration
-    await promisify<string, Bulk, number, boolean>(this.cache.set)(bulk.uid, bulk, expirationInSeconds);
+    this.cache.set(bulk.uid, bulk, expirationInSeconds);
 
     return bulk;
   }
@@ -147,7 +146,7 @@ export class BulkStorage {
     bulk.source = bulkRequest.source;
     bulk.type = bulkRequest.type;
 
-    await this.save(bulk);
+    this.save(bulk);
 
     // tell the database that the bulk was created
     await this.database.bulkCreated(bulk);
@@ -161,14 +160,14 @@ export class BulkStorage {
    * @returns a promise that contains the deleted bulk process
    */
   public async delete(uid: string): Promise<Bulk> {
-    const bulk = await this.read(uid);
+    const bulk = this.read(uid);
 
     if (typeof bulk === 'undefined') {
       throw new Error(`Bulk that should be deleted was not found. UID was "${uid}"`);
     }
 
     // delete the bulk process from the cache
-    await promisify<string>(this.cache.del)(uid);
+    this.cache.del(uid);
 
     // tell the database to handle the expiration of the bulk
     await this.database.bulkExpired(bulk);
@@ -183,7 +182,7 @@ export class BulkStorage {
    */
   public async markAsDone(bulk: Bulk): Promise<void> {
     bulk.state = 'done';
-    await this.save(bulk);
+    this.save(bulk);
 
     // tell the database that this is the new bulk
     await this.database.bulkUpdated(bulk);
@@ -196,8 +195,8 @@ export class BulkStorage {
    * @param uid uid of the bulk process
    * @returns a promise that contains a bulk
    */
-  public async read(uid: string): Promise<Bulk | undefined> {
-    return promisify<string, Bulk | undefined>(this.cache.get)(uid);
+  public read(uid: string): Bulk | undefined {
+    return this.cache.get(uid);
   }
 
 }

test/routes/virtual-plugin-route.spec.ts

@@ -21,7 +21,7 @@ import {
 import {expect, use} from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import {Request} from 'express';
-import got, { Options } from 'got';
+import got, {Options} from 'got';
 import nock from 'nock';
 import sinon from 'sinon';
 import {mockReq} from 'sinon-express-mock';
@@ -79,9 +79,9 @@ describe('Virtual plugin routes', async function () {
 
       await virtualPluginRoute(req, plugin);
 
-      expect(gotStub.args[0][0]).to.equal(plugin.route);
+      expect(gotStub.args[0][0]).to.equal(plugin.route.substr(1));
       expect(((gotStub.args[0] as any)[1] as Options).prefixUrl).to.equal(plugin.address);
-      expect(((gotStub.args[0] as any)[1] as Options).body).to.equal(req.body);
+      expect(((gotStub.args[0] as any)[1] as Options).json).to.equal(req.body);
     });
 
     it('should provide data from the plugin when its route is called', async function () {

test/storage/bulk-storage.spec.ts

@@ -81,14 +81,14 @@ describe('Bulk Storage', function () {
     });
 
     it('should throw an error if the bulk for deletion cannot be read', async function () {
-      sandbox.stub(BulkStorage.prototype, 'read').callsFake(async () => Promise.resolve(undefined));
+      sandbox.stub(BulkStorage.prototype, 'read').callsFake(() => undefined);
       const bulkStorage = new BulkStorage(database);
 
       return expect(bulkStorage.delete('123')).to.be.rejected;
     });
 
     it('should delete a bulk', async function () {
-      const readStub =  sandbox.stub(BulkStorage.prototype, 'read').callsFake(async () => Promise.resolve(bulk));
+      const readStub =  sandbox.stub(BulkStorage.prototype, 'read').callsFake(() => bulk);
       let caught: any;
       sandbox.stub(NodeCache.prototype, 'del').callsFake(() => caught = 123);
       // force call