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

package/dist/node_modules/ali-oss/lib/cluster.js

@@ -0,0 +1,228 @@
+const Base = require('sdk-base');
+const util = require('util');
+const ready = require('get-ready');
+const copy = require('copy-to');
+const currentIP = require('address').ip();
+
+const RR = 'roundRobin';
+const MS = 'masterSlave';
+
+module.exports = function (OssClient) {
+  function Client(options) {
+    if (!(this instanceof Client)) {
+      return new Client(options);
+    }
+
+    if (!options || !Array.isArray(options.cluster)) {
+      throw new Error('require options.cluster to be an array');
+    }
+
+    Base.call(this);
+
+    this.clients = [];
+    this.availables = {};
+
+    for (let i = 0; i < options.cluster.length; i++) {
+      const opt = options.cluster[i];
+      copy(options).pick('timeout', 'agent', 'urllib').to(opt);
+      this.clients.push(new OssClient(opt));
+      this.availables[i] = true;
+    }
+
+    this.schedule = options.schedule || RR;
+    // only read from master, default is false
+    this.masterOnly = !!options.masterOnly;
+    this.index = 0;
+
+    const heartbeatInterval = options.heartbeatInterval || 10000;
+    this._checkAvailableLock = false;
+    this._timerId = this._deferInterval(this._checkAvailable.bind(this, true), heartbeatInterval);
+    this._ignoreStatusFile = options.ignoreStatusFile || false;
+    this._init();
+  }
+
+  util.inherits(Client, Base);
+  const proto = Client.prototype;
+  ready.mixin(proto);
+
+  const GET_METHODS = ['head', 'get', 'getStream', 'list', 'getACL'];
+
+  const PUT_METHODS = ['put', 'putStream', 'delete', 'deleteMulti', 'copy', 'putMeta', 'putACL'];
+
+  GET_METHODS.forEach(method => {
+    proto[method] = async function (...args) {
+      const client = this.chooseAvailable();
+      let lastError;
+      try {
+        return await client[method](...args);
+      } catch (err) {
+        if (err.status && err.status >= 200 && err.status < 500) {
+          // 200 ~ 499 belong to normal response, don't try again
+          throw err;
+        }
+        // < 200 || >= 500 need to retry from other cluser node
+        lastError = err;
+      }
+
+      for (let i = 0; i < this.clients.length; i++) {
+        const c = this.clients[i];
+        if (c !== client) {
+          try {
+            return await c[method].apply(client, args);
+          } catch (err) {
+            if (err.status && err.status >= 200 && err.status < 500) {
+              // 200 ~ 499 belong to normal response, don't try again
+              throw err;
+            }
+            // < 200 || >= 500 need to retry from other cluser node
+            lastError = err;
+          }
+        }
+      }
+
+      lastError.message += ' (all clients are down)';
+      throw lastError;
+    };
+  });
+
+  // must cluster node write success
+  PUT_METHODS.forEach(method => {
+    proto[method] = async function (...args) {
+      const res = await Promise.all(this.clients.map(client => client[method](...args)));
+      return res[0];
+    };
+  });
+
+  proto.signatureUrl = function signatureUrl(/* name */ ...args) {
+    const client = this.chooseAvailable();
+    return client.signatureUrl(...args);
+  };
+
+  proto.getObjectUrl = function getObjectUrl(/* name, baseUrl */ ...args) {
+    const client = this.chooseAvailable();
+    return client.getObjectUrl(...args);
+  };
+
+  proto._init = function _init() {
+    const that = this;
+    (async () => {
+      await that._checkAvailable(that._ignoreStatusFile);
+      that.ready(true);
+    })().catch(err => {
+      that.emit('error', err);
+    });
+  };
+
+  proto._checkAvailable = async function _checkAvailable(ignoreStatusFile) {
+    const name = `._ali-oss/check.status.${currentIP}.txt`;
+    if (!ignoreStatusFile) {
+      // only start will try to write the file
+      await this.put(name, Buffer.from(`check available started at ${Date()}`));
+    }
+
+    if (this._checkAvailableLock) {
+      return;
+    }
+    this._checkAvailableLock = true;
+    const downStatusFiles = [];
+    for (let i = 0; i < this.clients.length; i++) {
+      const client = this.clients[i];
+      // check 3 times
+      let available = await this._checkStatus(client, name);
+      if (!available) {
+        // check again
+        available = await this._checkStatus(client, name);
+      }
+      if (!available) {
+        // check again
+        /* eslint no-await-in-loop: [0] */
+        available = await this._checkStatus(client, name);
+        if (!available) {
+          downStatusFiles.push(client._objectUrl(name));
+        }
+      }
+      this.availables[i] = available;
+    }
+    this._checkAvailableLock = false;
+
+    if (downStatusFiles.length > 0) {
+      const err = new Error(
+        `${downStatusFiles.length} data node down, please check status file: ${downStatusFiles.join(', ')}`
+      );
+      err.name = 'CheckAvailableError';
+      this.emit('error', err);
+    }
+  };
+
+  proto._checkStatus = async function _checkStatus(client, name) {
+    let available = true;
+    try {
+      await client.head(name);
+    } catch (err) {
+      // 404 will be available too
+      if (!err.status || err.status >= 500 || err.status < 200) {
+        available = false;
+      }
+    }
+    return available;
+  };
+
+  proto.chooseAvailable = function chooseAvailable() {
+    if (this.schedule === MS) {
+      // only read from master
+      if (this.masterOnly) {
+        return this.clients[0];
+      }
+      for (let i = 0; i < this.clients.length; i++) {
+        if (this.availables[i]) {
+          return this.clients[i];
+        }
+      }
+      // all down, try to use this first one
+      return this.clients[0];
+    }
+
+    // RR
+    let n = this.clients.length;
+    while (n > 0) {
+      const i = this._nextRRIndex();
+      if (this.availables[i]) {
+        return this.clients[i];
+      }
+      n--;
+    }
+    // all down, try to use this first one
+    return this.clients[0];
+  };
+
+  proto._nextRRIndex = function _nextRRIndex() {
+    const index = this.index++;
+    if (this.index >= this.clients.length) {
+      this.index = 0;
+    }
+    return index;
+  };
+
+  proto._error = function error(err) {
+    if (err) throw err;
+  };
+
+  proto._createCallback = function _createCallback(ctx, gen, cb) {
+    return () => {
+      cb = cb || this._error;
+      gen.call(ctx).then(() => {
+        cb();
+      }, cb);
+    };
+  };
+  proto._deferInterval = function _deferInterval(gen, timeout, cb) {
+    return setInterval(this._createCallback(this, gen, cb), timeout);
+  };
+
+  proto.close = function close() {
+    clearInterval(this._timerId);
+    this._timerId = null;
+  };
+
+  return Client;
+};

package/dist/node_modules/ali-oss/lib/common/bucket/abortBucketWorm.d.ts

@@ -0,0 +1,4 @@
+export declare function abortBucketWorm(this: any, name: string, options: any): Promise<{
+    res: any;
+    status: any;
+}>;

package/dist/node_modules/ali-oss/lib/common/bucket/abortBucketWorm.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortBucketWorm = void 0;
+const checkBucketName_1 = require("../utils/checkBucketName");
+async function abortBucketWorm(name, options) {
+    checkBucketName_1.checkBucketName(name);
+    const params = this._bucketRequestParams('DELETE', name, 'worm', options);
+    const result = await this.request(params);
+    return {
+        res: result.res,
+        status: result.status
+    };
+}
+exports.abortBucketWorm = abortBucketWorm;

package/dist/node_modules/ali-oss/lib/common/bucket/abortBucketWorm.ts

@@ -0,0 +1,12 @@
+import { checkBucketName } from '../utils/checkBucketName';
+
+export async function abortBucketWorm(this: any, name: string, options) {
+  checkBucketName(name);
+  const params = this._bucketRequestParams('DELETE', name, 'worm', options);
+
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.status
+  };
+}

package/dist/node_modules/ali-oss/lib/common/bucket/completeBucketWorm.d.ts

@@ -0,0 +1,4 @@
+export declare function completeBucketWorm(this: any, name: string, wormId: string, options: any): Promise<{
+    res: any;
+    status: any;
+}>;

package/dist/node_modules/ali-oss/lib/common/bucket/completeBucketWorm.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeBucketWorm = void 0;
+const checkBucketName_1 = require("../utils/checkBucketName");
+async function completeBucketWorm(name, wormId, options) {
+    checkBucketName_1.checkBucketName(name);
+    const params = this._bucketRequestParams('POST', name, { wormId }, options);
+    const result = await this.request(params);
+    return {
+        res: result.res,
+        status: result.status
+    };
+}
+exports.completeBucketWorm = completeBucketWorm;

package/dist/node_modules/ali-oss/lib/common/bucket/completeBucketWorm.ts

@@ -0,0 +1,12 @@
+import { checkBucketName } from '../utils/checkBucketName';
+
+export async function completeBucketWorm(this: any, name: string, wormId: string, options) {
+  checkBucketName(name);
+  const params = this._bucketRequestParams('POST', name, { wormId }, options);
+
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.status
+  };
+}

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketEncryption.js

@@ -0,0 +1,20 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+// const jstoxml = require('jstoxml');
+/**
+ * deleteBucketEncryption
+ * @param {String} bucketName - bucket name
+ */
+
+proto.deleteBucketEncryption = async function deleteBucketEncryption(bucketName) {
+  _checkBucketName(bucketName);
+  const params = this._bucketRequestParams('DELETE', bucketName, 'encryption');
+  params.successStatuses = [204];
+  params.xmlResponse = true;
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketInventory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * deleteBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+export declare function deleteBucketInventory(this: any, bucketName: string, inventoryId: string, options?: any): Promise<{
+    status: any;
+    res: any;
+}>;

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketInventory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBucketInventory = void 0;
+const checkBucketName_1 = require("../utils/checkBucketName");
+/**
+ * deleteBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+async function deleteBucketInventory(bucketName, inventoryId, options = {}) {
+    const subres = Object.assign({ inventory: '', inventoryId }, options.subres);
+    checkBucketName_1.checkBucketName(bucketName);
+    const params = this._bucketRequestParams('DELETE', bucketName, subres, options);
+    params.successStatuses = [204];
+    const result = await this.request(params);
+    return {
+        status: result.status,
+        res: result.res
+    };
+}
+exports.deleteBucketInventory = deleteBucketInventory;

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketInventory.ts

@@ -0,0 +1,21 @@
+import { checkBucketName } from '../utils/checkBucketName';
+/**
+ * deleteBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+
+export async function deleteBucketInventory(this: any, bucketName: string, inventoryId: string, options: any = {}) {
+  const subres: any = Object.assign({ inventory: '', inventoryId }, options.subres);
+  checkBucketName(bucketName);
+
+  const params = this._bucketRequestParams('DELETE', bucketName, subres, options);
+  params.successStatuses = [204];
+
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res
+  };
+}

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketLifecycle.js

@@ -0,0 +1,13 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+
+proto.deleteBucketLifecycle = async function deleteBucketLifecycle(name, options) {
+  _checkBucketName(name);
+  const params = this._bucketRequestParams('DELETE', name, 'lifecycle', options);
+  params.successStatuses = [204];
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketPolicy.js

@@ -0,0 +1,21 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+/**
+ * deleteBucketPolicy
+ * @param {String} bucketName - bucket name
+ * @param {Object} options
+ */
+
+proto.deleteBucketPolicy = async function deleteBucketPolicy(bucketName, options = {}) {
+  _checkBucketName(bucketName);
+
+  const params = this._bucketRequestParams('DELETE', bucketName, 'policy', options);
+  params.successStatuses = [204];
+  const result = await this.request(params);
+
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketTags.js

@@ -0,0 +1,21 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+/**
+ * deleteBucketTags
+ * @param {String} name - bucket name
+ * @param {Object} options
+ */
+
+proto.deleteBucketTags = async function deleteBucketTags(name, options = {}) {
+  _checkBucketName(name);
+
+  const params = this._bucketRequestParams('DELETE', name, 'tagging', options);
+  params.successStatuses = [204];
+  const result = await this.request(params);
+
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/deleteBucketWebsite.js

@@ -0,0 +1,13 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+
+proto.deleteBucketWebsite = async function deleteBucketWebsite(name, options) {
+  _checkBucketName(name);
+  const params = this._bucketRequestParams('DELETE', name, 'website', options);
+  params.successStatuses = [204];
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/extendBucketWorm.d.ts

@@ -0,0 +1,4 @@
+export declare function extendBucketWorm(this: any, name: string, wormId: string, days: string | number, options: any): Promise<{
+    res: any;
+    status: any;
+}>;

package/dist/node_modules/ali-oss/lib/common/bucket/extendBucketWorm.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendBucketWorm = void 0;
+const checkBucketName_1 = require("../utils/checkBucketName");
+const obj2xml_1 = require("../utils/obj2xml");
+async function extendBucketWorm(name, wormId, days, options) {
+    checkBucketName_1.checkBucketName(name);
+    const params = this._bucketRequestParams('POST', name, { wormExtend: '', wormId }, options);
+    const paramlXMLObJ = {
+        ExtendWormConfiguration: {
+            RetentionPeriodInDays: days
+        }
+    };
+    params.mime = 'xml';
+    params.content = obj2xml_1.obj2xml(paramlXMLObJ, { headers: true });
+    params.successStatuses = [200];
+    const result = await this.request(params);
+    return {
+        res: result.res,
+        status: result.status
+    };
+}
+exports.extendBucketWorm = extendBucketWorm;

package/dist/node_modules/ali-oss/lib/common/bucket/extendBucketWorm.ts

@@ -0,0 +1,21 @@
+import { checkBucketName } from '../utils/checkBucketName';
+import { obj2xml } from '../utils/obj2xml';
+
+export async function extendBucketWorm(this: any, name: string, wormId: string, days: string | number, options) {
+  checkBucketName(name);
+  const params = this._bucketRequestParams('POST', name, { wormExtend: '', wormId }, options);
+  const paramlXMLObJ = {
+    ExtendWormConfiguration: {
+      RetentionPeriodInDays: days
+    }
+  };
+
+  params.mime = 'xml';
+  params.content = obj2xml(paramlXMLObJ, { headers: true });
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.status
+  };
+}

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketEncryption.js

@@ -0,0 +1,21 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+/**
+ * getBucketEncryption
+ * @param {String} bucketName - bucket name
+ */
+
+proto.getBucketEncryption = async function getBucketEncryption(bucketName) {
+  _checkBucketName(bucketName);
+  const params = this._bucketRequestParams('GET', bucketName, 'encryption');
+  params.successStatuses = [200];
+  params.xmlResponse = true;
+  const result = await this.request(params);
+  const encryption = result.data.ApplyServerSideEncryptionByDefault;
+  return {
+    encryption,
+    status: result.status,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketInventory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * getBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+export declare function getBucketInventory(this: any, bucketName: string, inventoryId: string, options?: any): Promise<{
+    status: any;
+    res: any;
+    inventory: any;
+}>;

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketInventory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBucketInventory = void 0;
+const checkBucketName_1 = require("../utils/checkBucketName");
+const formatInventoryConfig_1 = require("../utils/formatInventoryConfig");
+/**
+ * getBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+async function getBucketInventory(bucketName, inventoryId, options = {}) {
+    const subres = Object.assign({ inventory: '', inventoryId }, options.subres);
+    checkBucketName_1.checkBucketName(bucketName);
+    const params = this._bucketRequestParams('GET', bucketName, subres, options);
+    params.successStatuses = [200];
+    params.xmlResponse = true;
+    const result = await this.request(params);
+    return {
+        status: result.status,
+        res: result.res,
+        inventory: formatInventoryConfig_1.formatInventoryConfig(result.data)
+    };
+}
+exports.getBucketInventory = getBucketInventory;

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketInventory.ts

@@ -0,0 +1,24 @@
+import { checkBucketName } from '../utils/checkBucketName';
+import { formatInventoryConfig } from '../utils/formatInventoryConfig';
+/**
+ * getBucketInventory
+ * @param {String} bucketName - bucket name
+ * @param {String} inventoryId
+ * @param {Object} options
+ */
+
+export async function getBucketInventory(this: any, bucketName: string, inventoryId: string, options: any = {}) {
+  const subres: any = Object.assign({ inventory: '', inventoryId }, options.subres);
+  checkBucketName(bucketName);
+
+  const params = this._bucketRequestParams('GET', bucketName, subres, options);
+  params.successStatuses = [200];
+
+  params.xmlResponse = true;
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res,
+    inventory: formatInventoryConfig(result.data)
+  };
+}

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketLifecycle.js

@@ -0,0 +1,33 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { isArray } = require('../utils/isArray');
+const { formatObjKey } = require('../utils/formatObjKey');
+
+const proto = exports;
+
+proto.getBucketLifecycle = async function getBucketLifecycle(name, options) {
+  _checkBucketName(name);
+  const params = this._bucketRequestParams('GET', name, 'lifecycle', options);
+  params.successStatuses = [200];
+  params.xmlResponse = true;
+  const result = await this.request(params);
+  let rules = result.data.Rule || null;
+  if (rules) {
+    if (!isArray(rules)) {
+      rules = [rules];
+    }
+    rules = rules.map(_ => {
+      if (_.ID) {
+        _.id = _.ID;
+        delete _.ID;
+      }
+      if (_.Tag && !isArray(_.Tag)) {
+        _.Tag = [_.Tag];
+      }
+      return formatObjKey(_, 'firstLowerCase');
+    });
+  }
+  return {
+    rules,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketPolicy.js

@@ -0,0 +1,28 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+/**
+ * getBucketPolicy
+ * @param {String} bucketName - bucket name
+ * @param {Object} options
+ */
+
+proto.getBucketPolicy = async function getBucketPolicy(bucketName, options = {}) {
+  _checkBucketName(bucketName);
+
+  const params = this._bucketRequestParams('GET', bucketName, 'policy', options);
+
+  const result = await this.request(params);
+  params.successStatuses = [200];
+  let policy = null;
+
+  if (result.res.status === 200) {
+    policy = JSON.parse(result.res.data.toString());
+  }
+
+  return {
+    policy,
+    status: result.status,
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/bucket/getBucketRequestPayment.js

@@ -0,0 +1,25 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+
+const proto = exports;
+/**
+ * getBucketRequestPayment
+ * @param {String} bucketName - bucket name
+ * @param {Object} options
+ */
+
+proto.getBucketRequestPayment = async function getBucketRequestPayment(bucketName, options) {
+  options = options || {};
+
+  _checkBucketName(bucketName);
+  const params = this._bucketRequestParams('GET', bucketName, 'requestPayment', options);
+  params.successStatuses = [200];
+  params.xmlResponse = true;
+
+  const result = await this.request(params);
+
+  return {
+    status: result.status,
+    res: result.res,
+    payer: result.data.Payer
+  };
+};