ci: update benchmark runner

package.json

@@ -63,13 +63,13 @@
     "@swc/core": "^1.2.135",
     "ava": "^5.0.0",
     "aws-sdk-client-mock": "^3.0.0",
-    "benchmark": "^2.1.4",
     "c8": "^8.0.0",
     "husky": "^8.0.0",
     "lerna": "^6.0.0",
     "lint-staged": "^15.0.0",
     "prettier": "^3.0.0",
     "sinon": "^17.0.0",
+    "tinybench": "^2.5.1",
     "ts-standard": "^12.0.0",
     "tsd": "^0.29.0"
   },

packages/appconfig/__benchmarks__/index.js

@@ -1,4 +1,4 @@
-import Benchmark from 'benchmark'
+import { Bench } from 'tinybench'
 import middy from '../../core/index.js'
 import middleware from '../index.js'
 
@@ -8,7 +8,7 @@ import {
   GetSecretValueCommand
 } from '@aws-sdk/client-appconfig'
 
-const suite = new Benchmark.Suite('@middy/appconfig')
+const bench = new Bench({ time: 1_000 })
 
 const context = {
   getRemainingTimeInMillis: () => 30000
@@ -29,7 +29,7 @@ const setupHandler = (options = {}) => {
 const coldHandler = setupHandler({ cacheExpiry: 0 })
 const warmHandler = setupHandler()
 
-suite
+await bench
   .add('without cache', async (event = {}) => {
     try {
       await coldHandler(event, context)
@@ -40,7 +40,7 @@ suite
       await warmHandler(event, context)
     } catch (e) {}
   })
-  .on('cycle', (event) => {
-    console.log(suite.name, String(event.target))
-  })
-  .run({ async: true })
+
+  .run()
+
+console.table(bench.table())

packages/cloudwatch-metrics/__benchmarks__/index.js

@@ -1,9 +1,9 @@
 /*
-import Benchmark from 'benchmark'
+import { Bench } from 'tinybench'
 import middy from '../../core/index.js'
 import middleware from '../index.js'
 
-const suite = new Benchmark.Suite('@middy/cloudwatch-metrics')
+const bench = new Bench({ time: 1_000 })
 
 const context = {
   getRemainingTimeInMillis: () => 30000
@@ -17,7 +17,7 @@ const setupHandler = () => {
 const warmHandler = setupHandler()
 
 // TODO fix error
-suite
+await bench
   .add('Cold Invocation', async (event = {}) => {
     const coldHandler = setupHandler()
     try {
@@ -29,7 +29,7 @@ suite
       await warmHandler(event, context)
     } catch (e) {}
   })
-  .on('cycle', (event) => {
-    console.log(suite.name, String(event.target))
-  })
-  .run({ async: true }) */
+
+  .run()
+
+console.table(bench.table()) */

packages/core/__benchmarks__/index.js

@@ -1,35 +1,102 @@
-import Benchmark from 'benchmark'
+import { Bench } from 'tinybench'
 import middy from '../index.js'
 
-const suite = new Benchmark.Suite('@middy/core')
+const bench = new Bench({ time: 1_000 })
 
+const middleware = (opts = {}) => {
+  const middlewareBefore = (request) => {}
+  const middlewareAfter = (request) => {}
+  const middlewareOnError = (request) => {
+    if (request.response !== undefined) return
+    middlewareAfter(request)
+  }
+  return {
+    before: middlewareBefore,
+    after: middlewareAfter,
+    onError: middlewareOnError
+  }
+}
+const middlewareAsync = (opts = {}) => {
+  const middlewareBefore = async (request) => {}
+  const middlewareAfter = async (request) => {}
+  const middlewareOnError = async (request) => {
+    if (request.response !== undefined) return
+    await middlewareAfter(request)
+  }
+  return {
+    before: middlewareBefore,
+    after: middlewareAfter,
+    onError: middlewareOnError
+  }
+}
+const baseHandler = () => {}
+const baseHandlerAsync = async () => {}
 const context = {
   getRemainingTimeInMillis: () => 30000
 }
-const setupHandler = (timeoutEarlyInMillis = 0) => {
-  const baseHandler = () => {}
-  return middy(baseHandler, { timeoutEarlyInMillis })
-}
 
-const warmHandler = setupHandler()
-const warmtimeoutHandler = setupHandler(1000)
+const warmHandler = middy().handler(baseHandler)
+const warmAsyncHandler = middy().handler(baseHandlerAsync)
+const middlewares = new Array(25)
+middlewares.fill(middleware())
+const warmMiddlewareHandler = middy().use(middlewares).handler(baseHandler)
+const middlewaresAsync = new Array(25)
+middlewaresAsync.fill(middlewareAsync())
+const warmAsyncMiddlewareHandler = middy()
+  .use(middlewaresAsync)
+  .handler(baseHandler)
+const warmTimeoutHandler = middy({ timeoutEarlyInMillis: 0 }).handler(
+  baseHandler
+)
+
+// const warmNextHandler = middyNext().handler(baseHandler)
+// const warmNextMiddlewareHandler = middyNext()
+//   .use([middleware()])
+//   .handler(baseHandler)
+// const warmNextAsyncMiddlewareHandler = middyNext()
+//   .use([middlewareAsync()])
+//   .handler(baseHandler)
+// const warmNextTimeoutHandler = middyNext({ timeoutEarlyInMillis: 0 }).handler(
+//   baseHandler
+// )
 
-suite
+await bench
   .add('Cold Invocation', async (event = {}) => {
-    const coldHandler = setupHandler()
+    const coldHandler = middy().handler(baseHandler)
     await coldHandler(event, context)
   })
-  .add('Cold Invocation w/ Timeout', async (event = {}) => {
-    const coldHandler = setupHandler(1000)
+  .add('Cold Invocation with middleware', async (event = {}) => {
+    const middlewares = new Array(25)
+    middlewares.fill(middleware())
+    const coldHandler = middy().use(middlewares).handler(baseHandler)
     await coldHandler(event, context)
   })
   .add('Warm Invocation', async (event = {}) => {
     await warmHandler(event, context)
   })
-  .add('Warm Invocation with Timeout', async (event = {}) => {
-    await warmtimeoutHandler(event, context)
+  // .add('Warm Invocation * next', async (event = {}) => {
+  //   await warmNextHandler(event, context)
+  // })
+  .add('Warm Async Invocation', async (event = {}) => {
+    await warmAsyncHandler(event, context)
   })
-  .on('cycle', (event) => {
-    console.log(suite.name, String(event.target))
+  .add('Warm Invocation without Timeout', async (event = {}) => {
+    await warmTimeoutHandler(event, context)
   })
-  .run({ async: true })
+  // .add('Warm Invocation with Timeout * next', async (event = {}) => {
+  //   await warmNextTimeoutHandler(event, context)
+  // })
+  // TODO StreamifyResponse
+  .add('Warm Invocation with middleware', async (event = {}) => {
+    await warmMiddlewareHandler(event, context)
+  })
+  // .add('Warm Invocation with middleware * next', async (event = {}) => {
+  //   await warmNextMiddlewareHandler(event, context)
+  // })
+  .add('Warm Invocation with async middleware', async (event = {}) => {
+    await warmAsyncMiddlewareHandler(event, context)
+  })
+
+  .run()
+
+console.table(bench.table())