@akemona-org/strapi-plugin-upload 3.7.0

package/controllers/upload/admin.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const _ = require('lodash');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+const validateSettings = require('../validation/settings');
+const validateUploadBody = require('../validation/upload');
+
+const { CREATED_BY_ATTRIBUTE } = contentTypesUtils.constants;
+
+const ACTIONS = {
+  read: 'plugins::upload.read',
+  readSettings: 'plugins::upload.settings.read',
+  create: 'plugins::upload.assets.create',
+  update: 'plugins::upload.assets.update',
+  download: 'plugins::upload.assets.download',
+  copyLink: 'plugins::upload.assets.copy-link',
+};
+
+const fileModel = 'plugins::upload.file';
+
+module.exports = {
+  async find(ctx) {
+    const {
+      state: { userAbility },
+    } = ctx;
+
+    const pm = strapi.admin.services.permission.createPermissionsManager({
+      ability: userAbility,
+      action: ACTIONS.read,
+      model: fileModel,
+    });
+
+    if (!pm.isAllowed) {
+      return ctx.forbidden();
+    }
+
+    const method = _.has(ctx.query, '_q') ? 'search' : 'fetchAll';
+
+    const query = pm.queryFrom(ctx.query);
+    const files = await strapi.plugins.upload.services.upload[method](query, []);
+
+    ctx.body = pm.sanitize(files, { withPrivate: false });
+  },
+
+  async findOne(ctx) {
+    const {
+      state: { userAbility },
+      params: { id },
+    } = ctx;
+
+    const { pm, file } = await findEntityAndCheckPermissions(
+      userAbility,
+      ACTIONS.read,
+      fileModel,
+      id
+    );
+
+    ctx.body = pm.sanitize(file, { withPrivate: false });
+  },
+
+  async count(ctx) {
+    const pm = strapi.admin.services.permission.createPermissionsManager({
+      ability: ctx.state.userAbility,
+      action: ACTIONS.read,
+      model: fileModel,
+    });
+
+    if (!pm.isAllowed) {
+      return ctx.forbidden();
+    }
+
+    const method = _.has(ctx.query, '_q') ? 'countSearch' : 'count';
+    const query = pm.queryFrom(ctx.query);
+
+    const count = await strapi.plugins.upload.services.upload[method](query);
+
+    ctx.body = { count };
+  },
+
+  async destroy(ctx) {
+    const {
+      state: { userAbility },
+      params: { id },
+    } = ctx;
+
+    const { pm, file } = await findEntityAndCheckPermissions(
+      userAbility,
+      ACTIONS.update,
+      fileModel,
+      id
+    );
+
+    await strapi.plugins['upload'].services.upload.remove(file);
+
+    ctx.body = pm.sanitize(file, { action: ACTIONS.read, withPrivate: false });
+  },
+
+  async updateSettings(ctx) {
+    const {
+      request: { body },
+      state: { userAbility },
+    } = ctx;
+
+    if (userAbility.cannot(ACTIONS.readSettings, fileModel)) {
+      return ctx.forbidden();
+    }
+
+    const data = await validateSettings(body);
+
+    await strapi.plugins.upload.services.upload.setSettings(data);
+
+    ctx.body = { data };
+  },
+
+  async getSettings(ctx) {
+    const {
+      state: { userAbility },
+    } = ctx;
+
+    if (userAbility.cannot(ACTIONS.readSettings, fileModel)) {
+      return ctx.forbidden();
+    }
+
+    const data = await strapi.plugins.upload.services.upload.getSettings();
+
+    ctx.body = { data };
+  },
+
+  async updateFileInfo(ctx) {
+    const {
+      state: { userAbility, user },
+      query: { id },
+      request: { body },
+    } = ctx;
+
+    const uploadService = strapi.plugins.upload.services.upload;
+    const { pm } = await findEntityAndCheckPermissions(userAbility, ACTIONS.update, fileModel, id);
+
+    const data = await validateUploadBody(body);
+    const file = await uploadService.updateFileInfo(id, data.fileInfo, { user });
+
+    ctx.body = pm.sanitize(file, { action: ACTIONS.read, withPrivate: false });
+  },
+
+  async replaceFile(ctx) {
+    const {
+      state: { userAbility, user },
+      query: { id },
+      request: { body, files: { files } = {} },
+    } = ctx;
+
+    const uploadService = strapi.plugins.upload.services.upload;
+    const { pm } = await findEntityAndCheckPermissions(userAbility, ACTIONS.update, fileModel, id);
+
+    if (Array.isArray(files)) {
+      throw strapi.errors.badRequest(null, {
+        errors: [
+          { id: 'Upload.replace.single', message: 'Cannot replace a file with multiple ones' },
+        ],
+      });
+    }
+
+    const data = await validateUploadBody(body);
+    const replacedFiles = await uploadService.replace(id, { data, file: files }, { user });
+
+    ctx.body = pm.sanitize(replacedFiles, { action: ACTIONS.read, withPrivate: false });
+  },
+
+  async uploadFiles(ctx) {
+    const {
+      state: { userAbility, user },
+      request: { body, files: { files } = {} },
+    } = ctx;
+
+    const uploadService = strapi.plugins.upload.services.upload;
+    const pm = strapi.admin.services.permission.createPermissionsManager({
+      ability: userAbility,
+      action: ACTIONS.create,
+      model: fileModel,
+    });
+
+    if (!pm.isAllowed) {
+      throw strapi.errors.forbidden();
+    }
+
+    const data = await validateUploadBody(body);
+    const uploadedFiles = await uploadService.upload({ data, files }, { user });
+
+    ctx.body = pm.sanitize(uploadedFiles, { action: ACTIONS.read, withPrivate: false });
+  },
+};
+
+const findEntityAndCheckPermissions = async (ability, action, model, id) => {
+  const file = await strapi.plugins.upload.services.upload.fetch({ id }, []);
+
+  if (_.isNil(file)) {
+    throw strapi.errors.notFound();
+  }
+
+  const pm = strapi.admin.services.permission.createPermissionsManager({ ability, action, model });
+
+  const author = await strapi.admin.services.user.findOne({ id: file[CREATED_BY_ATTRIBUTE] }, [
+    'roles',
+  ]);
+
+  const fileWithRoles = _.set(_.cloneDeep(file), 'created_by', author);
+
+  if (pm.ability.cannot(pm.action, pm.toSubject(fileWithRoles))) {
+    throw strapi.errors.forbidden();
+  }
+
+  return { pm, file };
+};

package/controllers/upload/api.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const _ = require('lodash');
+const { sanitizeEntity } = require('@akemona-org/strapi-utils');
+const validateSettings = require('../validation/settings');
+const validateUploadBody = require('../validation/upload');
+
+const sanitize = (data, options = {}) => {
+  return sanitizeEntity(data, {
+    model: strapi.getModel('file', 'upload'),
+    ...options,
+  });
+};
+
+module.exports = {
+  async find(ctx) {
+    const method = _.has(ctx.query, '_q') ? 'search' : 'fetchAll';
+
+    const files = await strapi.plugins.upload.services.upload[method](ctx.query);
+
+    ctx.body = sanitize(files);
+  },
+
+  async findOne(ctx) {
+    const {
+      params: { id },
+    } = ctx;
+
+    const file = await strapi.plugins.upload.services.upload.fetch({ id });
+
+    if (!file) {
+      return ctx.notFound('file.notFound');
+    }
+
+    ctx.body = sanitize(file);
+  },
+
+  async count(ctx) {
+    const method = _.has(ctx.query, '_q') ? 'countSearch' : 'count';
+
+    ctx.body = await strapi.plugins.upload.services.upload[method](ctx.query);
+  },
+
+  async destroy(ctx) {
+    const {
+      params: { id },
+    } = ctx;
+
+    const file = await strapi.plugins['upload'].services.upload.fetch({ id });
+
+    if (!file) {
+      return ctx.notFound('file.notFound');
+    }
+
+    await strapi.plugins['upload'].services.upload.remove(file);
+
+    ctx.body = sanitize(file);
+  },
+
+  async updateSettings(ctx) {
+    const {
+      request: { body },
+    } = ctx;
+
+    const data = await validateSettings(body);
+
+    await strapi.plugins.upload.services.upload.setSettings(data);
+
+    ctx.body = { data };
+  },
+
+  async getSettings(ctx) {
+    const data = await strapi.plugins.upload.services.upload.getSettings();
+
+    ctx.body = { data };
+  },
+
+  async updateFileInfo(ctx) {
+    const {
+      query: { id },
+      request: { body },
+    } = ctx;
+    const data = await validateUploadBody(body);
+
+    const result = await strapi.plugins.upload.services.upload.updateFileInfo(id, data.fileInfo);
+
+    ctx.body = sanitize(result);
+  },
+
+  async replaceFile(ctx) {
+    const {
+      query: { id },
+      request: { body, files: { files } = {} },
+    } = ctx;
+
+    // cannot replace with more than one file
+    if (Array.isArray(files)) {
+      throw strapi.errors.badRequest(null, {
+        errors: [
+          { id: 'Upload.replace.single', message: 'Cannot replace a file with multiple ones' },
+        ],
+      });
+    }
+
+    const replacedFiles = await strapi.plugins.upload.services.upload.replace(id, {
+      data: await validateUploadBody(body),
+      file: files,
+    });
+
+    ctx.body = sanitize(replacedFiles);
+  },
+
+  async uploadFiles(ctx) {
+    const {
+      request: { body, files: { files } = {} },
+    } = ctx;
+
+    const uploadedFiles = await strapi.plugins.upload.services.upload.upload({
+      data: await validateUploadBody(body),
+      files,
+    });
+
+    ctx.body = sanitize(uploadedFiles);
+  },
+};

package/controllers/validation/settings.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const settingsSchema = yup.object({
+  sizeOptimization: yup.boolean().required(),
+  responsiveDimensions: yup.boolean().required(),
+});
+
+const validateSettings = (data) => {
+  return settingsSchema
+    .validate(data, {
+      abortEarly: false,
+    })
+    .catch((error) => {
+      throw strapi.errors.badRequest('ValidationError', {
+        errors: formatYupErrors(error),
+      });
+    });
+};
+
+module.exports = validateSettings;

package/controllers/validation/upload.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const fileInfoSchema = yup.object({
+  name: yup.string().nullable(),
+  alternativeText: yup.string().nullable(),
+  caption: yup.string().nullable(),
+});
+
+const uploadSchema = yup.object({
+  fileInfo: fileInfoSchema,
+});
+
+const multiUploadSchema = yup.object({
+  fileInfo: yup.array().of(fileInfoSchema),
+});
+
+const validateUploadBody = (data = {}, isMulti = false) => {
+  const schema = isMulti ? multiUploadSchema : uploadSchema;
+
+  return schema.validate(data, { abortEarly: false }).catch((err) => {
+    throw strapi.errors.badRequest('ValidationError', { errors: formatYupErrors(err) });
+  });
+};
+
+module.exports = validateUploadBody;

package/documentation/1.0.0/overrides/upload-File.json

@@ -0,0 +1,263 @@
+{
+  "paths": {
+    "/upload/": {
+      "post": {
+        "description": "Upload one or multiple files",
+        "responses": {
+          "200": {
+            "description": "response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "name": {
+                        "type": "string"
+                      },
+                      "hash": {
+                        "type": "string",
+                        "format": "uuid"
+                      },
+                      "sha256": {
+                        "type": "string"
+                      },
+                      "ext": {
+                        "type": "string"
+                      },
+                      "mime": {
+                        "type": "string"
+                      },
+                      "size": {
+                        "type": "decimal"
+                      },
+                      "url": {
+                        "type": "string",
+                        "format": "uri"
+                      },
+                      "provider": {
+                        "type": "string"
+                      },
+                      "related": {
+                        "type": "array",
+                        "items": {
+                          "type": "object"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "summary": "",
+        "tags": [
+          "Upload - File"
+        ],
+        "requestBody": {
+          "description": "",
+          "required": true,
+          "content": {
+            "multipart/form-data": {
+              "schema": {
+                "required": ["files"],
+                "properties": {
+                  "files": {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "format": "binary"
+                    }
+                  },
+                  "path": {
+                    "type": "string",
+                    "example": "/public/upload"
+                  },
+                  "refId": {
+                    "type": "string",
+                    "example": "5a993616b8e66660e8baf45c"
+                  },
+                  "ref": {
+                    "type": "string",
+                    "example": "user"
+                  },
+                  "source": {
+                    "type": "string",
+                    "example": "users-permissions"
+                  },
+                  "field": {
+                    "type": "string",
+                    "example": "avatar"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/upload/files/count": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "count": {
+                      "type": "integer"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/upload/files": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/UploadFile"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/upload/search/{id}": {
+      "get": {
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "",
+            "deprecated": false,
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/UploadFile"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/upload/files/{_id}": {
+      "get": {
+        "parameters": [
+          {
+            "name": "_id",
+            "in": "path",
+            "description": "",
+            "deprecated": false,
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UploadFile"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "parameters": [
+          {
+            "name": "_id",
+            "in": "path",
+            "description": "",
+            "deprecated": false,
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Document deleted"
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "UploadFile": {
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "sha256": {
+            "type": "string"
+          },
+          "hash": {
+            "type": "string"
+          },
+          "ext": {
+            "type": "string"
+          },
+          "size": {
+            "type": "decimal"
+          },
+          "mime": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          },
+          "provider": {
+            "type": "string"
+          },
+          "updatedAt": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string"
+          },
+          "related": {
+            "type": "array",
+            "items": {
+              "type":"string"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/errors.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const errorTypes = {
+  ENTITY_TOO_LARGE: 'entityTooLarge',
+  UNKNOWN_ERROR: 'unknownError',
+};
+
+const entityTooLarge = message => {
+  const error = new Error(message || 'Entity too large');
+  error.type = errorTypes.ENTITY_TOO_LARGE;
+  return error;
+};
+entityTooLarge.type = errorTypes.ENTITY_TOO_LARGE;
+
+const unknownError = message => {
+  const error = new Error(message || 'Unknown error');
+  error.type = errorTypes.UNKNOWN_ERROR;
+  return error;
+};
+unknownError.type = errorTypes.UNKNOWN_ERROR;
+
+const is = (err, errorFactory) => {
+  return err.type && err.type === errorFactory.type;
+};
+
+const convertToStrapiError = err => {
+  if (is(err, entityTooLarge)) {
+    return strapi.errors.entityTooLarge('FileTooBig', {
+      errors: [
+        {
+          id: 'Upload.status.sizeLimit',
+          message: 'file is bigger than the limit size!',
+        },
+      ],
+    });
+  } else {
+    strapi.log.error(err);
+    return strapi.errors.badImplementation();
+  }
+};
+
+module.exports = {
+  errors: {
+    entityTooLarge,
+    unknownError,
+  },
+  convertToStrapiError,
+};

package/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { errors } = require('./errors');
+
+module.exports = {
+  errors,
+};

package/middlewares/upload/defaults.json

@@ -0,0 +1,5 @@
+{
+  "upload": {
+    "enabled": true
+  }
+}