backend-manager 4.1.2 → 4.2.0

package/package.json

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

package/src/manager/functions/core/actions/api/admin/get-stats.js

@@ -205,7 +205,7 @@ Module.prototype.getAllUsers = function () {
 Module.prototype.getAllNotifications = function () {
   const self = this;
   return new Promise(async function(resolve, reject) {
-    await self.libraries.admin.firestore().collection('notifications/subscriptions/all')
+    await self.libraries.admin.firestore().collection('notifications')
     .get()
     .then(function(querySnapshot) {
       return resolve(querySnapshot.size)

package/src/manager/functions/core/actions/api/admin/send-notification.js

@@ -1,20 +1,26 @@
-const path_processing = 'notifications/processing/all/{notificationId}';
-const path_subscriptions = 'notifications/subscriptions/all';
-const badTokenReasons = ['messaging/invalid-registration-token', 'messaging/registration-token-not-registered']
-
+// Constants
+const PATH_NOTIFICATIONS = 'notifications';
+const BAD_TOKEN_REASONS = [
+  'messaging/invalid-registration-token',
+  'messaging/registration-token-not-registered',
+];
+
+// Module
 function Module() {
 
 }
 
+// Main
 Module.prototype.main = function () {
   const self = this;
+
+  // Shortcuts
   const Manager = self.Manager;
   const Api = self.Api;
   const assistant = self.assistant;
   const payload = self.payload;
 
   return new Promise(async function(resolve, reject) {
-
     // Set up response obj
     payload.response.data = {
       subscribers: 0,
@@ -24,33 +30,39 @@ Module.prototype.main = function () {
     }
 
     // Fix notification payload
-    self._notificationPayload = {
-      notification: self.payload.data.payload.notification || {},
-    };
-    self._notificationPayload.notification.title = self.payload.data.payload.title || self.payload.data.payload.notification.title || 'Notification';
-    self._notificationPayload.notification.click_action = self.payload.data.payload.click_action || self.payload.data.payload.notification.click_action || 'https://itwcreativeworks.com';
-    self._notificationPayload.notification.body = self.payload.data.payload.body || self.payload.data.payload.notification.body || 'Check this out';
-    self._notificationPayload.notification.icon = self.payload.data.payload.icon || self.payload.data.payload.notification.icon || self.Manager.config.brand.brandmark || 'https://cdn.itwcreativeworks.com/assets/itw-creative-works/images/socials/itw-creative-works-brandmark-square-black-1024x1024.png';
+    // Yes, it needs to be NESTED!!! DO NOT REMOVE THE NEST!
+    const note = {
+      notification: {
+        title: payload.data.payload.title || 'Notification',
+        body: payload.data.payload.body || 'Check this out',
+        icon: payload.data.payload.icon || 'https://cdn.itwcreativeworks.com/assets/itw-creative-works/images/socials/itw-creative-works-brandmark-square-black-1024x1024.png',
+        click_action: payload.data.payload.clickAction || 'https://itwcreativeworks.com',
+      }
+    }
 
+    // Set notification payload
     try {
-      self._notificationPayload.notification.click_action = new URL(self._notificationPayload.notification.click_action);
-      self._notificationPayload.notification.click_action.searchParams.set('cb', new Date().getTime())
-      self._notificationPayload.notification.click_action = self._notificationPayload.notification.click_action.toString()
+      const url = new URL(note.notification.click_action);
+      url.searchParams.set('cb', new Date().getTime());
+      note.notification.click_action = url.toString();
     } catch (e) {
-      assistant.errorify(`Failed to add cb to URL: ${e}`, {code: 500, log: true});
+      reject(assistant.errorify(`Failed to add cb to URL: ${e}`, {code: 400, log: true}));
     }
 
-    assistant.log('Resolved notification payload', self._notificationPayload)
+    // Log
+    assistant.log('Resolved notification payload', note)
 
+    // Check if user is admin
     if (!payload.user.roles.admin) {
       return reject(assistant.errorify(`Admin required.`, {code: 401}));
     }
 
-    if (!payload.data.payload.title || !payload.data.payload.body) {
+    // Check if title and body are set
+    if (!note.notification.title || !note.notification.body) {
       return reject(assistant.errorify(`Parameters <title> and <body> required`, {code: 400, sentry: true}));
     }
 
-    await self.getTokens({tags: false})
+    await self.processTokens(note, {tags: false})
     .then(r => {
       return resolve({data: payload.response.data})
     })
@@ -62,136 +74,158 @@ Module.prototype.main = function () {
 };
 
 // HELPERS //
-Module.prototype.getTokens = function (options) {
+Module.prototype.processTokens = async function (note, options) {
   const self = this;
+
+  // Shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  // Set options
   options = options || {};
   options.tags = options.tags || false;
 
-  return new Promise(async function(resolve, reject) {
-    let subs = self.libraries.admin.firestore().collection(path_subscriptions);
-    let batchPromises = [];
+  // Define collection path
+  const queryConditions = options.tags
+    ? [{ field: 'tags', operator: 'array-contains-any', value: options.tags }]
+    : [];
 
-    if (options.tags) {
-      subs.where('tags', 'array-contains-any', options.tags)
-    }
-    await subs
-      .get()
-      .then(function(querySnapshot) {
-        self.assistant.log(`Queried ${querySnapshot.size} tokens.`);
-        self.payload.response.data.subscribers = querySnapshot.size;
-        // self.result.subscriptionsStart = querySnapshot.size;
-        let batchCurrentSize = 0;
-        let batchSizeMax = 1000;
-
-        let batchCurrent = [];
-        let batchLoops = 1;
-
-        querySnapshot.forEach(function(doc) {
-          // log(self, 'loading... ', batchLoops+'/'+querySnapshot.size);
-          if ((batchCurrentSize < batchSizeMax - 1) && (batchLoops < querySnapshot.size)) {
-            batchCurrent.push(doc.data().token);
-            batchCurrentSize++;
-          } else {
-            let batchId = batchPromises.length + 1;
-            batchCurrent.push(doc.data().token);
-            batchCurrentSize++;
-            console.log(`Got batch ID: ${batchId} with ${batchCurrentSize} tokens.`);
-            batchPromises.push(self.sendBatch(batchCurrent, batchId));
-            batchCurrent = [];
-            batchCurrentSize = 0;
-            self.payload.response.data.batches++;
-          }
-          batchLoops++;
-        });
-      })
-      .catch(function(e) {
-        self.assistant.error('Error querying tokens: ', e)
-        reject(error);
-      });
-
-    await Promise.all(batchPromises)
-      .then(function(values) {
-        self.assistant.log('Finished all batches.');
-      })
-      .catch(function(e) {
-        self.assistant.error('Error sending batches: ', e)
-      });
-    resolve();
+  // Batch processing logic
+  await Manager.Utilities().iterateCollection(
+    async (batch, index) => {
+      let batchTokens = [];
+
+      // Collect tokens from the current batch
+      for (const doc of batch.docs) {
+        const data = doc.data();
+        batchTokens.push(data.token);
+      }
 
+      // Send the batch
+      try {
+        assistant.log(`Sending batch ${index} with ${batchTokens.length} tokens.`);
+        await self.sendBatch(batchTokens, note, index);
+      } catch (e) {
+        assistant.error(`Error sending batch ${index}`, e);
+      }
+    },
+    {
+      collection: PATH_NOTIFICATIONS,
+      where: queryConditions,
+      batchSize: 1000,
+      log: true,
+    }
+  )
+  .then(() => {
+    assistant.log('All batches processed successfully.');
+  })
+  .catch(e => {
+    assistant.errorify(`Error during token processing: ${e}`, { code: 500, log: true });
   });
-}
+};
 
-Module.prototype.sendBatch = function (batch, id) {
+Module.prototype.sendBatch = async function (batch, note, id) {
   const self = this;
-  return new Promise(async function(resolve, reject) {
-    // self.assistant.log(`Sending batch ID: ${id}`, batch);
-    self.assistant.log(`Sending batch ID: ${id}`);
-
-    // self.assistant.log('payload', payload);
-
-    await self.libraries.admin.messaging().sendToDevice(batch, self._notificationPayload)
-      .then(async function (response) {
-        // self.result.batches.list.push('#' + id + ' | ' + '✅  ' + response.successCount + ' | ' + '❌  ' + response.failureCount);
-        self.assistant.log('Sent batch #' + id);
-        // self.result.successes += response.successCount;
-        // self.result.failures += response.failureCount;
-        // console.log('RESP', response);
-        if (response.failureCount > 0) {
-          await self.cleanTokens(batch, response.results, id);
-        }
-        self.payload.response.data.sent += (batch.length - response.failureCount);
-        resolve();
-      })
-      .catch(function (e) {
-        self.assistant.error('Error sending batch #' + id, e);
-        // self.result.status = 'fail';
-        reject(e);
-      })
-  });
-}
 
-Module.prototype.cleanTokens = function (batch, results, id) {
+  // Shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  // Libraries
+  const { admin } = self.libraries;
+
+  try {
+    // Log
+    assistant.log(`Sending batch ID: ${id}`);
+
+    // Send the batch
+    const response = await admin.messaging().sendToDevice(batch, note);
+
+    // Log
+    assistant.log(`Sent batch ID: ${id}, Success: ${response.successCount}, Failures: ${response.failureCount}`);
+
+    // Clean bad tokens
+    if (response.failureCount > 0) {
+      await self.cleanTokens(batch, response.results, id);
+    }
+
+    // Update response
+    payload.response.data.sent += (batch.length - response.failureCount);
+  } catch (e) {
+    throw assistant.errorify(`Error sending batch ${id}: ${e}`, { code: 500, log: true });
+  }
+};
+
+Module.prototype.cleanTokens = async function (batch, results, id) {
   const self = this;
 
-  return new Promise(async function(resolve, reject) {
-    let cleanPromises = [];
-    // self.assistant.log(`Cleaning tokens of batch ID: ${id}`, results);
-    self.assistant.log(`Cleaning tokens of batch ID: ${id}`);
+  // Shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
 
-    results.forEach(function (item, index) {
-      if (!item.error) {
-        return false;
-      }
-      let curCode = item.error.code;
-      let token = batch[index];
-      self.assistant.log(`Found bad token: ${index} = ${curCode}`);
-      if (badTokenReasons.includes(curCode)) {
-        cleanPromises.push(self.deleteToken(token, curCode));
+  // Log
+  assistant.log(`Cleaning tokens of batch ID: ${id}`);
+
+  // Filter out bad tokens
+  const cleanPromises = results
+    .map((item, index) => {
+      // Check if the token is bad
+      if (item.error && BAD_TOKEN_REASONS.includes(item.error.code)) {
+        const token = batch[index];
+
+        // Log
+        assistant.log(`Found bad token: ${token} (Reason: ${item.error.code})`);
+
+        // Delete the token
+        return self.deleteToken(token, item.error.code);
       }
+
+      // Return null for valid tokens
+      return null;
     })
-    await Promise.all(cleanPromises)
-      .catch(function(e) {
-        self.assistant.log('error', "Error cleaning failed tokens: ", e);
-      });
-    resolve();
-  });
-}
+    // Filter out nulls for valid tokens
+    .filter(Boolean);
+
+  // Clean bad tokens
+  try {
+    await Promise.all(cleanPromises);
+    assistant.log(`Completed cleaning tokens for batch ID: ${id}`);
+  } catch (e) {
+    assistant.error(`Error cleaning tokens for batch ID: ${id}`, e);
+  }
+};
 
-Module.prototype.deleteToken = function (token, errorCode) {
+Module.prototype.deleteToken = async function (token, errorCode) {
   const self = this;
-  return new Promise(function(resolve, reject) {
-    self.libraries.admin.firestore().doc(`${path_subscriptions}/${token}`)
-      .delete()
-      .then(function() {
-        self.assistant.log(`Deleting bad token: ${token} for reason ${errorCode}`);
-        self.payload.response.data.deleted++;
-        resolve();
-      })
-      .catch(function(error) {
-        self.assistant.log('error', `Error deleting bad token: ${token} for reason ${errorCode} because of error ${error}`);
-        resolve();
-      })
-  });
-}
+
+  // Shortcuts
+  const Manager = self.Manager;
+  const Api = self.Api;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  // Libraries
+  const { admin } = self.libraries;
+
+  // Delete the token
+  try {
+    // Delete the token
+    await admin.firestore().doc(`${PATH_NOTIFICATIONS}/${token}`).delete();
+
+    // Log
+    assistant.log(`Deleted bad token: ${token} (Reason: ${errorCode})`);
+
+    // Update response
+    payload.response.data.deleted++;
+  } catch (error) {
+    assistant.error(`Failed to delete bad token: ${token} (Reason: ${errorCode}). Error: ${error}`);
+  }
+};
 
 module.exports = Module;

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

@@ -9,6 +9,8 @@ function Module() {
 
 Module.prototype.init = function (Manager, data) {
   const self = this;
+
+  // Set properties
   self.Manager = Manager;
   self.libraries = Manager.libraries;
   self.assistant = Manager.Assistant({req: data.req, res: data.res})
@@ -30,15 +32,14 @@ Module.prototype.init = function (Manager, data) {
   self.assistant.request.data.payload = self.assistant.request.data.payload || {};
   self.assistant.request.data.options = self.assistant.request.data.options || {};
 
-  if (Manager.options.log) {
-    self.assistant.log(`Executing (log): ${resolved.command}`, self.assistant.request, JSON.stringify(self.assistant.request))
-  }
-
+  // Return
   return self;
 }
 
 Module.prototype.main = function() {
   const self = this;
+
+  // Shortcuts
   const Manager = self.Manager;
   const libraries = self.libraries;
   const assistant = self.assistant;
@@ -47,19 +48,34 @@ Module.prototype.main = function() {
 
   return new Promise(async function(resolve, reject) {
     return libraries.cors(req, res, async () => {
+      // Set properties
       self.payload.data = assistant.request.data;
       self.payload.user = await assistant.authenticate();
 
+      // Set properties
+      const headers = assistant.request.headers;
+      const method = assistant.request.method;
+      const url = assistant.request.url;
+      const geolocation = assistant.request.geolocation;
+      const client = assistant.request.client;
+
+      // Strip URL
+      const strippedUrl = stripUrl(url);
+
       // Quit if OPTIONS request
-      if (self.assistant.request.method === 'OPTIONS') {
+      if (method === 'OPTIONS') {
         return resolve();
       }
 
       // Resolve command
       const resolved = self.resolveCommand(self.payload.data.command);
 
-      self.assistant.log(`Executing: ${resolved.command}`, self.payload, JSON.stringify(self.payload))
-      self.assistant.log(`Resolved URL: ${Manager.project.functionsUrl}?command=${encodeURIComponent(resolved.command)}&payload=${encodeURIComponent(JSON.stringify(self.assistant.request.data.payload))}`)
+      // Log
+      // assistant.log(`Executing: ${resolved.command}`, self.payload, JSON.stringify(self.payload))
+      // assistant.log(`Resolved URL: ${Manager.project.functionsUrl}?command=${encodeURIComponent(resolved.command)}&payload=${encodeURIComponent(JSON.stringify(self.assistant.request.data.payload))}`)
+      assistant.log(`bm_api(${resolved.command}): Request (${geolocation.ip} @ ${geolocation.country}, ${geolocation.region}, ${geolocation.city}) [${method} > ${strippedUrl}]`, JSON.stringify(assistant.request.data));
+      assistant.log(`bm_api(${resolved.command}): Headers`, JSON.stringify(headers));
+
 
       // Set up options
       self.payload.data.options = self.payload.data.options || {};
@@ -70,7 +86,7 @@ Module.prototype.main = function() {
         let delay = Math.floor(self.payload.data.options.delay / 1000);
 
         await powertools.poll(() => {
-          self.assistant.log(`Delaying for ${delay--} seconds...`);
+          assistant.log(`Delaying for ${delay--} seconds...`);
         }, {interval: 1000, timeout: self.payload.data.options.delay})
         .catch(e => e);
       }
@@ -116,7 +132,7 @@ Module.prototype.main = function() {
 
       // Send response
       if (self.payload.response.status >= 200 && self.payload.response.status < 399) {
-        self.assistant.log(`Finished ${resolved.command} (status=${self.payload.response.status})`, self.payload, JSON.stringify(self.payload))
+        assistant.log(`Finished ${resolved.command} (status=${self.payload.response.status})`, self.payload, JSON.stringify(self.payload))
 
         if (self.payload.response.redirect) {
           res.redirect(self.payload.response.redirect);
@@ -126,7 +142,7 @@ Module.prototype.main = function() {
           return resolve();
         }
       } else {
-        self.assistant.error(`Error executing ${resolved.command} @ ${resolved.path} (status=${self.payload.response.status}):`, self.payload.response.error)
+        assistant.error(`Error executing ${resolved.command} @ ${resolved.path} (status=${self.payload.response.status}):`, self.payload.response.error)
         res.send(`${self.payload.response.error}`)
         return reject(self.payload.response.error);
       }
@@ -188,8 +204,17 @@ Module.prototype.import = function (command, payload, user, response) {
 
 Module.prototype.resolveCommand = function (command) {
   const self = this;
+
+  // Shortcuts
+  const assistant = self.assistant;
+
+  // Set original command
   const originalCommand = command;
 
+  // Set properties
+  const method = assistant.request.method;
+
+  // Set command
   command = command || '';
 
   // Start
@@ -251,9 +276,9 @@ Module.prototype.resolveCommand = function (command) {
   // Check local path
   const resolvedPath = self.resolveApiPath(command);
 
-  // if (!command || command === 'error:error') {
-  if (!resolvedPath) {
-    self.assistant.log(`This command does not exist: ${originalCommand} => ${command} @ ${resolvedPath}`)
+  // Log if command does not exist
+  if (method !== 'OPTIONS' && !resolvedPath) {
+    assistant.error(`This command does not exist: ${originalCommand} => ${command} @ ${resolvedPath}`)
   }
 
   return {
@@ -354,4 +379,10 @@ Module.prototype.resolveApiPath = function (command) {
   }
 };
 
+function stripUrl(url) {
+  const newUrl = new URL(url);
+
+  return `${newUrl.hostname}${newUrl.pathname}`.replace(/\/$/, '');
+}
+
 module.exports = Module;

package/src/manager/functions/core/admin/get-stats.js

@@ -179,7 +179,7 @@ let Module = {
   getAllSubscriptions: function () {
     let self = this;
     return new Promise(async function(resolve, reject) {
-      await self.libraries.admin.firestore().collection('notifications/subscriptions/all')
+      await self.libraries.admin.firestore().collection('notifications')
       .get()
       .then(function(querySnapshot) {
         return resolve(querySnapshot.size)

package/src/manager/functions/core/events/firestore/{on-subscription.js → notifications/on-write.js}

@@ -49,12 +49,12 @@ Module.prototype.main = function () {
     if (eventType === 'delete') {
       await libraries.admin.firestore().doc(`meta/stats`)
         .update({
-          'subscriptions.total': libraries.admin.firestore.FieldValue.increment(-1),
+          'notifications.total': libraries.admin.firestore.FieldValue.increment(-1),
         })
         .then(r => {
           analytics = self.Manager.Analytics({
             assistant: assistant,
-            uuid: _.get(dataBefore, 'link.user.data.uid', undefined),
+            uuid: dataBefore?.owner?.uid,
           })
           .event({
             name: 'notification-unsubscribe',
@@ -78,12 +78,12 @@ Module.prototype.main = function () {
   } else if (eventType === 'create') {
       await libraries.admin.firestore().doc(`meta/stats`)
         .update({
-          'subscriptions.total': libraries.admin.firestore.FieldValue.increment(1),
+          'notifications.total': libraries.admin.firestore.FieldValue.increment(1),
         })
         .then(r => {
           analytics = self.Manager.Analytics({
             assistant: assistant,
-            uuid: _.get(dataAfter, 'link.user.data.uid', undefined),
+            uuid: dataAfter?.owner?.uid,
           })
           .event({
             name: 'notification-subscribe',

package/src/manager/helpers/assistant-old-auth.js

@@ -0,0 +1,116 @@
+BackendAssistant.prototype.authenticate = async function (options) {
+  const self = this;
+
+  // Shortcuts
+  let admin = self.ref.admin;
+  let functions = self.ref.functions;
+  let req = self.ref.req;
+  let res = self.ref.res;
+  let data = self.request.data;
+  let idToken;
+
+  options = options || {};
+  options.resolve = typeof options.resolve === 'undefined' ? true : options.resolve;
+
+  function _resolve(user) {
+    user = user || {};
+    user.authenticated = typeof user.authenticated === 'undefined'
+      ? false
+      : user.authenticated;
+
+    if (options.resolve) {
+      self.request.user = self.resolveAccount(user);
+      return self.request.user;
+    } else {
+      return user;
+    }
+  }
+
+  if (req?.headers?.authorization && req?.headers?.authorization?.startsWith('Bearer ')) {
+    // Read the ID Token from the Authorization header.
+    idToken = req.headers.authorization.split('Bearer ')[1];
+    self.log('Found "Authorization" header', idToken);
+  } else if (req?.cookies?.__session) {
+    // Read the ID Token from cookie.
+    idToken = req.cookies.__session;
+    self.log('Found "__session" cookie', idToken);
+  } else if (data.backendManagerKey || data.authenticationToken) {
+    // Check with custom BEM Token
+    let storedApiKey;
+    try {
+      // Disabled this 5/11/24 because i dont know why we would need to do functions.config() if we already have the Manager
+      // const workingConfig = self.Manager?.config || functions.config();
+      storedApiKey = self.Manager?.config?.backend_manager?.key || '';
+    } catch (e) {
+      // Do nothing
+    }
+
+    // Set idToken as working token of either backendManagerKey or authenticationToken
+    idToken = data.backendManagerKey || data.authenticationToken;
+
+    // Log the token
+    self.log('Found "backendManagerKey" or "authenticationToken" parameter', {storedApiKey: storedApiKey, idToken: idToken});
+
+    // Check if the token is correct
+    if (storedApiKey && (storedApiKey === data.backendManagerKey || storedApiKey === data.authenticationToken)) {
+      self.request.user.authenticated = true;
+      self.request.user.roles.admin = true;
+      return _resolve(self.request.user);
+    }
+  } else if (options.apiKey || data.apiKey) {
+    const apiKey = options.apiKey || data.apiKey;
+    self.log('Found "options.apiKey"', apiKey);
+
+    if (apiKey.includes('test')) {
+      return _resolve(self.request.user);
+    }
+
+    await admin.firestore().collection(`users`)
+      .where('api.privateKey', '==', apiKey)
+      .get()
+      .then(function(querySnapshot) {
+        querySnapshot.forEach(function(doc) {
+          self.request.user = doc.data();
+          self.request.user.authenticated = true;
+        });
+      })
+      .catch(function(error) {
+        console.error('Error getting documents: ', error);
+      });
+
+    return _resolve(self.request.user);
+  } else {
+    // self.log('No Firebase ID token was able to be extracted.',
+    //   'Make sure you authenticate your request by providing either the following HTTP header:',
+    //   'Authorization: Bearer <Firebase ID Token>',
+    //   'or by passing a "__session" cookie',
+    //   'or by passing backendManagerKey or authenticationToken in the body or query');
+
+    return _resolve(self.request.user);
+  }
+
+  // Check with firebase
+  try {
+    const decodedIdToken = await admin.auth().verifyIdToken(idToken);
+    if (options.debug) {
+      self.log('Token correctly decoded', decodedIdToken.email, decodedIdToken.user_id);
+    }
+    await admin.firestore().doc(`users/${decodedIdToken.user_id}`)
+    .get()
+    .then(async function (doc) {
+      if (doc.exists) {
+        self.request.user = Object.assign({}, self.request.user, doc.data());
+      }
+      self.request.user.authenticated = true;
+      self.request.user.auth.uid = decodedIdToken.user_id;
+      self.request.user.auth.email = decodedIdToken.email;
+      if (options.debug) {
+        self.log('Found user doc', self.request.user)
+      }
+    })
+    return _resolve(self.request.user);
+  } catch (error) {
+    self.error('Error while verifying Firebase ID token:', error);
+    return _resolve(self.request.user);
+  }
+};