muffin/dist/routes/api/upload.js

The 21st century way of building websites

'use strict';

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

var _koaRouter = require('koa-router');

var _koaRouter2 = _interopRequireDefault(_koaRouter);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _db = require('../../utils/db');

var _utils = require('../../utils');

var _uploads = require('../uploads');

var _uploads2 = _interopRequireDefault(_uploads);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

const router = new _koaRouter2.default();

function detSeparator(handle) {
  let numbers = {};

  const types = {
    spaces: ' ',
    dots: '.',
    underscores: '_',
    dashes: '-'
  };

  for (let type in types) {
    if (!types.hasOwnProperty(type)) {
      continue;
    }

    numbers[type] = handle.split(types[type]).length - 1;
  }

  const largest = Object.keys(numbers).reduce((prev, curr) => {
    return numbers[prev] > numbers[curr] ? prev : curr;
  });

  return types[largest];
}

router.get('/files', _uploads2.default.routes());

router.post('/upload', (() => {
  var ref = _asyncToGenerator(function* (ctx, next) {
    const file = ctx.request.body.files.file;
    const ext = _path2.default.extname(file.name);
    const name = _path2.default.basename(file.name, ext);

    // Determine the most used separator in the filename
    const separator = detSeparator(name);
    let id = 0;

    // Encode filename as URI string
    function formatName(n) {
      return encodeURIComponent(name + (n > 0 ? separator + n : '') + ext);
    }

    let isAvailable = false;

    do {
      // Check if filename is already in DB
      try {
        isAvailable = yield _db.fs.exist({
          filename: formatName(id),
          root: 'media'
        });
      } catch (err) {
        return (0, _utils.log)('Couldn\'t check if media exists', err);
      }

      // Increase id if it's already in use
      if (isAvailable) {
        id++;
      } else {
        // If not, simply go on
        break;
      }
    } while (true);

    const writestream = _db.fs.createWriteStream({
      filename: formatName(id),
      root: 'media',
      content_type: file.type
    });

    // Get file from disk and pipe it to gfs's writestream
    const content = _fsExtra2.default.createReadStream(file.path);
    content.pipe(writestream);

    try {
      yield new Promise(function (resolve) {
        return writestream.on('close', function () {
          return resolve();
        });
      });
    } catch (err) {
      return (0, _utils.log)('Not able to save media', err);
    }

    ctx.body = {
      contentType: file.type,
      uploadDate: new Date().toJSON()
    };

    yield next();

    // Remove temporary file after response
    _fsExtra2.default.unlink(file.path, function (err) {
      if (err) (0, _utils.log)('Couldn\'t remove temporary media file', err);
    });
  });

  return function (_x, _x2) {
    return ref.apply(this, arguments);
  };
})());

exports.default = router;
module.exports = exports['default'];