serverless-offline 11.1.2 → 11.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "11.1.2",
+  "version": "11.2.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "exports": {
@@ -85,14 +85,14 @@
     "@hapi/boom": "^10.0.0",
     "@hapi/h2o2": "^10.0.0",
     "@hapi/hapi": "^20.2.2",
-    "@serverless/utils": "^6.8.0",
-    "aws-sdk": "^2.1231.0",
+    "@serverless/utils": "^6.8.1",
+    "aws-sdk": "^2.1241.0",
     "boxen": "^7.0.0",
     "chalk": "^5.1.2",
     "execa": "^6.1.0",
     "fs-extra": "^10.1.0",
     "java-invoke-local": "0.0.6",
-    "jose": "^4.10.0",
+    "jose": "^4.10.3",
     "js-string-escape": "^1.0.1",
     "jsonpath-plus": "^7.2.0",
     "jsonschema": "^1.4.1",
@@ -104,12 +104,12 @@
     "p-memoize": "^7.1.1",
     "p-retry": "^5.1.1",
     "velocityjs": "^2.0.6",
-    "ws": "^8.9.0"
+    "ws": "^8.10.0"
   },
   "devDependencies": {
     "@istanbuljs/esm-loader-hook": "^0.2.0",
     "archiver": "^5.3.1",
-    "eslint": "^8.25.0",
+    "eslint": "^8.26.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",
@@ -117,7 +117,7 @@
     "git-list-updated": "^1.2.1",
     "husky": "^8.0.1",
     "lint-staged": "^13.0.3",
-    "mocha": "^10.0.0",
+    "mocha": "^10.1.0",
     "nyc": "^15.1.0",
     "prettier": "^2.7.1",
     "serverless": "^3.23.0",

package/src/ServerlessOffline.js

@@ -61,8 +61,13 @@ export default class ServerlessOffline {
   async start() {
     this.#mergeOptions()
 
-    const { httpEvents, lambdas, scheduleEvents, webSocketEvents } =
-      this.#getEvents()
+    const {
+      httpEvents,
+      httpApiEvents,
+      lambdas,
+      scheduleEvents,
+      webSocketEvents,
+    } = this.#getEvents()
 
     if (lambdas.length > 0) {
       await this.#createLambda(lambdas)
@@ -70,8 +75,8 @@ export default class ServerlessOffline {
 
     const eventModules = []
 
-    if (httpEvents.length > 0) {
-      eventModules.push(this.#createHttp(httpEvents))
+    if (httpApiEvents.length > 0 || httpEvents.length > 0) {
+      eventModules.push(this.#createHttp([...httpApiEvents, ...httpEvents]))
     }
 
     if (scheduleEvents.length > 0) {
@@ -259,6 +264,7 @@ export default class ServerlessOffline {
     const { service } = this.#serverless
 
     const httpEvents = []
+    const httpApiEvents = []
     const lambdas = []
     const scheduleEvents = []
     const webSocketEvents = []
@@ -275,66 +281,75 @@ export default class ServerlessOffline {
       events.forEach((event) => {
         const { http, httpApi, schedule, websocket } = event
 
-        if ((http || httpApi) && functionDefinition.handler) {
+        if (http && functionDefinition.handler) {
           const httpEvent = {
             functionKey,
             handler: functionDefinition.handler,
-            http: http || httpApi,
+            http,
           }
 
-          if (httpApi) {
-            // Ensure definitions for 'httpApi' events are objects so that they can be marked
-            // with an 'isHttpApi' property (they are handled differently to 'http' events)
-            if (typeof httpEvent.http === 'string') {
-              httpEvent.http = {
-                routeKey: httpEvent.http === '*' ? '$default' : httpEvent.http,
-              }
-            } else if (typeof httpEvent.http === 'object') {
-              if (!httpEvent.http.method) {
-                log.warning(
-                  `Event definition is missing a method for function "${functionKey}"`,
-                )
-                httpEvent.http.method = ''
-              }
-              if (
-                httpEvent.http.method === '*' &&
-                httpEvent.http.path === '*'
-              ) {
-                httpEvent.http.routeKey = '$default'
-              } else {
-                const resolvedMethod =
-                  httpEvent.http.method === '*'
-                    ? 'ANY'
-                    : httpEvent.http.method.toUpperCase()
-                httpEvent.http.routeKey = `${resolvedMethod} ${httpEvent.http.path}`
-              }
-              // Clear these properties to avoid confusion (they will be derived from the routeKey
-              // when needed later)
-              delete httpEvent.http.method
-              delete httpEvent.http.path
-            } else {
+          httpEvents.push(httpEvent)
+        }
+
+        if (httpApi && functionDefinition.handler) {
+          const httpApiEvent = {
+            functionKey,
+            handler: functionDefinition.handler,
+            http: httpApi,
+          }
+
+          // Ensure definitions for 'httpApi' events are objects so that they can be marked
+          // with an 'isHttpApi' property (they are handled differently to 'http' events)
+          if (typeof httpApiEvent.http === 'string') {
+            httpApiEvent.http = {
+              routeKey:
+                httpApiEvent.http === '*' ? '$default' : httpApiEvent.http,
+            }
+          } else if (typeof httpApiEvent.http === 'object') {
+            if (!httpApiEvent.http.method) {
               log.warning(
-                `Event definition must be a string or object but received ${typeof httpEvent.http} for function "${functionKey}"`,
+                `Event definition is missing a method for function "${functionKey}"`,
               )
-              httpEvent.http.routeKey = ''
+              httpApiEvent.http.method = ''
             }
-
-            httpEvent.http.isHttpApi = true
-
             if (
-              functionDefinition.httpApi &&
-              functionDefinition.httpApi.payload
+              httpApiEvent.http.method === '*' &&
+              httpApiEvent.http.path === '*'
             ) {
-              httpEvent.http.payload = functionDefinition.httpApi.payload
+              httpApiEvent.http.routeKey = '$default'
             } else {
-              httpEvent.http.payload =
-                service.provider.httpApi && service.provider.httpApi.payload
-                  ? service.provider.httpApi.payload
-                  : '2.0'
+              const resolvedMethod =
+                httpApiEvent.http.method === '*'
+                  ? 'ANY'
+                  : httpApiEvent.http.method.toUpperCase()
+              httpApiEvent.http.routeKey = `${resolvedMethod} ${httpApiEvent.http.path}`
             }
+            // Clear these properties to avoid confusion (they will be derived from the routeKey
+            // when needed later)
+            delete httpApiEvent.http.method
+            delete httpApiEvent.http.path
+          } else {
+            log.warning(
+              `Event definition must be a string or object but received ${typeof httpApiEvent.http} for function "${functionKey}"`,
+            )
+            httpApiEvent.http.routeKey = ''
           }
 
-          httpEvents.push(httpEvent)
+          httpApiEvent.http.isHttpApi = true
+
+          if (
+            functionDefinition.httpApi &&
+            functionDefinition.httpApi.payload
+          ) {
+            httpApiEvent.http.payload = functionDefinition.httpApi.payload
+          } else {
+            httpApiEvent.http.payload =
+              service.provider.httpApi && service.provider.httpApi.payload
+                ? service.provider.httpApi.payload
+                : '2.0'
+          }
+
+          httpApiEvents.push(httpApiEvent)
         }
 
         if (schedule) {
@@ -354,6 +369,7 @@ export default class ServerlessOffline {
     })
 
     return {
+      httpApiEvents,
       httpEvents,
       lambdas,
       scheduleEvents,

package/src/events/http/Http.js

@@ -4,8 +4,16 @@ import HttpServer from './HttpServer.js'
 export default class Http {
   #httpServer = null
 
+  #lambda = null
+
+  #options = null
+
+  #serverless = null
+
   constructor(serverless, options, lambda) {
-    this.#httpServer = new HttpServer(serverless, options, lambda)
+    this.#lambda = lambda
+    this.#options = options
+    this.#serverless = serverless
   }
 
   start() {
@@ -18,6 +26,12 @@ export default class Http {
   }
 
   async createServer() {
+    this.#httpServer = new HttpServer(
+      this.#serverless,
+      this.#options,
+      this.#lambda,
+    )
+
     await this.#httpServer.createServer()
   }
 

package/src/events/http/HttpServer.js

@@ -459,12 +459,12 @@ export default class HttpServer {
 
       // default request template to '' if we don't have a definition pushed in from serverless or endpoint
       const requestTemplate =
-        typeof requestTemplates !== 'undefined' && integration === 'AWS'
+        requestTemplates !== undefined && integration === 'AWS'
           ? requestTemplates[contentType]
           : ''
 
       const schemas =
-        typeof endpoint?.request?.schemas !== 'undefined'
+        endpoint?.request?.schemas !== undefined
           ? endpoint.request.schemas[contentType]
           : ''
 
@@ -647,10 +647,7 @@ export default class HttpServer {
                 headerValue = valueArray[3]
                   ? jsonPath(result, valueArray.slice(3).join('.'))
                   : result
-                if (
-                  typeof headerValue === 'undefined' ||
-                  headerValue === null
-                ) {
+                if (headerValue === undefined || headerValue === null) {
                   headerValue = ''
                 } else {
                   headerValue = headerValue.toString()
@@ -857,7 +854,7 @@ export default class HttpServer {
 
         if (typeof result === 'string') {
           response.source = stringify(result)
-        } else if (result && typeof result.body !== 'undefined') {
+        } else if (result && result.body !== undefined) {
           if (result.isBase64Encoded) {
             response.encoding = 'binary'
             response.source = Buffer.from(result.body, 'base64')

package/src/events/http/lambda-events/LambdaProxyIntegrationEvent.js

@@ -104,7 +104,7 @@ export default class LambdaProxyIntegrationEvent {
       ) {
         headers['Content-Type'] = 'application/json'
       }
-    } else if (typeof body === 'undefined' || body === '') {
+    } else if (body === undefined || body === '') {
       body = null
     }
 

package/src/events/http/lambda-events/LambdaProxyIntegrationEventV2.js

@@ -87,7 +87,7 @@ export default class LambdaProxyIntegrationEventV2 {
       if (!headers['content-type']) {
         headers['content-type'] = 'application/json'
       }
-    } else if (typeof body === 'undefined' || body === '') {
+    } else if (body === undefined || body === '') {
       body = null
     }
 

package/src/lambda/handler-runner/HandlerRunner.js

@@ -116,6 +116,9 @@ export default class HandlerRunner {
       log.error(
         `Unhandled exception in handler '${this.#funOptions.functionKey}'.`,
       )
+
+      log.error(err)
+
       throw err
     }
   }

package/src/lambda/routes/invocations/invocationsRoute.js

@@ -43,7 +43,7 @@ export default function invocationsRoute(lambda, options) {
       let statusCode = 200
       let functionError = null
       if (invokeResults) {
-        const isPayloadDefined = typeof invokeResults.Payload !== 'undefined'
+        const isPayloadDefined = invokeResults.Payload !== undefined
         resultPayload = isPayloadDefined ? invokeResults.Payload : ''
         statusCode = invokeResults.StatusCode || 200
         functionError = invokeResults.FunctionError || null