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

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

@@ -0,0 +1,57 @@
+/* eslint-disable object-curly-newline */
+const utility = require('utility');
+const { obj2xml } = require('../utils/obj2xml');
+
+const proto = exports;
+
+proto.deleteMulti = async function deleteMulti(names, options = {}) {
+  const objects = [];
+  if (!names || !names.length) {
+    throw new Error('names is required');
+  }
+  for (let i = 0; i < names.length; i++) {
+    const object = {};
+    if (typeof names[i] === 'string') {
+      object.Key = utility.escape(this._objectName(names[i]));
+    } else {
+      const { key, versionId } = names[i];
+      object.Key = utility.escape(this._objectName(key));
+      object.VersionId = versionId;
+    }
+    objects.push(object);
+  }
+
+  const paramXMLObj = {
+    Delete: {
+      Quiet: !!options.quiet,
+      Object: objects
+    }
+  };
+
+  const paramXML = obj2xml(paramXMLObj, {
+    headers: true
+  });
+
+  options.subres = Object.assign({ delete: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('POST', '', options);
+  params.mime = 'xml';
+  params.content = paramXML;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+  const result = await this.request(params);
+
+  const r = result.data;
+  let deleted = (r && r.Deleted) || null;
+  if (deleted) {
+    if (!Array.isArray(deleted)) {
+      deleted = [deleted];
+    }
+  }
+  return {
+    res: result.res,
+    deleted: deleted || []
+  };
+};

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

@@ -0,0 +1,22 @@
+const proto = exports;
+/**
+ * deleteObjectTagging
+ * @param {String} name - object name
+ * @param {Object} options
+ */
+
+proto.deleteObjectTagging = async function deleteObjectTagging(name, options = {}) {
+  options.subres = Object.assign({ tagging: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  name = this._objectName(name);
+  const params = this._objectRequestParams('DELETE', name, 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/object/generateObjectUrl.js

@@ -0,0 +1,28 @@
+const urlutil = require('url');
+const { isIP } = require('../utils/isIP');
+
+const proto = exports;
+
+/**
+ * Get Object url by name
+ * @param {String} name - object name
+ * @param {String} [baseUrl] - If provide `baseUrl`, will use `baseUrl` instead the default `endpoint and bucket`.
+ * @return {String} object url include bucket
+ */
+proto.generateObjectUrl = function generateObjectUrl(name, baseUrl) {
+  if (isIP(this.options.endpoint.hostname)) {
+    throw new Error('can not get the object URL when endpoint is IP');
+  }
+  if (!baseUrl) {
+    baseUrl = this.options.endpoint.format();
+    const copyUrl = urlutil.parse(baseUrl);
+    const { bucket } = this.options;
+
+    copyUrl.hostname = `${bucket}.${copyUrl.hostname}`;
+    copyUrl.host = `${bucket}.${copyUrl.host}`;
+    baseUrl = copyUrl.format();
+  } else if (baseUrl[baseUrl.length - 1] !== '/') {
+    baseUrl += '/';
+  }
+  return baseUrl + this._escape(this._objectName(name));
+};

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

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const is = require('is-type-of');
+
+const proto = exports;
+/**
+ * get
+ * @param {String} name - object name
+ * @param {String | Stream} file
+ * @param {Object} options
+ * @param {{res}}
+ */
+proto.get = async function get(name, file, options = {}) {
+  let writeStream = null;
+  let needDestroy = false;
+
+  if (is.writableStream(file)) {
+    writeStream = file;
+  } else if (is.string(file)) {
+    writeStream = fs.createWriteStream(file);
+    needDestroy = true;
+  } else {
+    // get(name, options)
+    options = file;
+  }
+
+  options = options || {};
+  const isBrowserEnv = process && process.browser;
+  const responseCacheControl = options.responseCacheControl === null ? '' : 'no-cache';
+  const defaultSubresOptions =
+    isBrowserEnv && responseCacheControl ? { 'response-cache-control': responseCacheControl } : {};
+  options.subres = Object.assign(defaultSubresOptions, options.subres);
+
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  if (options.process) {
+    options.subres['x-oss-process'] = options.process;
+  }
+
+  let result;
+  try {
+    const params = this._objectRequestParams('GET', name, options);
+    params.writeStream = writeStream;
+    params.successStatuses = [200, 206, 304];
+
+    result = await this.request(params);
+
+    if (needDestroy) {
+      writeStream.destroy();
+    }
+  } catch (err) {
+    if (needDestroy) {
+      writeStream.destroy();
+      // should delete the exists file before throw error
+      await this._deleteFileSafe(file);
+    }
+    throw err;
+  }
+
+  return {
+    res: result.res,
+    content: result.data
+  };
+};

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

@@ -0,0 +1,30 @@
+const proto = exports;
+
+/*
+ * Get object's ACL
+ * @param {String} name the object key
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.getACL = async function getACL(name, options = {}) {
+  options.subres = Object.assign({ acl: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  name = this._objectName(name);
+
+  const params = this._objectRequestParams('GET', name, options);
+  params.successStatuses = [200];
+  params.xmlResponse = true;
+
+  const result = await this.request(params);
+
+  return {
+    acl: result.data.AccessControlList.Grant,
+    owner: {
+      id: result.data.Owner.ID,
+      displayName: result.data.Owner.DisplayName
+    },
+    res: result.res
+  };
+};

package/dist/node_modules/ali-oss/lib/common/object/getAsyncFetch.d.ts

@@ -0,0 +1 @@
+export declare function getAsyncFetch(this: any, taskId: any, options?: any): Promise<object>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAsyncFetch = void 0;
+const formatObjKey_1 = require("../utils/formatObjKey");
+/*
+ * getAsyncFetch
+ * @param {String} asyncFetch taskId
+ * @param {Object} options
+ */
+async function getAsyncFetch(taskId, options = {}) {
+    options.subres = Object.assign({ asyncFetch: '' }, options.subres);
+    options.headers = options.headers || {};
+    const params = this._objectRequestParams('GET', '', options);
+    params.headers['x-oss-task-id'] = taskId;
+    params.successStatuses = [200];
+    params.xmlResponse = true;
+    const result = await this.request(params);
+    const taskInfo = formatObjKey_1.formatObjKey(result.data.TaskInfo, 'firstLowerCase');
+    return {
+        res: result.res,
+        status: result.status,
+        state: result.data.State,
+        taskInfo
+    };
+}
+exports.getAsyncFetch = getAsyncFetch;

package/dist/node_modules/ali-oss/lib/common/object/getAsyncFetch.ts

@@ -0,0 +1,25 @@
+import { formatObjKey } from '../utils/formatObjKey';
+
+/*
+ * getAsyncFetch
+ * @param {String} asyncFetch taskId
+ * @param {Object} options
+ */
+export async function getAsyncFetch(this: any, taskId, options: any = {}): Promise<object> {
+  options.subres = Object.assign({ asyncFetch: '' }, options.subres);
+  options.headers = options.headers || {};
+
+  const params = this._objectRequestParams('GET', '', options);
+  params.headers['x-oss-task-id'] = taskId;
+  params.successStatuses = [200];
+  params.xmlResponse = true;
+
+  const result = await this.request(params);
+  const taskInfo = formatObjKey(result.data.TaskInfo, 'firstLowerCase');
+  return {
+    res: result.res,
+    status: result.status,
+    state: result.data.State,
+    taskInfo
+  };
+}

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

@@ -0,0 +1,98 @@
+/* eslint-disable no-use-before-define */
+const proto = exports;
+const { isObject } = require('../utils/isObject');
+const { isArray } = require('../utils/isArray');
+
+proto.getBucketVersions = getBucketVersions;
+proto.listObjectVersions = getBucketVersions;
+
+async function getBucketVersions(query = {}, options = {}) {
+  // prefix, key-marker, max-keys, delimiter, encoding-type, version-id-marker
+  if (query.versionIdMarker && query.keyMarker === undefined) {
+    throw new Error('A version-id marker cannot be specified without a key marker');
+  }
+
+  options.subres = Object.assign({ versions: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('GET', '', options);
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  params.query = formatQuery(query);
+
+  const result = await this.request(params);
+  let objects = result.data.Version || [];
+  let deleteMarker = result.data.DeleteMarker || [];
+  const that = this;
+  if (objects) {
+    if (!Array.isArray(objects)) {
+      objects = [objects];
+    }
+    objects = objects.map(obj => ({
+      name: obj.Key,
+      url: that._objectUrl(obj.Key),
+      lastModified: obj.LastModified,
+      isLatest: obj.IsLatest === 'true',
+      versionId: obj.VersionId,
+      etag: obj.ETag,
+      type: obj.Type,
+      size: Number(obj.Size),
+      storageClass: obj.StorageClass,
+      owner: {
+        id: obj.Owner.ID,
+        displayName: obj.Owner.DisplayName
+      }
+    }));
+  }
+  if (deleteMarker) {
+    if (!isArray(deleteMarker)) {
+      deleteMarker = [deleteMarker];
+    }
+    deleteMarker = deleteMarker.map(obj => ({
+      name: obj.Key,
+      lastModified: obj.LastModified,
+      versionId: obj.VersionId,
+      owner: {
+        id: obj.Owner.ID,
+        displayName: obj.Owner.DisplayName
+      }
+    }));
+  }
+  let prefixes = result.data.CommonPrefixes || null;
+  if (prefixes) {
+    if (!isArray(prefixes)) {
+      prefixes = [prefixes];
+    }
+    prefixes = prefixes.map(item => item.Prefix);
+  }
+  return {
+    res: result.res,
+    objects,
+    deleteMarker,
+    prefixes,
+    // attirbute of legacy error
+    nextMarker: result.data.NextKeyMarker || null,
+    // attirbute of legacy error
+    NextVersionIdMarker: result.data.NextVersionIdMarker || null,
+    nextKeyMarker: result.data.NextKeyMarker || null,
+    nextVersionIdMarker: result.data.NextVersionIdMarker || null,
+    isTruncated: result.data.IsTruncated === 'true'
+  };
+}
+
+function camel2Line(name) {
+  return name.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+
+function formatQuery(query = {}) {
+  const obj = {};
+  if (isObject(query)) {
+    Object.keys(query).forEach(key => {
+      obj[camel2Line(key)] = query[key];
+    });
+  }
+
+  return obj;
+}

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

@@ -0,0 +1,23 @@
+const proto = exports;
+/**
+ * getObjectMeta
+ * @param {String} name - object name
+ * @param {Object} options
+ * @param {{res}}
+ */
+
+proto.getObjectMeta = async function getObjectMeta(name, options) {
+  options = options || {};
+  name = this._objectName(name);
+  options.subres = Object.assign({ objectMeta: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('HEAD', name, options);
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  return {
+    status: result.status,
+    res: result.res
+  };
+};

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

@@ -0,0 +1,34 @@
+const proto = exports;
+const { isObject } = require('../utils/isObject');
+/**
+ * getObjectTagging
+ * @param {String} name - object name
+ * @param {Object} options
+ * @return {Object}
+ */
+
+proto.getObjectTagging = async function getObjectTagging(name, options = {}) {
+  options.subres = Object.assign({ tagging: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  name = this._objectName(name);
+  const params = this._objectRequestParams('GET', name, options);
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  const Tagging = await this.parseXML(result.data);
+  let { Tag } = Tagging.TagSet;
+  Tag = Tag && isObject(Tag) ? [Tag] : Tag || [];
+
+  const tag = {};
+
+  Tag.forEach(item => {
+    tag[item.Key] = item.Value;
+  });
+
+  return {
+    status: result.status,
+    res: result.res,
+    tag
+  };
+};

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

@@ -0,0 +1,21 @@
+const { isIP } = require('../utils/isIP');
+
+const proto = exports;
+/**
+ * Get Object url by name
+ * @param {String} name - object name
+ * @param {String} [baseUrl] - If provide `baseUrl`,
+ *        will use `baseUrl` instead the default `endpoint`.
+ * @return {String} object url
+ */
+proto.getObjectUrl = function getObjectUrl(name, baseUrl) {
+  if (isIP(this.options.endpoint.hostname)) {
+    throw new Error('can not get the object URL when endpoint is IP');
+  }
+  if (!baseUrl) {
+    baseUrl = this.options.endpoint.format();
+  } else if (baseUrl[baseUrl.length - 1] !== '/') {
+    baseUrl += '/';
+  }
+  return baseUrl + this._escape(this._objectName(name));
+};

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

@@ -0,0 +1,23 @@
+const proto = exports;
+/**
+ * getSymlink
+ * @param {String} name - object name
+ * @param {Object} options
+ * @param {{res}}
+ */
+
+proto.getSymlink = async function getSymlink(name, options = {}) {
+  options.subres = Object.assign({ symlink: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  name = this._objectName(name);
+  const params = this._objectRequestParams('GET', name, options);
+  params.successStatuses = [200];
+  const result = await this.request(params);
+  const target = result.res.headers['x-oss-symlink-target'];
+  return {
+    targetName: decodeURIComponent(target),
+    res: result.res
+  };
+};

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

@@ -0,0 +1,40 @@
+const { checkEnv } = require('../utils/checkEnv');
+const proto = exports;
+/**
+ * head
+ * @param {String} name - object name
+ * @param {Object} options
+ * @param {{res}}
+ */
+
+proto.head = async function head(name, options = {}) {
+  checkEnv(
+    'Because HeadObject has gzip enabled, head cannot get the file size correctly. If you need to get the file size, please use getObjectMeta'
+  );
+  options.subres = Object.assign({}, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('HEAD', name, options);
+  params.successStatuses = [200, 304];
+
+  const result = await this.request(params);
+
+  const data = {
+    meta: null,
+    res: result.res,
+    status: result.status
+  };
+
+  if (result.status === 200) {
+    Object.keys(result.headers).forEach(k => {
+      if (k.indexOf('x-oss-meta-') === 0) {
+        if (!data.meta) {
+          data.meta = {};
+        }
+        data.meta[k.substring(11)] = result.headers[k];
+      }
+    });
+  }
+  return data;
+};

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

@@ -0,0 +1,26 @@
+const merge = require('merge-descriptors');
+
+const proto = exports;
+
+merge(proto, require('./getSymlink'));
+merge(proto, require('./putSymlink'));
+merge(proto, require('./getObjectMeta'));
+merge(proto, require('./copyObject'));
+merge(proto, require('./calculatePostSignature'));
+merge(proto, require('./getObjectTagging'));
+merge(proto, require('./putObjectTagging'));
+merge(proto, require('./deleteObjectTagging'));
+merge(proto, require('./getBucketVersions'));
+merge(proto, require('./deleteMulti'));
+merge(proto, require('./getACL'));
+merge(proto, require('./putACL'));
+merge(proto, require('./head'));
+merge(proto, require('./delete'));
+merge(proto, require('./get'));
+merge(proto, require('./postAsyncFetch'));
+merge(proto, require('./getAsyncFetch'));
+merge(proto, require('./generateObjectUrl'));
+merge(proto, require('./getObjectUrl'));
+merge(proto, require('./signatureUrl'));
+merge(proto, require('./asyncSignatureUrl'));
+merge(proto, require('./signatureUrlV4'));

package/dist/node_modules/ali-oss/lib/common/object/postAsyncFetch.d.ts

@@ -0,0 +1 @@
+export declare function postAsyncFetch(this: any, object: any, url: any, options?: any): Promise<object>;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postAsyncFetch = void 0;
+const obj2xml_1 = require("../utils/obj2xml");
+/*
+ * postAsyncFetch
+ * @param {String} name the object key
+ * @param {String} url
+ * @param {Object} options
+ *        {String} options.host
+ *        {String} options.contentMD5
+ *        {String} options.callback
+ *        {String} options.storageClass Standard/IA/Archive
+ *        {Boolean} options.ignoreSameKey  default value true
+ */
+async function postAsyncFetch(object, url, options = {}) {
+    options.subres = Object.assign({ asyncFetch: '' }, options.subres);
+    options.headers = options.headers || {};
+    object = this._objectName(object);
+    const { host = '', contentMD5 = '', callback = '', storageClass = '', ignoreSameKey = true } = options;
+    const paramXMLObj = {
+        AsyncFetchTaskConfiguration: {
+            Url: url,
+            Object: object,
+            Host: host,
+            ContentMD5: contentMD5,
+            Callback: callback,
+            StorageClass: storageClass,
+            IgnoreSameKey: ignoreSameKey
+        }
+    };
+    const params = this._objectRequestParams('POST', '', options);
+    params.mime = 'xml';
+    params.xmlResponse = true;
+    params.successStatuses = [200];
+    params.content = obj2xml_1.obj2xml(paramXMLObj);
+    const result = await this.request(params);
+    return {
+        res: result.res,
+        status: result.status,
+        taskId: result.data.TaskId
+    };
+}
+exports.postAsyncFetch = postAsyncFetch;

package/dist/node_modules/ali-oss/lib/common/object/postAsyncFetch.ts

@@ -0,0 +1,46 @@
+import { obj2xml } from '../utils/obj2xml';
+
+/*
+ * postAsyncFetch
+ * @param {String} name the object key
+ * @param {String} url
+ * @param {Object} options
+ *        {String} options.host
+ *        {String} options.contentMD5
+ *        {String} options.callback
+ *        {String} options.storageClass Standard/IA/Archive
+ *        {Boolean} options.ignoreSameKey  default value true
+ */
+export async function postAsyncFetch(this: any, object, url, options: any = {}): Promise<object> {
+  options.subres = Object.assign({ asyncFetch: '' }, options.subres);
+  options.headers = options.headers || {};
+  object = this._objectName(object);
+
+  const { host = '', contentMD5 = '', callback = '', storageClass = '', ignoreSameKey = true } = options;
+
+  const paramXMLObj = {
+    AsyncFetchTaskConfiguration: {
+      Url: url,
+      Object: object,
+      Host: host,
+      ContentMD5: contentMD5,
+      Callback: callback,
+      StorageClass: storageClass,
+      IgnoreSameKey: ignoreSameKey
+    }
+  };
+
+  const params = this._objectRequestParams('POST', '', options);
+  params.mime = 'xml';
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+  params.content = obj2xml(paramXMLObj);
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res,
+    status: result.status,
+    taskId: result.data.TaskId
+  };
+}

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

@@ -0,0 +1,27 @@
+const proto = exports;
+
+/*
+ * Set object's ACL
+ * @param {String} name the object key
+ * @param {String} acl the object ACL
+ * @param {Object} options
+ */
+proto.putACL = async function putACL(name, acl, options) {
+  options = options || {};
+  options.subres = Object.assign({ acl: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  options.headers = options.headers || {};
+  options.headers['x-oss-object-acl'] = acl;
+  name = this._objectName(name);
+
+  const params = this._objectRequestParams('PUT', name, options);
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};