aws-v3-sdk 1.0.34 → 1.0.41

package/README.md

@@ -1,2 +1,138 @@
-# aws-v3-sdk
-AWS JS SDK UTILS
+# AWS SDK for JavaScript
+
+[![NPM version](https://img.shields.io/npm/v/aws-v3-sdk.svg)](https://www.npmjs.com/package/aws-v3-sdk)
+[![NPM downloads](https://img.shields.io/npm/dm/aws-v3-sdk.svg)](https://www.npmjs.com/package/aws-v3-sdk)
+
+
+## Version 1.0.40
+
+This package can be used to migrate to AWS SDK v3 from AWS SDK v2 without much change in exisint codebase.
+This package takes the exisint AWS SDK v2 format and convert it to the AWS SDK v3 format.
+
+
+AWS SDK V2
+```js
+const AWS = require('aws-sdk')
+const docClient = new AWS.DynamoDB.DocumentClient()
+let params = {
+    TableName: TABLE_NAME,
+    Key: {
+      'id': ID
+    }
+}
+docClient.get(params, function (err, data) {
+    console.log(data.Item)
+  })
+```
+AWS SDK V3
+```js
+const AWS = require('aws-v3-sdk')
+const docClient = new AWS.DynamoDB.DocumentClient()
+let params = {
+    TableName: TABLE_NAME,
+    Key: {
+      'id': ID
+    }
+}
+docClient.get(params, function (err, data) {
+    console.log(data.Item)
+})
+```
+
+## Table of Contents:
+* [Supported Function](#supported-function)
+* [Getting Started](#getting-Started)
+* [Getting Help](#getting-help)
+* [Contributing](#contributing)
+
+
+## Supported Functions
+
+1. Dynamo DB
+2. Lambda
+3. OpenSearch
+4. Cognito
+5. S3
+6. SNS
+7. SQS
+8. STS
+9. Cognito
+
+## Getting Started
+
+## How To Install
+
+### In Node.js
+
+The preferred way to install the AWS SDK for Node.js is to use the
+[npm](http://npmjs.org) package manager for Node.js. Simply type the following
+into a terminal window:
+
+```sh
+npm install aws-v3-sdk
+```
+
+Then within your application, you can reference the react native compatible version of the SDK with the following:
+We can use the old SDK format without migrating the code base. Just update the AWS import.
+
+```javascript
+const AWS = require('aws-v3-sdk')
+
+const s3 = new AWS.S3()
+
+const params = {
+    Bucket: <BUCKET NAME>,
+    Key: <FILE KEY>,
+    Body: <STRING DATA,
+    ContentType: 'text/json'
+
+}
+
+s3.putObject(params, (err, data) => {
+    if (err) {
+        < DO Stuff HERE >
+    } else {
+        < DO Stuff HERE >
+    }
+})
+```
+
+
+
+### Supported Functions
+
+**Dynamo DB**
+    get
+    query
+    scan
+    put
+    delete
+    update
+    batchWrite
+    transactWrite
+    batchGet
+
+S3
+    getSignedUrl
+    getObject
+    putObject
+    headObject
+    createMultipartUpload
+    completeMultipartUpload
+    
+
+
+### Known Limitations
+There are a few known limitations.
+
+ * This package has not been updated to handle all the AWS SDK APIs.
+
+
+# Contributing
+We welcome community contributions and pull requests. See [CONTRIBUTING.md](https://github.com/aws/aws-sdk-js/blob/master/CONTRIBUTING.md) for information on how to set up a development environment and submit code.
+
+## License
+
+This SDK is distributed under the
+[Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0),
+see LICENSE.txt and NOTICE.txt for more information.

package/clients/dynamo/DocumentClientAsync.js

@@ -1,130 +1,133 @@
-const { DynamoDB, DynamoDBClient } = require('@aws-sdk/client-dynamodb')
-const { DynamoDBDocument, DynamoDBDocumentClient, GetCommand, BatchWriteCommand, PutCommand, QueryCommand, ScanCommand, DeleteCommand } = require('@aws-sdk/lib-dynamodb')
+const { DynamoDBClient } = require('@aws-sdk/client-dynamodb')
+const {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  DeleteCommand,
+  UpdateCommand,
+  BatchGetCommand,
+  TransactWriteCommand,
+  BatchWriteCommand
+} = require('@aws-sdk/lib-dynamodb')
+
 const ddb = new DynamoDBClient()
 const documentClient = DynamoDBDocumentClient.from(ddb)
 
 class DocumentClientAsync {
-  get (params, callback) {
-    return new Promise((resolve, reject) => {
-      const getCommand = new GetCommand(params)
-      documentClient.send(getCommand, (err, response) => {
-        if (err || !response) {
-          return reject(err)
-        }
-        if (response.Item) {
-          return resolve(response)
-        } else if (!response.Item) {
-          return resolve({})
-        }
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
-      }
+  async get (params, callback) {
+    try {
+      const command = new GetCommand(params)
+      const result = await documentClient.send(command)
+      const response = result?.Item ? result : {}
+      if (typeof callback === 'function') callback(null, response)
+      return response
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
+  }
+
+  async query (params, callback) {
+    try {
+      const command = new QueryCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
-      }
-      return Promise.reject(error)
-    })
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 
-  query (params, callback) {
-    return new Promise((resolve, reject) => {
-      const getCommand = new QueryCommand(params)
-      documentClient.send(getCommand, (err, response) => {
-        if (err || !response) {
-          return resolve(err)
-        }
-        return resolve(response)
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
-      }
+  async scan (params, callback) {
+    try {
+      const command = new ScanCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
+  }
+
+  async put (params, callback) {
+    try {
+      if (params?.Item) {
+        params.Item = Object.fromEntries(
+          Object.entries(params.Item).filter(([, v]) => v !== undefined)
+        )
       }
-      return Promise.reject(error)
-    })
+      const command = new PutCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
+      return result
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 
-  put (params, callback) {
-    return new Promise((resolve, reject) => {
-      let item = params.Item
-      try {
-        item = Object.fromEntries(Object.entries(item).filter(([key, value]) => value !== undefined))
-      } catch (error) {
+  async delete (params, callback) {
+    try {
+      const command = new DeleteCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
+      return result
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
+  }
 
-      }
-      params.Item = item
-      const putCommand = new PutCommand(params)
-      documentClient.send(putCommand, (err, response) => {
-        if (err || !response) {
-          return resolve(err)
-        }
-        return resolve(response)
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
-      }
+  async update (params, callback) {
+    try {
+      const command = new UpdateCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
-      }
-      return Promise.reject(error)
-    })
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 
-  delete (params, callback) {
-    return new Promise((resolve, reject) => {
-      const docClient = DynamoDBDocument.from(new DynamoDB())
-      docClient.delete(params, (err, response) => {
-        if (err) {
-          return resolve(err)
-        } else {
-          return resolve(response)
-        }
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
-      }
+  async batchGet (params, callback) {
+    try {
+      const command = new BatchGetCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
-      }
-      return Promise.reject(error)
-    })
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 
-  update (params, callback) {
-    return new Promise((resolve, reject) => {
-      const docClient = DynamoDBDocument.from(new DynamoDB())
-      docClient.update(params, (err, response) => {
-        if (err) {
-          return resolve(err)
-        } else {
-          return resolve(response)
-        }
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
-      }
+  async batchWrite (params, callback) {
+    try {
+      const command = new BatchWriteCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
-      }
-      return Promise.reject(error)
-    })
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
+  }
+
+  async transactWrite (params, callback) {
+    try {
+      const command = new TransactWriteCommand(params)
+      const result = await documentClient.send(command)
+      if (typeof callback === 'function') callback(null, result)
+      return result
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 }
 

package/clients/lambda copy.js

@@ -0,0 +1,60 @@
+const { LambdaClient, InvokeCommand, InvokeAsyncCommand } = require('@aws-sdk/client-lambda')
+const { toUtf8, fromUtf8 } = require('@aws-sdk/util-utf8-node')
+
+const { Agent } = require('https')
+const { NodeHttpHandler } = require('@aws-sdk/node-http-handler')
+
+const keepAliveOptions = new NodeHttpHandler({
+  httpsAgent: new Agent({
+    keepAlive: false,
+    maxSockets: 50
+  })
+})
+
+class Lambda {
+  constructor (region, session) {
+    if (region && session) {
+      this.client = new LambdaClient({ region, credentials: session, requestHandler: keepAliveOptions })
+    } else {
+      this.client = new LambdaClient({ requestHandler: keepAliveOptions })
+    }
+  }
+
+  async invoke (params, callback) {
+    const command = new InvokeCommand(params)
+    this.client.send(command).then(response => {
+      if (response.Payload) {
+        response.Payload = toUtf8(response.Payload)
+      }
+      callback(null, response)
+    }).catch(err => {
+      callback(err)
+    })
+  }
+
+  invokeAsync (params, callback) {
+    return new Promise((resolve, reject) => {
+      const command = new InvokeCommand(params)
+      this.client.send(command).then(response => {
+        if (response.Payload) {
+          response.Payload = toUtf8(response.Payload)
+        }
+        resolve(response)
+      }).catch(err => {
+        resolve(err)
+      })
+    }).then(result => {
+      if (callback && typeof callback === 'function') {
+        callback(null, result)
+      }
+      return result
+    }).catch(error => {
+      if (callback && typeof callback === 'function') {
+        callback(error, null)
+      }
+      return Promise.reject(error)
+    })
+  }
+}
+
+module.exports = Lambda

package/clients/lambda.js

@@ -21,35 +21,33 @@ class Lambda {
   }
 
   async invoke (params, callback) {
-    const command = new InvokeCommand(params)
-    this.client.send(command).then(response => {
-      response.Payload = toUtf8(response.Payload)
-      callback(null, response)
-    }).catch(err => {
-      callback(err)
-    })
+    try {
+      const command = new InvokeCommand(params)
+      const result = await this.client.send(command)
+      if (result.Payload) {
+        result.Payload = toUtf8(result.Payload)
+      }
+      if (typeof callback === 'function') callback(null, result)
+      return result
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 
-  invokeAsync (params, callback) {
-    return new Promise((resolve, reject) => {
+  async invokeAsync (params, callback) {
+    try {
       const command = new InvokeCommand(params)
-      this.client.send(command).then(response => {
-        response.Payload = toUtf8(response.Payload)
-        resolve(response)
-      }).catch(err => {
-        resolve(err)
-      })
-    }).then(result => {
-      if (callback && typeof callback === 'function') {
-        callback(null, result)
+      const result = await this.client.send(command)
+      if (result.Payload) {
+        result.Payload = toUtf8(result.Payload)
       }
+      if (typeof callback === 'function') callback(null, result)
       return result
-    }).catch(error => {
-      if (callback && typeof callback === 'function') {
-        callback(error, null)
-      }
-      return Promise.reject(error)
-    })
+    } catch (error) {
+      if (typeof callback === 'function') callback(error, null)
+      throw error
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-v3-sdk",
-  "version": "1.0.34",
+  "version": "1.0.41",
   "description": "AWS v3 SDK Utils",
   "main": "index.js",
   "scripts": {