@pi-r/aws-v3 0.6.1 → 0.6.3

package/README.md

@@ -1,5 +1,7 @@
 ### @pi-r/aws-v3
 
+https://e-mc.readthedocs.io/en/latest/cloud/aws-v3.html
+
 ### LICENSE
 
 MIT

package/client/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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;
 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 util_1 = require("@e-mc/cloud/util");
 const types_1 = require("@e-mc/types");
@@ -14,11 +15,14 @@ async function setCannedAcl(S3, client, Bucket, ACL, service = 'aws-v3', recursi
         case 1:
             Policy = (0, aws_1.getBucketPublicReadPolicy)(Bucket);
             break;
-        case 'private':
-            Policy = (0, aws_1.getPrivatePolicy)(Bucket);
+        case 'public-read-write':
+            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, false, true);
+            break;
+        case 'authenticated-read':
+            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, true);
             break;
         default:
-            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, ACL === 'authenticated-read', ACL === 'public-read-write');
+            Policy = (0, aws_1.getPrivatePolicy)(Bucket);
             break;
     }
     return client.send(new S3.PutBucketPolicyCommand({ Bucket, Policy }))
@@ -54,16 +58,77 @@ function sanitizeCredentials(credential) {
     }
     return result;
 }
+function fromProvider(credential) {
+    const from = credential.provider;
+    let credentials = credential.credentials;
+    if ((0, types_1.isPlainObject)(from)) {
+        if (from.http) {
+            credentials = Providers.fromHttp((0, types_1.isPlainObject)(from.http) ? from.http : {});
+        }
+        else if ((0, types_1.isPlainObject)(from.ini)) {
+            credentials = Providers.fromIni(from.ini);
+        }
+        else if ((0, types_1.isPlainObject)(from.cognitoIdentity)) {
+            credentials = Providers.fromCognitoIdentity(from.cognitoIdentity);
+        }
+        else if ((0, types_1.isPlainObject)(from.cognitoIdentityPool)) {
+            credentials = Providers.fromCognitoIdentityPool(from.cognitoIdentityPool);
+        }
+        else if ((0, types_1.isPlainObject)(from.temporaryCredentials)) {
+            credentials = Providers.fromTemporaryCredentials(from.temporaryCredentials);
+        }
+        else if ((0, types_1.isPlainObject)(from.webToken)) {
+            credentials = Providers.fromWebToken(from.webToken);
+        }
+        else if ((0, types_1.isPlainObject)(from.containerMetadata)) {
+            credentials = Providers.fromContainerMetadata(from.containerMetadata);
+        }
+        else if ((0, types_1.isPlainObject)(from.instanceMetadata)) {
+            credentials = Providers.fromInstanceMetadata(from.instanceMetadata);
+        }
+        else if ((0, types_1.isPlainObject)(from.process)) {
+            credentials = Providers.fromProcess(from.process);
+        }
+        else if ((0, types_1.isPlainObject)(from.tokenFile)) {
+            credentials = Providers.fromTokenFile(from.tokenFile);
+        }
+        else if ((0, types_1.isPlainObject)(from.sso)) {
+            credentials = Providers.fromSSO(from.sso);
+        }
+        else if (from.env && (0, aws_1.isEnvDefined)()) {
+            credentials = Providers.fromEnv();
+        }
+        else if (from.ini && (0, aws_1.isSharedCredentialsDefined)()) {
+            credentials = Providers.fromIni();
+        }
+        if ((0, types_1.isPlainObject)(credentials)) {
+            if (from.nodeProviderChain) {
+                credentials = Providers.fromNodeProviderChain((0, types_1.isPlainObject)(from.nodeProviderChain) ? { ...credentials, ...from.nodeProviderChain } : credentials);
+            }
+            credential.credentials = credentials;
+        }
+        delete credential.provider;
+    }
+    if ((0, types_1.isPlainObject)(credentials)) {
+        let expiration = credentials.expiration;
+        if (expiration) {
+            if ((0, types_1.isString)(expiration)) {
+                expiration = new Date(expiration);
+                credentials.expiration = expiration;
+            }
+            if (!(expiration instanceof Date && !isNaN(expiration.getTime()))) {
+                delete credentials.expiration;
+            }
+        }
+    }
+    return credential;
+}
 const isNoSuchBucket = (err) => err instanceof Error && err.name === 'NoSuchBucket';
 function createStorageClient(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
     try {
         sanitizeCredentials(credential);
-        const expiration = credential.credentials?.expiration;
-        if (expiration && !(expiration instanceof Date)) {
-            delete credential.expiration;
-        }
         const AWS = require(sdk);
-        return [new AWS.S3Client(credential), AWS];
+        return [new AWS.S3Client(fromProvider(credential)), AWS];
     }
     catch (err) {
         this.checkPackage(err, sdk.split('/')[0], { passThrough: true });
@@ -72,18 +137,17 @@ function createStorageClient(credential, service = 'aws-v3', sdk = '@aws-sdk/cli
 }
 exports.createStorageClient = createStorageClient;
 function createDatabaseClient(credential) {
-    return [Lib.DynamoDBDocumentClient.from(new Client.DynamoDBClient(credential), credential.translateConfig), Lib];
+    return [Lib.DynamoDBDocumentClient.from(new Client.DynamoDBClient(fromProvider(credential)), credential.translateConfig), Lib];
 }
 exports.createDatabaseClient = createDatabaseClient;
 function validateStorage(credential) {
     const credentials = sanitizeCredentials(credential);
     const profile = credential.profile;
-    if (profile || !credentials && process.env.AWS_SDK_LOAD_CONFIG === '1') {
-        const { fromIni } = require('@aws-sdk/credential-provider-ini');
-        credential.credentials = fromIni({ profile });
+    if (profile || !credentials && !credential.provider && (0, aws_1.isSharedCredentialsDefined)()) {
+        credential.credentials = Providers.fromIni({ profile });
         return true;
     }
-    return !!credentials && (typeof credentials === 'function' || (0, aws_1.isAccessDefined)(credentials) || (0, aws_1.isEnvDefined)());
+    return !!credentials && (typeof credentials === 'function' || (0, aws_1.isAccessDefined)(credentials)) || (0, types_1.isPlainObject)(credential.provider) || (0, aws_1.isEnvDefined)();
 }
 exports.validateStorage = validateStorage;
 function validateDatabase(credential, data) {
@@ -107,7 +171,7 @@ async function createBucketV2(credential, Bucket, ACL, options, service = 'aws-v
         .catch(async () => {
         const input = { ...options, Bucket };
         const region = credential.region;
-        if (typeof region === 'string' && region !== 'us-east-1') {
+        if ((0, types_1.isString)(region) && region !== 'us-east-1') {
             input.CreateBucketConfiguration || (input.CreateBucketConfiguration = { LocationConstraint: region });
         }
         return client.send(new AWS.CreateBucketCommand(input))
@@ -247,7 +311,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
                 }
             }
             const [db, AWS] = createClient();
-            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: (0, aws_1.parseAttributeValue)(id) };
+            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: id };
             const command = { TableName, Key };
             if (update) {
                 await db.send(new AWS.UpdateCommand({ ...command, ...update }));
@@ -261,13 +325,13 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             if (TableName) {
                 query.TableName = TableName;
             }
-            if (limit > 0) {
-                query.Limit = limit;
-            }
             if (!query.TableName) {
                 closeClient();
                 throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
             }
+            if (limit > 0) {
+                query.Limit = limit;
+            }
             if (useCache && (rows = getCache(queryString = Module.asString(query, true)))) {
                 result[i] = rows;
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/aws-v3",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "AWS V3 cloud functions for E-mc.",
   "main": "client/index.js",
   "publishConfig": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/anpham6/pi-r.git",
+    "url": "git+https://github.com/anpham6/pi-r.git",
     "directory": "src/cloud/aws-v3"
   },
   "keywords": [
@@ -20,12 +20,13 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.8.1",
-    "@e-mc/module": "^0.8.1",
-    "@e-mc/types": "^0.8.1",
-    "@pi-r/aws": "^0.6.1",
-    "@aws-sdk/client-dynamodb": "^3.485.0",
-    "@aws-sdk/client-s3": "^3.485.0",
-    "@aws-sdk/lib-dynamodb": "^3.485.0"
+    "@e-mc/cloud": "^0.8.3",
+    "@e-mc/module": "^0.8.3",
+    "@e-mc/types": "^0.8.3",
+    "@pi-r/aws": "^0.6.3",
+    "@aws-sdk/client-dynamodb": "^3.501.0",
+    "@aws-sdk/client-s3": "^3.501.0",
+    "@aws-sdk/credential-providers": "^3.501.0",
+    "@aws-sdk/lib-dynamodb": "^3.501.0"
   }
 }

package/upload/index.js

@@ -134,35 +134,37 @@ function upload(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
             client.send(new AWS.PutObjectCommand(params), { abortSignal: this.signal })
                 .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);
-                if (first) {
-                    if ((0, types_1.isPlainObject)(tags)) {
-                        const TagSet = [];
-                        for (const name in tags) {
-                            TagSet.push({ Key: name, Value: tags[name] });
-                        }
-                        client.send(new AWS.PutObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner, Tagging: { TagSet }, RequestPayer: params.RequestPayer }), error => {
-                            if (!error) {
-                                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Tags created" /* VAL_CLOUD.CREATE_TAG */, Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
-                            }
-                            else {
-                                addLog(error);
-                            }
-                        });
-                    }
-                    else if (tags === false) {
-                        client.send(new AWS.DeleteObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner }), error => {
-                            if (!error) {
-                                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Tags deleted" /* VAL_CLOUD.DELETE_TAG */, Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
-                            }
-                            else {
-                                addLog(error);
-                            }
-                        });
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* VAL_CLOUD.UPLOAD_FILE */, 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] });
                     }
-                    cleanup();
-                    callback(null, url);
+                    client.send(new AWS.PutObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner, Tagging: { TagSet }, RequestPayer: params.RequestPayer }), error => {
+                        if (!error) {
+                            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Tags created" /* VAL_CLOUD.CREATE_TAG */, Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
+                        }
+                        else {
+                            addLog(error);
+                        }
+                    });
                 }
-                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* VAL_CLOUD.UPLOAD_FILE */, url, { ...Cloud.LOG_CLOUD_UPLOAD });
+                else if (tags === false || length === 0) {
+                    client.send(new AWS.DeleteObjectTaggingCommand({ Bucket, Key: params.Key, ExpectedBucketOwner: params.ExpectedBucketOwner }), error => {
+                        if (!error) {
+                            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Tags deleted" /* VAL_CLOUD.DELETE_TAG */, Bucket], params.Key, { ...Cloud.LOG_CLOUD_COMMAND });
+                        }
+                        else {
+                            addLog(error);
+                        }
+                    });
+                }
+                cleanup();
+                callback(null, url);
             })
                 .catch(err => {
                 if (first) {