node-lambda 1.3.0 → 2.0.0-alpha.0

package/.github/workflows/workflow.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [16.x, 18.x, 20.x]
+        node-version: [20.x, 22.x]
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-node@v4
@@ -32,7 +32,7 @@ jobs:
     - uses: actions/checkout@v4
     - uses: actions/setup-node@v4
       with:
-        node-version: 20.x
+        node-version: 22.x
         cache: 'npm'
     - run: node -v
     - run: npm -v

package/README.md

@@ -1,4 +1,4 @@
-If you found this useful, consider also checking out [dotenv-vault](https://github.com/dotenv-org/dotenv-vault). Thank you! 😇
+> If you found this useful, consider also checking out [dotenvx](https://github.com/dotenvx/dotenvx). Thank you! 😇
 
 # node-lambda
 

package/bin/node-lambda

@@ -2,7 +2,7 @@
 
 'use strict'
 
-require('dotenv').config()
+require('@dotenvx/dotenvx').config()
 const process = require('process')
 const path = require('path')
 

package/lib/.env.example

@@ -16,4 +16,5 @@ AWS_VPC_SECURITY_GROUPS=
 AWS_TRACING_CONFIG=
 AWS_LOGS_RETENTION_IN_DAYS=
 EXCLUDE_GLOBS="event.json build/"
+CONFIG_FILE="deploy.env"
 PACKAGE_DIRECTORY=build

package/lib/aws.js

@@ -1,38 +1,41 @@
-'use strict'
-
-const aws = require('aws-sdk')
-const proxy = require('proxy-agent')
-
-module.exports = {
-  sdk: aws,
-  updateConfig (config, region) {
-    const awsSecurity = { region }
-
-    if (config.profile) {
-      aws.config.credentials = new aws.SharedIniFileCredentials({
-        profile: config.profile
-      })
-    } else {
-      awsSecurity.accessKeyId = config.accessKey
-      awsSecurity.secretAccessKey = config.secretKey
-    }
-
-    if (config.sessionToken) {
-      awsSecurity.sessionToken = config.sessionToken
-    }
-
-    if (config.deployTimeout) {
-      aws.config.httpOptions.timeout = parseInt(config.deployTimeout)
-    }
-
-    if (config.proxy) {
-      aws.config.httpOptions.agent = proxy(config.proxy)
-    }
-
-    if (config.endpoint) {
-      aws.config.endpoint = config.endpoint
-    }
-
-    aws.config.update(awsSecurity)
-  }
-}
+// TODO:
+// Support these option settings in SDK v3
+//
+// 'use strict'
+//
+// const aws = require('aws-sdk')
+// const proxy = require('proxy-agent')
+//
+// module.exports = {
+//   sdk: aws,
+//   updateConfig (config, region) {
+//     const awsSecurity = { region }
+//
+//     if (config.profile) {
+//       aws.config.credentials = new aws.SharedIniFileCredentials({
+//         profile: config.profile
+//       })
+//     } else {
+//       awsSecurity.accessKeyId = config.accessKey
+//       awsSecurity.secretAccessKey = config.secretKey
+//     }
+//
+//     if (config.sessionToken) {
+//       awsSecurity.sessionToken = config.sessionToken
+//     }
+//
+//     if (config.deployTimeout) {
+//       aws.config.httpOptions.timeout = parseInt(config.deployTimeout)
+//     }
+//
+//     if (config.proxy) {
+//       aws.config.httpOptions.agent = proxy(config.proxy)
+//     }
+//
+//     if (config.endpoint) {
+//       aws.config.endpoint = config.endpoint
+//     }
+//
+//     aws.config.update(awsSecurity)
+//   }
+// }

package/lib/cloudwatch_logs.js

@@ -1,15 +1,14 @@
 'use strict'
 
+const {
+  CloudWatchLogsClient,
+  CreateLogGroupCommand,
+  PutRetentionPolicyCommand
+} = require('@aws-sdk/client-cloudwatch-logs')
+
 class CloudWatchLogs {
-  constructor (aws, region) {
-    // Authenticated `aws` object in `lib/main.js`
-    this.lambda = new aws.Lambda({
-      region,
-      apiVersion: '2015-03-31'
-    })
-    this.cloudwatchlogs = new aws.CloudWatchLogs({
-      apiVersion: '2014-03-28'
-    })
+  constructor (config) {
+    this.client = new CloudWatchLogsClient(config)
   }
 
   _logGroupName (params) {
@@ -17,33 +16,24 @@ class CloudWatchLogs {
   }
 
   _createLogGroup (params) {
-    return new Promise((resolve, reject) => {
-      this.cloudwatchlogs.createLogGroup({
+    try {
+      return this.client.send(new CreateLogGroupCommand({
         logGroupName: this._logGroupName(params)
-      }, (err, data) => {
-        if (err) {
-          if (err.code === 'ResourceAlreadyExistsException') {
-            // If it exists it will result in an error but there is no problem.
-            return resolve({})
-          }
-          return reject(err)
-        }
-
-        resolve(data)
-      })
-    })
+      }))
+    } catch (err) {
+      if (err.code === 'ResourceAlreadyExistsException') {
+        // If it exists it will result in an error but there is no problem.
+        return {}
+      }
+      throw err
+    }
   }
 
   _putRetentionPolicy (params) {
-    return new Promise((resolve, reject) => {
-      this.cloudwatchlogs.putRetentionPolicy({
-        logGroupName: this._logGroupName(params),
-        retentionInDays: params.retentionInDays
-      }, (err, data) => {
-        if (err) return reject(err)
-        resolve(data)
-      })
-    })
+    return this.client.send(new PutRetentionPolicyCommand({
+      logGroupName: this._logGroupName(params),
+      retentionInDays: params.retentionInDays
+    }))
   }
 
   setLogsRetentionPolicy (params) {

package/lib/main.js

@@ -3,14 +3,13 @@
 const process = require('process')
 const path = require('path')
 const os = require('os')
-const aws = require(path.join(__dirname, 'aws'))
 const { exec, execSync, execFile } = require('child_process')
 const fs = require('fs-extra')
 const klaw = require('klaw')
 const packageJson = require(path.join(__dirname, '..', 'package.json'))
 const { minimatch } = require('minimatch')
 const archiver = require('archiver')
-const dotenv = require('dotenv')
+const dotenv = require('@dotenvx/dotenvx')
 const ScheduleEvents = require(path.join(__dirname, 'schedule_events'))
 const S3Events = require(path.join(__dirname, 's3_events'))
 const S3Deploy = require(path.join(__dirname, 's3_deploy'))
@@ -19,6 +18,29 @@ const CloudWatchLogs = require(path.join(__dirname, 'cloudwatch_logs'))
 const AWSXRay = require('aws-xray-sdk-core')
 const { createNamespace } = require('continuation-local-storage')
 
+/*
+ * Migrating to v3.
+ *
+ * # About retry
+ * By default, each client already has a default retry strategy.
+ * The default retry count is 3, and only retryable errors will be retried.
+ * https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html
+ */
+const {
+  LambdaClient,
+  CreateEventSourceMappingCommand,
+  CreateFunctionCommand,
+  DeleteEventSourceMappingCommand,
+  GetFunctionCommand,
+  ListEventSourceMappingsCommand,
+  ListTagsCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateEventSourceMappingCommand,
+  UpdateFunctionCodeCommand,
+  UpdateFunctionConfigurationCommand
+} = require('@aws-sdk/client-lambda')
+
 const maxBufferSize = 50 * 1024 * 1024
 
 class Lambda {
@@ -236,8 +258,8 @@ Emulate only the body of the API Gateway event.
       Role: program.role,
       Runtime: program.runtime,
       Description: program.description,
-      MemorySize: program.memorySize,
-      Timeout: program.timeout,
+      MemorySize: Number(program.memorySize),
+      Timeout: Number(program.timeout),
       Architectures: program.architecture ? [program.architecture] : ['x86_64'],
       Publish: (() => {
         if (typeof program.publish === 'boolean') {
@@ -661,43 +683,24 @@ Emulate only the body of the API Gateway event.
       delete functionConfigParams.Layers
     }
 
-    const updateConfigRequest = lambda.updateFunctionConfiguration(functionConfigParams)
-    updateConfigRequest.on('retry', (response) => {
-      console.log(response.error.message)
-      console.log('=> Retrying')
-    })
-    const updateConfigResponse = await updateConfigRequest.promise()
+    const updateConfigResponse = await lambda.send(new UpdateFunctionConfigurationCommand(functionConfigParams))
 
     // Wait for the `Configuration.LastUpdateStatus` to change from `InProgress` to `Successful`.
+    const getFunction = new GetFunctionCommand({ FunctionName: params.FunctionName })
     for (let i = 0; i < 10; i++) {
-      const data = await lambda.getFunction({ FunctionName: params.FunctionName }).promise()
+      const data = await lambda.send(getFunction)
       if (data.Configuration.LastUpdateStatus === 'Successful') {
         break
       }
       await new Promise((resolve) => setTimeout(resolve, 3000))
     }
-
-    const updateCodeRequest = lambda.updateFunctionCode(functionCodeParams)
-    updateCodeRequest.on('retry', (response) => {
-      console.log(response.error.message)
-      console.log('=> Retrying')
-    })
-    await updateCodeRequest.promise()
+    lambda.send(new UpdateFunctionCodeCommand(functionCodeParams))
 
     return updateConfigResponse
   }
 
   _uploadNew (lambda, params) {
-    return new Promise((resolve, reject) => {
-      const request = lambda.createFunction(params, (err, data) => {
-        if (err) return reject(err)
-        resolve(data)
-      })
-      request.on('retry', (response) => {
-        console.log(response.error.message)
-        console.log('=> Retrying')
-      })
-    })
+    return lambda.send(new CreateFunctionCommand(params))
   }
 
   _readArchive (program) {
@@ -769,16 +772,12 @@ they may not work as expected in the Lambda environment.
     return this._zip(program, codeDirectory)
   }
 
-  _listEventSourceMappings (lambda, params) {
-    return new Promise((resolve, reject) => {
-      lambda.listEventSourceMappings(params, (err, data) => {
-        if (err) return reject(err)
-        if (data && data.EventSourceMappings) {
-          return resolve(data.EventSourceMappings)
-        }
-        return resolve([])
-      })
-    })
+  async _listEventSourceMappings (lambda, params) {
+    const data = await lambda.send(new ListEventSourceMappingsCommand(params))
+    if (data && data.EventSourceMappings) {
+      return data.EventSourceMappings
+    }
+    return []
   }
 
   _getStartingPosition (eventSource) {
@@ -846,48 +845,30 @@ they may not work as expected in the Lambda environment.
       switch (updateEventSource.type) {
         case 'create':
           delete updateEventSource.type
-          return new Promise((resolve, reject) => {
-            lambda.createEventSourceMapping(updateEventSource, (err, data) => {
-              if (err) return reject(err)
-              resolve(data)
-            })
-          })
+          return lambda.send(new CreateEventSourceMappingCommand(updateEventSource))
         case 'update':
           delete updateEventSource.type
-          return new Promise((resolve, reject) => {
-            lambda.updateEventSourceMapping(updateEventSource, (err, data) => {
-              if (err) return reject(err)
-              resolve(data)
-            })
-          })
+          return lambda.send(new UpdateEventSourceMappingCommand(updateEventSource))
         case 'delete':
           delete updateEventSource.type
-          return new Promise((resolve, reject) => {
-            lambda.deleteEventSourceMapping(updateEventSource, (err, data) => {
-              if (err) return reject(err)
-              resolve(data)
-            })
-          })
+          return lambda.send(new DeleteEventSourceMappingCommand(updateEventSource))
+        default:
+          return Promise.resolve()
       }
-      return Promise.resolve()
     }))
   }
 
-  _updateTags (lambda, functionArn, tags) {
+  async _updateTags (lambda, functionArn, tags) {
     if (!tags || Object.keys(tags).length <= 0) {
-      return Promise.resolve([])
-    } else {
-      return lambda.listTags({ Resource: functionArn }).promise()
-        .then(data => {
-          const keys = Object.keys(data.Tags)
-          return keys && keys.length > 0
-            ? lambda.untagResource({ Resource: functionArn, TagKeys: keys }).promise()
-            : Promise.resolve()
-        })
-        .then(() => {
-          return lambda.tagResource({ Resource: functionArn, Tags: tags }).promise()
-        })
+      return []
     }
+
+    const data = await lambda.send(new ListTagsCommand({ Resource: functionArn }))
+    const keys = Object.keys(data.Tags)
+    if (keys && keys.length > 0) {
+      await lambda.send(new UntagResourceCommand({ Resource: functionArn, TagKeys: keys }))
+    }
+    return lambda.send(new TagResourceCommand({ Resource: functionArn, Tags: tags }))
   }
 
   _updateScheduleEvents (scheduleEvents, functionArn, scheduleList) {
@@ -973,115 +954,108 @@ they may not work as expected in the Lambda environment.
       !!err.message.match(/^Function not found:/)
   }
 
-  _deployToRegion (program, params, region, buffer) {
-    aws.updateConfig(program, region)
+  async _deployToRegion (program, params, region, buffer) {
+    // sdk v3 todo: Migration of aws.updateConfig.
+    // aws.updateConfig(program, region)
+    const config = { region }
 
     console.log('=> Reading event source file to memory')
     const eventSourceList = this._eventSourceList(program)
 
-    return Promise.resolve().then(() => {
-      if (this._isUseS3(program)) {
-        const s3Deploy = new S3Deploy(aws.sdk, region)
-        return s3Deploy.putPackage(params, region, buffer)
-      }
-      return null
-    }).then((code) => {
-      if (code != null) params.Code = code
-    }).then(() => {
-      if (!this._isUseS3(program)) {
-        console.log(`=> Uploading zip file to AWS Lambda ${region} with parameters:`)
-      } else {
-        console.log(`=> Uploading AWS Lambda ${region} with parameters:`)
-      }
-      console.log(params)
+    if (this._isUseS3(program)) {
+      const s3Deploy = new S3Deploy(config)
+      params.Code = await s3Deploy.putPackage(params, region, buffer)
+      console.log(`=> Uploading AWS Lambda ${region} with parameters:`)
+    } else {
+      console.log(`=> Uploading zip file to AWS Lambda ${region} with parameters:`)
+    }
+    console.log(params)
 
-      const lambda = new aws.sdk.Lambda({
-        region,
-        apiVersion: '2015-03-31'
-      })
-      const scheduleEvents = new ScheduleEvents(aws.sdk, region)
-      const s3Events = new S3Events(aws.sdk, region)
-      const cloudWatchLogs = new CloudWatchLogs(aws.sdk, region)
+    const lambdaClient = new LambdaClient(config)
+    const scheduleEvents = new ScheduleEvents(config)
+    const s3Events = new S3Events(config)
+    const cloudWatchLogs = new CloudWatchLogs(config)
 
-      // Checking function
-      return lambda.getFunction({
-        FunctionName: params.FunctionName
-      }).promise().then(() => {
-        // Function exists
-        return this._listEventSourceMappings(lambda, {
+    const existsFunction = await (async () => {
+      try {
+        await lambdaClient.send(new GetFunctionCommand({
           FunctionName: params.FunctionName
-        }).then((existingEventSourceList) => {
-          return Promise.all([
-            this._uploadExisting(lambda, params).then((results) => {
-              console.log('=> Done uploading. Results follow: ')
-              console.log(results)
-              return results
-            }).then(results => {
-              return Promise.all([
-                this._updateScheduleEvents(
-                  scheduleEvents,
-                  results.FunctionArn,
-                  eventSourceList.ScheduleEvents
-                ),
-                this._updateS3Events(
-                  s3Events,
-                  results.FunctionArn,
-                  eventSourceList.S3Events
-                ),
-                this._updateTags(
-                  lambda,
-                  results.FunctionArn,
-                  params.Tags)
-              ])
-            }),
-            this._updateEventSources(
-              lambda,
-              params.FunctionName,
-              existingEventSourceList,
-              eventSourceList.EventSourceMappings
-            ),
-            this._setLogsRetentionPolicy(
-              cloudWatchLogs,
-              program,
-              params.FunctionName
-            )
-          ])
-        })
-      }).catch((err) => {
+        }))
+        return true
+      } catch (err) {
         if (!this._isFunctionDoesNotExist(err)) {
           throw err
         }
-        // Function does not exist
-        return this._uploadNew(lambda, params).then((results) => {
-          console.log('=> Done uploading. Results follow: ')
-          console.log(results)
-
-          return Promise.all([
-            this._updateEventSources(
-              lambda,
-              params.FunctionName,
-              [],
-              eventSourceList.EventSourceMappings
-            ),
-            this._updateScheduleEvents(
-              scheduleEvents,
-              results.FunctionArn,
-              eventSourceList.ScheduleEvents
-            ),
-            this._updateS3Events(
-              s3Events,
-              results.FunctionArn,
-              eventSourceList.S3Events
-            ),
-            this._setLogsRetentionPolicy(
-              cloudWatchLogs,
-              program,
-              params.FunctionName
-            )
-          ])
-        })
+        return false
+      }
+    })()
+
+    if (existsFunction) {
+      const existingEventSourceList = await this._listEventSourceMappings(lambdaClient, {
+        FunctionName: params.FunctionName
       })
-    })
+      const results = await this._uploadExisting(lambdaClient, params)
+      console.log('=> Done uploading. Results follow: ')
+      console.log(results)
+
+      return Promise.all([
+        Promise.all([
+          this._updateScheduleEvents(
+            scheduleEvents,
+            results.FunctionArn,
+            eventSourceList.ScheduleEvents
+          ),
+          this._updateS3Events(
+            s3Events,
+            results.FunctionArn,
+            eventSourceList.S3Events
+          ),
+          this._updateTags(
+            lambdaClient,
+            results.FunctionArn,
+            params.Tags)
+        ]),
+        this._updateEventSources(
+          lambdaClient,
+          params.FunctionName,
+          existingEventSourceList,
+          eventSourceList.EventSourceMappings
+        ),
+        this._setLogsRetentionPolicy(
+          cloudWatchLogs,
+          program,
+          params.FunctionName
+        )
+      ])
+    } else {
+      const results = await this._uploadNew(lambdaClient, params)
+      console.log('=> Done uploading. Results follow: ')
+      console.log(results)
+
+      return Promise.all([
+        this._updateEventSources(
+          lambdaClient,
+          params.FunctionName,
+          [],
+          eventSourceList.EventSourceMappings
+        ),
+        this._updateScheduleEvents(
+          scheduleEvents,
+          results.FunctionArn,
+          eventSourceList.ScheduleEvents
+        ),
+        this._updateS3Events(
+          s3Events,
+          results.FunctionArn,
+          eventSourceList.S3Events
+        ),
+        this._setLogsRetentionPolicy(
+          cloudWatchLogs,
+          program,
+          params.FunctionName
+        )
+      ])
+    }
   }
 
   _printDeployResults (results, isFirst) {

package/lib/s3_deploy.js

@@ -2,6 +2,13 @@
 
 const process = require('process')
 const crypto = require('crypto')
+
+const {
+  S3Client,
+  CreateBucketCommand,
+  PutObjectCommand
+} = require('@aws-sdk/client-s3')
+
 // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#createBucket-property
 const S3_LOCATION_POSSIBLE_VALUES = [
   'EU',
@@ -33,12 +40,8 @@ const S3_LOCATION_POSSIBLE_VALUES = [
 ]
 
 class S3Deploy {
-  constructor (aws, region) {
-    // Authenticated `aws` object in `lib/main.js`
-    this.s3 = new aws.S3({
-      region,
-      apiVersion: '2006-03-01'
-    })
+  constructor (config) {
+    this.client = new S3Client(config)
   }
 
   _md5 (str) {
@@ -107,30 +110,21 @@ class S3Deploy {
         LocationConstraint: s3Location
       }
     }
-    return new Promise((resolve, reject) => {
-      this.s3.createBucket(_params, (err, data) => {
-        if (err) {
-          // Ignored created
-          if (err.code === 'BucketAlreadyOwnedByYou') return resolve({})
-          return reject(err)
-        }
-        resolve(data)
-      })
-    })
+    try {
+      return this.client.send(new CreateBucketCommand(_params))
+    } catch (err) {
+      // Ignored created
+      if (err.code === 'BucketAlreadyOwnedByYou') return {}
+      throw err
+    }
   }
 
   _putObject (params, buffer) {
-    const _params = {
+    return this.client.send(new PutObjectCommand({
       Body: buffer,
       Bucket: params.bucketName,
       Key: params.s3Key
-    }
-    return new Promise((resolve, reject) => {
-      this.s3.putObject(_params, (err, data) => {
-        if (err) reject(err)
-        resolve(data)
-      })
-    })
+    }))
   }
 
   putPackage (params, region, buffer) {