@bleedingdev/modern-js-server-core 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/esm/plugins/render/ssrCache.mjs

@@ -1,54 +1,88 @@
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
 import { X_RENDER_CACHE } from "../../constants.mjs";
 import { createTransformStream, getPathname } from "../../utils/index.mjs";
+const preventsSharedCaching = (headers)=>/(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:[=,]|$)/i.test(headers.get('cache-control') || '');
+const isCacheableResponse = (response)=>200 === response.status && !preventsSharedCaching(response.headers) && !response.headers.has('set-cookie') && !response.headers.get('vary');
 const removeTailSlash = (s)=>s.replace(/\/+$/, '');
 const ZERO_RENDER_LEVEL = /"renderLevel":0/;
 const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
 async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
     const response = await requestHandler(request, requestHandlerOptions);
     const { onError } = requestHandlerOptions;
-    const nonCacheableStatusCodes = [
-        204,
-        305,
-        404,
-        405,
-        500,
-        501,
-        502,
-        503,
-        504
-    ];
-    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const deleteCache = async ()=>{
+        try {
+            await container.delete(key);
+        } catch  {
+            (onError || console.error)('[render-cache] delete cache failed');
+        }
+    };
+    if (!isCacheableResponse(response) || !response.body) {
+        await deleteCache();
+        return response;
+    }
+    const headers = Object.fromEntries(response.headers);
     const decoder = new TextDecoder();
     if (response.body) {
         const stream = createTransformStream();
         const reader = response.body.getReader();
         const writer = stream.writable.getWriter();
         let html = '';
-        const push = ()=>reader.read().then(({ done, value })=>{
-                if (done) {
-                    const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
-                    if (match) return void writer.close();
-                    const current = Date.now();
-                    const cache = {
-                        val: html,
-                        cursor: current
-                    };
-                    container.set(key, JSON.stringify(cache), {
+        let cancelled = false;
+        const cancel = async (reason)=>{
+            cancelled = true;
+            await reader.cancel(reason);
+        };
+        writer.closed.catch(cancel).catch(()=>{});
+        const onAbort = ()=>{
+            Promise.allSettled([
+                cancel(request.signal.reason),
+                writer.abort(request.signal.reason)
+            ]);
+        };
+        request.signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (request.signal.aborted) onAbort();
+        const pumping = (async ()=>{
+            try {
+                for(;;){
+                    const { done, value } = await reader.read();
+                    if (cancelled) return;
+                    if (done) break;
+                    html += decoder.decode(value, {
+                        stream: true
+                    });
+                    await writer.write(value);
+                }
+                html += decoder.decode();
+                await writer.close();
+                if (cancelled) return;
+                if (ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html)) return void await deleteCache();
+                const cache = {
+                    val: html,
+                    cursor: Date.now(),
+                    headers
+                };
+                try {
+                    await container.set(key, JSON.stringify(cache), {
                         ttl
-                    }).catch(()=>{
-                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
                     });
-                    writer.close();
-                    return;
+                } catch (error) {
+                    (onError || console.error)('[render-cache] set cache failed');
                 }
-                const content = decoder.decode(value);
-                html += content;
-                writer.write(value);
-                push();
-            });
-        push();
+            } catch (error) {
+                await Promise.allSettled([
+                    cancel(error),
+                    writer.abort(error)
+                ]);
+                if (cacheStatus) try {
+                    (onError || console.error)('[render-cache] response stream failed');
+                } catch  {}
+            } finally{
+                request.signal.removeEventListener('abort', onAbort);
+            }
+        })();
+        pumping.catch(()=>{});
         cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
         return new Response(stream.readable, {
             status: response.status,
@@ -63,9 +97,12 @@ function computedKey(req, cacheControl) {
     const pathname = getPathname(req);
     const { customKey } = cacheControl;
     const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
-    if (!customKey) return defaultKey;
-    if ('string' == typeof customKey) return customKey;
-    return customKey(defaultKey);
+    if (customKey) if ('string' == typeof customKey) return customKey;
+    else return customKey(defaultKey);
+    else {
+        const url = new URL(req.url);
+        return `${url.origin}${defaultKey}${url.search}`;
+    }
 }
 function shouldUseCache(request) {
     const url = new URL(request.url);
@@ -76,7 +113,7 @@ function shouldUseCache(request) {
 }
 function matchCacheControl(cacheOption, req) {
     if (!cacheOption || !req) return;
-    {
+    else {
         if (isCacheControl(cacheOption)) return cacheOption;
         if (isCacheOptionProvider(cacheOption)) return cacheOption(req);
         const url = req.url;
@@ -95,13 +132,15 @@ function matchCacheControl(cacheOption, req) {
 async function getCacheResult(request, options) {
     const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
     const { onError } = requestHandlerOptions;
-    const key = computedKey(request, cacheControl);
+    const hasCredentials = request.headers.has('cookie') || request.headers.has('authorization');
+    if ('GET' !== request.method || !shouldUseCache(request) || preventsSharedCaching(request.headers) || hasCredentials && !cacheControl.customKey) return requestHandler(request, requestHandlerOptions);
+    const key = `${CACHE_NAMESPACE}:v2:${computedKey(request, cacheControl)}`;
     let value;
     try {
         value = await container.get(key);
     } catch (_) {
-        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
-        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        if (onError) onError('[render-cache] get cache failed');
+        else console.error('[render-cache] get cache failed');
         value = void 0;
     }
     const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -115,27 +154,27 @@ async function getCacheResult(request, options) {
         container,
         cacheStatus: 'miss'
     });
-    {
+    else {
         const cache = JSON.parse(value);
         const interval = Date.now() - cache.cursor;
         if (interval <= maxAge) {
             const cacheStatus = 'hit';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });
-        }
-        if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
-            key,
-            request,
-            requestHandler,
-            requestHandlerOptions,
-            ttl,
-            container,
-            cacheStatus: 'expired'
-        });
-        {
+        } else {
+            if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container,
+                cacheStatus: 'expired'
+            });
             processCache({
                 key,
                 request,
@@ -145,10 +184,15 @@ async function getCacheResult(request, options) {
                 container
             }).then(async (response)=>{
                 await response.text();
+            }).catch((error)=>{
+                try {
+                    (onError || console.error)('[render-cache] revalidation failed');
+                } catch  {}
             });
             const cacheStatus = 'stale';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });

package/dist/esm/serverBase.mjs

@@ -146,7 +146,7 @@ function applyMiddlewares() {
         if (middleware.before) {
             const targetIndex = finalMiddlewares.findIndex((item)=>{
                 if (middleware.before?.includes(item.name)) return true;
-                return false;
+                else return false;
             });
             if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
             else finalMiddlewares.push(middleware);
@@ -167,7 +167,7 @@ function applyMiddlewares() {
     }
     function handler2Handlers(handler) {
         if (Array.isArray(handler)) return handler;
-        return [
+        else return [
             handler
         ];
     }

package/dist/esm/utils/transformStream.mjs

@@ -14,7 +14,7 @@ function transformResponse(response, transformCb) {
     if (response.body) {
         const stream = createTransformStream(async (before)=>{
             if (Array.isArray(transformCb)) return transformCb.reduce(async (before, cb)=>cb(await before), Promise.resolve(before));
-            return transformCb(before);
+            else return transformCb(before);
         });
         response.body.pipeThrough(stream);
         readable = stream.readable;

package/dist/esm-node/adapters/node/hono.mjs

@@ -30,27 +30,36 @@ const httpCallBack2HonoMid = (handler)=>async (context, next)=>{
         } else await next();
     };
 const noop = ()=>{};
-const connectMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
-            const { req, res } = context.env.node;
-            if (handler.length < 3) resolve(handler(req, res, noop));
-            else handler(req, res, (err)=>{
+const connectMid2HonoMid = (handler)=>async (context, next)=>{
+        const { req, res: rawRes } = context.env.node;
+        const res = rawRes;
+        if (handler.length < 3) return handler(req, res, noop);
+        const continueChain = await new Promise((resolve, reject)=>{
+            const onFinish = ()=>{
+                context.res;
+                context.finalized = true;
+                resolve(false);
+            };
+            res.once?.('finish', onFinish);
+            handler(req, res, (err)=>{
+                res.removeListener?.('finish', onFinish);
                 if (err) reject(err);
-                else resolve(next());
+                else resolve(true);
             });
         });
-const connectMockMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
+        if (continueChain) await next();
+    };
+const connectMockMid2HonoMid = (handler)=>{
+    if (handler.length >= 3) return connectMid2HonoMid(handler);
+    return async (context, _next)=>new Promise((resolve)=>{
             const { req, res: rawRes } = context.env.node;
             const res = rawRes;
-            if (handler.length < 3) {
-                res.once?.('finish', ()=>{
-                    context.res;
-                    context.finalized = true;
-                    resolve();
-                });
-                handler(req, res, noop);
-            } else handler(req, res, (err)=>{
-                if (err) reject(err);
-                else resolve(next());
+            res.once?.('finish', ()=>{
+                context.res;
+                context.finalized = true;
+                resolve();
             });
+            handler(req, res, noop);
         });
+};
 export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid };

package/dist/esm-node/adapters/node/node.mjs

@@ -25,7 +25,9 @@ const createWebRequest = (req, res, body)=>{
         headers: headerRecord,
         signal: controller.signal
     };
-    res.on('close', ()=>controller.abort('res closed'));
+    res.on('close', ()=>{
+        if (!res.writableFinished || req.aborted) controller.abort('res closed');
+    });
     const protocol = 'encrypted' in req.socket && req.socket.encrypted ? 'https' : 'http';
     const authority = req.headers[':authority'] ?? req.headers.host;
     const url = `${protocol}://${authority}${req.url}`;

package/dist/esm-node/adapters/node/plugins/static.mjs

@@ -155,7 +155,7 @@ function createStaticMiddleware(options) {
             respondAsset: options.respondAsset,
             respondPublicFallback: options.respondPublicFallback
         })(c, next);
-        {
+        else {
             const filepath = path.join(pwd, pathname.replace(pathPrefix, ()=>''));
             if (!isPathInside(filepath, pwd)) return next();
             if (!await fs.pathExists(filepath)) return next();

package/dist/esm-node/helper.mjs

@@ -3,7 +3,7 @@ const LOADER_CONTEXT = 'loaderContext';
 function getLoaderCtx(c) {
     const loaderContext = c.get(LOADER_CONTEXT);
     if (loaderContext) return loaderContext;
-    {
+    else {
         const loaderContext = new Map();
         c.set(LOADER_CONTEXT, loaderContext);
         return loaderContext;

package/dist/esm-node/plugins/log.mjs

@@ -41,7 +41,8 @@ function logHandler() {
         log(logFn, "<--", method, path);
         const start = Date.now();
         await next();
-        log(logFn, "-->", method, path, c?.env?.node?.res?.statusCode ?? c.res.status, time(start));
+        const nodeRes = c?.env?.node?.res;
+        log(logFn, "-->", method, path, nodeRes?.headersSent ? nodeRes.statusCode : c.res.status, time(start));
     };
 }
 const logPlugin = ()=>({

package/dist/esm-node/plugins/render/render.mjs

@@ -8,14 +8,8 @@ import { dataHandler } from "./dataHandler.mjs";
 import { renderRscHandler } from "./renderRscHandler.mjs";
 import { serverActionHandler } from "./serverActionHandler.mjs";
 import { ssrRender } from "./ssrRender.mjs";
-import { __webpack_require__ } from "../../rslib-runtime~0.mjs";
 import { createRequire as __rspack_createRequire } from "node:module";
 const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
-__webpack_require__.add({
-    "@modern-js/runtime-utils/router" (module) {
-        module.exports = __rspack_createRequire_require("@modern-js/runtime-utils/router");
-    }
-});
 const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
     const dynamicRoutes = [];
@@ -48,8 +42,7 @@ function matchRoute(router, pathname, entryName) {
             void 0,
             {}
         ];
-    }
-    {
+    } else {
         const result = matchedRoutes[0];
         if (!result) return [
             void 0,
@@ -74,6 +67,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig
     return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, serverContext, contextForceCSR, reporter })=>{
         const forMatchpathname = matchPathname ?? getPathname(req);
         const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
+        serverContext?.set('renderRoute', routeInfo);
         const framework = cutNameByHyphen(metaName || 'modern-js');
         const fallbackHeader = `x-${framework}-ssr-fallback`;
         let fallbackReason = null;
@@ -166,7 +160,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         const { nestedRoutesJson } = serverManifest;
         const routes = nestedRoutesJson?.[options.routeInfo.entryName];
         if (routes) {
-            const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+            const { matchRoutes } = __rspack_createRequire_require("@modern-js/runtime-utils/router");
             const url = new URL(request.url);
             const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
             if (matchedRoutes) {
@@ -204,7 +198,7 @@ async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFa
     if (req.headers.get('x-rsc-action')) return 'rsc-action';
     if (req.headers.get('x-rsc-tree')) return 'rsc-tree';
     if (!isSSR) return 'csr';
-    {
+    else {
         if (query.__loader) return 'data';
         const fallbackHeaderValue = req.headers.get(fallbackHeader) || nodeReq?.headers[fallbackHeader];
         if (forceCSR && (query.csr || fallbackHeaderValue || contextForceCSR)) {
@@ -233,6 +227,6 @@ async function csrRender(request, options) {
             [X_MODERNJS_RENDER]: 'client'
         })
     });
-    return csrRscRender(request, options);
+    else return csrRscRender(request, options);
 }
 export { createRender, matchRoute };

package/dist/esm-node/plugins/render/ssrCache.mjs

@@ -2,54 +2,88 @@ import "node:module";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
 import { X_RENDER_CACHE } from "../../constants.mjs";
 import { createTransformStream, getPathname } from "../../utils/index.mjs";
+const preventsSharedCaching = (headers)=>/(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:[=,]|$)/i.test(headers.get('cache-control') || '');
+const isCacheableResponse = (response)=>200 === response.status && !preventsSharedCaching(response.headers) && !response.headers.has('set-cookie') && !response.headers.get('vary');
 const removeTailSlash = (s)=>s.replace(/\/+$/, '');
 const ZERO_RENDER_LEVEL = /"renderLevel":0/;
 const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
 async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
     const response = await requestHandler(request, requestHandlerOptions);
     const { onError } = requestHandlerOptions;
-    const nonCacheableStatusCodes = [
-        204,
-        305,
-        404,
-        405,
-        500,
-        501,
-        502,
-        503,
-        504
-    ];
-    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const deleteCache = async ()=>{
+        try {
+            await container.delete(key);
+        } catch  {
+            (onError || console.error)('[render-cache] delete cache failed');
+        }
+    };
+    if (!isCacheableResponse(response) || !response.body) {
+        await deleteCache();
+        return response;
+    }
+    const headers = Object.fromEntries(response.headers);
     const decoder = new TextDecoder();
     if (response.body) {
         const stream = createTransformStream();
         const reader = response.body.getReader();
         const writer = stream.writable.getWriter();
         let html = '';
-        const push = ()=>reader.read().then(({ done, value })=>{
-                if (done) {
-                    const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
-                    if (match) return void writer.close();
-                    const current = Date.now();
-                    const cache = {
-                        val: html,
-                        cursor: current
-                    };
-                    container.set(key, JSON.stringify(cache), {
+        let cancelled = false;
+        const cancel = async (reason)=>{
+            cancelled = true;
+            await reader.cancel(reason);
+        };
+        writer.closed.catch(cancel).catch(()=>{});
+        const onAbort = ()=>{
+            Promise.allSettled([
+                cancel(request.signal.reason),
+                writer.abort(request.signal.reason)
+            ]);
+        };
+        request.signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (request.signal.aborted) onAbort();
+        const pumping = (async ()=>{
+            try {
+                for(;;){
+                    const { done, value } = await reader.read();
+                    if (cancelled) return;
+                    if (done) break;
+                    html += decoder.decode(value, {
+                        stream: true
+                    });
+                    await writer.write(value);
+                }
+                html += decoder.decode();
+                await writer.close();
+                if (cancelled) return;
+                if (ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html)) return void await deleteCache();
+                const cache = {
+                    val: html,
+                    cursor: Date.now(),
+                    headers
+                };
+                try {
+                    await container.set(key, JSON.stringify(cache), {
                         ttl
-                    }).catch(()=>{
-                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
                     });
-                    writer.close();
-                    return;
+                } catch (error) {
+                    (onError || console.error)('[render-cache] set cache failed');
                 }
-                const content = decoder.decode(value);
-                html += content;
-                writer.write(value);
-                push();
-            });
-        push();
+            } catch (error) {
+                await Promise.allSettled([
+                    cancel(error),
+                    writer.abort(error)
+                ]);
+                if (cacheStatus) try {
+                    (onError || console.error)('[render-cache] response stream failed');
+                } catch  {}
+            } finally{
+                request.signal.removeEventListener('abort', onAbort);
+            }
+        })();
+        pumping.catch(()=>{});
         cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
         return new Response(stream.readable, {
             status: response.status,
@@ -64,9 +98,12 @@ function computedKey(req, cacheControl) {
     const pathname = getPathname(req);
     const { customKey } = cacheControl;
     const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
-    if (!customKey) return defaultKey;
-    if ('string' == typeof customKey) return customKey;
-    return customKey(defaultKey);
+    if (customKey) if ('string' == typeof customKey) return customKey;
+    else return customKey(defaultKey);
+    else {
+        const url = new URL(req.url);
+        return `${url.origin}${defaultKey}${url.search}`;
+    }
 }
 function shouldUseCache(request) {
     const url = new URL(request.url);
@@ -77,7 +114,7 @@ function shouldUseCache(request) {
 }
 function matchCacheControl(cacheOption, req) {
     if (!cacheOption || !req) return;
-    {
+    else {
         if (isCacheControl(cacheOption)) return cacheOption;
         if (isCacheOptionProvider(cacheOption)) return cacheOption(req);
         const url = req.url;
@@ -96,13 +133,15 @@ function matchCacheControl(cacheOption, req) {
 async function getCacheResult(request, options) {
     const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
     const { onError } = requestHandlerOptions;
-    const key = computedKey(request, cacheControl);
+    const hasCredentials = request.headers.has('cookie') || request.headers.has('authorization');
+    if ('GET' !== request.method || !shouldUseCache(request) || preventsSharedCaching(request.headers) || hasCredentials && !cacheControl.customKey) return requestHandler(request, requestHandlerOptions);
+    const key = `${CACHE_NAMESPACE}:v2:${computedKey(request, cacheControl)}`;
     let value;
     try {
         value = await container.get(key);
     } catch (_) {
-        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
-        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        if (onError) onError('[render-cache] get cache failed');
+        else console.error('[render-cache] get cache failed');
         value = void 0;
     }
     const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -116,27 +155,27 @@ async function getCacheResult(request, options) {
         container,
         cacheStatus: 'miss'
     });
-    {
+    else {
         const cache = JSON.parse(value);
         const interval = Date.now() - cache.cursor;
         if (interval <= maxAge) {
             const cacheStatus = 'hit';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });
-        }
-        if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
-            key,
-            request,
-            requestHandler,
-            requestHandlerOptions,
-            ttl,
-            container,
-            cacheStatus: 'expired'
-        });
-        {
+        } else {
+            if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container,
+                cacheStatus: 'expired'
+            });
             processCache({
                 key,
                 request,
@@ -146,10 +185,15 @@ async function getCacheResult(request, options) {
                 container
             }).then(async (response)=>{
                 await response.text();
+            }).catch((error)=>{
+                try {
+                    (onError || console.error)('[render-cache] revalidation failed');
+                } catch  {}
             });
             const cacheStatus = 'stale';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });

package/dist/esm-node/serverBase.mjs

@@ -147,7 +147,7 @@ function applyMiddlewares() {
         if (middleware.before) {
             const targetIndex = finalMiddlewares.findIndex((item)=>{
                 if (middleware.before?.includes(item.name)) return true;
-                return false;
+                else return false;
             });
             if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
             else finalMiddlewares.push(middleware);
@@ -168,7 +168,7 @@ function applyMiddlewares() {
     }
     function handler2Handlers(handler) {
         if (Array.isArray(handler)) return handler;
-        return [
+        else return [
             handler
         ];
     }

package/dist/esm-node/utils/transformStream.mjs

@@ -15,7 +15,7 @@ function transformResponse(response, transformCb) {
     if (response.body) {
         const stream = createTransformStream(async (before)=>{
             if (Array.isArray(transformCb)) return transformCb.reduce(async (before, cb)=>cb(await before), Promise.resolve(before));
-            return transformCb(before);
+            else return transformCb(before);
         });
         response.body.pipeThrough(stream);
         readable = stream.readable;