backend-manager 3.0.62 → 3.0.64

package/package.json

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

package/src/manager/functions/core/actions/api/user/sign-up.js

@@ -23,7 +23,7 @@ Module.prototype.main = function () {
         // Get auth user from firebase
         const ip = assistant.request.geolocation.ip;
         const authUser = await Manager.libraries.admin.auth().getUser(user.auth.uid).catch(e => e);
-        const usage = await Manager.Usage().init(assistant, {log: true, localKey: ip});
+        const usage = await Manager.Usage().init(assistant, {log: true, key: ip});
 
         if (authUser instanceof Error) {
           return reject(assistant.errorManager(`Failed to get auth user: ${authUser}`, {code: 500, sentry: false, send: false, log: false}).error)

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/functions/core/events/auth/before-create.js

@@ -31,6 +31,8 @@ Module.prototype.main = function () {
 
     assistant.log(`Request: ${user.uid}`, user, context);
 
+    // TODO: ⛔️⛔️⛔️ UTILIZE THE NEW .usage() system (similar to src/manager/functions/core/actions/api/user/sign-up.js)
+
     // if (context.additionalUserInfo.recaptchaScore < 0.5) {
     //   assistant.error(`Recaptcha score (${context.additionalUserInfo.recaptchaScore}) too low for ${user.uid}`);
 

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

@@ -41,7 +41,8 @@ Usage.prototype.init = function (assistant, options) {
     options.refetch = typeof options.refetch === 'undefined' ? false : options.refetch;
     options.clear = typeof options.clear === 'undefined' ? false : options.clear;
     options.today = typeof options.today === 'undefined' ? undefined : options.today;
-    options.localKey = typeof options.localKey === 'undefined' ? undefined : options.localKey;
+    options.key = typeof options.key === 'undefined' ? undefined : options.key;
+    options.unauthenticatedMode = typeof options.unauthenticatedMode === 'undefined' ? 'firestore' : options.unauthenticatedMode;
     options.log = typeof options.log === 'undefined' ? false : options.log;
 
     // Check for required options
@@ -59,11 +60,11 @@ Usage.prototype.init = function (assistant, options) {
     self.storage = Manager.storage({name: 'usage', temporary: true, clear: options.clear, log: options.log});
 
     // Set local key
-    const localKey = (options.localKey || self.assistant.request.geolocation.ip || '')
+    self.key = (options.key || self.assistant.request.geolocation.ip || '')
       .replace(/[\.:]/g, '_');
 
     // Set paths
-    self.paths.user = `users.${localKey}`;
+    self.paths.user = `users.${self.key}`;
     self.paths.app = `apps.${options.app}`;
 
     // Get storage data
@@ -73,10 +74,26 @@ Usage.prototype.init = function (assistant, options) {
     // Authenticate user (user will be resolved as well)
     self.user = await assistant.authenticate();
 
-    // Replce with local if no user
-    if (!self.user.auth.uid) {
-      const existingLocal = self.storage.get(self.paths.user, {}).value();
-      self.user.usage = existingLocal && existingLocal.usage ? existingLocal.usage : self.user.usage;
+    self.useUnauthenticatedStorage = !self.user.auth.uid || self.options.key;
+
+    // Load usage with temporary if unauthenticated
+    if (self.useUnauthenticatedStorage) {
+      let foundUsage;
+
+      if (options.unauthenticatedMode === 'firestore') {
+        foundUsage = await Manager.libraries.admin.firestore().doc(`temporary/usage`)
+          .get()
+          .then((r) => {
+            return r.data()?.[`${self.key}`];
+          })
+          .catch((e) => {
+            assistant.errorManager(`Usage.init(): Error fetching usage data: ${e}`, {sentry: true, send: false, log: true});
+          });
+      } else {
+        foundUsage = self.storage.get(`${self.paths.user}.usage`, {}).value();
+      }
+
+      self.user.usage = foundUsage ? foundUsage : self.user.usage;
     }
 
     // Log
@@ -209,7 +226,7 @@ Usage.prototype.set = function (path, value) {
   const assistant = self.assistant;
 
   // Update total and period
-  const resolved = `usage.${path}.${key}`;
+  const resolved = `usage.${path}.period`;
 
   value = value || 0;
 
@@ -227,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) {
@@ -235,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 () {
@@ -245,11 +272,29 @@ Usage.prototype.update = function () {
     const Manager = self.Manager;
     const assistant = self.assistant;
 
-    // Write self.user to firestore or local if no user or if localKey is set
-    if (
-      self.user.auth.uid
-      && !self.options.localKey
-    ) {
+    // Write self.user to firestore or local if no user or if key is set
+    if (self.useUnauthenticatedStorage) {
+      if (self.options.unauthenticatedMode === 'firestore') {
+        Manager.libraries.admin.firestore().doc(`temporary/usage`)
+          .set({
+            [`${self.key}`]: self.user.usage,
+          }, {merge: true})
+          .then(() => {
+            self.log(`Usage.update(): Updated user.usage in firestore`, self.user.usage);
+
+            return resolve();
+          })
+          .catch(e => {
+            return reject(assistant.errorManager(e, {sentry: true, send: false, log: false}));
+          });
+      } else {
+        self.storage.set(`${self.paths.user}.usage`, self.user.usage).write();
+
+        self.log(`Usage.update(): Updated user.usage in local storage`, self.user.usage);
+
+        return resolve();
+      }
+    } else {
       Manager.libraries.admin.firestore().doc(`users/${self.user.auth.uid}`)
         .set({
           usage: self.user.usage,
@@ -262,12 +307,6 @@ Usage.prototype.update = function () {
         .catch(e => {
           return reject(assistant.errorManager(e, {sentry: true, send: false, log: false}));
         });
-    } else {
-      self.storage.set(`${self.paths.user}.usage`, self.user.usage).write();
-
-      self.log(`Usage.update(): Updated user.usage in local storage`, self.user.usage);
-
-      return resolve();
     }
   });
 };

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');