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

package/examples/basic/basic.spec.js

@@ -5,6 +5,9 @@ const expect = require("chai").expect
 const ServerlessInvoker = require("../../index")
 
 describe("basic", function () {
+  // in serverless v3 these started taking longer than the default 2000ms
+  this.timeout(2500)
+
   let sls = null
   beforeEach(function () {
     sls = new ServerlessInvoker(path.join(__dirname))

package/examples/comprehensive/comprehensive.spec.js

@@ -4,167 +4,173 @@ const path = require("path")
 const expect = require("chai").expect
 const ServerlessInvoker = require("../../index")
 
-let sls = null
-
-beforeEach(function () {
-  process.chdir(path.join(__dirname))
-  sls = new ServerlessInvoker(path.join(__dirname))
-})
-
-it("should work with callbacks too", function () {
-  const response = sls.invoke("GET api/callback")
-  return expect(response).to.eventually.have.property("statusCode", 200)
-})
+describe("comprehensive", function () {
+  let sls = null
+  // in serverless v3 these started taking longer than the default 2000ms
+  this.timeout(2500)
+
+  beforeEach(function () {
+    process.chdir(path.join(__dirname))
+    sls = new ServerlessInvoker(path.join(__dirname))
+  })
 
-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 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 shorthand", function () {
-  const response = sls.invoke("GET api/shorthand")
-  return expect(response).to.eventually.have.property("statusCode", 200)
-})
+  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 multiple params", function () {
-  const response = sls.invoke("GET api/res1/1111/res2/2222")
-  return expect(response).to.eventually.have.property("statusCode", 200)
-})
+  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 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(
-    "body.message",
-    "Go Serverless v1.0! Your function executed successfully!"
-  )
-})
+  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 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(
-    "body.message",
-    "process.env.MY_SIMPLE==simple value"
-  )
-})
+  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(
+      "body.message",
+      "Go Serverless v1.0! Your function executed successfully!"
+    )
+  })
 
-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",
+  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(
+      "body.message",
+      "process.env.MY_SIMPLE==simple value"
+    )
   })
-})
 
-it("should pass pathParameters with values when present", function () {
-  const response = sls.invoke("GET api/res1/xxx/res2/yyy")
-  return response.then((resp) => {
-    return expect(resp.body.input).to.have.deep.property("pathParameters", {
-      res1ID: "xxx",
-      res2ID: "yyy",
+  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",
     })
   })
-})
 
-it("should pass pathParameters along with existing event too", function () {
-  const response = sls.invoke("GET api/res1/xxx/res2/yyy", {
-    requestPayload: "boo",
-  })
-  return response.then((resp) => {
-    expect(resp.body).to.have.property("input")
-    expect(resp.body.input).to.have.deep.property("pathParameters", {
-      res1ID: "xxx",
-      res2ID: "yyy",
+  it("should pass pathParameters with values when present", function () {
+    const response = sls.invoke("GET /api/res1/xxx/res2/yyy")
+    return response.then((resp) => {
+      return expect(resp.body.input).to.have.deep.property("pathParameters", {
+        res1ID: "xxx",
+        res2ID: "yyy",
+      })
     })
-    expect(resp.body.input).to.have.property("requestPayload", "boo")
   })
-})
 
-it("should pass pathParameters empty when not present", function () {
-  const response = sls.invoke("GET api/hello")
-  return response.then((resp) => {
-    return expect(resp.body.input).to.have.deep.property("pathParameters", {})
+  it("should pass pathParameters along with existing event too", function () {
+    const response = sls.invoke("GET /api/res1/xxx/res2/yyy", {
+      requestPayload: "boo",
+    })
+    return response.then((resp) => {
+      expect(resp.body).to.have.property("input")
+      expect(resp.body.input).to.have.deep.property("pathParameters", {
+        res1ID: "xxx",
+        res2ID: "yyy",
+      })
+      expect(resp.body.input).to.have.property("requestPayload", "boo")
+    })
   })
-})
 
-it("should pass greedy path params", function () {
-  const response = sls.invoke("GET api/greedy/blah/blah/blah")
-  return response.then((resp) => {
-    return expect(resp.body.input).to.have.deep.property("pathParameters", {
-      money: "blah/blah/blah",
+  it("should pass pathParameters empty when not present", function () {
+    const response = sls.invoke("GET api/hello")
+    return response.then((resp) => {
+      return expect(resp.body.input).to.have.deep.property("pathParameters", {})
     })
   })
-})
 
-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 expect(resp.body.input).to.have.deep.property(
-      "queryStringParameters",
-      {
-        p1: "val1",
-        p2: "val2",
-      }
-    )
+  it("should pass greedy path params", function () {
+    const response = sls.invoke("GET api/greedy/blah/blah/blah")
+    return response.then((resp) => {
+      return expect(resp.body.input).to.have.deep.property("pathParameters", {
+        money: "blah/blah/blah",
+      })
+    })
   })
-})
 
-it("should pass queryStringParameters even when not present", function () {
-  const response = sls.invoke("GET api/with_querystring_params")
-  return response.then((resp) => {
-    return expect(resp.body.input).to.have.deep.property(
-      "queryStringParameters",
-      {}
+  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 expect(resp.body.input).to.have.deep.property(
+        "queryStringParameters",
+        {
+          p1: "val1",
+          p2: "val2",
+        }
+      )
+    })
   })
-})
 
-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) => {
-    expect(resp.body.input).to.have.deep.property("queryStringParameters", {
-      qs1: "qsval1",
+  it("should pass queryStringParameters even when not present", function () {
+    const response = sls.invoke("GET api/with_querystring_params")
+    return response.then((resp) => {
+      return expect(resp.body.input).to.have.deep.property(
+        "queryStringParameters",
+        {}
+      )
     })
-    return expect(resp.body.input).to.have.deep.property("pathParameters", {
-      pathparam1: "ppvalue",
+  })
+
+  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) => {
+      expect(resp.body.input).to.have.deep.property("queryStringParameters", {
+        qs1: "qsval1",
+      })
+      return expect(resp.body.input).to.have.deep.property("pathParameters", {
+        pathparam1: "ppvalue",
+      })
     })
   })
-})
 
-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 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 () {
-  const response = sls.invoke("GET api/errorWorld")
-  return expect(response).to.eventually.have.property("statusCode", 502)
-})
+  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 () {
-  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 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 () {
-  process.chdir(path.join(__dirname))
-  const localSls = new ServerlessInvoker()
-  expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
-})
+  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 () {
-  process.chdir(path.join(__dirname, "./subdir"))
-  const localSls = new ServerlessInvoker()
-  expect(localSls.servicePath).to.match(/examples\/comprehensive$/)
-})
+  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 () {
-  process.chdir(path.join(__dirname, "../../test-data/no-serverless-found"))
-  expect(() => new ServerlessInvoker()).to.throw(
-    /^Cannot find serverless.yml. Started search in working directory/
-  )
+  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/serverless.yml

@@ -34,7 +34,7 @@ functions:
   shorthand_path_syntax:
     handler: handler.hello
     events:
-      - http: GET api/shorthand
+      - http: GET /api/shorthand
 
   malformed_http_event:
     handler: handler.hello
@@ -46,7 +46,7 @@ functions:
   path_with_multiple_params:
     handler: handler.hello
     events:
-      - http: GET api/res1/{res1ID}/res2/{res2ID}
+      - http: GET /api/res1/{res1ID}/res2/{res2ID}
 
   env:
     handler: handler.env

package/index.js

@@ -1,12 +1,13 @@
 "use strict"
 const path = require("path")
-const fs = require("fs")
+const { existsSync } = require("fs")
+const fsPromises = require("fs/promises")
 const Serverless = require("serverless")
-const Promise = require("bluebird")
 const { wrap } = require("lambda-wrapper")
 const assert = require("assert")
 const url = require("url")
 const querystring = require("querystring")
+const YAML = require("yaml")
 
 class ServerlessInvoker {
   /**
@@ -14,14 +15,14 @@ class ServerlessInvoker {
    * @param {*string} servicePath Path to the directory containing the serverless file.
    */
   constructor(servicePath) {
-    this.servicePath = servicePath || this.findServicePath()
+    this.servicePath = servicePath || ServerlessInvoker.findServicePath()
     this.serverless = null
     this.serverlessEvents = null
   }
 
-  findServicePath() {
+  static findServicePath() {
     let dir = process.cwd()
-    while (dir !== "/" && !fs.existsSync(path.join(dir, "serverless.yml"))) {
+    while (dir !== "/" && !existsSync(path.join(dir, "serverless.yml"))) {
       dir = path.dirname(dir)
     }
     if (dir === "/") {
@@ -32,14 +33,30 @@ class ServerlessInvoker {
     return dir
   }
 
-  initializeServerless() {
+  static async loadServerlessYaml(path) {
+    const file = await fsPromises.readFile(path, "utf8")
+    return YAML.parse(file)
+  }
+
+  async initializeServerless() {
+    process.env.SLS_DEBUG = "*"
+    // Serverless v3 requires us to load the config manually: https://www.serverless.com/framework/docs/deprecations#serverless-constructor-service-configuration-dependency
+    // see also https://www.serverless.com/framework/docs/guides/upgrading-v3#low-level-changes
+    // https://www.serverless.com/framework/docs/deprecations#serverless-constructor-configcommands-and-configoptions-requirement
+    const slsService = await ServerlessInvoker.loadServerlessYaml(
+      path.join(this.servicePath, "serverless.yml")
+    )
     const config = {
-      servicePath: this.servicePath,
+      serviceDir: path.dirname(this.servicePath),
+      configurationFilename: "serverless.yml",
+      configuration: slsService,
+      commands: [],
+      options: {},
     }
     const sls = new Serverless(config)
     // NOTE: I've seen sls.init() run very slowly; nearly 500ms!
     return sls.init().then(() => {
-      return sls.variables.populateService().then(() => {
+      sls.service.load().then(() => {
         sls.service.setFunctionNames({})
         sls.service.mergeArrays()
         sls.service.validate()
@@ -54,7 +71,7 @@ class ServerlessInvoker {
    * @param {*object} event The event that should be submitted to the http endpoint.
    * @param {*object} context The context passed to the lambda function
    */
-  invoke(httpRequest, event, context) {
+  async invoke(httpRequest, event, context) {
     // Read the serverless.yml file
     return this.initializeServerless()
       .then(() => this.loadServerlessEvents())
@@ -160,27 +177,22 @@ class ServerlessInvoker {
     return myURL.pathname
   }
 
-  loadServerlessEnvironment() {
-    return Promise.try(() => {
-      let env = this.serverless.service.provider.environment
-      Object.assign(process.env, env)
-      return env
-    })
+  async loadServerlessEnvironment() {
+    let env = this.serverless.service.provider.environment
+    Object.assign(process.env, env)
+    return env
   }
 
-  invokeWithLambdaWrapper(httpEvent, event, context) {
-    return Promise.try(() => {
-      let handlerModule = require(path.join(
-        this.servicePath,
-        httpEvent.handlerPath
-      ))
-      let lambda = wrap(handlerModule, { handler: httpEvent.handlerName })
-      lambda = Promise.promisifyAll(lambda)
-      return lambda.runHandler(event, context || {})
-    })
+  async invokeWithLambdaWrapper(httpEvent, event, context) {
+    const handlerModule = require(path.join(
+      this.servicePath,
+      httpEvent.handlerPath
+    ))
+    const lambda = wrap(handlerModule, { handler: httpEvent.handlerName })
+    return lambda.runHandler(event, context || {})
   }
 
-  loadServerlessEvents() {
+  async loadServerlessEvents() {
     let funcs = this.serverless.service
       .getAllFunctions()
       .map((fname) => {
@@ -281,7 +293,7 @@ class ServerlessInvoker {
         events.push(e)
       }
     }
-    return Promise.resolve(events)
+    return events
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-http-invoker",
-  "version": "2.0.0-beta.1",
+  "version": "3.0.0",
   "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/)",
@@ -40,10 +40,11 @@
     "lint-fix": "prettier --write \"{,!(node_modules)/**/}*.{ts,tsx,js,jsx,md,yml,json,html}\""
   },
   "dependencies": {
-    "lambda-wrapper": "^0.3.0"
+    "lambda-wrapper": "^0.3.0",
+    "yaml": "^2.1.1"
   },
   "peerDependencies": {
-    "serverless": "^1.27.3"
+    "serverless": "^3.22.0"
   },
   "devDependencies": {
     "chai": "^4.3.6",
@@ -52,6 +53,6 @@
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "prettier": "^2.7.1",
-    "serverless": "^2.46.0"
+    "serverless": "^3.22.0"
   }
 }