eslint and code cleanup of uploads

src/collections/registerRoutes.js

@@ -5,7 +5,6 @@ import authRoutes from '../auth/routes';
 import {
   query, create, findOne, destroy, update,
 } from '../mongoose/requestHandlers';
-import { upload as uploadMedia, update as updateMedia } from '../uploads/requestHandlers';
 import bindModelMiddleware from '../mongoose/bindModel';
 import setModelLocaleMiddleware from '../localization/setModelLocale';
 
@@ -28,18 +27,13 @@ const registerRoutes = ({ model, config }, router) => {
     bindModelMiddleware(model),
     setModelLocaleMiddleware());
 
-  // TODO: this feels sloppy, need to discuss media enabled collection handlers
-  const createHandler = config.media ? (req, res, next) => uploadMedia(req, res, next, config.media) : create;
-  const updateHandler = config.media ? (req, res, next) => updateMedia(req, res, next, config.media) : update;
-  // TODO: Do we need a delete?
-
   router.route(`/${config.slug}`)
     .get(config.policies.read, query)
-    .post(config.policies.create, createHandler);
+    .post(config.policies.create, create);
 
   router.route(`/${config.slug}/:id`)
     .get(config.policies.read, findOne)
-    .put(config.policies.update, updateHandler)
+    .put(config.policies.update, update)
     .delete(config.policies.destroy, destroy);
 };
 

src/init/uploads.js

@@ -8,12 +8,10 @@ const initUploads = ({ config, app, router }) => {
   app.use(fileUpload({}));
 
   if (config.uploads) {
-    app.use(fileUpload());
+    app.use(fileUpload({dubug: true}));
 
-    router.use('', uploadRoutes(config)
-    );
+    router.use('', uploadRoutes(config));
   }
-}
+};
 
 export default initUploads;
-

src/uploads/images/imageResizer.js

@@ -1,39 +1,42 @@
 import sharp from 'sharp';
 import { promisify } from 'util';
 import imageSize from 'image-size';
+
 const sizeOf = promisify(imageSize);
 
 function getOutputImageName(sourceImage, size) {
-  let extension = sourceImage.split('.').pop();
-  let filenameWithoutExtension = sourceImage.substr(0, sourceImage.lastIndexOf('.')) || sourceImage;
+  const extension = sourceImage.split('.')
+    .pop();
+  const filenameWithoutExtension = sourceImage.substr(0, sourceImage.lastIndexOf('.')) || sourceImage;
   return `${filenameWithoutExtension}-${size.width}x${size.height}.${extension}`;
 }
 
 export async function resizeAndSave(config, uploadConfig, file) {
-  let sourceImage = `${config.staticDir}/${file.name}`;
+  const sourceImage = `${config.staticDir}/${file.name}`;
 
-  let outputSizes = [];
+  const outputSizes = [];
   try {
     const dimensions = await sizeOf(sourceImage);
-    for (let desiredSize of uploadConfig.imageSizes) {
+    uploadConfig.imageSizes.map(async (desiredSize) => {
       if (desiredSize.width > dimensions.width) {
-        continue;
+        return;
       }
-      let outputImageName = getOutputImageName(sourceImage, desiredSize);
+      const outputImageName = getOutputImageName(sourceImage, desiredSize);
+      // eslint-disable-next-line no-await-in-loop
       await sharp(sourceImage)
         .resize(desiredSize.width, desiredSize.height, {
-          position: desiredSize.crop || 'centre' // would it make sense for this to be set by the uploader?
+          position: desiredSize.crop || 'centre', // would it make sense for this to be set by the uploader?
         })
         .toFile(outputImageName);
       outputSizes.push({
         name: desiredSize.name,
         height: desiredSize.height,
-        width: desiredSize.width
+        width: desiredSize.width,
       });
-    }
+    });
   } catch (e) {
     console.log('error in resize and save', e.message);
   }
-
+  console.log(outputSizes);
   return outputSizes;
 }

src/uploads/images/model.js

@@ -2,22 +2,20 @@ import mongoose from 'mongoose';
 import localizationPlugin from '../../localization/plugin';
 
 const imageUploadModelLoader = (Upload, config) => {
-
   const ImageSchema = new mongoose.Schema(
     {
       sizes: [{
         name: { type: String },
         height: { type: Number },
         width: { type: Number },
-        _id: false
-      }]
-    }
+        _id: false,
+      }],
+    },
   );
 
   ImageSchema.plugin(localizationPlugin, config.localization);
 
   return Upload.discriminator('image', ImageSchema);
-
 };
 
 export default imageUploadModelLoader;

src/uploads/requestHandlers.js

@@ -1,72 +1,8 @@
 import mkdirp from 'mkdirp';
-import { resizeAndSave } from './images/imageResizer';
 import httpStatus from 'http-status';
+import { resizeAndSave } from './images/imageResizer';
 import modelById from '../mongoose/resolvers/modelById';
-
-const update = async (req, res, next, config) => {
-    const query = {
-      Model: req.model,
-      id: req.params.id,
-      locale: req.locale,
-    };
-    let doc = await modelById(query, {returnRawDoc: true});
-    if (!doc)
-      return res.status(httpStatus.NOT_FOUND).send('Not Found');
-
-    if (req.files && req.files.file) {
-      doc['filename'] = req.files.file.name;
-      let outputFilepath = `${config.staticDir}/${req.files.file.name}`;
-      let moveError = await req.files.file.mv(outputFilepath);
-      if (moveError) return res.status(500).send(moveError);
-      let handlerData = await fileTypeHandler(config, req.uploadConfig, req.files.file);
-      Object.keys(handlerData).forEach(e => {
-        doc[e] = handlerData[e];
-      });
-    }
-
-    doc.save((saveError) => {
-      if (saveError)
-        return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({error: saveError});
-
-      return res.json({
-        message: 'success',
-        result: doc.toJSON({virtuals: true})
-      });
-    });
-  };
-
-const upload = async (req, res, next, config) => {
-  if (!req.files || Object.keys(req.files).length === 0) {
-    return res.status(400).send('No files were uploaded.');
-  }
-
-  mkdirp(config.staticDir, (err) => {
-    if (err) {
-      console.error(err);
-      return res.status(500).send('Upload failed.');
-    }
-  });
-
-  let outputFilepath = `${config.staticDir}/${req.files.file.name}`;
-  let moveError = await req.files.file.mv(outputFilepath);
-  if (moveError) return res.status(500).send(moveError);
-
-  let handlerData = await fileTypeHandler(config, req.uploadConfig, req.files.file);
-
-  req.model.create({
-    filename: req.files.file.name,
-    ...handlerData
-  }, (mediaCreateError, result) => {
-    if (mediaCreateError)
-      return res.status(500).json({error: mediaCreateError});
-
-    return res.status(201)
-      .json({
-        message: 'success',
-        result: result.toJSON({virtuals: true})
-      });
-  });
-};
+import { NotFound } from '../errors';
 
 async function fileTypeHandler(config, uploadConfig, file) {
   const data = {};
@@ -77,4 +13,88 @@ async function fileTypeHandler(config, uploadConfig, file) {
   return data;
 }
 
-export {update, upload};
+const update = async (req, res, next, config) => {
+  const query = {
+    Model: req.model,
+    id: req.params.id,
+    locale: req.locale,
+  };
+  const doc = await modelById(query, { returnRawDoc: true });
+  if (!doc) {
+    res.status(httpStatus.NOT_FOUND)
+      .json(new NotFound());
+    return;
+  }
+
+  if (req.files && req.files.file) {
+    doc.filename = req.files.file.name;
+    const outputFilepath = `${config.staticDir}/${req.files.file.name}`;
+    const moveError = await req.files.file.mv(outputFilepath);
+    if (moveError) {
+      res.status(httpStatus.INTERNAL_SERVER_ERROR)
+        .json(moveError);
+      return;
+    }
+    const handlerData = await fileTypeHandler(config, req.uploadConfig, req.files.file);
+    Object.assign(doc, handlerData);
+  }
+
+  doc.save((saveError) => {
+    if (saveError) {
+      res.status(httpStatus.INTERNAL_SERVER_ERROR)
+        .json({ error: saveError });
+      return;
+    }
+
+    res.status(httpStatus.OK)
+      .json({
+        message: 'success',
+        result: doc.toJSON({ virtuals: true }),
+      });
+  });
+};
+
+const upload = async (req, res, next, config) => {
+  console.log(req.files);
+  if (!req.files || Object.keys(req.files).length === 0) {
+    res.status(400)
+      .send('No files were uploaded.');
+    return;
+  }
+
+  mkdirp(config.staticDir, (err) => {
+    if (err) {
+      console.error(err);
+      res.status(500)
+        .json({ error: 'Upload failed.' });
+    }
+  });
+
+  const outputFilepath = `${config.staticDir}/${req.files.file.name}`;
+  const moveError = await req.files.file.mv(outputFilepath);
+  if (moveError) {
+    res.status(httpStatus.INTERNAL_SERVER_ERROR)
+      .send(moveError);
+    return;
+  }
+
+  const handlerData = await fileTypeHandler(config, req.uploadConfig, req.files.file);
+
+  req.model.create({
+    filename: req.files.file.name,
+    ...handlerData,
+  }, (mediaCreateError, result) => {
+    if (mediaCreateError) {
+      return res.status(httpStatus.INTERNAL_SERVER_ERROR)
+        .json({ error: mediaCreateError });
+    }
+
+    return res.status(httpStatus.CREATED)
+      .json({
+        message: 'success',
+        result: result.toJSON({ virtuals: true }),
+      });
+  });
+};
+
+export { update, upload };

src/uploads/routes.js

@@ -8,7 +8,7 @@ import passport from 'passport';
 
 const router = express.Router();
 
-const uploadRoutes = config => {
+const uploadRoutes = (config) => {
 
   const Upload = uploadModelLoader(config);
   const UploadModels = {
@@ -19,17 +19,16 @@ const uploadRoutes = config => {
   router.all('/upload*',
     passport.authenticate('jwt', { session: false }),
     uploadMiddleware(config, UploadModels),
-    setModelLocaleMiddleware(),
-  );
+    setModelLocaleMiddleware());
 
   router.route('/upload')
     .post(
-      (req, res, next) => upload(req, res, next, config)
+      (req, res, next) => upload(req, res, next, config),
     );
 
   router.route('/upload/:id')
     .put(
-      (req, res, next) => update(req, res, next, config)
+      (req, res, next) => update(req, res, next, config),
     );
 
   return router;