@taraai/read-write/lib/utils/createMutate.js

Synchronous NoSQL/Firestore for React

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createMutate;

var _isFunction = _interopRequireDefault(require("lodash/isFunction"));

var _toolkit = require("@reduxjs/toolkit");

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

function safeProvider(fnc, state) {
  try {
    return fnc(state);
  } catch (err) {
    return new Error(`Default Provider "${fnc.name}" doesn't accept redux state.`);
  }
}

function createMutate(_ref) {
  let {
    action,
    ...mutation
  } = _ref;
  if (!_toolkit.createAsyncThunk) throw new Error("'createMutate' requires @reduxjs/toolkit. Run 'yarn add @reduxjs/toolkit'");
  const {
    read,
    write,
    readwrite
  } = mutation;
  return (0, _toolkit.createAsyncThunk)(action, (payload, thunkAPI) => {
    try {
      const state = thunkAPI.getState && thunkAPI.getState() || {};
      const {
        getFirestore,
        getFirebase,
        ...extras
      } = thunkAPI.extra || {};
      const {
        mutate
      } = getFirestore();
      const globals = Object.keys(extras).reduce((obj, extra) => ({ ...obj,
        [extra]: safeProvider(extras[extra], state)
      }), {
        uid: state.firebase && state.firebase.auth && state.firebase.auth.uid
      });
      const {
        read: reads,
        write: writes
      } = readwrite ? readwrite(payload, globals) : {
        read: read(payload, globals),
        write: Array.isArray(write) ? write : [write]
      };
      const isTransaction = reads && !Object.keys(reads).every(key => (0, _isFunction.default)(reads[key]));

      if (isTransaction) {
        return mutate({
          reads,
          writes
        });
      }

      const values = Object.keys(reads).reduce((reader, key) => {
        if (reader[key]) return reader;
        return (0, _isFunction.default)(reads[key]) ? { ...reader,
          [key]: reads[key]()
        } : { ...reader,
          [key]: reads[key]
        };
      }, globals);
      const isBatch = Array.isArray(write);

      if (isBatch) {
        return mutate(write.map(writeFnc => writeFnc(values)));
      }

      return mutate(write(values));
    } catch (error) {
      return error;
    }
  });
}