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

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

@@ -0,0 +1,355 @@
+const crypto = require('crypto');
+const is = require('is-type-of');
+const qs = require('qs');
+const { lowercaseKeyHeader } = require('./utils/lowercaseKeyHeader');
+const { encodeString } = require('./utils/encodeString');
+
+/**
+ *
+ * @param {String} resourcePath
+ * @param {Object} parameters
+ * @return
+ */
+exports.buildCanonicalizedResource = function buildCanonicalizedResource(resourcePath, parameters) {
+  let canonicalizedResource = `${resourcePath}`;
+  let separatorString = '?';
+
+  if (is.string(parameters) && parameters.trim() !== '') {
+    canonicalizedResource += separatorString + parameters;
+  } else if (is.array(parameters)) {
+    parameters.sort();
+    canonicalizedResource += separatorString + parameters.join('&');
+  } else if (parameters) {
+    const compareFunc = (entry1, entry2) => {
+      if (entry1[0] > entry2[0]) {
+        return 1;
+      } else if (entry1[0] < entry2[0]) {
+        return -1;
+      }
+      return 0;
+    };
+    const processFunc = key => {
+      canonicalizedResource += separatorString + key;
+      if (parameters[key] || parameters[key] === 0) {
+        canonicalizedResource += `=${parameters[key]}`;
+      }
+      separatorString = '&';
+    };
+    Object.keys(parameters).sort(compareFunc).forEach(processFunc);
+  }
+
+  return canonicalizedResource;
+};
+
+/**
+ * @param {String} method
+ * @param {String} resourcePath
+ * @param {Object} request
+ * @param {String} expires
+ * @return {String} canonicalString
+ */
+exports.buildCanonicalString = function canonicalString(method, resourcePath, request, expires) {
+  request = request || {};
+  const headers = lowercaseKeyHeader(request.headers);
+  const OSS_PREFIX = 'x-oss-';
+  const ossHeaders = [];
+  const headersToSign = {};
+
+  let signContent = [
+    method.toUpperCase(),
+    headers['content-md5'] || '',
+    headers['content-type'],
+    expires || headers['x-oss-date']
+  ];
+
+  Object.keys(headers).forEach(key => {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.indexOf(OSS_PREFIX) === 0) {
+      headersToSign[lowerKey] = String(headers[key]).trim();
+    }
+  });
+
+  Object.keys(headersToSign)
+    .sort()
+    .forEach(key => {
+      ossHeaders.push(`${key}:${headersToSign[key]}`);
+    });
+
+  signContent = signContent.concat(ossHeaders);
+
+  signContent.push(this.buildCanonicalizedResource(resourcePath, request.parameters));
+
+  return signContent.join('\n');
+};
+
+/**
+ * @param {String} accessKeySecret
+ * @param {String} canonicalString
+ */
+exports.computeSignature = function computeSignature(accessKeySecret, canonicalString, headerEncoding = 'utf-8') {
+  const signature = crypto.createHmac('sha1', accessKeySecret);
+  return signature.update(Buffer.from(canonicalString, headerEncoding)).digest('base64');
+};
+
+/**
+ * @param {String} accessKeyId
+ * @param {String} accessKeySecret
+ * @param {String} canonicalString
+ */
+exports.authorization = function authorization(accessKeyId, accessKeySecret, canonicalString, headerEncoding) {
+  return `OSS ${accessKeyId}:${this.computeSignature(accessKeySecret, canonicalString, headerEncoding)}`;
+};
+
+/**
+ * @param {string[]} [additionalHeaders]
+ * @returns {string[]}
+ */
+exports.fixAdditionalHeaders = additionalHeaders => {
+  if (!additionalHeaders) {
+    return [];
+  }
+
+  const OSS_PREFIX = 'x-oss-';
+
+  return [...new Set(additionalHeaders.map(v => v.toLowerCase()))]
+    .filter(v => {
+      return v !== 'content-type' && v !== 'content-md5' && !v.startsWith(OSS_PREFIX);
+    })
+    .sort();
+};
+
+/**
+ * @param {string} method
+ * @param {Object} request
+ * @param {Object} request.headers
+ * @param {Object} [request.queries]
+ * @param {string} [bucketName]
+ * @param {string} [objectName]
+ * @param {string[]} [additionalHeaders] additional headers after deduplication, lowercase and sorting
+ * @returns {string}
+ */
+exports.getCanonicalRequest = function getCanonicalRequest(method, request, bucketName, objectName, additionalHeaders) {
+  const headers = lowercaseKeyHeader(request.headers);
+  const queries = request.queries || {};
+  const OSS_PREFIX = 'x-oss-';
+
+  if (objectName && !bucketName) {
+    throw Error('Please ensure that bucketName is passed into getCanonicalRequest.');
+  }
+
+  const signContent = [
+    method.toUpperCase(), // HTTP Verb
+    encodeString(`/${bucketName ? `${bucketName}/` : ''}${objectName || ''}`).replace(/%2F/g, '/') // Canonical URI
+  ];
+
+  // Canonical Query String
+  signContent.push(
+    qs.stringify(queries, {
+      encoder: encodeString,
+      sort: (a, b) => a.localeCompare(b),
+      strictNullHandling: true
+    })
+  );
+
+  // Canonical Headers
+  if (additionalHeaders) {
+    additionalHeaders.forEach(v => {
+      if (!Object.prototype.hasOwnProperty.call(headers, v)) {
+        throw Error(`Can't find additional header ${v} in request headers.`);
+      }
+    });
+  }
+
+  const tempHeaders = new Set(additionalHeaders);
+
+  Object.keys(headers).forEach(v => {
+    if (v === 'content-type' || v === 'content-md5' || v.startsWith(OSS_PREFIX)) {
+      tempHeaders.add(v);
+    }
+  });
+
+  const canonicalHeaders = `${[...tempHeaders]
+    .sort()
+    .map(v => `${v}:${is.string(headers[v]) ? headers[v].trim() : headers[v]}\n`)
+    .join('')}`;
+
+  signContent.push(canonicalHeaders);
+
+  // Additional Headers
+  if (additionalHeaders.length > 0) {
+    signContent.push(additionalHeaders.join(';'));
+  } else {
+    signContent.push('');
+  }
+
+  // Hashed Payload
+  signContent.push(headers['x-oss-content-sha256'] || 'UNSIGNED-PAYLOAD');
+
+  return signContent.join('\n');
+};
+
+/**
+ * @param {string} region Standard region, e.g. cn-hangzhou
+ * @param {string} date ISO8601 UTC:yyyymmdd'T'HHMMss'Z'
+ * @param {string} canonicalRequest
+ * @returns {string}
+ */
+exports.getStringToSign = function getStringToSign(region, date, canonicalRequest) {
+  const stringToSign = [
+    'OSS4-HMAC-SHA256',
+    date, // TimeStamp
+    `${date.split('T')[0]}/${region}/oss/aliyun_v4_request`, // Scope
+    crypto.createHash('sha256').update(canonicalRequest).digest('hex') // Hashed Canonical Request
+  ];
+
+  return stringToSign.join('\n');
+};
+
+/**
+ * @param {String} accessKeySecret
+ * @param {string} date yyyymmdd
+ * @param {string} region Standard region, e.g. cn-hangzhou
+ * @param {string} stringToSign
+ * @returns {string}
+ */
+exports.getSignatureV4 = function getSignatureV4(accessKeySecret, date, region, stringToSign) {
+  const signingDate = crypto.createHmac('sha256', `aliyun_v4${accessKeySecret}`).update(date).digest();
+  const signingRegion = crypto.createHmac('sha256', signingDate).update(region).digest();
+  const signingOss = crypto.createHmac('sha256', signingRegion).update('oss').digest();
+  const signingKey = crypto.createHmac('sha256', signingOss).update('aliyun_v4_request').digest();
+  const signatureValue = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex');
+
+  return signatureValue;
+};
+
+/**
+ * @param {String} accessKeyId
+ * @param {String} accessKeySecret
+ * @param {string} region Standard region, e.g. cn-hangzhou
+ * @param {string} method
+ * @param {Object} request
+ * @param {Object} request.headers
+ * @param {Object} [request.queries]
+ * @param {string} [bucketName]
+ * @param {string} [objectName]
+ * @param {string[]} [additionalHeaders]
+ * @param {string} [headerEncoding='utf-8']
+ * @returns {string}
+ */
+exports.authorizationV4 = function authorizationV4(
+  accessKeyId,
+  accessKeySecret,
+  region,
+  method,
+  request,
+  bucketName,
+  objectName,
+  additionalHeaders,
+  headerEncoding = 'utf-8'
+) {
+  const fixedAdditionalHeaders = this.fixAdditionalHeaders(additionalHeaders);
+  const fixedHeaders = {};
+  Object.entries(request.headers).forEach(v => {
+    fixedHeaders[v[0]] = is.string(v[1]) ? Buffer.from(v[1], headerEncoding).toString() : v[1];
+  });
+  const date = fixedHeaders['x-oss-date'] || (request.queries && request.queries['x-oss-date']);
+  const canonicalRequest = this.getCanonicalRequest(
+    method,
+    {
+      headers: fixedHeaders,
+      queries: request.queries
+    },
+    bucketName,
+    objectName,
+    fixedAdditionalHeaders
+  );
+  const stringToSign = this.getStringToSign(region, date, canonicalRequest);
+  const onlyDate = date.split('T')[0];
+  const signatureValue = this.getSignatureV4(accessKeySecret, onlyDate, region, stringToSign);
+  const additionalHeadersValue =
+    fixedAdditionalHeaders.length > 0 ? `AdditionalHeaders=${fixedAdditionalHeaders.join(';')},` : '';
+
+  return `OSS4-HMAC-SHA256 Credential=${accessKeyId}/${onlyDate}/${region}/oss/aliyun_v4_request,${additionalHeadersValue}Signature=${signatureValue}`;
+};
+
+/**
+ *
+ * @param {String} accessKeySecret
+ * @param {Object} options
+ * @param {String} resource
+ * @param {Number} expires
+ */
+exports._signatureForURL = function _signatureForURL(accessKeySecret, options = {}, resource, expires, headerEncoding) {
+  const headers = {};
+  const { subResource = {} } = options;
+
+  if (options.process) {
+    const processKeyword = 'x-oss-process';
+    subResource[processKeyword] = options.process;
+  }
+
+  if (options.trafficLimit) {
+    const trafficLimitKey = 'x-oss-traffic-limit';
+    subResource[trafficLimitKey] = options.trafficLimit;
+  }
+
+  if (options.response) {
+    Object.keys(options.response).forEach(k => {
+      const key = `response-${k.toLowerCase()}`;
+      subResource[key] = options.response[k];
+    });
+  }
+
+  Object.keys(options).forEach(key => {
+    const lowerKey = key.toLowerCase();
+    const value = options[key];
+    if (lowerKey.indexOf('x-oss-') === 0) {
+      headers[lowerKey] = value;
+    } else if (lowerKey.indexOf('content-md5') === 0) {
+      headers[key] = value;
+    } else if (lowerKey.indexOf('content-type') === 0) {
+      headers[key] = value;
+    }
+  });
+
+  if (Object.prototype.hasOwnProperty.call(options, 'security-token')) {
+    subResource['security-token'] = options['security-token'];
+  }
+
+  if (Object.prototype.hasOwnProperty.call(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;
+    }
+    subResource.callback = Buffer.from(JSON.stringify(json)).toString('base64');
+
+    if (options.callback.customValue) {
+      const callbackVar = {};
+      Object.keys(options.callback.customValue).forEach(key => {
+        callbackVar[`x:${key}`] = options.callback.customValue[key];
+      });
+      subResource['callback-var'] = Buffer.from(JSON.stringify(callbackVar)).toString('base64');
+    }
+  }
+
+  const canonicalString = this.buildCanonicalString(
+    options.method,
+    resource,
+    {
+      headers,
+      parameters: subResource
+    },
+    expires.toString()
+  );
+
+  return {
+    Signature: this.computeSignature(accessKeySecret, canonicalString, headerEncoding),
+    subResource
+  };
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketName.d.ts

@@ -0,0 +1 @@
+export declare const checkBucketName: (name: string, createBucket?: boolean) => void;

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketName.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBucketName = void 0;
+exports.checkBucketName = (name, createBucket = false) => {
+    const bucketRegex = createBucket ? /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/ : /^[a-z0-9_][a-z0-9-_]{1,61}[a-z0-9_]$/;
+    if (!bucketRegex.test(name)) {
+        throw new Error('The bucket must be conform to the specifications');
+    }
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketName.ts

@@ -0,0 +1,6 @@
+export const checkBucketName = (name: string, createBucket = false): void => {
+  const bucketRegex = createBucket ? /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/ : /^[a-z0-9_][a-z0-9-_]{1,61}[a-z0-9_]$/;
+  if (!bucketRegex.test(name)) {
+    throw new Error('The bucket must be conform to the specifications');
+  }
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketNameTest.d.ts

@@ -0,0 +1 @@
+export declare const checkBucketNameTest: (name: string, createBucket: boolean) => void;

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketNameTest.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBucketNameTest = void 0;
+const isArray_1 = require("./isArray");
+exports.checkBucketNameTest = (name, createBucket) => {
+    const bucketRegex = createBucket ? /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/ : /^[a-z0-9_][a-z0-9-_]{1,61}[a-z0-9_]$/;
+    if (!bucketRegex.test(name)) {
+        throw new Error('The bucket must be conform to the specifications');
+    }
+};
+let res = isArray_1.isArray([1, 2, 3]);
+console.log(res, 'is array');
+res = isArray_1.isArray('');
+console.log(res, 'is array');

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketNameTest.ts

@@ -0,0 +1,12 @@
+import { isArray } from './isArray';
+
+export const checkBucketNameTest = (name: string, createBucket: boolean): void => {
+  const bucketRegex = createBucket ? /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/ : /^[a-z0-9_][a-z0-9-_]{1,61}[a-z0-9_]$/;
+  if (!bucketRegex.test(name)) {
+    throw new Error('The bucket must be conform to the specifications');
+  }
+};
+let res = isArray([1, 2, 3]);
+console.log(res, 'is array');
+res = isArray('');
+console.log(res, 'is array');

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketTag.d.ts

@@ -0,0 +1 @@
+export declare const checkBucketTag: (tag: object) => void;

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketTag.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBucketTag = void 0;
+const { checkValid } = require('./checkValid');
+const { isObject } = require('./isObject');
+const commonRules = [
+    {
+        validator: value => {
+            if (typeof value !== 'string') {
+                throw new Error('the key and value of the tag must be String');
+            }
+        }
+    }
+];
+const rules = {
+    key: [
+        ...commonRules,
+        {
+            pattern: /^.{1,64}$/,
+            msg: 'tag key can be a maximum of 64 bytes in length'
+        },
+        {
+            pattern: /^(?!https*:\/\/|Aliyun)/,
+            msg: 'tag key can not startsWith: http://, https://, Aliyun'
+        }
+    ],
+    value: [
+        ...commonRules,
+        {
+            pattern: /^.{0,128}$/,
+            msg: 'tag value can be a maximum of 128 bytes in length'
+        }
+    ]
+};
+exports.checkBucketTag = (tag) => {
+    if (!isObject(tag)) {
+        throw new Error('bucket tag must be Object');
+    }
+    const entries = Object.entries(tag);
+    if (entries.length > 20) {
+        throw new Error('maximum of 20 tags for a bucket');
+    }
+    const rulesIndexKey = ['key', 'value'];
+    entries.forEach(keyValue => {
+        keyValue.forEach((item, index) => {
+            checkValid(item, rules[rulesIndexKey[index]]);
+        });
+    });
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkBucketTag.ts

@@ -0,0 +1,52 @@
+const { checkValid } = require('./checkValid');
+const { isObject } = require('./isObject');
+
+const commonRules = [
+  {
+    validator: value => {
+      if (typeof value !== 'string') {
+        throw new Error('the key and value of the tag must be String');
+      }
+    }
+  }
+];
+
+const rules = {
+  key: [
+    ...commonRules,
+    {
+      pattern: /^.{1,64}$/,
+      msg: 'tag key can be a maximum of 64 bytes in length'
+    },
+    {
+      pattern: /^(?!https*:\/\/|Aliyun)/,
+      msg: 'tag key can not startsWith: http://, https://, Aliyun'
+    }
+  ],
+  value: [
+    ...commonRules,
+    {
+      pattern: /^.{0,128}$/,
+      msg: 'tag value can be a maximum of 128 bytes in length'
+    }
+  ]
+};
+
+export const checkBucketTag = (tag: object) => {
+  if (!isObject(tag)) {
+    throw new Error('bucket tag must be Object');
+  }
+
+  const entries = Object.entries(tag);
+
+  if (entries.length > 20) {
+    throw new Error('maximum of 20 tags for a bucket');
+  }
+
+  const rulesIndexKey = ['key', 'value'];
+  entries.forEach(keyValue => {
+    keyValue.forEach((item, index) => {
+      checkValid(item, rules[rulesIndexKey[index]]);
+    });
+  });
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkConfigValid.d.ts

@@ -0,0 +1 @@
+export declare const checkConfigValid: (conf: any, key: 'endpoint' | 'region') => void;

package/dist/node_modules/ali-oss/lib/common/utils/checkConfigValid.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConfigValid = void 0;
+const checkConfigMap = {
+    endpoint: checkEndpoint,
+    region: /^[a-zA-Z0-9\-_]+$/
+};
+function checkEndpoint(endpoint) {
+    if (typeof endpoint === 'string') {
+        return /^[a-zA-Z0-9._:/-]+$/.test(endpoint);
+    }
+    else if (endpoint.host) {
+        return /^[a-zA-Z0-9._:/-]+$/.test(endpoint.host);
+    }
+    return false;
+}
+exports.checkConfigValid = (conf, key) => {
+    if (checkConfigMap[key]) {
+        let isConfigValid = true;
+        if (checkConfigMap[key] instanceof Function) {
+            isConfigValid = checkConfigMap[key](conf);
+        }
+        else {
+            isConfigValid = checkConfigMap[key].test(conf);
+        }
+        if (!isConfigValid) {
+            throw new Error(`The ${key} must be conform to the specifications`);
+        }
+    }
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkConfigValid.ts

@@ -0,0 +1,27 @@
+const checkConfigMap = {
+  endpoint: checkEndpoint,
+  region: /^[a-zA-Z0-9\-_]+$/
+};
+
+function checkEndpoint(endpoint) {
+  if (typeof endpoint === 'string') {
+    return /^[a-zA-Z0-9._:/-]+$/.test(endpoint);
+  } else if (endpoint.host) {
+    return /^[a-zA-Z0-9._:/-]+$/.test(endpoint.host);
+  }
+  return false;
+}
+
+export const checkConfigValid = (conf, key: 'endpoint' | 'region'): void => {
+  if (checkConfigMap[key]) {
+    let isConfigValid = true;
+    if (checkConfigMap[key] instanceof Function) {
+      isConfigValid = (checkConfigMap[key] as Function)(conf);
+    } else {
+      isConfigValid = (checkConfigMap[key] as RegExp).test(conf);
+    }
+    if (!isConfigValid) {
+      throw new Error(`The ${key} must be conform to the specifications`);
+    }
+  }
+};

package/dist/node_modules/ali-oss/lib/common/utils/checkEnv.d.ts

@@ -0,0 +1 @@
+export declare function checkEnv(msg: string): void;

package/dist/node_modules/ali-oss/lib/common/utils/checkEnv.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEnv = void 0;
+function checkEnv(msg) {
+    if (process.browser) {
+        console.warn(msg);
+    }
+}
+exports.checkEnv = checkEnv;

package/dist/node_modules/ali-oss/lib/common/utils/checkEnv.ts

@@ -0,0 +1,5 @@
+export function checkEnv(msg: string) {
+  if (process.browser) {
+    console.warn(msg);
+  }
+}

package/dist/node_modules/ali-oss/lib/common/utils/checkObjectTag.d.ts

@@ -0,0 +1 @@
+export declare function checkObjectTag(tag: any): void;

package/dist/node_modules/ali-oss/lib/common/utils/checkObjectTag.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkObjectTag = void 0;
+const { checkValid } = require('./checkValid');
+const { isObject } = require('./isObject');
+const commonRules = [
+    {
+        validator: value => {
+            if (typeof value !== 'string') {
+                throw new Error('the key and value of the tag must be String');
+            }
+        }
+    },
+    {
+        pattern: /^[a-zA-Z0-9 +-=._:/]+$/,
+        msg: 'tag can contain letters, numbers, spaces, and the following symbols: plus sign (+), hyphen (-), equal sign (=), period (.), underscore (_), colon (:), and forward slash (/)'
+    }
+];
+const rules = {
+    key: [
+        ...commonRules,
+        {
+            pattern: /^.{1,128}$/,
+            msg: 'tag key can be a maximum of 128 bytes in length'
+        }
+    ],
+    value: [
+        ...commonRules,
+        {
+            pattern: /^.{0,256}$/,
+            msg: 'tag value can be a maximum of 256 bytes in length'
+        }
+    ]
+};
+function checkObjectTag(tag) {
+    if (!isObject(tag)) {
+        throw new Error('tag must be Object');
+    }
+    const entries = Object.entries(tag);
+    if (entries.length > 10) {
+        throw new Error('maximum of 10 tags for a object');
+    }
+    const rulesIndexKey = ['key', 'value'];
+    entries.forEach(keyValue => {
+        keyValue.forEach((item, index) => {
+            checkValid(item, rules[rulesIndexKey[index]]);
+        });
+    });
+}
+exports.checkObjectTag = checkObjectTag;