backend-manager 3.2.85 → 3.2.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.85",
+  "version": "3.2.86",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -71,4 +71,4 @@
     "wonderful-log": "^1.0.5",
     "yargs": "^17.7.2"
   }
-}
+}

package/src/manager/helpers/assistant.js

@@ -349,7 +349,7 @@ BackendAssistant.prototype.errorify = function (e, options) {
   // Construct error
   const newError = e instanceof Error
     ? e
-    : new Error(stringify(e));
+    : new Error(stringifyNonStrings(e));
 
   // Fix code
   // options.code = newError.code || options.code;
@@ -474,7 +474,7 @@ function isBetween(value, min, max) {
   return value >= min && value <= max;
 }
 
-function stringify(e) {
+function stringifyNonStrings(e) {
   if (typeof e === 'string') {
     return e;
   } else {
@@ -942,30 +942,33 @@ BackendAssistant.prototype.parseMultipartFormData = function (options) {
   });
 }
 
-function stringify(obj, replacer, spaces, cycleReplacer) {
-  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
-}
-
-// https://github.com/moll/json-stringify-safe/blob/master/stringify.js
-function serializer(replacer, cycleReplacer) {
-  var stack = [], keys = []
-
-  if (cycleReplacer == null) cycleReplacer = function(key, value) {
-    if (stack[0] === value) return '[Circular ~]'
-    return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`;
-  }
-
-  return function(key, value) {
-    if (stack.length > 0) {
-      var thisPos = stack.indexOf(this)
-      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
-      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
-      if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
-    }
-    else stack.push(value)
-
-    return replacer == null ? value : replacer.call(this, key, value)
-  }
-}
+// Not sure what this is for? But it has a good serializer code
+// Disabled 2024-03-21 because there was another stringify() function that i was intending to use but it was actually using this
+// It was adding escaped quotes to strings
+// function stringify(obj, replacer, spaces, cycleReplacer) {
+//   return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
+// }
+
+// // https://github.com/moll/json-stringify-safe/blob/master/stringify.js
+// function serializer(replacer, cycleReplacer) {
+//   var stack = [], keys = []
+
+//   if (cycleReplacer == null) cycleReplacer = function(key, value) {
+//     if (stack[0] === value) return '[Circular ~]'
+//     return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`;
+//   }
+
+//   return function(key, value) {
+//     if (stack.length > 0) {
+//       var thisPos = stack.indexOf(this)
+//       ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
+//       ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+//       if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
+//     }
+//     else stack.push(value)
+
+//     return replacer == null ? value : replacer.call(this, key, value)
+//   }
+// }
 
 module.exports = BackendAssistant;

package/src/manager/helpers/middleware.js

@@ -34,6 +34,7 @@ Middleware.prototype.run = function (libPath, options) {
     options.setupAnalytics = typeof options.setupAnalytics === 'boolean' ? options.setupAnalytics : true;
     options.setupUsage = typeof options.setupUsage === 'boolean' ? options.setupUsage : true;
     options.setupSettings = typeof options.setupSettings === 'undefined' ? true : options.setupSettings;
+    options.cleanSettings = typeof options.cleanSettings === 'undefined' ? true : options.cleanSettings;
     options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
 
     // Log
@@ -80,12 +81,19 @@ Middleware.prototype.run = function (libPath, options) {
     if (options.setupSettings) {
       // assistant.log(`Middleware.process(): Resolving settings with schema ${options.schema}...`);
 
+      // Resolve settings
       try {
         assistant.settings = Manager.Settings().resolve(assistant, options.schema, data);
       } catch (e) {
         return assistant.respond(new Error(`Unable to resolve schema ${options.schema}: ${e.message}`), {code: 500, sentry: true});
       }
 
+      // Clean settings by looping through and trimming all strings
+      if (options.cleanSettings) {
+        clean(assistant.settings);
+      }
+
+      // Log
       assistant.log(`Middleware.process(): Resolved settings with schema ${options.schema}`, JSON.stringify(assistant.settings));
     }
 
@@ -106,4 +114,15 @@ Middleware.prototype.run = function (libPath, options) {
   });
 };
 
+function clean(obj) {
+  for (let key in obj) {
+    if (typeof obj[key] === 'object') {
+      clean(obj[key]);
+    } else if (typeof obj[key] === 'string') {
+      obj[key] = obj[key]
+        .trim();
+    }
+  }
+}
+
 module.exports = Middleware;

package/src/manager/helpers/settings.js

@@ -42,22 +42,36 @@ Settings.prototype.resolve = function (assistant, schema, settings) {
   // Resolve settings
   self.settings = powertools.defaults(settings, schema);
 
-  // Check for missing required keys
-  powertools.getKeys(schema).forEach((key) => {
-    const isRequired = key.endsWith('.required') ? _.get(schema, key, false) : false;
+  // Iterate each key and check for some things
+  processSchema(schema, (path, schemaNode) => {
+    const originalValue = _.get(settings, path);
+    const resolvedValue = _.get(self.settings, path);
+    let replaceValue = undefined;
+
+    // assistant.log('Found:', path, schemaNode);
+    // assistant.log('originalValue:', originalValue);
+    // assistant.log('resolvedValue:', resolvedValue);
+
+    // Check if this node is marked as required
+    if (schemaNode.required && typeof originalValue === 'undefined') {
+      throw assistant.errorify(`Required key {${path}} is missing in settings`, {code: 400});
+    }
 
-    // Skip if not required
-    if (!isRequired) {
-      return;
+    // Clean
+    if (schemaNode.clean) {
+      if (schemaNode.clean instanceof RegExp) {
+        replaceValue = resolvedValue.replace(schemaNode.clean, '');
+      } else if (typeof schemaNode.clean === 'function') {
+        replaceValue = schemaNode.clean(resolvedValue);
+      }
     }
 
-    // Use regex to replace '.required' only if it's at the end of the string
-    const settingsKey = key.replace(/\.required$/, '');
+    // assistant.log('replaceValue:', replaceValue);
 
-    // Check if the required key is missing
-    if (typeof _.get(settings, settingsKey, undefined) === 'undefined') {
-      // Handle the missing required key as needed
-      throw assistant.errorify(`Required key '${settingsKey}' is missing in settings`, {code: 400});
+    // Replace
+    if (typeof replaceValue !== 'undefined' && replaceValue !== resolvedValue) {
+      assistant.warn(`Replacing ${path}: originalValue=${originalValue}, resolvedValue=${resolvedValue}, replaceValue=${replaceValue}`);
+      _.set(self.settings, path, replaceValue);
     }
   });
 
@@ -92,6 +106,23 @@ Settings.prototype.constant = function (name, options) {
   }
 };
 
+function processSchema(schema, fn, path) {
+  path = path || '';
+
+  // Base case: Check if the current level has 'types' and 'default', indicating metadata
+  if (schema.hasOwnProperty('types') && schema.hasOwnProperty('default')) {
+    // Call the processing function with the current path and schema as arguments
+    fn(path, schema);
+    return;
+  }
+
+  // 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);
+  });
+}
+
 function loadSchema(assistant, schema, settings) {
   const planId = assistant.request.user.plan.id;