fsd-oss 0.10.1 → 0.11.1

package/lib/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const Path = require("path");
-const OSS = require("ali-oss");
 const slash = require("slash");
 const minimatch = require("minimatch");
 const Debugger = require("debug");
 const eachLimit = require("async/eachLimit");
 const RPC = require("@alicloud/pop-core");
+const simple_oss_client_1 = require("./simple-oss-client");
 const stream_1 = require("stream");
 const debug = Debugger('fsd-oss');
 const CALLBACK_BODY = 'bucket=${bucket}&path=${object}&etag=${etag}&size=${size}&mimeType=${mimeType}&height=${imageInfo.height}&width=${imageInfo.width}&format=${imageInfo.format}';
@@ -28,14 +28,12 @@ class OSSAdapter {
         if (options.endpoint)
             throw new Error('fsd-oss options "endpoint" has been deprecated, please use region/[internal]/[secure] instead!');
         this._options = options;
-        this._oss = new OSS({
+        this._oss = new simple_oss_client_1.default({
             accessKeyId: options.accessKeyId,
             accessKeySecret: options.accessKeySecret,
             bucket: options.bucket,
-            region: options.region,
-            internal: options.internal,
-            secure: options.secure,
-            timeout: options.timeout
+            endpoint: `https://${options.region}${options.internal ? '-internal' : ''}.aliyuncs.com`,
+            timeout: parseInt(options.timeout) || 0
         });
         if (options.accountId && options.roleName) {
             let stsEndpoint = 'https://sts.aliyuncs.com';
@@ -52,7 +50,7 @@ class OSSAdapter {
         this.createUploadToken = async (path, meta) => {
             if (!options.accountId || !options.roleName)
                 throw new Error('Can not create sts token, missing options: accountId and roleName!');
-            path = slash(Path.join(options.root, path)).substr(1);
+            path = slash(Path.join(options.root, path)).substring(1);
             let params = {
                 RoleArn: `acs:ram::${options.accountId}:role/${options.roleName}`,
                 RoleSessionName: 'fsd',
@@ -110,21 +108,21 @@ class OSSAdapter {
     async append(path, data) {
         debug('append %s', path);
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         if (typeof data === 'string') {
             data = Buffer.from(data);
         }
-        let options = {};
+        let position = 0;
         try {
-            options.position = await this.size(path);
+            position = await this.size(path);
         }
         catch (e) { }
-        await this._oss.append(p, data, options);
+        await this._oss.append(p, data, { position });
     }
     async createReadStream(path, options) {
         debug('createReadStream %s options: %o', path, options);
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         let opts = {};
         if (options) {
             let start = options.start || 0;
@@ -140,45 +138,42 @@ class OSSAdapter {
                 opts.headers = { Range: `bytes=${Range}` };
             }
         }
-        let res = await this._oss.getStream(p, opts);
-        if (!res || !res.stream)
-            throw new Error('no stream');
-        return res.stream;
+        return (await this._oss.get(p, opts).stream());
     }
     async createWriteStream(path, options) {
         debug('createWriteStream %s', path);
         if (options === null || options === void 0 ? void 0 : options.start)
             throw new Error('fsd-oss read stream does not support start options');
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         let stream = new stream_1.PassThrough();
-        stream.promise = this._oss.putStream(p, stream);
+        stream.promise = this._oss.put(p, stream);
         return stream;
     }
     async unlink(path) {
         var _a;
         debug('unlink %s', path);
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         if (path.endsWith('/')) {
-            let nextMarker = '';
+            let continuationToken = '';
             do {
                 let list = await this._oss.list({
                     prefix: p,
-                    marker: nextMarker,
-                    'max-keys': 1000
-                }, {});
-                ({ nextMarker } = list);
-                if ((_a = list.objects) === null || _a === void 0 ? void 0 : _a.length) {
-                    let objects = list.objects.map((o) => o.name);
+                    continuationToken,
+                    maxKeys: 1000
+                });
+                continuationToken = list.NextContinuationToken;
+                if ((_a = list.Contents) === null || _a === void 0 ? void 0 : _a.length) {
+                    let objects = list.Contents.map((o) => o.Key);
                     await this._oss.deleteMulti(objects, {
                         quiet: true
                     });
                 }
-            } while (nextMarker);
+            } while (continuationToken);
         }
         else {
-            await this._oss.delete(p);
+            await this._oss.del(p);
         }
     }
     async mkdir(path, recursive) {
@@ -192,7 +187,7 @@ class OSSAdapter {
             }
         }
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         let res = await this._oss.put(p, Buffer.from(''));
         debug('mkdir result: %O', res);
     }
@@ -207,52 +202,37 @@ class OSSAdapter {
             pattern = recursion;
         }
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         let results = [];
-        let nextMarker = '';
+        let continuationToken = '';
         do {
             let list = await this._oss.list({
                 prefix: p,
                 delimiter,
-                marker: nextMarker,
-                'max-keys': 1000
-            }, {});
+                continuationToken,
+                maxKeys: 1000
+            });
             debug('list: %O', list);
-            ({ nextMarker } = list);
-            if (list.prefixes) {
-                list.prefixes.forEach((name) => {
-                    let relative = slash(Path.relative(p, name));
-                    if (!relative)
-                        return;
-                    results.push({
-                        name: `${relative}/`,
-                        metadata: {
-                            size: 0,
-                            lastModified: null
-                        }
-                    });
-                });
-            }
-            if (list.objects) {
-                list.objects.forEach((object) => {
-                    let { name } = object;
-                    let relative = slash(Path.relative(p, name));
+            continuationToken = list.NextContinuationToken;
+            if (list.Contents) {
+                list.Contents.forEach((object) => {
+                    let relative = slash(Path.relative(p, object.Key));
                     if (!relative)
                         return;
-                    if (name.endsWith('/'))
+                    if (object.Key.endsWith('/'))
                         relative += '/';
                     if (pattern && pattern !== '**/*' && !minimatch(relative, pattern))
                         return;
                     results.push({
                         name: relative,
                         metadata: {
-                            size: object.size,
-                            lastModified: new Date(object.lastModified)
+                            size: object.Size,
+                            lastModified: new Date(object.LastModified)
                         }
                     });
                 });
             }
-        } while (nextMarker);
+        } while (continuationToken);
         return results;
     }
     async createUrl(path, options) {
@@ -262,7 +242,7 @@ class OSSAdapter {
         if (urlPrefix && publicRead) {
             return urlPrefix + p;
         }
-        let url = this._oss.signatureUrl(p.substr(1), options);
+        let url = this._oss.signatureUrl(p.substring(1), options);
         if (urlPrefix) {
             url = url.replace(/https?\:\/\/[^/]+/, urlPrefix);
         }
@@ -274,29 +254,28 @@ class OSSAdapter {
         if (!(await this.exists(path)))
             throw new Error('The source path is not exists!');
         const { root } = this._options;
-        let from = slash(Path.join(root, path)).substr(1);
-        let to = slash(Path.join(root, dest)).substr(1);
+        let from = slash(Path.join(root, path)).substring(1);
+        let to = slash(Path.join(root, dest)).substring(1);
         if (path.endsWith('/')) {
             debug('copy directory %s -> %s', from, to);
-            let nextMarker = '';
+            let continuationToken = '';
             do {
                 let list = await this._oss.list({
                     prefix: from,
-                    marker: nextMarker,
-                    'max-keys': 1000
-                }, {});
+                    continuationToken,
+                    maxKeys: 1000
+                });
                 debug('list result: %O', list);
-                ({ nextMarker } = list);
-                if ((_a = list.objects) === null || _a === void 0 ? void 0 : _a.length) {
-                    await eachLimit(list.objects, 10, async (object) => {
-                        let { name } = object;
-                        debug(' -> copy %s', name);
-                        let relative = slash(Path.relative(from, name));
+                continuationToken = list.NextContinuationToken;
+                if ((_a = list.Contents) === null || _a === void 0 ? void 0 : _a.length) {
+                    await eachLimit(list.Contents, 10, async (object) => {
+                        debug(' -> copy %s', object.Key);
+                        let relative = slash(Path.relative(from, object.Key));
                         let target = slash(Path.join(to, relative));
-                        await this._oss.copy(target, name);
+                        await this._oss.copy(target, object.Key);
                     });
                 }
-            } while (nextMarker);
+            } while (continuationToken);
         }
         else {
             debug('copy file %s -> %s', from, to);
@@ -315,13 +294,13 @@ class OSSAdapter {
     async exists(path) {
         debug('check exists %s', path);
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         if (path.endsWith('/')) {
             let list = await this._oss.list({
                 prefix: p,
-                'max-keys': 1
-            }, {});
-            return list.objects && list.objects.length > 0;
+                maxKeys: 1
+            });
+            return list.Contents && list.Contents.length > 0;
         }
         try {
             await this._oss.head(p);
@@ -334,7 +313,7 @@ class OSSAdapter {
     async isFile(path) {
         debug('check is file %s', path);
         const { root } = this._options;
-        let p = slash(Path.join(root, path)).substr(1);
+        let p = slash(Path.join(root, path)).substring(1);
         try {
             await this._oss.head(p);
             return true;
@@ -345,7 +324,7 @@ class OSSAdapter {
     }
     async isDirectory(path) {
         debug('check is directory %s', path);
-        let p = slash(Path.join(this._options.root, path)).substr(1);
+        let p = slash(Path.join(this._options.root, path)).substring(1);
         try {
             await this._oss.head(p);
             return true;
@@ -356,30 +335,24 @@ class OSSAdapter {
     }
     async size(path) {
         debug('get file size %s', path);
-        let p = slash(Path.join(this._options.root, path)).substr(1);
-        let list = await this._oss.list({
-            prefix: p,
-            'max-keys': 1
-        }, {});
-        if (!list.objects || !list.objects.length || list.objects[0].name !== p)
-            throw new Error(`${path} is not exist!`);
-        return list.objects[0].size;
+        let p = slash(Path.join(this._options.root, path)).substring(1);
+        let res = await this._oss.head(p);
+        return parseInt(res.headers.get('Content-Length')) || 0;
     }
     async lastModified(path) {
         debug('get file lastModified %s', path);
-        let p = slash(Path.join(this._options.root, path)).substr(1);
+        let p = slash(Path.join(this._options.root, path)).substring(1);
         let res = await this._oss.head(p);
-        let headers = res.res.headers;
-        return new Date(headers['last-modified'] || headers.date);
+        let headers = res.headers;
+        return new Date(headers.get('Last-Modified'));
     }
     async initMultipartUpload(path, partCount) {
         debug('initMultipartUpload %s, partCount: %d', path, partCount);
-        let p = slash(Path.join(this._options.root, path)).substr(1);
-        let res = await this._oss.initMultipartUpload(p);
-        let { uploadId } = res;
+        let p = slash(Path.join(this._options.root, path)).substring(1);
+        let { UploadId } = await this._oss.initMultipartUpload(p);
         let files = [];
         for (let i = 1; i <= partCount; i += 1) {
-            files.push(`task://${uploadId}?${i}`);
+            files.push(`task://${UploadId}?${i}`);
         }
         return files;
     }
@@ -389,11 +362,12 @@ class OSSAdapter {
         if (!partTask.startsWith('task://'))
             throw new Error('Invalid part task id');
         let [uploadId, no] = partTask.replace('task://', '').split('?');
-        let res = await this._oss._uploadPart(p, uploadId, parseInt(no), {
-            stream: data,
-            size
+        let res = await this._oss.uploadPart(p, uploadId, parseInt(no), data, {
+            headers: {
+                'Content-Length': String(size)
+            }
         });
-        let etag = res.etag.replace(/"/g, '');
+        let etag = res.headers.get('ETag').replace(/"/g, '');
         return `${partTask.replace('task://', 'part://')}#${etag}`;
     }
     async completeMultipartUpload(path, parts) {

package/lib/simple-oss-client.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const qs = require("qs");
+const xmljs = require("xml-js");
+const sha1 = require("crypto-js/hmac-sha1");
+const md5 = require("crypto-js/md5");
+const Base64Encoder = require("crypto-js/enc-base64");
+const mime = require("mime-types");
+const akita_1 = require("akita");
+const client = akita_1.default.create({});
+class SimpleOSSClient {
+    constructor(config) {
+        this.config = config;
+        if (/^https?:/.test(config.endpoint)) {
+            let url = new URL(config.endpoint);
+            this.endpoint = url.host;
+        }
+        else {
+            this.endpoint = config.endpoint;
+        }
+    }
+    append(name, body, options) {
+        options = options || {};
+        let position = options.position || 0;
+        if (!options.mime)
+            options.mime = mime.lookup(name) || 'application/octet-stream';
+        return this.requestData('POST', `${name}?append&position=${position}`, body, options);
+    }
+    get(name, options) {
+        return this.request('GET', name, null, options);
+    }
+    put(name, body, options) {
+        options = options || {};
+        if (!options.mime)
+            options.mime = mime.lookup(name) || 'application/octet-stream';
+        return this.requestData('PUT', name, body, options);
+    }
+    async copy(to, from, options) {
+        options = options || {};
+        if (!options.headers)
+            options.headers = {};
+        options.headers['x-oss-copy-source'] = `/${this.config.bucket}/${from}`;
+        let res = await this.requestData('PUT', to, null, options);
+        res = Object.assign({ headers: res.headers }, res.CopyObjectResult);
+        return res;
+    }
+    async head(name, options) {
+        let response = await this.request('HEAD', name, null, options).response();
+        if (response.status === 404) {
+            throw new Error('NoSuchKey');
+        }
+        if (response.status !== 200) {
+            throw new Error(response.statusText);
+        }
+        return { headers: response.headers };
+    }
+    async list(options) {
+        let query = {
+            'list-type': '2'
+        };
+        if (options.prefix)
+            query.prefix = options.prefix;
+        if (options.delimiter)
+            query.delimiter = options.delimiter;
+        if (options.startAfter)
+            query['start-after'] = options.startAfter;
+        if (options.continuationToken)
+            query['continuation-token'] = options.continuationToken;
+        if (options.maxKeys)
+            query['max-keys'] = options.maxKeys;
+        if (options.encodingType)
+            query['encoding-type'] = options.encodingType;
+        if (options.fetchOwner)
+            query['fetch-owner'] = options.fetchOwner;
+        options.query = query;
+        let res = await this.requestData('GET', '', null, options);
+        res = Object.assign({ headers: res.headers }, res.ListBucketResult);
+        res.KeyCount = parseInt(res.KeyCount);
+        res.MaxKeys = parseInt(res.MaxKeys);
+        res.IsTruncated = res.IsTruncated === 'true';
+        res.Prefix = res.Prefix || '';
+        if (res.Contents) {
+            if (!Array.isArray(res.Contents))
+                res.Contents = [res.Contents];
+            res.Contents.forEach((content) => {
+                content.Size = parseInt(content.Size);
+            });
+        }
+        return res;
+    }
+    del(name, options) {
+        options = options || {};
+        if (!options.mime)
+            options.mime = mime.lookup(name) || 'application/octet-stream';
+        return this.requestData('DELETE', name, null, options);
+    }
+    async deleteMulti(names, options) {
+        options = options || {};
+        let body = `<?xml version="1.0" encoding="UTF-8"?><Delete><Quiet>${options.quiet || false}</Quiet>${names.map((name) => `<Object><Key>${name}</Key></Object>`).join('')}</Delete>`;
+        if (!options.mime)
+            options.mime = 'application/xml';
+        if (!options.headers)
+            options.headers = {};
+        options.headers['Content-MD5'] = md5(body).toString(Base64Encoder);
+        let res = await this.requestData('POST', '?delete', body, options);
+        res = Object.assign({ headers: res.headers }, res.DeleteResult);
+        if (res.Deleted) {
+            if (!Array.isArray(res.Deleted))
+                res.Deleted = [res.Deleted];
+            res.Deleted.forEach((deleted) => {
+                if (deleted.DeleteMarker)
+                    deleted.DeleteMarker = deleted.DeleteMarker === 'true';
+            });
+        }
+        return res;
+    }
+    async initMultipartUpload(name, options) {
+        options = options || {};
+        if (!options.mime)
+            options.mime = mime.lookup(name) || 'application/octet-stream';
+        let res = await this.requestData('POST', `${name}?uploads`, '', options);
+        return Object.assign({ headers: res.headers }, res.InitiateMultipartUploadResult);
+    }
+    uploadPart(name, uploadId, partNumber, body, options) {
+        options = options || {};
+        if (!options.mime)
+            options.mime = mime.lookup(name) || 'application/octet-stream';
+        return this.requestData('PUT', `${name}?partNumber=${partNumber}&uploadId=${uploadId}`, body, options);
+    }
+    async completeMultipartUpload(name, uploadId, parts, options) {
+        options = options || {};
+        options.mime = 'application/xml';
+        let body = `<?xml version="1.0" encoding="UTF-8"?>\n<CompleteMultipartUpload>${parts
+            .map((part) => `<Part><PartNumber>${part.number}</PartNumber><ETag>${part.etag}</ETag></Part>`)
+            .join('')}</CompleteMultipartUpload>`;
+        let res = await this.requestData('POST', `${name}?uploadId=${uploadId}`, body, options);
+        return Object.assign({ headers: res.headers }, res.CompleteMultipartUploadResult);
+    }
+    request(method, resource, body, options) {
+        options = options || {};
+        let headers = options.headers || {};
+        if (options.mime) {
+            headers['Content-Type'] = options.mime;
+        }
+        if (options.meta) {
+            Object.keys(options.meta).forEach((key) => {
+                headers[`x-oss-meta-${key}`] = String(options.meta[key]);
+            });
+        }
+        headers['x-oss-date'] = new Date().toUTCString();
+        if (this.config.stsToken) {
+            headers['x-oss-security-token'] = this.config.stsToken;
+        }
+        headers.authorization = this.getSign(method, `/${this.config.bucket}/${resource}`, headers);
+        let url = `https://${this.config.bucket}.${this.endpoint}/${resource}`;
+        return client.request(url, {
+            method,
+            headers,
+            query: options.query,
+            body,
+            timeout: options.timeout || this.config.timeout || 60000
+        });
+    }
+    async requestData(method, resource, body, options) {
+        let response = await this.request(method, resource, body, options).response();
+        let xml = await response.text();
+        if (!xml && response.status === 200) {
+            return {
+                headers: response.headers
+            };
+        }
+        let data = xmljs.xml2js(xml, { compact: true });
+        if (data.Error) {
+            throw new Error(data.Error.Message._text);
+        }
+        let res = Object.assign({ headers: response.headers }, conventXmlObject(data));
+        delete res._declaration;
+        return res;
+    }
+    signatureUrl(name, options) {
+        options = options || {};
+        let expires = parseInt((Date.now() / 1000 + (options.expires || 3600)));
+        let response = options.response || {};
+        let url = `https://${this.config.bucket}.${this.endpoint}/${name}`;
+        let query = {};
+        if (options.trafficLimit) {
+            query['x-oss-traffic-limit'] = options.trafficLimit;
+        }
+        if (options.response) {
+            Object.keys(response).forEach((key) => {
+                query[`response-${key}`] = response[key];
+            });
+        }
+        if (this.config.stsToken) {
+            query['security-token'] = this.config.stsToken;
+        }
+        let parts = [options.method || 'GET', '', '', String(expires)];
+        let string = qs.stringify(query);
+        parts.push(`/${this.config.bucket}/${name}${string ? `?${string}` : ''}`);
+        query.Signature = sha1(parts.join('\n'), this.config.accessKeySecret).toString(Base64Encoder);
+        query.OSSAccessKeyId = this.config.accessKeyId;
+        query.Expires = expires;
+        return `${url}?${qs.stringify(query)}`;
+    }
+    getSign(method, canonicalizedResource, headers) {
+        headers = headers || {};
+        let parts = [
+            method,
+            headers['Content-MD5'] || '',
+            headers['Content-Type'] || '',
+            headers['x-oss-date'] || new Date().toUTCString()
+        ];
+        Object.keys(headers)
+            .sort()
+            .forEach((key) => {
+            if (key.startsWith('x-oss-'))
+                parts.push(`${key}:${headers[key]}`);
+        });
+        parts.push(canonicalizedResource);
+        let sign = sha1(parts.join('\n'), this.config.accessKeySecret).toString(Base64Encoder);
+        return `OSS ${this.config.accessKeyId}:${sign}`;
+    }
+}
+exports.default = SimpleOSSClient;
+function conventXmlObject(object) {
+    if (Array.isArray(object))
+        return object.map(conventXmlObject);
+    if (object && typeof object === 'object') {
+        let keys = Object.keys(object);
+        if (keys.length === 1 && keys[0] === '_text')
+            return object._text;
+        let res = {};
+        for (let key of keys) {
+            res[key] = conventXmlObject(object[key]);
+        }
+        return res;
+    }
+    return object;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fsd-oss",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "Aliyun OSS adapter for fsd",
   "main": "lib/index.js",
   "types": "index.d.ts",
@@ -13,11 +13,14 @@
   "license": "MIT",
   "dependencies": {
     "@alicloud/pop-core": "^1.7.12",
-    "ali-oss": "^6.17.1",
+    "akita": "^1.0.4",
     "async": "*",
+    "crypto-js": "^4.1.1",
     "debug": "^4.3.4",
+    "mime-types": "^2.1.35",
     "minimatch": "^3.1.2",
-    "slash": "^3.0.0"
+    "slash": "^3.0.0",
+    "xml-js": "^1.6.11"
   },
-  "gitHead": "0e15db87212337e709c07bdc9c855132bb347db9"
+  "gitHead": "5f39a56e4f5ae28e6f15c7888413561a924b54de"
 }

package/simple-oss-client.d.ts

@@ -0,0 +1,167 @@
+import { Request } from 'akita';
+
+export default class SimpleOSSClient {
+  config: SimpleOSSClientConfig;
+  endpoint: string;
+
+  constructor(config: SimpleOSSClientConfig);
+
+  append(name: string, body: any, options?: AppendOptions): Promise<Result>;
+
+  get(name: string, options?: RequestOptions): Request<any>;
+
+  put(name: string, body: any, options?: RequestOptions): Promise<Result>;
+
+  copy(to: string, from: string, options?: RequestOptions): Promise<CopyResult>;
+
+  head(name: string, options?: RequestOptions): Promise<Result>;
+
+  list(options: ListOptions): Promise<ListResult>;
+
+  del(name: string, options?: RequestOptions): Promise<Result>;
+
+  deleteMulti(names: string[], options?: DeleteMultiOptions): Promise<DeleteMultiResult>;
+
+  initMultipartUpload(
+    name: string,
+    options?: RequestOptions
+  ): Promise<InitiateMultipartUploadResult>;
+
+  uploadPart(
+    name: string,
+    uploadId: string,
+    partNumber: number,
+    body: any,
+    options?: RequestOptions
+  ): Promise<Result>;
+
+  completeMultipartUpload(
+    name: string,
+    uploadId: string,
+    parts: Array<{ number: number; etag: string }>,
+    options?: RequestOptions
+  ): Promise<CompleteMultipartUploadResult>;
+
+  request(method: string, resource: string, body?: any, options?: RequestOptions): Request<any>;
+
+  requestData(method: string, resource: string, body?: any, options?: RequestOptions): Promise<any>;
+
+  signatureUrl(name: string, options?: SignatureUrlOptions): string;
+}
+
+export interface SimpleOSSClientConfig {
+  accessKeyId: string;
+  accessKeySecret: string;
+  bucket: string;
+  endpoint: string;
+  stsToken?: string;
+  timeout?: number;
+}
+
+export interface RequestOptions {
+  timeout?: number;
+  mime?: string;
+  meta?: UserMeta;
+  headers?: Record<string, string>;
+  query?: Record<string, string>;
+}
+
+export interface Result {
+  headers: Headers;
+}
+
+export interface UserMeta extends Record<string, string | number> {
+  uid: number;
+  pid: number;
+}
+
+export interface AppendOptions extends RequestOptions {
+  position?: number;
+}
+
+export interface CopyResult extends Result {
+  ETag: string;
+  LastModified: string;
+}
+
+export interface ListOptions extends RequestOptions {
+  prefix?: string;
+  delimiter?: string;
+  startAfter?: string;
+  continuationToken?: string;
+  maxKeys?: number;
+  encodingType?: string;
+  fetchOwner?: boolean;
+}
+
+export interface ListResult extends Result {
+  Name: string;
+  Prefix: string;
+  StartAfter: string;
+  MaxKeys: number;
+  EncodingType: string;
+  IsTruncated: boolean;
+  KeyCount: number;
+  NextContinuationToken?: string;
+  Contents: ListResultContent[];
+}
+
+export interface ListResultContent {
+  Key: string;
+  LastModified: string;
+  ETag: string;
+  Size: number;
+  StorageClass: string;
+  Owner: {
+    ID: string;
+    DisplayName: string;
+  };
+}
+
+export interface DeleteMultiOptions extends RequestOptions {
+  quiet?: boolean;
+}
+
+export interface DeleteMultiResult extends Result {
+  Deleted: Deleted[];
+}
+
+export interface Deleted {
+  Key: string;
+  DeleteMarker?: boolean;
+  DeleteMarkerVersionId?: string;
+  VersionId?: string;
+}
+
+export interface InitiateMultipartUploadResult extends Result {
+  Bucket: string;
+  Key: string;
+  UploadId: string;
+}
+
+export interface CompleteMultipartUploadResult extends Result {
+  EncodingType: string;
+  Location: string;
+  Bucket: string;
+  Key: string;
+  ETag: string;
+}
+
+export interface SignatureUrlOptions {
+  /**
+   * 连接过期时间，单位秒，默认为 1800 秒
+   */
+  expires?: number;
+  /**
+   * 请求方法，默认为 GET
+   */
+  method?: string;
+  /**
+   * 限速 x-oss-traffic-limit
+   */
+  trafficLimit?: number;
+  /**
+   * 返回头信息
+   */
+  response?: Record<string, string>;
+}

package/simple-oss-client.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = require('./lib/simple-oss-client').default;