picgo-plugin-s3 1.2.4 → 1.3.1

package/README.md

@@ -29,10 +29,9 @@ picgo set uploader aws-s3
 | `endpoint`           | 指定自定义终端节点                                                      | `s3.us-west-2.amazonaws.com`                             |
 | `proxy`              | 代理地址                                                                | 支持http代理，例如 `http://127.0.0.1:1080`               |
 | `region`             | 指定执行服务请求的区域                                                  | `us-west-1`                                              |
-| `pathStyleAccess`    | 是否启用 S3 Path style                                                  | 默认为 `false`，使用 minio 请设置为 `true`               |
+| `pathStyleAccess`    | 是否启用 S3 Path style                                                  | 默认为 `false`，使用 minio 请设置为 `true` (e.g., https://s3.amazonaws.com/<bucketName>/<key> instead of https://<bucketName>.s3.amazonaws.com/<key>)              |
 | `rejectUnauthorized` | 是否拒绝无效 TLS 证书连接                                               | 默认为 `true`，如上传失败日志显示证书问题可设置为`false` |
-| `bucketEndpoint`     | 提供的 Endpoint 是否针对单个存储桶（如果它针对根 API 端点，则为 false） | 默认为 `false`                                           |
-| `acl`                | 访问控制列表，上传资源的访问策略                                        | 默认为 `public-read`                                     |
+| `acl`                | 访问控制列表，上传资源的访问策略                                        | 默认为 `public-read`, AWS 可选 `private"|"public-read"|"public-read-write"|"authenticated-read"|"aws-exec-read"|"bucket-owner-read"|"bucket-owner-full-control`                                     |
 
 **上传路径支持 payload：**
 

package/dist/config.d.ts

@@ -9,6 +9,5 @@ export interface IS3UserConfig {
     urlPrefix?: string;
     pathStyleAccess?: boolean;
     rejectUnauthorized?: boolean;
-    bucketEndpoint?: boolean;
     acl?: string;
 }

package/dist/index.js

@@ -13,7 +13,6 @@ module.exports = (ctx) => {
             uploadPath: "{year}/{month}/{md5}.{extName}",
             pathStyleAccess: false,
             rejectUnauthorized: true,
-            bucketEndpoint: false,
             acl: "public-read",
         };
         let userConfig = ctx.getConfig("picBed.aws-s3");
@@ -95,14 +94,6 @@ module.exports = (ctx) => {
                 required: false,
                 alias: "rejectUnauthorized",
             },
-            {
-                name: "bucketEndpoint",
-                type: "confirm",
-                default: userConfig.bucketEndpoint || false,
-                message: "提供的Endpoint是否针对单个存储桶（如果它针对根 API 端点，则为 false）",
-                required: false,
-                alias: "bucketEndpoint",
-            },
             {
                 name: "acl",
                 type: "input",
@@ -120,35 +111,43 @@ module.exports = (ctx) => {
         }
         if (userConfig.urlPrefix) {
             userConfig.urlPrefix = userConfig.urlPrefix.replace(/\/?$/, "");
+            if (userConfig.pathStyleAccess) {
+                userConfig.urlPrefix += "/" + userConfig.bucketName;
+            }
         }
         const client = uploader_1.default.createS3Client(userConfig);
         const output = ctx.output;
-        const tasks = output.map((item, idx) => uploader_1.default.createUploadTask(client, userConfig.bucketName, (0, utils_1.formatPath)(item, userConfig.uploadPath), item, idx, userConfig.acl));
+        const tasks = output.map((item, idx) => uploader_1.default.createUploadTask({
+            client,
+            index: idx,
+            bucketName: userConfig.bucketName,
+            path: (0, utils_1.formatPath)(item, userConfig.uploadPath),
+            item: item,
+            acl: userConfig.acl,
+            urlPrefix: userConfig.urlPrefix,
+        }));
+        let results;
         try {
-            const results = await Promise.all(tasks);
-            for (const result of results) {
-                const { index, url, imgURL } = result;
-                delete output[index].buffer;
-                delete output[index].base64Image;
-                output[index].url = url;
-                output[index].imgUrl = url;
-                if (userConfig.urlPrefix) {
-                    output[index].url = `${userConfig.urlPrefix}/${imgURL}`;
-                    output[index].imgUrl = `${userConfig.urlPrefix}/${imgURL}`;
-                }
-            }
-            return ctx;
+            results = await Promise.all(tasks);
         }
         catch (err) {
-            ctx.log.error("上传到 Amazon S3 发生错误，请检查配置是否正确");
+            ctx.log.error("上传到 S3 存储发生错误，请检查网络连接和配置是否正确");
             ctx.log.error(err);
             ctx.emit("notification", {
-                title: "Amazon S3 上传错误",
+                title: "S3 存储上传错误",
                 body: "请检查配置是否正确",
                 text: "",
             });
             throw err;
         }
+        for (const result of results) {
+            const { index, url, imgURL } = result;
+            delete output[index].buffer;
+            delete output[index].base64Image;
+            output[index].imgUrl = imgURL;
+            output[index].url = url;
+        }
+        return ctx;
     };
     const register = () => {
         ctx.helper.uploader.register("aws-s3", {

package/dist/uploader.d.ts

@@ -1,15 +1,29 @@
-import { S3 } from "aws-sdk";
+import { S3Client } from "@aws-sdk/client-s3";
 import { IImgInfo } from "picgo";
 import { IS3UserConfig } from "./config";
 export interface IUploadResult {
+    index: number;
+    key: string;
     url: string;
     imgURL: string;
+    versionId?: string;
+    eTag?: string;
+}
+declare function createS3Client(opts: IS3UserConfig): S3Client;
+interface createUploadTaskOpts {
+    client: S3Client;
+    bucketName: string;
+    path: string;
+    item: IImgInfo;
     index: number;
+    acl: string;
+    urlPrefix?: string;
 }
-declare function createS3Client(opts: IS3UserConfig): S3;
-declare function createUploadTask(s3: S3, bucketName: string, path: string, item: IImgInfo, index: number, acl: string): Promise<IUploadResult>;
+declare function createUploadTask(opts: createUploadTaskOpts): Promise<IUploadResult>;
+declare function getFileURL(opts: createUploadTaskOpts, eTag: string, versionId: string): Promise<string>;
 declare const _default: {
     createS3Client: typeof createS3Client;
     createUploadTask: typeof createUploadTask;
+    getFileURL: typeof getFileURL;
 };
 export default _default;

package/dist/uploader.js

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const aws_sdk_1 = require("aws-sdk");
-const utils_1 = require("./utils");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const node_http_handler_1 = require("@aws-sdk/node-http-handler");
 const url_1 = __importDefault(require("url"));
+const utils_1 = require("./utils");
 function createS3Client(opts) {
     let sslEnabled = true;
     try {
@@ -15,52 +17,95 @@ function createS3Client(opts) {
     catch (_a) {
         // eslint-disable-next-line no-empty
     }
-    const s3 = new aws_sdk_1.S3({
-        region: opts.region,
-        endpoint: opts.endpoint,
-        accessKeyId: opts.accessKeyID,
-        secretAccessKey: opts.secretAccessKey,
-        s3ForcePathStyle: opts.pathStyleAccess,
-        s3BucketEndpoint: opts.bucketEndpoint,
-        sslEnabled: sslEnabled,
-        httpOptions: {
-            agent: (0, utils_1.getProxyAgent)(opts.proxy, sslEnabled, opts.rejectUnauthorized),
+    const httpHandlerOpts = {};
+    if (sslEnabled) {
+        httpHandlerOpts.httpsAgent = ((0, utils_1.getProxyAgent)(opts.proxy, true, opts.rejectUnauthorized));
+    }
+    else {
+        httpHandlerOpts.httpAgent = ((0, utils_1.getProxyAgent)(opts.proxy, false, opts.rejectUnauthorized));
+    }
+    const clientOptions = {
+        region: opts.region || "auto",
+        endpoint: opts.endpoint || undefined,
+        credentials: {
+            accessKeyId: opts.accessKeyID,
+            secretAccessKey: opts.secretAccessKey,
         },
-    });
-    return s3;
+        tls: sslEnabled,
+        forcePathStyle: opts.pathStyleAccess,
+        requestHandler: new node_http_handler_1.NodeHttpHandler(httpHandlerOpts),
+    };
+    const client = new client_s3_1.S3Client(clientOptions);
+    return client;
 }
-function createUploadTask(s3, bucketName, path, item, index, acl) {
-    return new Promise((resolve, reject) => {
-        if (!item.buffer && !item.base64Image) {
-            reject(new Error("undefined image"));
-        }
-        (0, utils_1.extractInfo)(item)
-            .then(({ body, contentType, contentEncoding }) => {
-            const opts = {
-                Key: path,
-                Bucket: bucketName,
-                ACL: acl,
-                Body: body,
-                ContentType: contentType,
-                ContentEncoding: contentEncoding,
-            };
-            s3.upload(opts)
-                .promise()
-                .then((result) => {
-                resolve({
-                    url: result.Location,
-                    imgURL: result.Key,
-                    index,
-                });
-            })
-                .catch((err) => reject(err));
-        })
-            .catch((err) => {
-            reject(err);
-        });
+async function createUploadTask(opts) {
+    if (!opts.item.buffer && !opts.item.base64Image) {
+        return Promise.reject(new Error("undefined image"));
+    }
+    let body;
+    let contentType;
+    let contentEncoding;
+    try {
+        ;
+        ({ body, contentType, contentEncoding } = await (0, utils_1.extractInfo)(opts.item));
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+    const command = new client_s3_1.PutObjectCommand({
+        Bucket: opts.bucketName,
+        Key: opts.path,
+        ACL: opts.acl,
+        Body: body,
+        ContentType: contentType,
+        ContentEncoding: contentEncoding,
     });
+    let output;
+    try {
+        output = await opts.client.send(command);
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+    let url;
+    if (!opts.urlPrefix) {
+        try {
+            url = await getFileURL(opts, output.ETag, output.VersionId);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    else {
+        url = `${opts.urlPrefix}/${opts.path}`;
+    }
+    return {
+        index: opts.index,
+        key: opts.path,
+        url: url,
+        imgURL: url,
+        versionId: output.VersionId,
+        eTag: output.ETag,
+    };
+}
+async function getFileURL(opts, eTag, versionId) {
+    try {
+        const signedUrl = await (0, s3_request_presigner_1.getSignedUrl)(opts.client, new client_s3_1.GetObjectCommand({
+            Bucket: opts.bucketName,
+            Key: opts.path,
+            IfMatch: eTag,
+            VersionId: versionId,
+        }), { expiresIn: 3600 });
+        const urlObject = new URL(signedUrl);
+        urlObject.search = "";
+        return urlObject.href;
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
 }
 exports.default = {
     createS3Client,
     createUploadTask,
+    getFileURL,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picgo-plugin-s3",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "picgo amazon s3 uploader",
   "main": "dist/index.js",
   "publishConfig": {
@@ -39,7 +39,9 @@
     "typescript": "^4.8.4"
   },
   "dependencies": {
-    "aws-sdk": "^2.839.0",
+    "@aws-sdk/client-s3": "^3.304.0",
+    "@aws-sdk/lib-storage": "^3.304.0",
+    "@aws-sdk/s3-request-presigner": "^3.305.0",
     "file-type": "^16.2.0",
     "hpagent": "^1.2.0",
     "mime": "^2.5.2"