@akemona-org/strapi-plugin-upload 3.7.0

package/middlewares/upload/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { resolve } = require('path');
+const range = require('koa-range');
+const koaStatic = require('koa-static');
+const _ = require('lodash');
+
+module.exports = strapi => ({
+  initialize() {
+    const configPublicPath = strapi.config.get(
+      'middleware.settings.public.path',
+      strapi.config.paths.static
+    );
+    const staticDir = resolve(strapi.dir, configPublicPath);
+
+    strapi.app.on('error', err => {
+      if (err.code === 'EPIPE') {
+        // when serving audio or video the browsers sometimes close the connection to go to range requests instead.
+        // This causes koa to emit a write EPIPE error. We can ignore it.
+        // Right now this ignores it globally and we cannot do much more because it is how koa handles it.
+        return;
+      }
+
+      strapi.app.onerror(err);
+    });
+
+    const localServerConfig =
+      _.get(strapi, 'plugins.upload.config.providerOptions.localServer') || {};
+    strapi.router.get(
+      '/uploads/(.*)',
+      range,
+      koaStatic(staticDir, { defer: true, ...localServerConfig })
+    );
+  },
+});

package/models/File.js

@@ -0,0 +1,7 @@
+'use strict';
+
+/**
+ * Lifecycle callbacks for the `File` model.
+ */
+
+module.exports = {};

package/models/File.settings.json

@@ -0,0 +1,86 @@
+{
+  "info": {
+    "name": "file",
+    "description": ""
+  },
+  "options": {
+    "timestamps": true
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": false
+    },
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "configurable": false,
+      "required": true
+    },
+    "alternativeText": {
+      "type": "string",
+      "configurable": false
+    },
+    "caption": {
+      "type": "string",
+      "configurable": false
+    },
+    "width": {
+      "type": "integer",
+      "configurable": false
+    },
+    "height": {
+      "type": "integer",
+      "configurable": false
+    },
+    "formats": {
+      "type": "json",
+      "configurable": false
+    },
+    "hash": {
+      "type": "string",
+      "configurable": false,
+      "required": true
+    },
+    "ext": {
+      "type": "string",
+      "configurable": false
+    },
+    "mime": {
+      "type": "string",
+      "configurable": false,
+      "required": true
+    },
+    "size": {
+      "type": "decimal",
+      "configurable": false,
+      "required": true
+    },
+    "url": {
+      "type": "string",
+      "configurable": false,
+      "required": true
+    },
+    "previewUrl": {
+      "type": "string",
+      "configurable": false
+    },
+    "provider": {
+      "type": "string",
+      "configurable": false,
+      "required": true
+    },
+    "provider_metadata": {
+      "type": "json",
+      "configurable": false
+    },
+    "related": {
+      "collection": "*",
+      "filter": "field",
+      "configurable": false
+    }
+  }
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@akemona-org/strapi-plugin-upload",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "Makes it easy to upload images and files to your Strapi Application.",
+  "strapi": {
+    "name": "Media Library",
+    "icon": "cloud-upload-alt",
+    "description": "upload.plugin.description",
+    "required": true
+  },
+  "scripts": {
+    "test": "echo \"no tests yet\""
+  },
+  "dependencies": {
+    "@akemona-org/strapi-helper-plugin": "3.7.0",
+    "@akemona-org/strapi-provider-upload-local": "3.7.0",
+    "@akemona-org/strapi-utils": "3.7.0",
+    "@buffetjs/core": "3.3.8",
+    "@buffetjs/custom": "3.3.8",
+    "@buffetjs/hooks": "3.3.8",
+    "@buffetjs/icons": "3.3.8",
+    "@buffetjs/styles": "3.3.8",
+    "@buffetjs/utils": "3.3.8",
+    "byte-size": "^7.0.1",
+    "cropperjs": "^1.5.11",
+    "immer": "9.0.16",
+    "immutable": "^3.8.2",
+    "is-valid-domain": "0.0.17",
+    "koa-range": "0.3.0",
+    "koa-static": "^5.0.0",
+    "lodash": "4.17.21",
+    "node-fetch": "2.6.1",
+    "react": "^16.14.0",
+    "react-copy-to-clipboard": "^5.0.3",
+    "react-dom": "^16.9.0",
+    "react-intl": "4.5.0",
+    "react-redux": "7.2.3",
+    "react-router": "^5.2.0",
+    "react-router-dom": "^5.0.0",
+    "reactstrap": "8.4.1",
+    "sharp": "0.31.1",
+    "stream-to-array": "^2.3.0",
+    "uuid": "^3.2.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akemona/strapi.git",
+    "directory": "packages/strapi-plugin-upload"
+  },
+  "author": {
+    "name": "Akemona team",
+    "email": "strapi@akemona.com",
+    "url": "https://strapi.akemona.com"
+  },
+  "maintainers": [
+    {
+      "name": "Akemona team",
+      "email": "strapi@akemona.com",
+      "url": "https://strapi.akemona.com"
+    }
+  ],
+  "engines": {
+    "node": ">=10.16.0 <=14.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+}

package/services/Upload.js

@@ -0,0 +1,397 @@
+'use strict';
+
+/**
+ * Upload.js service
+ *
+ * @description: A set of functions similar to controller's actions to avoid code duplication.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const util = require('util');
+const _ = require('lodash');
+const {
+  nameToSlug,
+  contentTypes: contentTypesUtils,
+  sanitizeEntity,
+  webhook: webhookUtils,
+} = require('@akemona-org/strapi-utils');
+
+const { MEDIA_UPDATE, MEDIA_CREATE, MEDIA_DELETE } = webhookUtils.webhookEvents;
+
+const { bytesToKbytes } = require('../utils/file');
+
+const { UPDATED_BY_ATTRIBUTE, CREATED_BY_ATTRIBUTE } = contentTypesUtils.constants;
+
+const randomSuffix = () => crypto.randomBytes(5).toString('hex');
+
+const generateFileName = (name) => {
+  const baseName = nameToSlug(name, { separator: '_', lowercase: false });
+
+  return `${baseName}_${randomSuffix()}`;
+};
+
+const sendMediaMetrics = (/* data */) => {
+  /* if (_.has(data, 'caption') && !_.isEmpty(data.caption)) {
+    strapi.telemetry.send('didSaveMediaWithCaption');
+  }
+
+  if (_.has(data, 'alternativeText') && !_.isEmpty(data.alternativeText)) {
+    strapi.telemetry.send('didSaveMediaWithAlternativeText');
+  } */
+};
+
+const combineFilters = (params) => {
+  // FIXME: until we support boolean operators for querying we need to make mime_ncontains use AND instead of OR
+  if (_.has(params, 'mime_ncontains') && Array.isArray(params.mime_ncontains)) {
+    params._where = params.mime_ncontains.map((val) => ({ mime_ncontains: val }));
+    delete params.mime_ncontains;
+  }
+};
+
+module.exports = {
+  formatFileInfo({ filename, type, size }, fileInfo = {}, metas = {}) {
+    const ext = path.extname(filename);
+    const basename = path.basename(fileInfo.name || filename, ext);
+
+    const usedName = fileInfo.name || filename;
+
+    const entity = {
+      name: usedName,
+      alternativeText: fileInfo.alternativeText,
+      caption: fileInfo.caption,
+      hash: generateFileName(basename),
+      ext,
+      mime: type,
+      size: bytesToKbytes(size),
+    };
+
+    const { refId, ref, source, field } = metas;
+
+    if (refId && ref && field) {
+      entity.related = [
+        {
+          refId,
+          ref,
+          source,
+          field,
+        },
+      ];
+    }
+
+    if (metas.path) {
+      entity.path = metas.path;
+    }
+
+    return entity;
+  },
+
+  async enhanceFile(file, fileInfo = {}, metas = {}) {
+    let readBuffer;
+    try {
+      readBuffer = await util.promisify(fs.readFile)(file.path);
+    } catch (e) {
+      if (e.code === 'ERR_FS_FILE_TOO_LARGE') {
+        throw strapi.errors.entityTooLarge('FileTooBig', {
+          errors: [
+            {
+              id: 'Upload.status.sizeLimit',
+              message: `${file.name} file is bigger than the limit size!`,
+              values: { file: file.name },
+            },
+          ],
+        });
+      }
+      throw e;
+    }
+
+    const { optimize } = strapi.plugins.upload.services['image-manipulation'];
+
+    const { buffer, info } = await optimize(readBuffer);
+
+    const formattedFile = this.formatFileInfo(
+      {
+        filename: file.name,
+        type: file.type,
+        size: file.size,
+      },
+      fileInfo,
+      metas
+    );
+
+    return _.assign(formattedFile, info, {
+      buffer,
+    });
+  },
+
+  async upload({ data, files }, { user } = {}) {
+    const { fileInfo, ...metas } = data;
+
+    const fileArray = Array.isArray(files) ? files : [files];
+    const fileInfoArray = Array.isArray(fileInfo) ? fileInfo : [fileInfo];
+
+    const doUpload = async (file, fileInfo) => {
+      const fileData = await this.enhanceFile(file, fileInfo, metas);
+
+      return this.uploadFileAndPersist(fileData, { user });
+    };
+
+    return await Promise.all(
+      fileArray.map((file, idx) => doUpload(file, fileInfoArray[idx] || {}))
+    );
+  },
+
+  async uploadFileAndPersist(fileData, { user } = {}) {
+    const config = strapi.plugins.upload.config;
+
+    const { getDimensions, generateThumbnail, generateResponsiveFormats } =
+      strapi.plugins.upload.services['image-manipulation'];
+
+    await strapi.plugins.upload.provider.upload(fileData);
+
+    const thumbnailFile = await generateThumbnail(fileData);
+    if (thumbnailFile) {
+      await strapi.plugins.upload.provider.upload(thumbnailFile);
+      delete thumbnailFile.buffer;
+      _.set(fileData, 'formats.thumbnail', thumbnailFile);
+    }
+
+    const formats = await generateResponsiveFormats(fileData);
+    if (Array.isArray(formats) && formats.length > 0) {
+      for (const format of formats) {
+        if (!format) continue;
+
+        const { key, file } = format;
+
+        await strapi.plugins.upload.provider.upload(file);
+        delete file.buffer;
+
+        _.set(fileData, ['formats', key], file);
+      }
+    }
+
+    const { width, height } = await getDimensions(fileData.buffer);
+
+    delete fileData.buffer;
+
+    _.assign(fileData, {
+      provider: config.provider,
+      width,
+      height,
+    });
+
+    return this.add(fileData, { user });
+  },
+
+  async updateFileInfo(id, { name, alternativeText, caption }, { user } = {}) {
+    const dbFile = await this.fetch({ id });
+
+    if (!dbFile) {
+      throw strapi.errors.notFound('file not found');
+    }
+
+    const newInfos = {
+      name: _.isNil(name) ? dbFile.name : name,
+      alternativeText: _.isNil(alternativeText) ? dbFile.alternativeText : alternativeText,
+      caption: _.isNil(caption) ? dbFile.caption : caption,
+    };
+
+    return this.update({ id }, newInfos, { user });
+  },
+
+  async replace(id, { data, file }, { user } = {}) {
+    const config = strapi.plugins.upload.config;
+
+    const { getDimensions, generateThumbnail, generateResponsiveFormats } =
+      strapi.plugins.upload.services['image-manipulation'];
+
+    const dbFile = await this.fetch({ id });
+
+    if (!dbFile) {
+      throw strapi.errors.notFound('file not found');
+    }
+
+    const { fileInfo } = data;
+    const fileData = await this.enhanceFile(file, fileInfo);
+
+    // keep a constant hash
+    _.assign(fileData, {
+      hash: dbFile.hash,
+      ext: dbFile.ext,
+    });
+
+    // execute delete function of the provider
+    if (dbFile.provider === config.provider) {
+      await strapi.plugins.upload.provider.delete(dbFile);
+
+      if (dbFile.formats) {
+        await Promise.all(
+          Object.keys(dbFile.formats).map((key) => {
+            return strapi.plugins.upload.provider.delete(dbFile.formats[key]);
+          })
+        );
+      }
+    }
+
+    await strapi.plugins.upload.provider.upload(fileData);
+
+    // clear old formats
+    _.set(fileData, 'formats', {});
+
+    const thumbnailFile = await generateThumbnail(fileData);
+    if (thumbnailFile) {
+      await strapi.plugins.upload.provider.upload(thumbnailFile);
+      delete thumbnailFile.buffer;
+      _.set(fileData, 'formats.thumbnail', thumbnailFile);
+    }
+
+    const formats = await generateResponsiveFormats(fileData);
+    if (Array.isArray(formats) && formats.length > 0) {
+      for (const format of formats) {
+        if (!format) continue;
+
+        const { key, file } = format;
+
+        await strapi.plugins.upload.provider.upload(file);
+        delete file.buffer;
+
+        _.set(fileData, ['formats', key], file);
+      }
+    }
+
+    const { width, height } = await getDimensions(fileData.buffer);
+    delete fileData.buffer;
+
+    _.assign(fileData, {
+      provider: config.provider,
+      width,
+      height,
+    });
+
+    return this.update({ id }, fileData, { user });
+  },
+
+  async update(params, values, { user } = {}) {
+    const fileValues = { ...values };
+    if (user) {
+      fileValues[UPDATED_BY_ATTRIBUTE] = user.id;
+    }
+    sendMediaMetrics(fileValues);
+
+    const res = await strapi.query('file', 'upload').update(params, fileValues);
+    const modelDef = strapi.getModel('file', 'upload');
+    strapi.eventHub.emit(MEDIA_UPDATE, { media: sanitizeEntity(res, { model: modelDef }) });
+    return res;
+  },
+
+  async add(values, { user } = {}) {
+    const fileValues = { ...values };
+    if (user) {
+      fileValues[UPDATED_BY_ATTRIBUTE] = user.id;
+      fileValues[CREATED_BY_ATTRIBUTE] = user.id;
+    }
+    sendMediaMetrics(fileValues);
+
+    const res = await strapi.query('file', 'upload').create(fileValues);
+    const modelDef = strapi.getModel('file', 'upload');
+    strapi.eventHub.emit(MEDIA_CREATE, { media: sanitizeEntity(res, { model: modelDef }) });
+    return res;
+  },
+
+  fetch(params, populate) {
+    return strapi.query('file', 'upload').findOne(params, populate);
+  },
+
+  fetchAll(params, populate) {
+    combineFilters(params);
+    return strapi.query('file', 'upload').find(params, populate);
+  },
+
+  search(params, populate) {
+    return strapi.query('file', 'upload').search(params, populate);
+  },
+
+  countSearch(params) {
+    return strapi.query('file', 'upload').countSearch(params);
+  },
+
+  count(params) {
+    combineFilters(params);
+    return strapi.query('file', 'upload').count(params);
+  },
+
+  async remove(file) {
+    const config = strapi.plugins.upload.config;
+
+    // execute delete function of the provider
+    if (file.provider === config.provider) {
+      await strapi.plugins.upload.provider.delete(file);
+
+      if (file.formats) {
+        await Promise.all(
+          Object.keys(file.formats).map((key) => {
+            return strapi.plugins.upload.provider.delete(file.formats[key]);
+          })
+        );
+      }
+    }
+
+    const media = await strapi.query('file', 'upload').findOne({
+      id: file.id,
+    });
+
+    const modelDef = strapi.getModel('file', 'upload');
+    strapi.eventHub.emit(MEDIA_DELETE, { media: sanitizeEntity(media, { model: modelDef }) });
+
+    return strapi.query('file', 'upload').delete({ id: file.id });
+  },
+
+  async uploadToEntity(params, files, source) {
+    const { id, model, field } = params;
+
+    const arr = Array.isArray(files) ? files : [files];
+    const enhancedFiles = await Promise.all(
+      arr.map((file) => {
+        return this.enhanceFile(
+          file,
+          {},
+          {
+            refId: id,
+            ref: model,
+            source,
+            field,
+          }
+        );
+      })
+    );
+
+    await Promise.all(enhancedFiles.map((file) => this.uploadFileAndPersist(file)));
+  },
+
+  getSettings() {
+    return strapi
+      .store({
+        type: 'plugin',
+        name: 'upload',
+        key: 'settings',
+      })
+      .get();
+  },
+
+  setSettings(value) {
+    /*  if (value.responsiveDimensions === true) {
+      strapi.telemetry.send('didEnableResponsiveDimensions');
+    } else {
+      strapi.telemetry.send('didDisableResponsiveDimensions');
+    } */
+
+    return strapi
+      .store({
+        type: 'plugin',
+        name: 'upload',
+        key: 'settings',
+      })
+      .set({ value });
+  },
+};