@nocobase/plugin-file-manager 2.0.0-alpha.9 → 2.0.0-beta.2

package/dist/node_modules/ali-oss/lib/common/multipart-copy.js

@@ -0,0 +1,240 @@
+/* eslint-disable no-async-promise-executor */
+
+const debug = require('debug')('ali-oss:multipart-copy');
+const copy = require('copy-to');
+
+const proto = exports;
+
+/**
+ * Upload a part copy in a multipart from the source bucket/object
+ * used with initMultipartUpload and completeMultipartUpload.
+ * @param {String} name copy object name
+ * @param {String} uploadId the upload id
+ * @param {Number} partNo the part number
+ * @param {String} range  like 0-102400  part size need to copy
+ * @param {Object} sourceData
+ *        {String} sourceData.sourceKey  the source object name
+ *        {String} sourceData.sourceBucketName  the source bucket name
+ * @param {Object} options
+ */
+/* eslint max-len: [0] */
+proto.uploadPartCopy = async function uploadPartCopy(name, uploadId, partNo, range, sourceData, options = {}) {
+  options.headers = options.headers || {};
+  const versionId = options.versionId || (options.subres && options.subres.versionId) || null;
+  let copySource;
+  if (versionId) {
+    copySource = `/${sourceData.sourceBucketName}/${encodeURIComponent(sourceData.sourceKey)}?versionId=${versionId}`;
+  } else {
+    copySource = `/${sourceData.sourceBucketName}/${encodeURIComponent(sourceData.sourceKey)}`;
+  }
+
+  options.headers['x-oss-copy-source'] = copySource;
+  if (range) {
+    options.headers['x-oss-copy-source-range'] = `bytes=${range}`;
+  }
+
+  options.subres = {
+    partNumber: partNo,
+    uploadId
+  };
+  const params = this._objectRequestParams('PUT', name, options);
+  params.mime = options.mime;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    name,
+    etag: result.res.headers.etag,
+    res: result.res
+  };
+};
+
+/**
+ * @param {String} name copy object name
+ * @param {Object} sourceData
+ *        {String} sourceData.sourceKey  the source object name
+ *        {String} sourceData.sourceBucketName  the source bucket name
+ *        {Number} sourceData.startOffset  data copy start byte offset, e.g: 0
+ *        {Number} sourceData.endOffset  data copy end byte offset, e.g: 102400
+ * @param {Object} options
+ *        {Number} options.partSize
+ */
+proto.multipartUploadCopy = async function multipartUploadCopy(name, sourceData, options = {}) {
+  this.resetCancelFlag();
+  const { versionId = null } = options;
+  const metaOpt = {
+    versionId
+  };
+  const objectMeta = await this._getObjectMeta(sourceData.sourceBucketName, sourceData.sourceKey, metaOpt);
+  const fileSize = objectMeta.res.headers['content-length'];
+  sourceData.startOffset = sourceData.startOffset || 0;
+  sourceData.endOffset = sourceData.endOffset || fileSize;
+
+  if (options.checkpoint && options.checkpoint.uploadId) {
+    return await this._resumeMultipartCopy(options.checkpoint, sourceData, options);
+  }
+
+  const minPartSize = 100 * 1024;
+
+  const copySize = sourceData.endOffset - sourceData.startOffset;
+  if (copySize < minPartSize) {
+    throw new Error(`copySize must not be smaller than ${minPartSize}`);
+  }
+
+  if (options.partSize && options.partSize < minPartSize) {
+    throw new Error(`partSize must not be smaller than ${minPartSize}`);
+  }
+
+  const init = await this.initMultipartUpload(name, options);
+  const { uploadId } = init;
+  const partSize = this._getPartSize(copySize, options.partSize);
+
+  const checkpoint = {
+    name,
+    copySize,
+    partSize,
+    uploadId,
+    doneParts: []
+  };
+
+  if (options && options.progress) {
+    await options.progress(0, checkpoint, init.res);
+  }
+
+  return await this._resumeMultipartCopy(checkpoint, sourceData, options);
+};
+
+/*
+ * Resume multipart copy from checkpoint. The checkpoint will be
+ * updated after each successful part copy.
+ * @param {Object} checkpoint the checkpoint
+ * @param {Object} options
+ */
+proto._resumeMultipartCopy = async function _resumeMultipartCopy(checkpoint, sourceData, options) {
+  if (this.isCancel()) {
+    throw this._makeCancelEvent();
+  }
+  const { versionId = null } = options;
+  const metaOpt = {
+    versionId
+  };
+  const { copySize, partSize, uploadId, doneParts, name } = checkpoint;
+
+  const partOffs = this._divideMultipartCopyParts(copySize, partSize, sourceData.startOffset);
+  const numParts = partOffs.length;
+
+  const uploadPartCopyOptions = {
+    headers: {}
+  };
+
+  if (options.copyheaders) {
+    copy(options.copyheaders).to(uploadPartCopyOptions.headers);
+  }
+  if (versionId) {
+    copy(metaOpt).to(uploadPartCopyOptions);
+  }
+
+  const uploadPartJob = function uploadPartJob(self, partNo, source) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!self.isCancel()) {
+          const pi = partOffs[partNo - 1];
+          const range = `${pi.start}-${pi.end - 1}`;
+
+          let result;
+          try {
+            result = await self.uploadPartCopy(name, uploadId, partNo, range, source, uploadPartCopyOptions);
+          } catch (error) {
+            if (error.status === 404) {
+              throw self._makeAbortEvent();
+            }
+            throw error;
+          }
+          if (!self.isCancel()) {
+            debug(`content-range ${result.res.headers['content-range']}`);
+            doneParts.push({
+              number: partNo,
+              etag: result.res.headers.etag
+            });
+            checkpoint.doneParts = doneParts;
+
+            if (options && options.progress) {
+              await options.progress(doneParts.length / numParts, checkpoint, result.res);
+            }
+          }
+        }
+        resolve();
+      } catch (err) {
+        err.partNum = partNo;
+        reject(err);
+      }
+    });
+  };
+
+  const all = Array.from(new Array(numParts), (x, i) => i + 1);
+  const done = doneParts.map(p => p.number);
+  const todo = all.filter(p => done.indexOf(p) < 0);
+  const defaultParallel = 5;
+  const parallel = options.parallel || defaultParallel;
+
+  if (this.checkBrowserAndVersion('Internet Explorer', '10') || parallel === 1) {
+    for (let i = 0; i < todo.length; i++) {
+      if (this.isCancel()) {
+        throw this._makeCancelEvent();
+      }
+      /* eslint no-await-in-loop: [0] */
+      await uploadPartJob(this, todo[i], sourceData);
+    }
+  } else {
+    // upload in parallel
+    const errors = await this._parallelNode(todo, parallel, uploadPartJob, sourceData);
+
+    const abortEvent = errors.find(err => err.name === 'abort');
+    if (abortEvent) throw abortEvent;
+
+    if (this.isCancel()) {
+      throw this._makeCancelEvent();
+    }
+
+    // check errors after all jobs are completed
+    if (errors && errors.length > 0) {
+      const err = errors[0];
+      err.message = `Failed to copy some parts with error: ${err.toString()} part_num: ${err.partNum}`;
+      throw err;
+    }
+  }
+
+  return await this.completeMultipartUpload(name, uploadId, doneParts, options);
+};
+
+proto._divideMultipartCopyParts = function _divideMultipartCopyParts(fileSize, partSize, startOffset) {
+  const numParts = Math.ceil(fileSize / partSize);
+
+  const partOffs = [];
+  for (let i = 0; i < numParts; i++) {
+    const start = partSize * i + startOffset;
+    const end = Math.min(start + partSize, fileSize + startOffset);
+
+    partOffs.push({
+      start,
+      end
+    });
+  }
+
+  return partOffs;
+};
+
+/**
+ * Get Object Meta
+ * @param {String} bucket  bucket name
+ * @param {String} name   object name
+ * @param {Object} options
+ */
+proto._getObjectMeta = async function _getObjectMeta(bucket, name, options) {
+  const currentBucket = this.getBucket();
+  this.setBucket(bucket);
+  const data = await this.head(name, options);
+  this.setBucket(currentBucket);
+  return data;
+};

package/dist/node_modules/ali-oss/lib/common/multipart.js

@@ -0,0 +1,271 @@
+const copy = require('copy-to');
+const callback = require('./callback');
+const { deepCopyWith } = require('./utils/deepCopy');
+const { isBuffer } = require('./utils/isBuffer');
+const { omit } = require('./utils/omit');
+
+const proto = exports;
+
+/**
+ * List the on-going multipart uploads
+ * https://help.aliyun.com/document_detail/31997.html
+ * @param {Object} options
+ * @return {Array} the multipart uploads
+ */
+proto.listUploads = async function listUploads(query, options) {
+  options = options || {};
+  const opt = {};
+  copy(options).to(opt);
+  opt.subres = 'uploads';
+  const params = this._objectRequestParams('GET', '', opt);
+  params.query = query;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+  let uploads = result.data.Upload || [];
+  if (!Array.isArray(uploads)) {
+    uploads = [uploads];
+  }
+  uploads = uploads.map(up => ({
+    name: up.Key,
+    uploadId: up.UploadId,
+    initiated: up.Initiated
+  }));
+
+  return {
+    res: result.res,
+    uploads,
+    bucket: result.data.Bucket,
+    nextKeyMarker: result.data.NextKeyMarker,
+    nextUploadIdMarker: result.data.NextUploadIdMarker,
+    isTruncated: result.data.IsTruncated === 'true'
+  };
+};
+
+/**
+ * List the done uploadPart parts
+ * @param {String} name object name
+ * @param {String} uploadId multipart upload id
+ * @param {Object} query
+ * {Number} query.max-parts The maximum part number in the response of the OSS. Default value: 1000
+ * {Number} query.part-number-marker Starting position of a specific list.
+ * {String} query.encoding-type Specify the encoding of the returned content and the encoding type.
+ * @param {Object} options
+ * @return {Object} result
+ */
+proto.listParts = async function listParts(name, uploadId, query, options) {
+  options = options || {};
+  const opt = {};
+  copy(options).to(opt);
+  opt.subres = {
+    uploadId
+  };
+  const params = this._objectRequestParams('GET', name, opt);
+  params.query = query;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res,
+    uploadId: result.data.UploadId,
+    bucket: result.data.Bucket,
+    name: result.data.Key,
+    partNumberMarker: result.data.PartNumberMarker,
+    nextPartNumberMarker: result.data.NextPartNumberMarker,
+    maxParts: result.data.MaxParts,
+    isTruncated: result.data.IsTruncated,
+    parts: result.data.Part || []
+  };
+};
+
+/**
+ * Abort a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Object} options
+ */
+proto.abortMultipartUpload = async function abortMultipartUpload(name, uploadId, options) {
+  this._stop();
+  options = options || {};
+  const opt = {};
+  copy(options).to(opt);
+  opt.subres = { uploadId };
+  const params = this._objectRequestParams('DELETE', name, opt);
+  params.successStatuses = [204];
+
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};
+
+/**
+ * Initiate a multipart upload transaction
+ * @param {String} name the object name
+ * @param {Object} options
+ * @return {String} upload id
+ */
+proto.initMultipartUpload = async function initMultipartUpload(name, options) {
+  options = options || {};
+  const opt = {};
+  copy(options).to(opt);
+  opt.headers = opt.headers || {};
+  this._convertMetaToHeaders(options.meta, opt.headers);
+
+  opt.subres = 'uploads';
+  const params = this._objectRequestParams('POST', name, opt);
+  params.mime = options.mime;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res,
+    bucket: result.data.Bucket,
+    name: result.data.Key,
+    uploadId: result.data.UploadId
+  };
+};
+
+/**
+ * Upload a part in a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Integer} partNo the part number
+ * @param {File} file upload File, whole File
+ * @param {Integer} start  part start bytes  e.g: 102400
+ * @param {Integer} end  part end bytes  e.g: 204800
+ * @param {Object} options
+ */
+proto.uploadPart = async function uploadPart(name, uploadId, partNo, file, start, end, options) {
+  const data = {
+    size: end - start
+  };
+  const isBrowserEnv = process && process.browser;
+  isBrowserEnv
+    ? (data.content = await this._createBuffer(file, start, end))
+    : (data.stream = await this._createStream(file, start, end));
+  return await this._uploadPart(name, uploadId, partNo, data, options);
+};
+
+/**
+ * Complete a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Array} parts the uploaded parts, each in the structure:
+ *        {Integer} number partNo
+ *        {String} etag  part etag  uploadPartCopy result.res.header.etag
+ * @param {Object} options
+ *         {Object} options.callback The callback parameter is composed of a JSON string encoded in Base64
+ *         {String} options.callback.url  the OSS sends a callback request to this URL
+ *         {String} options.callback.host  The host header value for initiating callback requests
+ *         {String} options.callback.body  The value of the request body when a callback is initiated
+ *         {String} options.callback.contentType  The Content-Type of the callback requests initiatiated
+ *         {Object} options.callback.customValue  Custom parameters are a map of key-values, e.g:
+ *                   customValue = {
+ *                     key1: 'value1',
+ *                     key2: 'value2'
+ *                   }
+ */
+proto.completeMultipartUpload = async function completeMultipartUpload(name, uploadId, parts, options) {
+  const completeParts = parts
+    .concat()
+    .sort((a, b) => a.number - b.number)
+    .filter((item, index, arr) => !index || item.number !== arr[index - 1].number);
+  let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<CompleteMultipartUpload>\n';
+  for (let i = 0; i < completeParts.length; i++) {
+    const p = completeParts[i];
+    xml += '<Part>\n';
+    xml += `<PartNumber>${p.number}</PartNumber>\n`;
+    xml += `<ETag>${p.etag}</ETag>\n`;
+    xml += '</Part>\n';
+  }
+  xml += '</CompleteMultipartUpload>';
+
+  options = options || {};
+  let opt = {};
+  opt = deepCopyWith(options, _ => {
+    if (isBuffer(_)) return null;
+  });
+  opt.subres = { uploadId };
+  opt.headers = omit(opt.headers, ['x-oss-server-side-encryption', 'x-oss-storage-class']);
+
+  const params = this._objectRequestParams('POST', name, opt);
+  callback.encodeCallback(params, opt);
+  params.mime = 'xml';
+  params.content = xml;
+
+  if (!(params.headers && params.headers['x-oss-callback'])) {
+    params.xmlResponse = true;
+  }
+  params.successStatuses = [200];
+  const result = await this.request(params);
+
+  if (options.progress) {
+    await options.progress(1, null, result.res);
+  }
+
+  const ret = {
+    res: result.res,
+    bucket: params.bucket,
+    name,
+    etag: result.res.headers.etag
+  };
+
+  if (params.headers && params.headers['x-oss-callback']) {
+    ret.data = JSON.parse(result.data.toString());
+  }
+
+  return ret;
+};
+
+/**
+ * Upload a part in a multipart upload transaction
+ * @param {String} name the object name
+ * @param {String} uploadId the upload id
+ * @param {Integer} partNo the part number
+ * @param {Object} data the body data
+ * @param {Object} options
+ */
+proto._uploadPart = async function _uploadPart(name, uploadId, partNo, data, options) {
+  options = options || {};
+  const opt = {};
+  copy(options).to(opt);
+  opt.headers = opt.headers || {};
+  opt.headers['Content-Length'] = data.size;
+
+  // Uploading shards does not require x-oss server side encryption
+  opt.headers = omit(opt.headers, ['x-oss-server-side-encryption']);
+  opt.subres = {
+    partNumber: partNo,
+    uploadId
+  };
+
+  const params = this._objectRequestParams('PUT', name, opt);
+  params.mime = opt.mime;
+  const isBrowserEnv = process && process.browser;
+  isBrowserEnv ? (params.content = data.content) : (params.stream = data.stream);
+  params.successStatuses = [200];
+  params.disabledMD5 = options.disabledMD5;
+
+  const result = await this.request(params);
+
+  if (!result.res.headers.etag) {
+    throw new Error(
+      'Please set the etag of expose-headers in OSS \n https://help.aliyun.com/document_detail/32069.html'
+    );
+  }
+  if (data.stream) {
+    data.stream = null;
+    params.stream = null;
+  }
+  return {
+    name,
+    etag: result.res.headers.etag,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/object/asyncSignatureUrl.js

@@ -0,0 +1,57 @@
+const urlutil = require('url');
+const utility = require('utility');
+const copy = require('copy-to');
+const signHelper = require('../../common/signUtils');
+const { isIP } = require('../utils/isIP');
+const { setSTSToken } = require('../utils/setSTSToken');
+const { isFunction } = require('../utils/isFunction');
+
+const proto = exports;
+
+/**
+ * asyncSignatureUrl
+ * @param {String} name object name
+ * @param {Object} options options
+ * @param {boolean} [strictObjectNameValidation=true] the flag of verifying object name strictly
+ */
+proto.asyncSignatureUrl = async function asyncSignatureUrl(name, options, strictObjectNameValidation = true) {
+  if (isIP(this.options.endpoint.hostname)) {
+    throw new Error('can not get the object URL when endpoint is IP');
+  }
+
+  if (strictObjectNameValidation && /^\?/.test(name)) {
+    throw new Error(`Invalid object name ${name}`);
+  }
+
+  options = options || {};
+  name = this._objectName(name);
+  options.method = options.method || 'GET';
+  const expires = utility.timestamp() + (options.expires || 1800);
+  const params = {
+    bucket: this.options.bucket,
+    object: name
+  };
+
+  const resource = this._getResource(params);
+
+  if (this.options.stsToken && isFunction(this.options.refreshSTSToken)) {
+    await setSTSToken.call(this);
+  }
+
+  if (this.options.stsToken) {
+    options['security-token'] = this.options.stsToken;
+  }
+
+  const signRes = signHelper._signatureForURL(this.options.accessKeySecret, options, resource, expires);
+
+  const url = urlutil.parse(this._getReqUrl(params));
+  url.query = {
+    OSSAccessKeyId: this.options.accessKeyId,
+    Expires: expires,
+    Signature: signRes.Signature
+  };
+
+  copy(signRes.subResource).to(url.query);
+
+  return url.format();
+};

package/dist/node_modules/ali-oss/lib/common/object/calculatePostSignature.js

@@ -0,0 +1,35 @@
+const { policy2Str } = require('../utils/policy2Str');
+const signHelper = require('../signUtils');
+const { isObject } = require('../utils/isObject');
+
+const proto = exports;
+
+/**
+ * @param {Object or JSON} policy specifies the validity of the fields in the request.
+ * @return {Object} params
+ *         {String} params.OSSAccessKeyId
+ *         {String} params.Signature
+ *         {String} params.policy JSON text encoded with UTF-8 and Base64.
+ */
+proto.calculatePostSignature = function calculatePostSignature(policy) {
+  if (!isObject(policy) && typeof policy !== 'string') {
+    throw new Error('policy must be JSON string or Object');
+  }
+  if (!isObject(policy)) {
+    try {
+      JSON.stringify(JSON.parse(policy));
+    } catch (error) {
+      throw new Error('policy must be JSON string or Object');
+    }
+  }
+  policy = Buffer.from(policy2Str(policy), 'utf8').toString('base64');
+
+  const Signature = signHelper.computeSignature(this.options.accessKeySecret, policy);
+
+  const query = {
+    OSSAccessKeyId: this.options.accessKeyId,
+    Signature,
+    policy
+  };
+  return query;
+};

package/dist/node_modules/ali-oss/lib/common/object/copyObject.js

@@ -0,0 +1,74 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+
+const REPLACE_HEDERS = [
+  'content-type',
+  'content-encoding',
+  'content-language',
+  'content-disposition',
+  'cache-control',
+  'expires'
+];
+
+proto.copy = async function copy(name, sourceName, bucketName, options) {
+  if (typeof bucketName === 'object') {
+    options = bucketName; // 兼容旧版本，旧版本第三个参数为options
+  }
+  options = options || {};
+  options.headers = options.headers || {};
+
+  Object.keys(options.headers).forEach(key => {
+    options.headers[`x-oss-copy-source-${key.toLowerCase()}`] = options.headers[key];
+  });
+  if (options.meta || Object.keys(options.headers).find(_ => REPLACE_HEDERS.includes(_.toLowerCase()))) {
+    options.headers['x-oss-metadata-directive'] = 'REPLACE';
+  }
+  this._convertMetaToHeaders(options.meta, options.headers);
+
+  sourceName = this._getSourceName(sourceName, bucketName);
+
+  if (options.versionId) {
+    sourceName = `${sourceName}?versionId=${options.versionId}`;
+  }
+
+  options.headers['x-oss-copy-source'] = sourceName;
+
+  const params = this._objectRequestParams('PUT', name, options);
+  params.xmlResponse = true;
+  params.successStatuses = [200, 304];
+
+  const result = await this.request(params);
+
+  let { data } = result;
+  if (data) {
+    data = {
+      etag: data.ETag,
+      lastModified: data.LastModified
+    };
+  }
+
+  return {
+    data,
+    res: result.res
+  };
+};
+
+// todo delete
+proto._getSourceName = function _getSourceName(sourceName, bucketName) {
+  if (typeof bucketName === 'string') {
+    sourceName = this._objectName(sourceName);
+  } else if (sourceName[0] !== '/') {
+    bucketName = this.options.bucket;
+  } else {
+    bucketName = sourceName.replace(/\/(.+?)(\/.*)/, '$1');
+    sourceName = sourceName.replace(/(\/.+?\/)(.*)/, '$2');
+  }
+
+  _checkBucketName(bucketName);
+
+  sourceName = encodeURIComponent(sourceName);
+
+  sourceName = `/${bucketName}/${sourceName}`;
+  return sourceName;
+};

package/dist/node_modules/ali-oss/lib/common/object/delete.js

@@ -0,0 +1,22 @@
+const proto = exports;
+/**
+ * delete
+ * @param {String} name - object name
+ * @param {Object} options
+ * @param {{res}}
+ */
+
+proto.delete = async function _delete(name, options = {}) {
+  options.subres = Object.assign({}, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('DELETE', name, options);
+  params.successStatuses = [204];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};