backend-manager 3.0.63 → 3.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.0.63",
+  "version": "3.0.64",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/manager/functions/core/cron/daily/reset-usage.js

@@ -163,6 +163,15 @@ Module.prototype.clearFirestore = function() {
       })
     }
 
+    // Clear temporary/usage in firestore by deleting the doc
+    await libraries.admin.firestore().doc(`temporary/usage`).delete()
+    .then(r => {
+      assistant.log(`cron/daily/reset-usage() [firestore]: Deleted temporary/usage`);
+    })
+    .catch(e => {
+      assistant.errorManager(`Error deleting temporary/usage: ${e}`, {sentry: false, send: false, log: true})
+    })
+
     return resolve();
   });
 }

package/src/manager/helpers/assistant.js

@@ -33,6 +33,11 @@ BackendAssistant.prototype.init = function (ref, options) {
 
   const now = new Date();
 
+  // Attached libraries - used in .errorify()
+  self.analytics = null;
+  self.usage = null;
+
+  // Set meta
   self.meta = {};
 
   self.meta.startTime = {};
@@ -43,6 +48,7 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.meta.environment = options.environment || self.getEnvironment();
   self.meta.type = options.functionType || process.env.FUNCTION_SIGNATURE_TYPE || 'unknown';
 
+  // Set ref
   self.ref = {};
   ref = ref || {};
   self.ref.res = ref.res || {};
@@ -50,14 +56,17 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.ref.admin = ref.admin || {};
   self.ref.functions = ref.functions || {};
   self.ref.Manager = ref.Manager || {};
+  self.Manager = self.ref.Manager;
 
   // Set ID
   try {
-    self.id = self.ref.Manager.Utilities().randomId();
+    self.id = self.Manager.Utilities().randomId();
   } catch {
     self.id = now.getTime();
   }
 
+  self.tag = `${self.meta.name}/${self.id}`;
+
   // Set stuff about request
   self.request = {};
   self.request.referrer = (self.ref.req.headers || {}).referrer || (self.ref.req.headers || {}).referer || '';
@@ -146,6 +155,7 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.constant.pastTime.timestamp = '1999-01-01T00:00:00Z';
   self.constant.pastTime.timestampUNIX = 915148800;
 
+  // Log options
   if (
     (self.meta.environment === 'development')
     && ((self.request.method !== 'OPTIONS') || (self.request.method === 'OPTIONS' && options.showOptionsLog))
@@ -155,8 +165,10 @@ BackendAssistant.prototype.init = function (ref, options) {
     console.log(options.optionsLogString);
   }
 
+  // Set tmpdir
   self.tmpdir = path.resolve(os.tmpdir(), options.fileSavePath, uuid.v4());
 
+  // Set initialized
   self.initialized = true;
 
   return self;
@@ -279,7 +291,7 @@ BackendAssistant.prototype._log = function() {
   const logs = [...Array.prototype.slice.call(arguments)];
 
   // 2. Prepend log prefix log string
-  logs.unshift(`[${self.meta.name}/${self.id} @ ${new Date().toISOString()}]:`);
+  logs.unshift(`[${self.tag} @ ${new Date().toISOString()}]:`);
 
   // 3. Pass along arguments to console.log
   if (logs[1] === 'error') {
@@ -335,22 +347,36 @@ BackendAssistant.prototype._log = function() {
 BackendAssistant.prototype.errorManager = function(e, options) {
   const self = this;
 
+  // Set options
   options = options || {};
-  options.code = typeof options.code === 'undefined' ? 500 : options.code;
-  options.log = typeof options.log === 'undefined' ? true : options.log;
-  options.sentry = typeof options.sentry === 'undefined' ? true : options.sentry;
-  options.send = typeof options.send === 'undefined' ? true : options.send;
-
+  options.code = typeof options.code === 'undefined'
+    ? 500
+    : options.code;
+  options.log = typeof options.log === 'undefined'
+    ? true
+    : options.log;
+  options.sentry = typeof options.sentry === 'undefined'
+    ? true
+    : options.sentry;
+  options.send = typeof options.send === 'undefined'
+    ? true
+    : options.send;
+
+  // Construct error
   const newError = e instanceof Error
     ? e
     : new Error(stringify(e));
 
+  options.code = newError.code || options.code;
+
   // Attach properties
   Object.keys(options)
   .forEach((item, i) => {
-    Object.assign(newError , { [item]: options[item] })
+    Object.assign(newError, { [item]: options[item] });
   });
 
+  // Attach properties
+  _attachHeaderProperties(self, options);
 
   // Log the error
   if (options.log) {
@@ -359,12 +385,17 @@ BackendAssistant.prototype.errorManager = function(e, options) {
 
   // Send error to Sentry
   if (options.sentry) {
-    self.ref.Manager.libraries.sentry.captureException(newError);
+    self.Manager.libraries.sentry.captureException(newError);
   }
 
   // Quit and respond to the request
   if (options.send && self.ref.res && self.ref.res.status) {
-    self.ref.res.status(options.code).send(newError ? newError.message || newError : 'Unknown error');
+    self.ref.res
+      .status(options.code)
+      .send(newError
+        ? newError.message || newError
+        : 'Unknown error'
+      );
   }
 
   return {
@@ -372,6 +403,38 @@ BackendAssistant.prototype.errorManager = function(e, options) {
   }
 }
 
+BackendAssistant.prototype.errorify = BackendAssistant.prototype.errorManager;
+
+BackendAssistant.prototype.respond = function(response, options) {
+  const self = this;
+
+  // Set options
+  options = options || {};
+  options.code = typeof options.code === 'undefined'
+    ? 200
+    : options.code;
+  options.log = typeof options.log === 'undefined'
+    ? true
+    : options.log;
+
+  // Attach properties
+  _attachHeaderProperties(self, options);
+
+  // Log the error
+  if (options.log) {
+    self.log(`Responding with ${options.code} code:`, JSON.stringify(response));
+  }
+
+  // Send response
+  self.ref.res.status(options.code);
+
+  if (typeof response === 'string') {
+    self.ref.res.send(response);
+  } else {
+    self.ref.res.json(response);
+  }
+}
+
 function stringify(e) {
   if (typeof e === 'string') {
     return e;
@@ -380,6 +443,21 @@ function stringify(e) {
   }
 }
 
+function _attachHeaderProperties(self, options) {
+  // Create headers
+  const headers = {
+    code: options.code,
+    tag: self.tag,
+    usage: {
+      current: self?.usage?.getUsage() || {},
+      limits: self?.usage?.getLimit() || {},
+    },
+    additional: options.additional || {},
+  }
+
+  // Attach properties
+  self.ref.res.header('bm-properties', JSON.stringify(headers));
+}
 
 BackendAssistant.prototype.authenticate = async function (options) {
   const self = this;
@@ -422,7 +500,7 @@ BackendAssistant.prototype.authenticate = async function (options) {
     // Check with custom BEM Token
     let storedApiKey;
     try {
-      const workingConfig = _.get(self.ref.Manager, 'config') || functions.config();
+      const workingConfig = _.get(self.Manager, 'config') || functions.config();
       storedApiKey = _.get(workingConfig, 'backend_manager.key', '')
     } catch (e) {
 

package/src/manager/helpers/middleware.js

@@ -0,0 +1,70 @@
+/**
+ * Middleware
+ * Used to handle middleware for the assistant
+ */
+
+const path = require('path');
+
+function Middleware(m) {
+  const self = this;
+
+  self.Manager = m;
+}
+
+Middleware.prototype.run = function (library, req, res, options) {
+  const self = this;
+  const Manager = self.Manager;
+  const { cors } = Manager.libraries;
+
+  return cors(req, res, async () => {
+    const assistant = Manager.Assistant({req: req, res: res});
+
+    const data = assistant.request.data;
+    const geolocation = assistant.request.geolocation;
+    const client = assistant.request.client;
+
+    // Set options
+    options = options || {};
+    options.setupAnalytics = typeof options.setupAnalytics === 'boolean' ? options.setupAnalytics : true;
+    options.setupUsage = typeof options.setupUsage === 'boolean' ? options.setupUsage : true;
+
+    // Log
+    assistant.log(`Middleware.process(): Request (${geolocation.ip} @ ${geolocation.country}, ${geolocation.region}, ${geolocation.city})`, JSON.stringify(data));
+
+    // Load library
+    try {
+      library = path.resolve(process.cwd(), `${library}.js`);
+      library = new (require(library))();
+    } catch (e) {
+      assistant.errorManager(`Unable to load library @ (${library}): ${e.message}`, {sentry: true, send: true, log: true});
+    }
+
+    // Setup analytics
+    if (options.setupAnalytics) {
+      assistant.analytics = Manager.Analytics({
+        assistant: assistant,
+        uuid: assistant.request.geolocation.ip,
+      })
+    }
+
+    // Setup usage
+    if (options.setupUsage) {
+      assistant.usage = await Manager.Usage().init(assistant);
+    }
+
+    // Process
+    try {
+      library.main(assistant, req, res)
+      // .then(result => {
+      //   return res.status(200).json(result);
+      // })
+      .catch(e => {
+        assistant.errorManager(e, {sentry: true, send: true, log: true});
+      });
+    } catch (e) {
+      assistant.errorManager(e, {sentry: true, send: true, log: true});
+    }
+  });
+};
+
+module.exports = Middleware;

package/src/manager/helpers/usage.js

@@ -244,7 +244,11 @@ Usage.prototype.getUsage = function (path) {
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  return _.get(self.user, `usage.${path}.period`, 0);
+  if (path) {
+    return _.get(self.user, `usage.${path}.period`, 0);
+  } else {
+    return self.user.usage;
+  }
 };
 
 Usage.prototype.getLimit = function (path) {
@@ -252,7 +256,13 @@ Usage.prototype.getLimit = function (path) {
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  return _.get(self.app, `products.${self.options.app}-${self.user.plan.id}.limits.${path}`, 0);
+  const key = `products.${self.options.app}-${self.user.plan.id}.limits`;
+
+  if (path) {
+    return _.get(self.app, `${key}.${path}`, 0);
+  } else {
+    return _.get(self.app, key, {});
+  }
 };
 
 Usage.prototype.update = function () {

package/src/manager/index.js

@@ -606,6 +606,12 @@ Manager.prototype.Usage = function () {
   return new self.libraries.Usage(self, ...arguments);
 };
 
+Manager.prototype.Middleware = function () {
+  const self = this;
+  self.libraries.Middleware = self.libraries.Middleware || require('./helpers/middleware.js');
+  return new self.libraries.Middleware(self, ...arguments);
+};
+
 Manager.prototype.Settings = function () {
   const self = this;
   self.libraries.Settings = self.libraries.Settings || require('./helpers/settings.js');