@pi-r/aws-v3 0.6.0 → 0.6.1

package/client/index.js

@@ -213,40 +213,42 @@ 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, length === 1 ? credential : { ...credential }));
+    const createClient = () => client || (client = createDatabaseClient.call(this, credential));
     const closeClient = () => client?.[0].destroy();
+    (0, aws_1.setDatabaseEndpoint)(credential);
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
-        const { service, table, id = '', query, partitionKey, key = partitionKey, limit = 0, update, ignoreCache } = item;
-        if (!table) {
-            closeClient();
-            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
-        }
-        (0, aws_1.setDatabaseEndpoint)(credential);
-        const renewCache = ignoreCache === 0;
+        let { service, table: TableName, id, query, partitionKey, key = partitionKey, limit = 0, update, ignoreCache } = item;
+        const useCache = caching && ignoreCache !== true;
         const getCache = (value) => {
             if (ignoreCache !== 1) {
-                cacheValue.renewCache = renewCache;
+                cacheValue.renewCache = ignoreCache === 0;
                 return this.getQueryResult(service, credential, value, cacheValue);
             }
         };
-        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? table + '_' : '';
+        cacheValue.exclusiveOf = Array.isArray(ignoreCache) ? ignoreCache : undefined;
+        let rows, queryString = '';
         if (key && (id || (0, types_1.isPlainObject)(key))) {
-            if (queryString) {
-                queryString += Module.asString(key, true) + id;
+            if (!TableName) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+            }
+            if (useCache) {
+                queryString = TableName + '_' + Module.asString(key, true) + (id !== undefined ? '_' + Module.asString(id, true) : '');
                 if (!update && (rows = getCache(queryString))) {
                     result[i] = rows;
                     continue;
                 }
             }
             const [db, AWS] = createClient();
-            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: id };
-            const command = { TableName: table, Key };
+            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: (0, aws_1.parseAttributeValue)(id) };
+            const command = { TableName, Key };
             if (update) {
                 await db.send(new AWS.UpdateCommand({ ...command, ...update }));
             }
@@ -256,18 +258,65 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             }
         }
         else if ((0, types_1.isPlainObject)(query)) {
-            if (queryString && (rows = getCache(queryString += Module.asString(query, true) + limit))) {
-                result[i] = rows;
-                continue;
+            if (TableName) {
+                query.TableName = TableName;
             }
-            query.TableName = table;
             if (limit > 0) {
                 query.Limit = limit;
             }
+            if (!query.TableName) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+            }
+            if (useCache && (rows = getCache(queryString = Module.asString(query, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            const [db, AWS] = createClient();
+            const { Count, Items } = await db.send(new AWS.QueryCommand(query));
+            if (Count && Items) {
+                rows = Items;
+            }
+        }
+        else if ((0, types_1.isArray)(query)) {
+            let params = (item.params || {});
+            if (!(0, types_1.isPlainObject)(params.RequestItems)) {
+                params.RequestItems = {};
+            }
+            TableName || (TableName = Object.keys(params.RequestItems)[0]);
+            if (!TableName) {
+                throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+            }
+            // @ts-ignore
+            const Item = (_a = params.RequestItems)[TableName] || (_a[TableName] = {});
+            Item.Keys = query;
+            params = { RequestItems: { [TableName]: Item } };
+            if (useCache && (rows = getCache(queryString = Module.asString(params, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            const [db, AWS] = createClient();
+            const { Responses } = await db.send(new AWS.BatchGetCommand(params));
+            if (Responses) {
+                rows = Responses[TableName];
+            }
+        }
+        else if (TableName) {
+            let params = item.params;
+            if ((0, types_1.isPlainObject)(params)) {
+                params.TableName = TableName;
+            }
+            else {
+                params = { TableName };
+            }
+            if (useCache && (rows = getCache(queryString = Module.asString(params, true)))) {
+                result[i] = rows;
+                continue;
+            }
             const [db, AWS] = createClient();
-            const output = await db.send(new AWS.QueryCommand(query));
-            if (output.Count && output.Items) {
-                rows = output.Items;
+            const { Count, Items } = await db.send(new AWS.ScanCommand(params));
+            if (Count && Items) {
+                rows = Items;
             }
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/aws-v3",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "AWS V3 cloud functions for E-mc.",
   "main": "client/index.js",
   "publishConfig": {
@@ -20,12 +20,12 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.8.0",
-    "@e-mc/module": "^0.8.0",
-    "@e-mc/types": "^0.8.0",
-    "@pi-r/aws": "^0.6.0",
-    "@aws-sdk/client-dynamodb": "^3.478.0",
-    "@aws-sdk/client-s3": "^3.478.0",
-    "@aws-sdk/lib-dynamodb": "^3.478.0"
+    "@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"
   }
 }

package/upload/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
-const fs = require("fs");
 const stream = require("stream");
 const util_1 = require("@e-mc/cloud/util");
 const aws_1 = require("@pi-r/aws");
@@ -80,15 +79,10 @@ function upload(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
         const Body = [data.buffer];
         const ContentType = [contentType];
         if (fileGroup) {
-            for (const [content, ext, localFile] of fileGroup) {
-                try {
-                    Body.push(typeof content === 'string' ? fs.readFileSync(content) : content);
-                    Key.push(ext === '.map' && localFile ? path.basename(localFile) : filename + ext);
-                }
-                catch (err) {
-                    addLog(err);
-                }
-            }
+            const [key, body, type] = (0, util_1.createKeyAndBody)(filename, fileGroup, addLog);
+            Key.push(...key);
+            Body.push(...body);
+            ContentType.push(...type);
         }
         for (let i = 0; i < Key.length; ++i) {
             const first = i === 0;