@taraai/read-write/lib/redux-firebase/actions/storage.js

Synchronous NoSQL/Firestore for React

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.deleteFile = deleteFile;
exports.uploadFile = uploadFile;
exports.uploadFiles = uploadFiles;

var _map2 = _interopRequireDefault(require("lodash/map"));

var _constants = require("../constants");

var _actions = require("../utils/actions");

var _storage = require("../utils/storage");

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

const {
  FILE_UPLOAD_START,
  FILE_UPLOAD_ERROR,
  FILE_UPLOAD_COMPLETE,
  FILE_DELETE_START,
  FILE_DELETE_ERROR,
  FILE_DELETE_COMPLETE
} = _constants.actionTypes;

function uploadFile(dispatch, firebase, config) {
  if (!firebase.storage) {
    throw new Error('Firebase storage is required to upload files');
  }

  const {
    path,
    file,
    dbPath,
    options = {
      progress: false
    }
  } = config || {};
  const {
    metadata: fileMetadata
  } = options || {};
  const {
    logErrors
  } = firebase._.config;
  const nameFromOptions = typeof options.name === 'function' ? options.name(file, firebase, config) : options.name;
  const filename = nameFromOptions || file.name;
  const meta = { ...config,
    filename
  };
  dispatch({
    type: FILE_UPLOAD_START,
    payload: { ...config,
      filename
    }
  });

  const uploadPromise = () => options.progress ? (0, _storage.uploadFileWithProgress)(dispatch, firebase, {
    path,
    file,
    filename,
    meta,
    fileMetadata
  }) : firebase.storage().ref(`${path}/${filename}`).put(file, fileMetadata);

  return uploadPromise().then(uploadTaskSnapshot => {
    if (!dbPath || !firebase.database && !firebase.firestore) {
      dispatch({
        type: FILE_UPLOAD_COMPLETE,
        meta: { ...config,
          filename
        },
        payload: {
          uploadTaskSnapshot,
          uploadTaskSnaphot: uploadTaskSnapshot
        }
      });
      return {
        uploadTaskSnapshot,
        uploadTaskSnaphot: uploadTaskSnapshot
      };
    }

    return (0, _storage.writeMetadataToDb)({
      firebase,
      uploadTaskSnapshot,
      dbPath,
      options
    }).then(payload => {
      dispatch({
        type: FILE_UPLOAD_COMPLETE,
        meta: { ...config,
          filename
        },
        payload
      });
      return payload;
    });
  }).catch(err => {
    if (logErrors) {
      console.error && console.error(`RRF: Error uploading file: ${err.message || err}`, err);
    }

    dispatch({
      type: FILE_UPLOAD_ERROR,
      path,
      payload: err
    });
    return Promise.reject(err);
  });
}

function uploadFiles(dispatch, firebase, _ref) {
  let {
    files,
    ...other
  } = _ref;
  return Promise.all((0, _map2.default)(files, file => uploadFile(dispatch, firebase, {
    file,
    ...other
  })));
}

function deleteFile(dispatch, firebase, _ref2) {
  let {
    path,
    dbPath
  } = _ref2;
  return (0, _actions.wrapInDispatch)(dispatch, {
    method: _storage.deleteFile,
    args: [firebase, {
      path,
      dbPath
    }],
    types: [FILE_DELETE_START, FILE_DELETE_COMPLETE, FILE_DELETE_ERROR]
  });
}