GraphQL removing files

[nezzard]

Hi, it would be very good if it were possible to delete previously uploaded files through GraphQL.

Now we are developing an online store, when adding goods, the manager can upload thumbnails to the goods, I need to give the opportunity to delete previously uploaded thumbnails through GraphQL.

Everything is built on Apollo nuxt, I would not want to use it to remove axios thumbnails.

[alexandrebodin]

Hi @nezzard It sure would be cool to support it. This would be fairly straight forward to implement.

If you feel like opening a PR don't hesitate to reach out on slack ;)

[nitronapp]

You can create a custom upload mutation and in resolver check for the previous file and delete it before uploading the new one. Example:

const path = require('path');
const _ = require('lodash');
const crypto = require('crypto');
const toArray = require('stream-to-array');
const uuid = require('uuid/v4');

function niceHash(buffer) {
  return crypto
    .createHash('sha256')
    .update(buffer)
    .digest('base64')
    .replace(/=/g, '')
    .replace(/\//g, '-')
    .replace(/\+/, '_');
}

module.exports = {
    mutation: `
        customUpload(refId: ID, ref: String, field: String, source: String, file: Upload!): UploadFile!
    `,
    resolver: {
        Mutation: {
          customUpload: {
            description: 'Upload one file',
            plugin: 'upload',
            resolverOf: 'Upload.upload',
            resolver: async (obj, { file: upload, ...fields }) => {
              const file = await formatFile(upload, fields);
    
              const config = await strapi
                .store({
                  environment: strapi.config.environment,
                  type: 'plugin',
                  name: 'upload',
                }).get({ key: 'provider' });
               
              //Here we do our check for previous file and delete if available
              const result = await strapi.query(fields.ref).findOne({id: fields.refId});
              if(result[fields.field]) {
                const deleteResult = await strapi.query('file', 'upload').delete({ id: result[fields.field].id });
              }

              //Continue uploading
              const uploadedFiles = await strapi.plugins.upload.services.upload.upload(
                [file],
                config
              );

              // Return response.
              return uploadedFiles.length === 1 ? uploadedFiles[0] : uploadedFiles;
            },
          }
        }
    }
}

const formatFile = async (upload, fields) => {
    const { filename, mimetype, createReadStream } = await upload;
  
    const stream = createReadStream();
  
    const parts = await toArray(stream);
    const buffers = parts.map(part =>
      _.isBuffer(part) ? part : Buffer.from(part)
    );
  
    const buffer = Buffer.concat(buffers);
  
    const { refId, ref, source, field } = fields;
    
    const fileData = {
      name: filename,
      sha256: niceHash(buffer),
      hash: uuid().replace(/-/g, ''),
      ext: path.extname(filename),
      buffer,
      mime: mimetype,
      size: (buffer.length / 1000).toFixed(2),
    };
 
    // Add details to the file to be able to create the relationships.
    if (refId && ref && field) {
      fileData.related = [
        {
          refId,
          ref,
          source,
          field,
        },
      ];
    }
  
    return fileData;
  };