node-lambda 1.2.1 → 2.0.0-alpha.0

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 {
@@ -52,14 +74,25 @@ event_sources.json and ${program.eventFile} files as needed.`)
   }
 
   async run (program) {
-    if (!['nodejs14.x', 'nodejs16.x', 'nodejs18.x'].includes(program.runtime)) {
+    if (!['nodejs16.x', 'nodejs18.x', 'nodejs20.x'].includes(program.runtime)) {
       console.error(`Runtime [${program.runtime}] is not supported.`)
       process.exit(254)
     }
 
     this._createSampleFile(program.eventFile, 'event.json')
     const splitHandler = program.handler.split('.')
-    const filename = splitHandler[0] + '.js'
+    const filename = (() => {
+      for (const extension of ['.js', '.mjs']) {
+        if (fs.existsSync(splitHandler[0] + extension)) {
+          return splitHandler[0] + extension
+        }
+      }
+    })()
+    if (filename == null) {
+      console.error('Handler file not found.')
+      process.exitCode = 255
+      return
+    }
     const handlername = splitHandler[1]
 
     // Set custom environment variables if program.configFile is defined
@@ -225,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') {
@@ -650,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) {
@@ -758,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) {
@@ -835,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) {
@@ -962,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) {

package/lib/s3_events.js

@@ -1,20 +1,16 @@
 'use strict'
 
+const { S3Client, PutBucketNotificationConfigurationCommand } = require('@aws-sdk/client-s3')
+const { LambdaClient, AddPermissionCommand } = require('@aws-sdk/client-lambda')
+
 /**
  * Do not create S3 bucket.
  * Put the Notification Configuration in the existing Bucket.
  */
 class S3Events {
-  constructor (aws, region) {
-    // Authenticated `aws` object in `lib/main.js`
-    this.lambda = new aws.Lambda({
-      region,
-      apiVersion: '2015-03-31'
-    })
-    this.s3 = new aws.S3({
-      region,
-      apiVersion: '2006-03-01'
-    })
+  constructor (config) {
+    this.s3Client = new S3Client(config)
+    this.lambdaClient = new LambdaClient(config)
   }
 
   _functionName (params) {
@@ -36,17 +32,14 @@ class S3Events {
   }
 
   _addPermission (params) {
-    return new Promise((resolve, reject) => {
-      const _params = this._addPermissionParams(params)
-      this.lambda.addPermission(_params, (err, data) => {
-        if (err) {
-          if (err.code !== 'ResourceConflictException') reject(err)
-          // If it exists it will result in an error but there is no problem.
-          resolve('Permission already set')
-        }
-        resolve(data)
-      })
-    })
+    const _params = this._addPermissionParams(params)
+    try {
+      return this.lambdaClient.send(new AddPermissionCommand(_params))
+    } catch (err) {
+      if (err.code !== 'ResourceConflictException') throw err
+      // If it exists it will result in an error but there is no problem.
+      return 'Permission already set'
+    }
   }
 
   _lambdaFunctionConfiguration (params) {
@@ -86,12 +79,8 @@ class S3Events {
   }
 
   _putBucketNotificationConfiguration (putBucketNotificationConfigurationParams) {
-    return new Promise((resolve, reject) => {
-      this.s3.putBucketNotificationConfiguration(putBucketNotificationConfigurationParams, (err, data) => {
-        if (err) reject(err)
-        resolve(data)
-      })
-    })
+    return this.s3Client.send(
+      new PutBucketNotificationConfigurationCommand(putBucketNotificationConfigurationParams))
   }
 
   add (paramsList) {

package/lib/schedule_events.js

@@ -1,15 +1,12 @@
 'use strict'
 
+const { CloudWatchEventsClient, PutRuleCommand, PutTargetsCommand } = require('@aws-sdk/client-cloudwatch-events')
+const { LambdaClient, AddPermissionCommand } = require('@aws-sdk/client-lambda')
+
 class ScheduleEvents {
-  constructor (aws, region) {
-    // Authenticated `aws` object in `lib/main.js`
-    this.lambda = new aws.Lambda({
-      region,
-      apiVersion: '2015-03-31'
-    })
-    this.cloudwatchevents = new aws.CloudWatchEvents({
-      apiVersion: '2015-10-07'
-    })
+  constructor (config) {
+    this.cweClient = new CloudWatchEventsClient(config)
+    this.lambdaClient = new LambdaClient(config)
   }
 
   _ruleDescription (params) {
@@ -34,13 +31,9 @@ class ScheduleEvents {
 
   _putRule (params) {
     // return RuleArn if created
-    return new Promise((resolve, reject) => {
-      const _params = this._putRulePrams(params)
-      this.cloudwatchevents.putRule(_params, (err, rule) => {
-        if (err) reject(err)
-        resolve(rule)
-      })
-    })
+    return this.cweClient.send(
+      new PutRuleCommand(this._putRulePrams(params))
+    )
   }
 
   _addPermissionParams (params) {
@@ -54,17 +47,14 @@ class ScheduleEvents {
   }
 
   _addPermission (params) {
-    return new Promise((resolve, reject) => {
-      const _params = this._addPermissionParams(params)
-      this.lambda.addPermission(_params, (err, data) => {
-        if (err) {
-          if (err.code !== 'ResourceConflictException') reject(err)
-          // If it exists it will result in an error but there is no problem.
-          resolve('Permission already set')
-        }
-        resolve(data)
-      })
-    })
+    const _params = this._addPermissionParams(params)
+    try {
+      return this.lambdaClient.send(new AddPermissionCommand(_params))
+    } catch (err) {
+      if (err.code !== 'ResourceConflictException') throw err
+      // If it exists it will result in an error but there is no problem.
+      return 'Permission already set'
+    }
   }
 
   _putTargetsParams (params) {
@@ -79,14 +69,10 @@ class ScheduleEvents {
   }
 
   _putTargets (params) {
-    return new Promise((resolve, reject) => {
-      const _params = this._putTargetsParams(params)
-      this.cloudwatchevents.putTargets(_params, (err, data) => {
-        // even if it is already registered, it will not be an error.
-        if (err) reject(err)
-        resolve(data)
-      })
-    })
+    // even if it is already registered, it will not be an error.
+    return this.cweClient.send(
+      new PutTargetsCommand(this._putTargetsParams(params))
+    )
   }
 
   add (params) {