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

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

@@ -0,0 +1,420 @@
+const debug = require('debug')('ali-oss:object');
+const fs = require('fs');
+const is = require('is-type-of');
+const copy = require('copy-to');
+const path = require('path');
+const mime = require('mime');
+const callback = require('./common/callback');
+const { Transform } = require('stream');
+const pump = require('pump');
+const { isBuffer } = require('./common/utils/isBuffer');
+const { retry } = require('./common/utils/retry');
+const { obj2xml } = require('./common/utils/obj2xml');
+
+const proto = exports;
+
+/**
+ * Object operations
+ */
+
+/**
+ * append an object from String(file path)/Buffer/ReadableStream
+ * @param {String} name the object key
+ * @param {Mixed} file String(file path)/Buffer/ReadableStream
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.append = async function append(name, file, options) {
+  options = options || {};
+  if (options.position === undefined) options.position = '0';
+  options.subres = {
+    append: '',
+    position: options.position
+  };
+  options.method = 'POST';
+
+  const result = await this.put(name, file, options);
+  result.nextAppendPosition = result.res.headers['x-oss-next-append-position'];
+  return result;
+};
+
+/**
+ * put an object from String(file path)/Buffer/ReadableStream
+ * @param {String} name the object key
+ * @param {Mixed} file String(file path)/Buffer/ReadableStream
+ * @param {Object} options
+ *        {Object} options.callback The callback parameter is composed of a JSON string encoded in Base64
+ *        {String} options.callback.url  the OSS sends a callback request to this URL
+ *        {String} options.callback.host  The host header value for initiating callback requests
+ *        {String} options.callback.body  The value of the request body when a callback is initiated
+ *        {String} options.callback.contentType  The Content-Type of the callback requests initiatiated
+ *        {Object} options.callback.customValue  Custom parameters are a map of key-values, e.g:
+ *                  customValue = {
+ *                    key1: 'value1',
+ *                    key2: 'value2'
+ *                  }
+ * @return {Object}
+ */
+proto.put = async function put(name, file, options) {
+  let content;
+  options = options || {};
+  name = this._objectName(name);
+
+  if (isBuffer(file)) {
+    content = file;
+  } else if (is.string(file)) {
+    const stats = fs.statSync(file);
+    if (!stats.isFile()) {
+      throw new Error(`${file} is not file`);
+    }
+    options.mime = options.mime || mime.getType(path.extname(file));
+    options.contentLength = await this._getFileSize(file);
+    const getStream = () => fs.createReadStream(file);
+    const putStreamStb = (objectName, makeStream, configOption) => {
+      return this.putStream(objectName, makeStream(), configOption);
+    };
+    return await retry(putStreamStb, this.options.retryMax, {
+      errorHandler: err => {
+        const _errHandle = _err => {
+          const statusErr = [-1, -2].includes(_err.status);
+          const requestErrorRetryHandle = this.options.requestErrorRetryHandle || (() => true);
+          return statusErr && requestErrorRetryHandle(_err);
+        };
+        if (_errHandle(err)) return true;
+        return false;
+      }
+    })(name, getStream, options);
+  } else if (is.readableStream(file)) {
+    return await this.putStream(name, file, options);
+  } else {
+    throw new TypeError('Must provide String/Buffer/ReadableStream for put.');
+  }
+
+  options.headers = options.headers || {};
+  this._convertMetaToHeaders(options.meta, options.headers);
+
+  const method = options.method || 'PUT';
+  const params = this._objectRequestParams(method, name, options);
+
+  callback.encodeCallback(params, options);
+
+  params.mime = options.mime;
+  params.content = content;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  const ret = {
+    name,
+    url: this._objectUrl(name),
+    res: result.res
+  };
+
+  if (params.headers && params.headers['x-oss-callback']) {
+    ret.data = JSON.parse(result.data.toString());
+  }
+
+  return ret;
+};
+
+/**
+ * put an object from ReadableStream. If `options.contentLength` is
+ * not provided, chunked encoding is used.
+ * @param {String} name the object key
+ * @param {Readable} stream the ReadableStream
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.putStream = async function putStream(name, stream, options) {
+  options = options || {};
+  options.headers = options.headers || {};
+  name = this._objectName(name);
+  if (options.contentLength) {
+    options.headers['Content-Length'] = options.contentLength;
+  } else {
+    options.headers['Transfer-Encoding'] = 'chunked';
+  }
+  this._convertMetaToHeaders(options.meta, options.headers);
+
+  const method = options.method || 'PUT';
+  const params = this._objectRequestParams(method, name, options);
+  callback.encodeCallback(params, options);
+  params.mime = options.mime;
+  const transform = new Transform();
+  // must remove http stream header for signature
+  transform._transform = function _transform(chunk, encoding, done) {
+    this.push(chunk);
+    done();
+  };
+  params.stream = pump(stream, transform);
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  const ret = {
+    name,
+    url: this._objectUrl(name),
+    res: result.res
+  };
+
+  if (params.headers && params.headers['x-oss-callback']) {
+    ret.data = JSON.parse(result.data.toString());
+  }
+
+  return ret;
+};
+
+proto.getStream = async function getStream(name, options) {
+  options = options || {};
+
+  if (options.process) {
+    options.subres = options.subres || {};
+    options.subres['x-oss-process'] = options.process;
+  }
+
+  const params = this._objectRequestParams('GET', name, options);
+  params.customResponse = true;
+  params.successStatuses = [200, 206, 304];
+
+  const result = await this.request(params);
+
+  return {
+    stream: result.res,
+    res: {
+      status: result.status,
+      headers: result.headers
+    }
+  };
+};
+
+proto.putMeta = async function putMeta(name, meta, options) {
+  return await this.copy(name, name, {
+    meta: meta || {},
+    timeout: options && options.timeout,
+    ctx: options && options.ctx
+  });
+};
+
+proto.list = async function list(query, options) {
+  // prefix, marker, max-keys, delimiter
+
+  const params = this._objectRequestParams('GET', '', options);
+  params.query = query;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+  let objects = result.data.Contents || [];
+  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,
+      etag: obj.ETag,
+      type: obj.Type,
+      size: Number(obj.Size),
+      storageClass: obj.StorageClass,
+      owner: {
+        id: obj.Owner.ID,
+        displayName: obj.Owner.DisplayName
+      }
+    }));
+  }
+  let prefixes = result.data.CommonPrefixes || null;
+  if (prefixes) {
+    if (!Array.isArray(prefixes)) {
+      prefixes = [prefixes];
+    }
+    prefixes = prefixes.map(item => item.Prefix);
+  }
+  return {
+    res: result.res,
+    objects,
+    prefixes,
+    nextMarker: result.data.NextMarker || null,
+    isTruncated: result.data.IsTruncated === 'true'
+  };
+};
+
+proto.listV2 = async function listV2(query = {}, options = {}) {
+  const continuation_token = query['continuation-token'] || query.continuationToken;
+  delete query['continuation-token'];
+  delete query.continuationToken;
+  if (continuation_token) {
+    options.subres = Object.assign(
+      {
+        'continuation-token': continuation_token
+      },
+      options.subres
+    );
+  }
+  const params = this._objectRequestParams('GET', '', options);
+  params.query = Object.assign({ 'list-type': 2 }, query);
+  delete params.query['continuation-token'];
+  delete query.continuationToken;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+  let objects = result.data.Contents || [];
+  const that = this;
+  if (objects) {
+    if (!Array.isArray(objects)) {
+      objects = [objects];
+    }
+
+    objects = objects.map(obj => {
+      let owner = null;
+      if (obj.Owner) {
+        owner = {
+          id: obj.Owner.ID,
+          displayName: obj.Owner.DisplayName
+        };
+      }
+      return {
+        name: obj.Key,
+        url: that._objectUrl(obj.Key),
+        lastModified: obj.LastModified,
+        etag: obj.ETag,
+        type: obj.Type,
+        size: Number(obj.Size),
+        storageClass: obj.StorageClass,
+        owner
+      };
+    });
+  }
+  let prefixes = result.data.CommonPrefixes || null;
+  if (prefixes) {
+    if (!Array.isArray(prefixes)) {
+      prefixes = [prefixes];
+    }
+    prefixes = prefixes.map(item => item.Prefix);
+  }
+  return {
+    res: result.res,
+    objects,
+    prefixes,
+    isTruncated: result.data.IsTruncated === 'true',
+    keyCount: +result.data.KeyCount,
+    continuationToken: result.data.ContinuationToken || null,
+    nextContinuationToken: result.data.NextContinuationToken || null
+  };
+};
+
+/**
+ * Restore Object
+ * @param {String} name the object key
+ * @param {Object} options {type : Archive or ColdArchive}
+ * @returns {{res}}
+ */
+proto.restore = async function restore(name, options = { type: 'Archive' }) {
+  options = options || {};
+  options.subres = Object.assign({ restore: '' }, options.subres);
+  if (options.versionId) {
+    options.subres.versionId = options.versionId;
+  }
+  const params = this._objectRequestParams('POST', name, options);
+  if (options.type === 'ColdArchive') {
+    const paramsXMLObj = {
+      RestoreRequest: {
+        Days: options.Days ? options.Days : 2,
+        JobParameters: {
+          Tier: options.JobParameters ? options.JobParameters : 'Standard'
+        }
+      }
+    };
+    params.content = obj2xml(paramsXMLObj, {
+      headers: true
+    });
+    params.mime = 'xml';
+  }
+  params.successStatuses = [202];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};
+
+proto._objectUrl = function _objectUrl(name) {
+  return this._getReqUrl({ bucket: this.options.bucket, object: name });
+};
+
+/**
+ * generator request params
+ * @return {Object} params
+ *
+ * @api private
+ */
+
+proto._objectRequestParams = function (method, name, options) {
+  if (!this.options.bucket && !this.options.cname) {
+    throw new Error('Please create a bucket first');
+  }
+
+  options = options || {};
+  name = this._objectName(name);
+  const params = {
+    object: name,
+    bucket: this.options.bucket,
+    method,
+    subres: options && options.subres,
+    additionalHeaders: options && options.additionalHeaders,
+    timeout: options && options.timeout,
+    ctx: options && options.ctx
+  };
+
+  if (options.headers) {
+    params.headers = {};
+    copy(options.headers).to(params.headers);
+  }
+  return params;
+};
+
+proto._objectName = function (name) {
+  return name.replace(/^\/+/, '');
+};
+
+proto._statFile = function (filepath) {
+  return new Promise((resolve, reject) => {
+    fs.stat(filepath, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+};
+
+proto._convertMetaToHeaders = function (meta, headers) {
+  if (!meta) {
+    return;
+  }
+
+  Object.keys(meta).forEach(k => {
+    headers[`x-oss-meta-${k}`] = meta[k];
+  });
+};
+
+proto._deleteFileSafe = function (filepath) {
+  return new Promise(resolve => {
+    fs.exists(filepath, exists => {
+      if (!exists) {
+        resolve();
+      } else {
+        fs.unlink(filepath, err => {
+          if (err) {
+            debug('unlink %j error: %s', filepath, err);
+          }
+          resolve();
+        });
+      }
+    });
+  });
+};

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

@@ -0,0 +1,295 @@
+/**
+ * Copyright(c) ali-sdk and other contributors.
+ * MIT Licensed
+ *
+ * Authors:
+ *   rockuw <rockuw@gmail.com> (http://rockuw.com)
+ */
+
+/**
+ * Module dependencies.
+ */
+
+const jstoxml = require('jstoxml');
+const utility = require('utility');
+const copy = require('copy-to');
+const urlutil = require('url');
+
+const proto = exports;
+
+/**
+ * RTMP operations
+ */
+
+/**
+ * Create a live channel
+ * @param {String} id the channel id
+ * @param {Object} conf the channel configuration
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.putChannel = async function putChannel(id, conf, options) {
+  options = options || {};
+  options.subres = 'live';
+
+  const params = this._objectRequestParams('PUT', id, options);
+  params.xmlResponse = true;
+  params.content = jstoxml.toXML({
+    LiveChannelConfiguration: conf
+  });
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  let publishUrls = result.data.PublishUrls.Url;
+  if (!Array.isArray(publishUrls)) {
+    publishUrls = [publishUrls];
+  }
+  let playUrls = result.data.PlayUrls.Url;
+  if (!Array.isArray(playUrls)) {
+    playUrls = [playUrls];
+  }
+
+  return {
+    publishUrls,
+    playUrls,
+    res: result.res
+  };
+};
+
+/**
+ * Get the channel info
+ * @param {String} id the channel id
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.getChannel = async function getChannel(id, options) {
+  options = options || {};
+  options.subres = 'live';
+
+  const params = this._objectRequestParams('GET', id, options);
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    data: result.data,
+    res: result.res
+  };
+};
+
+/**
+ * Delete the channel
+ * @param {String} id the channel id
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.deleteChannel = async function deleteChannel(id, options) {
+  options = options || {};
+  options.subres = 'live';
+
+  const params = this._objectRequestParams('DELETE', id, options);
+  params.successStatuses = [204];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};
+
+/**
+ * Set the channel status
+ * @param {String} id the channel id
+ * @param {String} status the channel status
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.putChannelStatus = async function putChannelStatus(id, status, options) {
+  options = options || {};
+  options.subres = {
+    live: null,
+    status
+  };
+
+  const params = this._objectRequestParams('PUT', id, options);
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};
+
+/**
+ * Get the channel status
+ * @param {String} id the channel id
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.getChannelStatus = async function getChannelStatus(id, options) {
+  options = options || {};
+  options.subres = {
+    live: null,
+    comp: 'stat'
+  };
+
+  const params = this._objectRequestParams('GET', id, options);
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    data: result.data,
+    res: result.res
+  };
+};
+
+/**
+ * List the channels
+ * @param {Object} query the query parameters
+ *  filter options:
+ *   - prefix {String}: the channel id prefix (returns channels with this prefix)
+ *   - marker {String}: the channle id marker (returns channels after this id)
+ *   - max-keys {Number}: max number of channels to return
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.listChannels = async function listChannels(query, options) {
+  // prefix, marker, max-keys
+
+  options = options || {};
+  options.subres = 'live';
+
+  const params = this._objectRequestParams('GET', '', options);
+  params.query = query;
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  let channels = result.data.LiveChannel || [];
+  if (!Array.isArray(channels)) {
+    channels = [channels];
+  }
+
+  channels = channels.map(x => {
+    x.PublishUrls = x.PublishUrls.Url;
+    if (!Array.isArray(x.PublishUrls)) {
+      x.PublishUrls = [x.PublishUrls];
+    }
+    x.PlayUrls = x.PlayUrls.Url;
+    if (!Array.isArray(x.PlayUrls)) {
+      x.PlayUrls = [x.PlayUrls];
+    }
+
+    return x;
+  });
+
+  return {
+    channels,
+    nextMarker: result.data.NextMarker || null,
+    isTruncated: result.data.IsTruncated === 'true',
+    res: result.res
+  };
+};
+
+/**
+ * Get the channel history
+ * @param {String} id the channel id
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.getChannelHistory = async function getChannelHistory(id, options) {
+  options = options || {};
+  options.subres = {
+    live: null,
+    comp: 'history'
+  };
+
+  const params = this._objectRequestParams('GET', id, options);
+  params.xmlResponse = true;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  let records = result.data.LiveRecord || [];
+  if (!Array.isArray(records)) {
+    records = [records];
+  }
+  return {
+    records,
+    res: result.res
+  };
+};
+
+/**
+ * Create vod playlist
+ * @param {String} id the channel id
+ * @param {String} name the playlist name
+ * @param {Object} time the begin and end time
+ *  time:
+ *   - startTime {Number}: the begin time in epoch seconds
+ *   - endTime {Number}: the end time in epoch seconds
+ * @param {Object} options
+ * @return {Object}
+ */
+proto.createVod = async function createVod(id, name, time, options) {
+  options = options || {};
+  options.subres = {
+    vod: null
+  };
+  copy(time).to(options.subres);
+
+  const params = this._objectRequestParams('POST', `${id}/${name}`, options);
+  params.query = time;
+  params.successStatuses = [200];
+
+  const result = await this.request(params);
+
+  return {
+    res: result.res
+  };
+};
+
+/**
+ * Get RTMP Url
+ * @param {String} channelId the channel id
+ * @param {Object} options
+ *  options:
+ *   - expires {Number}: expire time in seconds
+ *   - params {Object}: the parameters such as 'playlistName'
+ * @return {String} the RTMP url
+ */
+proto.getRtmpUrl = function (channelId, options) {
+  options = options || {};
+  const expires = utility.timestamp() + (options.expires || 1800);
+  const res = {
+    bucket: this.options.bucket,
+    object: this._objectName(`live/${channelId}`)
+  };
+  const resource = `/${res.bucket}/${channelId}`;
+
+  options.params = options.params || {};
+  const query = Object.keys(options.params)
+    .sort()
+    .map(x => `${x}:${options.params[x]}\n`)
+    .join('');
+
+  const stringToSign = `${expires}\n${query}${resource}`;
+  const signature = this.signature(stringToSign);
+
+  const url = urlutil.parse(this._getReqUrl(res));
+  url.protocol = 'rtmp:';
+  url.query = {
+    OSSAccessKeyId: this.options.accessKeyId,
+    Expires: expires,
+    Signature: signature
+  };
+  copy(options.params).to(url.query);
+
+  return url.format();
+};

package/dist/node_modules/ali-oss/lib/setConfig.d.ts

@@ -0,0 +1,3 @@
+declare let client: any;
+export declare const setConfig: (options: any, ctx: any) => void;
+export { client };