@bowtie/sls/src/models/Document.js

Serverless helpers & utilities

const AWS = require('aws-sdk');
const uuidv1 = require('uuid/v1')
// const merge = require('deepmerge')
const { verifySchema } = require('@bowtie/utils')
const { dynamoose, defaults, helpers } = require('../config')
const { parseServiceConfig, scanRecursive, findDeploymentHost, findDeploymentLinks } = require('../utils')
const pubnub = require('../pubnub')
// [HIGH] TODO: WTF?!?
// const Audit = require('./Audit')

const { Schema } = dynamoose
const { envGetAlias, tagIsRelease } = helpers

const DocumentSchema = new Schema({
  id: {
    type: String,
    required: true,
    hashKey: true,
    default: (model) => uuidv1()
  },
  timestamp: {
    type: Number,
    // index: true,
    required: true,
    // rangeKey: true,
    default: (model) => Date.now()
  },
  getObjectUrl: String,
  putObjectUrl: String,
  uploaded: {
    type: Boolean,
    default: false
  },
  published: {
    type: Boolean,
    default: false
  },
  lifetime: {
    type: Number,
    required: true,
    default: 30
  },
  owner: {
    type: String,
    // index: true,
    // required: true,
    // rangeKey: true
  },
  filepath: {
    type: String,
    required: true,
    default: '',
  },
  filename: {
    type: String,
    required: true
  },
  filetype: {
    type: String,
    required: true
  },
  filesize: {
    type: Number,
    required: true,
    default: 0
  },
  permissions: {
    type: 'map',
    map: {
      deny: Array,
      allow: Array,
    }
  }
}, {
  timestamps: true,
  throughput: 'ON_DEMAND'
})

const DocumentModel = dynamoose.model(process.env.DOCUMENTS_TABLE_NAME, DocumentSchema)

DocumentModel.methods.set('scanAll', async function (params = {}) {
  return scanRecursive(this, params)
})

DocumentModel.methods.document.set('publish', function (data = {}, action = 'saved') {
  return new Promise(
    (resolve, reject) => {
      const payload = {
        channel: 'documents',
        message: {
          data,
          action,
          service: process.env.SERVICE_NAME,
          subject: this
        }
      }

      console.log('Document publish', { payload, data }, this)

      if (pubnub) {
        pubnub.publish(payload, (status, response) => {
          console.log('PN Publish', { status, response })

          if (status.error) {
            const { operation, statusCode } = status
            reject(new Error(`FAIL: Document#publish() failed: (${operation} -> ${statusCode}})`))
          } else {
            resolve(this)
          }
        })
      } else {
        console.log('PubNub is not configured, not publishing updates')

        resolve(this)
      }
    }
  )
})

DocumentModel.methods.document.set('saveNotify', async function (options = {}) {
  if (!this.filepath) {
    this.filepath = 'default'
  }

  this.getObjectUrl = await this.getSignedUrl('getObject');

  if (!this.putObjectUrl) {
    this.putObjectUrl = await this.getSignedUrl('putObject');
  }

  const data = await this.save()
  return await this.publish(data, 'saved')
})

DocumentModel.methods.document.set('getSignedUrl', async function (operation = 'getObject') {
  // AWS.config.update({region: 'us-east-1'});

  const s3 = new AWS.S3({
    signatureVersion: 'v4'
  });

  const params = this.signedUrlParams();

  if (operation === 'putObject') {
    params.ContentType = this.filetype;
  }

  console.log('INFO: Document.getSignedUrl()', { params });

  const signedUrl = await s3.getSignedUrlPromise(operation, params)

  console.log('INFO: Document.getSignedUrl()', { signedUrl });

  return signedUrl;
})

DocumentModel.methods.document.set('signedUrlParams', function (options = {}) {
  const Bucket = process.env.SECURE_BUCKET_NAME;
  const Key = `${this.filepath}/${this.filename}`.replace(/\/+/g, '/').replace(/\s/g, '_');
  const Expires = this.lifetime;
  // const ContentType = this.filetype;

  return ({
    Expires,
    Bucket,
    Key,
    // ContentType,
  });
});


module.exports = DocumentModel