Enable saving file in the storage folder ✨

Author: MiroDojkic

client/api/asset.js

@@ -1,16 +1,17 @@
 import request from './request';
 
 const urls = {
-  base: repositoryId => `/repositories/${repositoryId}/assets`
+  base: 'assets'
 };
 
-function getUrl(repositoryId, key) {
-  const params = { key };
-  return request.get(urls.base(repositoryId), { params }).then(res => res.data.url);
+function getUrl(folder, key) {
+  const params = { key: `${folder}/${key}` };
+  return request.get(urls.base, { params }).then(res => res.data.url);
 }
 
-function upload(repositoryId, data) {
-  return request.post(urls.base(repositoryId), data).then(res => res.data);
+function upload(folder, data) {
+  if (folder) data.append('folder', folder);
+  return request.post(urls.base, data).then(res => res.data);
 }
 
 export default {

client/components/common/mixins/upload.js

@@ -18,7 +18,8 @@ export default {
     },
     upload: loader(function (e) {
       this.createFileForm(e);
-      return this.$storageService.upload(this.repositoryId, this.form)
+      const folder = `repository/${this.repositoryId}`;
+      return this.$storageService.upload(folder, this.form)
         .then(data => {
           const { name } = this.form.get('file');
           this.$emit('upload', { ...data, name });

server/repository/index.js

@@ -19,7 +19,6 @@ const activity = require('../activity');
 const comment = require('../comment');
 const revision = require('../revision');
 const contentElement = require('../content-element');
-const storageRouter = require('../shared/storage/storage.router');
 /* eslint-enable */
 
 // NOTE: disk storage engine expects an object to be passed as the first argument
@@ -59,7 +58,6 @@ mount(router, '/:repositoryId', activity);
 mount(router, '/:repositoryId', revision);
 mount(router, '/:repositoryId', contentElement);
 mount(router, '/:repositoryId', comment);
-mount(router, '/:repositoryId', storageRouter);
 
 function mount(router, mountPath, subrouter) {
   return router.use(path.join(mountPath, subrouter.path), subrouter.router);

server/router.js

@@ -5,6 +5,7 @@ const { authenticate } = require('./shared/auth');
 const express = require('express');
 const { extractAuthData } = require('./shared/auth/mw');
 const repository = require('./repository');
+const storage = require('./shared/storage/storage.router');
 const tag = require('./tag');
 const user = require('./user');
 
@@ -24,6 +25,7 @@ authConfig.oidc.enabled && (() => {
 // Protected routes:
 router.use(authenticate('jwt'));
 router.use(repository.path, repository.router);
+router.use(storage.path, storage.router);
 router.use(tag.path, tag.router);
 
 module.exports = router;

server/shared/storage/helpers.js

@@ -4,7 +4,7 @@ const { elementRegistry } = require('../content-plugins');
 const get = require('lodash/get');
 const config = require('../../../config/server').storage;
 const Promise = require('bluebird');
-const proxy = require('../../repository/proxy');
+const proxy = require('../storage/proxy');
 const set = require('lodash/set');
 const toPairs = require('lodash/toPairs');
 const values = require('lodash/values');

server/shared/storage/storage.controller.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { getFileUrl, getPath, saveFile } = require('../../repository/storage');
 const { readFile, sha256 } = require('./util');
 const config = require('../../../config/server').storage;
 const fecha = require('fecha');
@@ -9,49 +8,55 @@ const JSZip = require('jszip');
 const mime = require('mime-types');
 const path = require('path');
 const pickBy = require('lodash/pickBy');
+const Storage = require('./');
 
 const getStorageUrl = key => `${config.protocol}${key}`;
+const storage = new Storage(config);
 
 function getUrl(req, res) {
   const { query: { key } } = req;
-  return getFileUrl(key).then(url => res.json({ url }));
+  return storage.getFileUrl(key).then(url => res.json({ url }));
 }
 
-async function upload({ file, body, user, repository }, res) {
+async function upload({ file, body, user }, res) {
+  const { folder, unpack } = body;
   const { name } = path.parse(file.originalname);
-  const { id: repositoryId } = repository;
-  if (body.unpack) {
+  if (unpack) {
     const timestamp = fecha.format(new Date(), 'YYYY-MM-DDTHH:mm:ss');
     const root = `${timestamp}__${user.id}__${name}`;
-    const assets = await uploadArchiveContent(repositoryId, file, root);
+    const assets = await uploadArchiveContent(folder, file, root);
     return res.json({ root, assets });
   }
-  const asset = await uploadFile(repositoryId, file, name);
+  const asset = await uploadFile(folder, file, name);
   return res.json(asset);
 }
 
 module.exports = { getUrl, upload };
 
-async function uploadFile(repositoryId, file, name) {
+async function uploadFile(folder, file, name) {
   const buffer = await readFile(file);
   const hash = sha256(file.originalname, buffer);
   const extension = path.extname(file.originalname);
   const fileName = `${hash}___${name}${extension}`;
-  const key = path.join(getPath(repositoryId), fileName);
-  await saveFile(key, buffer, { ContentType: file.mimetype });
-  const publicUrl = await getFileUrl(key);
+  const keyComponents = [folder, fileName].filter(Boolean);
+  const key = path.join(...keyComponents);
+  await storage.saveFile(key, buffer, { ContentType: file.mimetype });
+  const publicUrl = await storage.getFileUrl(key);
   return { key, publicUrl, url: getStorageUrl(key) };
 }
 
-async function uploadArchiveContent(repositoryId, archive, name) {
+async function uploadArchiveContent(folder, archive, name) {
   const buffer = await readFile(archive);
   const content = await JSZip.loadAsync(buffer);
   const files = pickBy(content.files, it => !it.dir);
   const keys = await Promise.all(Object.keys(files).map(async src => {
-    const key = path.join(getPath(repositoryId), name, src);
+    const keyComponents = [folder, name, src].filter(Boolean);
+    const key = path.join(...keyComponents);
     const file = await content.file(src).async('uint8array');
     const mimeType = mime.lookup(src);
-    await saveFile(key, Buffer.from(file), { ContentType: mimeType });
+    await storage.saveFile(key, Buffer.from(file), {
+      ContentType: mimeType
+    });
     return [key, getStorageUrl(key)];
   }));
   return fromPairs(keys);