@opennextjs/aws 3.5.2 → 3.5.4

package/dist/build/patch/astCodePatcher.d.ts

@@ -0,0 +1,58 @@
+import { type Edit, Lang, type NapiConfig, type SgNode } from "@ast-grep/napi";
+import type { PatchCodeFn } from "./codePatcher";
+export type * from "@ast-grep/napi";
+/**
+ * fix has the same meaning as in yaml rules
+ * see https://ast-grep.github.io/guide/rewrite-code.html#using-fix-in-yaml-rule
+ */
+export type RuleConfig = NapiConfig & {
+    fix?: string;
+};
+/**
+ * Returns the `Edit`s and `Match`es for an ast-grep rule in yaml format
+ *
+ * The rule must have a `fix` to rewrite the matched node.
+ *
+ * Tip: use https://ast-grep.github.io/playground.html to create rules.
+ *
+ * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
+ * @param root The root node
+ * @param once only apply once
+ * @returns A list of edits and a list of matches.
+ */
+export declare function applyRule(rule: string | RuleConfig, root: SgNode, { once }?: {
+    once?: boolean | undefined;
+}): {
+    edits: Edit[];
+    matches: SgNode[];
+};
+/**
+ * Parse a file and obtain its root.
+ *
+ * @param path The file path
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root for the file.
+ */
+export declare function parseFile(path: string, lang?: Lang): SgNode;
+/**
+ * Patches the code from by applying the rule.
+ *
+ * This function is mainly for on off edits and tests,
+ * use `getRuleEdits` to apply multiple rules.
+ *
+ * @param code The source code
+ * @param rule The astgrep rule (yaml or NapiConfig)
+ * @param lang The language used by the source code
+ * @param lang Whether to apply the rule only once
+ * @returns The patched code
+ */
+export declare function patchCode(code: string, rule: string | RuleConfig, { lang, once }?: {
+    lang?: Lang | undefined;
+    once?: boolean | undefined;
+}): string;
+/**
+ * @param rule
+ * @param lang
+ * @returns a callback applying the the rule.
+ */
+export declare function createPatchCode(rule: string | RuleConfig, lang?: Lang): PatchCodeFn;

package/dist/build/patch/astCodePatcher.js

@@ -0,0 +1,76 @@
+// Mostly copied from the cloudflare adapter
+import { readFileSync } from "node:fs";
+import { Lang, parse, } from "@ast-grep/napi";
+import yaml from "yaml";
+/**
+ * Returns the `Edit`s and `Match`es for an ast-grep rule in yaml format
+ *
+ * The rule must have a `fix` to rewrite the matched node.
+ *
+ * Tip: use https://ast-grep.github.io/playground.html to create rules.
+ *
+ * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
+ * @param root The root node
+ * @param once only apply once
+ * @returns A list of edits and a list of matches.
+ */
+export function applyRule(rule, root, { once = false } = {}) {
+    const ruleConfig = typeof rule === "string" ? yaml.parse(rule) : rule;
+    if (ruleConfig.transform) {
+        throw new Error("transform is not supported");
+    }
+    if (!ruleConfig.fix) {
+        throw new Error("no fix to apply");
+    }
+    const fix = ruleConfig.fix;
+    const matches = once
+        ? [root.find(ruleConfig)].filter((m) => m !== null)
+        : root.findAll(ruleConfig);
+    const edits = [];
+    matches.forEach((match) => {
+        edits.push(match.replace(
+        // Replace known placeholders by their value
+        fix
+            .replace(/\$\$\$([A-Z0-9_]+)/g, (_m, name) => match
+            .getMultipleMatches(name)
+            .map((n) => n.text())
+            .join(""))
+            .replace(/\$([A-Z0-9_]+)/g, (m, name) => match.getMatch(name)?.text() ?? m)));
+    });
+    return { edits, matches };
+}
+/**
+ * Parse a file and obtain its root.
+ *
+ * @param path The file path
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root for the file.
+ */
+export function parseFile(path, lang = Lang.TypeScript) {
+    return parse(lang, readFileSync(path, { encoding: "utf-8" })).root();
+}
+/**
+ * Patches the code from by applying the rule.
+ *
+ * This function is mainly for on off edits and tests,
+ * use `getRuleEdits` to apply multiple rules.
+ *
+ * @param code The source code
+ * @param rule The astgrep rule (yaml or NapiConfig)
+ * @param lang The language used by the source code
+ * @param lang Whether to apply the rule only once
+ * @returns The patched code
+ */
+export function patchCode(code, rule, { lang = Lang.TypeScript, once = false } = {}) {
+    const node = parse(lang, code).root();
+    const { edits } = applyRule(rule, node, { once });
+    return node.commitEdits(edits);
+}
+/**
+ * @param rule
+ * @param lang
+ * @returns a callback applying the the rule.
+ */
+export function createPatchCode(rule, lang = Lang.TypeScript) {
+    return async ({ code }) => patchCode(code, rule, { lang });
+}

package/dist/build/patch/codePatcher.d.ts

@@ -0,0 +1,46 @@
+import type { getManifests } from "../copyTracedFiles.js";
+import * as buildHelper from "../helper.js";
+type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
+export interface VersionedField<T> {
+    /**
+     * The versions of Next.js that this field should be used for
+     * Should be in the format `">=16.0.0 <=17.0.0"` or `">=16.0.0"` or `"<=17.0.0"`
+     * **Be careful with spaces**
+     */
+    versions?: Versions;
+    field: T;
+}
+export type PatchCodeFn = (args: {
+    /**
+     * The code of the file that needs to be patched
+     */
+    code: string;
+    /**
+     * The final path of the file that needs to be patched
+     */
+    filePath: string;
+    /**
+     * All files that are traced and will be included in the bundle
+     */
+    tracedFiles: string[];
+    /**
+     * Next.js manifests that are used by Next at runtime
+     */
+    manifests: ReturnType<typeof getManifests>;
+}) => Promise<string>;
+interface IndividualPatch {
+    pathFilter: RegExp;
+    contentFilter?: RegExp;
+    patchCode: PatchCodeFn;
+}
+export interface CodePatcher {
+    name: string;
+    patches: IndividualPatch | VersionedField<IndividualPatch>[];
+}
+export declare function parseVersions(versions?: Versions): {
+    before?: string;
+    after?: string;
+};
+export declare function extractVersionedField<T>(fields: VersionedField<T>[], version: string): T[];
+export declare function applyCodePatches(buildOptions: buildHelper.BuildOptions, tracedFiles: string[], manifests: ReturnType<typeof getManifests>, codePatcher: CodePatcher[]): Promise<void>;
+export {};

package/dist/build/patch/codePatcher.js

@@ -0,0 +1,119 @@
+import * as fs from "node:fs/promises";
+import logger from "../../logger.js";
+import * as buildHelper from "../helper.js";
+export function parseVersions(versions) {
+    if (!versions) {
+        return {};
+    }
+    // We need to use regex to extract the versions
+    const versionRegex = /([<>]=)(\d+\.\d+\.\d+)/g;
+    const matches = Array.from(versions.matchAll(versionRegex));
+    if (matches.length === 0) {
+        throw new Error("Invalid version range, no matches found");
+    }
+    if (matches.length > 2) {
+        throw new Error("Invalid version range, too many matches found");
+    }
+    let after;
+    let before;
+    for (const match of matches) {
+        const [_, operator, version] = match;
+        if (operator === "<=") {
+            before = version;
+        }
+        else {
+            after = version;
+        }
+    }
+    // Before returning we reconstruct the version string and compare it to the original
+    // If they don't match we throw an error
+    // We have to do this because template literal types here seems to allow for extra spaces
+    // that could easily break the version comparison and allow some patch to be applied on incorrect versions
+    // This might even go unnoticed
+    const reconstructedVersion = `${after ? `>=${after}` : ""}${before ? `${after ? " " : ""}<=${before}` : ""}`;
+    if (reconstructedVersion !== versions) {
+        throw new Error("Invalid version range, the reconstructed version does not match the original");
+    }
+    return {
+        before,
+        after,
+    };
+}
+export function extractVersionedField(fields, version) {
+    const result = [];
+    for (const field of fields) {
+        // No versions specified, the patch always apply
+        if (!field.versions) {
+            result.push(field.field);
+            continue;
+        }
+        const { before, after } = parseVersions(field.versions);
+        // range
+        if (before && after) {
+            if (buildHelper.compareSemver(version, "<=", before) &&
+                buildHelper.compareSemver(version, ">=", after)) {
+                result.push(field.field);
+            }
+            continue;
+        }
+        // before only
+        if (before) {
+            if (buildHelper.compareSemver(version, "<=", before)) {
+                result.push(field.field);
+            }
+            continue;
+        }
+        // after only
+        if (after) {
+            if (buildHelper.compareSemver(version, ">=", after)) {
+                result.push(field.field);
+            }
+        }
+    }
+    return result;
+}
+export async function applyCodePatches(buildOptions, tracedFiles, manifests, codePatcher) {
+    const nextVersion = buildOptions.nextVersion;
+    logger.time("Applying code patches");
+    // We first filter against the version
+    // We also flatten the array of patches so that we get both the name and all the necessary patches
+    const patchesToApply = codePatcher.flatMap(({ name, patches }) => Array.isArray(patches)
+        ? extractVersionedField(patches, nextVersion).map((patch) => ({
+            name,
+            patch,
+        }))
+        : [{ name, patch: patches }]);
+    await Promise.all(tracedFiles.map(async (filePath) => {
+        // We check the filename against the filter to see if we should apply the patch
+        const patchMatchingPath = patchesToApply.filter(({ patch }) => {
+            return filePath.match(patch.pathFilter);
+        });
+        if (patchMatchingPath.length === 0) {
+            return;
+        }
+        const content = await fs.readFile(filePath, "utf-8");
+        // We filter a last time against the content this time
+        const patchToApply = patchMatchingPath.filter(({ patch }) => {
+            if (!patch.contentFilter) {
+                return true;
+            }
+            return content.match(patch.contentFilter);
+        });
+        if (patchToApply.length === 0) {
+            return;
+        }
+        // We apply the patches
+        let patchedContent = content;
+        for (const { patch, name } of patchToApply) {
+            logger.debug(`Applying code patch: ${name} to ${filePath}`);
+            patchedContent = await patch.patchCode({
+                code: patchedContent,
+                filePath,
+                tracedFiles,
+                manifests,
+            });
+        }
+        await fs.writeFile(filePath, patchedContent);
+    }));
+    logger.timeEnd("Applying code patches");
+}

package/dist/build/patch/patchFetchCacheISR.d.ts

@@ -0,0 +1,5 @@
+import type { CodePatcher } from "./codePatcher";
+export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const patchFetchCacheForISR: CodePatcher;
+export declare const patchUnstableCacheForISR: CodePatcher;

package/dist/build/patch/patchFetchCacheISR.js

@@ -0,0 +1,102 @@
+import { Lang } from "@ast-grep/napi";
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
+import { createPatchCode } from "./astCodePatcher.js";
+export const fetchRule = `
+rule:
+  kind: member_expression
+  pattern: $WORK_STORE.isOnDemandRevalidate
+  inside:
+    kind: ternary_expression
+    all:
+      - has: {kind: 'null'}
+      - has: 
+          kind: await_expression
+          has:
+            kind: call_expression
+            all:
+              - has:
+                  kind: member_expression
+                  has:
+                    kind: property_identifier
+                    field: property
+                    regex: get
+              - has:
+                  kind: arguments
+                  has:
+                    kind: object
+                    has:
+                      kind: pair
+                      all:
+                        - has:
+                            kind: property_identifier
+                            field: key
+                            regex: softTags
+    inside:
+        kind: variable_declarator
+
+fix:
+  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)
+`;
+export const unstable_cacheRule = `
+rule:
+  kind: member_expression
+  pattern: $STORE_OR_CACHE.isOnDemandRevalidate
+  inside:
+    kind: if_statement
+    stopBy: end
+    has:
+      kind: statement_block
+      has:
+        kind: variable_declarator
+        has: 
+          kind: await_expression
+          has:
+            kind: call_expression
+            all:
+              - has:
+                  kind: member_expression
+                  has:
+                    kind: property_identifier
+                    field: property
+                    regex: get
+              - has:
+                  kind: arguments
+                  has:
+                    kind: object
+                    has:
+                      kind: pair
+                      all:
+                        - has:
+                            kind: property_identifier
+                            field: key
+                            regex: softTags
+        stopBy: end
+fix:
+  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)
+`;
+export const patchFetchCacheForISR = {
+    name: "patch-fetch-cache-for-isr",
+    patches: [
+        {
+            versions: ">=14.0.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+                contentFilter: /\.isOnDemandRevalidate/,
+                patchCode: createPatchCode(fetchRule, Lang.JavaScript),
+            },
+        },
+    ],
+};
+export const patchUnstableCacheForISR = {
+    name: "patch-unstable-cache-for-isr",
+    patches: [
+        {
+            versions: ">=14.2.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
+                contentFilter: /\.isOnDemandRevalidate/,
+                patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
+            },
+        },
+    ],
+};

package/dist/build/patch/patchFetchCacheWaitUntil.d.ts

@@ -0,0 +1,3 @@
+import type { CodePatcher } from "./codePatcher";
+export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    - has: { pattern: $_.arrayBuffer().then, stopBy: end }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - any:\n        - inside:\n            kind: sequence_expression\n            inside:\n                kind: return_statement\n        - inside:\n            kind: expression_statement\n            precedes:\n                kind: return_statement\n    - has: { pattern: $_.FETCH, stopBy: end }\n\nfix: |\n  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)\n";
+export declare const patchFetchCacheSetMissingWaitUntil: CodePatcher;

package/dist/build/patch/patchFetchCacheWaitUntil.js

@@ -0,0 +1,36 @@
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
+import { createPatchCode } from "./astCodePatcher.js";
+export const rule = `
+rule:
+  kind: call_expression
+  pattern: $PROMISE
+  all:
+    - has: { pattern: $_.arrayBuffer().then, stopBy: end }
+    - has: { pattern: "Buffer.from", stopBy: end }
+    - any:
+        - inside:
+            kind: sequence_expression
+            inside:
+                kind: return_statement
+        - inside:
+            kind: expression_statement
+            precedes:
+                kind: return_statement
+    - has: { pattern: $_.FETCH, stopBy: end }
+
+fix: |
+  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)
+`;
+export const patchFetchCacheSetMissingWaitUntil = {
+    name: "patch-fetch-cache-set-missing-wait-until",
+    patches: [
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+                contentFilter: /arrayBuffer\(\)\s*\.then/,
+                patchCode: createPatchCode(rule),
+            },
+        },
+    ],
+};

package/dist/build.js

@@ -17,7 +17,7 @@ export async function build(openNextConfigPath, nodeExternals) {
     showWarningOnWindows();
     const baseDir = process.cwd();
     const openNextDistDir = url.fileURLToPath(new URL(".", import.meta.url));
-    const { config, buildDir } = await compileOpenNextConfig(baseDir, openNextConfigPath, nodeExternals);
+    const { config, buildDir } = await compileOpenNextConfig(baseDir, openNextConfigPath, { nodeExternals });
     // Initialize options
     const options = buildHelper.normalizeOptions(config, openNextDistDir, buildDir);
     logger.setLevel(options.debug ? "debug" : "info");

package/dist/core/requestHandler.js

@@ -9,7 +9,9 @@ import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_R
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
+//#override patchAsyncStorage
 patchAsyncStorage();
+//#endOverride
 export async function openNextHandler(internalEvent, options) {
     const initialHeaders = internalEvent.headers;
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
@@ -94,7 +96,7 @@ export async function openNextHandler(internalEvent, options) {
                     resolvedRoutes: [],
                     origin: false,
                     initialURL: internalEvent.url,
-                }, headers, options.streamCreator);
+                }, routingResult.headers, options.streamCreator);
                 response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
                 const [bodyToConsume, bodyToReturn] = routingResult.body.tee();

package/dist/core/routing/cacheInterceptor.js

@@ -48,7 +48,12 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
                 url = `${NextConfig.basePath}${url}`;
             }
             await globalThis.queue.send({
-                MessageBody: { host, url },
+                MessageBody: {
+                    host,
+                    url,
+                    eTag: etag,
+                    lastModified: lastModified ?? Date.now(),
+                },
                 MessageDeduplicationId: hash(`${path}-${lastModified}-${etag}`),
                 MessageGroupId: generateMessageGroupId(path),
             });

package/dist/core/routing/middleware.js

@@ -1,4 +1,4 @@
-import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, } from "../../adapters/config/index.js";
+import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { localizePath } from "./i18n/index.js";
 //NOTE: we should try to avoid importing stuff from next as much as possible
@@ -24,7 +24,11 @@ function defaultMiddlewareLoader() {
 export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
     const headers = internalEvent.headers;
     // We bypass the middleware if the request is internal
-    if (headers["x-isr"])
+    // We should only do that if the request has the correct `x-prerender-revalidate` header
+    // The `x-prerender-revalidate` header is set at build time and should be safe to trust
+    if (headers["x-isr"] &&
+        headers["x-prerender-revalidate"] ===
+            PrerenderManifest.preview.previewModeId)
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
     const normalizedPath = localizePath(internalEvent);
@@ -73,6 +77,12 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const reqHeaders = {};
     const resHeaders = {};
     responseHeaders.delete("x-middleware-override-headers");
+    /*  Next will set the header `x-middleware-set-cookie` when you `set-cookie` in the middleware.
+     *  We can delete it here since it will be set in `set-cookie` aswell. Next removes this header in the response themselves.
+     * `x-middleware-next` is set when you invoke `NextResponse.next()`. We can delete it here aswell.
+     */
+    responseHeaders.delete("x-middleware-set-cookie");
+    responseHeaders.delete("x-middleware-next");
     const xMiddlewareKey = "x-middleware-request-";
     responseHeaders.forEach((value, key) => {
         if (key.startsWith(xMiddlewareKey)) {

package/dist/core/routing/queue.d.ts

@@ -1 +1,2 @@
+export declare function generateShardId(rawPath: string, maxConcurrency: number, prefix: string): string;
 export declare function generateMessageGroupId(rawPath: string): string;

package/dist/core/routing/queue.js

@@ -1,3 +1,14 @@
+export function generateShardId(rawPath, maxConcurrency, prefix) {
+    let a = cyrb128(rawPath);
+    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    let t = (a += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    // This will generate a random int between 0 and maxConcurrency
+    const randomInt = Math.floor(randomFloat * maxConcurrency);
+    return `${prefix}-${randomInt}`;
+}
 // Since we're using a FIFO queue, every messageGroupId is treated sequentially
 // This could cause a backlog of messages in the queue if there is too much page to
 // revalidate at once. To avoid this, we generate a random messageGroupId for each
@@ -6,17 +17,10 @@
 // will always have the same messageGroupId.
 // https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript#answer-47593316
 export function generateMessageGroupId(rawPath) {
-    let a = cyrb128(rawPath);
-    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
-    let t = (a += 0x6d2b79f5);
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     // This will generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
     // This means that we could have 1000 revalidate request at the same time
     const maxConcurrency = Number.parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
-    const randomInt = Math.floor(randomFloat * maxConcurrency);
-    return `revalidate-${randomInt}`;
+    return generateShardId(rawPath, maxConcurrency, "revalidate");
 }
 // Used to generate a hash int from a string
 function cyrb128(str) {

package/dist/core/routing/util.js

@@ -268,10 +268,10 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
             const lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
             // For some weird cases, lastModified is not set, haven't been able to figure out yet why
             // For those cases we add the etag to the deduplication id, it might help
-            const etag = headers.etag ?? headers.ETag ?? "";
+            const eTag = `${headers.etag ?? headers.ETag ?? ""}`;
             await globalThis.queue.send({
-                MessageBody: { host, url: revalidateUrl },
-                MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${etag}`),
+                MessageBody: { host, url: revalidateUrl, eTag, lastModified },
+                MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${eTag}`),
                 MessageGroupId: generateMessageGroupId(rawPath),
             });
         }

package/dist/logger.d.ts

@@ -8,5 +8,13 @@ declare const _default: {
     };
     warn: (...args: any[]) => void;
     error: (...args: any[]) => void;
+    time: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    timeEnd: {
+        (label?: string): void;
+        (label?: string): void;
+    };
 };
 export default _default;

package/dist/logger.js

@@ -10,4 +10,6 @@ export default {
     info: console.log,
     warn: (...args) => console.warn(chalk.yellow("WARN"), ...args),
     error: (...args) => console.error(chalk.red("ERROR"), ...args),
+    time: console.time,
+    timeEnd: console.timeEnd,
 };

package/dist/overrides/wrappers/express-dev.js

@@ -19,7 +19,9 @@ const wrapper = async (handler, converter) => {
         const internalEvent = await converter.convertFrom(req);
         const streamCreator = {
             writeHeaders: (prelude) => {
+                res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
+                res.flushHeaders();
                 return res;
             },
             onFinish: () => { },

package/dist/overrides/wrappers/node.js

@@ -8,7 +8,6 @@ const wrapper = async (handler, converter) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
                 res.flushHeaders();
-                res.uncork();
                 return res;
             },
         };