@middy/core 2.5.6 → 3.0.0-alpha.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2021 Luciano Mammino, will Farrell and the [Middy team](https://github.com/middyjs/middy/graphs/contributors)
+Copyright (c) 2017-2022 Luciano Mammino, will Farrell and the [Middy team](https://github.com/middyjs/middy/graphs/contributors)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -47,7 +47,7 @@ Everyone is very welcome to contribute to this repository. Feel free to [raise i
 
 ## License
 
-Licensed under [MIT License](LICENSE). Copyright (c) 2017-2021 Luciano Mammino, will Farrell, and the [Middy team](https://github.com/middyjs/middy/graphs/contributors).
+Licensed under [MIT License](LICENSE). Copyright (c) 2017-2022 Luciano Mammino, will Farrell, and the [Middy team](https://github.com/middyjs/middy/graphs/contributors).
 
 <a href="https://app.fossa.io/projects/git%2Bgithub.com%2Fmiddyjs%2Fmiddy?ref=badge_large">
   <img src="https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmiddyjs%2Fmiddy.svg?type=large" alt="FOSSA Status"  style="max-width:100%;">

package/index.d.ts

@@ -9,11 +9,14 @@ declare type PluginHookWithMiddlewareName = (middlewareName: string) => void
 declare type PluginHookPromise = (request: Request) => Promise<unknown> | unknown
 
 interface PluginObject {
+  internal?: any
   beforePrefetch?: PluginHook
   requestStart?: PluginHook
   beforeMiddleware?: PluginHookWithMiddlewareName
   afterMiddleware?: PluginHookWithMiddlewareName
   beforeHandler?: PluginHook
+  timeoutEarlyInMillis?: number
+  timeoutEarlyResponse?: PluginHook
   afterHandler?: PluginHook
   requestEnd?: PluginHookPromise
 }
@@ -39,20 +42,14 @@ export interface MiddlewareObj<TEvent = any, TResult = any, TErr = Error, TConte
 // The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type MiddyInputHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext, callback: LambdaCallback<TResult>) => void | Promise<TResult>
-type MiddyInputPromiseHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext,) => Promise<TResult>
+type MiddyInputPromiseHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = ( event: TEvent, context: TContext, ) => Promise<TResult>;
 
 export interface MiddyfiedHandler<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> extends MiddyInputHandler<TEvent, TResult, TContext>,
   MiddyInputPromiseHandler<TEvent, TResult, TContext> {
   use: UseFn<TEvent, TResult, TErr, TContext>
-  applyMiddleware: AttachMiddlewareObj<TEvent, TResult, TErr, TContext>
   before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
   after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
   onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  __middlewares: {
-    before: Array<MiddlewareFn<TEvent, TResult, TErr, TContext>>
-    after: Array<MiddlewareFn<TEvent, TResult, TErr, TContext>>
-    onError: Array<MiddlewareFn<TEvent, TResult, TErr, TContext>>
-  }
 }
 
 declare type AttachMiddlewareFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> = (middleware: MiddlewareFn) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>

package/index.js

@@ -1,93 +1,114 @@
-const middy = (baseHandler = () => {}, plugin) => {
-  plugin?.beforePrefetch?.()
+const defaultLambdaHandler = () => {}
+const defaultPlugin = {
+  timeoutEarlyInMillis: 5,
+  timeoutEarlyResponse: () => { throw new Error('Timeout') }
+}
+
+const middy = (lambdaHandler = defaultLambdaHandler, plugin = {}) => {
+  // Allow base handler to be set using .handler()
+  if (typeof lambdaHandler !== 'function') {
+    plugin = lambdaHandler
+    lambdaHandler = defaultLambdaHandler
+  }
+  plugin = { ...defaultPlugin, ...plugin }
+  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0
+
+  plugin.beforePrefetch?.()
   const beforeMiddlewares = []
   const afterMiddlewares = []
   const onErrorMiddlewares = []
 
-  const instance = (event = {}, context = {}) => {
-    plugin?.requestStart?.()
+  const middy = (event = {}, context = {}) => {
+    plugin.requestStart?.()
     const request = {
       event,
       context,
       response: undefined,
       error: undefined,
-      internal: {}
+      internal: plugin.internal ?? {}
     }
 
     return runRequest(
       request,
       [...beforeMiddlewares],
-      baseHandler,
+      lambdaHandler,
       [...afterMiddlewares],
       [...onErrorMiddlewares],
       plugin
     )
   }
 
-  instance.use = (middlewares) => {
-    if (Array.isArray(middlewares)) {
-      for (const middleware of middlewares) {
-        instance.applyMiddleware(middleware)
-      }
-      return instance
+  middy.use = (middlewares) => {
+    if (!Array.isArray(middlewares)) {
+      middlewares = [middlewares]
     }
-    return instance.applyMiddleware(middlewares)
-  }
+    for (const middleware of middlewares) {
+      const { before, after, onError } = middleware
 
-  instance.applyMiddleware = (middleware) => {
-    const { before, after, onError } = middleware
+      if (!before && !after && !onError) {
+        throw new Error(
+          'Middleware must be an object containing at least one key among "before", "after", "onError"'
+        )
+      }
 
-    if (!before && !after && !onError) {
-      throw new Error(
-        'Middleware must be an object containing at least one key among "before", "after", "onError"'
-      )
+      if (before) middy.before(before)
+      if (after) middy.after(after)
+      if (onError) middy.onError(onError)
     }
-
-    if (before) instance.before(before)
-    if (after) instance.after(after)
-    if (onError) instance.onError(onError)
-
-    return instance
+    return middy
   }
 
   // Inline Middlewares
-  instance.before = (beforeMiddleware) => {
+  middy.before = (beforeMiddleware) => {
     beforeMiddlewares.push(beforeMiddleware)
-    return instance
+    return middy
   }
-  instance.after = (afterMiddleware) => {
+  middy.after = (afterMiddleware) => {
     afterMiddlewares.unshift(afterMiddleware)
-    return instance
+    return middy
   }
-  instance.onError = (onErrorMiddleware) => {
-    onErrorMiddlewares.push(onErrorMiddleware)
-    return instance
+  middy.onError = (onErrorMiddleware) => {
+    onErrorMiddlewares.unshift(onErrorMiddleware)
+    return middy
   }
-
-  instance.__middlewares = {
-    before: beforeMiddlewares,
-    after: afterMiddlewares,
-    onError: onErrorMiddlewares
+  middy.handler = (replaceLambdaHandler) => {
+    lambdaHandler = replaceLambdaHandler
   }
 
-  return instance
+  return middy
 }
 
 const runRequest = async (
   request,
   beforeMiddlewares,
-  baseHandler,
+  lambdaHandler,
   afterMiddlewares,
   onErrorMiddlewares,
   plugin
 ) => {
+  const { timeoutEarly } = plugin
   try {
     await runMiddlewares(request, beforeMiddlewares, plugin)
     // Check if before stack hasn't exit early
     if (request.response === undefined) {
-      plugin?.beforeHandler?.()
-      request.response = await baseHandler(request.event, request.context)
-      plugin?.afterHandler?.()
+      plugin.beforeHandler?.()
+
+      const handlerAbort = new AbortController()
+      let timeoutAbort
+      if (timeoutEarly) timeoutAbort = new AbortController()
+      request.response = await Promise.race([
+        lambdaHandler(request.event, request.context, { signal: handlerAbort.signal }),
+        timeoutEarly
+          ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, { signal: timeoutAbort.signal })
+            .then(() => {
+              handlerAbort.abort()
+              return plugin.timeoutEarlyResponse()
+            })
+          : Promise.race([])
+      ])
+      if (timeoutEarly) timeoutAbort.abort() // lambdaHandler may not be a promise
+
+      plugin.afterHandler?.()
       await runMiddlewares(request, afterMiddlewares, plugin)
     }
   } catch (e) {
@@ -106,7 +127,7 @@ const runRequest = async (
     // Catch if onError stack hasn't handled the error
     if (request.response === undefined) throw request.error
   } finally {
-    await plugin?.requestEnd?.(request)
+    await plugin.requestEnd?.(request)
   }
 
   return request.response
@@ -114,9 +135,9 @@ const runRequest = async (
 
 const runMiddlewares = async (request, middlewares, plugin) => {
   for (const nextMiddleware of middlewares) {
-    plugin?.beforeMiddleware?.(nextMiddleware?.name)
-    const res = await nextMiddleware?.(request)
-    plugin?.afterMiddleware?.(nextMiddleware?.name)
+    plugin.beforeMiddleware?.(nextMiddleware.name)
+    const res = await nextMiddleware(request)
+    plugin.afterMiddleware?.(nextMiddleware.name)
     // short circuit chaining and respond early
     if (res !== undefined) {
       request.response = res
@@ -125,4 +146,105 @@ const runMiddlewares = async (request, middlewares, plugin) => {
   }
 }
 
-module.exports = middy
+// Start Polyfill (Nodejs v14)
+/*
+MIT License
+
+Copyright (c) 2019 Steve Faulkner
+
+node-abort-controller
+ */
+const polyfillAbortController = async () => {
+  if (process.version < 'v15.0.0') {
+    const events = await import('events')
+    const { EventEmitter } = events
+
+    class AbortSignal {
+      constructor () {
+        this.eventEmitter = new EventEmitter()
+        this.onabort = null
+        this.aborted = false
+      }
+
+      toString () {
+        return '[object AbortSignal]'
+      }
+
+      get [Symbol.toStringTag] () {
+        return 'AbortSignal'
+      }
+
+      removeEventListener (name, handler) {
+        this.eventEmitter.removeListener(name, handler)
+      }
+
+      addEventListener (name, handler) {
+        this.eventEmitter.on(name, handler)
+      }
+
+      dispatchEvent (type) {
+        const event = { type, target: this }
+        const handlerName = `on${type}`
+
+        if (typeof this[handlerName] === 'function') this[handlerName](event)
+
+        this.eventEmitter.emit(type, event)
+      }
+    }
+
+    return class AbortController {
+      constructor () {
+        this.signal = new AbortSignal()
+      }
+
+      abort () {
+        if (this.signal.aborted) return
+
+        this.signal.aborted = true
+        this.signal.dispatchEvent('abort')
+      }
+
+      toString () {
+        return '[object AbortController]'
+      }
+
+      get [Symbol.toStringTag] () {
+        return 'AbortController'
+      }
+    }
+  } else {
+    return AbortController
+  }
+}
+global.AbortController = await polyfillAbortController()
+
+const polyfillSetTimeoutPromise = async () => {
+
+  if (process.version < 'v15.0.0') {
+    return (ms, { signal }) => {
+      if (signal.aborted) {
+        return Promise.reject(new Error('Aborted', 'AbortError'))
+      }
+      return new Promise((resolve, reject) => {
+        const abortHandler = () => {
+          clearTimeout(timeout)
+          reject(new Error('Aborted', 'AbortError'))
+        }
+        // start async operation
+        const timeout = setTimeout(() => {
+          resolve()
+          signal.removeEventListener('abort', abortHandler)
+        }, ms)
+        signal.addEventListener('abort', abortHandler)
+      })
+    }
+  } else {
+    const timers = await import('timers/promises')
+    return timers.setTimeout
+  }
+}
+global.setTimeoutPromise = await polyfillSetTimeoutPromise()
+// import { setTimeout as setTimeoutPromise } from 'timers/promises'
+// End Polyfill
+
+export default middy

package/package.json

@@ -1,23 +1,25 @@
 {
   "name": "@middy/core",
-  "version": "2.5.6",
+  "version": "3.0.0-alpha.3",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
-  "type": "commonjs",
+  "type": "module",
   "engines": {
-    "node": ">=12"
+    "node": ">=14"
   },
   "engineStrict": true,
   "publishConfig": {
     "access": "public"
   },
-  "main": "index.js",
+  "exports": "./index.js",
   "types": "index.d.ts",
   "files": [
+    "index.js",
     "index.d.ts"
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
   },
   "license": "MIT",
   "keywords": [
@@ -43,7 +45,7 @@
   "homepage": "https://github.com/middyjs/middy#readme",
   "devDependencies": {
     "@types/aws-lambda": "^8.10.76",
-    "@types/node": "^16.0.0"
+    "@types/node": "^17.0.0"
   },
-  "gitHead": "0c789f55b4adf691f977b0d9904d1a805bb3bb2b"
+  "gitHead": "1441158711580313765e6d156046ef0fade0d156"
 }