@strapi/provider-upload-local
Version:
Local provider for strapi upload
168 lines (161 loc) • 7.68 kB
JavaScript
;
var stream = require('stream');
var fs = require('fs');
var path = require('path');
var fse = require('fs-extra');
var utils = require('@strapi/utils');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var fs__default = /*#__PURE__*/_interopDefault(fs);
var path__default = /*#__PURE__*/_interopDefault(path);
var fse__default = /*#__PURE__*/_interopDefault(fse);
var utils__namespace = /*#__PURE__*/_interopNamespace(utils);
const { PayloadTooLargeError } = utils__namespace.errors;
const { kbytesToBytes, bytesToHumanReadable } = utils__namespace.file;
const UPLOADS_FOLDER_NAME = 'uploads';
var index = {
init ({ sizeLimit: providerOptionsSizeLimit } = {}) {
// TODO V5: remove providerOptions sizeLimit
if (providerOptionsSizeLimit) {
process.emitWarning('[deprecated] In future versions, "sizeLimit" argument will be ignored from upload.config.providerOptions. Move it to upload.config');
}
// Ensure uploads folder exists
const uploadPath = path__default.default.resolve(strapi.dirs.static.public, UPLOADS_FOLDER_NAME);
if (!fse__default.default.pathExistsSync(uploadPath)) {
throw new Error(`The upload folder (${uploadPath}) doesn't exist or is not accessible. Please make sure it exists.`);
}
return {
checkFileSize (file, options) {
const { sizeLimit } = options ?? {};
// TODO V5: remove providerOptions sizeLimit
if (providerOptionsSizeLimit) {
if (kbytesToBytes(file.size) > providerOptionsSizeLimit) throw new PayloadTooLargeError(`${file.name} exceeds size limit of ${bytesToHumanReadable(providerOptionsSizeLimit)}.`);
} else if (sizeLimit) {
if (kbytesToBytes(file.size) > sizeLimit) throw new PayloadTooLargeError(`${file.name} exceeds size limit of ${bytesToHumanReadable(sizeLimit)}.`);
}
},
uploadStream (file) {
if (!file.stream) {
return Promise.reject(new Error('Missing file stream'));
}
const { stream: stream$1 } = file;
return new Promise((resolve, reject)=>{
stream.pipeline(stream$1, fs__default.default.createWriteStream(path__default.default.join(uploadPath, `${file.hash}${file.ext}`)), (err)=>{
if (err) {
return reject(err);
}
file.url = `/${UPLOADS_FOLDER_NAME}/${file.hash}${file.ext}`;
resolve();
});
});
},
upload (file) {
if (!file.buffer) {
return Promise.reject(new Error('Missing file buffer'));
}
const { buffer } = file;
return new Promise((resolve, reject)=>{
// write file in public/assets folder
fs__default.default.writeFile(path__default.default.join(uploadPath, `${file.hash}${file.ext}`), buffer, (err)=>{
if (err) {
return reject(err);
}
file.url = `/${UPLOADS_FOLDER_NAME}/${file.hash}${file.ext}`;
resolve();
});
});
},
replaceStream (newFile, oldFile) {
if (!newFile.stream) {
return Promise.reject(new Error('Missing file stream'));
}
// If the destination path is unchanged, writing the new file overwrites
// the old one atomically. If the hash or extension changed, write the
// new file first then unlink the old one so we never leave a gap.
const newPath = path__default.default.join(uploadPath, `${newFile.hash}${newFile.ext}`);
const oldPath = path__default.default.join(uploadPath, `${oldFile.hash}${oldFile.ext}`);
const samePath = newPath === oldPath;
const { stream: stream$1 } = newFile;
return new Promise((resolve, reject)=>{
stream.pipeline(stream$1, fs__default.default.createWriteStream(newPath), (err)=>{
if (err) {
return reject(err);
}
newFile.url = `/${UPLOADS_FOLDER_NAME}/${newFile.hash}${newFile.ext}`;
if (!samePath && fs__default.default.existsSync(oldPath)) {
fs__default.default.unlink(oldPath, (unlinkErr)=>{
if (unlinkErr) {
return reject(unlinkErr);
}
resolve();
});
return;
}
resolve();
});
});
},
replace (newFile, oldFile) {
if (!newFile.buffer) {
return Promise.reject(new Error('Missing file buffer'));
}
const newPath = path__default.default.join(uploadPath, `${newFile.hash}${newFile.ext}`);
const oldPath = path__default.default.join(uploadPath, `${oldFile.hash}${oldFile.ext}`);
const samePath = newPath === oldPath;
const { buffer } = newFile;
return new Promise((resolve, reject)=>{
fs__default.default.writeFile(newPath, buffer, (err)=>{
if (err) {
return reject(err);
}
newFile.url = `/${UPLOADS_FOLDER_NAME}/${newFile.hash}${newFile.ext}`;
if (!samePath && fs__default.default.existsSync(oldPath)) {
fs__default.default.unlink(oldPath, (unlinkErr)=>{
if (unlinkErr) {
return reject(unlinkErr);
}
resolve();
});
return;
}
resolve();
});
});
},
delete (file) {
return new Promise((resolve, reject)=>{
const filePath = path__default.default.join(uploadPath, `${file.hash}${file.ext}`);
if (!fs__default.default.existsSync(filePath)) {
resolve("File doesn't exist");
return;
}
// remove file from public/assets folder
fs__default.default.unlink(filePath, (err)=>{
if (err) {
return reject(err);
}
resolve();
});
});
}
};
}
};
module.exports = index;
//# sourceMappingURL=index.js.map