backend-manager 4.1.2 → 4.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "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/settings.js

@@ -62,7 +62,7 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
   // console.log('---self.settings', self.settings);
 
   // Iterate each key and check for some things
-  processSchema(schema, (path, schemaNode) => {
+  iterateSchema(schema, (path, schemaNode) => {
     const originalValue = _.get(settings, path);
     const resolvedValue = _.get(self.settings, path);
     let replaceValue = undefined;
@@ -154,7 +154,7 @@ Settings.prototype.constant = function (name, options) {
   }
 };
 
-function processSchema(schema, fn, path) {
+function iterateSchema(schema, fn, path) {
   path = path || '';
 
   // Base case: Check if the current level has 'types' and 'default', indicating metadata
@@ -167,7 +167,7 @@ function processSchema(schema, fn, path) {
   // Recursive case: Iterate through nested keys if we're not at a metadata node
   Object.keys(schema).forEach(key => {
     const nextPath = path ? `${path}.${key}` : key;
-    processSchema(schema[key], fn, nextPath);
+    iterateSchema(schema[key], fn, nextPath);
   });
 }
 

package/src/manager/index.js

@@ -871,11 +871,11 @@ Manager.prototype.setupFunctions = function (exporter, options) {
   .auth.user()
   .onDelete(async (user, context) => self._process((new (require(`${core}/events/auth/on-delete.js`))()).init(self, { user: user, context: context})));
 
-  exporter.bm_subOnWrite =
+  exporter.bm_notificationsOnWrite =
   self.libraries.functions
   .runWith({memory: '256MB', timeoutSeconds: 60})
-  .firestore.document('notifications/subscriptions/all/{token}')
-  .onWrite(async (change, context) => self._process((new (require(`${core}/events/firestore/on-subscription.js`))()).init(self, { change: change, context: context, })));
+  .firestore.document('notifications/{token}')
+  .onWrite(async (change, context) => self._process((new (require(`${core}/events/firestore/notifications/on-write.js`))()).init(self, { change: change, context: context, })));
 
   // Setup cron jobs
   exporter.bm_cronDaily =

package/templates/backend-manager-tests.js

@@ -126,24 +126,24 @@ describe("BackendManager Tests", () => {
   describe("notifications", () => {
     it("unauthenticated can subscribe", async () => {
       const db = auth(accounts.unauthenticated);
-      const doc = db.doc(`notifications/subscriptions/all/token`);
+      const doc = db.doc(`notifications/token`);
       await firebase.assertSucceeds(doc.set({token: 'token'}));
     });
     it("authenticated can subscribe", async () => {
       const db = auth(accounts.regular);
-      const doc = db.doc(`notifications/subscriptions/all/token`);
+      const doc = db.doc(`notifications/token`);
       await firebase.assertSucceeds(doc.set({token: 'token'}));
     });
 
     it("unauthenticated can read subscription by token", async () => {
       const db = auth(accounts.unauthenticated);
-      const doc = db.doc(`notifications/subscriptions/all/token`);
+      const doc = db.doc(`notifications/token`);
       await firebase.assertSucceeds(doc.get());
     });
 
     it("authenticated can read subscription by token", async () => {
       const db = auth(accounts.regular);
-      const doc = db.doc(`notifications/subscriptions/all/token`);
+      const doc = db.doc(`notifications/token`);
       await firebase.assertSucceeds(doc.get());
     });
 

package/templates/firestore.rules

@@ -9,7 +9,7 @@ service cloud.firestore {
     match /{document=**} {
       allow read, write: if isAdmin();
     }
-        
+
     // Protect user account data
     match /users/{uid} {
       allow read: if belongsTo(uid);
@@ -17,8 +17,8 @@ service cloud.firestore {
     }
 
     // Protect notification data
-    match /notifications/subscriptions/all/{token} {
-      allow read: if existingData().token == token || belongsTo(existingData().link.user.pk);
+    match /notifications/{token} {
+      allow read: if existingData().token == token || belongsTo(existingData().owner.uid);
       allow update: if existingData().token == token;
       allow create: if true;
     }
@@ -40,7 +40,7 @@ service cloud.firestore {
     }
     function belongsTo(identity) {
       return isAuthenticated() && (authUid() == identity || authEmail() == identity);
-      // eventually include a check for (existingData().link.email == identity)...(in case its a doc owned by a user that's not actually user doc)
+      // eventually include a check for (existingData().owner.uid == identity)...(in case its a doc owned by a user that's not actually user doc)
     }
 
     function getRoles() {