How to use mime-types

function mimeFromPath ( path ) {
  var mType = mimeTypes.lookup( path )
  if ( mType == null ) {
    console.error( 'No mime type found', path )
  }
  return mType
}

generated_extension() {
  logger.debug('trying to generate extension', this.content_type);
  if (customFileExtensions.hasOwnProperty(this.content_type)) {
   return customFileExtensions[this.content_type];
  } else {
   return mime.extension(this.content_type) ? mime.extension(this.content_type) : 'jpg';
  }
 }

multer.diskStorage({
 filename: (req, file, cb) => {
  const ext = mimeType.extension(file.mimetype)
  cb(null, `file-${Date.now()}.${ext}`)
 },
 destination: (req, file, cb) => {
  cb(null, uploadDir)
 }
})

function Mime(req, res, next){
 var pathObj = url.parse(req.url, true)
 var mimeType = mime.lookup(pathObj.pathname)
 console.log(mimeType)

 res.setHeader('content-type', mimeType)
 next()
}

FS.readFile(fileObj.path, (err, fileData) => {
       s3.putObject({
                 Bucket: CONFIG.awsConfig.bucket,
         Key: fileName,
         Body: fileData,
         ContentType: mime.lookup(fileName)
                }, (err, data) => {
                err ? reject(err): resolve(data);
        });
     });

function isVideo(file) {
  return (mime.lookup(file) || '').startsWith('video/')
}

private getCharSet() {
    let charset: false | string = mimeTypes.charset(
      this.getContentType()
    );
    if (false === charset) {
      charset = 'ascii';
    }
    charset = charset.toLowerCase()
      .split('-')
      .join('')
      .trim();

    return charset;
  }

multer({
  storage: multer.diskStorage({
    destination: path.join(__dirname, "../public/files/image"),
    filename: (req, file, cb)=>{
      crypto.pseudoRandomBytes(4, (err, raw)=>{
        const mimeType = mime.lookup(file.originalname);
        // throw away any extension if provided
        const nameSplit = file.originalname.split(".").slice(0, -1);
        // nameSplit.pop();

        // replace all white spaces with - for safe file name on different filesystem
        const name = nameSplit.join(".").replace(/\s/g, "-");
        cb(null, raw.toString("hex") + name + "." + mime.extension(mimeType));
      });
    },
  }),
})

basePath () {
    let name
    const purl = urlconv.parse( this.url )
    if ( purl.query && purl.query.includes( '=' ) && this.mimeType ) {
      const pathp = osPath.parse( purl.path )
      const ext = '.' + mimeTypes.extension( this.mimeType )
      name = pathp.base + ext
    } else {
      const pathp = osPath.parse( purl.pathname )
      name = pathp.name + pathp.ext.toLowerCase()
    }
    return sanitizeFN( decodeURIComponent( name ))
  }

fileInfoServices.service('type', function (path) {
  let type = String(mime.lookup(path.toString()))

  return type
 }, 'path')

_fetchThumbnailSupplier(file, options) {
    const mime = options.mimetype || mimetypes.lookup(file);
    let Supplier;

    if (!mime) {
      throw new E.UnknownFiletypeError(file, undefined, "Unable to probe mimetype from filename");
    }

    if (this._thumbSuppliers.has(mime)) {
      Supplier = this._thumbSuppliers.get(mime);
    } else if (this._thumbSuppliers.has(mime.replace(/(.+\/)(.+)/, "$1*"))) {
      // regex to replace application/json -> application/*
      Supplier = this._thumbSuppliers.get(mime.replace(/(.+\/)(.+)/, "$1*"));
    } else {
      throw new E.UnknownFiletypeError(file, mime, "FileType has no associated ThumbnailSupplier");
    }

    return new Supplier(options);
  }

function isAudio(file) {
  return (mime.lookup(file) || '').startsWith('audio/')
}

multer({
  storage: multer.diskStorage({
    destination: path.join(__dirname, "../public/files/image"),
    filename: (req, file, cb)=>{
      crypto.pseudoRandomBytes(4, (err, raw)=>{
        const mimeType = mime.lookup(file.originalname);
        // throw away any extension if provided
        const nameSplit = file.originalname.split(".").slice(0, -1);
        // nameSplit.pop();

        // replace all white spaces with - for safe file name on different filesystem
        const name = nameSplit.join(".").replace(/\s/g, "-");
        cb(null, raw.toString("hex") + name + "." + mime.extension(mimeType));
      });
    },
  }),
})

multer({
  storage: multer.diskStorage({
    destination: path.join(__dirname, 'files/'),
    filename: function (req, file, cb) {
      crypto.pseudoRandomBytes(4, function (err, raw) {
        const mime_type = mime.lookup(file.originalname);

        // throw away any extension if provided
        const nameSplit = file.originalname.split(".").slice(0,-1);
        //nameSplit.pop();

        // replace all white spaces with - for safe file name on different filesystem 
        const name = nameSplit.join(".").replace(/\s/g,'-');
        cb(null, raw.toString('hex') + name + '.' + mime.extension(mime_type));
      });
    }
  })
})

multer({
  storage: multer.diskStorage({
    destination: path.join(__dirname, "../public/files/image"),
    filename: (req, file, cb)=>{
      crypto.pseudoRandomBytes(4, (err, raw)=>{
        const mimeType = mime.lookup(file.originalname);
        // throw away any extension if provided
        const nameSplit = file.originalname.split(".").slice(0, -1);
        // nameSplit.pop();

        // replace all white spaces with - for safe file name on different filesystem
        const name = nameSplit.join(".").replace(/\s/g, "-");
        cb(null, raw.toString("hex") + name + "." + mime.extension(mimeType));
      });
    },
  }),
})