@pi-r/aws-v3 0.6.7 → 0.7.1

package/README.md

@@ -1,10 +1,7 @@
-# @pi-r/aws-v3
+### @pi-r/aws-v3
 
-## Documentation
+https://e-mc.readthedocs.io/en/latest/cloud/aws-v3.html
 
-- [E-mc](https://e-mc.readthedocs.io/en/latest/cloud/aws-v3.html)
-- [squared](https://squared.readthedocs.io)
-
-## LICENSE
+### LICENSE
 
 MIT

package/client/index.js

@@ -1,27 +1,26 @@
 "use strict";
-exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.validateDatabase = exports.validateStorage = exports.createDatabaseClient = exports.createStorageClient = void 0;
+exports.CLOUD_UPLOAD_CHUNK = exports.CLOUD_UPLOAD_STREAM = exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketTagging = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.validateDatabase = exports.validateStorage = exports.createDatabaseClient = exports.createStorageClient = void 0;
 const Lib = require("@aws-sdk/lib-dynamodb");
 const Client = require("@aws-sdk/client-dynamodb");
 const Providers = require("@aws-sdk/credential-providers");
-const aws_1 = require("@pi-r/aws");
+const Cloud = require("@e-mc/cloud");
 const util_1 = require("@e-mc/cloud/util");
 const types_1 = require("@e-mc/types");
-const Module = require("@e-mc/module");
-const Cloud = require("@e-mc/cloud");
-async function setCannedAcl(S3, client, Bucket, ACL, service = 'aws-v3', recursive) {
+const aws_lib_1 = require("@pi-r/aws-lib");
+async function setCannedAcl(S3, client, Bucket, ACL, service = "aws-v3", recursive) {
     let Policy;
     switch (ACL) {
         case 1:
-            Policy = (0, aws_1.getBucketPublicReadPolicy)(Bucket);
+            Policy = (0, aws_lib_1.getBucketPublicReadPolicy)(Bucket);
             break;
-        case 'public-read-write':
-            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, false, true);
+        case "public-read-write":
+            Policy = (0, aws_lib_1.getPublicReadPolicy)(Bucket, false, true);
             break;
-        case 'authenticated-read':
-            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, true);
+        case "authenticated-read":
+            Policy = (0, aws_lib_1.getPublicReadPolicy)(Bucket, true);
             break;
         default:
-            Policy = (0, aws_1.getPrivatePolicy)(Bucket);
+            Policy = (0, aws_lib_1.getPrivatePolicy)(Bucket);
             break;
     }
     return client.send(new S3.PutBucketPolicyCommand({ Bucket, Policy }))
@@ -40,23 +39,6 @@ async function setCannedAcl(S3, client, Bucket, ACL, service = 'aws-v3', recursi
         }
     });
 }
-function sanitizeCredentials(credential) {
-    const result = credential.credentials || (credential.credentials = {});
-    for (const attr in credential) {
-        switch (attr) {
-            case 'accessKeyId':
-            case 'secretAccessKey':
-            case 'sessionToken':
-            case 'expiration':
-                if (typeof result !== 'function') {
-                    result[attr] = credential[attr];
-                }
-                delete credential[attr];
-                break;
-        }
-    }
-    return result;
-}
 function fromProvider(credential) {
     const from = credential.provider;
     let credentials = credential.credentials;
@@ -94,10 +76,10 @@ function fromProvider(credential) {
         else if ((0, types_1.isPlainObject)(from.sso)) {
             credentials = Providers.fromSSO(from.sso);
         }
-        else if (from.env && (0, aws_1.isEnvDefined)()) {
+        else if (from.env && (0, aws_lib_1.isEnvDefined)()) {
             credentials = Providers.fromEnv();
         }
-        else if (from.ini && (0, aws_1.isSharedCredentialsDefined)()) {
+        else if (from.ini && (0, aws_lib_1.isSharedCredentialsDefined)()) {
             credentials = Providers.fromIni();
         }
         if ((0, types_1.isPlainObject)(credentials)) {
@@ -123,9 +105,8 @@ function fromProvider(credential) {
     return credential;
 }
 const isNoSuchBucket = (err) => err instanceof Error && err.name === 'NoSuchBucket';
-function createStorageClient(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+function createStorageClient(credential, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     try {
-        sanitizeCredentials(credential);
         const AWS = require(sdk);
         return [new AWS.S3Client(fromProvider(credential)), AWS];
     }
@@ -140,25 +121,24 @@ function createDatabaseClient(credential) {
 }
 exports.createDatabaseClient = createDatabaseClient;
 function validateStorage(credential) {
-    const credentials = sanitizeCredentials(credential);
-    const profile = credential.profile;
-    if (profile || !credentials && !credential.provider && (0, aws_1.isSharedCredentialsDefined)()) {
-        credential.credentials = Providers.fromIni({ profile });
+    const credentials = credential.credentials;
+    if (!credentials && !credential.provider && (0, aws_lib_1.isSharedCredentialsDefined)()) {
+        credential.credentials = Providers.fromIni();
         return true;
     }
-    return !!credentials && (typeof credentials === 'function' || (0, aws_1.isAccessDefined)(credentials)) || (0, types_1.isPlainObject)(credential.provider) || (0, aws_1.isEnvDefined)();
+    return !!credentials && ((0, aws_lib_1.isAccessDefined)(credentials) || typeof credentials === 'function') || (0, types_1.isPlainObject)(credential.provider) || (0, aws_lib_1.isEnvDefined)();
 }
 exports.validateStorage = validateStorage;
 function validateDatabase(credential, data) {
-    return (0, aws_1.isDatabaseDefined)(credential, data) && validateStorage(credential);
+    return (0, aws_lib_1.isDatabaseDefined)(credential, data) && validateStorage(credential);
 }
 exports.validateDatabase = validateDatabase;
-async function createBucket(credential, Bucket, publicRead, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
-    return createBucketV2.call(this, credential, Bucket, publicRead ? 'public-read' : undefined, undefined, service, sdk);
+async function createBucket(credential, Bucket, publicRead, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
+    return createBucketV2.call(this, credential, Bucket, publicRead ? "public-read" : undefined, undefined, service, sdk);
 }
 exports.createBucket = createBucket;
-async function createBucketV2(credential, Bucket, ACL, options, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
-    ACL = ACL === 1 ? 1 : (0, aws_1.checkBucketCannedACL)(ACL);
+async function createBucketV2(credential, Bucket, ACL, options, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
+    ACL = ACL === 1 ? 1 : (0, aws_lib_1.checkBucketCannedACL)(ACL);
     const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
     return client.send(new AWS.HeadBucketCommand({ Bucket }))
         .then(async () => {
@@ -170,8 +150,8 @@ async function createBucketV2(credential, Bucket, ACL, options, service = 'aws-v
         .catch(async () => {
         const input = { ...options, Bucket };
         const region = credential.region;
-        if ((0, types_1.isString)(region) && region !== 'us-east-1') {
-            input.CreateBucketConfiguration || (input.CreateBucketConfiguration = { LocationConstraint: region });
+        if ((0, types_1.isString)(region) && region !== "us-east-1") {
+            input.CreateBucketConfiguration ||= { LocationConstraint: region };
         }
         return client.send(new AWS.CreateBucketCommand(input))
             .then(async () => {
@@ -197,7 +177,7 @@ async function createBucketV2(credential, Bucket, ACL, options, service = 'aws-v
     });
 }
 exports.createBucketV2 = createBucketV2;
-async function setBucketPolicy(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+async function setBucketPolicy(credential, Bucket, options, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
     const block = 'PublicAccessBlockConfiguration' in options;
     const policy = !block && 'Policy' in options && !('ACL' in options);
@@ -207,7 +187,7 @@ async function setBucketPolicy(credential, Bucket, options, service = 'aws', sdk
         this.formatMessage(64, service, [block ? "Bucket configured" : policy ? "Bucket policy configured" : "Bucket ACL configured", Bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
         return true;
     })
-        .catch(err => {
+        .catch((err) => {
         if (!isNoSuchBucket(err)) {
             this.formatFail(64, service, ["Unable to update bucket policy", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
         }
@@ -215,7 +195,30 @@ async function setBucketPolicy(credential, Bucket, options, service = 'aws', sdk
     });
 }
 exports.setBucketPolicy = setBucketPolicy;
-async function setBucketWebsite(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+async function setBucketTagging(credential, Bucket, options, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
+    if (!(0, types_1.isPlainObject)(options) || !Array.isArray(options.Tagging?.TagSet)) {
+        return false;
+    }
+    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
+    const deleting = options.Tagging.TagSet.length === 0;
+    const command = () => {
+        this.formatMessage(64, service, [deleting ? "Tags deleted" : "Tags created", Bucket], null, { ...Cloud.LOG_CLOUD_COMMAND });
+        return true;
+    };
+    const error = (err) => {
+        if (!isNoSuchBucket(err)) {
+            this.formatFail(64, service, ["Unable to update bucket tagging", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        }
+        return false;
+    };
+    if (deleting) {
+        return client.send(new AWS.DeleteBucketTaggingCommand({ Bucket, ExpectedBucketOwner: options.ExpectedBucketOwner })).then(command).catch((err) => error(err));
+    }
+    options.Bucket = Bucket;
+    return client.send(new AWS.PutBucketTaggingCommand(options)).then(command).catch((err) => error(err));
+}
+exports.setBucketTagging = setBucketTagging;
+async function setBucketWebsite(credential, Bucket, options, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
     const WebsiteConfiguration = {};
     const { indexPage: Suffix, errorPage: Key } = options;
@@ -227,26 +230,26 @@ async function setBucketWebsite(credential, Bucket, options, service = 'aws', sd
     }
     return client.send(new AWS.PutBucketWebsiteCommand({ Bucket, WebsiteConfiguration }))
         .then(() => {
-        this.formatMessage(64, service, ["Bucket configured", Bucket], WebsiteConfiguration, { ...Cloud.LOG_CLOUD_COMMAND });
+        this.formatMessage(64, service, ["Bucket website configured", Bucket], WebsiteConfiguration, { ...Cloud.LOG_CLOUD_COMMAND });
         return true;
     })
-        .catch(err => {
+        .catch((err) => {
         if (!isNoSuchBucket(err)) {
-            this.formatFail(64, service, ["Unable to configure bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            this.formatFail(64, service, ["Unable to set bucket website", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
         }
         return false;
     });
 }
 exports.setBucketWebsite = setBucketWebsite;
-async function deleteObjects(credential, Bucket, service, sdk) {
+async function deleteObjects(credential, Bucket, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     return deleteObjectsV2.call(this, credential, Bucket, true, service, sdk);
 }
 exports.deleteObjects = deleteObjects;
-async function deleteObjectsV2(credential, Bucket, recursive = true, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+async function deleteObjectsV2(credential, Bucket, recursive = true, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
     return client.send(new AWS.ListObjectsCommand({ Bucket }))
         .then(async ({ Contents }) => {
-        if (Contents === null || Contents === void 0 ? void 0 : Contents.length) {
+        if (Contents?.length) {
             let Objects = Contents.map(data => ({ Key: data.Key }));
             if (!recursive) {
                 Objects = Objects.filter(value => !value.Key.includes('/'));
@@ -259,12 +262,12 @@ async function deleteObjectsV2(credential, Bucket, recursive = true, service = '
                     this.formatMessage(64, service, ["Bucket emptied" + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', { ...Cloud.LOG_CLOUD_COMMAND });
                 }
             })
-                .catch(err => {
+                .catch((err) => {
                 this.formatFail(64, service, ["Unable to empty bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
             });
         }
     })
-        .catch(err => {
+        .catch((err) => {
         if (!isNoSuchBucket(err)) {
             this.formatFail(64, service, ["Unable to list bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
         }
@@ -276,18 +279,17 @@ async function executeQuery(credential, data, sessionKey) {
 }
 exports.executeQuery = executeQuery;
 async function executeBatchQuery(credential, batch, sessionKey) {
-    var _a;
     const length = batch.length;
     const result = new Array(length);
     const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
     const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
     let client;
-    const createClient = () => client || (client = createDatabaseClient.call(this, credential));
-    const closeClient = () => client === null || client === void 0 ? void 0 : client[0].destroy();
-    (0, aws_1.setDatabaseEndpoint)(credential);
+    const createClient = () => client ||= createDatabaseClient.call(this, credential);
+    const closeClient = () => client?.[0].destroy();
+    (0, aws_lib_1.setDatabaseEndpoint)(credential);
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
-        let { service, table: TableName, id, query, partitionKey, key = partitionKey, limit = 0, update, ignoreCache } = item;
+        let { service, table: TableName, id, query, key, limit = 0, update, ignoreCache } = item;
         const useCache = caching && ignoreCache !== true;
         const getCache = (value) => {
             if (ignoreCache !== 1) {
@@ -303,7 +305,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
                 throw (0, util_1.formatError)(item, "Missing database table");
             }
             if (useCache) {
-                queryString = TableName + '_' + Module.asString(key, true) + (id !== undefined ? '_' + Module.asString(id, true) : '');
+                queryString = TableName + '_' + Cloud.asString(key, true) + (id !== undefined ? '_' + Cloud.asString(id, true) : '');
                 if (!update && (rows = getCache(queryString))) {
                     result[i] = rows;
                     continue;
@@ -331,7 +333,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             if (limit > 0) {
                 query.Limit = limit;
             }
-            if (useCache && (rows = getCache(queryString = Module.asString(query, true)))) {
+            if (useCache && (rows = getCache(queryString = Cloud.asString(query, true)))) {
                 result[i] = rows;
                 continue;
             }
@@ -346,14 +348,14 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             if (!(0, types_1.isPlainObject)(params.RequestItems)) {
                 params.RequestItems = {};
             }
-            TableName || (TableName = Object.keys(params.RequestItems)[0]);
+            TableName ||= Object.keys(params.RequestItems)[0];
             if (!TableName) {
                 throw (0, util_1.formatError)(item, "Missing database table");
             }
-            const Item = (_a = params.RequestItems)[TableName] || (_a[TableName] = {});
+            const Item = params.RequestItems[TableName] ||= {};
             Item.Keys = query;
             params = { RequestItems: { [TableName]: Item } };
-            if (useCache && (rows = getCache(queryString = Module.asString(params, true)))) {
+            if (useCache && (rows = getCache(queryString = Cloud.asString(params, true)))) {
                 result[i] = rows;
                 continue;
             }
@@ -371,7 +373,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             else {
                 params = { TableName };
             }
-            if (useCache && (rows = getCache(queryString = Module.asString(params, true)))) {
+            if (useCache && (rows = getCache(queryString = Cloud.asString(params, true)))) {
                 result[i] = rows;
                 continue;
             }
@@ -391,3 +393,5 @@ async function executeBatchQuery(credential, batch, sessionKey) {
     return result;
 }
 exports.executeBatchQuery = executeBatchQuery;
+exports.CLOUD_UPLOAD_STREAM = true;
+exports.CLOUD_UPLOAD_CHUNK = true;

package/download/index.js

@@ -1,33 +1,31 @@
 "use strict";
 const util_1 = require("@e-mc/cloud/util");
 const types_1 = require("@e-mc/types");
-const Module = require("@e-mc/module");
 const Cloud = require("@e-mc/cloud");
 const client_1 = require("@pi-r/aws-v3");
-module.exports = function download(config, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+module.exports = function download(config, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     const [client, AWS] = client_1.createStorageClient.call(this, config, service, sdk);
     return (data, callback) => {
         const { bucket: Bucket, download: target } = data;
-        const Key = target.filename;
+        const Key = target.keyname || target.filename;
         if (!Bucket || !Key) {
             callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Bucket' : 'Key'));
             return;
         }
-        const location = Module.joinPath(Bucket, Key);
-        let input = { Bucket, Key, VersionId: target.versionId };
-        client.send(new AWS.GetObjectCommand(input), { abortSignal: this.signal })
+        const location = Cloud.joinPath(Bucket, Key);
+        client.send(new AWS.GetObjectCommand({ ...target.options, Bucket, Key, VersionId: target.versionId }), { abortSignal: this.signal })
             .then(result => {
-            (0, util_1.readableAsBuffer)(result.Body).then(buffer => callback(null, buffer)).catch(err => callback(err));
-            const deleteObject = target.deleteObject;
+            (0, util_1.readableAsBuffer)(result.Body).then(buffer => callback(null, buffer)).catch((err) => callback(err));
+            let deleteObject = target.deleteObject;
             if (deleteObject) {
-                if ((0, types_1.isPlainObject)(deleteObject)) {
-                    input = Object.assign(deleteObject, input);
+                if (!(0, types_1.isPlainObject)(deleteObject)) {
+                    deleteObject = undefined;
                 }
-                client.send(new AWS.DeleteObjectCommand(input))
+                client.send(new AWS.DeleteObjectCommand({ ...deleteObject, Bucket, Key, VersionId: target.versionId }))
                     .then(() => this.formatMessage(64, service, "Delete success", location, { ...Cloud.LOG_CLOUD_DELETE }))
-                    .catch(err => this.formatFail(64, service, ["Delete failed", location], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active }));
+                    .catch((err) => this.formatFail(64, service, ["Delete failed", location], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active }));
             }
         })
-            .catch(err => callback(err));
+            .catch((err) => callback(err));
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/aws-v3",
-  "version": "0.6.7",
+  "version": "0.7.1",
   "description": "AWS V3 cloud functions for E-mc.",
   "main": "client/index.js",
   "publishConfig": {
@@ -20,13 +20,14 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.8.8",
-    "@e-mc/module": "^0.8.8",
-    "@e-mc/types": "^0.8.8",
-    "@pi-r/aws": "^0.6.7",
-    "@aws-sdk/client-dynamodb": "^3.540.0",
-    "@aws-sdk/client-s3": "^3.540.0",
-    "@aws-sdk/credential-providers": "^3.540.0",
-    "@aws-sdk/lib-dynamodb": "^3.540.0"
+    "@e-mc/cloud": "^0.9.2",
+    "@e-mc/module": "^0.9.2",
+    "@e-mc/types": "^0.9.2",
+    "@pi-r/aws-lib": "^0.7.1",
+    "@aws-sdk/client-dynamodb": "^3.584.0",
+    "@aws-sdk/client-s3": "^3.583.0",
+    "@aws-sdk/credential-providers": "^3.583.0",
+    "@aws-sdk/lib-dynamodb": "^3.584.0",
+    "@aws-sdk/lib-storage": "^3.583.0"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,41 @@
+import type { CloudDatabase, CloudStorage } from '@e-mc/types/lib/cloud';
+
+import type { AwsAuthInputConfig } from '@aws-sdk/middleware-signing';
+import type { DynamoDBClientConfig, QueryCommandInput, ScanCommandInput } from '@aws-sdk/client-dynamodb';
+import type { BatchGetCommandInput, TranslateConfig, UpdateCommandInput } from '@aws-sdk/lib-dynamodb';
+import type { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import type { S3ClientConfig } from '@aws-sdk/client-s3';
+
+export interface AWSBaseCredential extends AwsAuthInputConfig {
+    provider?: {
+        http?: unknown;
+        ini?: unknown;
+        cognitoIdentity?: unknown;
+        cognitoIdentityPool?: unknown;
+        temporaryCredentials?: unknown;
+        webToken?: unknown;
+        containerMetadata?: unknown;
+        instanceMetadata?: unknown;
+        process?: unknown;
+        tokenFile?: unknown;
+        sso?: unknown;
+        env?: unknown;
+        nodeProviderChain?: unknown;
+    };
+}
+
+export type AWSStorage = CloudStorage<AWSStorageCredential, "aws-v3">;
+
+export interface AWSStorageCredential extends S3ClientConfig, AWSBaseCredential {}
+
+export interface AWSDatabaseQuery extends CloudDatabase<QueryCommandInput | ObjectMap<NativeAttributeValue>[], PlainObject, UpdateCommandInput, BatchGetCommandInput | ScanCommandInput> {
+    source: "cloud";
+    service: "aws-v3";
+    key?: string | AttributeKey;
+}
+
+export interface AWSDatabaseCredential extends Omit<DynamoDBClientConfig, "credentials">, AWSBaseCredential {
+    translateConfig?: TranslateConfig;
+}
+
+export type AttributeKey = Record<string, NativeAttributeValue>;

package/upload/index.js

@@ -1,24 +1,24 @@
 "use strict";
 const path = require("path");
+const fs = require("fs");
 const stream = require("stream");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const Cloud = require("@e-mc/cloud");
 const util_1 = require("@e-mc/cloud/util");
-const aws_1 = require("@pi-r/aws");
 const types_1 = require("@e-mc/types");
-const Module = require("@e-mc/module");
-const Cloud = require("@e-mc/cloud");
+const aws_lib_1 = require("@pi-r/aws-lib");
 const client_1 = require("@pi-r/aws-v3");
 const BUCKET_SESSION = new Set();
 const BUCKET_RESPONSE = {};
-module.exports = function upload(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+module.exports = function upload(credential, service = "aws-v3", sdk = "@aws-sdk/client-s3") {
     const [client, AWS] = client_1.createStorageClient.call(this, credential, service, sdk);
     return async (data, callback) => {
-        var _a;
         const { bucket: Bucket, localUri } = data;
-        const { pathname = '', fileGroup, contentType, metadata, tags, endpoint, active, publicRead, acl, admin = {}, overwrite, options } = data.upload;
+        const { pathname = '', flags = 0, fileGroup, contentType, metadata, tags: Tags, endpoint, active, publicRead, acl, admin = {}, overwrite, options } = data.upload;
         let filename = data.upload.filename || path.basename(localUri), bucketKey;
         const cleanup = () => {
             BUCKET_SESSION.delete(service + Bucket);
-            if (bucketKey && bucketKey in BUCKET_RESPONSE) {
+            if (bucketKey) {
                 delete BUCKET_RESPONSE[bucketKey];
             }
         };
@@ -30,21 +30,49 @@ module.exports = function upload(credential, service = 'aws-v3', sdk = '@aws-sdk
         const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err, service, Bucket);
         const configBucket = admin.configBucket;
         if (!BUCKET_SESSION.has(service + Bucket)) {
-            const bucketAcl = admin.publicRead ? 'public-read' : admin.acl;
-            const response = BUCKET_RESPONSE[_a = bucketKey = (0, aws_1.getBucketKey)(credential, Bucket, bucketAcl, service, sdk)] || (BUCKET_RESPONSE[_a] = client_1.createBucketV2.call(this, credential, Bucket, bucketAcl, configBucket === null || configBucket === void 0 ? void 0 : configBucket.create, service, sdk));
+            const bucketAcl = admin.publicRead ? "public-read" : admin.acl;
+            const response = BUCKET_RESPONSE[bucketKey = (0, aws_lib_1.getBucketKey)(credential, Bucket, bucketAcl, service, sdk)] ||= client_1.createBucketV2.call(this, credential, Bucket, bucketAcl, configBucket?.create, service, sdk);
             if (!await response) {
                 errorResponse(null);
                 return;
             }
             BUCKET_SESSION.add(service + Bucket);
         }
-        const DefaultRetention = configBucket === null || configBucket === void 0 ? void 0 : configBucket.retentionPolicy;
-        if ((0, types_1.isPlainObject)(DefaultRetention)) {
-            client.send(new AWS.PutObjectLockConfigurationCommand({ Bucket, ObjectLockConfiguration: { ObjectLockEnabled: 'Enabled', Rule: { DefaultRetention } }, ExpectedBucketOwner: options === null || options === void 0 ? void 0 : options.ExpectedBucketOwner, RequestPayer: options === null || options === void 0 ? void 0 : options.RequestPayer }))
-                .then(() => {
-                aws_1.writeMessageDefaultRetention.call(this, Bucket, DefaultRetention, service);
-            })
-                .catch(err => addLog(err));
+        if (configBucket) {
+            const { cors: CORSConfiguration, lifecycle: LifecycleConfiguration, retentionPolicy: DefaultRetention } = configBucket;
+            const ExpectedBucketOwner = options?.ExpectedBucketOwner;
+            const commandMessage = (feature, message) => this.formatMessage(64, service, ["Bucket configured" + ` (${feature})`, message || Bucket], ExpectedBucketOwner, { ...Cloud[message === 'delete' ? 'LOG_CLOUD_WARN' : 'LOG_CLOUD_COMMAND'] });
+            if ((0, types_1.isPlainObject)(DefaultRetention)) {
+                client.send(new AWS.PutObjectLockConfigurationCommand({ Bucket, ObjectLockConfiguration: { ObjectLockEnabled: 'Enabled', Rule: { DefaultRetention } }, ExpectedBucketOwner, RequestPayer: options?.RequestPayer }))
+                    .then(() => {
+                    this.formatMessage(64, service, ["Bucket configured" + ' (Retention Policy)', Bucket], (0, aws_lib_1.formatDefaultRetention)(DefaultRetention), { ...Cloud.LOG_CLOUD_COMMAND });
+                })
+                    .catch((err) => addLog(err));
+            }
+            if (CORSConfiguration && Array.isArray(CORSConfiguration.CORSRules)) {
+                if (CORSConfiguration.CORSRules.length === 0) {
+                    client.send(new AWS.DeleteBucketCorsCommand({ Bucket, ExpectedBucketOwner }))
+                        .then(() => commandMessage('CORS', 'delete'))
+                        .catch((err) => addLog(err));
+                }
+                else {
+                    client.send(new AWS.PutBucketCorsCommand({ Bucket, CORSConfiguration, ExpectedBucketOwner }))
+                        .then(() => commandMessage('CORS'))
+                        .catch((err) => addLog(err));
+                }
+            }
+            if (LifecycleConfiguration && Array.isArray(LifecycleConfiguration.Rules)) {
+                if (LifecycleConfiguration.Rules.length === 0) {
+                    client.send(new AWS.DeleteBucketLifecycleCommand({ Bucket, ExpectedBucketOwner }))
+                        .then(() => commandMessage('Lifecycle', 'delete'))
+                        .catch((err) => addLog(err));
+                }
+                else {
+                    client.send(new AWS.PutBucketLifecycleConfigurationCommand({ Bucket, LifecycleConfiguration, ExpectedBucketOwner }))
+                        .then(() => commandMessage('Lifecycle'))
+                        .catch((err) => addLog(err));
+                }
+            }
         }
         if (!overwrite) {
             const current = filename;
@@ -57,9 +85,9 @@ module.exports = function upload(credential, service = 'aws-v3', sdk = '@aws-sdk
                         break;
                     }
                 }
-                exists = await client.send(new AWS.HeadObjectCommand({ Bucket, Key: pathname ? Module.joinPath(pathname, filename) : filename }))
+                exists = await client.send(new AWS.HeadObjectCommand({ Bucket, Key: pathname ? Cloud.joinPath(pathname, filename) : filename }))
                     .then(() => true)
-                    .catch(err => {
+                    .catch((err) => {
                     if (err instanceof Error && err.name !== 'NotFound') {
                         filename = (0, types_1.generateUUID)() + path.extname(current);
                         return true;
@@ -75,13 +103,37 @@ module.exports = function upload(credential, service = 'aws-v3', sdk = '@aws-sdk
             await client.send(new AWS.PutObjectCommand({ Bucket, Key: pathname, Body: Buffer.from(''), ContentLength: 0 })).catch(() => { });
         }
         const Key = [filename];
-        const Body = [data.buffer];
+        const Body = [];
+        const Stream = [];
         const ContentType = [contentType];
-        if (fileGroup) {
-            const [key, body, type] = (0, util_1.createKeyAndBody)(filename, fileGroup, addLog);
-            Key.push(...key);
-            Body.push(...body);
-            ContentType.push(...type);
+        let partSize = 0;
+        const getPartSize = () => partSize > 0 ? Math.max(partSize, 5242880) : undefined;
+        if (flags & 2) {
+            if (flags & 4) {
+                partSize = (0, types_1.alignSize)(data.upload.chunkSize, 1024);
+            }
+            try {
+                Stream.push(data.buffer.length ? stream.Readable.from(data.buffer, { highWaterMark: getPartSize() }) : fs.createReadStream(localUri, { highWaterMark: getPartSize(), signal: this.signal }));
+                if (fileGroup) {
+                    const [key, body, type] = (0, util_1.createKeyAndBody)(filename, fileGroup, 0, addLog, 2);
+                    Key.push(...key);
+                    Stream.push(...body);
+                    ContentType.push(...type);
+                }
+            }
+            catch (err) {
+                errorResponse(err);
+                return;
+            }
+        }
+        else {
+            Body.push(data.buffer);
+            if (fileGroup) {
+                const [key, body, type] = (0, util_1.createKeyAndBody)(filename, fileGroup, 0, addLog);
+                Key.push(...key);
+                Body.push(...body);
+                ContentType.push(...type);
+            }
         }
         for (let i = 0; i < Key.length; ++i) {
             const first = i === 0;
@@ -91,81 +143,62 @@ module.exports = function upload(credential, service = 'aws-v3', sdk = '@aws-sdk
                 }
                 return;
             }
-            const objectKey = Module.joinPath(pathname, Key[i]);
-            let params;
-            try {
-                params = { ...options, Bucket, Key: pathname + Key[i], Body: stream.Readable.from(Body[i]) };
-                const readable = publicRead || active && publicRead !== false && !acl;
-                if (first) {
-                    params.ContentType || (params.ContentType = ContentType[i]);
+            const objectKey = Cloud.joinPath(pathname, Key[i]);
+            const params = { ...options, Bucket, Key: pathname + Key[i], Body: Stream[i] || stream.Readable.from(Body[i]) };
+            const readable = publicRead || active && publicRead !== false && !acl;
+            let tags, length = -1;
+            if (first) {
+                params.ContentType ||= ContentType[i];
+                if (readable) {
+                    params.ACL = "public-read";
+                }
+                else if (acl) {
+                    params.ACL = acl;
+                }
+                if (metadata) {
+                    params.Metadata = metadata;
+                }
+                if ((0, types_1.isPlainObject)(Tags) && (length = Object.keys(Tags).length) > 0) {
+                    tags = [];
+                    for (const name in Tags) {
+                        tags.push({ Key: name, Value: Tags[name] });
+                    }
+                }
+                else if (Tags === false) {
+                    length = 0;
+                }
+            }
+            else {
+                params.ContentType = ContentType[i];
+                if (!params.ACL) {
                     if (readable) {
-                        params.ACL = 'public-read';
+                        params.ACL = "public-read";
                     }
                     else if (acl) {
                         params.ACL = acl;
                     }
-                    if (metadata) {
-                        params.Metadata = metadata;
-                    }
                 }
-                else {
-                    params.ContentType = ContentType[i];
-                    if (!params.ACL) {
-                        if (readable) {
-                            params.ACL = 'public-read';
-                        }
-                        else if (acl) {
-                            params.ACL = acl;
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (first) {
-                    errorResponse(err);
-                    return;
-                }
-                if (err instanceof Error) {
-                    this.addLog(this.statusType.WARN, err.message, service + ': ' + Bucket);
-                }
-                continue;
             }
-            client.send(new AWS.PutObjectCommand(params), { abortSignal: this.signal })
+            new lib_storage_1.Upload({ client, params, tags, partSize: getPartSize(), queueSize: partSize > 0 ? data.upload.chunkLimit : undefined }).done()
                 .then(() => {
-                const url = endpoint ? Module.joinPath(endpoint, objectKey) : Module.joinPath(`https://${Bucket}.s3.${!credential.region || credential.region === 'us-east-1' ? 'us-east-1.' : ''}amazonaws.com`, objectKey);
+                const url = endpoint ? Cloud.joinPath(endpoint, objectKey) : Cloud.joinPath(`https://${Bucket}.s3.${!credential.region || credential.region === "us-east-1" ? "us-east-1" + '.' : ''}amazonaws.com`, objectKey);
                 this.formatMessage(64, service, "Upload success", url, { ...Cloud.LOG_CLOUD_UPLOAD });
-                if (!first) {
-                    return;
-                }
-                let length = -1;
-                if ((0, types_1.isPlainObject)(tags) && (length = Object.keys(tags).length) > 0) {
-                    const TagSet = [];
-                    for (const name in tags) {
-                        TagSet.push({ Key: name, Value: tags[name] });
+                if (first) {
+                    if (length === 0) {
+                        client.send(new AWS.DeleteObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner }), error => {
+                            if (!error) {
+                                this.formatMessage(64, service, ["Tags deleted", Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
+                            }
+                            else {
+                                addLog(error);
+                            }
+                        });
                     }
-                    client.send(new AWS.PutObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner, Tagging: { TagSet }, RequestPayer: params.RequestPayer }), error => {
-                        if (!error) {
-                            this.formatMessage(64, service, ["Tags created", Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
-                        }
-                        else {
-                            addLog(error);
-                        }
-                    });
-                }
-                else if (tags === false || length === 0) {
-                    client.send(new AWS.DeleteObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner }), error => {
-                        if (!error) {
-                            this.formatMessage(64, service, ["Tags deleted", Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
-                        }
-                        else {
-                            addLog(error);
-                        }
-                    });
-                }
-                cleanup();
-                callback(null, url);
+                    cleanup();
+                    callback(null, url);
+                }
             })
-                .catch(err => {
+                .catch((err) => {
                 if (first) {
                     errorResponse(err);
                 }