backend-manager 4.0.13 → 4.0.14

package/src/manager/helpers/settings.js

@@ -18,6 +18,8 @@ function Settings(m) {
 
 Settings.prototype.resolve = function (assistant, schema, settings, options) {
   const self = this;
+
+  // Shortcuts
   const Manager = self.Manager;
 
   // Set settings
@@ -28,6 +30,8 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
   options = options || {};
   options.dir = typeof options.dir === 'undefined' ? `${Manager.cwd}/schemas` : options.dir;
   options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
+  options.user = options.user || assistant.request.user;
+  options.checkRequired = typeof options.checkRequired === 'undefined' ? true : options.checkRequired;
 
   // Load schema if not provided and schema is defined in options
   // console.log('----schema:', schema);
@@ -40,7 +44,7 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
   ) {
     const schemaPath = path.resolve(options.dir, `${options.schema.replace('.js', '')}.js`);
 
-    schema = loadSchema(assistant, schemaPath, settings);
+    schema = loadSchema(assistant, schemaPath, settings, options);
   }
 
   // Resolve settings
@@ -66,7 +70,7 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
     // Check if this node is marked as required
     let isRequired = false;
     if (typeof schemaNode.required === 'function') {
-      isRequired = schemaNode.required(assistant);
+      isRequired = schemaNode.required(assistant, schemaPath, settings, options);
     } else if (typeof schemaNode.required === 'boolean') {
       isRequired = schemaNode.required;
     }
@@ -74,7 +78,7 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
     // assistant.log('isRequired:', isRequired);
 
     // If the key is required and the original value is undefined, throw an error
-    if (isRequired && typeof originalValue === 'undefined') {
+    if (options.checkRequired && isRequired && typeof originalValue === 'undefined') {
       throw assistant.errorify(`Required key {${path}} is missing in settings`, {code: 400});
     }
 
@@ -144,10 +148,12 @@ function processSchema(schema, fn, path) {
   });
 }
 
-function loadSchema(assistant, schema, settings) {
-  const planId = assistant.request.user.plan.id;
+function loadSchema(assistant, schema, settings, options) {
+  // Get plan ID
+  const planId = options?.user?.plan?.id || 'basic';
 
-  const lib = require(schema)(assistant);
+  // Load schema
+  const lib = require(schema)(assistant, schema, settings, options);
   const def = lib.defaults;
   const plan = lib[planId];
 

package/src/manager/helpers/utilities.js

@@ -4,19 +4,27 @@ let _;
 function Utilities(Manager) {
   const self = this;
 
+  // Libraries
   _ = require('lodash');
 
+  // Cache
   self.cache = {};
 
+  // Set Manager
   self.Manager = Manager;
 }
 
 Utilities.prototype.iterateCollection = function (callback, options) {
   const self = this;
+
+  // Shortcuts
   const Manager = self.Manager;
-  const admin = Manager.libraries.admin;
 
   return new Promise(function(resolve, reject) {
+    // Libraries
+    const { admin } = Manager.libraries;
+
+    // Set counters
     let batch = -1;
     let collectionCount = 0;
 
@@ -147,33 +155,43 @@ Utilities.prototype.iterateCollection = function (callback, options) {
 
 Utilities.prototype.iterateUsers = function (callback, options) {
   const self = this;
+
+  // Shortcuts
   const Manager = self.Manager;
-  const admin = Manager.libraries.admin;
 
   return new Promise(function(resolve, reject) {
+    // Libraries
+    const { admin } = Manager.libraries;
+
+    // Set counters
     let batch = -1;
 
+    // Set defaults
     options = options || {};
     options.batchSize = options.batchSize || 1000;
     options.log = options.log;
     options.pageToken = options.pageToken;
 
+    // List all users
     function listAllUsers(nextPageToken) {
       // List batch of users, 1000 at a time.
       admin.auth()
         .listUsers(options.batchSize, nextPageToken)
         .then(async (listUsersResult) => {
-
+          // Increment batch
           batch++;
 
+          // If no users, resolve
           if (listUsersResult.users.length === 0) {
             return resolve();
           }
 
+          // Log
           if (options.log) {
             console.log('Processing batch:', batch);
           }
 
+          // Callback
           callback({
             snap: listUsersResult,
             users: listUsersResult.users,
@@ -190,7 +208,6 @@ Utilities.prototype.iterateUsers = function (callback, options) {
               console.error('Callback failed', e);
               return reject(e)
             });
-
         })
         .catch((e) => {
           console.error('Query failed', e);
@@ -198,33 +215,157 @@ Utilities.prototype.iterateUsers = function (callback, options) {
         });
     }
 
+    // Run
     listAllUsers(options.pageToken);
   });
 };
 
+Utilities.prototype.getDocumentWithOwnerUser = function (path, options) {
+  const self = this;
+
+  // Shortcuts
+  const Manager = self.Manager;
+
+  return new Promise(async function(resolve, reject) {
+    // Libraries
+    const { admin } = Manager.libraries;
+
+    // Set options
+    path = path || '';
+
+    // Set defaults
+    options = options || {};
+    options.owner = options.owner || 'owner.uid';
+    options.log = typeof options.log === 'undefined' ? false : options.log;
+
+    // Set resolve/schema options
+    options.resolve = options.resolve || {};
+    options.resolve.schema = options.resolve.schema || '';
+    options.resolve.checkRequired = options.resolve.checkRequired;
+    options.resolve.assistant = options.resolve.assistant;
+
+    // If no doc is provided, throw an error
+    if (!path) {
+      return reject(new Error('No document provided'));
+    }
+
+    // Get document
+    const document = await admin.firestore().doc(path)
+      .get()
+      .then(doc => {
+        const data = doc.data();
+
+        // If the document doesn't exist, throw an error
+        if (!doc.exists) {
+          return reject(new Error(`Document {${path}} not found`));
+        }
+
+        // Return
+        return data;
+      })
+      .catch((e) => e);
+
+    // Check for errors
+    if (document instanceof Error) {
+      return reject(document);
+    }
+
+    // Log the document
+    if (options.log) {
+      console.log('Document:', document);
+    }
+
+    // Resolve owner UID
+    const ownerUID = _.get(document, options.owner);
+
+    // Get the owner user
+    const user = admin.firestore().doc(`users/${ownerUID}`)
+      .get()
+      .then(doc => {
+        const data = doc.data();
+
+        // If the user doesn't exist, throw an error
+        if (!doc.exists) {
+          return reject(new Error(`User {${ownerUID}} not found`));
+        }
+
+        // Return
+        return data;
+      })
+      .catch((e) => e);
+
+    // Check for errors
+    if (user instanceof Error) {
+      return reject(user);
+    }
+
+    // Create the resolved user
+    const userResolved = Manager.User(user).properties;
+
+    // Log the user
+    if (options.log) {
+      console.log('User:', user);
+      console.log('User (resolved):', userResolved);
+    }
+
+    // Resolve with schema
+    if (options.resolve.schema) {
+      const documentResolved = Manager.Settings().resolve(options.resolve.assistant, undefined, document, {
+        schema: options.resolve.schema,
+        user: userResolved,
+        checkRequired: options.resolve.checkRequired,
+      });
+
+      // Log the resolved document
+      if (options.log) {
+        console.log('Document (resolved):', documentResolved);
+      }
+
+      // Return
+      return resolve({
+        document: documentResolved,
+        user: userResolved,
+      });
+    }
+
+    // Return without schema resolution
+    return resolve({
+      document: document,
+      user: userResolved,
+    });
+  });
+};
+
 Utilities.prototype.randomId = function (options) {
   const self = this;
 
+  // Set defaults
   options = options || {};
   options.size = options.size || 14;
 
-  if (!nanoId) {
-    nanoId = require('nanoid');
+  // Load library
+  nanoId = nanoId
+    ? nanoId
+    : require('nanoid');
 
-    nanoId = nanoId.customAlphabet(
-      nanoId.urlAlphabet.replace(/_|-/g, ''),
-      options.size,
-    )
-  }
+  // Custom alphabet
+  const alphabet = nanoId.customAlphabet(
+    nanoId.urlAlphabet.replace(/_|-/g, ''),
+    options.size,
+  )
 
-  return nanoId();
+  // Return
+  return alphabet();
 };
 
 Utilities.prototype.get = function (docPath, options) {
   const self = this;
 
+  // Shortcuts
+  const Manager = self.Manager;
+
   return new Promise(function(resolve, reject) {
-    const Manager = self.Manager;
+    // Libraries
     const { admin } = Manager.libraries;
 
     // Set defaults