backend-manager 1.1.105 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "1.1.105",
+  "version": "2.0.2",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -27,38 +27,37 @@
   },
   "homepage": "https://itwcreativeworks.com",
   "dependencies": {
-    "@firebase/rules-unit-testing": "^2.0.1",
-    "@google-cloud/storage": "^5.16.0",
-    "@sendgrid/mail": "^7.6.0",
-    "@sentry/node": "^6.15.0",
-    "backend-assistant": "^0.0.57",
+    "@firebase/rules-unit-testing": "^2.0.2",
+    "@google-cloud/storage": "^5.19.2",
+    "@sendgrid/mail": "^7.6.2",
+    "@sentry/node": "^6.19.6",
+    "backend-assistant": "^0.0.58",
     "busboy": "^0.3.1",
     "chalk": "^4.1.2",
     "cors": "^2.8.5",
-    "dotenv": "^10.0.0",
+    "dotenv": "^16.0.0",
     "firebase-admin": "^9.12.0",
-    "firebase-functions": "^3.16.0",
-    "fs-jetpack": "^4.2.0",
-    "hcaptcha": "^0.1.0",
-    "inquirer": "^8.2.0",
-    "json5": "^2.2.0",
+    "firebase-functions": "^3.20.1",
+    "fs-jetpack": "^4.3.1",
+    "hcaptcha": "^0.1.1",
+    "inquirer": "^8.2.2",
+    "json5": "^2.2.1",
     "lodash": "^4.17.21",
     "mailchimp-api-v3": "^1.15.0",
-    "mocha": "^9.1.3",
-    "moment": "^2.29.1",
-    "node-fetch": "^2.6.5",
+    "mocha": "^9.2.2",
+    "moment": "^2.29.3",
+    "node-fetch": "^2.6.7",
     "node-powertools": "^0.0.10",
-    "npm": "^7.24.2",
     "npm-api": "^1.0.1",
     "paypal-server-api": "^0.0.5",
     "pushid": "^1.0.0",
-    "semver": "^7.3.5",
+    "semver": "^7.3.7",
     "shortid": "^2.2.16",
     "uid-generator": "^2.0.0",
-    "ultimate-jekyll-poster": "^0.0.9",
-    "universal-analytics": "^0.4.23",
+    "ultimate-jekyll-poster": "^0.0.10",
+    "universal-analytics": "^0.5.3",
     "uuid": "^8.3.2",
-    "yargs": "^17.2.1"
+    "yargs": "^17.4.1"
   },
   "files": [
     "bin/",

package/src/cli/cli.js

@@ -280,11 +280,15 @@ Main.prototype.setup = async function () {
     // let latest = semver.clean(await getPkgVersion(pkg));
     let latest = semver.clean(cleanPackageVersion(self.packageJSON.dependencies['firebase-admin']));
     let mine = cleanPackageVersion(self.package.dependencies[pkg] || '0.0.0');
-
+    const majorVersionMismatch = ((semver.major(latest) > semver.major(mine)));
     let bemv = cleanPackageVersion(self.packageJSON.dependencies[pkg]);
     bemPackageVersionWarning(pkg, bemv, latest);
 
-    return !(semver.gt(latest, mine));
+    if (majorVersionMismatch) {
+      console.log(chalk.red(`Version ${chalk.bold(latest)} of ${chalk.bold(pkg)} available but you must install this manually because it is a major update.`));
+    }
+
+    return !(semver.gt(latest, mine)) || majorVersionMismatch;
   }, fix_fba);
 
   await this.test('using updated firebase-functions', async function () {
@@ -292,19 +296,28 @@ Main.prototype.setup = async function () {
     // let latest = semver.clean(await getPkgVersion(pkg));
     let latest = semver.clean(cleanPackageVersion(self.packageJSON.dependencies['firebase-functions']));
     let mine = cleanPackageVersion(self.package.dependencies[pkg] || '0.0.0');
-
+    const majorVersionMismatch = ((semver.major(latest) > semver.major(mine)));
     let bemv = cleanPackageVersion(self.packageJSON.dependencies[pkg]);
     bemPackageVersionWarning(pkg, bemv, latest);
 
-    return !(semver.gt(latest, mine));
+    if (majorVersionMismatch) {
+      console.log(chalk.red(`Version ${chalk.bold(latest)} of ${chalk.bold(pkg)} available but you must install this manually because it is a major update.`));
+    }
+
+    return !(semver.gt(latest, mine)) || majorVersionMismatch;
   }, fix_fbf);
 
   await this.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');
+    const majorVersionMismatch = !isLocal(mine) && ((semver.major(latest) > semver.major(mine)));
+
+    if (majorVersionMismatch) {
+      console.log(chalk.red(`Version ${chalk.bold(latest)} of ${chalk.bold(pkg)} available but you must install this manually because it is a major update.`));
+    }
 
-    return isLocal(mine) || !(semver.gt(latest, mine));
+    return isLocal(mine) || !(semver.gt(latest, mine)) || majorVersionMismatch;
   }, fix_bem);
 
   (async function() {
@@ -453,10 +466,13 @@ Main.prototype.setup = async function () {
   }
 
 
-  const prepareStatsURL = `https://us-central1-${_.get(this.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_getStats?authenticationToken=${_.get(this.runtimeConfigJSON, 'backend_manager.key')}`;
-  // const prepareStatsURL = `https://us-central1-${_.get(this.firebaseRC, 'projects.default')}.cloudfunctions.net/bm_getStats?authenticationToken=undefined`;
+  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 statsFetchResult = await fetch(prepareStatsURL, {
     method: 'post',
+    body: JSON.stringify({
+      command: 'admin:get-stats',
+    }),
     timeout: 3000,
   })
   .then(async (res) => {
@@ -694,9 +710,11 @@ function fix_packageversion(self) {
 };
 
 async function fix_fbf(self) {
+  // console.log('----FIX FBF'); return Promise.resolve();
   return await installPkg('firebase-functions', `@${self.packageJSON.dependencies['firebase-functions']}`)
 };
 async function fix_fba(self) {
+  // console.log('----FIX FBA'); return Promise.resolve();
   return await installPkg('firebase-admin', `@${self.packageJSON.dependencies['firebase-admin']}`)
 };
 async function fix_bem(self) {

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

@@ -0,0 +1,160 @@
+const fetch = require('node-fetch');
+const Poster = require('ultimate-jekyll-poster');
+const pathApi =  require('path');
+const { get } = require('lodash');
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    const repoInfo = assistant.parseRepo(get(self.Manager.config, 'github.repo_website'));
+
+    const poster = new Poster();
+
+    // Save to disk OR commit
+    poster.onDownload = async function (meta) {
+      return new Promise(async function(resolve, reject) {
+        let finalPath = poster.removeDirDot(meta.finalPath);
+        let tempPath = (meta.tempPath);
+        await createFile(get(self.Manager.config, 'github.user'), repoInfo.user, repoInfo.name, get(self.Manager.config, 'github.key'), finalPath, await poster.readImage(tempPath))
+        .catch((e) => {
+          // console.log('---CAUGHT 1', e);
+        })
+        resolve();
+      });
+    }
+
+    const finalPost = await poster.create(payload.data);
+
+    // Save post OR commit
+    await createFile(get(self.Manager.config, 'github.user'), repoInfo.user, repoInfo.name, get(self.Manager.config, 'github.key'), poster.removeDirDot(finalPost.path), finalPost.content)
+    .catch((e) => {
+      return reject(assistant.errorManager(`Failed to post: ${e}`, {code: 500, sentry: false, send: false, log: false}).error)
+    })
+
+    return resolve({data: finalPost});
+  });
+
+};
+
+// HELPERS //
+async function createFile(user, repoUser, repoName, key, path, contents) {
+  let fileParsed = pathApi.parse(path);
+
+  let base64Data = Buffer.from(contents).toString('base64');
+  // base64Data = contents;
+  // console.log('--------base64Data', base64Data);
+  return new Promise(async (resolve, reject) => {
+    let sha;
+    try {
+
+      // let pathGet = `https://api.github.com/repos/iwiedenm/ultimate-jekyll/git/trees/template:${encodeURIComponent(path_noExt)}`;
+      let branch = (repoName === 'ultimate-jekyll') ? 'template' : 'master';
+
+      let pathGet = `https://api.github.com/repos/${repoUser}/${repoName}/git/trees/${branch}:${encodeURIComponent(pathApi.dirname(path))}`;
+      await makeRequest({
+        method: 'GET',
+        url: pathGet,
+        body: {
+        },
+        timeout: 30000,
+        json: true,
+        headers: {
+          'User-Agent': user,
+          // 'Authorization': `Basic ${user}:${key}`,
+          'Authorization': `Basic ${Buffer.from(user + ':' + key).toString('base64')}`,
+        }
+      })
+      .then(function (resp) {
+        // sha = resp.sha;
+        sha = resp.tree.find(function (element) {
+          // console.log('checiing', element.path, fileParsed.base);
+          return element.path === fileParsed.base;
+        });
+        sha = sha.sha;
+      });
+  } catch (e) {
+    sha = null;
+  }
+
+  let pathPut = `https://api.github.com/repos/${repoUser}/${repoName}/contents/${path}`;
+  let writeRequest =
+  {
+    // url: `https://api.github.com/repos/:owner/:repo/contents/:path`,
+    method: 'PUT',
+    url: pathPut,
+    body: {
+      message: `BackendManager Post: ${new Date().toISOString()}`,
+      content: base64Data,
+    },
+    timeout: 30000,
+    json: true,
+    headers: {
+      'User-Agent': user,
+      // 'Authorization': `Basic ${user}:${key}`,
+      'Authorization': `Basic ${Buffer.from(user + ':' + key).toString('base64')}`,
+    }
+  }
+  if (sha) {
+    writeRequest.body.sha = sha;
+  }
+  // console.log('--------PUT', pathPut);
+  await makeRequest(writeRequest)
+  .then((json) => {
+    if (!json || (json.message && (json.message === 'Not Found' || json.message.includes('Invalid request'))) ) {
+      return reject(new Error(json.message));
+    }
+  })
+  .catch((e) => {
+    return reject(e);
+  })
+  return resolve(true)
+  });
+}
+
+function makeRequest(options) {
+  return new Promise(function(resolve, reject) {
+    options.headers = options.headers || {};
+    options.headers['Content-Type'] = 'application/json';
+    let hasBody = Object.keys(options.body || {}).length > 0
+    fetch(options.url, {
+        method: options.method,
+        body: hasBody ? JSON.stringify(options.body) : undefined,
+        timeout: 30000,
+        headers: options.headers,
+        auth: options.auth,
+      })
+      .then(res => res.json())
+      .then(json => {
+        return resolve(json);
+      })
+      .catch(e => {
+        // console.error('e', e);
+        return reject(e);
+      })
+
+  });
+}
+
+module.exports = Module;

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

@@ -0,0 +1,172 @@
+const _ = require('lodash');
+const powertools = require('node-powertools');
+
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+    self.docs = [];
+    assistant.log('Queries', payload.data.payload.queries);
+    let queries = powertools.arrayify(payload.data.payload.queries || []);
+
+    let promises = [];
+    for (var i = 0; i < queries.length; i++) {
+      queries[i]
+      promises.push(self.runQuery(queries[i]))
+    }
+
+    await Promise.all(promises)
+      .then((r) => {
+        return resolve({data: self.docs});
+      })
+      .catch((e) => {
+        return reject(assistant.errorManager(e, {code: 500, sentry: false, send: false, log: false}).error)
+      })
+
+  });
+
+};
+
+Module.prototype.runQuery = function (query) {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+
+  query = query || {};
+  query.where = powertools.arrayify(query.where || []);
+  query.filter = powertools.arrayify(query.filter || []);
+  query.orderBy = powertools.arrayify(query.orderBy || []);
+
+  // self.assistant.log('Query', query);
+
+  return new Promise(function(resolve, reject) {
+    let collection;
+
+    if (!query.collection) {
+      return resolve([]);
+      // return reject(new Error('No collection specified.'));
+    }
+
+    collection = self.libraries.admin.firestore().collection(query.collection);
+
+    for (var i = 0; i < query.where.length; i++) {
+      let cur = query.where[i];
+      collection = collection.where(cur.field, cur.operator, cur.value);
+    }
+    for (var i = 0; i < query.orderBy.length; i++) {
+      let cur = query.orderBy[i];
+      collection = collection.orderBy(cur.field, cur.order)
+    }
+    if (query.limit) {
+      collection = collection.limit(query.limit)
+    }
+    if (query.startAt) {
+      collection = collection.startAt(query.startAt)
+    }
+    if (query.startAfter) {
+      collection = collection.startAfter(query.startAfter)
+    }
+    if (query.endAt) {
+      collection = collection.endAt(query.endAt)
+    }
+    if (query.endBefore) {
+      collection = collection.endBefore(query.endBefore)
+    }
+
+    collection
+    .get()
+    .then(function (querySnapshot) {
+      querySnapshot.forEach(function (doc) {
+
+        let exists = self.docs.find(item => {
+          return item.path === doc.ref.path
+        })
+
+        if (!exists && checkFilter(doc.data(), query.filter)) {
+          self.docs.push({
+            path: doc.ref.path,
+            data: doc.data(),
+          });
+        }
+
+      });
+
+      if (query.filterIndex) {
+        let iS = query.filterIndex[0];
+        let iF = query.filterIndex[1];
+        iF = iF > self.docs.length ? self.docs.length - 1 : iF;
+        self.docs = self.docs.slice(iS, iF);
+      }
+
+      return resolve(self.docs);
+    })
+    .catch(function (error) {
+      self.assistant.error(error, {environment: 'production'})
+      return reject(error);
+    });
+  });
+
+
+};
+
+function checkFilter(data, filter) {
+
+  // Loop through all filters
+  for (var i = 0, l = filter.length; i < l; i++) {
+    // Set up field and checks
+    let field = `${filter[i].field}`.split(' || ');
+    field = powertools.arrayify(field);
+    let matches = filter[i].matches || '';
+    let regex = powertools.regexify(matches);
+
+    // Pass/fail
+    let innerPassed = false;
+
+    // Loop through each filter's fields
+    for (var i2 = 0, l2 = field.length; i2 < l2; i2++) {
+      let fieldInner = field[i2];
+      let value = _.get(data, fieldInner, undefined);
+
+      if (typeof value === 'undefined') {
+        innerPassed = false;
+        continue;
+      } else if (typeof value === 'string') {
+        if (value.match(regex)) {
+          innerPassed = true;
+          break;
+        }
+      }
+    }
+
+    // If there was not a successful innerPassed then break (innerPassed works on OR logic)
+    if (!innerPassed) {
+      return false;
+    }
+
+  }
+  return true;
+}
+
+module.exports = Module;

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

@@ -0,0 +1,54 @@
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    if (payload.user.authenticated || payload.user.roles.admin) {
+
+      // console.log('---payload.data.payload', payload.data.payload);
+
+      payload.data.payload.path = `${payload.data.payload.path || ''}`;
+      payload.data.payload.document = payload.data.payload.document || {};
+      payload.data.payload.options = payload.data.payload.options || { merge: true };
+
+
+      if (!payload.data.payload.path) {
+        return reject(assistant.errorManager(`<path> parameter required`, {code: 400, sentry: false, send: false, log: false}).error)
+      } else {
+        await self.libraries.admin.firestore().doc(payload.data.payload.path)
+        .get()
+        .then(doc => {
+          return resolve({data: doc.data()});
+        })
+        .catch(e => {
+          return reject(assistant.errorManager(e, {code: 500, sentry: false, send: false, log: false}).error)
+        })
+      }
+
+    } else {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    }
+
+  });
+
+};
+
+
+module.exports = Module;

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

@@ -0,0 +1,47 @@
+function Module() {
+
+}
+
+Module.prototype.init = async function (s, payload) {
+  const self = this;
+  self.Manager = s.Manager;
+  self.libraries = s.Manager.libraries;
+  self.assistant = s.Manager.assistant;
+  self.payload = payload;
+
+  return self;
+};
+
+Module.prototype.main = function () {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+  const payload = self.payload;
+
+  return new Promise(async function(resolve, reject) {
+
+    payload.data.payload.path = `${payload.data.payload.path || ''}`;
+    payload.data.payload.document = payload.data.payload.document || {};
+    payload.data.payload.options = payload.data.payload.options || {};
+    payload.data.payload.options.merge = typeof payload.data.payload.options.merge === 'undefined' ? true : payload.data.payload.options.merge;
+
+    if (!payload.user.roles.admin) {
+      return reject(assistant.errorManager(`Admin required.`, {code: 401, sentry: false, send: false, log: false}).error)
+    } else if (!payload.data.payload.path) {
+      return reject(assistant.errorManager(`Path parameter required.`, {code: 400, sentry: false, send: false, log: false}).error)
+    } else {
+      await self.libraries.admin.firestore().doc(payload.data.payload.path)
+      .set(payload.data.payload.document, payload.data.payload.options)
+      .then(r => {
+        return resolve({data: {path: payload.data.payload.path}});
+      })
+      .catch(e => {
+        return reject(assistant.errorManager(e, {code: 500, sentry: false, send: false, log: false}).error)
+      })
+    }
+  });
+
+};
+
+
+module.exports = Module;