Service for persisting data to S3

remoteStorageService.js

import AWS from "aws-sdk";
import config from "config";
import uuidV4 from "uuid/v4";
import querystring from "querystring";

class RemoteStorageService {

  constructor() {
    this._apiVersion = "2011-06-15";
    this._s3 = new AWS.S3({
      apiVersion: this.apiVersion,
      accessKeyId : config.aws.accessKeyId,
      secretAccessKey : config.aws.secretAccessKey
    });
  }

  get apiVersion() {
    return this._apiVersion;
  }

  set apiVersion(apiVersion) {
    throw new Error("may not override apiVersion value");
  }

  get s3() {
    return this._s3;
  }

  set s3(s3) {
    throw new Error("may not override s3 object");
  }

  storeFile(fileData, fileName) {
    return new Promise((resolve, reject) => {
      const key = this.newKeyForFileName(fileName);

      const params = {
        Body: fileData,
        Bucket: config.aws.s3BucketName,
        Key: key
      };

      this.s3.putObject(params, (err, data) => {
        if (err) {
          reject(err);
          return;
        }

        const resolveData = {
          key: key
        }

        resolve(resolveData);
      });
    });
  }

  getPresignedPostDetailsForFileName(fileName) {
    return new Promise((resolve, reject) => {
      const key = this.newKeyForFileName(fileName);
      const params = {
        Bucket: config.aws.s3BucketName,
        Fields: {
          key: key
        }
      };

      this.s3.createPresignedPost(params, (err, { url, fields }) => {
        if (err) {
          reject(err);
          return;
        }

        const details = {
          url: url,
          fields: fields
        }

        resolve(details);
      });
    });
  }

  getHeadObjectForFileByKey(key) {
    return new Promise((resolve, reject) => {
      const params = {
        Bucket: config.aws.s3BucketName,
        Key: key
      };

      this.s3.headObject(params, (err, headObject) => {
        if (err) {
          reject(err);
          return;
        }

        resolve(headObject);
      });
    });
  }

  getPresignedURLForFileByKey(key, expiresSeconds=300) {
    return new Promise((resolve, reject) => {
      const params = {
        Bucket: config.aws.s3BucketName,
        Key: key,
        Expires: expiresSeconds
      };

      this.s3.getSignedUrl("getObject", params, (err, url) => {
        if (err) {
          reject(err);
          return;
        }

        resolve(url);
      });
    });
  }

  getStoredFileByKey(key) {
    return new Promise((resolve, reject) => {
      const params = {
        Bucket: config.aws.s3BucketName,
        Key: key
      };

      this.s3.getObject(params, (err, data) => {
        if (err) {
          reject(err);
          return;
        }

        resolve(data);
      });
    });
  }

  getStoredFileStreamByKey(key) {
    return new Promise((resolve, reject) => {
      const params = {
        Bucket: config.aws.s3BucketName,
        Key: key
      };

      const s3Stream = this.s3.getObject(params).createReadStream();

      resolve(s3Stream);
    });
  }

  newKeyForFileName(fileName) {
    return `${ uuidV4() }-${ querystring.escape(fileName) }`;
  }
}

export default RemoteStorageService;