npm - @middy/core - Versions diffs - 5.0.0-alpha.1 → 5.0.0-alpha.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/index.js +168 -201
package/package.json +1 -1

package/index.js CHANGED Viewed

@@ -1,209 +1,176 @@
-/* global awslambda */
-import { Readable } from 'node:stream'
-import { pipeline } from 'node:stream/promises'
-import { setTimeout } from 'node:timers/promises'
-const defaultLambdaHandler = () => {}
+/* 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: () => {
-    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
-  }
-  plugin = { ...defaultPlugin, ...plugin }
-  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0
-  plugin.beforePrefetch?.()
-  const beforeMiddlewares = []
-  const afterMiddlewares = []
-  const onErrorMiddlewares = []
-  const middyHandler = (event = {}, context = {}) => {
-    plugin.requestStart?.()
-    const request = {
-      event,
-      context,
-      response: undefined,
-      error: undefined,
-      internal: plugin.internal ?? {}
+    timeoutEarlyInMillis: 5,
+    timeoutEarlyResponse: ()=>{
+        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;
     }
-    return runRequest(
-      request,
-      [...beforeMiddlewares],
-      lambdaHandler,
-      [...afterMiddlewares],
-      [...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
-          }
+    plugin = {
+        ...defaultPlugin,
+        ...plugin
+    };
+    plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
+    plugin.beforePrefetch?.();
+    const beforeMiddlewares = [];
+    const afterMiddlewares = [];
+    const onErrorMiddlewares = [];
+    const middyHandler = (event = {}, context = {})=>{
+        plugin.requestStart?.();
+        const request = {
+            event,
+            context,
+            response: undefined,
+            error: undefined,
+            internal: plugin.internal ?? {}
+        };
+        return runRequest(request, [
+            ...beforeMiddlewares
+        ], lambdaHandler, [
+            ...afterMiddlewares
+        ], [
+            ...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);
         }
-        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 = [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
-  }
-  // Inline Middlewares
-  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 // 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()
-      if (timeoutEarly) timeoutAbort = new AbortController()
-      request.response = await Promise.race([
-        lambdaHandler(request.event, request.context, {
-          signal: handlerAbort.signal
-        }),
-        timeoutEarly
-          ? setTimeout(
-            request.context.getRemainingTimeInMillis() -
-                plugin.timeoutEarlyInMillis,
-            undefined,
-            { signal: timeoutAbort.signal }
-          ).then(() => {
-            handlerAbort.abort()
-            return plugin.timeoutEarlyResponse()
-          })
-          : Promise.race([])
-      ])
-      timeoutAbort?.abort() // lambdaHandler may not be a promise
-      plugin.afterHandler?.()
-      await runMiddlewares(request, afterMiddlewares, plugin)
-    }
-  } catch (e) {
-    timeoutAbort?.abort() // timeout should be aborted on errors
-    // Reset response changes made by after stack before error thrown
-    request.response = undefined
-    request.error = e
+        // 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 = [
+                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;
+    };
+    // Inline Middlewares
+    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 // disable when AWS context missing (tests, containers)
+    ;
     try {
-      await runMiddlewares(request, onErrorMiddlewares, plugin)
+        await runMiddlewares(request, beforeMiddlewares, plugin);
+        // Check if before stack hasn't exit early
+        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 ? setTimeout(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, undefined, {
+                    signal: timeoutAbort.signal
+                }).then(()=>{
+                    handlerAbort.abort();
+                    return plugin.timeoutEarlyResponse();
+                }) : Promise.race([])
+            ]);
+            timeoutAbort?.abort() // lambdaHandler may not be a promise
+            ;
+            plugin.afterHandler?.();
+            await runMiddlewares(request, afterMiddlewares, plugin);
+        }
     } catch (e) {
-      // Save error that wasn't handled
-      e.originalError = request.error
-      request.error = e
-      throw request.error
+        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);
     }
-    // Catch if onError stack hasn't handled the 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)
-    // short circuit chaining and respond early
-    if (typeof res !== 'undefined') {
-      request.response = res
-      return
+    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);
+        // short circuit chaining and respond early
+        if (typeof res !== 'undefined') {
+            request.response = res;
+            return;
+        }
     }
-  }
-}
+};
+export default middy;
-export default middy

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.2",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {