@pi-r/aws 0.10.2 → 0.11.0

package/client/index.d.ts

@@ -7,7 +7,7 @@ import type { BucketCannedACL } from '@pi-r/aws-lib';
 import type { AWSDatabaseCredential, AWSDatabaseQuery, AWSStorageCredential, ConfigureBucketOptions } from '../types';
 
 import type { AttributeValue, DocumentClient } from 'aws-sdk/clients/dynamodb';
-import type { CreateBucketRequest, ListObjectsRequest as IListObjectsRequest } from 'aws-sdk/clients/s3';
+import type { CopyObjectRequest, CreateBucketRequest, ListObjectsRequest as IListObjectsRequest } from 'aws-sdk/clients/s3';
 
 declare namespace AWS {
     type ListObjectsRequest = IListObjectsRequest & RecursiveAction;
@@ -23,6 +23,7 @@ declare namespace AWS {
     function deleteObjects(this: IModule, credential: AWSStorageCredential, Bucket: string, service?: string, sdk?: string): Promise<void>;
     function deleteObjectsV2(this: IModule, credential: AWSStorageCredential, Bucket: string, recursive?: boolean, service?: string, sdk?: string): Promise<void>;
     function deleteObjectsV3(this: IModule, credential: AWSStorageCredential, Bucket: string, options?: ListObjectsRequest, service?: string, sdk?: string): Promise<void>;
+    function copyObject(this: IModule, credential: AWSStorageCredential, BucketSource: string, KeySource: string, Bucket: string, Key: string, options?: CopyObjectRequest, service?: string, sdk?: string): Promise<void>;
     function executeQuery(this: ICloud, credential: AWSDatabaseCredential, data: AWSDatabaseQuery, sessionKey?: string): Promise<QueryResult>;
     function executeBatchQuery(this: ICloud, credential: AWSDatabaseCredential, batch: AWSDatabaseQuery[], sessionKey?: string): Promise<BatchQueryResult>;
     function parseAttributeValue(value: unknown): AttributeValue;

package/client/index.js

@@ -12,6 +12,7 @@ exports.setBucketWebsite = setBucketWebsite;
 exports.deleteObjects = deleteObjects;
 exports.deleteObjectsV2 = deleteObjectsV2;
 exports.deleteObjectsV3 = deleteObjectsV3;
+exports.copyObject = copyObject;
 exports.executeQuery = executeQuery;
 exports.executeBatchQuery = executeBatchQuery;
 exports.parseAttributeValue = parseAttributeValue;
@@ -35,17 +36,17 @@ async function setCannedAcl(S3, Bucket, ACL, service = "aws", recursive) {
     }
     const callback = (err) => {
         if (!err) {
-            this.formatMessage(64, service, ['Grant ' + ACL, Bucket], '', { ...recursive ? Cloud.LOG_CLOUD_DELAYED : Cloud.LOG_CLOUD_COMMAND });
+            this.formatMessage(64, service, ['Grant ' + ACL, Bucket], '', Cloud.optionsLogMessage(recursive ? 'DELAYED' : 'COMMAND'));
         }
         else if (!recursive) {
-            if (err instanceof Error && err.code === 'OperationAborted') {
+            if ((0, types_1.isErrorCode)(err, 'OperationAborted')) {
                 setTimeout(() => {
                     void setCannedAcl.call(this, S3, Bucket, ACL, service, true);
                 }, 60000);
-                this.formatMessage(64, service, [`Grant ${ACL} (delayed)`, Bucket], err, { ...Cloud.LOG_CLOUD_DELAYED });
+                this.formatMessage(64, service, [`Grant ${ACL} (delayed)`, Bucket], err, Cloud.optionsLogMessage('DELAYED'));
             }
             else {
-                this.formatMessage(64, service, ['Unable to grant ' + ACL, Bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+                this.formatMessage(64, service, ['Unable to grant ' + ACL, Bucket], err, Cloud.optionsLogMessage('WARN'));
             }
         }
     };
@@ -149,7 +150,7 @@ async function createBucketV2(credential, Bucket, ACL, options, service = "aws",
         }
         return S3.createBucket(input).promise()
             .then(async () => {
-            this.formatMessage(64, service, ["Bucket created", Bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
+            this.formatMessage(64, service, ["Bucket created", Bucket], '', Cloud.optionsLogMessage('COMMAND'));
             if (ACL) {
                 await setCannedAcl.call(this, S3, Bucket, ACL, service);
             }
@@ -164,7 +165,7 @@ async function createBucketV2(credential, Bucket, ACL, options, service = "aws",
                     }
                     return true;
                 default:
-                    this.formatFail(64, service, ["Unable to create bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL });
+                    this.formatFail(64, service, ["Unable to create bucket", Bucket], err, Cloud.optionsLogMessage('FAIL'));
                     return false;
             }
         });
@@ -180,12 +181,12 @@ async function setBucketPolicy(credential, Bucket, options, service = "aws", sdk
     }
     return ('PublicAccessBlockConfiguration' in options ? S3.putPublicAccessBlock(options) : 'Policy' in options && (0, types_1.isString)(options.Policy) && !ibm ? S3.putBucketPolicy(options) : S3.putBucketAcl(options)).promise()
         .then(() => {
-        this.formatMessage(64, service, ["Bucket policy configured", Bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
+        this.formatMessage(64, service, ["Bucket policy configured", Bucket], '', Cloud.optionsLogMessage('COMMAND'));
         return true;
     })
         .catch((err) => {
         if (!isNoSuchBucket(err)) {
-            this.formatFail(64, service, ["Unable to update bucket policy", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            this.formatFail(64, service, ["Unable to update bucket policy", Bucket], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
         }
         return false;
     });
@@ -196,21 +197,25 @@ async function setBucketTagging(credential, Bucket, options, service = "aws", sd
     }
     const S3 = 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 });
+    const success = () => {
+        this.formatMessage(64, service, [deleting ? "Tags deleted" : "Tags created", Bucket], null, Cloud.optionsLogMessage('COMMAND'));
         return true;
     };
-    const error = (err) => {
+    const failed = (err) => {
         if (!isNoSuchBucket(err)) {
-            this.formatFail(64, service, ["Unable to update bucket tagging", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            this.formatFail(64, service, ["Unable to update bucket tagging", Bucket], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
         }
         return false;
     };
     if (deleting) {
-        return S3.deleteBucketTagging({ Bucket, ExpectedBucketOwner: options.ExpectedBucketOwner }).promise().then(command).catch((err) => error(err));
+        return S3.deleteBucketTagging({ Bucket, ExpectedBucketOwner: options.ExpectedBucketOwner }).promise()
+            .then(success)
+            .catch(failed);
     }
     options.Bucket = Bucket;
-    return S3.putBucketTagging(options).promise().then(command).catch(error);
+    return S3.putBucketTagging(options).promise()
+        .then(success)
+        .catch(failed);
 }
 async function setBucketWebsite(credential, Bucket, options, service = "aws", sdk = "aws-sdk/clients/s3") {
     const S3 = createStorageClient.call(this, credential, service, sdk);
@@ -224,12 +229,12 @@ async function setBucketWebsite(credential, Bucket, options, service = "aws", sd
     }
     return S3.putBucketWebsite({ Bucket, WebsiteConfiguration }).promise()
         .then(() => {
-        this.formatMessage(64, service, ["Bucket website configured", Bucket], WebsiteConfiguration, { ...Cloud.LOG_CLOUD_COMMAND });
+        this.formatMessage(64, service, ["Bucket website configured", Bucket], WebsiteConfiguration, Cloud.optionsLogMessage('COMMAND'));
         return true;
     })
         .catch((err) => {
         if (!isNoSuchBucket(err)) {
-            this.formatFail(64, service, ["Unable to set bucket website", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            this.formatFail(64, service, ["Unable to set bucket website", Bucket], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
         }
         return false;
     });
@@ -247,7 +252,7 @@ async function deleteObjectsV3(credential, Bucket, options = {}, service = "aws"
         recursive = options.recursive;
         delete options.recursive;
     }
-    options.Bucket ||= Bucket;
+    options.Bucket = Bucket;
     const S3 = createStorageClient.call(this, credential, service, sdk);
     return S3.listObjects(options).promise()
         .then(async ({ Contents }) => {
@@ -261,20 +266,35 @@ async function deleteObjectsV3(credential, Bucket, options = {}, service = "aws"
                 const Deleted = data.Deleted;
                 if ((0, types_1.isArray)(Deleted)) {
                     const files = Deleted.length + ' files';
-                    this.formatMessage(64, service, ["Bucket emptied" + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', { ...Cloud.LOG_CLOUD_COMMAND });
+                    this.formatMessage(64, service, ["Bucket emptied" + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', Cloud.optionsLogMessage('COMMAND'));
                 }
             })
                 .catch((err) => {
-                this.formatFail(64, service, ["Unable to empty bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+                this.formatFail(64, service, ["Unable to empty bucket", Bucket], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
             });
         }
     })
         .catch((err) => {
         if (!isNoSuchBucket(err)) {
-            this.formatFail(64, service, ["Unable to list bucket", Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            this.formatFail(64, service, ["Unable to list bucket", Bucket], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
         }
     });
 }
+async function copyObject(credential, BucketSource, KeySource, Bucket, Key, options = {}, service = "aws", sdk = "aws-sdk/clients/s3") {
+    const S3 = createStorageClient.call(this, credential, service, sdk);
+    const index = Key.lastIndexOf('/');
+    if (index !== -1) {
+        await S3.putObject({ Bucket, Key: Key.substring(0, index + 1), Body: Buffer.from(''), ContentLength: 0 }).promise().catch(() => { });
+    }
+    const CopySource = BucketSource + '/' + KeySource;
+    return S3.copyObject({ ...options, Bucket, Key, CopySource }).promise()
+        .then(() => {
+        this.formatMessage(64, service, ["Copy success", Bucket], CopySource, Cloud.optionsLogMessage('COMMAND'));
+    })
+        .catch((err) => {
+        this.formatFail(64, service, ["Copy failed", Bucket + '/' + Key], err, Cloud.optionsLogMessage('FAIL', { fatal: false }));
+    });
+}
 async function executeQuery(credential, data, sessionKey) {
     return (await executeBatchQuery.call(this, credential, [data], sessionKey))[0] || [];
 }
@@ -419,7 +439,7 @@ function parseAttributeValue(value) {
     return { NULL: true };
 }
 function isNoSuchBucket(err) {
-    return err instanceof Error && err.code === 'NoSuchBucket';
+    return (0, types_1.isErrorCode)(err, 'NoSuchBucket');
 }
 exports.CLOUD_UPLOAD_STREAM = true;
 exports.CLOUD_UPLOAD_CHUNK = true;

package/download/index.js

@@ -1,6 +1,7 @@
 "use strict";
 const Cloud = require("@e-mc/cloud");
 const types_1 = require("@e-mc/types");
+const util_1 = require("@e-mc/cloud/util");
 const client_1 = require("@pi-r/aws");
 function download(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
     const s3 = client_1.createStorageClient.call(this, credential, service, sdk);
@@ -11,21 +12,30 @@ function download(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
             callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Bucket' : 'Key'));
             return;
         }
-        const location = Cloud.joinPath(Bucket, Key);
-        s3.getObject({ ...target.options, Bucket, Key, VersionId: target.versionId }, (err, result) => {
+        s3.getObject({ ...target.options, Bucket, Key, VersionId: target.versionId }, async (err, result) => {
             if (!err) {
                 callback(null, result.Body);
-                let deleteObject = target.deleteObject;
-                if (deleteObject) {
-                    if (!(0, types_1.isPlainObject)(deleteObject)) {
-                        deleteObject = undefined;
+                const copyTo = (0, util_1.intoArray)(target.copyObject);
+                if (copyTo) {
+                    const tasks = [];
+                    for (const { bucket, pathname, filename, options } of copyTo) {
+                        const keyObject = filename ? Cloud.joinPath(pathname, filename, true) : Key;
+                        tasks.push(client_1.copyObject
+                            .call(this, credential, Bucket, Key, bucket, keyObject, options, service, sdk)
+                            .catch((0, util_1.createErrorHandler)(this, service, Bucket)));
                     }
-                    s3.deleteObject({ ...deleteObject, Bucket, Key, VersionId: target.versionId }, error => {
+                    await Promise.all(tasks);
+                }
+                const deleteObject = target.deleteObject;
+                if (deleteObject) {
+                    const location = Cloud.joinPath(Bucket, Key);
+                    const deleteOptions = (0, types_1.isPlainObject)(deleteObject) ? deleteObject : undefined;
+                    s3.deleteObject({ ...deleteOptions, Bucket, Key, VersionId: target.versionId }, error => {
                         if (!error) {
-                            this.formatMessage(64, service, "Delete success", location, { ...Cloud.LOG_CLOUD_DELETE });
+                            this.formatMessage(64, service, "Delete success", location, Cloud.optionsLogMessage('DELETE'));
                         }
                         else {
-                            this.formatFail(64, service, ["Delete failed", location], error, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active });
+                            this.formatFail(64, service, ["Delete failed", location], error, Cloud.optionsLogMessage('FAIL', { fatal: !!target.active }));
                         }
                     });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/aws",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "AWS V2 cloud functions for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -20,10 +20,10 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.12.5",
-    "@e-mc/module": "^0.12.5",
-    "@e-mc/types": "^0.12.5",
-    "@pi-r/aws-lib": "^0.10.2",
+    "@e-mc/cloud": "^0.13.0",
+    "@e-mc/module": "^0.13.0",
+    "@e-mc/types": "^0.13.0",
+    "@pi-r/aws-lib": "^0.11.0",
     "aws-sdk": "^2.1692.0"
   }
 }

package/upload/index.js

@@ -15,29 +15,22 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
     const s3 = client_1.createStorageClient.call(this, credential, service, sdk);
     return async (data, callback) => {
         const { bucket: Bucket, localUri } = data;
-        const { pathname = '', flags = 0, fileGroup, contentType, metadata, tags: 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 = () => {
+        const complete = (err, url) => {
             BUCKET_SESSION.delete(service + Bucket);
             if (bucketKey) {
                 delete BUCKET_RESPONSE[bucketKey];
             }
+            callback(err, url);
         };
-        const errorResponse = (err) => {
-            cleanup();
-            callback(err);
-        };
-        const addLog = (err) => {
-            if (err instanceof Error) {
-                this.addLog(this.statusType.WARN, err, service, Bucket);
-            }
-        };
+        const addLog = (0, util_1.createErrorHandler)(this, Bucket, service);
         const configBucket = admin.configBucket;
         if (!BUCKET_SESSION.has(service + Bucket)) {
             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);
+                complete(null);
                 return;
             }
             BUCKET_SESSION.add(service + Bucket);
@@ -52,7 +45,7 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
                 if ((0, types_1.isPlainObject)(DefaultRetention)) {
                     s3.putObjectLockConfiguration({ Bucket, ObjectLockConfiguration: { ObjectLockEnabled: 'Enabled', Rule: { DefaultRetention } }, ExpectedBucketOwner, RequestPayer: options?.RequestPayer }, err => {
                         if (!err) {
-                            this.formatMessage(64, service, ["Bucket configured" + ' (Retention Policy)', Bucket], (0, aws_lib_1.formatDefaultRetention)(DefaultRetention), { ...Cloud.LOG_CLOUD_COMMAND });
+                            this.formatMessage(64, service, ["Bucket configured" + ' (Retention Policy)', Bucket], (0, aws_lib_1.formatDefaultRetention)(DefaultRetention), Cloud.optionsLogMessage('COMMAND'));
                         }
                         else {
                             addLog(err);
@@ -116,7 +109,7 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
                         break;
                     }
                 }
-                exists = await s3.headObject({ Bucket, Key: pathname ? Cloud.joinPath(pathname, filename) : filename }).promise()
+                exists = await s3.headObject({ Bucket, Key: Cloud.joinPath(pathname, filename, true) }).promise()
                     .then(() => true)
                     .catch((err) => {
                     if (err instanceof Error && err.code !== 'NotFound') {
@@ -126,11 +119,11 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
                 });
             } while (exists && ++i);
             if (i > 0) {
-                this.formatMessage(64, service, ["File renamed", current], filename, { ...Cloud.LOG_CLOUD_WARN });
+                this.formatMessage(64, service, ["File renamed", current], filename, Cloud.optionsLogMessage('WARN'));
             }
         }
         if (pathname) {
-            await s3.putObject({ Bucket, Key: pathname, Body: Buffer.from(''), ContentLength: 0 }).promise().catch(() => { });
+            await s3.putObject({ Bucket, Key: pathname.endsWith('/') ? pathname : pathname + '/', Body: Buffer.from(''), ContentLength: 0 }).promise().catch(() => { });
         }
         const partSize = flags & 4 ? (0, types_1.alignSize)(data.upload.chunkSize, 1024) : 0;
         const Key = [filename];
@@ -148,7 +141,7 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
                 }
             }
             catch (err) {
-                errorResponse(err);
+                complete(err);
                 return;
             }
         }
@@ -170,11 +163,11 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
             const first = i === 0;
             if (this.aborted) {
                 if (first) {
-                    errorResponse((0, types_1.createAbortError)());
+                    complete((0, types_1.createAbortError)());
                 }
                 return;
             }
-            const params = { ...options, Bucket, Key: pathname + Key[i], Body: Stream[i] || Body[i] };
+            const params = { ...options, Bucket, Key: Cloud.joinPath(pathname, Key[i], true), Body: Stream[i] || Body[i] };
             const readable = publicRead || active && publicRead !== false && !acl;
             let tags, length = -1;
             if (first) {
@@ -214,7 +207,7 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
             new aws.S3.ManagedUpload({ service: s3, params, tags, partSize: getPartSize(), queueSize: partSize > 0 ? data.upload.chunkLimit : undefined }).send((err, result) => {
                 if (err) {
                     if (first) {
-                        errorResponse(err);
+                        complete(err);
                     }
                     else {
                         addLog(err);
@@ -222,20 +215,30 @@ function upload(credential, service = "aws", sdk = "aws-sdk/clients/s3") {
                     return;
                 }
                 const url = endpoint ? Cloud.joinPath(endpoint, result.Key) : result.Location;
-                this.formatMessage(64, service, "Upload success", url, { ...Cloud.LOG_CLOUD_UPLOAD });
+                this.formatMessage(64, service, "Upload success", url, Cloud.optionsLogMessage('UPLOAD'));
                 if (first) {
                     if (length === 0) {
                         s3.deleteObjectTagging({ Bucket, Key: result.Key, ExpectedBucketOwner: params.ExpectedBucketOwner }, error => {
                             if (!error) {
-                                this.formatMessage(64, service, ["Tags deleted", Bucket], result.Key, { ...Cloud.LOG_CLOUD_COMMAND });
+                                this.formatMessage(64, service, ["Tags deleted", Bucket], result.Key, Cloud.optionsLogMessage('COMMAND'));
                             }
                             else {
                                 addLog(error);
                             }
                         });
                     }
-                    cleanup();
-                    callback(null, url);
+                    const copyTo = (0, util_1.intoArray)(data.upload.copyObject);
+                    if (copyTo) {
+                        const tasks = [];
+                        for (const { bucket: bucketName, pathname: pathObject = pathname, filename: fileObject, options: copyOptions } of copyTo) {
+                            const keyObject = fileObject ? Cloud.joinPath(pathObject, fileObject, true) : result.Key;
+                            tasks.push(client_1.copyObject
+                                .call(this, credential, Bucket, result.Key, bucketName, keyObject, copyOptions, service, sdk)
+                                .catch(addLog));
+                        }
+                        void Promise.all(tasks);
+                    }
+                    complete(null, url);
                 }
             });
         }