@middy/core 5.0.0-alpha.0 → 5.0.0-alpha.2

package/README.md

@@ -19,8 +19,9 @@
   <a href="https://snyk.io/test/github/middyjs/middy">
     <img src="https://snyk.io/test/github/middyjs/middy/badge.svg" alt="Known Vulnerabilities" data-canonical-src="https://snyk.io/test/github/middyjs/middy" style="max-width:100%;">
   </a>
-  <a href="https://lgtm.com/projects/g/middyjs/middy/context:javascript">
-    <img src="https://img.shields.io/lgtm/grade/javascript/g/middyjs/middy.svg?logo=lgtm&logoWidth=18" alt="Language grade: JavaScript" style="max-width:100%;">
+  <a href="https://github.com/middyjs/middy/actions/workflows/sast.yml">
+    <img src="https://github.com/middyjs/middy/actions/workflows/sast.yml/badge.svg
+?branch=main&event=push" alt="CodeQL" style="max-width:100%;">
   </a>
   <a href="https://bestpractices.coreinfrastructure.org/projects/5280">
     <img src="https://bestpractices.coreinfrastructure.org/projects/5280/badge" alt="Core Infrastructure Initiative (CII) Best Practices"  style="max-width:100%;">

package/index.d.ts

@@ -6,7 +6,9 @@ import {
 
 declare type PluginHook = () => void
 declare type PluginHookWithMiddlewareName = (middlewareName: string) => void
-declare type PluginHookPromise = (request: Request) => Promise<unknown> | unknown
+declare type PluginHookPromise = (
+  request: Request
+) => Promise<unknown> | unknown
 
 interface PluginObject {
   internal?: any
@@ -19,62 +21,149 @@ interface PluginObject {
   timeoutEarlyResponse?: PluginHook
   afterHandler?: PluginHook
   requestEnd?: PluginHookPromise
+  streamifyResponse?: Boolean
 }
 
-export interface Request<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> {
+export interface Request<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> {
   event: TEvent
   context: TContext
   response: TResult | null
   error: TErr | null
-  internal: {
-    [key: string]: any
-  }
+  internal: TInternal
 }
 
-declare type MiddlewareFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> = (request: Request<TEvent, TResult, TErr, TContext>) => any
+declare type MiddlewareFn<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = (request: Request<TEvent, TResult, TErr, TContext, TInternal>) => any
 
-export interface MiddlewareObj<TEvent = unknown, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> {
-  before?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  after?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+export interface MiddlewareObj<
+  TEvent = unknown,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> {
+  before?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
 }
 
 // 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 MiddyInputHandler<
+  TEvent,
+  TResult,
+  TContext extends LambdaContext = LambdaContext
+> = (
+  event: TEvent,
+  context: TContext,
+  callback: LambdaCallback<TResult>
+) => // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+void | Promise<TResult> | 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>,
+export interface MiddyfiedHandler<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> extends MiddyInputHandler<TEvent, TResult, TContext>,
   MiddyInputPromiseHandler<TEvent, TResult, TContext> {
-  use: UseFn<TEvent, TResult, TErr, TContext>
-  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
-  handler: <TAdditional>(handler: MiddlewareHandler<LambdaHandler<TEvent & TAdditional, TResult>, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  use: UseFn<TEvent, TResult, TErr, TContext, TInternal>
+  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  handler: <TAdditional>(
+    handler: MiddlewareHandler<
+    LambdaHandler<TEvent & TAdditional, TResult>,
+    TContext
+    >
+  ) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 }
 
-declare type AttachMiddlewareFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
-  (middleware: MiddlewareFn<TEvent, TResult, TErr, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+declare type AttachMiddlewareFn<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = (
+  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
-declare type AttachMiddlewareObj<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
-  (middleware: MiddlewareObj<TEvent, TResult, TErr, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+declare type AttachMiddlewareObj<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = (
+  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
-declare type UseFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
-  <TMiddleware extends MiddlewareObj<any, any, Error, any>>(middlewares: TMiddleware | TMiddleware[]) => TMiddleware extends MiddlewareObj<infer TMiddlewareEvent, any, Error, infer TMiddlewareContext>
-    ? MiddyfiedHandler<TMiddlewareEvent & TEvent, TResult, TErr, TMiddlewareContext & TContext> // always true
-    : never
+declare type UseFn<
+  TEvent = any,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = <TMiddleware extends MiddlewareObj<any, any, Error, any, any>>(
+  middlewares: TMiddleware | TMiddleware[]
+) => TMiddleware extends MiddlewareObj<
+infer TMiddlewareEvent,
+any,
+Error,
+infer TMiddlewareContext,
+infer TMiddlewareInternal
+>
+  ? MiddyfiedHandler<
+  TMiddlewareEvent & TEvent,
+  TResult,
+  TErr,
+  TMiddlewareContext & TContext,
+  TMiddlewareInternal & TInternal
+  > // always true
+  : never
 
-declare type MiddlewareHandler<THandler extends LambdaHandler<any, any>, TContext extends LambdaContext = LambdaContext> =
-  THandler extends LambdaHandler<infer TEvent, infer TResult> // always true
-    ? MiddyInputHandler<TEvent, TResult, TContext>
-    : never
+declare type MiddlewareHandler<
+  THandler extends LambdaHandler<any, any>,
+  TContext extends LambdaContext = LambdaContext
+> = THandler extends LambdaHandler<infer TEvent, infer TResult> // always true
+  ? MiddyInputHandler<TEvent, TResult, TContext>
+  : never
 
 /**
  * Middy factory function. Use it to wrap your existing handler to enable middlewares on it.
  * @param handler your original AWS Lambda function
  * @param plugin wraps around each middleware and handler to add custom lifecycle behaviours (e.g. to profile performance)
  */
-declare function middy<TEvent = unknown, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> (handler?: MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>, plugin?: PluginObject): MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+declare function middy<
+  TEvent = unknown,
+  TResult = any,
+  TErr = Error,
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> (
+  handler?:
+  | MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>
+  | PluginObject,
+  plugin?: PluginObject
+): MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare namespace middy {
   export {

package/index.js

@@ -1,12 +1,22 @@
+/* global awslambda */ import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { setTimeout } from 'node:timers/promises';
 const defaultLambdaHandler = ()=>{};
 const defaultPlugin = {
     timeoutEarlyInMillis: 5,
     timeoutEarlyResponse: ()=>{
-        throw new Error('Timeout');
-    }
+        const err = new Error('[AbortError]: The operation was aborted.', {
+            cause: {
+                package: '@middy/core'
+            }
+        });
+        err.name = 'TimeoutError';
+        throw err;
+    },
+    streamifyResponse: false // Deprecate need for this when AWS provides a flag for when it's looking for it
 };
 const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
+    // Allow base handler to be set using .handler()
     if (typeof lambdaHandler !== 'function') {
         plugin = lambdaHandler;
         lambdaHandler = defaultLambdaHandler;
@@ -20,7 +30,7 @@ const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
     const beforeMiddlewares = [];
     const afterMiddlewares = [];
     const onErrorMiddlewares = [];
-    const middy = (event = {}, context = {})=>{
+    const middyHandler = (event = {}, context = {})=>{
         plugin.requestStart?.();
         const request = {
             event,
@@ -37,6 +47,35 @@ const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
             ...onErrorMiddlewares
         ], plugin);
     };
+    const middy = plugin.streamifyResponse ? awslambda.streamifyResponse(async (event, responseStream, context)=>{
+        const handlerResponse = await middyHandler(event, context);
+        let handlerBody = handlerResponse;
+        if (handlerResponse.statusCode) {
+            handlerBody = handlerResponse.body ?? '';
+            responseStream = awslambda.HttpResponseStream.from(responseStream, handlerResponse);
+        }
+        // Source @datastream/core (MIT)
+        let handlerStream;
+        if (handlerBody._readableState) {
+            handlerStream = handlerBody;
+        } else if (typeof handlerBody === 'string') {
+            function* iterator(input) {
+                const size = 16384 // 16 * 1024 // Node.js default
+                ;
+                let position = 0;
+                const length = input.length;
+                while(position < length){
+                    yield input.substring(position, position + size);
+                    position += size;
+                }
+            }
+            handlerStream = Readable.from(iterator(handlerBody));
+        }
+        if (!handlerStream) {
+            throw new Error('handler response not a ReadableStream');
+        }
+        await pipeline(handlerStream, responseStream);
+    }) : middyHandler;
     middy.use = (middlewares)=>{
         if (!Array.isArray(middlewares)) {
             middlewares = [
@@ -44,7 +83,7 @@ const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
             ];
         }
         for (const middleware of middlewares){
-            const { before , after , onError  } = 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"');
             }
@@ -54,6 +93,7 @@ const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
         }
         return middy;
     };
+    // Inline Middlewares
     middy.before = (beforeMiddleware)=>{
         beforeMiddlewares.push(beforeMiddleware);
         return middy;
@@ -74,9 +114,11 @@ const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
 };
 const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
     let timeoutAbort;
-    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
+    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis // disable when AWS context missing (tests, containers)
+    ;
     try {
         await runMiddlewares(request, beforeMiddlewares, plugin);
+        // Check if before stack hasn't exit early
         if (typeof request.response === 'undefined') {
             plugin.beforeHandler?.();
             const handlerAbort = new AbortController();
@@ -92,21 +134,26 @@ const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddle
                     return plugin.timeoutEarlyResponse();
                 }) : Promise.race([])
             ]);
-            timeoutAbort?.abort();
+            timeoutAbort?.abort() // lambdaHandler may not be a promise
+            ;
             plugin.afterHandler?.();
             await runMiddlewares(request, afterMiddlewares, plugin);
         }
     } catch (e) {
-        timeoutAbort?.abort();
+        timeoutAbort?.abort() // timeout should be aborted on errors
+        ;
+        // Reset response changes made by after stack before error thrown
         request.response = undefined;
         request.error = e;
         try {
             await runMiddlewares(request, onErrorMiddlewares, plugin);
         } catch (e) {
+            // Save error that wasn't handled
             e.originalError = request.error;
             request.error = e;
             throw request.error;
         }
+        // Catch if onError stack hasn't handled the error
         if (typeof request.response === 'undefined') throw request.error;
     } finally{
         await plugin.requestEnd?.(request);
@@ -118,6 +165,7 @@ const runMiddlewares = async (request, middlewares, plugin)=>{
         plugin.beforeMiddleware?.(nextMiddleware.name);
         const res = await nextMiddleware(request);
         plugin.afterMiddleware?.(nextMiddleware.name);
+        // short circuit chaining and respond early
         if (typeof res !== 'undefined') {
             request.response = res;
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "5.0.0-alpha.0",
+  "version": "5.0.0-alpha.2",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
@@ -10,24 +10,18 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "./index.cjs",
   "module": "./index.js",
   "exports": {
     ".": {
       "import": {
         "types": "./index.d.ts",
         "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.cjs"
       }
     }
   },
   "types": "index.d.ts",
   "files": [
     "index.js",
-    "index.cjs",
     "index.d.ts"
   ],
   "scripts": {
@@ -63,7 +57,10 @@
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.76",
-    "@types/node": "^18.0.0"
+    "@types/node": "^20.0.0"
   },
-  "gitHead": "08c35e3dba9efdad0b86666ce206ce302cc65d07"
+  "gitHead": "ebce8d5df8783077fa49ba62ee9be20e8486a7f1",
+  "dependencies": {
+    "@datastream/core": "0.0.35"
+  }
 }

package/index.cjs

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(module, "exports", {
-    enumerable: true,
-    get: ()=>_default
-});
-const _promises = require("node:timers/promises");
-const defaultLambdaHandler = ()=>{};
-const defaultPlugin = {
-    timeoutEarlyInMillis: 5,
-    timeoutEarlyResponse: ()=>{
-        throw new Error('Timeout');
-    }
-};
-const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
-    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 middy = (event = {}, context = {})=>{
-        plugin.requestStart?.();
-        const request = {
-            event,
-            context,
-            response: undefined,
-            error: undefined,
-            internal: plugin.internal ?? {}
-        };
-        return runRequest(request, [
-            ...beforeMiddlewares
-        ], lambdaHandler, [
-            ...afterMiddlewares
-        ], [
-            ...onErrorMiddlewares
-        ], plugin);
-    };
-    middy.use = (middlewares)=>{
-        if (!Array.isArray(middlewares)) {
-            middlewares = [
-                middlewares
-            ];
-        }
-        for (const middleware of middlewares){
-            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) middy.before(before);
-            if (after) middy.after(after);
-            if (onError) middy.onError(onError);
-        }
-        return middy;
-    };
-    middy.before = (beforeMiddleware)=>{
-        beforeMiddlewares.push(beforeMiddleware);
-        return middy;
-    };
-    middy.after = (afterMiddleware)=>{
-        afterMiddlewares.unshift(afterMiddleware);
-        return middy;
-    };
-    middy.onError = (onErrorMiddleware)=>{
-        onErrorMiddlewares.unshift(onErrorMiddleware);
-        return middy;
-    };
-    middy.handler = (replaceLambdaHandler)=>{
-        lambdaHandler = replaceLambdaHandler;
-        return middy;
-    };
-    return middy;
-};
-const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
-    let timeoutAbort;
-    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
-    try {
-        await runMiddlewares(request, beforeMiddlewares, plugin);
-        if (typeof request.response === 'undefined') {
-            plugin.beforeHandler?.();
-            const handlerAbort = new AbortController();
-            if (timeoutEarly) timeoutAbort = new AbortController();
-            request.response = await Promise.race([
-                lambdaHandler(request.event, request.context, {
-                    signal: handlerAbort.signal
-                }),
-                timeoutEarly ? (0, _promises.setTimeout)(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, undefined, {
-                    signal: timeoutAbort.signal
-                }).then(()=>{
-                    handlerAbort.abort();
-                    return plugin.timeoutEarlyResponse();
-                }) : Promise.race([])
-            ]);
-            timeoutAbort?.abort();
-            plugin.afterHandler?.();
-            await runMiddlewares(request, afterMiddlewares, plugin);
-        }
-    } catch (e) {
-        timeoutAbort?.abort();
-        request.response = undefined;
-        request.error = e;
-        try {
-            await runMiddlewares(request, onErrorMiddlewares, plugin);
-        } catch (e) {
-            e.originalError = request.error;
-            request.error = e;
-            throw request.error;
-        }
-        if (typeof request.response === 'undefined') throw request.error;
-    } finally{
-        await plugin.requestEnd?.(request);
-    }
-    return request.response;
-};
-const runMiddlewares = async (request, middlewares, plugin)=>{
-    for (const nextMiddleware of middlewares){
-        plugin.beforeMiddleware?.(nextMiddleware.name);
-        const res = await nextMiddleware(request);
-        plugin.afterMiddleware?.(nextMiddleware.name);
-        if (typeof res !== 'undefined') {
-            request.response = res;
-            return;
-        }
-    }
-};
-const _default = middy;
-