@akemona-org/strapi-plugin-upload 3.7.0

package/admin/src/utils/getFileModelTimestamps.js

@@ -0,0 +1,15 @@
+import { get } from 'lodash';
+import pluginId from '../pluginId';
+
+const getFileModelTimestamps = plugins => {
+  const timestamps = get(plugins, [pluginId, 'fileModel', 'options', 'timestamps']);
+
+  // All connectors must initialise the "timestamps" option as a tuple
+  if (!Array.isArray(timestamps) || timestamps.length !== 2) {
+    throw new Error('Unexpected timestamp field configuration.');
+  }
+
+  return timestamps;
+};
+
+export default getFileModelTimestamps;

package/admin/src/utils/getFilesToDownload.js

@@ -0,0 +1,5 @@
+const getFilesToDownload = files => {
+  return files.filter(file => file.isDownloading === true);
+};
+
+export default getFilesToDownload;

package/admin/src/utils/getRequestUrl.js

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getRequestUrl = path => `/${pluginId}/${path}`;
+
+export default getRequestUrl;

package/admin/src/utils/getTrad.js

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = id => `${pluginId}.${id}`;
+
+export default getTrad;

package/admin/src/utils/getType.js

@@ -0,0 +1,15 @@
+const getType = mime => {
+  if (!mime) {
+    return 'file';
+  }
+
+  const type = mime.split(/[\s/]+/)[0];
+
+  if (type === 'image' || type === 'video') {
+    return type;
+  }
+
+  return 'file';
+};
+
+export default getType;

package/admin/src/utils/getYupError.js

@@ -0,0 +1,17 @@
+import { get } from 'lodash';
+
+const getYupError = error => {
+  return get(error, 'inner', []).reduce((acc, curr) => {
+    acc[
+      curr.path
+        .split('[')
+        .join('.')
+        .split(']')
+        .join('')
+    ] = { id: curr.message, number: curr.params.wrongURLsNumber };
+
+    return acc;
+  }, {});
+};
+
+export default getYupError;

package/admin/src/utils/index.js

@@ -0,0 +1,20 @@
+export { default as canDownloadFile } from './canDownloadFile';
+export { default as compactParams } from './compactParams';
+export { default as createFileToDownloadName } from './createFileToDownloadName';
+export { default as createMatrix } from './createMatrix';
+export { default as createNewFilesToDownloadArray } from './createNewFilesToDownloadArray';
+export { default as createNewFilesToUploadArray } from './createNewFilesToUploadArray';
+export { default as formatBytes } from './formatBytes';
+export { default as formatFileForEditing } from './formatFileForEditing';
+export { default as formatFilters } from './formatFilters';
+export { default as generatePageFromStart } from './generatePageFromStart';
+export { default as generateStartFromPage } from './generateStartFromPage';
+export { default as getFileModelTimestamps } from './getFileModelTimestamps';
+export { default as getFilesToDownload } from './getFilesToDownload';
+export { default as getRequestUrl } from './getRequestUrl';
+export { default as getTrad } from './getTrad';
+export { default as getType } from './getType';
+export { default as getYupError } from './getYupError';
+export { default as ItemTypes } from './ItemTypes';
+export { default as unformatBytes } from './unformatBytes';
+export { default as urlSchema } from './urlYupSchema';

package/admin/src/utils/unformatBytes.js

@@ -0,0 +1,16 @@
+function unformatBytes(value) {
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const k = 1000;
+
+  const number = value.split(/KB|MB|GB/)[0];
+  const unit = value.split(number)[1];
+
+  const i = sizes.findIndex(size => size === unit);
+
+  const multiplicator = k ** i;
+  const newValue = number * multiplicator;
+
+  return newValue / 1000;
+}
+
+export default unformatBytes;

package/admin/src/utils/urlYupSchema.js

@@ -0,0 +1,49 @@
+/* eslint-disable no-template-curly-in-string */
+import * as yup from 'yup';
+import { translatedErrors as errorsTrads } from 'strapi-helper-plugin';
+import getTrad from './getTrad';
+
+const urlSchema = yup.object().shape({
+  filesToDownload: yup
+    .array()
+    .of(yup.string())
+
+    .test({
+      name: 'isUrlValid',
+      message: '${path}',
+      test(values) {
+        const filtered = values.filter(val => {
+          try {
+            // eslint-disable-next-line no-new
+            new URL(val);
+
+            return false;
+          } catch (err) {
+            // invalid url
+            return true;
+          }
+        });
+
+        const filteredLength = filtered.length;
+
+        if (filteredLength === 0) {
+          return true;
+        }
+
+        const errorMessage =
+          filteredLength > 1
+            ? 'form.upload-url.error.url.invalids'
+            : 'form.upload-url.error.url.invalid';
+
+        return this.createError({
+          path: this.path,
+          message: getTrad(errorMessage),
+          params: { wrongURLsNumber: filtered.length },
+        });
+      },
+    })
+    .min(0, errorsTrads.min)
+    .max(20, errorsTrads.max),
+});
+
+export default urlSchema;

package/config/config.json

@@ -0,0 +1,8 @@
+{
+  "enabled": true,
+  "provider": "local",
+  "providerOptions": {
+    "sizeLimit": 1000000
+  },
+  "actionOptions": {}
+}

package/config/functions/bootstrap.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const { convertToStrapiError } = require('../../errors');
+
+module.exports = async () => {
+  // set plugin store
+  const configurator = strapi.store({
+    type: 'plugin',
+    name: 'upload',
+    key: 'settings',
+  });
+
+  strapi.plugins.upload.provider = createProvider(strapi.plugins.upload.config || {});
+
+  // if provider config does not exist set one by default
+  const config = await configurator.get();
+
+  if (!config) {
+    await configurator.set({
+      value: {
+        sizeOptimization: true,
+        responsiveDimensions: true,
+      },
+    });
+  }
+
+  await pruneObsoleteRelations();
+  await registerPermissionActions();
+};
+
+const wrapFunctionForErrors = fn => async (...args) => {
+  try {
+    return await fn(...args);
+  } catch (err) {
+    throw convertToStrapiError(err);
+  }
+};
+
+const createProvider = ({ provider, providerOptions, actionOptions = {} }) => {
+  try {
+    const providerInstance = require(`strapi-provider-upload-${provider}`).init(providerOptions);
+
+    return Object.assign(Object.create(baseProvider), {
+      ...providerInstance,
+      upload: wrapFunctionForErrors((file, options = actionOptions.upload) => {
+        return providerInstance.upload(file, options);
+      }),
+      delete: wrapFunctionForErrors((file, options = actionOptions.delete) => {
+        return providerInstance.delete(file, options);
+      }),
+    });
+  } catch (err) {
+    strapi.log.error(err);
+    throw new Error(
+      `The provider package isn't installed. Please run \`npm install strapi-provider-upload-${provider}\``
+    );
+  }
+};
+
+const baseProvider = {
+  extend(obj) {
+    Object.assign(this, obj);
+  },
+  upload() {
+    throw new Error('Provider upload method is not implemented');
+  },
+  delete() {
+    throw new Error('Provider delete method is not implemented');
+  },
+};
+
+const pruneObsoleteRelations = async () => {
+  const { upload: plugin } = strapi.plugins;
+  const modelIsNotDefined = !plugin || !plugin.models || !plugin.models.file;
+
+  if (modelIsNotDefined) {
+    return Promise.resolve();
+  }
+
+  await strapi.query('file', 'upload').custom(pruneObsoleteRelationsQuery)();
+};
+
+const pruneObsoleteRelationsQuery = ({ model }) => {
+  if (model.orm !== 'mongoose') {
+    return Promise.resolve();
+  }
+
+  const models = Array.from(strapi.db.models.values());
+  const modelsId = models.map(model => model.globalId);
+
+  return model.updateMany(
+    { related: { $elemMatch: { kind: { $nin: modelsId } } } },
+    { $pull: { related: { kind: { $nin: modelsId } } } }
+  );
+};
+
+const registerPermissionActions = async () => {
+  const actions = [
+    {
+      section: 'plugins',
+      displayName: 'Access the Media Library',
+      uid: 'read',
+      pluginName: 'upload',
+    },
+    {
+      section: 'plugins',
+      displayName: 'Create (upload)',
+      uid: 'assets.create',
+      subCategory: 'assets',
+      pluginName: 'upload',
+    },
+    {
+      section: 'plugins',
+      displayName: 'Update (crop, details, replace) + delete',
+      uid: 'assets.update',
+      subCategory: 'assets',
+      pluginName: 'upload',
+    },
+    {
+      section: 'plugins',
+      displayName: 'Download',
+      uid: 'assets.download',
+      subCategory: 'assets',
+      pluginName: 'upload',
+    },
+    {
+      section: 'plugins',
+      displayName: 'Copy link',
+      uid: 'assets.copy-link',
+      subCategory: 'assets',
+      pluginName: 'upload',
+    },
+    {
+      section: 'settings',
+      displayName: 'Access the Media Library settings page',
+      uid: 'settings.read',
+      category: 'media library',
+      pluginName: 'upload',
+    },
+  ];
+
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+};

package/config/routes.json

@@ -0,0 +1,98 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/settings",
+      "handler": "Upload.getSettings",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/settings",
+      "handler": "Upload.updateSettings",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/",
+      "handler": "Upload.upload",
+      "config": {
+        "policies": [],
+        "description": "Upload a file",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/files/count",
+      "handler": "Upload.count",
+      "config": {
+        "policies": [],
+        "description": "Retrieve the total number of uploaded files",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/files",
+      "handler": "Upload.find",
+      "config": {
+        "policies": [],
+        "description": "Retrieve all file documents",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/files/:id",
+      "handler": "Upload.findOne",
+      "config": {
+        "policies": [],
+        "description": "Retrieve a single file depending on its id",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/search/:id",
+      "handler": "Upload.search",
+      "config": {
+        "policies": [],
+        "description": "Search for an uploaded file",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/files/:id",
+      "handler": "Upload.destroy",
+      "config": {
+        "policies": [],
+        "description": "Delete an uploaded file",
+        "tag": {
+          "plugin": "upload",
+          "name": "File"
+        }
+      }
+    }
+  ]
+}

package/config/schema.graphql.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const _ = require('lodash');
+const { streamToBuffer } = require('../utils/file');
+
+module.exports = {
+  definition: `
+    input FileInfoInput {
+      name: String
+      alternativeText: String
+      caption: String
+    }
+  `,
+  mutation: `
+    upload(refId: ID, ref: String, field: String, source: String, info: FileInfoInput, file: Upload!): UploadFile!
+    multipleUpload(refId: ID, ref: String, field: String, source: String, files: [Upload]!): [UploadFile]!
+    updateFileInfo(id: ID!, info: FileInfoInput!): UploadFile!
+  `,
+  resolver: {
+    Query: {
+      file: false,
+      files: {
+        resolver: 'plugins::upload.upload.find',
+      },
+    },
+    Mutation: {
+      createFile: false,
+      updateFile: false,
+      upload: {
+        description: 'Upload one file',
+        resolverOf: 'plugins::upload.upload.upload',
+        resolver: async (obj, { file: upload, info, ...fields }) => {
+          const file = await formatFile(upload, info, fields);
+
+          const uploadedFiles = await strapi.plugins.upload.services.upload.uploadFileAndPersist(
+            file
+          );
+
+          // Return response.
+          return uploadedFiles.length === 1 ? uploadedFiles[0] : uploadedFiles;
+        },
+      },
+      multipleUpload: {
+        description: 'Upload one file',
+        resolverOf: 'plugins::upload.upload.upload',
+        resolver: async (obj, { files: uploads, ...fields }) => {
+          const files = await Promise.all(uploads.map(upload => formatFile(upload, {}, fields)));
+
+          const uploadService = strapi.plugins.upload.services.upload;
+
+          return Promise.all(files.map(file => uploadService.uploadFileAndPersist(file)));
+        },
+      },
+      updateFileInfo: {
+        description: 'Update file information',
+        resolverOf: 'plugins::upload.upload.upload',
+        resolver: async (obj, { id, info }) => {
+          return await strapi.plugins.upload.services.upload.updateFileInfo(id, info);
+        },
+      },
+      deleteFile: {
+        description: 'Delete one file',
+        resolverOf: 'plugins::upload.upload.destroy',
+        resolver: async (obj, options, { context }) => {
+          const file = await strapi.plugins.upload.services.upload.fetch({ id: context.params.id });
+          if (file) {
+            const fileResult = await strapi.plugins.upload.services.upload.remove(file);
+            return { file: fileResult };
+          }
+        },
+      },
+    },
+  },
+};
+
+const formatFile = async (upload, extraInfo, metas) => {
+  const { filename, mimetype, createReadStream } = await upload;
+
+  const { optimize } = strapi.plugins.upload.services['image-manipulation'];
+  const readBuffer = await streamToBuffer(createReadStream());
+
+  const { buffer, info } = await optimize(readBuffer);
+
+  const uploadService = strapi.plugins.upload.services.upload;
+  const fileInfo = uploadService.formatFileInfo(
+    {
+      filename,
+      type: mimetype,
+      size: buffer.length,
+    },
+    extraInfo || {},
+    metas
+  );
+
+  return _.assign(fileInfo, info, { buffer });
+};

package/controllers/Upload.js

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * Upload.js controller
+ *
+ */
+
+const _ = require('lodash');
+const { sanitizeEntity } = require('@akemona-org/strapi-utils');
+const apiUploadController = require('./upload/api');
+const adminUploadController = require('./upload/admin');
+
+const resolveController = (ctx) => {
+  const {
+    state: { isAuthenticatedAdmin },
+  } = ctx;
+
+  return isAuthenticatedAdmin ? adminUploadController : apiUploadController;
+};
+
+const resolveControllerMethod = (method) => (ctx) => {
+  const controller = resolveController(ctx);
+  const callbackFn = controller[method];
+
+  if (!_.isFunction(callbackFn)) {
+    return ctx.notFound();
+  }
+
+  return callbackFn(ctx);
+};
+
+module.exports = {
+  find: resolveControllerMethod('find'),
+  findOne: resolveControllerMethod('findOne'),
+  count: resolveControllerMethod('count'),
+  destroy: resolveControllerMethod('destroy'),
+  updateSettings: resolveControllerMethod('updateSettings'),
+  getSettings: resolveControllerMethod('getSettings'),
+
+  async upload(ctx) {
+    const isUploadDisabled = _.get(strapi.plugins, 'upload.config.enabled', true) === false;
+
+    if (isUploadDisabled) {
+      throw strapi.errors.badRequest(null, {
+        errors: [{ id: 'Upload.status.disabled', message: 'File upload is disabled' }],
+      });
+    }
+
+    const {
+      query: { id },
+      request: { files: { files } = {} },
+    } = ctx;
+    const controller = resolveController(ctx);
+
+    if (id && (_.isEmpty(files) || files.size === 0)) {
+      return controller.updateFileInfo(ctx);
+    }
+
+    if (_.isEmpty(files) || files.size === 0) {
+      throw strapi.errors.badRequest(null, {
+        errors: [{ id: 'Upload.status.empty', message: 'Files are empty' }],
+      });
+    }
+
+    await (id ? controller.replaceFile : controller.uploadFiles)(ctx);
+  },
+
+  async search(ctx) {
+    const { id } = ctx.params;
+    const model = strapi.getModel('file', 'upload');
+    const entries = await strapi.query('file', 'upload').custom(searchQueries)({
+      id,
+    });
+
+    ctx.body = sanitizeEntity(entries, { model });
+  },
+};
+
+const searchQueries = {
+  bookshelf({ model }) {
+    return ({ id }) => {
+      return model
+        .query((qb) => {
+          qb.whereRaw('LOWER(hash) LIKE ?', [`%${id}%`]).orWhereRaw('LOWER(name) LIKE ?', [
+            `%${id}%`,
+          ]);
+        })
+        .fetchAll()
+        .then((results) => results.toJSON());
+    };
+  },
+  mongoose({ model }) {
+    return ({ id }) => {
+      const re = new RegExp(id, 'i');
+
+      return model
+        .find({
+          $or: [{ hash: re }, { name: re }],
+        })
+        .lean();
+    };
+  },
+};