S3

import AWS from 'aws-sdk';

const { AWS_REGION = 'us-east-1', NODE_ENV = 'development', AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY } = process.env;
const config = {
  region: AWS_REGION,
  accessKeyId: AWS_ACCESS_KEY_ID,
  secretAccessKey: AWS_SECRET_ACCESS_KEY,
};

AWS.config.update(config);

const s3 = new AWS.S3({ httpOptions: { timeout: 10000 } });

export default class S3 {
  static get(params) {
    return new Promise((resolve, reject) =>
      s3.getObject(
        params,
        (err, response) => err ? reject(err) : resolve(response && response.Body ? response.Body.toString() : response)
      )
    );
  }

  static put(params) {
    return new Promise((resolve, reject) =>
      s3.putObject(
        params,
        err => err ? reject(err) : resolve()
      )
    );
  }

  static delete(params, items) {
    return new Promise(async (resolve, reject) =>
      s3.deleteObjects(
        Object.assign({}, params, { Delete: { Objects: items.map(({ Key }) => ({ Key })) }}),
        err => err ? reject(err) : resolve()
      )
    );
  }

  static list(params, list = []) {
    return new Promise(
      async (resolve, reject) => s3.listObjects(
        params,
        (err, { Contents, IsTruncated }) => {
          if (err) {
            return reject(err);
          }

          const files = list.concat(Contents.reduce((items, item) => {
            if (item.Size > 0) {
              items.push(item);
            }

            return items;
          }, []));

          if (!params.MaxKeys && IsTruncated) {
            return this.list(Object.assign({}, params, { Marker: Contents[Contents.length - 1].Key }), files)
              .then(items => resolve(items))
              .catch(e => reject(e));
          }

          return resolve(files);
        }
      )
    );
  }

  static prune({ Bucket, Prefix }, limit) {
    return new Promise(async (resolve, reject) => {
      try {
        const files = await this.list({ Bucket, Prefix });

        if (files.length > limit) {
          await this.delete({ Bucket }, files.sort((a, b) => a.LastModified < b.LastModified).slice(0, limit));
          return resolve();
        }
      } catch (e) {
        return reject(e);
      }
    });
  }
}