@taraai/read-write/lib/utils/query-populates.js

Synchronous NoSQL/Firestore for React

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getPopulateActions = getPopulateActions;
exports.populateList = populateList;
exports.promisesForPopulate = promisesForPopulate;

var _forEach = _interopRequireDefault(require("lodash/forEach"));

var _get = _interopRequireDefault(require("lodash/get"));

var _has = _interopRequireDefault(require("lodash/has"));

var _isObject = _interopRequireDefault(require("lodash/isObject"));

var _set = _interopRequireDefault(require("lodash/set"));

var _query = require("./query");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function populateList(firebase, originalObj, p, results) {
  if (!results[p.root]) {
    (0, _set.default)(results, p.root, {});
  }

  return Promise.all(map(originalObj, (id, childKey) => {
    const populateKey = id === true || p.populateByKey ? childKey : id;
    return (0, _query.getPopulateChild)(firebase, p, populateKey).then(pc => {
      if (pc) {
        return (0, _set.default)(results, `${p.root}.${populateKey}`, pc);
      }

      return results;
    });
  }));
}

function getPopulateObj(str) {
  if (typeof str === 'string' || str instanceof String) {
    return str;
  }

  const strArray = str.split(':');
  return {
    child: strArray[0],
    root: strArray[1]
  };
}

function getPopulateObjs(arr) {
  if (!Array.isArray(arr)) {
    return arr;
  }

  return arr.map(o => (0, _isObject.default)(o) ? o : getPopulateObj(o));
}

function promisesForPopulate(firebase, dataKey, originalData, populatesIn) {
  const promisesArray = [];
  const results = {};
  const populatesForData = getPopulateObjs(typeof populatesIn === 'function' ? populatesIn(dataKey, originalData) : populatesIn);
  const dataHasPopulateChilds = populatesForData.some(populate => (0, _has.default)(originalData, populate.child));

  if (dataHasPopulateChilds) {
    populatesForData.forEach(p => {
      const childDataVal = (0, _get.default)(originalData, p.child);

      if (typeof childDataVal === 'string' || childDataVal instanceof String) {
        return promisesArray.push((0, _query.getPopulateChild)(firebase, p, childDataVal).then(v => {
          if (v) {
            (0, _set.default)(results, `${p.storeAs ? p.storeAs : p.root}.${childDataVal}`, v);
          }
        }));
      }

      return promisesArray.push(populateList(firebase, childDataVal, p, results));
    });
  } else {
    (0, _forEach.default)(originalData, (d, key) => {
      const populatesForDataItem = getPopulateObjs(typeof populatesIn === 'function' ? populatesIn(key, d) : populatesIn);
      (0, _forEach.default)(populatesForDataItem, p => {
        const idOrList = (0, _get.default)(d, p.child);

        if (!idOrList) {
          return;
        }

        if (typeof idOrList === 'string' || idOrList instanceof String) {
          return promisesArray.push((0, _query.getPopulateChild)(firebase, p, idOrList).then(v => {
            if (v) {
              (0, _set.default)(results, `${p.storeAs ? p.storeAs : p.root}.${idOrList}`, v);
            }

            return results;
          }));
        }

        if (Array.isArray(idOrList) || (0, _isObject.default)(idOrList)) {
          return promisesArray.push(populateList(firebase, idOrList, p, results));
        }
      });
    });
  }

  return Promise.all(promisesArray).then(() => results);
}

function getPopulateActions(_ref) {
  let {
    firebase,
    docData,
    meta
  } = _ref;
  return promisesForPopulate(firebase, docData.id, (0, _query.dataByIdSnapshot)(docData), meta.populates).then(populateResults => Object.keys(populateResults).map(resultKey => ({
    meta: {
      collection: resultKey
    },
    payload: {
      data: populateResults[resultKey]
    },
    requesting: false,
    requested: true
  }))).catch(populateErr => {
    console.error('Error with populate:', populateErr, meta);
    return Promise.reject(populateErr);
  });
}