backend-manager 3.2.108 → 3.2.110

package/CHANGELOG.md

@@ -15,18 +15,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Security` in case of vulnerabilities.
 
 ---
-## [3.2.32] - 2023-01-30
-### Added
+## [3.2.109] - 2024-05-08
+### Changed
+- Replaced all `methods` references with `routes`. This should be changed in your code as well.
+
+## [3.2.32] - 2024-01-30
+### Changed
 - Modified `.assistant().errorify()` to have defaults of `log`, `sentry`, and `send` to `false` if not specified to prevent accidental logging and premature sending of errors.
 
-## [3.2.30] - 2023-01-30
-### Added
+## [3.2.30] - 2024-01-30
+### Changed
 - Modified `.assistant()` token/key check to use `options.apiKey || data.apiKey`
 
-## [3.2.0] - 2023-01-19
+## [3.2.0] - 2024-01-19
 ### Added
-- Added `.settings()` API. Put your settings in `./schema/*.js` and access them with `assistant.settings.*`.
-
+- Added `.settings()` API. Put your settings in `./schemas/*.js` and access them with `assistant.settings.*`.
 
 ## [3.1.0] - 2023-12-19
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.108",
+  "version": "3.2.110",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -39,13 +39,16 @@
     "@octokit/rest": "^19.0.13",
     "@sendgrid/mail": "^7.7.0",
     "@sentry/node": "^6.19.7",
+    "body-parser": "^1.20.2",
     "busboy": "^1.6.0",
     "chalk": "^4.1.2",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
+    "express": "^4.19.2",
     "firebase-admin": "^11.11.1",
     "firebase-functions": "^4.9.0",
     "fs-jetpack": "^5.1.0",
+    "glob": "^10.3.12",
     "hcaptcha": "^0.1.1",
     "inquirer": "^8.2.5",
     "json5": "^2.2.3",

package/src/cli/cli.js

@@ -82,9 +82,13 @@ Main.prototype.process = async function (args) {
     console.clear();
     process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
   }
+
+  // Log CWD
   if (self.options.cwd) {
     console.log('cwd: ', self.firebaseProjectPath);
   }
+
+  // Run setup
   if (self.options.setup) {
     // console.log(`Running Setup`);
     // console.log(`node:`, process.versions.node);
@@ -95,14 +99,21 @@ Main.prototype.process = async function (args) {
     await cmd_configGet(self).catch(e => log(chalk.red(`Failed to run config:get`)));
     await self.setup();
   }
+
+  // Install local BEM
   if ((self.options.i || self.options.install) && (self.options.local || self.options.dev || self.options.development)) {
     await uninstallPkg('backend-manager');
-    return await installPkg('file:../../../ITW-Creative-Works/backend-manager');
+    // return await installPkg('file:../../../ITW-Creative-Works/backend-manager');
+    return await installPkg('file:/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager');
   }
+
+  // Install live BEM
   if ((self.options.i || self.options.install) && (self.options.live || self.options.prod || self.options.production)) {
     await uninstallPkg('backend-manager');
     return await installPkg('backend-manager');
   }
+
+  // Serve firebase
   if (self.options.serve) {
     if (!self.options.quick && !self.options.q) {
     }
@@ -121,30 +132,36 @@ Main.prototype.process = async function (args) {
     });
   }
 
+  // Get indexes
   if (self.options['firestore:indexes:get'] || self.options['firestore:indexes'] || self.options['indexes:get']) {
     return await cmd_indexesGet(self, undefined, true);
   }
 
+  // Get config
   if (self.options['functions:config:get'] || self.options['config:get']) {
     return await cmd_configGet(self);
   }
 
+  // Set config
   if (self.options['functions:config:set'] || self.options['config:set']) {
     await cmd_configSet(self);
     return await cmd_configGet(self);
   }
 
+  // Unset config
   if (self.options['functions:config:unset'] || self.options['config:unset'] || self.options['config:delete'] || self.options['config:remove']) {
     await cmd_configUnset(self);
     return await cmd_configGet(self);
   }
 
+  // Get rules
   if (self.options['rules:default'] || self.options['rules:getdefault']) {
     self.getRulesFile();
     console.log(self.default.firestoreRulesWhole.match(bem_allRulesDefaultRegex)[0].replace('    ///', '///'));
     return;
   }
 
+  // Deploy
   if (self.options.deploy) {
     await self.setup();
 
@@ -166,8 +183,9 @@ Main.prototype.process = async function (args) {
       console.error(chalk.red(`${cleanOutput(data)}`));
       // ls = null;
     });
-
   }
+
+  // Test
   if (self.options['test']) {
     await self.setup();
     // firebase emulators:exec --only firestore 'npm test'
@@ -182,6 +200,7 @@ Main.prototype.process = async function (args) {
     });
   }
 
+  // Clean
   if (self.options['clean:npm']) {
     // await self.setup();
     // firebase emulators:exec --only firestore 'npm test'

package/src/manager/functions/core/actions/api/admin/create-post.js

@@ -100,8 +100,6 @@ Module.prototype.main = function () {
       // Insert ads
       const articleWithAds = insertAds(formattedContent, 3, 1500);
 
-
-
       // Log
       assistant.log(`main(): articleWithAds`, articleWithAds);
 

package/src/manager/functions/core/actions/api/test/run-hook.js

@@ -28,7 +28,7 @@ Module.prototype.main = function () {
     try {
       hook = (new (require(pathify(`${Manager.cwd}/${payload.data.payload.path}.js`)))());
     } catch (e) {
-      hook = (new (require(pathify(`${Manager.cwd}/methods/hooks/${payload.data.payload.path}.js`)))());
+      hook = (new (require(pathify(`${Manager.cwd}/routes/hooks/${payload.data.payload.path}.js`)))());
     }
 
     // Run the hook

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

@@ -326,7 +326,7 @@ function resolveBasePath(basePath, command) {
 };
 
 function resolveApiPath(command) {
-  const projectBasePath = path.join(process.cwd(), 'methods/api');
+  const projectBasePath = path.join(process.cwd(), 'routes/api');
   const localBasePath = './api/';
 
   const projectPath = resolveBasePath(projectBasePath, command);

package/src/manager/helpers/assistant.js

@@ -140,17 +140,19 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.request.path = (self.ref.req.path || '');
   self.request.user = self.resolveAccount({authenticated: false});
 
+  // Set body and query
   if (options.accept === 'json') {
     self.request.body = tryParse(self.ref.req.body || '{}');
     self.request.query = tryParse(self.ref.req.query || '{}');
   }
 
-  self.request.headers = (self.ref.req.headers || {});
-  self.request.data = Object.assign(
-    {},
-    _.cloneDeep(self.request.body || {}),
-    _.cloneDeep(self.request.query || {})
-  );
+  // Set headers
+  self.request.headers = self.ref.req.headers || {};
+
+  // Merge data
+  self.request.data = _.merge({}, self.request.body, self.request.query);
+
+  // Set multipart data
   self.request.multipartData = {
     fields: {},
     files: {},
@@ -385,6 +387,11 @@ BackendAssistant.prototype.errorify = function (e, options) {
       sendable = `${sendable} (${newError.tag})`;
     }
 
+    // Log
+    if (options.log) {
+      self.log(`Sending response (${options.code}):`, JSON.stringify(sendable));
+    }
+
     // Send response
     res
       .status(options.code)
@@ -463,7 +470,11 @@ BackendAssistant.prototype.respond = function(response, options) {
   _log(`Sending response`);
 
   // If it is an object, send as json
-  if (response && typeof response === 'object') {
+  if (
+    response
+    && typeof response === 'object'
+    && typeof res.json === 'function'
+  ) {
     return res.json(response);
   } else {
     return res.send(response);

package/src/manager/helpers/middleware.js

@@ -39,15 +39,21 @@ Middleware.prototype.run = function (libPath, options) {
     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' ? `${process.cwd()}/routes` : options.routesDir;
+    options.schemasDir = typeof options.schemasDir === 'undefined' ? `${process.cwd()}/schemas` : options.schemasDir;
+
     // Log
     assistant.log(`Middleware.process(): Request (${geolocation.ip} @ ${geolocation.country}, ${geolocation.region}, ${geolocation.city})`, JSON.stringify(data));
 
-    const basePath = path.resolve(process.cwd(), `methods/${libPath.replace('.js', '')}`);
-    let library;
+    // Set paths
+    const routesDir = path.resolve(options.routesDir, libPath.replace('.js', ''));
+    const schemasDir = path.resolve(options.schemasDir);
 
     // Load library
+    let library;
     try {
-      libPath = path.resolve(basePath, `index.js`);
+      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});
@@ -85,7 +91,8 @@ Middleware.prototype.run = function (libPath, options) {
 
       // Resolve settings
       try {
-        assistant.settings = Manager.Settings().resolve(assistant, options.schema, data);
+        // 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});
       }

package/src/manager/helpers/settings.js

@@ -16,25 +16,29 @@ function Settings(m) {
   self.settings = null;
 }
 
-Settings.prototype.resolve = function (assistant, schema, settings) {
+Settings.prototype.resolve = function (assistant, schema, settings, options) {
   const self = this;
   const Manager = self.Manager;
 
   // Set settings
-  schema = schema;
-  settings = typeof settings === 'undefined' ? {} : settings;
+  schema = schema || undefined;
+  settings = settings || {};
 
-  // Throw error if there is no schema
-  if (typeof schema === 'undefined') {
-    throw assistant.errorify(`Schema is undefined`, {code: 500});
-  }
-
-  // Reset settings
-  self.settings = null;
-
-  // Load schema
-  if (typeof schema === 'string') {
-    const schemaPath = path.resolve(process.cwd(), `schemas/${schema.replace('.js', '')}.js`);
+  // Set options
+  options = options || {};
+  options.dir = typeof options.dir === 'undefined' ? `${process.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);
   }

package/src/manager/helpers/usage.js

@@ -120,10 +120,12 @@ Usage.prototype.init = function (assistant, options) {
     // Get app data
     self.app = self.storage.get(`${self.paths.app}.data`, {}).value();
 
+    // Check for app data
     if (!self.app) {
       return reject(new Error('Usage.init(): No app data found'));
     }
 
+    // Log
     self.log(`Usage.init(): Got app data`, self.app);
     self.log(`Usage.init(): Got user`, self.user);
 
@@ -135,26 +137,43 @@ Usage.prototype.init = function (assistant, options) {
   });
 };
 
-Usage.prototype.validate = function (path, options) {
+Usage.prototype.validate = function (name, options) {
   const self = this;
 
   return new Promise(async function(resolve, reject) {
     const Manager = self.Manager;
     const assistant = self.assistant;
 
+    // Set options
     options = options || {};
     options.useCaptchaResponse = typeof options.useCaptchaResponse === 'undefined' ? true : options.useCaptchaResponse;
+    options.log = typeof options.log === 'undefined' ? true : options.log;
+    options.throw = typeof options.throw === 'undefined' ? false : options.throw;
 
     // Check for required options
-    const period = self.getUsage(path);
-    const allowed = self.getLimit(path);
+    const period = self.getUsage(name);
+    const allowed = self.getLimit(name);
 
-    // Log
-    self.log(`Usage.validate(): Checking ${period}/${allowed} for ${path}...`);
+    // Log (independent of options.log because this is important)
+    if (options.log) {
+      assistant.log(`Usage.validate(): Checking ${period}/${allowed} for ${name}...`);
+    }
+
+    // Reject function
+    function _reject() {
+      reject(
+        assistant.errorify(`You have exceeded your ${name} usage limit of ${period}/${allowed}.`, {code: 429})
+      );
+    }
+
+    // Dev mode throw
+    if (options.throw) {
+      return _reject();
+    }
 
     // If they are under the limit, resolve
     if (period < allowed) {
-      self.log(`Usage.validate(): Valid for ${path}`);
+      self.log(`Usage.validate(): Valid for ${name}`);
 
       return resolve(true);
     }
@@ -177,25 +196,28 @@ Usage.prototype.validate = function (path, options) {
     }
 
     // Otherwise, they are over the limit, reject
-    return reject(
-      assistant.errorify(`You have exceeded your ${path} usage limit of ${period}/${allowed}.`, {code: 429})
-    );
+    return _reject();
   });
 };
 
-Usage.prototype.increment = function (path, value, options) {
+Usage.prototype.increment = function (name, value, options) {
   const self = this;
   const Manager = self.Manager;
   const assistant = self.assistant;
 
+  // Set name
+  name = name || 'requests';
+
+  // Set value
   value = typeof value === 'undefined' ? 1 : value;
 
+  // Set options
   options = options || {};
   options.id = options.id || null;
 
   // Update total and period
   ['total', 'period', 'last'].forEach((key) => {
-    const resolved = `usage.${path}.${key}`;
+    const resolved = `usage.${name}.${key}`;
     const existing = _.get(self.user, resolved, 0);
 
     if (key === 'last') {
@@ -214,51 +236,58 @@ Usage.prototype.increment = function (path, value, options) {
   });
 
   // Log the updated user
-  self.log(`Usage.init(): Incremented ${path} for user`, self.user);
+  self.log(`Usage.init(): Incremented ${name} for user`, self.user);
 
   return self;
 };
 
-Usage.prototype.set = function (path, value) {
+Usage.prototype.set = function (name, value) {
   const self = this;
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  // Update total and period
-  const resolved = `usage.${path}.period`;
+  // Set name
+  name = name || 'requests';
 
+  // Set value
   value = typeof value === 'undefined' ? 0 : value;
 
+  // Update total and period
+  const resolved = `usage.${name}.period`;
+
   // Set the value
   _.set(self.user, resolved, value);
 
   // Log the updated user
-  self.log(`Usage.init(): Set ${path} for user`, self.user);
+  self.log(`Usage.init(): Set ${name} for user`, self.user);
 
   return self;
 };
 
-Usage.prototype.getUsage = function (path) {
+Usage.prototype.getUsage = function (name) {
   const self = this;
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  if (path) {
-    return _.get(self.user, `usage.${path}.period`, 0);
+  // Get usage
+  if (name) {
+    return _.get(self.user, `usage.${name}.period`, 0);
   } else {
     return self.user.usage;
   }
 };
 
-Usage.prototype.getLimit = function (path) {
+Usage.prototype.getLimit = function (name) {
   const self = this;
   const Manager = self.Manager;
   const assistant = self.assistant;
 
+  // Get key
   const key = `products.${self.options.app}-${self.user.plan.id}.limits`;
 
-  if (path) {
-    return _.get(self.app, `${key}.${path}`, 0);
+  // Get limit
+  if (name) {
+    return _.get(self.app, `${key}.${name}`, 0);
   } else {
     return _.get(self.app, key, {});
   }

package/src/manager/index.js

@@ -3,6 +3,9 @@ const path = require('path');
 const { get, merge } = require('lodash');
 const jetpack = require('fs-jetpack');
 const JSON5 = require('json5');
+const EventEmitter = require('events');
+// const EventEmitter = require('events').EventEmitter;
+const util = require('util');
 
 // const { debug, log, error, warn } = require('firebase-functions/lib/logger');
 // let User;
@@ -13,6 +16,7 @@ const wrappers = './functions/wrappers';
 
 function Manager(exporter, options) {
   const self = this;
+
   // Constants
   self.SERVER_UUID = '11111111-1111-1111-1111-111111111111';
 
@@ -24,11 +28,15 @@ function Manager(exporter, options) {
     storage: {},
   };
 
-  // self.isDevelopment = false;
+  // Setup EventEmitter
+  EventEmitter.call(self);
 
   return self;
 }
 
+// Inherit from EventEmitter
+util.inherits(Manager, EventEmitter);
+
 Manager.prototype.init = function (exporter, options) {
   const self = this;
 
@@ -36,6 +44,9 @@ Manager.prototype.init = function (exporter, options) {
   options = options || {};
   options.initialize = typeof options.initialize === 'undefined' ? true : options.initialize;
   options.log = typeof options.log === 'undefined' ? false : options.log;
+  options.projectType = typeof options.projectType === 'undefined' ? 'firebase' : options.projectType; // firebase, custom
+  options.routes = typeof options.routes === 'undefined' ? '/routes' : options.routes;
+  options.schemas = typeof options.schemas === 'undefined' ? '/schemas' : options.schemas;
   options.setupFunctions = typeof options.setupFunctions === 'undefined' ? true : options.setupFunctions;
   options.setupFunctionsLegacy = typeof options.setupFunctionsLegacy === 'undefined' ? false : options.setupFunctionsLegacy;
   options.setupFunctionsIdentity = typeof options.setupFunctionsIdentity === 'undefined' ? true : options.setupFunctionsIdentity;
@@ -71,6 +82,7 @@ Manager.prototype.init = function (exporter, options) {
   // Set properties
   self.cwd = process.cwd();
 
+  // Set options
   self.options = options;
   self.project = options.firebaseConfig || JSON.parse(process.env.FIREBASE_CONFIG || '{}');
   self.project.resourceZone = options.resourceZone;
@@ -206,222 +218,14 @@ Manager.prototype.init = function (exporter, options) {
     // admin.firestore().settings({/* your settings... */ timestampsInSnapshots: true})
   }
 
-  // Main functions
-  if (options.setupFunctions) {
-    exporter.bm_api =
-    self.libraries.functions
-    .runWith({memory: '256MB', timeoutSeconds: 60})
-    // TODO: Replace this with new API
-    .https.onRequest(async (req, res) => self._process((new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, })));
-
-    if (options.setupFunctionsLegacy) {
-      exporter.bm_signUpHandler =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/actions/sign-up-handler.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      // Admin
-      exporter.bm_createPost =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/admin/create-post.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_firestoreWrite =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/admin/firestore-write.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_getStats =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 420})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/admin/get-stats.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_sendNotification =
-      self.libraries.functions
-      .runWith({memory: '1GB', timeoutSeconds: 420})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/admin/send-notification.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_query =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/admin/query.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_createPostHandler =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/actions/create-post-handler.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_generateUuid =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${core}/actions/generate-uuid.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      // Test
-      exporter.bm_test_authenticate =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${test}/authenticate.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_test_createTestAccounts =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${test}/create-test-accounts.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-
-      exporter.bm_test_webhook =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .https.onRequest(async (req, res) => {
-        const Module = require(`${test}/webhook.js`);
-        Module.init(self, { req: req, res: res, });
-
-        return self._preProcess(Module)
-        .then(r => Module.main())
-        .catch(e => {
-          self.assistant.error(e);
-          return res.status(500).send(e.message);
-        });
-      });
-    }
-
-    // Events
-    if (options.setupFunctionsIdentity) {
-      exporter.bm_authBeforeCreate =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .auth.user()
-      .beforeCreate(async (user, context) => self._process((new (require(`${core}/events/auth/before-create.js`))()).init(self, { user: user, context: context})));
-
-      exporter.bm_authBeforeSignIn =
-      self.libraries.functions
-      .runWith({memory: '256MB', timeoutSeconds: 60})
-      .auth.user()
-      .beforeSignIn(async (user, context) => self._process((new (require(`${core}/events/auth/before-signin.js`))()).init(self, { user: user, context: context})));
-    }
-
-    exporter.bm_authOnCreate =
-    self.libraries.functions
-    .runWith({memory: '256MB', timeoutSeconds: 60})
-    .auth.user()
-    .onCreate(async (user, context) => self._process((new (require(`${core}/events/auth/on-create.js`))()).init(self, { user: user, context: context})));
-
-    exporter.bm_authOnDelete =
-    self.libraries.functions
-    .runWith({memory: '256MB', timeoutSeconds: 60})
-    .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 =
-    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, })));
+  // Setup main functions
+  if (options.projectType === 'firebase' && options.setupFunctions) {
+    self.setupFunctions(exporter, options);
+  }
 
-    // Cron
-    exporter.bm_cronDaily =
-    self.libraries.functions
-    .runWith({ memory: '256MB', timeoutSeconds: 120 })
-    .pubsub.schedule('every 24 hours')
-    .onRun(async (context) => self._process((new (require(`${core}/cron/daily.js`))()).init(self, { context: context, })));
+  // Setup custom server
+  if (options.projectType === 'custom') {
+    self.setupCustomServer(exporter, options);
   }
 
   // Set dotenv
@@ -799,6 +603,380 @@ Manager.prototype.debug = function () {
   }
 }
 
+// Setup functions
+Manager.prototype.setupFunctions = function (exporter, options) {
+  const self = this;
+
+  // Log
+  if (options.log) {
+    self.assistant.log('Setting up Firebase functions...');
+  }
+
+  // Setup functions
+  exporter.bm_api =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  // TODO: Replace this with new API
+  .https.onRequest(async (req, res) => self._process((new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, })));
+
+  // Setup legacy functions
+  if (options.setupFunctionsLegacy) {
+    exporter.bm_signUpHandler =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/sign-up-handler.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    // Admin
+    exporter.bm_createPost =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/create-post.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_firestoreWrite =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/firestore-write.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_getStats =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 420})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/get-stats.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_sendNotification =
+    self.libraries.functions
+    .runWith({memory: '1GB', timeoutSeconds: 420})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/send-notification.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_query =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/admin/query.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_createPostHandler =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/create-post-handler.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_generateUuid =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${core}/actions/generate-uuid.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    // Test
+    exporter.bm_test_authenticate =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/authenticate.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_test_createTestAccounts =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/create-test-accounts.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+
+    exporter.bm_test_webhook =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .https.onRequest(async (req, res) => {
+      const Module = require(`${test}/webhook.js`);
+      Module.init(self, { req: req, res: res, });
+
+      return self._preProcess(Module)
+      .then(r => Module.main())
+      .catch(e => {
+        self.assistant.error(e);
+        return res.status(500).send(e.message);
+      });
+    });
+  }
+
+  // Setup identity functions
+  if (options.setupFunctionsIdentity) {
+    exporter.bm_authBeforeCreate =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .auth.user()
+    .beforeCreate(async (user, context) => self._process((new (require(`${core}/events/auth/before-create.js`))()).init(self, { user: user, context: context})));
+
+    exporter.bm_authBeforeSignIn =
+    self.libraries.functions
+    .runWith({memory: '256MB', timeoutSeconds: 60})
+    .auth.user()
+    .beforeSignIn(async (user, context) => self._process((new (require(`${core}/events/auth/before-signin.js`))()).init(self, { user: user, context: context})));
+  }
+
+  // Setup events
+  exporter.bm_authOnCreate =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .auth.user()
+  .onCreate(async (user, context) => self._process((new (require(`${core}/events/auth/on-create.js`))()).init(self, { user: user, context: context})));
+
+  exporter.bm_authOnDelete =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .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 =
+  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, })));
+
+  // Setup cron jobs
+  exporter.bm_cronDaily =
+  self.libraries.functions
+  .runWith({ memory: '256MB', timeoutSeconds: 120 })
+  .pubsub.schedule('every 24 hours')
+  .onRun(async (context) => self._process((new (require(`${core}/cron/daily.js`))()).init(self, { context: context, })));
+};
+
+// Setup Custom Server
+Manager.prototype.setupCustomServer = function (_library, options) {
+  const self = this;
+
+  // Require
+  const glob = require('glob').globSync;
+
+  // Log
+  if (options.log) {
+    self.assistant.log('Setting up custom server...');
+  }
+
+  // Setup fastify
+  // const app = library({
+  //   logger: true,
+  //   // querystringParser: str => querystring.parse(str.toLowerCase())
+  // });
+
+  //
+  const app = require('express')({
+    logger: true,
+    // querystringParser: str => querystring.parse(str.toLowerCase())
+  });
+
+  // Setup body parser
+  app.use(require('body-parser').json());
+
+  // Designate paths
+  const managerRoutesPath = path.normalize(`${__dirname}/routes`);
+  const managerSchemasPath = path.normalize(`${__dirname}/schemas`);
+  const customRoutesPath = path.normalize(`${self.cwd}${options.routes}`);
+  const customSchemasPath = path.normalize(`${self.cwd}${options.schemas}`);
+
+  // Create routes
+  const routes = [];
+
+  // Push function
+  function _push(dir, isManager) {
+    // Get all files
+    glob('**/index.js', { cwd: dir })
+    .forEach((file) => {
+      // Build the item
+      const item = {
+        name: file.replace('/index.js', ''),
+        namespace: file,
+        path: path.resolve(dir, file),
+        dir: dir,
+        isManager: isManager,
+      }
+
+      // If it exists in routes, replace it
+      const existing = routes.findIndex(r => r.name === item.name);
+      if (existing > -1) {
+        routes[existing] = item;
+        return;
+      }
+
+      // Otherwise, push it
+      routes.push(item);
+    });
+  }
+
+  // Push routes
+  // _push(`${__dirname}/routes`)
+  _push(managerRoutesPath, true)
+  _push(customRoutesPath, false)
+
+  // Log routes
+  // if (options.log) {
+  //   self.assistant.log('Routes:', routes);
+  // }
+
+  // Install process
+  routes.forEach((file) => {
+    // console.log('---file', file);
+    // Require the file
+    const cors = self.libraries.cors;
+
+    // Log
+    if (options.log) {
+      self.assistant.log(`Initializing route: ${file.name} @ ${file.path}`);
+    }
+
+    // Register the route
+    app.all(`/${file.name}`, async (req, res) => {
+      return cors(req, res, async () => {
+        // self.Middleware(req, res).run(file.name, {schema: file.name})
+        self.Middleware(req, res).run(file.name, {
+          schema: file.name,
+          routesDir: file.isManager ? managerRoutesPath : customRoutesPath,
+          schemasDir: file.isManager ? managerSchemasPath : customSchemasPath,
+        })
+      });
+    })
+
+    // app.all(`/${name}`, async (req, res) => {
+    //   return cors(req, res, async () => {
+    //     // Fix req/res
+    //     req.body = req.body || {};
+    //     req.query = Object.assign({}, req.query || {});
+
+    //     // Manager.Middleware(req, res).run('tools/screenshot', {schema: 'screenshot'})
+    //     const handler = new (require(file.path))();
+    //     const assistant = self.Assistant({req: req, res: res}, {functionName: name, functionType: 'http'});
+    //     // const apiUser = await ApiManager.getUser(assistant);
+
+    //     // Set handler properties
+    //     handler.Manager = self;
+    //     handler.assistant = assistant;
+    //     handler.apiUser = null;
+
+    //     // Log
+    //     if (options.log) {
+    //       self.assistant.log(`[Request] ${name} @ ${filepath}`, req.body, req.query);
+    //     }
+
+    //     // Execute the route
+    //     try {
+    //       await handler.process(req, res);
+    //     } catch (e) {
+    //       assistant.respond(e, {code: e.code});
+    //     }
+    //   });
+    // })
+  });
+
+  // Run the server!
+  const server = app.listen({ port: process.env.PORT || 3000, host: '0.0.0.0' }, () => {
+    const address = server.address();
+
+    // Check if there's an error
+    if (server.address() === null) {
+      self.assistant.error(e);
+      process.exit(1);
+    }
+
+    // Log
+    if (options.log) {
+      self.assistant.log(`Server listening on ${address.address}:${address.port}`);
+    }
+
+    // Emit event
+    self.emit('online', new Event('online'), server, app);
+  });
+}
+
 function resolveProjectPackage() {
   try {
     return require(path.resolve(process.cwd(), 'functions', 'package.json'));

package/src/manager/routes/restart/index.js

@@ -0,0 +1,52 @@
+function Route() {
+  const self = this;
+
+  return self;
+}
+
+Route.prototype.process = async function (assistant) {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = assistant.Manager;
+  const usage = assistant.usage;
+  const user = assistant.usage.user;
+  const analytics = assistant.analytics;
+  const settings = assistant.settings;
+
+  // Load preloaded libraries
+  const jetpack = require('fs-jetpack');
+
+  // Send analytics event
+  analytics.event({
+    name: 'restart',
+    params: {},
+  });
+
+  // Check for user authentication
+  // if (!user.roles.admin) {
+  //   return assistant.respond(`Admin required`, {code: 401});;
+  // }
+
+  // Log
+  assistant.log('Restarting...');
+
+  // Remove node_modules
+  jetpack.remove('node_modules');
+
+  // Perform delayed refresh to allow a successful response
+  setTimeout(function () {
+    require('child_process').exec('refresh', (error, stdout, stderr) => {
+      // Quit the process if there is an error
+      if (error || stderr) {
+        console.log(`error: ${error ? error.message : stderr}`);
+        return process.exit(1);
+      }
+    });
+  }, 1000);
+
+  // Return success
+  assistant.respond({success: true});
+};
+
+module.exports = Route;

package/src/manager/routes/test/index.js

@@ -0,0 +1,43 @@
+function Route() {
+  const self = this;
+
+  return self;
+}
+
+Route.prototype.main = async function (assistant) {
+  const self = this;
+
+  // Set shortcuts
+  const Manager = assistant.Manager;
+  const usage = assistant.usage;
+  const user = assistant.usage.user;
+  const analytics = assistant.analytics;
+  const settings = assistant.settings;
+
+  // Load preloaded libraries
+  // ..
+
+  // Send analytics event
+  analytics.event({
+    name: 'test',
+    params: {},
+  });
+
+  // Check for user authentication
+  // if (!user.roles.admin) {
+  //   return assistant.respond(`Admin required`, {code: 401});;
+  // }
+
+  // Log
+  assistant.log('Running test');
+  assistant.log('assistant.request.body', assistant.request.body);
+  assistant.log('assistant.request.query', assistant.request.query);
+  assistant.log('assistant.request.headers', assistant.request.headers);
+  assistant.log('assistant.request.data', assistant.request.data);
+  assistant.log('assistant.settings', assistant.settings);
+
+  // Return success
+  assistant.respond({timestamp: new Date().toISOString(), id: assistant.id});
+};
+
+module.exports = Route;

package/src/manager/schemas/restart.js

@@ -0,0 +1,13 @@
+module.exports = function (assistant) {
+  return {
+    // DEFAULTS
+    ['defaults']: {
+      // Common
+      delay: {
+        types: ['number'],
+        default: 1000,
+        value: undefined,
+      },
+    },
+  };
+}

package/src/manager/schemas/test.js

@@ -0,0 +1,13 @@
+module.exports = function (assistant) {
+  return {
+    // DEFAULTS
+    ['defaults']: {
+      // Common
+      delay: {
+        types: ['number'],
+        default: 1000,
+        value: undefined,
+      },
+    },
+  };
+}