@opennextjs/cloudflare 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -119,7 +119,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
     writeTags(tags: string[]): Promise<void>;
     performWriteTagsWithRetry(doId: DOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
     getCacheInstance(): Promise<Cache | undefined>;
-    getCacheKey(doId: DOId, tags: string[]): Promise<Request<unknown, CfProperties<unknown>>>;
+    getCacheUrlKey(doId: DOId, tags: string[]): string;
     getFromRegionalCache(doId: DOId, tags: string[]): Promise<Response | undefined>;
     putToRegionalCache(doId: DOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
     deleteRegionalCache(doId: DOId, tags: string[]): Promise<void>;

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -194,8 +194,8 @@ class ShardedDOTagCache {
         }
         return this.localCache;
     }
-    async getCacheKey(doId, tags) {
-        return new Request(new URL(`shard/${doId.shardId}?tags=${encodeURIComponent(tags.join(";"))}`, "http://local.cache"));
+    getCacheUrlKey(doId, tags) {
+        return `http://local.cache/shard/${doId.shardId}?tags=${encodeURIComponent(tags.join(";"))}`;
     }
     async getFromRegionalCache(doId, tags) {
         try {
@@ -204,12 +204,10 @@ class ShardedDOTagCache {
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            const key = await this.getCacheKey(doId, tags);
-            return cache.match(key);
+            return cache.match(this.getCacheUrlKey(doId, tags));
         }
         catch (e) {
             error("Error while fetching from regional cache", e);
-            return;
         }
     }
     async putToRegionalCache(doId, tags, hasBeenRevalidated) {
@@ -218,9 +216,15 @@ class ShardedDOTagCache {
         const cache = await this.getCacheInstance();
         if (!cache)
             return;
-        const key = await this.getCacheKey(doId, tags);
-        await cache.put(key, new Response(`${hasBeenRevalidated}`, {
-            headers: { "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}` },
+        await cache.put(this.getCacheUrlKey(doId, tags), new Response(`${hasBeenRevalidated}`, {
+            headers: {
+                "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}`,
+                ...(tags.length > 0
+                    ? {
+                        "cache-tag": tags.join(","),
+                    }
+                    : {}),
+            },
         }));
     }
     async deleteRegionalCache(doId, tags) {
@@ -231,8 +235,7 @@ class ShardedDOTagCache {
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            const key = await this.getCacheKey(doId, tags);
-            await cache.delete(key);
+            await cache.delete(this.getCacheUrlKey(doId, tags));
         }
         catch (e) {
             debugCache("Error while deleting from regional cache", e);

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.spec.js

@@ -277,15 +277,13 @@ describe("DOShardedTagCache", () => {
         it("should return the cache key without the random part", async () => {
             const cache = shardedDOTagCache();
             const doId1 = new DOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
-            const reqKey = await cache.getCacheKey(doId1, ["_N_T_/tag1"]);
-            expect(reqKey.url).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
+            expect(cache.getCacheUrlKey(doId1, ["_N_T_/tag1"])).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
             const doId2 = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            const reqKey2 = await cache.getCacheKey(doId2, ["tag1"]);
-            expect(reqKey2.url).toBe("http://local.cache/shard/tag-hard;shard-1?tags=tag1");
+            expect(cache.getCacheUrlKey(doId2, ["tag1"])).toBe("http://local.cache/shard/tag-hard;shard-1?tags=tag1");
         });
     });
     describe("performWriteTagsWithRetry", () => {

package/dist/api/overrides/tag-cache/tag-cache-filter.d.ts

@@ -0,0 +1,26 @@
+import { NextModeTagCache } from "@opennextjs/aws/types/overrides";
+interface WithFilterOptions {
+    /**
+     * The original tag cache.
+     * Call to this will receive only the filtered tags.
+     */
+    tagCache: NextModeTagCache;
+    /**
+     * The function to filter tags.
+     * @param tag The tag to filter.
+     * @returns true if the tag should be forwarded, false otherwise.
+     */
+    filterFn: (tag: string) => boolean;
+}
+/**
+ * Creates a new tag cache that filters tags based on the provided filter function.
+ * This is useful to remove tags that are not used by the app, this could reduce the number of requests to the underlying tag cache.
+ */
+export declare function withFilter({ tagCache, filterFn }: WithFilterOptions): NextModeTagCache;
+/**
+ * Filter function to exclude tags that start with "_N_T_".
+ * This is used to filter out internal soft tags.
+ * Can be used if `revalidatePath` is not used.
+ */
+export declare function softTagFilter(tag: string): boolean;
+export {};

package/dist/api/overrides/tag-cache/tag-cache-filter.js

@@ -0,0 +1,41 @@
+/**
+ * Creates a new tag cache that filters tags based on the provided filter function.
+ * This is useful to remove tags that are not used by the app, this could reduce the number of requests to the underlying tag cache.
+ */
+export function withFilter({ tagCache, filterFn }) {
+    return {
+        name: `filtered-${tagCache.name}`,
+        mode: "nextMode",
+        getPathsByTags: tagCache.getPathsByTags
+            ? async (tags) => {
+                const filteredTags = tags.filter(filterFn);
+                if (filteredTags.length === 0) {
+                    return [];
+                }
+                return tagCache.getPathsByTags(filteredTags);
+            }
+            : undefined,
+        hasBeenRevalidated: async (tags, lastModified) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return false;
+            }
+            return tagCache.hasBeenRevalidated(filteredTags, lastModified);
+        },
+        writeTags: async (tags) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return;
+            }
+            return tagCache.writeTags(filteredTags);
+        },
+    };
+}
+/**
+ * Filter function to exclude tags that start with "_N_T_".
+ * This is used to filter out internal soft tags.
+ * Can be used if `revalidatePath` is not used.
+ */
+export function softTagFilter(tag) {
+    return !tag.startsWith("_N_T_");
+}

package/dist/api/overrides/tag-cache/tag-cache-filter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/overrides/tag-cache/tag-cache-filter.spec.js

@@ -0,0 +1,96 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { softTagFilter, withFilter } from "./tag-cache-filter";
+const mockedTagCache = {
+    name: "mocked",
+    mode: "nextMode",
+    getPathsByTags: vi.fn(),
+    hasBeenRevalidated: vi.fn(),
+    writeTags: vi.fn(),
+};
+const filterFn = (tag) => tag.startsWith("valid_");
+describe("withFilter", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should filter out tags based on writeTags", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        await tagCache.writeTags(tags);
+        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+    it("should not call writeTags if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        await tagCache.writeTags(tags);
+        expect(mockedTagCache.writeTags).not.toHaveBeenCalled();
+    });
+    it("should filter out tags based on hasBeenRevalidated", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        const lastModified = Date.now();
+        await tagCache.hasBeenRevalidated(tags, lastModified);
+        expect(mockedTagCache.hasBeenRevalidated).toHaveBeenCalledWith(["valid_tag"], lastModified);
+    });
+    it("should not call hasBeenRevalidated if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        const lastModified = Date.now();
+        await tagCache.hasBeenRevalidated(tags, lastModified);
+        expect(mockedTagCache.hasBeenRevalidated).not.toHaveBeenCalled();
+    });
+    it("should filter out tags based on getPathsByTags", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        await tagCache.getPathsByTags?.(tags);
+        expect(mockedTagCache.getPathsByTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+    it("should not call getPathsByTags if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        await tagCache.getPathsByTags?.(tags);
+        expect(mockedTagCache.getPathsByTags).not.toHaveBeenCalled();
+    });
+    it("should return the correct name", () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        expect(tagCache.name).toBe("filtered-mocked");
+    });
+    it("should not create a function if getPathsByTags is not defined", async () => {
+        const tagCache = withFilter({
+            tagCache: {
+                ...mockedTagCache,
+                getPathsByTags: undefined,
+            },
+            filterFn,
+        });
+        expect(tagCache.getPathsByTags).toBeUndefined();
+    });
+    it("should filter soft tags", () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn: softTagFilter,
+        });
+        tagCache.writeTags(["valid_tag", "_N_T_/", "_N_T_/test", "_N_T_/layout"]);
+        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+});

package/dist/cli/build/bundle-server.js

@@ -15,6 +15,7 @@ import { inlineFindDir } from "./patches/plugins/find-dir.js";
 import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
+import { patchPagesRouterContext } from "./patches/plugins/pages-router-context.js";
 import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
 import { fixRequire } from "./patches/plugins/require.js";
 import { shimRequireHook } from "./patches/plugins/require-hook.js";
@@ -77,6 +78,7 @@ export async function bundleServer(buildOpts) {
             fixRequire(updater),
             handleOptionalDependencies(optionalDependencies),
             patchInstrumentation(updater, buildOpts),
+            patchPagesRouterContext(buildOpts),
             inlineEvalManifest(updater, buildOpts),
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),

package/dist/cli/build/patches/plugins/pages-router-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESBuild plugin to handle pages router context.
+ *
+ * We need to change the import path for the pages router context to use the one provided in `pages-runtime.prod.js`
+ */
+import { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { PluginBuild } from "esbuild";
+export declare function patchPagesRouterContext(buildOpts: BuildOptions): {
+    name: string;
+    setup: (build: PluginBuild) => void;
+};

package/dist/cli/build/patches/plugins/pages-router-context.js

@@ -0,0 +1,32 @@
+/**
+ * ESBuild plugin to handle pages router context.
+ *
+ * We need to change the import path for the pages router context to use the one provided in `pages-runtime.prod.js`
+ */
+import { compareSemver } from "@opennextjs/aws/build/helper.js";
+export function patchPagesRouterContext(buildOpts) {
+    const pathRegex = /^.*\/(?<CONTEXT>.*)\.shared-runtime$/;
+    const isAfter15 = compareSemver(buildOpts.nextVersion, ">=", "15.0.0");
+    const isAfter153 = compareSemver(buildOpts.nextVersion, ">=", "15.3.0");
+    const basePath = `next/dist/server/${isAfter15 ? "" : "future/"}route-modules/pages/vendored/contexts/`;
+    return {
+        name: "pages-router-context",
+        setup: (build) => {
+            // If we are after 15.3, we don't need to patch the context anymore
+            if (isAfter153) {
+                return;
+            }
+            // We need to modify some imports (i.e. https://github.com/vercel/next.js/blob/48540b836642525b38a2cba40a92b4532c553a52/packages/next/src/server/require-hook.ts#L59-L68)
+            build.onResolve({ filter: /.*shared-runtime/ }, async ({ path, resolveDir, ...options }) => {
+                const match = path.match(pathRegex);
+                if (match && match.groups?.CONTEXT) {
+                    const newPath = `${basePath}${match.groups.CONTEXT}.js`;
+                    return await build.resolve(newPath, {
+                        resolveDir,
+                        ...options,
+                    });
+                }
+            });
+        },
+    };
+}

package/dist/cli/templates/worker.d.ts

@@ -1,4 +1,6 @@
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
-declare const _default: ExportedHandler<CloudflareEnv>;
+declare const _default: {
+    fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: CloudflareEnv, ctx: ExecutionContext): Promise<any>;
+};
 export default _default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.4",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -68,7 +68,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^3.114.3 || ^4.7.0"
+    "wrangler": "^4.7.0"
   },
   "scripts": {
     "clean": "rimraf dist",