backend-manager 2.0.26 → 2.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "2.0.26",
+  "version": "2.0.29",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -37,7 +37,7 @@
     "cors": "^2.8.5",
     "dotenv": "^16.0.0",
     "firebase-admin": "^9.12.0",
-    "firebase-functions": "^3.20.1",
+    "firebase-functions": "^3.21.0",
     "fs-jetpack": "^4.3.1",
     "hcaptcha": "^0.1.1",
     "inquirer": "^8.2.4",
@@ -47,9 +47,9 @@
     "mocha": "^9.2.2",
     "moment": "^2.29.3",
     "node-fetch": "^2.6.7",
-    "node-powertools": "^0.0.10",
+    "node-powertools": "^0.0.13",
     "npm-api": "^1.0.1",
-    "paypal-server-api": "^0.0.5",
+    "paypal-server-api": "^0.0.6",
     "pushid": "^1.0.0",
     "semver": "^7.3.7",
     "shortid": "^2.2.16",

package/src/cli/cli.js

@@ -6,7 +6,7 @@
 // https://github.com/sitepoint-editors/ginit
 
 let exec = require('child_process').exec;
-const fs = require('fs-jetpack');
+const jetpack = require('fs-jetpack');
 const path = require('path');
 const chalk = require('chalk');
 const _ = require('lodash');
@@ -49,65 +49,65 @@ let bem_fsRulesBackupRegex = /({{\s*?backend-manager\s*?}})/sgm;
 let MOCHA_PKG_SCRIPT = 'mocha ../test/ --recursive --timeout=10000';
 let NPM_CLEAN_SCRIPT = 'rm -fr node_modules && rm -fr package-lock.json && npm cache clean --force && npm install && npm rb';
 let NOFIX_TEXT = chalk.red(`There is no automatic fix for this check.`);
-let runtimeconfigTemplate = JSON.parse((fs.read(path.resolve(`${__dirname}/../../templates/runtimeconfig.json`))) || '{}');
-let bemConfigTemplate = JSON.parse((fs.read(path.resolve(`${__dirname}/../../templates/backend-manager-config.json`))) || '{}');
-let CLI_CONFIG = JSON5.parse((fs.read(path.resolve(`${__dirname}/config.json`))) || '{}');
+let runtimeconfigTemplate = JSON.parse((jetpack.read(path.resolve(`${__dirname}/../../templates/runtimeconfig.json`))) || '{}');
+let bemConfigTemplate = JSON.parse((jetpack.read(path.resolve(`${__dirname}/../../templates/backend-manager-config.json`))) || '{}');
+let CLI_CONFIG = JSON5.parse((jetpack.read(path.resolve(`${__dirname}/config.json`))) || '{}');
 
 function Main() {
 }
 
 Main.prototype.process = async function (args) {
-  let self = this;
-  this.options = {};
-  this.argv = argv;
-  this.firebaseProjectPath = process.cwd();
-  this.firebaseProjectPath = this.firebaseProjectPath.match(/\/functions$/) ? this.firebaseProjectPath.replace(/\/functions$/, '') : this.firebaseProjectPath;
-  this.testCount = 0;
-  this.testTotal = 0;
-  this.default = {};
-  this.packageJSON = require('../../package.json');
-  this.default.version = this.packageJSON.version;
+  const self = this;
+  self.options = {};
+  self.argv = argv;
+  self.firebaseProjectPath = process.cwd();
+  self.firebaseProjectPath = self.firebaseProjectPath.match(/\/functions$/) ? self.firebaseProjectPath.replace(/\/functions$/, '') : self.firebaseProjectPath;
+  self.testCount = 0;
+  self.testTotal = 0;
+  self.default = {};
+  self.packageJSON = require('../../package.json');
+  self.default.version = self.packageJSON.version;
 
   for (var i = 0; i < args.length; i++) {
-    this.options[args[i]] = true;
+    self.options[args[i]] = true;
   }
   // console.log(args);
   // console.log(options);
-  if (this.options.v || this.options.version || this.options['-v'] || this.options['-version']) {
-    console.log(`Backend manager is version: ${this.default.version}`);
+  if (self.options.v || self.options.version || self.options['-v'] || self.options['-version']) {
+    console.log(`Backend manager is version: ${self.default.version}`);
   }
 
   // https://gist.github.com/timneutkens/f2933558b8739bbf09104fb27c5c9664
-  if (this.options.clear) {
+  if (self.options.clear) {
     process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
     console.clear();
     process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
   }
-  if (this.options.cwd) {
-    console.log('cwd: ', this.firebaseProjectPath);
+  if (self.options.cwd) {
+    console.log('cwd: ', self.firebaseProjectPath);
   }
-  if (this.options.setup) {
+  if (self.options.setup) {
     await cmd_configGet(self).catch(e => log(chalk.red(`Failed to run config:get`)));
     await self.setup();
   }
-  if ((this.options.i || this.options.install) && (this.options.local || this.options.dev || this.options.development)) {
+  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');
     // await uninstallPkg('backend-assistant');
     // return await installPkg('file:../../backend-assistant');
   }
-  if ((this.options.i || this.options.install) && (this.options.live || this.options.prod || this.options.production)) {
+  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');
     // return await installPkg('backend-assistant');
   }
-  if (this.options.serve) {
-    if (!this.options.quick && !this.options.q) {
+  if (self.options.serve) {
+    if (!self.options.quick && !self.options.q) {
     }
     await cmd_configGet(self);
     await self.setup();
 
-    let port = this.argv.port || _.get(self.argv, '_', [])[1] || '5000';
+    let port = self.argv.port || _.get(self.argv, '_', [])[1] || '5000';
     let ls = spawn(`firebase serve --port ${port}`, {shell: true});
 
     ls.stdout.on('data', (data) => {
@@ -118,27 +118,32 @@ Main.prototype.process = async function (args) {
       // ls = null;
     });
   }
-  if (this.options['config:get']) {
+
+  if (self.options['firestore:indexes:get'] || self.options['firestore:indexes'] || self.options['indexes:get']) {
+    return await cmd_indexesGet(self, undefined, true);
+  }
+
+  if (self.options['functions:config:get'] || self.options['config:get']) {
     return await cmd_configGet(self);
   }
 
-  if (this.options['config:set']) {
+  if (self.options['functions:config:set'] || self.options['config:set']) {
     await cmd_configSet(self);
     return await cmd_configGet(self);
   }
 
-  if (this.options['config:unset'] || this.options['config:delete'] || this.options['config:remove']) {
+  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);
   }
 
-  if (this.options['rules:default'] || this.options['rules:getdefault']) {
+  if (self.options['rules:default'] || self.options['rules:getdefault']) {
     self.getRulesFile();
     console.log(self.default.firestoreRulesWhole.match(bem_fsRulesDefaultRegex)[0].replace('    ///', '///'));
     return;
   }
 
-  if (this.options.deploy) {
+  if (self.options.deploy) {
     await self.setup();
 
     // Quick check that not using local packages
@@ -161,7 +166,7 @@ Main.prototype.process = async function (args) {
     });
 
   }
-  if (this.options['test']) {
+  if (self.options['test']) {
     await self.setup();
     // firebase emulators:exec --only firestore 'npm test'
     // let ls = spawn('firebase', ['emulators:exec', '--only', 'firestore', 'npm test']);
@@ -175,7 +180,7 @@ Main.prototype.process = async function (args) {
     });
   }
 
-  if (this.options['clean:npm']) {
+  if (self.options['clean:npm']) {
     // await self.setup();
     // firebase emulators:exec --only firestore 'npm test'
     let ls = spawn(`${NPM_CLEAN_SCRIPT}`, {shell: true});
@@ -187,10 +192,10 @@ Main.prototype.process = async function (args) {
     });
   }
 
-  // if (this.options['url']) {
+  // if (self.options['url']) {
   //   // await self.setup();
   //   // firebase emulators:exec --only firestore 'npm test'
-  //   log(this.projectUrl)
+  //   log(self.projectUrl)
   // }
 
 };
@@ -199,68 +204,73 @@ module.exports = Main;
 
 
 Main.prototype.getRulesFile = function () {
-  let self = this;
-  this.default.firestoreRulesWhole = (fs.read(path.resolve(`${__dirname}/../../templates/firestore.rules`))).replace('=0.0.0-', `-${self.default.version}-`);
-  this.default.firestoreRulesCore = this.default.firestoreRulesWhole.match(bem_fsRulesRegex)[0];
+  const self = this;
+  self.default.firestoreRulesWhole = (jetpack.read(path.resolve(`${__dirname}/../../templates/firestore.rules`))).replace('=0.0.0-', `-${self.default.version}-`);
+  self.default.firestoreRulesCore = self.default.firestoreRulesWhole.match(bem_fsRulesRegex)[0];
 
 };
 
 Main.prototype.setup = async function () {
-  let self = this;
-  let cwd = fs.cwd();
-  log(chalk.green(`\n---- RUNNING v${this.default.version} SETUP ----`));
-  this.package = fs.read(`${this.firebaseProjectPath}/functions/package.json`) || '{}';
-  this.firebaseJSON = fs.read(`${this.firebaseProjectPath}/firebase.json`) || '{}';
-  this.firebaseRC = fs.read(`${this.firebaseProjectPath}/.firebaserc`) || '{}';
-  this.runtimeConfigJSON = fs.read(`${this.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}';
-  this.projectPackage = fs.read(`${this.firebaseProjectPath}/package.json`) || '{}';
-  this.gitignore = fs.read(`${this.firebaseProjectPath}/functions/.gitignore`) || '';
-  if (!this.package) {
+  const self = this;
+  let cwd = jetpack.cwd();
+  log(chalk.green(`\n---- RUNNING SETUP v${self.default.version} ----`));
+  self.package = jetpack.read(`${self.firebaseProjectPath}/functions/package.json`) || '{}';
+  self.firebaseJSON = jetpack.read(`${self.firebaseProjectPath}/firebase.json`) || '{}';
+  self.firebaseRC = jetpack.read(`${self.firebaseProjectPath}/.firebaserc`) || '{}';
+  self.runtimeConfigJSON = jetpack.read(`${self.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}';
+  self.remoteconfigJSON = jetpack.read(`${self.firebaseProjectPath}/remoteconfig.template.json`) || '{}';
+  self.projectPackage = jetpack.read(`${self.firebaseProjectPath}/package.json`) || '{}';
+
+  self.gitignore = jetpack.read(`${self.firebaseProjectPath}/functions/.gitignore`) || '';
+  if (!self.package) {
     log(chalk.red(`Missing functions/package.json :(`));
     return;
   }
   // console.log('cwd', cwd, cwd.endsWith('functions'));
   if (!cwd.endsWith('functions') && !cwd.endsWith('functions/')) {
-    log(chalk.red(`Please run ${chalk.bold('bm setup')} from the ${chalk.bold('functions')} folder. Run ${chalk.bold('cd functions')}.`));
+    log(chalk.red(`Please run ${chalk.bold('npx bm setup')} from the ${chalk.bold('functions')} folder. Run ${chalk.bold('cd functions')}.`));
     return;
   }
 
-  this.package = JSON.parse(this.package);
-  this.firebaseJSON = JSON.parse(this.firebaseJSON);
-  this.firebaseRC = JSON.parse(this.firebaseRC);
-  this.runtimeConfigJSON = JSON.parse(this.runtimeConfigJSON);
-  this.projectPackage = JSON.parse(this.projectPackage);
+  self.package = JSON.parse(self.package);
+  self.firebaseJSON = JSON.parse(self.firebaseJSON);
+  self.firebaseRC = JSON.parse(self.firebaseRC);
+  self.runtimeConfigJSON = JSON.parse(self.runtimeConfigJSON);
+  self.remoteconfigJSON = JSON.parse(self.remoteconfigJSON);
+  self.projectPackage = JSON.parse(self.projectPackage);
+
+  self.remoteconfigJSONExists = Object.keys(self.remoteconfigJSON).length > 0;
 
   self.getRulesFile();
 
-  this.default.firestoreRulesVersionRegex = new RegExp(`///---version-${self.default.version}---///`)
-  // bem_giRegex = new RegExp(fs.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)).replace(/\./g, '\\.'), 'm' )
-  bem_giRegex = new RegExp(fs.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)), 'm' )
+  self.default.firestoreRulesVersionRegex = new RegExp(`///---version-${self.default.version}---///`)
+  // bem_giRegex = new RegExp(jetpack.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)).replace(/\./g, '\\.'), 'm' )
+  bem_giRegex = new RegExp(jetpack.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)), 'm' )
 
   // tests
-  this.projectName = this.firebaseRC.projects.default;
-  this.projectUrl = `https://console.firebase.google.com/project/${this.projectName}`;
-  log(chalk.black(`Id: `, chalk.bold(`${this.projectName}`)));
-  log(chalk.black(`Url:`, chalk.bold(`${this.projectUrl}`)));
+  self.projectName = self.firebaseRC.projects.default;
+  self.projectUrl = `https://console.firebase.google.com/project/${self.projectName}`;
+  log(chalk.black(`Id: `, chalk.bold(`${self.projectName}`)));
+  log(chalk.black(`Url:`, chalk.bold(`${self.projectUrl}`)));
 
   if (!self.package || !self.package.engines || !self.package.engines.node) {
     throw new Error('Missing <engines.node> in package.json')
   }
 
-  await this.test('is a firebase project', async function () {
-    let exists = fs.exists(`${self.firebaseProjectPath}/firebase.json`);
+  await self.test('is a firebase project', async function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/firebase.json`);
     return exists;
   }, fix_isFirebase);
 
-  await this.test('.nvmrc file has proper version', async function () {
+  await self.test('.nvmrc file has proper version', async function () {
     // return !!self.package.dependencies && !!self.package.devDependencies;
-    // let gitignore = fs.read(path.resolve(`${__dirname}/../../templates/gitignore.md`));
-    let nvmrc = fs.read(`${self.firebaseProjectPath}/functions/.nvmrc`) || '';
+    // let gitignore = jetpack.read(path.resolve(`${__dirname}/../../templates/gitignore.md`));
+    let nvmrc = jetpack.read(`${self.firebaseProjectPath}/functions/.nvmrc`) || '';
     return nvmrc === `v${CLI_CONFIG.node}/*`
 
   }, fix_nvmrc);
 
-  await this.test(`using node ${CLI_CONFIG.node}`, function () {
+  await self.test(`using node ${CLI_CONFIG.node}`, function () {
     let processMajor = parseInt(process.versions.node.split('.')[0]);
     let engineMajor = parseInt(self.package.engines.node.split('.')[0]);
     if (processMajor < engineMajor) {
@@ -269,19 +279,19 @@ Main.prototype.setup = async function () {
     return self.package.engines.node.toString() === CLI_CONFIG.node && processMajor >= engineMajor;
   }, fix_nodeVersion);
 
-  // await this.test('project level package.json exists', async function () {
+  // await self.test('project level package.json exists', async function () {
   //   return !!(self.projectPackage && self.projectPackage.version && self.projectPackage.name);
   // }, fix_projpackage);
 
-  await this.test('functions level package.json exists', async function () {
+  await self.test('functions level package.json exists', async function () {
     return !!self.package && !!self.package.dependencies && !!self.package.devDependencies && !!self.package.version;
   }, fix_functionspackage);
 
-  // await this.test('functions level package.json has updated version', async function () {
+  // await self.test('functions level package.json has updated version', async function () {
   //   return self.package.version === self.projectPackage.version;
   // }, fix_packageversion);
 
-  await this.test('using updated firebase-admin', async function () {
+  await self.test('using updated firebase-admin', async function () {
     let pkg = 'firebase-admin';
     // let latest = semver.clean(await getPkgVersion(pkg));
     let latest = semver.clean(cleanPackageVersion(self.packageJSON.dependencies['firebase-admin']));
@@ -297,7 +307,7 @@ Main.prototype.setup = async function () {
     return !(semver.gt(latest, mine)) || majorVersionMismatch;
   }, fix_fba);
 
-  await this.test('using updated firebase-functions', async function () {
+  await self.test('using updated firebase-functions', async function () {
     let pkg = 'firebase-functions';
     // let latest = semver.clean(await getPkgVersion(pkg));
     let latest = semver.clean(cleanPackageVersion(self.packageJSON.dependencies['firebase-functions']));
@@ -313,7 +323,7 @@ Main.prototype.setup = async function () {
     return !(semver.gt(latest, mine)) || majorVersionMismatch;
   }, fix_fbf);
 
-  await this.test('using updated backend-manager', async function () {
+  await self.test('using updated backend-manager', async function () {
     let pkg = 'backend-manager';
     let latest = semver.clean(await getPkgVersion(pkg));
     let mine = cleanPackageVersion(self.package.dependencies[pkg] || '0.0.0');
@@ -333,36 +343,36 @@ Main.prototype.setup = async function () {
     bemPackageVersionWarning(pkg, bemv, latest);
   }());
 
-  // await this.test('using updated backend-assistant', async function () {
+  // await self.test('using updated backend-assistant', async function () {
   //   let pkg = 'backend-assistant';
   //   let latest = semver.clean(await getPkgVersion(pkg));
   //   let mine = (self.package.dependencies[pkg] || '0.0.0').replace('^', '').replace('~', '');
   //   return isLocal(mine) || !(semver.gt(latest, mine));
   // }, fix_bea);
 
-  // await this.test('using updated ultimate-jekyll-poster', async function () {
+  // await self.test('using updated ultimate-jekyll-poster', async function () {
   //   let pkg = 'ultimate-jekyll-poster';
   //   let latest = semver.clean(await getPkgVersion(pkg));
   //   let mine = (self.package.dependencies[pkg] || '0.0.0').replace('^', '').replace('~', '');
   //   return isLocal(mine) || !(semver.gt(latest, mine));
   // }, fix_ujp);
 
-  // await this.test('using updated @firebase/testing', async function () {
+  // await self.test('using updated @firebase/testing', async function () {
   //   let pkg = '@firebase/testing';
   //   let latest = semver.clean(await getPkgVersion(pkg));
   //   let mine = (self.package.devDependencies[pkg] || '0.0.0').replace('^', '').replace('~', '');
   //   return isLocal(mine) || !(semver.gt(latest, mine));
   // }, fix_fbTesting);
 
-  // await this.test('using updated mocha', async function () {
+  // await self.test('using updated mocha', async function () {
   //   let pkg = 'mocha';
   //   let latest = semver.clean(await getPkgVersion(pkg));
   //   let mine = (self.package.devDependencies[pkg] || '0.0.0').replace('^', '').replace('~', '');
   //   return isLocal(mine) || !(semver.gt(latest, mine));
   // }, fix_mocha);
 
-  await this.test('using proper .runtimeconfig', async function () {
-    let runtimeconfig = JSON.parse(fs.read(`${self.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}');
+  await self.test('using proper .runtimeconfig', async function () {
+    let runtimeconfig = JSON.parse(jetpack.read(`${self.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}');
     let ogPaths = getObjectPaths(runtimeconfigTemplate).split('\n');
     let pass = true;
     for (var i = 0, l = ogPaths.length; i < l; i++) {
@@ -377,8 +387,8 @@ Main.prototype.setup = async function () {
 
   }, fix_runtimeConfig);
 
-  await this.test('using proper backend-manager-config.json', async function () {
-    let bemConfig = JSON.parse(fs.read(`${self.firebaseProjectPath}/functions/backend-manager-config.json`) || '{}');
+  await self.test('using proper backend-manager-config.json', async function () {
+    let bemConfig = JSON.parse(jetpack.read(`${self.firebaseProjectPath}/functions/backend-manager-config.json`) || '{}');
     let ogPaths = getObjectPaths(bemConfigTemplate).split('\n');
     let pass = true;
     for (var i = 0, l = ogPaths.length; i < l; i++) {
@@ -393,76 +403,133 @@ Main.prototype.setup = async function () {
 
   }, fix_bemConfig);
 
-  await this.test('has service-account.json', function () {
-    let exists = fs.exists(`${self.firebaseProjectPath}/functions/service-account.json`);
+  await self.test('has service-account.json', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/functions/service-account.json`);
     return !!exists;
   }, fix_serviceAccount);
 
-  await this.test('has correct .gitignore', function () {
+  await self.test('has correct .gitignore', function () {
     let match = self.gitignore.match(bem_giRegexOuter);
     if (!match) {
       return false;
     } else {
-      let gitignore = fs.read(path.resolve(`${__dirname}/../../templates/gitignore.md`));
+      let gitignore = jetpack.read(path.resolve(`${__dirname}/../../templates/gitignore.md`));
       let file = gitignore.match(bem_giRegexOuter) ? RegExp.$1 : 'BAD1';
       let file2 = match[0].match(bem_giRegexOuter) ? RegExp.$1 : 'BAD2';
       return file === file2;
     }
   }, fix_gitignore);
 
-  await this.test('firestore rules in JSON', function () {
-    let firestore = _.get(self.firebaseJSON, 'firestore', {});
+
+  // Check firebase.json fields
+  await self.test('firestore rules in JSON', function () {
+    const firestore = _.get(self.firebaseJSON, 'firestore', {});
     return (firestore.rules === 'firestore.rules')
   }, fix_firestoreRules);
 
-  await this.test('realtime rules in JSON', function () {
-    let firestore = _.get(self.firebaseJSON, 'database', {});
-    return (firestore.rules === 'security.rules.json')
+  await self.test('firestore indexes in JSON', function () {
+    let firestore = _.get(self.firebaseJSON, 'firestore', {});
+    return (firestore.indexes === 'firestore.indexes.json')
+  }, fix_firestoreIndexes);
+
+  await self.test('realtime rules in JSON', function () {
+    const database = _.get(self.firebaseJSON, 'database', {});
+    return (database.rules === 'database.rules.json')
   }, fix_realtimeRules);
 
-  await this.test('hosting is set to dedicated folder in JSON', function () {
+  await self.test('storage rules in JSON', function () {
+    const storage = _.get(self.firebaseJSON, 'storage', {});
+    return (storage.rules === 'storage.rules')
+  }, fix_storageRules);
+
+  await self.test('remoteconfig template in JSON', function () {
+    const remoteconfig = _.get(self.firebaseJSON, 'remoteconfig', {});
+
+    if (self.remoteconfigJSONExists) {
+      return (remoteconfig.template === 'remoteconfig.template.json')
+    } else {
+      return (remoteconfig.template === '')
+    }
+  }, fix_remoteconfigTemplate);
+
+  await self.test('firestore indexes synced', async function () {
+    const tempPath = '_firestore.indexes.json'
+    const liveIndexes = await cmd_indexesGet(self, tempPath, false);
+
+    const localIndexes_exists = jetpack.exists(`${self.firebaseProjectPath}/firestore.indexes.json`);
+    let localIndexes
+    if (localIndexes_exists) {
+      localIndexes = require(`${self.firebaseProjectPath}/firestore.indexes.json`)
+    }
+    const equal = _.isEqual(liveIndexes, localIndexes);
+
+    if (localIndexes_exists && !equal) {
+      console.log(chalk.red(`To fix this...`));
+      console.log(chalk.red(`  - ${chalk.bold('npx bm indexes:get')} to overwrite Firestore's local indexes with the live indexes`));
+      console.log(chalk.red('  OR'));
+      console.log(chalk.red(`  - ${chalk.bold('firebase deploy --only firestore:indexes')} to replace the live indexes.`));
+    }
+
+    jetpack.remove(`${self.firebaseProjectPath}/${tempPath}`)
+
+    return !localIndexes_exists || equal
+  }, NOFIX);
+
+
+  // Update actual files
+  await self.test('update firestore rules file', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/firestore.rules`);
+    let contents = jetpack.read(`${self.firebaseProjectPath}/firestore.rules`) || '';
+    let containsCore = contents.match(bem_fsRulesRegex);
+    let matchesVersion = contents.match(self.default.firestoreRulesVersionRegex);
+
+    return (!!exists && !!containsCore && !!matchesVersion);
+  }, fix_firestoreRulesFile);
+
+  await self.test('update firestore indexes file', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/firestore.indexes.json`);
+    return (!!exists);
+  }, fix_firestoreIndexesFile);
+
+  await self.test('update realtime rules file', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/database.rules.json`);
+    return (!!exists);
+  }, fix_realtimeRulesFile);
+
+  await self.test('update storage rules file', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/storage.rules`);
+    return (!!exists);
+  }, fix_storageRulesFile);
+
+  await self.test('update remoteconfig template file', function () {
+    let exists = jetpack.exists(`${self.firebaseProjectPath}/remoteconfig.template.json`);
+    return (!!exists);
+  }, fix_remoteconfigTemplateFile);
+
+  // Hosting
+  await self.test('hosting is set to dedicated folder in JSON', function () {
     let hosting = _.get(self.firebaseJSON, 'hosting', {});
     return (hosting.public && (hosting.public === 'public' || hosting.public !== '.'))
   }, fix_firebaseHosting);
 
-  await this.test('update backend-manager-tests.js', function () {
-    fs.write(`${self.firebaseProjectPath}/test/backend-manager-tests.js`,
-      (fs.read(path.resolve(`${__dirname}/../../templates/backend-manager-tests.js`)))
+  await self.test('update backend-manager-tests.js', function () {
+    jetpack.write(`${self.firebaseProjectPath}/test/backend-manager-tests.js`,
+      (jetpack.read(path.resolve(`${__dirname}/../../templates/backend-manager-tests.js`)))
     )
     return true;
   }, NOFIX);
 
-  // await this.test('has mocha package.json script', function () {
+  // await self.test('has mocha package.json script', function () {
   //   let script = _.get(self.package, 'scripts.test', '')
   //   return script === MOCHA_PKG_SCRIPT;
   // }, fix_mochaScript);
 
-  // await this.test('has clean:npm package.json script', function () {
+  // await self.test('has clean:npm package.json script', function () {
   //   let script = _.get(self.package, 'scripts.clean:npm', '')
   //   return script === NPM_CLEAN_SCRIPT;
   // }, fix_cleanNpmScript);
 
-  await this.test('ignore firestore indexes file', function () {
-    let firestore = _.get(self.firebaseJSON, 'firestore', {});
-    return (firestore.indexes === '')
-  }, fix_firebaseIndexes);
 
-  await this.test('update firestore rules file', function () {
-    let exists = fs.exists(`${self.firebaseProjectPath}/firestore.rules`);
-    let contents = fs.read(`${self.firebaseProjectPath}/firestore.rules`) || '';
-    let containsCore = contents.match(bem_fsRulesRegex);
-    let matchesVersion = contents.match(self.default.firestoreRulesVersionRegex);
-
-    // console.log('exists', !!exists);
-    // console.log('containsCore', !!containsCore);
-    // console.log('matchesVersion', !!matchesVersion);
-    return (!!exists && !!containsCore && !!matchesVersion);
-  }, fix_firestoreRulesFile);
-
-  await this.test('update realtime rules file', function () {
-    let exists = fs.exists(`${self.firebaseProjectPath}/security.rules.json`);
-    return (!!exists);
-  }, fix_realtimeRulesFile);
 
 
   if (self.package.dependencies['backend-manager'].includes('file:')) {
@@ -472,8 +539,8 @@ Main.prototype.setup = async function () {
   }
 
 
-  const prepareStatsURL = `https://us-central1-${_.get(this.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_api?authenticationToken=${_.get(this.runtimeConfigJSON, 'backend_manager.key')}`;
-  // const prepareStatsURL = `https://us-central1-${_.get(this.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_api?authenticationToken=undefined`;
+  const prepareStatsURL = `https://us-central1-${_.get(self.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_api?authenticationToken=${_.get(self.runtimeConfigJSON, 'backend_manager.key')}`;
+  // const prepareStatsURL = `https://us-central1-${_.get(self.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_api?authenticationToken=undefined`;
   const statsFetchResult = await fetch(prepareStatsURL, {
     method: 'post',
     body: JSON.stringify({
@@ -512,18 +579,11 @@ Main.prototype.setup = async function () {
 
   console.log(chalk.green(`Checks finished. Passed ${self.testCount}/${self.testTotal} tests.`));
   if (self.testCount !== self.testTotal) {
-    console.log(chalk.yellow(`You should continue to run ${chalk.bold('bm setup')} until you pass all tests and fix all errors.`));
+    console.log(chalk.yellow(`You should continue to run ${chalk.bold('npx bm setup')} until you pass all tests and fix all errors.`));
   }
 
   return;
 
-  // await this.test('deleted firestore indexes', function () {
-  //   let indexes = fs.exists(`${self.firebaseProjectPath}/firestore.indexes.json`);
-  //   return (!indexes);
-  // }, fix_fsindexes);
-
-  // console.log(self.package);
-
 };
 
 // https://stackoverflow.com/questions/41802259/javascript-deep-check-objects-have-same-keys
@@ -550,7 +610,7 @@ function getObjectPaths(object, parent) {
 }
 
 Main.prototype.test = async function(name, fn, fix, args) {
-  let self = this;
+  const self = this;
   let status;
   let passed = await fn();
   return new Promise(async function(resolve, reject) {
@@ -600,9 +660,9 @@ function bemPackageVersionWarning(package, current, latest) {
 async function fix_runtimeConfig(self) {
   return new Promise(function(resolve, reject) {
     log(NOFIX_TEXT);
-    log(chalk.red(`You need to run ${chalk.bold(`bm config:set`)} for each of these keys:`));
+    log(chalk.red(`You need to run ${chalk.bold(`npx bm config:set`)} for each of these keys:`));
     let objectKeys = getObjectPaths(runtimeconfigTemplate).split('\n');
-    let theirConfig = JSON.parse(fs.read(`${self.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}');
+    let theirConfig = JSON.parse(jetpack.read(`${self.firebaseProjectPath}/functions/.runtimeconfig.json`) || '{}');
     for (var i = 0, l = objectKeys.length; i < l; i++) {
       let item = objectKeys[i];
       if (!item) {return}
@@ -614,7 +674,7 @@ async function fix_runtimeConfig(self) {
       }
     }
     // console.log('objectKeys', objectKeys);
-    // log(chalk.red(`You need to run ${chalk.bold(`bm config:set`)} for each of these keys: \n${getObjectPaths(runtimeconfigTemplate)}`));
+    // log(chalk.red(`You need to run ${chalk.bold(`npx bm config:set`)} for each of these keys: \n${getObjectPaths(runtimeconfigTemplate)}`));
     reject();
   });
 };
@@ -624,9 +684,9 @@ async function fix_bemConfig(self) {
     log(NOFIX_TEXT);
     log(chalk.red(`You need to open backend-manager-config.json and set each of these keys:`));
     let objectKeys = getObjectPaths(bemConfigTemplate).split('\n');
-    let theirConfig = JSON.parse(fs.read(`${self.firebaseProjectPath}/functions/backend-manager-config.json`) || '{}');
+    let theirConfig = JSON.parse(jetpack.read(`${self.firebaseProjectPath}/functions/backend-manager-config.json`) || '{}');
     if (Object.keys(theirConfig).length < 1) {
-      fs.write(`${self.firebaseProjectPath}/functions/backend-manager-config.json`, bemConfigTemplate)
+      jetpack.write(`${self.firebaseProjectPath}/functions/backend-manager-config.json`, bemConfigTemplate)
     }
     for (var i = 0, l = objectKeys.length; i < l; i++) {
       let item = objectKeys[i];
@@ -655,7 +715,7 @@ async function fix_serviceAccount(self) {
 // function fix_mochaScript(self) {
 //   return new Promise(function(resolve, reject) {
 //     _.set(self.package, 'scripts.test', MOCHA_PKG_SCRIPT);
-//     fs.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
+//     jetpack.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
 //     resolve();
 //   });
 // }
@@ -664,7 +724,7 @@ function fix_nodeVersion(self) {
   return new Promise(function(resolve, reject) {
     _.set(self.package, 'engines.node', CLI_CONFIG.node)
 
-    fs.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
+    jetpack.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
     resolve();
   });
 };
@@ -672,7 +732,7 @@ function fix_nodeVersion(self) {
 function fix_nvmrc(self) {
   return new Promise(function(resolve, reject) {
 
-    fs.write(`${self.firebaseProjectPath}/functions/.nvmrc`, `v${CLI_CONFIG.node}/*`);
+    jetpack.write(`${self.firebaseProjectPath}/functions/.nvmrc`, `v${CLI_CONFIG.node}/*`);
     resolve();
   });
 };
@@ -691,7 +751,7 @@ function fix_projpackage(self) {
     self.projectPackage.dependencies = self.projectPackage.dependencies || {};
     self.projectPackage.devDependencies = self.projectPackage.devDependencies || {};
 
-    fs.write(`${self.firebaseProjectPath}/package.json`, JSON.stringify(self.projectPackage, null, 2) );
+    jetpack.write(`${self.firebaseProjectPath}/package.json`, JSON.stringify(self.projectPackage, null, 2) );
     resolve();
   });
 };
@@ -702,7 +762,7 @@ function fix_functionspackage(self) {
     self.package.devDependencies = self.package.devDependencies || {};
     self.package.version = self.package.version || '0.0.1';
 
-    fs.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
+    jetpack.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
     resolve();
   });
 };
@@ -711,7 +771,7 @@ function fix_packageversion(self) {
   return new Promise(function(resolve, reject) {
     self.package.version = self.projectPackage.version;
 
-    fs.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
+    jetpack.write(`${self.firebaseProjectPath}/functions/package.json`, JSON.stringify(self.package, null, 2) );
     resolve();
   });
 };
@@ -725,7 +785,12 @@ async function fix_fba(self) {
   return await installPkg('firebase-admin', `@${self.packageJSON.dependencies['firebase-admin']}`)
 };
 async function fix_bem(self) {
-  return await installPkg('backend-manager')
+  await installPkg('backend-manager');
+
+  console.log(chalk.green(`Process has exited since a new version of backend-manager was installed. Run ${chalk.bold('npx bm setup')} again.`));
+  process.exit(0);
+
+  return;
 };
 // async function fix_bea(self) {
 //   return await installPkg('backend-assistant')
@@ -742,7 +807,7 @@ async function fix_bem(self) {
 
 function fix_gitignore(self) {
   return new Promise(function(resolve, reject) {
-    let gi = (fs.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)));
+    let gi = (jetpack.read(path.resolve(`${__dirname}/../../templates/gitignore.md`)));
     if (self.gitignore.match(bem_giRegexOuter)) {
       self.gitignore = self.gitignore.replace(bem_giRegexOuter, gi);
     } else {
@@ -751,7 +816,7 @@ function fix_gitignore(self) {
     self.gitignore = self.gitignore.replace(/\n\s*\n$/mg, '\n')
     // self.gitignore = `${self.gitignore}\n${gi}`.replace(/$\n/m,'');
     // self.gitignore = self.gitignore.replace(/$\n/m,'');
-    fs.write(`${self.firebaseProjectPath}/functions/.gitignore`, self.gitignore);
+    jetpack.write(`${self.firebaseProjectPath}/functions/.gitignore`, self.gitignore);
     resolve();
   });
 };
@@ -759,31 +824,39 @@ function fix_gitignore(self) {
 function fix_firestoreRules(self) {
   return new Promise(function(resolve, reject) {
     _.set(self.firebaseJSON, 'firestore.rules', 'firestore.rules')
-    fs.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
+    resolve();
+  });
+};
+
+function fix_firestoreIndexes(self) {
+  return new Promise(function(resolve, reject) {
+    _.set(self.firebaseJSON, 'firestore.indexes', 'firestore.indexes.json')
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
     resolve();
   });
 };
 
 function fix_realtimeRules(self) {
   return new Promise(function(resolve, reject) {
-    _.set(self.firebaseJSON, 'database.rules', 'security.rules.json')
-    fs.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
+    _.set(self.firebaseJSON, 'database.rules', 'database.rules.json')
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
     resolve();
   });
 };
 
-function fix_firebaseHosting(self) {
+function fix_storageRules(self) {
   return new Promise(function(resolve, reject) {
-    _.set(self.firebaseJSON, 'hosting.public', 'public')
-    fs.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
+    _.set(self.firebaseJSON, 'storage.rules', 'storage.rules')
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
     resolve();
   });
 };
 
-function fix_firebaseIndexes(self) {
+function fix_remoteconfigTemplate(self) {
   return new Promise(function(resolve, reject) {
-    _.set(self.firebaseJSON, 'firestore.indexes', "")
-    fs.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
+    _.set(self.firebaseJSON, 'remoteconfig.template', self.remoteconfigJSONExists ? 'remoteconfig.template.json' : '')
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
     resolve();
   });
 };
@@ -791,13 +864,13 @@ function fix_firebaseIndexes(self) {
 function fix_firestoreRulesFile(self) {
   return new Promise(function(resolve, reject) {
     let path = `${self.firebaseProjectPath}/firestore.rules`;
-    let exists = fs.exists(path);
-    let contents = fs.read(path) || '';
+    let exists = jetpack.exists(path);
+    let contents = jetpack.read(path) || '';
 
     if (!exists || !contents) {
       log(chalk.yellow(`Writing new firestore.rules file...`));
-      fs.write(path, self.default.firestoreRulesWhole)
-      contents = fs.read(path) || '';
+      jetpack.write(path, self.default.firestoreRulesWhole)
+      contents = jetpack.read(path) || '';
     }
 
     let hasTemplate = contents.match(bem_fsRulesRegex) || contents.match(bem_fsRulesBackupRegex);
@@ -812,32 +885,85 @@ function fix_firestoreRulesFile(self) {
       // console.log('replace wih', self.default.firestoreRulesCore);
       contents = contents.replace(bem_fsRulesBackupRegex, self.default.firestoreRulesCore)
       contents = contents.replace(bem_fsRulesRegex, self.default.firestoreRulesCore)
-      fs.write(path, contents)
+      jetpack.write(path, contents)
       log(chalk.yellow(`Writing core rules to firestore.rules file...`));
     }
     resolve();
   });
 };
 
+function fix_firestoreIndexesFile(self) {
+  return new Promise(async function(resolve, reject) {
+    const name = 'firestore.indexes.json';
+    let filePath = `${self.firebaseProjectPath}/${name}`;
+    let exists = jetpack.exists(filePath);
+
+    if (!exists) {
+      log(chalk.yellow(`Writing new ${name} file...`));
+      await cmd_indexesGet(self, name, false);
+    }
+
+    resolve();
+  });
+};
+
 function fix_realtimeRulesFile(self) {
   return new Promise(function(resolve, reject) {
-    let filePath = `${self.firebaseProjectPath}/security.rules.json`;
-    let exists = fs.exists(filePath);
-    let contents = fs.read(filePath) || '';
+    const name = 'database.rules.json';
+    let filePath = `${self.firebaseProjectPath}/${name}`;
+    let exists = jetpack.exists(filePath);
+    let contents = jetpack.read(filePath) || '';
 
     if (!exists) {
-      log(chalk.yellow(`Writing new security.rules.json file...`));
-      fs.write(filePath, fs.read(path.resolve(`${__dirname}/../../templates/security.rules.json`)))
-      contents = fs.read(filePath) || '';
+      log(chalk.yellow(`Writing new ${name} file...`));
+      jetpack.write(filePath, jetpack.read(path.resolve(`${__dirname}/../../templates/${name}`)))
+      contents = jetpack.read(filePath) || '';
     }
 
     resolve();
   });
 };
 
-function fix_fsindexes(self) {
+function fix_storageRulesFile(self) {
   return new Promise(function(resolve, reject) {
-    fs.remove(`${self.firebaseProjectPath}/firestore.indexes.json`)
+    const name = 'storage.rules';
+    let filePath = `${self.firebaseProjectPath}/${name}`;
+    let exists = jetpack.exists(filePath);
+    let contents = jetpack.read(filePath) || '';
+
+    if (!exists) {
+      log(chalk.yellow(`Writing new ${name} file...`));
+      jetpack.write(filePath, jetpack.read(path.resolve(`${__dirname}/../../templates/${name}`)))
+      contents = jetpack.read(filePath) || '';
+    }
+
+    resolve();
+  });
+};
+
+function fix_remoteconfigTemplateFile(self) {
+  return new Promise(function(resolve, reject) {
+    const name = 'remoteconfig.template.json'
+    let filePath = `${self.firebaseProjectPath}/${name}`;
+    let exists = jetpack.exists(filePath);
+    let contents = jetpack.read(filePath) || '';
+
+    if (!exists) {
+      log(chalk.yellow(`Writing new ${name} file...`));
+      jetpack.write(filePath, jetpack.read(path.resolve(`${__dirname}/../../templates/${name}`)))
+      contents = jetpack.read(filePath) || '';
+    }
+
+    resolve();
+  });
+};
+
+
+// Hosting
+function fix_firebaseHosting(self) {
+  return new Promise(function(resolve, reject) {
+    _.set(self.firebaseJSON, 'hosting.public', 'public')
+    jetpack.write(`${self.firebaseProjectPath}/firebase.json`, JSON.stringify(self.firebaseJSON, null, 2));
     resolve();
   });
 };
@@ -855,130 +981,165 @@ function getPkgVersion(package) {
   });
 }
 
-
-
-  async function cmd_configGet(self) {
-    return new Promise(function(resolve, reject) {
-      let cmd = exec(`firebase functions:config:get > ${self.firebaseProjectPath}/functions/.runtimeconfig.json`, function (error, stdout, stderr) {
-        if (error) {
+async function cmd_indexesGet(self, filePath, log) {
+  return new Promise(function(resolve, reject) {
+    const finalPath = `${self.firebaseProjectPath}/${filePath || 'firestore.indexes.json'}`;
+    let existingIndexes;
+    try {
+      existingIndexes = require(`${self.firebaseProjectPath}/firestore.indexes.json`)
+    } catch (e) {
+      if (log !== false) {
+        console.error('Failed to read existing local indexes', e);
+      }
+    }
+    let cmd = exec(`firebase firestore:indexes > ${finalPath}`, function (error, stdout, stderr) {
+      if (error) {
+        if (log !== false) {
           console.error(error);
-          reject(error);
-        } else {
-          console.log(chalk.green(`Saving config to: ${self.firebaseProjectPath}/functions/.runtimeconfig.json`));
+        }
+        reject(error);
+      } else {
+        const newIndexes = require(finalPath);
+        if (log !== false) {
+          console.log(chalk.green(`Saving indexes to: ${finalPath}`));
           console.log(stdout);
-          resolve();
+
+          const equal = (_.isEqual(newIndexes, existingIndexes));
+
+          if (!equal) {
+            console.log(chalk.red(`The live and local index files did not match and have been overwritten by the ${chalk.bold('live indexes')}`));
+          }
+
         }
-      });
+        resolve(newIndexes);
+      }
     });
-  }
+  });
+}
 
-  async function cmd_configSet(self, newPath, newValue) {
-    return new Promise(async function(resolve, reject) {
-      // console.log(this.options);
-      // console.log(this.argv);
-      newPath = newPath || await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'path',
-          default: 'service.key'
-        }
-      ]).then(answers => answers.path)
+async function cmd_configGet(self, filePath) {
+  return new Promise(function(resolve, reject) {
+    const finalPath = `${self.firebaseProjectPath}/${filePath || 'functions/.runtimeconfig.json'}`;
+    let cmd = exec(`firebase functions:config:get > ${finalPath}`, function (error, stdout, stderr) {
+      if (error) {
+        console.error(error);
+        reject(error);
+      } else {
+        console.log(chalk.green(`Saving config to: ${finalPath}`));
+        console.log(stdout);
+        resolve(require(finalPath));
+      }
+    });
+  });
+}
+
+async function cmd_configSet(self, newPath, newValue) {
+  return new Promise(async function(resolve, reject) {
+    // console.log(self.options);
+    // console.log(self.argv);
+    newPath = newPath || await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'path',
+        default: 'service.key'
+      }
+    ]).then(answers => answers.path)
 
+    try {
+      const object = JSON5.parse(newPath)
       try {
-        const object = JSON5.parse(newPath)
-        try {
-          if (typeof object === 'object') {
-            const keyify = (obj, prefix = '') =>
-              Object.keys(obj).reduce((res, el) => {
-                if( Array.isArray(obj[el]) ) {
-                  return res;
-                } else if( typeof obj[el] === 'object' && obj[el] !== null ) {
-                  return [...res, ...keyify(obj[el], prefix + el + '.')];
-                }
-                return [...res, prefix + el];
-              }, []);
-            const pathArray = keyify(object);
-            for (var i = 0; i < pathArray.length; i++) {
-              const pathName = pathArray[i];
-              const pathValue = _.get(object, pathName);
-              // console.log(chalk.blue(`Setting object: ${chalk.bold(pathName)} = ${chalk.bold(pathValue)}`));
-              console.log(chalk.blue(`Setting object: ${chalk.bold(pathName)}`));
-              await cmd_configSet(self, pathName, pathValue)
-              .catch(e => {
-                log(chalk.red(`Failed to save object path: ${e}`));
-              })
-            }
-            return resolve();
+        if (typeof object === 'object') {
+          const keyify = (obj, prefix = '') =>
+            Object.keys(obj).reduce((res, el) => {
+              if( Array.isArray(obj[el]) ) {
+                return res;
+              } else if( typeof obj[el] === 'object' && obj[el] !== null ) {
+                return [...res, ...keyify(obj[el], prefix + el + '.')];
+              }
+              return [...res, prefix + el];
+            }, []);
+          const pathArray = keyify(object);
+          for (var i = 0; i < pathArray.length; i++) {
+            const pathName = pathArray[i];
+            const pathValue = _.get(object, pathName);
+            // console.log(chalk.blue(`Setting object: ${chalk.bold(pathName)} = ${chalk.bold(pathValue)}`));
+            console.log(chalk.blue(`Setting object: ${chalk.bold(pathName)}`));
+            await cmd_configSet(self, pathName, pathValue)
+            .catch(e => {
+              log(chalk.red(`Failed to save object path: ${e}`));
+            })
           }
-        } catch (e) {
-          log(chalk.red(`Failed to save object: ${e}`));
-          return reject(e)
+          return resolve();
         }
       } catch (e) {
+        log(chalk.red(`Failed to save object: ${e}`));
+        return reject(e)
       }
+    } catch (e) {
+    }
 
-      newValue = newValue || await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'value',
-          default: '123-abc'
-        }
-      ]).then(answers => answers.value)
-
-      let isInvalid = false;
-      if (newPath !== newPath.toLowerCase()) {
-        isInvalid = true;
-        newPath = newPath.replace(/([A-Z])/g, '_$1').trim().toLowerCase();
+    newValue = newValue || await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'value',
+        default: '123-abc'
       }
-      log(chalk.yellow(`Saving to ${chalk.bold(newPath)}...`));
-      let cmd = exec(`firebase functions:config:set ${newPath}="${newValue}"`, function (error, stdout, stderr) {
-        if (error) {
-          log(chalk.red(`Failed to save ${chalk.bold(newPath)}: ${error}`));
-          reject(error);
+    ]).then(answers => answers.value)
+
+    let isInvalid = false;
+    if (newPath !== newPath.toLowerCase()) {
+      isInvalid = true;
+      newPath = newPath.replace(/([A-Z])/g, '_$1').trim().toLowerCase();
+    }
+    log(chalk.yellow(`Saving to ${chalk.bold(newPath)}...`));
+    let cmd = exec(`firebase functions:config:set ${newPath}="${newValue}"`, function (error, stdout, stderr) {
+      if (error) {
+        log(chalk.red(`Failed to save ${chalk.bold(newPath)}: ${error}`));
+        reject(error);
+      } else {
+        console.log(stdout);
+        if (isInvalid) {
+          log(chalk.red(`!!! Your path contained an invalid uppercase character`));
+          log(chalk.red(`!!! It was set to: ${chalk.bold(newPath)}`));
         } else {
-          console.log(stdout);
-          if (isInvalid) {
-            log(chalk.red(`!!! Your path contained an invalid uppercase character`));
-            log(chalk.red(`!!! It was set to: ${chalk.bold(newPath)}`));
-          } else {
-            log(chalk.green(`Successfully saved to ${chalk.bold(newPath)}`));
-          }
-          resolve();
+          log(chalk.green(`Successfully saved to ${chalk.bold(newPath)}`));
         }
-      });
+        resolve();
+      }
     });
-  }
+  });
+}
 
-  async function cmd_configUnset(self) {
-    return new Promise(async function(resolve, reject) {
-      // console.log(this.options);
-      // console.log(this.argv);
-      await inquirer
-        .prompt([
-          /* Pass your questions in here */
-          {
-            type: 'input',
-            name: 'path',
-            default: 'service.key'
+async function cmd_configUnset(self) {
+  return new Promise(async function(resolve, reject) {
+    // console.log(self.options);
+    // console.log(self.argv);
+    await inquirer
+      .prompt([
+        /* Pass your questions in here */
+        {
+          type: 'input',
+          name: 'path',
+          default: 'service.key'
+        }
+      ])
+      .then(answers => {
+        // Use user feedback for... whatever!!
+        // console.log('answer', answers);
+        log(chalk.yellow(`Deleting ${chalk.bold(answers.path)}...`));
+        let cmd = exec(`firebase functions:config:unset ${answers.path}`, function (error, stdout, stderr) {
+          if (error) {
+            log(chalk.red(`Failed to delete ${chalk.bold(answers.path)}: ${error}`));
+            reject(error);
+          } else {
+            console.log(stdout);
+            log(chalk.green(`Successfully deleted ${chalk.bold(answers.path)}`));
+            resolve();
           }
-        ])
-        .then(answers => {
-          // Use user feedback for... whatever!!
-          // console.log('answer', answers);
-          log(chalk.yellow(`Deleting ${chalk.bold(answers.path)}...`));
-          let cmd = exec(`firebase functions:config:unset ${answers.path}`, function (error, stdout, stderr) {
-            if (error) {
-              log(chalk.red(`Failed to delete ${chalk.bold(answers.path)}: ${error}`));
-              reject(error);
-            } else {
-              console.log(stdout);
-              log(chalk.green(`Successfully deleted ${chalk.bold(answers.path)}`));
-              resolve();
-            }
-          });
         });
-    });
-  }
+      });
+  });
+}
 
 
 // HELPER

package/src/manager/functions/core/actions/api/admin/firestore-read.js

@@ -11,7 +11,7 @@ Module.prototype.main = function () {
 
   return new Promise(async function(resolve, reject) {
 
-    if (payload.user.authenticated || payload.user.roles.admin) {
+    if (payload.user.roles.admin) {
 
       // console.log('---payload.data.payload', payload.data.payload);
 

package/src/manager/index.js

@@ -7,13 +7,15 @@ const { get, merge } = require('lodash');
 
 
 function Manager(exporter, options) {
+  const self = this;
   // Constants
-  this.SERVER_UUID = '11111111-1111-1111-1111-111111111111';
+  self.SERVER_UUID = '11111111-1111-1111-1111-111111111111';
 
   // Modable
-  this.libraries = {};
-  this.handlers = {};
-  return this;
+  self.libraries = {};
+  self.handlers = {};
+
+  return self;
 }
 
 Manager.prototype.init = function (exporter, options) {
@@ -92,7 +94,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   if (self.options.sentry) {
-    const sentryRelease = `${self.config.app.id || self.project.projectId}@${self.package.version}`;
+    const sentryRelease = `${get(self.config, 'app.id') || self.project.projectId}@${self.package.version}`;
     const sentryDSN = get(self.config, 'sentry.dsn', '');
     // console.log('Sentry', sentryRelease, sentryDSN);
 

package/templates/database.rules.json

@@ -0,0 +1,31 @@
+{
+  "rules": {
+    "gatherings": {
+      ".read": false,
+      ".write": false,
+			"online": {
+        ".read": "auth.uid != null && query.equalTo == auth.uid",
+        ".write": false,
+        ".indexOn": ["uid"],
+        "$uid": {
+          ".read": "
+          	// Allowed if user is signed in AND is the owner of the doc
+          	(auth != null && auth.uid == data.child('uid').val())
+          ",
+          ".write": "
+          	// Allowed if the user is signed in AND is the owner of the existing doc
+          	(auth != null && auth.uid == data.child('uid').val())
+          	// Allowed if the user is signed in AND is the owner of the new doc
+          	|| (auth != null && auth.uid == newData.child('uid').val())
+          	// Allowed if it's a delete
+          	|| (!newData.exists())
+						// Allowed if the existing doc has no owner
+          	|| (data.child('uid').val() == '')
+          	// Allowed if the new doc has no owner
+          	|| (newData.child('uid').val() == '')
+          ",
+      	}
+      }
+    }
+  }
+}

package/templates/firestore.indexes.json

@@ -0,0 +1,4 @@
+{
+  "indexes": [],
+  "fieldOverrides": []
+}

package/templates/storage.rules

@@ -0,0 +1,8 @@
+rules_version = '2';
+service firebase.storage {
+  match /b/{bucket}/o {
+    match /{allPaths=**} {
+      allow read, write: if request.auth!=null;
+    }
+  }
+}

package/templates/security.rules.json

@@ -1,6 +0,0 @@
-{
-  "rules": {
-    ".read": true,
-    ".write": true
-  }
-}