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

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

@@ -0,0 +1,127 @@
+/* eslint-disable no-use-before-define */
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { isArray } = require('../utils/isArray');
+const { deepCopy } = require('../utils/deepCopy');
+const { isObject } = require('../utils/isObject');
+const { obj2xml } = require('../utils/obj2xml');
+const { checkObjectTag } = require('../utils/checkObjectTag');
+const { getStrBytesCount } = require('../utils/getStrBytesCount');
+
+const proto = exports;
+
+proto.putBucketLifecycle = async function putBucketLifecycle(name, rules, options) {
+  _checkBucketName(name);
+
+  if (!isArray(rules)) {
+    throw new Error('rules must be Array');
+  }
+
+  const params = this._bucketRequestParams('PUT', name, 'lifecycle', options);
+  const Rule = [];
+  const paramXMLObj = {
+    LifecycleConfiguration: {
+      Rule
+    }
+  };
+
+  rules.forEach(_ => {
+    defaultDaysAndDate2Expiration(_); // todo delete, 兼容旧版本
+    checkRule(_);
+    if (_.id) {
+      _.ID = _.id;
+      delete _.id;
+    }
+    Rule.push(_);
+  });
+
+  const paramXML = obj2xml(paramXMLObj, {
+    headers: true,
+    firstUpperCase: true
+  });
+
+  params.content = paramXML;
+  params.mime = 'xml';
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};
+
+// todo delete, 兼容旧版本
+function defaultDaysAndDate2Expiration(obj) {
+  if (obj.days) {
+    obj.expiration = {
+      days: obj.days
+    };
+  }
+  if (obj.date) {
+    obj.expiration = {
+      createdBeforeDate: obj.date
+    };
+  }
+}
+
+function checkDaysAndDate(obj, key) {
+  const { days, createdBeforeDate } = obj;
+  if (!days && !createdBeforeDate) {
+    throw new Error(`${key} must includes days or createdBeforeDate`);
+  } else if (days && !/^[1-9][0-9]*$/.test(days)) {
+    throw new Error('days must be a positive integer');
+  } else if (createdBeforeDate && !/\d{4}-\d{2}-\d{2}T00:00:00.000Z/.test(createdBeforeDate)) {
+    throw new Error('createdBeforeDate must be date and conform to iso8601 format');
+  }
+}
+
+function handleCheckTag(tag) {
+  if (!isArray(tag) && !isObject(tag)) {
+    throw new Error('tag must be Object or Array');
+  }
+  tag = isObject(tag) ? [tag] : tag;
+  const tagObj = {};
+  const tagClone = deepCopy(tag);
+  tagClone.forEach(v => {
+    tagObj[v.key] = v.value;
+  });
+
+  checkObjectTag(tagObj);
+}
+
+function checkRule(rule) {
+  if (rule.id && getStrBytesCount(rule.id) > 255) throw new Error('ID is composed of 255 bytes at most');
+
+  if (rule.prefix === undefined) throw new Error('Rule must includes prefix');
+
+  if (!['Enabled', 'Disabled'].includes(rule.status)) throw new Error('Status must be  Enabled or Disabled');
+
+  if (rule.transition) {
+    if (!['IA', 'Archive'].includes(rule.transition.storageClass))
+      throw new Error('StorageClass must be  IA or Archive');
+    checkDaysAndDate(rule.transition, 'Transition');
+  }
+
+  if (rule.expiration) {
+    if (!rule.expiration.expiredObjectDeleteMarker) {
+      checkDaysAndDate(rule.expiration, 'Expiration');
+    } else if (rule.expiration.days || rule.expiration.createdBeforeDate) {
+      throw new Error('expiredObjectDeleteMarker cannot be used with days or createdBeforeDate');
+    }
+  }
+
+  if (rule.abortMultipartUpload) {
+    checkDaysAndDate(rule.abortMultipartUpload, 'AbortMultipartUpload');
+  }
+
+  if (!rule.expiration && !rule.abortMultipartUpload && !rule.transition && !rule.noncurrentVersionTransition) {
+    throw new Error(
+      'Rule must includes expiration or abortMultipartUpload or transition or noncurrentVersionTransition'
+    );
+  }
+
+  if (rule.tag) {
+    if (rule.abortMultipartUpload) {
+      throw new Error('Tag cannot be used with abortMultipartUpload');
+    }
+    handleCheckTag(rule.tag);
+  }
+}

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

@@ -0,0 +1,27 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { policy2Str } = require('../utils/policy2Str');
+const { isObject } = require('../utils/isObject');
+
+const proto = exports;
+/**
+ * putBucketPolicy
+ * @param {String} bucketName - bucket name
+ * @param {Object} policy - bucket policy
+ * @param {Object} options
+ */
+
+proto.putBucketPolicy = async function putBucketPolicy(bucketName, policy, options = {}) {
+  _checkBucketName(bucketName);
+
+  if (!isObject(policy)) {
+    throw new Error('policy is not Object');
+  }
+  const params = this._bucketRequestParams('PUT', bucketName, 'policy', options);
+  params.content = policy2Str(policy);
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

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

@@ -0,0 +1,40 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { obj2xml } = require('../utils/obj2xml');
+
+const proto = exports;
+/**
+ * putBucketRequestPayment
+ * @param {String} bucketName
+ * @param {String} payer
+ * @param {Object} options
+ */
+const payerAll = ['BucketOwner', 'Requester'];
+
+proto.putBucketRequestPayment = async function putBucketRequestPayment(bucketName, payer, options) {
+  options = options || {};
+  if (!payer || payerAll.indexOf(payer) < 0) {
+    throw new Error('payer must be BucketOwner or Requester');
+  }
+
+  _checkBucketName(bucketName);
+  const params = this._bucketRequestParams('PUT', bucketName, 'requestPayment', options);
+  params.successStatuses = [200];
+
+  const paramXMLObj = {
+    RequestPaymentConfiguration: {
+      Payer: payer
+    }
+  };
+  const paramXML = obj2xml(paramXMLObj, {
+    headers: true
+  });
+
+  params.mime = 'xml';
+  params.content = paramXML;
+
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

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

@@ -0,0 +1,39 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { obj2xml } = require('../utils/obj2xml');
+const { checkBucketTag } = require('../utils/checkBucketTag');
+
+const proto = exports;
+/**
+ * putBucketTags
+ * @param {String} name - bucket name
+ * @param {Object} tag -  bucket tag, eg: `{a: "1", b: "2"}`
+ * @param {Object} options
+ */
+
+proto.putBucketTags = async function putBucketTags(name, tag, options = {}) {
+  _checkBucketName(name);
+  checkBucketTag(tag);
+  const params = this._bucketRequestParams('PUT', name, 'tagging', 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/bucket/putBucketVersioning.js

@@ -0,0 +1,35 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { obj2xml } = require('../utils/obj2xml');
+
+const proto = exports;
+/**
+ * putBucketVersioning
+ * @param {String} name - bucket name
+ * @param {String} status
+ * @param {Object} options
+ */
+
+proto.putBucketVersioning = async function putBucketVersioning(name, status, options = {}) {
+  _checkBucketName(name);
+  if (!['Enabled', 'Suspended'].includes(status)) {
+    throw new Error('status must be Enabled or Suspended');
+  }
+  const params = this._bucketRequestParams('PUT', name, 'versioning', options);
+
+  const paramXMLObj = {
+    VersioningConfiguration: {
+      Status: status
+    }
+  };
+
+  params.mime = 'xml';
+  params.content = obj2xml(paramXMLObj, {
+    headers: true
+  });
+
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.status
+  };
+};

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

@@ -0,0 +1,50 @@
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { obj2xml } = require('../utils/obj2xml');
+const { isArray } = require('../utils/isArray');
+
+const proto = exports;
+proto.putBucketWebsite = async function putBucketWebsite(name, config = {}, options) {
+  _checkBucketName(name);
+  const params = this._bucketRequestParams('PUT', name, 'website', options);
+  const IndexDocument = {
+    Suffix: config.index || 'index.html'
+  };
+  const WebsiteConfiguration = {
+    IndexDocument
+  };
+  let website = {
+    WebsiteConfiguration
+  };
+
+  if (config.supportSubDir) {
+    IndexDocument.SupportSubDir = config.supportSubDir;
+  }
+
+  if (config.type) {
+    IndexDocument.Type = config.type;
+  }
+
+  if (config.error) {
+    WebsiteConfiguration.ErrorDocument = {
+      Key: config.error
+    };
+  }
+
+  if (config.routingRules !== undefined) {
+    if (!isArray(config.routingRules)) {
+      throw new Error('RoutingRules must be Array');
+    }
+    WebsiteConfiguration.RoutingRules = {
+      RoutingRule: config.routingRules
+    };
+  }
+
+  website = obj2xml(website);
+  params.content = website;
+  params.mime = 'xml';
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    res: result.res
+  };
+};

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

@@ -0,0 +1,27 @@
+exports.encodeCallback = function encodeCallback(reqParams, options) {
+  reqParams.headers = reqParams.headers || {};
+  if (!Object.prototype.hasOwnProperty.call(reqParams.headers, 'x-oss-callback')) {
+    if (options.callback) {
+      const json = {
+        callbackUrl: encodeURI(options.callback.url),
+        callbackBody: options.callback.body
+      };
+      if (options.callback.host) {
+        json.callbackHost = options.callback.host;
+      }
+      if (options.callback.contentType) {
+        json.callbackBodyType = options.callback.contentType;
+      }
+      const callback = Buffer.from(JSON.stringify(json)).toString('base64');
+      reqParams.headers['x-oss-callback'] = callback;
+
+      if (options.callback.customValue) {
+        const callbackVar = {};
+        Object.keys(options.callback.customValue).forEach(key => {
+          callbackVar[`x:${key}`] = options.callback.customValue[key].toString();
+        });
+        reqParams.headers['x-oss-callback-var'] = Buffer.from(JSON.stringify(callbackVar)).toString('base64');
+      }
+    }
+  }
+};

package/dist/node_modules/ali-oss/lib/common/client/getReqUrl.d.ts

@@ -0,0 +1 @@
+export declare function getReqUrl(this: any, params: any): string;

package/dist/node_modules/ali-oss/lib/common/client/getReqUrl.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReqUrl = void 0;
+const copy_to_1 = __importDefault(require("copy-to"));
+const url_1 = __importDefault(require("url"));
+const merge_descriptors_1 = __importDefault(require("merge-descriptors"));
+const is_type_of_1 = __importDefault(require("is-type-of"));
+const isIP_1 = require("../utils/isIP");
+const checkConfigValid_1 = require("../utils/checkConfigValid");
+function getReqUrl(params) {
+    const ep = {};
+    const isCname = this.options.cname;
+    checkConfigValid_1.checkConfigValid(this.options.endpoint, 'endpoint');
+    copy_to_1.default(this.options.endpoint, false).to(ep);
+    if (params.bucket && !isCname && !isIP_1.isIP(ep.hostname) && !this.options.sldEnable) {
+        ep.host = `${params.bucket}.${ep.host}`;
+    }
+    let resourcePath = '/';
+    if (params.bucket && this.options.sldEnable) {
+        resourcePath += `${params.bucket}/`;
+    }
+    if (params.object) {
+        // Preserve '/' in result url
+        resourcePath += this._escape(params.object).replace(/\+/g, '%2B');
+    }
+    ep.pathname = resourcePath;
+    const query = {};
+    if (params.query) {
+        merge_descriptors_1.default(query, params.query);
+    }
+    if (params.subres) {
+        let subresAsQuery = {};
+        if (is_type_of_1.default.string(params.subres)) {
+            subresAsQuery[params.subres] = '';
+        }
+        else if (is_type_of_1.default.array(params.subres)) {
+            params.subres.forEach(k => {
+                subresAsQuery[k] = '';
+            });
+        }
+        else {
+            subresAsQuery = params.subres;
+        }
+        merge_descriptors_1.default(query, subresAsQuery);
+    }
+    ep.query = query;
+    return url_1.default.format(ep);
+}
+exports.getReqUrl = getReqUrl;

package/dist/node_modules/ali-oss/lib/common/client/getReqUrl.ts

@@ -0,0 +1,51 @@
+import copy from 'copy-to';
+import urlutil from 'url';
+import merge from 'merge-descriptors';
+import is from 'is-type-of';
+import { isIP } from '../utils/isIP';
+import { checkConfigValid } from '../utils/checkConfigValid';
+
+export function getReqUrl(this: any, params) {
+  const ep: any = {};
+  const isCname = this.options.cname;
+  checkConfigValid(this.options.endpoint, 'endpoint');
+  copy(this.options.endpoint, false).to(ep);
+
+  if (params.bucket && !isCname && !isIP(ep.hostname) && !this.options.sldEnable) {
+    ep.host = `${params.bucket}.${ep.host}`;
+  }
+
+  let resourcePath = '/';
+  if (params.bucket && this.options.sldEnable) {
+    resourcePath += `${params.bucket}/`;
+  }
+
+  if (params.object) {
+    // Preserve '/' in result url
+    resourcePath += this._escape(params.object).replace(/\+/g, '%2B');
+  }
+  ep.pathname = resourcePath;
+
+  const query = {};
+  if (params.query) {
+    merge(query, params.query);
+  }
+
+  if (params.subres) {
+    let subresAsQuery = {};
+    if ((is as any).string(params.subres)) {
+      subresAsQuery[params.subres] = '';
+    } else if (is.array(params.subres)) {
+      params.subres.forEach(k => {
+        subresAsQuery[k] = '';
+      });
+    } else {
+      subresAsQuery = params.subres;
+    }
+    merge(query, subresAsQuery);
+  }
+
+  ep.query = query;
+
+  return urlutil.format(ep);
+}

package/dist/node_modules/ali-oss/lib/common/client/initOptions.js

@@ -0,0 +1,72 @@
+const ms = require('humanize-ms');
+const urlutil = require('url');
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const { setRegion } = require('../utils/setRegion');
+const { checkConfigValid } = require('../utils/checkConfigValid');
+
+function setEndpoint(endpoint, secure) {
+  checkConfigValid(endpoint, 'endpoint');
+  let url = urlutil.parse(endpoint);
+
+  if (!url.protocol) {
+    url = urlutil.parse(`http${secure ? 's' : ''}://${endpoint}`);
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error('Endpoint protocol must be http or https.');
+  }
+
+  return url;
+}
+
+module.exports = function (options) {
+  if (!options || !options.accessKeyId || !options.accessKeySecret) {
+    throw new Error('require accessKeyId, accessKeySecret');
+  }
+  if (options.stsToken && !options.refreshSTSToken && !options.refreshSTSTokenInterval) {
+    console.warn(
+      "It's recommended to set 'refreshSTSToken' and 'refreshSTSTokenInterval' to refresh" +
+        ' stsToken、accessKeyId、accessKeySecret automatically when sts token has expired'
+    );
+  }
+  if (options.bucket) {
+    _checkBucketName(options.bucket);
+  }
+  const opts = Object.assign(
+    {
+      region: 'oss-cn-hangzhou',
+      internal: false,
+      secure: false,
+      timeout: 60000,
+      bucket: null,
+      endpoint: null,
+      cname: false,
+      isRequestPay: false,
+      sldEnable: false,
+      headerEncoding: 'utf-8',
+      refreshSTSToken: null,
+      refreshSTSTokenInterval: 60000 * 5,
+      retryMax: 0,
+      authorizationV4: false // 启用v4签名，默认关闭
+    },
+    options
+  );
+
+  opts.accessKeyId = opts.accessKeyId.trim();
+  opts.accessKeySecret = opts.accessKeySecret.trim();
+
+  if (opts.timeout) {
+    opts.timeout = ms(opts.timeout);
+  }
+
+  if (opts.endpoint) {
+    opts.endpoint = setEndpoint(opts.endpoint, opts.secure);
+  } else if (opts.region) {
+    opts.endpoint = setRegion(opts.region, opts.internal, opts.secure);
+  } else {
+    throw new Error('require options.endpoint or options.region');
+  }
+
+  opts.inited = true;
+  return opts;
+};

package/dist/node_modules/ali-oss/lib/common/image/index.js

@@ -0,0 +1,5 @@
+const merge = require('merge-descriptors');
+
+const proto = exports;
+
+merge(proto, require('./processObjectSave'));

package/dist/node_modules/ali-oss/lib/common/image/processObjectSave.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-use-before-define */
+const { checkBucketName: _checkBucketName } = require('../utils/checkBucketName');
+const querystring = require('querystring');
+const {
+  Base64: { encode: str2Base64 }
+} = require('js-base64');
+
+const proto = exports;
+
+proto.processObjectSave = async function processObjectSave(sourceObject, targetObject, process, targetBucket) {
+  checkArgs(sourceObject, 'sourceObject');
+  checkArgs(targetObject, 'targetObject');
+  checkArgs(process, 'process');
+  targetObject = this._objectName(targetObject);
+  if (targetBucket) {
+    _checkBucketName(targetBucket);
+  }
+
+  const params = this._objectRequestParams('POST', sourceObject, {
+    subres: 'x-oss-process'
+  });
+
+  const bucketParam = targetBucket ? `,b_${str2Base64(targetBucket)}` : '';
+  targetObject = str2Base64(targetObject);
+
+  const content = {
+    'x-oss-process': `${process}|sys/saveas,o_${targetObject}${bucketParam}`
+  };
+  params.content = querystring.stringify(content);
+
+  const result = await this.request(params);
+  return {
+    res: result.res,
+    status: result.res.status
+  };
+};
+
+function checkArgs(name, key) {
+  if (!name) {
+    throw new Error(`${key} is required`);
+  }
+  if (typeof name !== 'string') {
+    throw new Error(`${key} must be String`);
+  }
+}