backend-manager 3.2.170 → 3.2.171

package/dist/manager/helpers/metadata.js

@@ -0,0 +1,32 @@
+const moment = require('moment');
+const uuidv4 = require('uuid').v4;
+
+function Metadata(Manager, document) {
+  const self = this;
+
+  self.Manager = Manager;
+
+  self.document = document || {};
+
+  return self;
+}
+
+Metadata.prototype.set = function (metadata) {
+  const self = this;
+
+  const now = moment();
+
+  self.document = self.document || {};
+  self.document.metadata = self.document.metadata || {};
+
+  self.document.metadata.updated = self.document.metadata.updated || {};
+  self.document.metadata.updated.timestamp = now.toISOString();
+  self.document.metadata.updated.timestampUNIX = now.unix();
+  self.document.metadata.tag = metadata.tag || uuidv4();
+
+  self.Manager.assistant.log(`Metadata: #${self.document.metadata.tag}`);
+
+  return self.document.metadata;
+};
+
+module.exports = Metadata;

package/dist/manager/helpers/middleware.js

@@ -0,0 +1,154 @@
+/**
+ * Middleware
+ * Used to handle middleware for the assistant
+ */
+
+const path = require('path');
+const powertools = require('node-powertools');
+const { merge } = require('lodash');
+
+function Middleware(m, req, res) {
+  const self = this;
+
+  self.Manager = m;
+  self.req = req;
+  self.res = res;
+}
+
+Middleware.prototype.run = function (libPath, options) {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = self.Manager;
+  const req = self.req;
+  const res = self.res;
+  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.authenticate = typeof options.authenticate === 'boolean' ? options.authenticate : true;
+    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.includeNonSchemaSettings = typeof options.includeNonSchemaSettings === 'undefined' ? false : options.includeNonSchemaSettings;
+    options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
+
+    // Set base path
+    options.routesDir = typeof options.routesDir === 'undefined' ? `${Manager.cwd}/routes` : options.routesDir;
+    options.schemasDir = typeof options.schemasDir === 'undefined' ? `${Manager.cwd}/schemas` : options.schemasDir;
+
+    // Log
+    assistant.log(`Middleware.process(): Request (${geolocation.ip} @ ${geolocation.country}, ${geolocation.region}, ${geolocation.city})`, JSON.stringify(data));
+
+    // Set paths
+    const routesDir = path.resolve(options.routesDir, libPath.replace('.js', ''));
+    const schemasDir = path.resolve(options.schemasDir);
+
+    // Wakeup trigger (quit immediately if wakeup is true to avoid cold start on a future request)
+    if (data.wakeup) {
+      assistant.log(`Middleware.process(): Wakeup activated at ${new Date().toISOString()}`);
+
+      return assistant.respond({wakeup: true});
+    }
+
+    // Load library
+    let library;
+    try {
+      libPath = path.resolve(routesDir, `index.js`);
+      library = new (require(libPath))();
+    } catch (e) {
+      return assistant.respond(new Error(`Unable to load library @ (${libPath}): ${e.message}`), {code: 500, sentry: true});
+    }
+
+    // Setup user
+    if (!options.setupUsage && options.authenticate) {
+      await assistant.authenticate();
+    }
+
+    // Setup usage
+    if (options.setupUsage) {
+      // assistant.usage = await Manager.Usage().init(assistant, {log: assistant.isProduction()});
+      assistant.usage = await Manager.Usage().init(assistant, {log: false});
+    }
+
+    // Log working user
+    const workingUser = assistant.getUser();
+    assistant.log(`Middleware.process(): User (${workingUser.auth.uid}, ${workingUser.auth.email}, ${workingUser.plan.id}=${workingUser.plan.status}):`, JSON.stringify(workingUser));
+
+    // Setup analytics
+    if (options.setupAnalytics) {
+      const uuid = assistant?.usage?.user?.auth?.uid
+        || assistant.request.user.auth.uid
+        || assistant.request.geolocation.ip
+
+      assistant.analytics = Manager.Analytics({
+        assistant: assistant,
+        uuid: uuid,
+      });
+    }
+
+    // Resolve settings
+    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);
+        assistant.settings = Manager.Settings().resolve(assistant, undefined, data, {dir: schemasDir, schema: options.schema});
+      } catch (e) {
+        return assistant.respond(new Error(`Unable to resolve schema ${options.schema}: ${e.message}`), {code: 500, sentry: true});
+      }
+
+      // Merge settings with data
+      if (options.includeNonSchemaSettings) {
+        assistant.settings = merge(data, assistant.settings)
+      }
+
+      // 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));
+    } else {
+      assistant.settings = data;
+    }
+
+    // Process
+    try {
+      // Set properties
+      library.Manager = Manager;
+      library.assistant = assistant;
+
+      // Run library
+      library.main(assistant, req, res)
+      .catch(e => {
+        return assistant.respond(e, {code: e.code, sentry: true});
+      });
+    } catch (e) {
+      return assistant.respond(e, {code: e.code, sentry: true});
+    }
+  });
+};
+
+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/dist/manager/helpers/roles.js

@@ -0,0 +1,69 @@
+function Roles(Manager) {
+  const self = this;
+  
+  self.Manager = Manager;
+}
+
+Roles.prototype.list = function () {
+  const self = this;
+
+  return [
+    // Staff
+    {
+      id: 'staff',
+      name: 'Staff',
+      regex: /(^staff$)/ig,
+    },    
+    {
+      id: 'admin',
+      name: 'Administrator',
+      regex: /(^administrator$|^admin$)/ig,
+    },
+    {
+      id: 'moderator',
+      name: 'Moderator',
+      regex: /(^moderator$|^mod$)/ig,
+    },
+    {
+      id: 'moderatorJr',
+      name: 'Jr. Moderator',
+      regex: /(^moderatorjr$|^modjr$)/ig,
+    },    
+    {
+      id: 'blogger',
+      name: 'Blogger',
+      regex: /(^blogger$|^blog$)/ig,
+    },
+    {
+      id: 'developer',
+      name: 'Developer',
+      regex: /(^developer$|^dev$)/ig,
+    },
+
+    // Features
+    {
+      id: 'betaTester',
+      name: 'Beta Tester',
+      regex: /(^betatester$|^beta$)/ig,
+    },
+    {
+      id: 'serverBooster',
+      name: 'Server Booster',
+      regex: /(^serverbooster$|^booster$)/ig,
+    },      
+
+    // Vanity
+    {
+      id: 'og',
+      name: 'OG',
+      regex: /(^og$)/ig,
+    },
+    {
+      id: 'vip',
+      name: 'VIP',
+      regex: /(^vip)/ig,
+    },    
+  ]
+};
+
+module.exports = Roles;

package/dist/manager/helpers/settings.js

@@ -0,0 +1,158 @@
+/**
+ * Settings
+ *
+ */
+// const jetpack = require('fs-jetpack');
+const path = require('path');
+const powertools = require('node-powertools');
+const _ = require('lodash');
+const moment = require('moment');
+
+function Settings(m) {
+  const self = this;
+
+  self.Manager = m;
+
+  self.settings = null;
+}
+
+Settings.prototype.resolve = function (assistant, schema, settings, options) {
+  const self = this;
+  const Manager = self.Manager;
+
+  // Set settings
+  schema = schema || undefined;
+  settings = settings || {};
+
+  // Set options
+  options = options || {};
+  options.dir = typeof options.dir === 'undefined' ? `${Manager.cwd}/schemas` : options.dir;
+  options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
+
+  // Load schema if not provided and schema is defined in options
+  // console.log('----schema:', schema);
+  // console.log('----settings:', settings);
+  // console.log('----options.dir:', options.dir);
+  // console.log('----options.schema:', options.schema);
+  if (
+    typeof schema === 'undefined'
+    && typeof options.schema !== 'undefined'
+  ) {
+    const schemaPath = path.resolve(options.dir, `${options.schema.replace('.js', '')}.js`);
+
+    schema = loadSchema(assistant, schemaPath, settings);
+  }
+
+  // Resolve settings
+  self.settings = powertools.defaults(settings, schema);
+
+  // If schema is not an object, throw an error
+  if (!schema || typeof schema !== 'object') {
+    throw assistant.errorify(`Invalid schema provided`, {code: 400});
+  }
+  // console.log('---schema', schema);
+  // console.log('---self.settings', self.settings);
+
+  // 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
+    let isRequired = false;
+    if (typeof schemaNode.required === 'function') {
+      isRequired = schemaNode.required(assistant);
+    } else if (typeof schemaNode.required === 'boolean') {
+      isRequired = schemaNode.required;
+    }
+
+    // assistant.log('isRequired:', isRequired);
+
+    // If the key is required and the original value is undefined, throw an error
+    if (isRequired && typeof originalValue === 'undefined') {
+      throw assistant.errorify(`Required key {${path}} is missing in settings`, {code: 400});
+    }
+
+    // Clean
+    if (schemaNode.clean) {
+      if (schemaNode.clean instanceof RegExp) {
+        replaceValue = resolvedValue.replace(schemaNode.clean, '');
+      } else if (typeof schemaNode.clean === 'function') {
+        replaceValue = schemaNode.clean(resolvedValue);
+      }
+    }
+
+    // assistant.log('replaceValue:', replaceValue);
+
+    // Replace
+    if (typeof replaceValue !== 'undefined' && replaceValue !== resolvedValue) {
+      assistant.warn(`Replacing ${path}: originalValue=${originalValue}, resolvedValue=${resolvedValue}, replaceValue=${replaceValue}`);
+      _.set(self.settings, path, replaceValue);
+    }
+  });
+
+  // Resolve
+  return self.settings;
+};
+
+Settings.prototype.constant = function (name, options) {
+  const self = this;
+  const Manager = self.Manager;
+
+  options = options || {};
+  options.date = typeof options.date === 'undefined' ? moment() : moment(options.date);
+
+  if (name === 'timestamp') {
+    return {
+      types: ['string'],
+      value: undefined,
+      default: options.date.toISOString(),
+    }
+  } else if (name === 'timestampUNIX') {
+    return {
+      types: ['number'],
+      value: undefined,
+      default: options.date.unix(),
+    }
+  } else if (name === 'timestampFULL') {
+    return {
+      timestamp: self.constant('timestamp', options),
+      timestampUNIX: self.constant('timestampUNIX', 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;
+
+  const lib = require(schema)(assistant);
+  const def = lib.defaults;
+  const plan = lib[planId];
+
+  // Merge
+  return _.merge({}, def, plan);
+}
+
+module.exports = Settings;