backend-manager 2.4.5 → 2.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "2.4.5",
+  "version": "2.4.6",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -31,7 +31,7 @@
     "@google-cloud/storage": "^5.20.5",
     "@sendgrid/mail": "^7.7.0",
     "@sentry/node": "^6.19.7",
-    "backend-assistant": "^0.0.71",
+    "backend-assistant": "^0.0.72",
     "busboy": "^1.6.0",
     "chalk": "^4.1.2",
     "cors": "^2.8.5",

package/src/manager/functions/core/actions/api/admin/backup.js

@@ -0,0 +1,203 @@
+const moment = require('moment');
+const powertools = require('node-powertools');
+const {Storage} = require('@google-cloud/storage');
+const storage = new Storage();
+
+function Module() {
+
+}
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    payload.data.payload.deletionRegex = payload.data.payload.deletionRegex ? powertools.regexify(payload.data.payload.deletionRegex) : payload.data.payload.deletionRegex;
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else {
+      const client = new self.libraries.admin.firestore.v1.FirestoreAdminClient({});
+      const projectId = self.Manager.project.projectId;
+      const resourceZone = self.Manager.project.resourceZone;
+      const databaseName = client.databasePath(projectId, '(default)');
+      const bucketName = `bm-backup-firestore-${projectId}`;
+      const bucketAddress = `gs://${bucketName}`;
+
+      await self.createBucket(bucketName, resourceZone);
+      await self.deleteOldFiles(bucketName, resourceZone);
+
+      client.exportDocuments({
+        name: databaseName,
+        outputUriPrefix: bucketAddress,
+        // Leave collectionIds empty to export all collections
+        // or set to a list of collection IDs to export,
+        collectionIds: []
+      })
+      .then(responses => {
+        const response = responses[0];
+        // assistant.log('Saved backup successfully', response['name'], {environment: 'development'})
+        assistant.log('Saved backup successfully:', response.metadata.outputUriPrefix, {environment: 'development'})
+        return resolve(response['name']);
+      })
+      .catch(e => {
+        return reject(assistant.errorManager(e, {code: 500, sentry: false, send: false, log: true}).error)
+      });
+
+
+    }
+  });
+
+};
+
+Module.prototype.createBucket = function (bucketName, resourceZone) {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(function(resolve, reject) {
+    storage.bucket(bucketName).getMetadata()
+      .then(async (meta) => {
+        assistant.log(`${bucketName} metadata`, meta[0], {environment: 'development'})
+        return resolve();
+      })
+      .catch(async (e) => {
+        const storageCreation = await storage.createBucket(bucketName, {
+          // location: 'ASIA',
+          location: resourceZone,
+          storageClass: 'COLDLINE',
+        })
+        .then(r => r)
+        .catch(e => e)
+
+        assistant.log('storageCreation', storageCreation, {environment: 'development'})
+
+        return resolve();
+      })
+  });
+};
+
+// https://github.com/zsolt-dev/auto-delete-gcp-storage-backups/blob/master/index.js
+Module.prototype.deleteOldFiles = function (bucketName, resourceZone) {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    const now = moment();
+    const deletionRegex = payload.data.payload.deletionRegex;
+
+    // Helpers
+    const getFileObjectWithMetaData = async (bucketName, fileName) => {
+      const [metaData] = await storage.bucket(bucketName).file(fileName).getMetadata();
+      return ({ fileName, created: metaData.timeCreated });
+    };
+
+    const deleteFileFromBucket = async (bucketName, fileName) => {
+      assistant.log(`Deleting item: ${fileName}...`, );
+      return await storage.bucket(bucketName).file(fileName).delete();
+    };
+
+    // Main
+    // get the file names as an array
+    let [allFiles] = await storage.bucket(bucketName).getFiles();
+    let deletePromises = [];
+    allFiles = allFiles.map(file => file.name);
+    // console.log(`all files: ${allFiles.join(', ')}`);
+
+    // transform to array of objects with creation timestamp { fileName: xyz, created: }
+    allFiles = allFiles.map(fileName => getFileObjectWithMetaData(bucketName, fileName));
+    allFiles = await Promise.all(allFiles);
+
+    allFiles.forEach((backup, i) => {
+      const date = moment(backup.created);
+      const day = date.date();
+      const month = date.month();
+      const age = now.diff(date, 'days', false);
+
+      assistant.log(`Sorting item ${i}: date=${date.format('MMM Do, YYYY')}, day=${day}, month=${month}, age=${age}`, );
+
+      if (age >= 31) {
+        if (day === 1) { return }
+        deletePromises.push(deleteFileFromBucket(bucketName, backup.fileName))
+      } else if ((deletionRegex && backup.fileName.match(deletionRegex))) {
+        deletePromises.push(deleteFileFromBucket(bucketName, backup.fileName))
+      }
+    })
+
+    await Promise.all(deletePromises);
+
+    return resolve();
+  });
+};
+
+Module.prototype._deleteOldFiles = function (bucketName, resourceZone) {
+  const self = this;
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    // Helpers
+    const getFileObjectWithMetaData = async (bucketName, fileName) => {
+      const [metaData] = await storage.bucket(bucketName).file(fileName).getMetadata();
+      return ({ fileName, created: metaData.timeCreated });
+    };
+
+    const deleteFileFromBucket = async (bucketName, fileName) => {
+      return await storage.bucket(bucketName).file(fileName).delete();
+    };
+
+    // Main
+    // get the file names as an array
+    let [allFiles] = await storage.bucket(bucketName).getFiles();
+    allFiles = allFiles.map(file => file.name);
+    console.log(`all files: ${allFiles.join(', ')}`);
+
+    // transform to array of objects with creation timestamp { fileName: xyz, created: }
+    allFiles = allFiles.map(fileName => getFileObjectWithMetaData(bucketName, fileName));
+    allFiles = await Promise.all(allFiles);
+
+
+    const filesToKeep = new Set(); // using set insted of array since set does not allow duplicates
+
+    // recent backups
+    allFiles.forEach(backup => {
+      const createdDate = new Date(backup.created);
+      createdDate.setHours( createdDate.getHours() + numHoursToKeepRecentBackups );
+      if(createdDate > new Date()) filesToKeep.add(backup.fileName);
+    })
+
+    // daily backups
+    for(var i = 0; i < numDaysToKeepOneDailyBackup; i++) {
+      // get day
+      const now = new Date();
+      now.setDate( now.getDate() - i );
+      dateString = now.toISOString().substring(0, 10);
+      // keep only one from that day
+      const backupsFromThatDay = allFiles.filter(backup => backup.created.startsWith(dateString));
+      if(backupsFromThatDay && backupsFromThatDay.length > 0) filesToKeep.add(backupsFromThatDay[0].fileName);
+    }
+
+    // filesToKeep.forEach(item => console.log(item));
+
+    const filesToDelete = allFiles.filter(backup => !filesToKeep.has(backup.fileName));
+    console.log(`Deleting ${filesToDelete.length} files: ${filesToDelete.map(backup => backup.fileName).join(', ')}`);
+
+    const deletePromises = filesToDelete.map(backup => deleteFileFromBucket(bucketName, backup.fileName));
+    await Promise.all(deletePromises);
+
+    return resolve();
+  });
+};
+
+module.exports = Module;

package/src/manager/functions/core/actions/api/admin/create-post.js

@@ -15,7 +15,7 @@ Module.prototype.main = function () {
   const payload = self.payload;
 
   return new Promise(async function(resolve, reject) {
-    if (!payload.user.roles.admin || !payload.user.roles.blogger) {
+    if (!payload.user.roles.admin && !payload.user.roles.blogger) {
       return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
     }
 

package/src/manager/functions/core/actions/api/admin/firestore-read.js

@@ -13,13 +13,10 @@ Module.prototype.main = function () {
 
     if (payload.user.roles.admin) {
 
-      // console.log('---payload.data.payload', payload.data.payload);
-
       payload.data.payload.path = `${payload.data.payload.path || ''}`;
       payload.data.payload.document = payload.data.payload.document || {};
       payload.data.payload.options = payload.data.payload.options || { merge: true };
 
-
       if (!payload.data.payload.path) {
         return reject(assistant.errorManager(`<path> parameter required`, {code: 400, sentry: false, send: false, log: false}).error)
       } else {

package/src/manager/functions/core/actions/api/test/webhook.js

@@ -8,9 +8,13 @@ Module.prototype.main = function () {
   const Api = self.Api;
   const assistant = self.assistant;
   const payload = self.payload;
+  const powertools = Manager.require('node-powertools');
 
   return new Promise(async function(resolve, reject) {
 
+    if (payload.data.payload.delay > 0) {
+      await powertools.wait(payload.data.payload.delay)
+    }
 
     if (payload.data.payload.status >= 200 && payload.data.payload.status <= 299) {
       return resolve({data: payload.data.payload.response, status: payload.data.payload.status});

package/src/manager/functions/core/actions/api/user/oauth2/discord.js

@@ -17,8 +17,10 @@ function OAuth2() {
 
 OAuth2.prototype.buildUrl = function (state, url) {
   const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
 
-  return new Promise(function(resolve, reject) {
+  return new Promise(async function(resolve, reject) {
     if (state === 'authorize') {
       // do something with url
       return resolve()
@@ -31,19 +33,36 @@ OAuth2.prototype.buildUrl = function (state, url) {
 OAuth2.prototype.verifyIdentity = function (tokenizeResult) {
   const self = this;
   const Manager = self.Manager;
+  const assistant = self.assistant;
+
+  return new Promise(async function(resolve, reject) {
 
-  return new Promise(function(resolve, reject) {
-    const decoded = decode(tokenizeResult.id_token);
+    const identityResponse = await fetch('https://discord.com/api/users/@me', {
+      timeout: 60000,
+      response: 'json',
+      tries: 1,
+      log: true,
+      cacheBreaker: false,
+      headers: {
+        authorization: `${tokenizeResult.token_type} ${tokenizeResult.access_token}`,
+      },
+    })
+    .then(json => json)
+    .catch(e => e)
 
-    // console.log('---decoded', decoded);
+    assistant.log('identityResponse', identityResponse, {environment: 'development'});
+
+    if (identityResponse instanceof Error) {
+      return reject(identityResponse);
+    }
 
     // Check if exists
     Manager.libraries.admin.firestore().collection(`users`)
-    .where(`oauth2.${self.provider}.identity.email`, '==', decoded.email)
+    .where(`oauth2.${self.provider}.identity.id`, '==', identityResponse.id)
     .get()
     .then(async (snap) => {
       if (snap.size === 0) {
-        return resolve(decoded);
+        return resolve(identityResponse);
       } else {
         return reject(new Error(`This ${self.name} account is already connected to a ${Manager.config.brand.name} account`));
       }
@@ -58,8 +77,9 @@ OAuth2.prototype.verifyIdentity = function (tokenizeResult) {
 // OAuth2.prototype.verifyConnection = function (newUrl, token) {
 //   const self = this;
 //   const Manager = self.Manager;
+//   const assistant = self.assistant;
 //
-//   return new Promise(function(resolve, reject) {
+//   return new Promise(async function(resolve, reject) {
 //
 //     fetch(newUrl, {
 //       method: 'post',

package/src/manager/functions/core/actions/api/user/oauth2/google.js

@@ -16,8 +16,10 @@ function OAuth2() {
 
 OAuth2.prototype.buildUrl = function (state, url) {
   const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
 
-  return new Promise(function(resolve, reject) {
+  return new Promise(async function(resolve, reject) {
     if (state === 'authorize') {
       // do something with url
       return resolve()
@@ -30,8 +32,9 @@ OAuth2.prototype.buildUrl = function (state, url) {
 OAuth2.prototype.verifyIdentity = function (tokenizeResult) {
   const self = this;
   const Manager = self.Manager;
+  const assistant = self.assistant;
 
-  return new Promise(function(resolve, reject) {
+  return new Promise(async function(resolve, reject) {
     const decoded = decode(tokenizeResult.id_token);
 
     // console.log('---decoded', decoded);
@@ -57,8 +60,9 @@ OAuth2.prototype.verifyIdentity = function (tokenizeResult) {
 // OAuth2.prototype.verifyConnection = function (newUrl, token) {
 //   const self = this;
 //   const Manager = self.Manager;
+//   const assistant = self.assistant;
 //
-//   return new Promise(function(resolve, reject) {
+//   return new Promise(async function(resolve, reject) {
 //
 //     fetch(newUrl, {
 //       method: 'post',

package/src/manager/functions/core/actions/api/user/oauth2.js

@@ -39,9 +39,13 @@ Module.prototype.main = function () {
         : payload.data.payload.redirect
 
       payload.data.payload.referrer = typeof payload.data.payload.referrer === 'undefined'
-        ? (assistant.meta.environment === 'development' ? `http://localhost:4000/oauth2` : `${Manager.config.brand.url}/oauth2`)
+        ? (assistant.meta.environment === 'development' ? `http://localhost:4000/authentication/account` : `${Manager.config.brand.url}/authentication/account`)
         : payload.data.payload.referrer
 
+      payload.data.payload.serverUrl = typeof payload.data.payload.serverUrl === 'undefined'
+        ? (assistant.meta.environment === 'development' ? `${Manager.project.functionsUrl}/bm_api` : `${Manager.project.functionsUrl}/bm_api`)
+        : payload.data.payload.serverUrl
+
       payload.data.payload.provider = payload.data.payload.provider || '';
       payload.data.payload.state = payload.data.payload.state || 'authorize'; // authorize, tokenize, deauthorize, refresh, get
       payload.data.payload.redirect_uri = payload.data.payload.redirect_uri
@@ -59,17 +63,22 @@ Module.prototype.main = function () {
         code: 'success',
         provider: payload.data.payload.provider,
         authenticationToken: payload.data.authenticationToken,
-        serverUrl: `${Manager.project.functionsUrl}/bm_api`,
+        serverUrl: payload.data.payload.serverUrl,
         referrer: payload.data.payload.referrer,
         redirectUrl: payload.data.payload.redirect_uri,
       }
 
       assistant.log('OAuth2 payload', payload.data.payload);
 
+      if (!payload.data.payload.provider) {
+        return reject(new Error(`The provider parameter is required.`));
+      }
+
       try {
         self.oauth2 = new (require(`./oauth2/${payload.data.payload.provider}.js`))();
         self.oauth2.parent = self;
         self.oauth2.Manager = self.Manager;
+        self.oauth2.assistant = self.assistant;
 
         newUrl = self.oauth2.urls[payload.data.payload.state]
 
@@ -159,6 +168,8 @@ Module.prototype.processState_tokenize = function (newUrl) {
   return new Promise(async function(resolve, reject) {
     const finalUrl = newUrl.toString();
 
+    assistant.log('Running processState_tokenize()', {environment: 'development'});
+
     const body = {
       client_id: _.get(Manager.config, `oauth2.${payload.data.payload.provider}.client_id`),
       client_secret: _.get(Manager.config, `oauth2.${payload.data.payload.provider}.client_secret`),
@@ -168,13 +179,13 @@ Module.prototype.processState_tokenize = function (newUrl) {
       // scope: '',
     };
 
-    // console.log('----body', body);
+    assistant.log('body', body, {environment: 'development'});
 
     const tokenizeResponse = await fetch(finalUrl, {
       method: 'POST',
       timeout: 60000,
       response: 'json',
-      tries: 2,
+      tries: 1,
       log: true,
       body: new URLSearchParams(body),
       cacheBreaker: false,
@@ -185,7 +196,7 @@ Module.prototype.processState_tokenize = function (newUrl) {
     .then(json => json)
     .catch(e => e)
 
-    // console.log('---tokenizeResponse', tokenizeResponse);
+    assistant.log('tokenizeResponse', tokenizeResponse, {environment: 'development'});
 
     if (tokenizeResponse instanceof Error) {
       return reject(tokenizeResponse);
@@ -196,7 +207,7 @@ Module.prototype.processState_tokenize = function (newUrl) {
     .then(identity => identity)
     .catch(e => e);
 
-    // console.log('---verifiedIdentity', verifiedIdentity);
+    assistant.log('verifiedIdentity', verifiedIdentity, {environment: 'development'});
 
     if (verifiedIdentity instanceof Error) {
       return reject(verifiedIdentity);
@@ -222,7 +233,7 @@ Module.prototype.processState_tokenize = function (newUrl) {
     .then(r => r)
     .catch(e => e)
 
-    // console.log('---storeResponse', storeResponse);
+    assistant.log('storeResponse', storeResponse, {environment: 'development'});
 
     if (storeResponse instanceof Error) {
       return reject(storeResponse);

package/src/manager/functions/core/actions/api.js

@@ -39,64 +39,70 @@ Module.prototype.main = function() {
   const req = self.req;
   const res = self.res;
 
-  return libraries.cors(req, res, async () => {
-    self.payload.data = assistant.request.data;
-    self.payload.user = await assistant.authenticate();
+  return new Promise(async function(resolve, reject) {
+    return libraries.cors(req, res, async () => {
+      self.payload.data = assistant.request.data;
+      self.payload.user = await assistant.authenticate();
 
-    const resolved = self.resolveCommand(self.payload.data.command);
+      const resolved = self.resolveCommand(self.payload.data.command);
 
-    self.assistant.log(`Executing: ${resolved.command}`, self.payload, JSON.stringify(self.payload), {environment: 'production'})
-    self.assistant.log(`Resolved URL: ${Manager.project.functionsUrl}?command=${encodeURIComponent(resolved.command)}&payload=${encodeURIComponent(JSON.stringify(self.assistant.request.data.payload))}`, {environment: 'development'})
+      self.assistant.log(`Executing: ${resolved.command}`, self.payload, JSON.stringify(self.payload), {environment: 'production'})
+      self.assistant.log(`Resolved URL: ${Manager.project.functionsUrl}?command=${encodeURIComponent(resolved.command)}&payload=${encodeURIComponent(JSON.stringify(self.assistant.request.data.payload))}`, {environment: 'development'})
 
-    if (!resolved.exists) {
-      self.payload.response.status = 400;
-      self.payload.response.error = new Error(`${self.payload.data.command} is not a valid command`);
-    } else {
-      await self.import(resolved.command)
-      .then(async lib => {
-        try {
-          // Call main function
-          await lib.main()
-          .then(result => {
-            result = result || {};
-            // console.log('---result', result);
-            // console.log('---self.payload.response.data', self.payload.response.data);
-            self.payload.response.status = result.status || self.payload.response.status || 200;
-            self.payload.response.data = result.data || self.payload.response.data || {};
-            self.payload.response.redirect = result.redirect || self.payload.response.redirect || null;
-          })
-          .catch(e => {
-            self.payload.response.status = e.code || 500;
-            self.payload.response.error = e || new Error('Unknown error occured');
-          })
-        } catch (e) {
-          self.payload.response.status = 500;
-          self.payload.response.error = e || new Error('Unknown error occured');
-        }
-      })
-      .catch(e => {
+      if (!resolved.exists) {
         self.payload.response.status = 400;
-        self.payload.response.error = new Error(`Failed to import: ${e}`);
-      })
-    }
+        self.payload.response.error = new Error(`${self.payload.data.command} is not a valid command`);
+      } else {
+        await self.import(resolved.command)
+        .then(async lib => {
+          try {
+            // Call main function
+            await lib.main()
+            .then(result => {
+              result = result || {};
+              // console.log('---result', result);
+              // console.log('---self.payload.response.data', self.payload.response.data);
+              self.payload.response.status = result.status || self.payload.response.status || 200;
+              self.payload.response.data = result.data || self.payload.response.data || {};
+              self.payload.response.redirect = result.redirect || self.payload.response.redirect || null;
+            })
+            .catch(e => {
+              // console.log('---e', e);
+              self.payload.response.status = e.code || 500;
+              self.payload.response.error = e || new Error('Unknown error occured');
+            })
+          } catch (e) {
+            self.payload.response.status = 500;
+            self.payload.response.error = e || new Error('Unknown error occured');
+          }
+        })
+        .catch(e => {
+          self.payload.response.status = 400;
+          self.payload.response.error = new Error(`Failed to import: ${e}`);
+        })
+      }
 
-    self.payload.response.status = _fixStatus(self.payload.response.status);
+      self.payload.response.status = _fixStatus(self.payload.response.status);
 
-    res.status(self.payload.response.status)
+      res.status(self.payload.response.status)
 
-    if (self.payload.response.status >= 200 && self.payload.response.status < 300) {
-      self.assistant.log(`Finished ${resolved.command} (status=${self.payload.response.status})`, self.payload, JSON.stringify(self.payload), {environment: 'production'})
+      if (self.payload.response.status >= 200 && self.payload.response.status < 300) {
+        self.assistant.log(`Finished ${resolved.command} (status=${self.payload.response.status})`, self.payload, JSON.stringify(self.payload), {environment: 'production'})
 
-      if (self.payload.response.redirect) {
-        return res.redirect(self.payload.response.redirect);
+        if (self.payload.response.redirect) {
+          res.redirect(self.payload.response.redirect);
+          return resolve();
+        } else {
+          res.json(self.payload.response.data);
+          return resolve();
+        }
       } else {
-        return res.json(self.payload.response.data);
+        console.error(`Error executing ${resolved.command} @ ${resolved.path} (status=${self.payload.response.status}):`, self.payload.response.error)
+        // return res.send(self.payload.response.error.message);
+        res.send(`${self.payload.response.error}`)
+        return reject(self.payload.response.error);
       }
-    } else {
-      console.error(`Error executing ${resolved.command} @ ${resolved.path} (status=${self.payload.response.status}):`, self.payload.response.error)
-      // return res.send(self.payload.response.error.message);
-      return res.send(`${self.payload.response.error}`);
-    }
+    });
   });
 }
 

package/src/manager/functions/core/cron/backup.js

@@ -0,0 +1,43 @@
+const fetch = require('wonderful-fetch');
+
+function Module() {
+
+}
+
+Module.prototype.init = function (Manager, data) {
+  const self = this;
+  self.Manager = Manager;
+  self.libraries = Manager.libraries;
+  self.assistant = Manager.Assistant()
+
+  self.context = data.context;
+  return self;
+}
+
+Module.prototype.main = function() {
+  const self = this;
+  const Manager = self.Manager;
+  const libraries = self.libraries;
+  const assistant = self.assistant;
+  const context = self.context;
+
+  return new Promise(async function(resolve, reject) {
+    fetch(`${Manager.project.functionsUrl}/bm_api`, {
+      method: 'post',
+      body: {
+        backendManagerKey: Manager.config.backend_manager.key,
+        command: 'admin:backup',
+      }
+    })
+    .then(response => {
+      assistant.log(`Successfully executed backup: ${response}`, {environment: 'production'})
+      return resolve(response);
+    })
+    .catch(e => {
+      assistant.errorManager(`Error executing backup: ${e}`, {sentry: true, send: false, log: true})
+      return reject();
+    })
+  });
+}
+
+module.exports = Module;

package/src/manager/index-bu.js

@@ -0,0 +1,235 @@
+if (options.setupFunctions) {
+  // exporter.bm_api =
+  // self.libraries.functions
+  // .runWith({memory: '256MB', timeoutSeconds: 60})
+  // .https.onRequest(async (req, res) => {
+  //   const Module = (new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, });
+  //
+  //   return self._preProcess(Module)
+  //   .then(r => Module.main())
+  //   .catch(e => {
+  //     self.assistant.error(e, {environment: 'production'});
+  //     return res.status(500).send(e.message);
+  //   });
+  // });
+  exporter.bm_api =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .https.onRequest(async (req, res) => {
+    return self._process((new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, }))
+  });
+
+  if (options.setupFunctionsLegacy) {
+    exporter.bm_signUpHandler =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/sign-up-handler.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    // Admin
+    exporter.bm_createPost =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/create-post.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_firestoreWrite =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/firestore-write.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_getStats =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 420})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/get-stats.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_sendNotification =
+    self.libraries.functions
+    .runWith({memory: '1GB', timeoutSeconds: 420})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/send-notification.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_query =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/query.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_createPostHandler =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/create-post-handler.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_generateUuid =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/generate-uuid.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    // Test
+    exporter.bm_test_authenticate =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/authenticate.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_test_createTestAccounts =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/create-test-accounts.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_test_webhook =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/webhook.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e, {environment: 'production'});
+        return res.status(500).send(e.message);
+      });
+    });
+  }
+
+  // Events
+  exporter.bm_authOnCreate =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .auth.user().onCreate(async (user) => {
+    const Module = require(`${core}/events/auth/on-create.js`);
+    Module.init(self, { user: user });
+
+    return self._preProcess(Module)
+    .then(r => Module.main())
+    .catch(e => {
+      self.assistant.error(e, {environment: 'production'});
+    });
+  });
+
+  exporter.bm_authOnDelete =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .auth.user().onDelete(async (user) => {
+    const Module = require(`${core}/events/auth/on-delete.js`);
+    Module.init(self, { user: user });
+
+    return self._preProcess(Module)
+    .then(r => Module.main())
+    .catch(e => {
+      self.assistant.error(e, {environment: 'production'});
+    });
+  });
+
+  exporter.bm_subOnWrite =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .firestore
+  .document('notifications/subscriptions/all/{token}')
+  .onWrite(async (change, context) => {
+    const Module = require(`${core}/events/firestore/on-subscription.js`);
+    Module.init(self, { change: change, context: context, });
+
+    return self._preProcess(Module)
+    .then(r => Module.main())
+    .catch(e => {
+      self.assistant.error(e, {environment: 'production'});
+    });
+  });
+}

package/src/manager/index.js

@@ -93,7 +93,6 @@ Manager.prototype.init = function (exporter, options) {
     ? `http://localhost:5001/${self.project.projectId}/${self.project.resourceZone}`
     : `https://${self.project.resourceZone}-${self.project.projectId}.cloudfunctions.net`;
 
-
   // Use the working Firebase logger that they disabled for whatever reason
   if (self.assistant.meta.environment !== 'development' && options.useFirebaseLogger) {
     require('firebase-functions/lib/logger/compat');
@@ -154,15 +153,9 @@ Manager.prototype.init = function (exporter, options) {
     exporter.bm_api =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
-    .https.onRequest(async (req, res) => {
-      const Module = (new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, });
-
-      return self._preProcess(Module)
-      .then(r => Module.main())
-      .catch(e => {
-        self.assistant.error(e, {environment: 'production'});
-        return res.status(500).send(e.message);
-      });
+    .https
+    .onRequest(async (req, res) => {
+      return self._process((new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, }))
     });
 
     if (options.setupFunctionsLegacy) {
@@ -338,45 +331,34 @@ Manager.prototype.init = function (exporter, options) {
     exporter.bm_authOnCreate =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
-    .auth.user().onCreate(async (user) => {
-      const Module = require(`${core}/events/auth/on-create.js`);
-      Module.init(self, { user: user });
-
-      return self._preProcess(Module)
-      .then(r => Module.main())
-      .catch(e => {
-        self.assistant.error(e, {environment: 'production'});
-      });
+    .auth.user()
+    .onCreate(async (user) => {
+      return self._process((new (require(`${core}/events/auth/on-create.js`))()).init(self, { user: user, }))
     });
 
     exporter.bm_authOnDelete =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
-    .auth.user().onDelete(async (user) => {
-      const Module = require(`${core}/events/auth/on-delete.js`);
-      Module.init(self, { user: user });
-
-      return self._preProcess(Module)
-      .then(r => Module.main())
-      .catch(e => {
-        self.assistant.error(e, {environment: 'production'});
-      });
+    .auth.user()
+    .onDelete(async (user) => {
+      return self._process((new (require(`${core}/events/auth/on-delete.js`))()).init(self, { user: user, }))
     });
 
     exporter.bm_subOnWrite =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
-    .firestore
-    .document('notifications/subscriptions/all/{token}')
+    .firestore.document('notifications/subscriptions/all/{token}')
     .onWrite(async (change, context) => {
-      const Module = require(`${core}/events/firestore/on-subscription.js`);
-      Module.init(self, { change: change, context: context, });
+      return self._process((new (require(`${core}/events/firestore/on-subscription.js`))()).init(self, { change: change, context: context, }))
+    });
 
-      return self._preProcess(Module)
-      .then(r => Module.main())
-      .catch(e => {
-        self.assistant.error(e, {environment: 'production'});
-      });
+    // Cron
+    exporter.bm_backup =
+    self.libraries.functions
+    .runWith({ memory: '256MB', timeoutSeconds: 60 })
+    .pubsub.schedule(get(self.config, 'backup.schedule', 'every 24 hours'))
+    .onRun(async (context) => {
+      return self._process((new (require(`${core}/cron/backup.js`))()).init(self, { context: context, }))
     });
   }
 
@@ -396,6 +378,46 @@ Manager.prototype.init = function (exporter, options) {
 };
 
 // HELPERS
+Manager.prototype._process = function (mod) {
+  const self = this;
+  const name = mod.assistant.meta.name;
+  const hook = self.handlers && self.handlers[name];
+  const req = mod.req;
+  const res = mod.res;
+
+  return new Promise(async function(resolve, reject) {
+    let error;
+
+    function _reject(e, log) {
+      if (log) {
+        // self.assistant.error(e, {environment: 'production'});
+        mod.assistant.errorManager(e, {code: 500, sentry: true, send: false, log: true});
+      }
+      // res.status(500).send(e.message);
+      return resolve()
+    }
+
+    // Run pre
+    if (hook) {
+      await hook(mod, 'pre').catch(e => {error = e});
+    }
+    if (error) { return _reject(error, true) }
+
+    // Run main
+    await mod.main().catch(e => {error = e});
+    if (error) { return _reject(error, false) }
+
+    // Run post
+    if (hook) {
+      await hook(mod, 'post').catch(e => {error = e});
+    }
+    if (error) { return _reject(error, true) }
+
+    // Fin
+    return resolve();
+  });
+};
+
 Manager.prototype._preProcess = function (mod) {
   const self = this;
   const name = mod.assistant.meta.name;