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

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

@@ -0,0 +1,43 @@
+const { obj2xml } = require('../utils/obj2xml');
+const { checkObjectTag } = require('../utils/checkObjectTag');
+
+const proto = exports;
+/**
+ * putObjectTagging
+ * @param {String} name - object name
+ * @param {Object} tag -  object tag, eg: `{a: "1", b: "2"}`
+ * @param {Object} options
+ */
+
+proto.putObjectTagging = async function putObjectTagging(name, tag, options = {}) {
+  checkObjectTag(tag);
+
+  options.subres = Object.assign({ tagging: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  name = this._objectName(name);
+  const params = this._objectRequestParams('PUT', name, options);
+  params.successStatuses = [200];
+  tag = Object.keys(tag).map(key => ({
+    Key: key,
+    Value: tag[key]
+  }));
+
+  const paramXMLObj = {
+    Tagging: {
+      TagSet: {
+        Tag: tag
+      }
+    }
+  };
+
+  params.mime = 'xml';
+  params.content = obj2xml(paramXMLObj);
+
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.status
+  };
+};

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

@@ -0,0 +1,33 @@
+const proto = exports;
+/**
+ * putSymlink
+ * @param {String} name - object name
+ * @param {String} targetName - target name
+ * @param {Object} options
+ * @param {{res}}
+ */
+
+proto.putSymlink = async function putSymlink(name, targetName, options) {
+  options = options || {};
+  options.headers = options.headers || {};
+  targetName = this._escape(this._objectName(targetName));
+  this._convertMetaToHeaders(options.meta, options.headers);
+  options.headers['x-oss-symlink-target'] = targetName;
+  options.subres = Object.assign({ symlink: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+
+  if (options.storageClass) {
+    options.headers['x-oss-storage-class'] = options.storageClass;
+  }
+
+  name = this._objectName(name);
+  const params = this._objectRequestParams('PUT', name, options);
+
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};

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

@@ -0,0 +1,52 @@
+const urlutil = require('url');
+const utility = require('utility');
+const copy = require('copy-to');
+const signHelper = require('../../common/signUtils');
+const { isIP } = require('../utils/isIP');
+
+const proto = exports;
+
+/**
+ *  signatureUrl
+ * @deprecated will be deprecated in 7.x
+ * @param {String} name object name
+ * @param {Object} options options
+ * @param {boolean} [strictObjectNameValidation=true] the flag of verifying object name strictly
+ */
+proto.signatureUrl = function signatureUrl(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) {
+    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/signatureUrlV4.js

@@ -0,0 +1,70 @@
+const dateFormat = require('dateformat');
+const urlUtil = require('url');
+
+const signHelper = require('../../common/signUtils');
+const { setSTSToken } = require('../utils/setSTSToken');
+const { isFunction } = require('../utils/isFunction');
+const { getStandardRegion } = require('../utils/getStandardRegion');
+
+const proto = exports;
+
+/**
+ * signatureUrlV4
+ *
+ * @param {string} method
+ * @param {number} expires
+ * @param {Object} [request]
+ * @param {Object} [request.headers]
+ * @param {Object} [request.queries]
+ * @param {string} [objectName]
+ * @param {string[]} [additionalHeaders]
+ */
+proto.signatureUrlV4 = async function signatureUrlV4(method, expires, request, objectName, additionalHeaders) {
+  const headers = (request && request.headers) || {};
+  const queries = { ...((request && request.queries) || {}) };
+  const date = new Date();
+  const formattedDate = dateFormat(date, "UTC:yyyymmdd'T'HHMMss'Z'");
+  const onlyDate = formattedDate.split('T')[0];
+  const fixedAdditionalHeaders = signHelper.fixAdditionalHeaders(additionalHeaders);
+  const region = getStandardRegion(this.options.region);
+
+  if (fixedAdditionalHeaders.length > 0) {
+    queries['x-oss-additional-headers'] = fixedAdditionalHeaders.join(';');
+  }
+  queries['x-oss-credential'] = `${this.options.accessKeyId}/${onlyDate}/${region}/oss/aliyun_v4_request`;
+  queries['x-oss-date'] = formattedDate;
+  queries['x-oss-expires'] = expires;
+  queries['x-oss-signature-version'] = 'OSS4-HMAC-SHA256';
+
+  if (this.options.stsToken && isFunction(this.options.refreshSTSToken)) {
+    await setSTSToken.call(this);
+  }
+
+  if (this.options.stsToken) {
+    queries['x-oss-security-token'] = this.options.stsToken;
+  }
+
+  const canonicalRequest = signHelper.getCanonicalRequest(
+    method,
+    {
+      headers,
+      queries
+    },
+    this.options.bucket,
+    objectName,
+    fixedAdditionalHeaders
+  );
+  const stringToSign = signHelper.getStringToSign(region, formattedDate, canonicalRequest);
+
+  queries['x-oss-signature'] = signHelper.getSignatureV4(this.options.accessKeySecret, onlyDate, region, stringToSign);
+
+  const signedUrl = urlUtil.parse(
+    this._getReqUrl({
+      bucket: this.options.bucket,
+      object: objectName
+    })
+  );
+  signedUrl.query = { ...queries };
+
+  return signedUrl.format();
+};

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

@@ -0,0 +1,177 @@
+const { isArray } = require('./utils/isArray');
+
+const proto = exports;
+
+proto._parallelNode = async function _parallelNode(todo, parallel, fn, sourceData) {
+  const that = this;
+  // upload in parallel
+  const jobErr = [];
+  let jobs = [];
+  const tempBatch = todo.length / parallel;
+  const remainder = todo.length % parallel;
+  const batch = remainder === 0 ? tempBatch : (todo.length - remainder) / parallel + 1;
+  let taskIndex = 1;
+  for (let i = 0; i < todo.length; i++) {
+    if (that.isCancel()) {
+      break;
+    }
+
+    if (sourceData) {
+      jobs.push(fn(that, todo[i], sourceData));
+    } else {
+      jobs.push(fn(that, todo[i]));
+    }
+
+    if (jobs.length === parallel || (taskIndex === batch && i === todo.length - 1)) {
+      try {
+        taskIndex += 1;
+        /* eslint no-await-in-loop: [0] */
+        await Promise.all(jobs);
+      } catch (err) {
+        jobErr.push(err);
+      }
+      jobs = [];
+    }
+  }
+
+  return jobErr;
+};
+
+proto._parallel = function _parallel(todo, parallel, jobPromise) {
+  const that = this;
+  return new Promise(resolve => {
+    const _jobErr = [];
+    if (parallel <= 0 || !todo) {
+      resolve(_jobErr);
+      return;
+    }
+
+    function onlyOnce(fn) {
+      return function (...args) {
+        if (fn === null) throw new Error('Callback was already called.');
+        const callFn = fn;
+        fn = null;
+        callFn.apply(this, args);
+      };
+    }
+
+    function createArrayIterator(coll) {
+      let i = -1;
+      const len = coll.length;
+      return function next() {
+        return ++i < len && !that.isCancel() ? { value: coll[i], key: i } : null;
+      };
+    }
+
+    const nextElem = createArrayIterator(todo);
+    let done = false;
+    let running = 0;
+    let looping = false;
+
+    function iterateeCallback(err) {
+      running -= 1;
+      if (err) {
+        done = true;
+        _jobErr.push(err);
+        resolve(_jobErr);
+      } else if (done && running <= 0) {
+        done = true;
+        resolve(_jobErr);
+      } else if (!looping) {
+        /* eslint no-use-before-define: [0] */
+        if (that.isCancel()) {
+          resolve(_jobErr);
+        } else {
+          replenish();
+        }
+      }
+    }
+
+    function iteratee(value, callback) {
+      jobPromise(value)
+        .then(result => {
+          callback(null, result);
+        })
+        .catch(err => {
+          callback(err);
+        });
+    }
+
+    function replenish() {
+      looping = true;
+      while (running < parallel && !done && !that.isCancel()) {
+        const elem = nextElem();
+        if (elem === null || _jobErr.length > 0) {
+          done = true;
+          if (running <= 0) {
+            resolve(_jobErr);
+          }
+          return;
+        }
+        running += 1;
+        iteratee(elem.value, onlyOnce(iterateeCallback));
+      }
+      looping = false;
+    }
+
+    replenish();
+  });
+};
+
+/**
+ * cancel operation, now can use with multipartUpload
+ * @param {Object} abort
+ *        {String} anort.name object key
+ *        {String} anort.uploadId upload id
+ *        {String} anort.options timeout
+ */
+proto.cancel = function cancel(abort) {
+  this.options.cancelFlag = true;
+
+  if (isArray(this.multipartUploadStreams)) {
+    this.multipartUploadStreams.forEach(_ => {
+      if (_.destroyed === false) {
+        const err = {
+          name: 'cancel',
+          message: 'cancel'
+        };
+        _.destroy(err);
+      }
+    });
+  }
+  this.multipartUploadStreams = [];
+  if (abort) {
+    this.abortMultipartUpload(abort.name, abort.uploadId, abort.options);
+  }
+};
+
+proto.isCancel = function isCancel() {
+  return this.options.cancelFlag;
+};
+
+proto.resetCancelFlag = function resetCancelFlag() {
+  this.options.cancelFlag = false;
+};
+
+proto._stop = function _stop() {
+  this.options.cancelFlag = true;
+};
+
+// cancel is not error , so create an object
+proto._makeCancelEvent = function _makeCancelEvent() {
+  const cancelEvent = {
+    status: 0,
+    name: 'cancel'
+  };
+  return cancelEvent;
+};
+
+// abort is not error , so create an object
+proto._makeAbortEvent = function _makeAbortEvent() {
+  const abortEvent = {
+    status: 0,
+    name: 'abort',
+    message: 'upload task has been abort'
+  };
+  return abortEvent;
+};