serverless-http-invoker 1.0.14 → 2.0.0-beta.1

package/.github/dependabot.yml

@@ -2,13 +2,12 @@ version: 2
 updates:
   # docs v2 https://docs.github.com/en/free-pro-team@latest/github/administering-a-repository/configuration-options-for-dependency-updates
   - package-ecosystem: "npm"
+    directory: "/"
     schedule:
       interval: "monthly"
-      # Check for npm updates on Sundays
-      day: "saturday"
+      day: "friday"
     allow:
       - dependency-type: "direct"
-    directory: "/"
     commit-message:
       # for production deps, prefix commit messages with "fix" (trigger a patch release)
       prefix: "fix"

package/.github/workflows/build.yml

@@ -1,89 +1,25 @@
-name: build
-
+# We want pushes to main, beta, and alpha to trigger a publish to npm for the corresponding npm dist-tag.
+# Any pull request targeting deploy branches should run all tests.
 on:
   push:
-    branches: [main]
+    branches: [main, beta, alpha]
+
   pull_request:
-    branches: [main]
+    branches: [main, beta, alpha]
 
 jobs:
-  lint:
-    runs-on: ubuntu-20.04
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: "Use Node.js (deliberately not using matrix)"
-        uses: actions/setup-node@v1
-        with:
-          node-version: v12.x
-
-      - name: install dependencies
-        run: |
-          npm i
-
-      - name: lint
-        run: |
-          npm run lint
-
-  build_and_test:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        node: [10, 12, 14]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ matrix.node }}
-        uses: actions/setup-node@v2
-        with:
-          node-version: ${{ matrix.node }}
-
-      - name: install dependencies
-        run: |
-          npm i
-
-      - name: test
-        env:
-          CI_NODE_VERSION: ${{ matrix.node }}
-        run: |
-          npm run test
-
-      - name: publish coverage
-        uses: coverallsapp/github-action@master
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          flag-name: nodejs-${{ matrix.node }}
-          parallel: true
-
-  finish_tests:
-    needs: build_and_test
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Coveralls Finished
-        uses: coverallsapp/github-action@master
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          parallel-finished: true
-
-  deploy_package:
-    needs: finish_tests
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Use Node.js v12.x
-        uses: actions/setup-node@v1
-        with:
-          node-version: v12.x
-
-      #- name: debug deploy_package
-      #  uses: actions/bin/debug@master
-
-      - name: deploy via semantic-release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: |
-          npx semantic-release@17
+  test:
+    uses: activescott/github-actions-workflows/.github/workflows/npm-tester.yml@npm-tester-v4
+    with:
+      package_dir: ./
+      node_versions: "[14, 16, 18]"
+      do_coveralls: true
+
+  publish:
+    if: ${{ github.event_name != 'pull_request' }}
+    needs: [test]
+    uses: activescott/github-actions-workflows/.github/workflows/npm-publisher.yml@npm-publisher-v4.0.1
+    with:
+      package_dir: ./
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/examples/basic/basic.spec.js

@@ -4,18 +4,18 @@ const path = require("path")
 const expect = require("chai").expect
 const ServerlessInvoker = require("../../index")
 
-describe("basic", function() {
+describe("basic", function () {
   let sls = null
-  beforeEach(function() {
+  beforeEach(function () {
     sls = new ServerlessInvoker(path.join(__dirname))
   })
 
-  it("should invoke simple path", function() {
+  it("should invoke simple path", function () {
     const response = sls.invoke("GET api/hello")
     return expect(response).to.eventually.have.property("statusCode", 200)
   })
 
-  it("should have event.httpMethod", function() {
+  it("should have event.httpMethod", function () {
     const response = sls.invoke("GET api/hello")
     return expect(response).to.eventually.have.deep.nested.property(
       "body.input.httpMethod",
@@ -23,7 +23,7 @@ describe("basic", function() {
     )
   })
 
-  it("should have event.path", function() {
+  it("should have event.path", function () {
     const response = sls.invoke("GET api/hello")
     return expect(response).to.eventually.have.deep.nested.property(
       "body.input.path",
@@ -31,7 +31,7 @@ describe("basic", function() {
     )
   })
 
-  it("should have event.resource", function() {
+  it("should have event.resource", function () {
     const response = sls.invoke("GET api/hello")
     return expect(response).to.eventually.have.deep.nested.property(
       "body.input.resource",

package/examples/basic/handler.js

@@ -1,19 +1,19 @@
 "use strict"
 const assert = require("assert")
 
-module.exports.hello = async event => {
+module.exports.hello = async (event) => {
   return {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify(
       {
         message: "Go Serverless v1.0! Your function executed successfully!",
-        input: event
+        input: event,
       },
       null,
       2
-    )
+    ),
   }
 }

package/examples/basic/serverless.yml

@@ -2,7 +2,7 @@ service: basic-example
 
 provider:
   name: aws
-  runtime: nodejs10.x
+  runtime: nodejs14.x
   region: us-west-2
 
 functions:

package/examples/comprehensive/comprehensive.spec.js

@@ -6,32 +6,32 @@ const ServerlessInvoker = require("../../index")
 
 let sls = null
 
-beforeEach(function() {
+beforeEach(function () {
   process.chdir(path.join(__dirname))
   sls = new ServerlessInvoker(path.join(__dirname))
 })
 
-it("should work with callbacks too", function() {
+it("should work with callbacks too", function () {
   const response = sls.invoke("GET api/callback")
   return expect(response).to.eventually.have.property("statusCode", 200)
 })
 
-it("should invoke path with params", function() {
+it("should invoke path with params", function () {
   const response = sls.invoke("GET api/hello/world")
   return expect(response).to.eventually.have.property("statusCode", 200)
 })
 
-it("should invoke path with shorthand", function() {
+it("should invoke path with shorthand", function () {
   const response = sls.invoke("GET api/shorthand")
   return expect(response).to.eventually.have.property("statusCode", 200)
 })
 
-it("should invoke path with multiple params", function() {
+it("should invoke path with multiple params", function () {
   const response = sls.invoke("GET api/res1/1111/res2/2222")
   return expect(response).to.eventually.have.property("statusCode", 200)
 })
 
-it("should parse json response body", function() {
+it("should parse json response body", function () {
   const response = sls.invoke("GET api/hello")
   expect(response).to.eventually.have.property("statusCode", 200)
   return expect(response).to.eventually.have.deep.nested.property(
@@ -40,7 +40,7 @@ it("should parse json response body", function() {
   )
 })
 
-it("should load environment", function() {
+it("should load environment", function () {
   const response = sls.invoke("GET api/env")
   expect(response).to.eventually.have.property("statusCode", 200)
   return expect(response).to.eventually.have.deep.nested.property(
@@ -49,69 +49,69 @@ it("should load environment", function() {
   )
 })
 
-it("should pass data to POST", function() {
+it("should pass data to POST", function () {
   const response = sls.invoke("POST api/postit", { body: "boo" })
   return expect(response).to.eventually.have.deep.property("body", {
-    message: "postit:boo"
+    message: "postit:boo",
   })
 })
 
-it("should pass pathParameters with values when present", function() {
+it("should pass pathParameters with values when present", function () {
   const response = sls.invoke("GET api/res1/xxx/res2/yyy")
-  return response.then(resp => {
+  return response.then((resp) => {
     return expect(resp.body.input).to.have.deep.property("pathParameters", {
       res1ID: "xxx",
-      res2ID: "yyy"
+      res2ID: "yyy",
     })
   })
 })
 
-it("should pass pathParameters along with existing event too", function() {
+it("should pass pathParameters along with existing event too", function () {
   const response = sls.invoke("GET api/res1/xxx/res2/yyy", {
-    requestPayload: "boo"
+    requestPayload: "boo",
   })
-  return response.then(resp => {
+  return response.then((resp) => {
     expect(resp.body).to.have.property("input")
     expect(resp.body.input).to.have.deep.property("pathParameters", {
       res1ID: "xxx",
-      res2ID: "yyy"
+      res2ID: "yyy",
     })
     expect(resp.body.input).to.have.property("requestPayload", "boo")
   })
 })
 
-it("should pass pathParameters empty when not present", function() {
+it("should pass pathParameters empty when not present", function () {
   const response = sls.invoke("GET api/hello")
-  return response.then(resp => {
+  return response.then((resp) => {
     return expect(resp.body.input).to.have.deep.property("pathParameters", {})
   })
 })
 
-it("should pass greedy path params", function() {
+it("should pass greedy path params", function () {
   const response = sls.invoke("GET api/greedy/blah/blah/blah")
-  return response.then(resp => {
+  return response.then((resp) => {
     return expect(resp.body.input).to.have.deep.property("pathParameters", {
-      money: "blah/blah/blah"
+      money: "blah/blah/blah",
     })
   })
 })
 
-it("should pass queryStringParameters with values when present", function() {
+it("should pass queryStringParameters with values when present", function () {
   const response = sls.invoke("GET api/with_querystring_params?p1=val1&p2=val2")
-  return response.then(resp => {
+  return response.then((resp) => {
     return expect(resp.body.input).to.have.deep.property(
       "queryStringParameters",
       {
         p1: "val1",
-        p2: "val2"
+        p2: "val2",
       }
     )
   })
 })
 
-it("should pass queryStringParameters even when not present", function() {
+it("should pass queryStringParameters even when not present", function () {
   const response = sls.invoke("GET api/with_querystring_params")
-  return response.then(resp => {
+  return response.then((resp) => {
     return expect(resp.body.input).to.have.deep.property(
       "queryStringParameters",
       {}
@@ -119,50 +119,50 @@ it("should pass queryStringParameters even when not present", function() {
   })
 })
 
-it("should match urls with query strings and path params in url", function() {
+it("should match urls with query strings and path params in url", function () {
   const response = sls.invoke(
     "GET api/with_querystring_params_and_pathparams/ppvalue?qs1=qsval1"
   )
-  return response.then(resp => {
+  return response.then((resp) => {
     expect(resp.body.input).to.have.deep.property("queryStringParameters", {
-      qs1: "qsval1"
+      qs1: "qsval1",
     })
     return expect(resp.body.input).to.have.deep.property("pathParameters", {
-      pathparam1: "ppvalue"
+      pathparam1: "ppvalue",
     })
   })
 })
 
-it("should marshal raw lambda exceptions back as http responses", function() {
+it("should marshal raw lambda exceptions back as http responses", function () {
   const response = sls.invoke("GET api/throwWorld")
   return expect(response).to.eventually.have.property("statusCode", 502)
 })
 
-it("should marshal raw handled lambda errors back as http responses", function() {
+it("should marshal raw handled lambda errors back as http responses", function () {
   const response = sls.invoke("GET api/errorWorld")
   return expect(response).to.eventually.have.property("statusCode", 502)
 })
 
-it("should error if path isn't found", function() {
+it("should error if path isn't found", function () {
   const response = sls.invoke("GET api/DOES_NOT_EXIST")
   return expect(response).to.eventually.be.rejectedWith(
     /^Serverless http event not found for HTTP request/
   )
 })
 
-it("should try to find service path in same dir", function() {
+it("should try to find service path in same dir", function () {
   process.chdir(path.join(__dirname))
   const localSls = new ServerlessInvoker()
   expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
 })
 
-it("should try to find service path in parent dir", function() {
+it("should try to find service path in parent dir", function () {
   process.chdir(path.join(__dirname, "./subdir"))
   const localSls = new ServerlessInvoker()
   expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
 })
 
-it("should fail if serverless.yml not found", function() {
+it("should fail if serverless.yml not found", function () {
   process.chdir(path.join(__dirname, "../../test-data/no-serverless-found"))
   expect(() => new ServerlessInvoker()).to.throw(
     /^Cannot find serverless.yml. Started search in working directory/

package/examples/comprehensive/handler.js

@@ -1,20 +1,20 @@
 "use strict"
 const assert = require("assert")
 
-module.exports.hello = async event => {
+module.exports.hello = async (event) => {
   return {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify(
       {
         message: "Go Serverless v1.0! Your function executed successfully!",
-        input: event
+        input: event,
       },
       null,
       2
-    )
+    ),
   }
 }
 
@@ -22,16 +22,16 @@ module.exports.callback = (event, context, callback) => {
   const response = {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify(
       {
         message: "Go Serverless v1.00! Your function executed successfully!",
-        input: event
+        input: event,
       },
       null,
       2
-    )
+    ),
   }
   callback(null, response)
 }
@@ -44,43 +44,43 @@ module.exports.errorWorld = (event, context, callback) => {
   callback(new Error("throw world"), null)
 }
 
-module.exports.with_querystring_params = async event => {
+module.exports.with_querystring_params = async (event) => {
   return {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify({
       message: "QueryStringParams on prop",
       queryStringParameters: event.queryStringParameters,
-      input: event
-    })
+      input: event,
+    }),
   }
 }
 
-module.exports.env = async event => {
+module.exports.env = async (event) => {
   assert(process.env.MY_SIMPLE === "simple value")
 
   return {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify({
       message: "process.env.MY_SIMPLE==" + process.env.MY_SIMPLE,
-      input: event
-    })
+      input: event,
+    }),
   }
 }
 
-module.exports.postit = async event => {
+module.exports.postit = async (event) => {
   return {
     statusCode: 200,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
     },
     body: JSON.stringify({
-      message: "postit:" + event.body
-    })
+      message: "postit:" + event.body,
+    }),
   }
 }

package/examples/comprehensive/serverless.yml

@@ -2,7 +2,7 @@ service: basic-example # NOTE: update this with your service name
 
 provider:
   name: aws
-  runtime: nodejs10.x
+  runtime: nodejs14.x
   region: us-west-2
 
   environment:

package/index.js

@@ -34,7 +34,7 @@ class ServerlessInvoker {
 
   initializeServerless() {
     const config = {
-      servicePath: this.servicePath
+      servicePath: this.servicePath,
     }
     const sls = new Serverless(config)
     // NOTE: I've seen sls.init() run very slowly; nearly 500ms!
@@ -58,9 +58,9 @@ class ServerlessInvoker {
     // Read the serverless.yml file
     return this.initializeServerless()
       .then(() => this.loadServerlessEvents())
-      .then(httpEvents => {
+      .then((httpEvents) => {
         // find the event that matches the specified httpRequest
-        let httpEvent = httpEvents.find(e => e.test(httpRequest))
+        let httpEvent = httpEvents.find((e) => e.test(httpRequest))
         if (!httpEvent) {
           throw new Error(
             `Serverless http event not found for HTTP request "${httpRequest}" in service path "${this.servicePath}".`
@@ -75,15 +75,14 @@ class ServerlessInvoker {
             httpEvent,
             httpRequest
           ),
-          queryStringParameters: ServerlessInvoker.parseQueryStringParameters(
-            httpRequest
-          ),
-          httpMethod: ServerlessInvoker.parseHttpMethod(httpRequest)
+          queryStringParameters:
+            ServerlessInvoker.parseQueryStringParameters(httpRequest),
+          httpMethod: ServerlessInvoker.parseHttpMethod(httpRequest),
         })
 
         return this.loadServerlessEnvironment().then(() => {
           return this.invokeWithLambdaWrapper(httpEvent, event, context)
-            .then(response => {
+            .then((response) => {
               if (
                 response &&
                 response.headers &&
@@ -96,7 +95,7 @@ class ServerlessInvoker {
               }
               return response
             })
-            .catch(eLambdaFuncError => {
+            .catch((eLambdaFuncError) => {
               // In this situation API Gateway returns 502 (bad gateway) and sets the response body to `{"message": "Internal server error"}`. We are adding a bit more detail to the error.
               console.error(
                 "serverless-http-invoker error invoking function:",
@@ -107,8 +106,8 @@ class ServerlessInvoker {
                 body: {
                   message: "Internal server error",
                   test_debug_error_message: eLambdaFuncError.toString(),
-                  test_debug_error_stack: eLambdaFuncError.stack
-                }
+                  test_debug_error_stack: eLambdaFuncError.stack,
+                },
               }
               return response
             })
@@ -184,23 +183,23 @@ class ServerlessInvoker {
   loadServerlessEvents() {
     let funcs = this.serverless.service
       .getAllFunctions()
-      .map(fname => {
+      .map((fname) => {
         let funcObj = this.serverless.service.getFunction(fname)
         let events = this.serverless.service.getAllEventsInFunction(fname)
         let f = {
           name: fname,
           handler: funcObj.handler,
           events: events.filter(
-            e => Object.keys(e).includes("http") && e.http !== null
-          )
+            (e) => Object.keys(e).includes("http") && e.http !== null
+          ),
         }
         return f
       })
-      .filter(f => f.events.length > 0)
-      .map(f => {
-        f.events = f.events.map(evt => {
+      .filter((f) => f.events.length > 0)
+      .map((f) => {
+        f.events = f.events.map((evt) => {
           // add a path parser regex:
-          RegExp.escape = function(s) {
+          RegExp.escape = function (s) {
             // https://stackoverflow.com/a/3561711/51061
             return s.replace(/[-/\\^$*+?.()|[\]]/g, "\\$&")
           }
@@ -232,11 +231,11 @@ class ServerlessInvoker {
           let matchPathParamNames = new RegExp(matchPathParamNamesPattern, "gi")
           let pathParamNames = matchPathParamNames.exec(path).slice(1) // the first element is full matched text so slice it off
           // remove the surrounding bracket characters:
-          pathParamNames = pathParamNames.map(p =>
+          pathParamNames = pathParamNames.map((p) =>
             p.replace(/^\{([^}]+)\}$/, "$1")
           )
           // remove the '+' postfix if it exists
-          pathParamNames = pathParamNames.map(p =>
+          pathParamNames = pathParamNames.map((p) =>
             p.endsWith("+") ? p.substring(0, p.length - 1) : p
           )
           // console.log('pathParamNames:', pathParamNames, 'path:', path)
@@ -263,11 +262,11 @@ class ServerlessInvoker {
           return Object.assign(evt.http, {
             matcher: matcher,
             pathParamNames: pathParamNames,
-            test: request => {
+            test: (request) => {
               const result = matcher.test(request)
               // console.log(`${method} ${path}: ${request} == ${result} \n  pattern:${matcher.source}`)
               return result
-            }
+            },
           })
         })
         return f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-http-invoker",
-  "version": "1.0.14",
+  "version": "2.0.0-beta.1",
   "description": "Locally invoke Serverless functions via their HTTP event as specified in Serverless.yml for testing.",
   "main": "index.js",
   "author": "Scott Willeke <scott@willeke.com> (https:/scott.willeke.com/)",
@@ -24,7 +24,7 @@
     "tdd"
   ],
   "engines": {
-    "node": ">=6"
+    "node": ">=14"
   },
   "repository": {
     "type": "git",
@@ -46,12 +46,12 @@
     "serverless": "^1.27.3"
   },
   "devDependencies": {
-    "chai": "^4.1.0",
+    "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "coveralls": "^3.0.4",
-    "mocha": "^8.3.2",
-    "nyc": "^15.0.0",
-    "prettier": "^1.18.2",
+    "coveralls": "^3.1.1",
+    "mocha": "^10.0.0",
+    "nyc": "^15.1.0",
+    "prettier": "^2.7.1",
     "serverless": "^2.46.0"
   }
 }

package/release.config.js

@@ -6,6 +6,6 @@ module.exports = {
     "next",
     "next-major",
     { name: "beta", prerelease: true },
-    { name: "alpha", prerelease: true }
-  ]
+    { name: "alpha", prerelease: true },
+  ],
 }

package/.github/workflows/dependabot-validate.yml

@@ -1,19 +0,0 @@
-name: dependabot validate
-
-on:
-  pull_request:
-    paths:
-      - ".github/dependabot.yml"
-      - ".github/workflows/dependabot-validate.yml"
-jobs:
-  validate:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-      - uses: marocchino/validate-dependabot@v1
-        id: validate
-      - uses: marocchino/sticky-pull-request-comment@v2
-        if: always()
-        with:
-          header: validate-dependabot
-          message: ${{ steps.validate.outputs.markdown }}