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

package/dist/api/config.js

@@ -17,6 +17,8 @@ export function defineCloudflareConfig(config = {}) {
                 queue: resolveQueue(queue),
             },
         },
+        // node:crypto is used to compute cache keys
+        edgeExternals: ["node:crypto"],
     };
 }
 function resolveIncrementalCache(value = "dummy") {

package/dist/api/overrides/incremental-cache/kv-incremental-cache.d.ts

@@ -1,6 +1,11 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "cf-kv-incremental-cache";
 export declare const BINDING_NAME = "NEXT_INC_CACHE_KV";
+export type KeyOptions = {
+    isFetch?: boolean;
+    buildId?: string;
+};
+export declare function computeCacheKey(key: string, options: KeyOptions): string;
 /**
  * Open Next cache based on Cloudflare KV.
  *

package/dist/api/overrides/incremental-cache/kv-incremental-cache.js

@@ -1,9 +1,15 @@
+import { createHash } from "node:crypto";
 import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
 import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "cf-kv-incremental-cache";
 export const BINDING_NAME = "NEXT_INC_CACHE_KV";
+export function computeCacheKey(key, options) {
+    const { isFetch = false, buildId = FALLBACK_BUILD_ID } = options;
+    const hash = createHash("sha256").update(key).digest("hex");
+    return `${buildId}/${hash}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+}
 /**
  * Open Next cache based on Cloudflare KV.
  *
@@ -28,7 +34,6 @@ class KVIncrementalCache {
             // if there is no lastModified property, the file was stored during build-time cache population.
             return {
                 value: entry,
-                // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
                 lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
             };
         }
@@ -70,8 +75,10 @@ class KVIncrementalCache {
         }
     }
     getKVKey(key, isFetch) {
-        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
-        return `${buildId}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+        return computeCacheKey(key, {
+            buildId: process.env.NEXT_BUILD_ID,
+            isFetch,
+        });
     }
 }
 export default new KVIncrementalCache();

package/dist/api/overrides/incremental-cache/r2-incremental-cache.d.ts

@@ -3,6 +3,12 @@ export declare const NAME = "cf-r2-incremental-cache";
 export declare const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
 export declare const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
 export declare const DEFAULT_PREFIX = "incremental-cache";
+export type KeyOptions = {
+    isFetch?: boolean;
+    directory?: string;
+    buildId?: string;
+};
+export declare function computeCacheKey(key: string, options: KeyOptions): string;
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.

package/dist/api/overrides/incremental-cache/r2-incremental-cache.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
@@ -6,6 +7,11 @@ export const NAME = "cf-r2-incremental-cache";
 export const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
 export const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
 export const DEFAULT_PREFIX = "incremental-cache";
+export function computeCacheKey(key, options) {
+    const { isFetch = false, directory = DEFAULT_PREFIX, buildId = FALLBACK_BUILD_ID } = options;
+    const hash = createHash("sha256").update(key).digest("hex");
+    return `${directory}/${buildId}/${hash}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+}
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -59,8 +65,11 @@ class R2IncrementalCache {
         }
     }
     getR2Key(key, isFetch) {
-        const directory = getCloudflareContext().env[PREFIX_ENV_NAME] ?? DEFAULT_PREFIX;
-        return `${directory}/${process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+        return computeCacheKey(key, {
+            directory: getCloudflareContext().env[PREFIX_ENV_NAME],
+            buildId: process.env.NEXT_BUILD_ID,
+            isFetch,
+        });
     }
 }
 export default new R2IncrementalCache();

package/dist/api/overrides/incremental-cache/regional-cache.d.ts

@@ -9,6 +9,13 @@ type Options = {
      *                 or an ISR/SSG entry for up to 30 minutes.
      */
     mode: "short-lived" | "long-lived";
+    /**
+     * The default TTL of long-lived cache entries.
+     * When no revalidate is provided, the default age will be used.
+     *
+     * @default `THIRTY_MINUTES_IN_SECONDS`
+     */
+    defaultLongLivedTtlSec?: number;
     /**
      * Whether the regional cache entry should be updated in the background or not when it experiences
      * a cache hit.
@@ -17,6 +24,11 @@ type Options = {
      */
     shouldLazilyUpdateOnCacheHit?: boolean;
 };
+interface PutToCacheInput {
+    key: string;
+    isFetch: boolean | undefined;
+    entry: IncrementalCacheEntry<boolean>;
+}
 /**
  * Wrapper adding a regional cache on an `IncrementalCache` implementation
  */
@@ -30,8 +42,8 @@ declare class RegionalCache implements IncrementalCache {
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
     protected getCacheInstance(): Promise<Cache>;
-    protected getCacheKey(key: string, isFetch?: boolean): Request<unknown, CfProperties<unknown>>;
-    protected putToCache(key: Request, entry: IncrementalCacheEntry<boolean>): Promise<void>;
+    protected getCacheUrlKey(key: string, isFetch?: boolean): string;
+    protected putToCache({ key, isFetch, entry }: PutToCacheInput): Promise<void>;
 }
 /**
  * A regional cache will wrap an incremental cache and provide faster cache lookups for an entry
@@ -50,6 +62,9 @@ declare class RegionalCache implements IncrementalCache {
  *                                  or an ISR/SSG entry for up to 30 minutes.
  * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
  *                                          the background or not when it experiences a cache hit.
+ * @param opts.defaultLongLivedTtlSec The default age to use for long-lived cache entries.
+ *                                  When no revalidate is provided, the default age will be used.
+ *                                  @default `THIRTY_MINUTES_IN_SECONDS`
  *
  * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */

package/dist/api/overrides/incremental-cache/regional-cache.js

@@ -24,9 +24,9 @@ class RegionalCache {
     async get(key, isFetch) {
         try {
             const cache = await this.getCacheInstance();
-            const localCacheKey = this.getCacheKey(key, isFetch);
+            const urlKey = this.getCacheUrlKey(key, isFetch);
             // Check for a cached entry as this will be faster than the store response.
-            const cachedResponse = await cache.match(localCacheKey);
+            const cachedResponse = await cache.match(urlKey);
             if (cachedResponse) {
                 debugCache("Get - cached response");
                 // Re-fetch from the store and update the regional cache in the background
@@ -34,7 +34,7 @@ class RegionalCache {
                     getCloudflareContext().ctx.waitUntil(this.store.get(key, isFetch).then(async (rawEntry) => {
                         const { value, lastModified } = rawEntry ?? {};
                         if (value && typeof lastModified === "number") {
-                            await this.putToCache(localCacheKey, { value, lastModified });
+                            await this.putToCache({ key, isFetch, entry: { value, lastModified } });
                         }
                     }));
                 }
@@ -45,7 +45,7 @@ class RegionalCache {
             if (!value || typeof lastModified !== "number")
                 return null;
             // Update the locale cache after retrieving from the store.
-            getCloudflareContext().ctx.waitUntil(this.putToCache(localCacheKey, { value, lastModified }));
+            getCloudflareContext().ctx.waitUntil(this.putToCache({ key, isFetch, entry: { value, lastModified } }));
             return { value, lastModified };
         }
         catch (e) {
@@ -56,11 +56,15 @@ class RegionalCache {
     async set(key, value, isFetch) {
         try {
             await this.store.set(key, value, isFetch);
-            await this.putToCache(this.getCacheKey(key, isFetch), {
-                value,
-                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
-                //       See https://developers.cloudflare.com/workers/reference/security-model/
-                lastModified: Date.now(),
+            await this.putToCache({
+                key,
+                isFetch,
+                entry: {
+                    value,
+                    // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                    //       See https://developers.cloudflare.com/workers/reference/security-model/
+                    lastModified: Date.now(),
+                },
             });
         }
         catch (e) {
@@ -71,7 +75,7 @@ class RegionalCache {
         try {
             await this.store.delete(key);
             const cache = await this.getCacheInstance();
-            await cache.delete(this.getCacheKey(key));
+            await cache.delete(this.getCacheUrlKey(key));
         }
         catch (e) {
             error("Failed to delete from regional cache", e);
@@ -83,16 +87,28 @@ class RegionalCache {
         this.localCache = await caches.open("incremental-cache");
         return this.localCache;
     }
-    getCacheKey(key, isFetch) {
-        return new Request(new URL(`${process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID}/${key}.${isFetch ? "fetch" : "cache"}`, "http://cache.local"));
+    getCacheUrlKey(key, isFetch) {
+        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+        return ("http://cache.local" + `/${buildId}/${key}`.replace(/\/+/g, "/") + `.${isFetch ? "fetch" : "cache"}`);
     }
-    async putToCache(key, entry) {
+    async putToCache({ key, isFetch, entry }) {
+        const urlKey = this.getCacheUrlKey(key, isFetch);
         const cache = await this.getCacheInstance();
         const age = this.opts.mode === "short-lived"
             ? ONE_MINUTE_IN_SECONDS
-            : entry.value.revalidate || THIRTY_MINUTES_IN_SECONDS;
-        await cache.put(key, new Response(JSON.stringify(entry), {
-            headers: new Headers({ "cache-control": `max-age=${age}` }),
+            : entry.value.revalidate || this.opts.defaultLongLivedTtlSec || THIRTY_MINUTES_IN_SECONDS;
+        // We default to the entry key if no tags are found.
+        // so that we can also revalidate page router based entry this way.
+        const tags = getTagsFromCacheEntry(entry) ?? [key];
+        await cache.put(urlKey, new Response(JSON.stringify(entry), {
+            headers: new Headers({
+                "cache-control": `max-age=${age}`,
+                ...(tags.length > 0
+                    ? {
+                        "cache-tag": tags.join(","),
+                    }
+                    : {}),
+            }),
         }));
     }
 }
@@ -113,9 +129,29 @@ class RegionalCache {
  *                                  or an ISR/SSG entry for up to 30 minutes.
  * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
  *                                          the background or not when it experiences a cache hit.
+ * @param opts.defaultLongLivedTtlSec The default age to use for long-lived cache entries.
+ *                                  When no revalidate is provided, the default age will be used.
+ *                                  @default `THIRTY_MINUTES_IN_SECONDS`
  *
  * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export function withRegionalCache(cache, opts) {
     return new RegionalCache(cache, opts);
 }
+/**
+ * Extract the list of tags from a cache entry.
+ */
+function getTagsFromCacheEntry(entry) {
+    if ("tags" in entry.value && entry.value.tags) {
+        return entry.value.tags;
+    }
+    if ("meta" in entry.value &&
+        entry.value.meta &&
+        "headers" in entry.value.meta &&
+        entry.value.meta.headers) {
+        const rawTags = entry.value.meta.headers["x-next-cache-tags"];
+        if (typeof rawTags === "string") {
+            return rawTags.split(",");
+        }
+    }
+}

package/dist/api/overrides/incremental-cache/static-assets-incremental-cache.js

@@ -23,7 +23,6 @@ class StaticAssetsIncrementalCache {
                 return null;
             return {
                 value: await response.json(),
-                // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
                 lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
             };
         }

package/dist/api/overrides/tag-cache/d1-next-tag-cache.d.ts

@@ -7,7 +7,6 @@ export declare class D1NextModeTagCache implements NextModeTagCache {
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
     writeTags(tags: string[]): Promise<void>;
     private getConfig;
-    protected removeBuildId(key: string): string;
     protected getCacheKey(key: string): string;
     protected getBuildId(): string;
 }

package/dist/api/overrides/tag-cache/d1-next-tag-cache.js

@@ -1,5 +1,4 @@
 import { error } from "@opennextjs/aws/adapters/logger.js";
-import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
 import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "d1-next-mode-tag-cache";
@@ -27,13 +26,12 @@ export class D1NextModeTagCache {
     }
     async writeTags(tags) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        // TODO: Remove `tags.length === 0` when https://github.com/opennextjs/opennextjs-aws/pull/828 is used
+        if (isDisabled || tags.length === 0)
             return Promise.resolve();
-        const result = await db.batch(tags.map((tag) => db
+        await db.batch(tags.map((tag) => db
             .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
             .bind(this.getCacheKey(tag), Date.now())));
-        if (!result)
-            throw new RecoverableError(`D1 insert failed for ${tags}`);
     }
     getConfig() {
         const db = getCloudflareContext().env[BINDING_NAME];
@@ -48,9 +46,6 @@ export class D1NextModeTagCache {
                 db,
             };
     }
-    removeBuildId(key) {
-        return key.replace(`${this.getBuildId()}/`, "");
-    }
     getCacheKey(key) {
         return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
     }

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.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/args.d.ts

@@ -5,7 +5,7 @@ export type Arguments = ({
     skipWranglerConfigCheck: boolean;
     minify: boolean;
 } | {
-    command: "preview" | "deploy";
+    command: "preview" | "deploy" | "upload";
     passthroughArgs: string[];
 } | {
     command: "populateCache";

package/dist/cli/args.js

@@ -28,6 +28,7 @@ export function getArgs() {
             };
         case "preview":
         case "deploy":
+        case "upload":
             return {
                 command: positionals[0],
                 outputDir,
@@ -44,7 +45,7 @@ export function getArgs() {
                 environment: getWranglerEnvironmentFlag(passthroughArgs),
             };
         default:
-            throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'populateCache'");
+            throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'upload' | 'populateCache'");
     }
 }
 function getPassthroughArgs() {

package/dist/cli/build/build.js

@@ -8,6 +8,7 @@ import logger from "@opennextjs/aws/logger.js";
 import { bundleServer } from "./bundle-server.js";
 import { compileCacheAssetsManifestSqlFile } from "./open-next/compile-cache-assets-manifest.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
+import { compileInit } from "./open-next/compile-init.js";
 import { compileDurableObjects } from "./open-next/compileDurableObjects.js";
 import { createServerBundle } from "./open-next/createServerBundle.js";
 import { createWranglerConfigIfNotExistent } from "./utils/index.js";
@@ -49,9 +50,11 @@ export async function build(options, config, projectOpts) {
     compileCache(options);
     // Compile .env files
     compileEnvFiles(options);
+    // Compile workerd init
+    compileInit(options);
     // Compile middleware
     await createMiddleware(options, { forceOnlyBuildOnce: true });
-    createStaticAssets(options);
+    createStaticAssets(options, { useBasePath: true });
     if (config.dangerous?.disableIncrementalCache !== true) {
         const { useTagCache, metaFiles } = createCacheAssets(options);
         if (useTagCache) {