@opennextjs/cloudflare 1.0.0-beta.4 → 1.0.1

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

@@ -1,4 +1,4 @@
-import { error } from "@opennextjs/aws/adapters/logger.js";
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
@@ -113,6 +113,38 @@ class ShardedDOTagCache {
                 db,
             };
     }
+    async getLastRevalidated(tags) {
+        const { isDisabled } = await this.getConfig();
+        if (isDisabled)
+            return 0;
+        try {
+            const shardedTagGroups = this.groupTagsByDO({ tags });
+            const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
+                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "number" });
+                if (cachedValue) {
+                    const cached = await cachedValue.text();
+                    try {
+                        return parseInt(cached, 10);
+                    }
+                    catch (e) {
+                        debug("Error while parsing cached value", e);
+                        // If we can't parse the cached value, we should just ignore it and go to the durable object
+                    }
+                }
+                const stub = this.getDurableObjectStub(doId);
+                const _lastRevalidated = await stub.getLastRevalidated(tags);
+                if (!_lastRevalidated) {
+                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "number" }, _lastRevalidated));
+                }
+                return _lastRevalidated;
+            }));
+            return Math.max(...shardedTagRevalidationOutcomes);
+        }
+        catch (e) {
+            error("Error while checking revalidation", e);
+            return 0;
+        }
+    }
     /**
      * This function checks if the tags have been revalidated
      * It is never supposed to throw and in case of error, it will return false
@@ -127,7 +159,7 @@ class ShardedDOTagCache {
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-                const cachedValue = await this.getFromRegionalCache(doId, tags);
+                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "boolean" });
                 if (cachedValue) {
                     return (await cachedValue.text()) === "true";
                 }
@@ -137,7 +169,7 @@ class ShardedDOTagCache {
                 // If we do so, we risk causing cache MISS even though it has been revalidated elsewhere
                 // On the other hand revalidating a tag that is used in a lot of places will cause a lot of requests
                 if (!_hasBeenRevalidated) {
-                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache(doId, tags, _hasBeenRevalidated));
+                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "boolean" }, _hasBeenRevalidated));
                 }
                 return _hasBeenRevalidated;
             }));
@@ -170,7 +202,11 @@ class ShardedDOTagCache {
             const stub = this.getDurableObjectStub(doId);
             await stub.writeTags(tags, lastModified);
             // Depending on the shards and the tags, deleting from the regional cache will not work for every tag
-            await this.deleteRegionalCache(doId, tags);
+            // We also need to delete both cache
+            await Promise.all([
+                this.deleteRegionalCache({ doId, tags, type: "boolean" }),
+                this.deleteRegionalCache({ doId, tags, type: "number" }),
+            ]);
         }
         catch (e) {
             error("Error while writing tags", e);
@@ -194,29 +230,31 @@ class ShardedDOTagCache {
         }
         return this.localCache;
     }
-    getCacheUrlKey(doId, tags) {
-        return `http://local.cache/shard/${doId.shardId}?tags=${encodeURIComponent(tags.join(";"))}`;
+    getCacheUrlKey(opts) {
+        const { doId, tags, type } = opts;
+        return `http://local.cache/shard/${doId.shardId}?type=${type}&tags=${encodeURIComponent(tags.join(";"))}`;
     }
-    async getFromRegionalCache(doId, tags) {
+    async getFromRegionalCache(opts) {
         try {
             if (!this.opts.regionalCache)
                 return;
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            return cache.match(this.getCacheUrlKey(doId, tags));
+            return cache.match(this.getCacheUrlKey(opts));
         }
         catch (e) {
             error("Error while fetching from regional cache", e);
         }
     }
-    async putToRegionalCache(doId, tags, hasBeenRevalidated) {
+    async putToRegionalCache(optsKey, value) {
         if (!this.opts.regionalCache)
             return;
         const cache = await this.getCacheInstance();
         if (!cache)
             return;
-        await cache.put(this.getCacheUrlKey(doId, tags), new Response(`${hasBeenRevalidated}`, {
+        const tags = optsKey.tags;
+        await cache.put(this.getCacheUrlKey(optsKey), new Response(`${value}`, {
             headers: {
                 "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}`,
                 ...(tags.length > 0
@@ -227,7 +265,7 @@ class ShardedDOTagCache {
             },
         }));
     }
-    async deleteRegionalCache(doId, tags) {
+    async deleteRegionalCache(optsKey) {
         // We never want to crash because of the cache
         try {
             if (!this.opts.regionalCache)
@@ -235,7 +273,7 @@ class ShardedDOTagCache {
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            await cache.delete(this.getCacheUrlKey(doId, tags));
+            await cache.delete(this.getCacheUrlKey(optsKey));
         }
         catch (e) {
             debugCache("Error while deleting from regional cache", e);

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

@@ -223,7 +223,11 @@ describe("DOShardedTagCache", () => {
             cache.deleteRegionalCache = vi.fn();
             await cache.writeTags(["tag1"]);
             expect(cache.deleteRegionalCache).toHaveBeenCalled();
-            expect(cache.deleteRegionalCache).toHaveBeenCalledWith(expect.objectContaining({ key: "tag-hard;shard-1;replica-1" }), ["tag1"]);
+            expect(cache.deleteRegionalCache).toHaveBeenCalledWith({
+                doId: expect.objectContaining({ key: "tag-hard;shard-1;replica-1" }),
+                tags: ["tag1"],
+                type: "boolean",
+            });
             // expect(cache.deleteRegionalCache).toHaveBeenCalledWith("tag-hard;shard-1;replica-1", ["tag1"]);
         });
     });
@@ -253,7 +257,7 @@ describe("DOShardedTagCache", () => {
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            expect(await cache.getFromRegionalCache(doId, ["tag1"])).toBeUndefined();
+            expect(await cache.getFromRegionalCache({ doId, tags: ["tag1"], type: "boolean" })).toBeUndefined();
         });
         it("should call .match on the cache", async () => {
             // @ts-expect-error - Defined on cloudfare context
@@ -268,7 +272,7 @@ describe("DOShardedTagCache", () => {
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            expect(await cache.getFromRegionalCache(doId, ["tag1"])).toBe("response");
+            expect(await cache.getFromRegionalCache({ doId, tags: ["tag1"], type: "boolean" })).toBe("response");
             // @ts-expect-error - Defined on cloudfare context
             globalThis.caches = undefined;
         });
@@ -277,13 +281,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" });
-            expect(cache.getCacheUrlKey(doId1, ["_N_T_/tag1"])).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
+            expect(cache.getCacheUrlKey({ doId: doId1, tags: ["_N_T_/tag1"], type: "boolean" })).toBe("http://local.cache/shard/tag-hard;shard-0?type=boolean&tags=_N_T_%2Ftag1");
             const doId2 = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            expect(cache.getCacheUrlKey(doId2, ["tag1"])).toBe("http://local.cache/shard/tag-hard;shard-1?tags=tag1");
+            expect(cache.getCacheUrlKey({ doId: doId2, tags: ["tag1"], type: "boolean" })).toBe("http://local.cache/shard/tag-hard;shard-1?type=boolean&tags=tag1");
         });
     });
     describe("performWriteTagsWithRetry", () => {

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

@@ -6,6 +6,13 @@ export function withFilter({ tagCache, filterFn }) {
     return {
         name: `filtered-${tagCache.name}`,
         mode: "nextMode",
+        getLastRevalidated: async (tags) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return 0;
+            }
+            return tagCache.getLastRevalidated(filteredTags);
+        },
         getPathsByTags: tagCache.getPathsByTags
             ? async (tags) => {
                 const filteredTags = tags.filter(filterFn);

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

@@ -3,6 +3,7 @@ import { softTagFilter, withFilter } from "./tag-cache-filter";
 const mockedTagCache = {
     name: "mocked",
     mode: "nextMode",
+    getLastRevalidated: vi.fn(),
     getPathsByTags: vi.fn(),
     hasBeenRevalidated: vi.fn(),
     writeTags: vi.fn(),

package/dist/cli/args.d.ts

@@ -7,10 +7,12 @@ export type Arguments = ({
 } | {
     command: "preview" | "deploy" | "upload";
     passthroughArgs: string[];
+    cacheChunkSize?: number;
 } | {
     command: "populateCache";
     target: WranglerTarget;
     environment?: string;
+    cacheChunkSize?: number;
 }) & {
     outputDir?: string;
 };

package/dist/cli/args.js

@@ -9,6 +9,7 @@ export function getArgs() {
             output: { type: "string", short: "o" },
             noMinify: { type: "boolean", default: false },
             skipWranglerConfigCheck: { type: "boolean", default: false },
+            cacheChunkSize: { type: "string" },
         },
         allowPositionals: true,
     });
@@ -33,6 +34,7 @@ export function getArgs() {
                 command: positionals[0],
                 outputDir,
                 passthroughArgs,
+                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
             };
         case "populateCache":
             if (!isWranglerTarget(positionals[1])) {
@@ -43,6 +45,7 @@ export function getArgs() {
                 outputDir,
                 target: positionals[1],
                 environment: getWranglerEnvironmentFlag(passthroughArgs),
+                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
             };
         default:
             throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'upload' | 'populateCache'");

package/dist/cli/build/build.d.ts

@@ -1,5 +1,5 @@
 import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import { OpenNextConfig } from "../../api/config.js";
 import type { ProjectOptions } from "../project-options.js";
 /**
  * Builds the application in a format that can be passed to workerd

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

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { getPackagePath } from "@opennextjs/aws/build/helper.js";
 import { ContentUpdater } from "@opennextjs/aws/plugins/content-updater.js";
 import { build } from "esbuild";
+import { getOpenNextConfig } from "../../api/config.js";
 import { patchVercelOgLibrary } from "./patches/ast/patch-vercel-og-library.js";
 import { patchWebpackRuntime } from "./patches/ast/webpack-runtime.js";
 import * as patches from "./patches/index.js";
@@ -64,13 +65,13 @@ export async function bundleServer(buildOpts) {
         // Next traces files using the default conditions from `nft` (`node`, `require`, `import` and `default`)
         //
         // Because we use the `node` platform for this build, the "module" condition is used when no conditions are defined.
-        // We explicitly set the conditions to an empty array to disable the "module" condition in order to match Next tracing.
+        // The conditions are always set (should it be to an empty array) to disable the "module" condition.
         //
         // See:
         // - default nft conditions: https://github.com/vercel/nft/blob/2b55b01/readme.md#exports--imports
         // - Next no explicit override: https://github.com/vercel/next.js/blob/2efcf11/packages/next/src/build/collect-build-traces.ts#L287
         // - ESBuild `node` platform: https://esbuild.github.io/api/#platform
-        conditions: [],
+        conditions: getOpenNextConfig(buildOpts).cloudflare?.useWorkerdCondition === false ? [] : ["workerd"],
         plugins: [
             shimRequireHook(buildOpts),
             inlineDynamicRequires(updater, buildOpts),
@@ -87,7 +88,7 @@ export async function bundleServer(buildOpts) {
             // Apply updater updates, must be the last plugin
             updater.plugin,
         ],
-        external: ["./middleware/handler.mjs", "*.wasm"],
+        external: ["./middleware/handler.mjs"],
         alias: {
             // Note: it looks like node-fetch is actually not necessary for us, so we could replace it with an empty shim
             //       but just to be safe we replace it with a module that re-exports the native fetch
@@ -124,6 +125,11 @@ export async function bundleServer(buildOpts) {
             // This define should be safe to use for Next 14.2+, earlier versions (13.5 and less) will cause trouble
             "process.env.__NEXT_EXPERIMENTAL_REACT": `${needsExperimentalReact(nextConfig)}`,
         },
+        banner: {
+            // We need to import them here, assigning them to `globalThis` does not work because node:timers use `globalThis` and thus create an infinite loop
+            // See https://github.com/cloudflare/workerd/blob/d6a764c/src/node/internal/internal_timers.ts#L56-L70
+            js: `import {setInterval, clearInterval, setTimeout, clearTimeout, setImmediate, clearImmediate} from "node:timers"`,
+        },
         platform: "node",
     });
     fs.writeFileSync(openNextServerBundle + ".meta.json", JSON.stringify(result.metafile, null, 2));
@@ -132,7 +138,7 @@ export async function bundleServer(buildOpts) {
     if (isMonorepo) {
         fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export { handler } from "./${normalizePath(packagePath)}/handler.mjs";`);
     }
-    console.log(`\x1b[35mWorker saved in \`${getOutputWorkerPath(buildOpts)}\` 🚀\n\x1b[0m`);
+    console.log(`\x1b[35mWorker saved in \`${path.relative(buildOpts.appPath, getOutputWorkerPath(buildOpts))}\` 🚀\n\x1b[0m`);
 }
 /**
  * This function applies patches required for the code to run on workers.
@@ -142,6 +148,7 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
     const patchedCode = await patchCodeWithValidations(code, [
         ["require", patches.patchRequire],
         ["cacheHandler", (code) => patches.patchCache(code, buildOpts)],
+        ["composableCache", (code) => patches.patchComposableCache(code, buildOpts), { isOptional: true }],
         [
             "'require(this.middlewareManifestPath)'",
             (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
@@ -152,6 +159,11 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
             // workers do not support dynamic require nor require.resolve
             (code) => code.replace('require.resolve("./cache.cjs")', '"unused"'),
         ],
+        [
+            "`require.resolve composable cache` call",
+            // workers do not support dynamic require nor require.resolve
+            (code) => code.replace('require.resolve("./composable-cache.cjs")', '"unused"'),
+        ],
     ]);
     await writeFile(workerOutputFile, patchedCode);
 }

package/dist/cli/build/open-next/createServerBundle.js

@@ -10,7 +10,7 @@ import { copyMiddlewareResources, generateEdgeBundle } from "@opennextjs/aws/bui
 import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { installDependencies } from "@opennextjs/aws/build/installDeps.js";
 import { applyCodePatches } from "@opennextjs/aws/build/patch/codePatcher.js";
-import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
+import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, patchUseCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
 // TODO: import from patches/index.js when https://github.com/opennextjs/opennextjs-aws/pull/827 is released
 import { patchBackgroundRevalidation } from "@opennextjs/aws/build/patch/patches/patchBackgroundRevalidation.js";
 import logger from "@opennextjs/aws/logger.js";
@@ -20,8 +20,10 @@ import { openNextExternalMiddlewarePlugin } from "@opennextjs/aws/plugins/extern
 import { openNextReplacementPlugin } from "@opennextjs/aws/plugins/replacement.js";
 import { openNextResolvePlugin } from "@opennextjs/aws/plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { getOpenNextConfig } from "../../../api/config.js";
 import { patchResRevalidate } from "../patches/plugins/res-revalidate.js";
 import { normalizePath } from "../utils/index.js";
+import { copyWorkerdPackages } from "../utils/workerd.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -91,7 +93,10 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const outPackagePath = path.join(outputPath, packagePath);
     fs.mkdirSync(outPackagePath, { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
+    // Normal cache
     fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outPackagePath, "cache.cjs"));
+    // Composable cache
+    fs.copyFileSync(path.join(options.buildDir, `composable-cache.${ext}`), path.join(outPackagePath, "composable-cache.cjs"));
     if (fnOptions.runtime === "deno") {
         addDenoJson(outputPath, packagePath);
     }
@@ -113,18 +118,24 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     // Copy env files
     buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
-    const { tracedFiles, manifests } = await copyTracedFiles({
+    const { tracedFiles, manifests, nodePackages } = await copyTracedFiles({
         buildOutputPath: appBuildOutputPath,
         packagePath,
         outputDir: outputPath,
         routes: fnOptions.routes ?? ["app/page.tsx"],
         bundledNextServer: isBundled,
     });
+    if (getOpenNextConfig(options).cloudflare?.useWorkerdCondition !== false) {
+        // Next does not trace the "workerd" build condition
+        // So we need to copy the whole packages using the condition
+        await copyWorkerdPackages(options, nodePackages);
+    }
     const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
     await applyCodePatches(options, tracedFiles, manifests, [
         patchFetchCacheSetMissingWaitUntil,
         patchFetchCacheForISR,
         patchUnstableCacheForISR,
+        patchUseCacheForISR,
         patchNextServer,
         patchEnvVars,
         patchBackgroundRevalidation,
@@ -142,6 +153,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "<=", "13.4.13");
     const isAfter141 = buildHelper.compareSemver(options.nextVersion, ">=", "14.1");
     const isAfter142 = buildHelper.compareSemver(options.nextVersion, ">=", "14.2");
+    const isAfter152 = buildHelper.compareSemver(options.nextVersion, ">=", "15.2.0");
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
@@ -161,6 +173,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
                 ...(isBefore13413 ? ["trustHostHeader"] : ["requestHandlerHost"]),
                 ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : ["stableIncrementalCache"]),
+                ...(isAfter152 ? [""] : ["composableCache"]),
             ],
         }),
         openNextResolvePlugin({

package/dist/cli/build/patches/investigated/patch-cache.d.ts

@@ -11,3 +11,4 @@ import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
  * instantiated with a dynamic require that uses a string literal for the path.
  */
 export declare function patchCache(code: string, buildOpts: BuildOptions): Promise<string>;
+export declare function patchComposableCache(code: string, buildOpts: BuildOptions): Promise<string>;

package/dist/cli/build/patches/investigated/patch-cache.js

@@ -22,3 +22,19 @@ const cacheHandler = null;
 CacheHandler = require('${normalizePath(cacheFile)}').default;
 `);
 }
+export async function patchComposableCache(code, buildOpts) {
+    const { outputDir } = buildOpts;
+    // TODO: switch to mjs
+    const outputPath = path.join(outputDir, "server-functions/default");
+    const cacheFile = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
+    //TODO: Do we want to move this to the new CodePatcher ?
+    return code.replace("const { cacheHandlers } = this.nextConfig.experimental", `
+const cacheHandlers = null;
+const handlersSymbol = Symbol.for('@next/cache-handlers');
+const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+globalThis[handlersMapSymbol] = new Map();
+globalThis[handlersMapSymbol].set("default", require('${normalizePath(cacheFile)}').default);
+globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+`);
+}

package/dist/cli/build/patches/plugins/eval-manifest.js

@@ -12,7 +12,7 @@ export function inlineEvalManifest(updater, buildOpts) {
     return updater.updateContent("inline-eval-manifest", [
         {
             field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest\.js$`, {
+                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
                     escape: false,
                 }),
                 contentFilter: /function evalManifest\(/,

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -12,7 +12,7 @@ export function inlineLoadManifest(updater, buildOpts) {
     return updater.updateContent("inline-load-manifest", [
         {
             field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest\.js$`, {
+                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
                     escape: false,
                 }),
                 contentFilter: /function loadManifest\(/,

package/dist/cli/build/patches/plugins/wrangler-external.js

@@ -19,7 +19,8 @@ export function setWranglerExternal() {
         name: "wrangler-externals",
         setup: async (build) => {
             const namespace = "wrangler-externals-plugin";
-            build.onResolve({ filter: /(\.bin|\.wasm\?module)$/ }, ({ path, importer }) => {
+            //TODO: Ideally in the future we would like to analyze the files in case they are using wasm in a Node way (i.e. WebAssembly.instantiate)
+            build.onResolve({ filter: /(\.bin|\.wasm(\?module)?)$/ }, ({ path, importer }) => {
                 return {
                     path: resolve(dirname(importer), path),
                     namespace,

package/dist/cli/build/utils/ensure-cf-config.d.ts

@@ -1,4 +1,4 @@
-import type { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { OpenNextConfig } from "../../../api/config.js";
 /**
  * Ensures open next is configured for cloudflare.
  *

package/dist/cli/build/utils/workerd.d.ts

@@ -0,0 +1,38 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+/**
+ * This function transforms the exports (or imports) object from the package.json
+ * to only include the build condition if found (e.g. "workerd") and remove everything else.
+ * If no build condition is found, it keeps everything as is.
+ * It also returns a boolean indicating if the build condition was found.
+ * @param conditionMap The exports (or imports) object from the package.json
+ * @param condition The build condition to look for
+ * @returns An object with the transformed exports and a boolean indicating if the build condition was found
+ */
+export declare function transformBuildCondition(conditionMap: {
+    [key: string]: unknown;
+}, condition: string): {
+    transformedExports: {
+        [key: string]: unknown;
+    };
+    hasBuildCondition: boolean;
+};
+interface PackageJson {
+    name: string;
+    exports?: {
+        [key: string]: unknown;
+    };
+    imports?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ *
+ * @param json The package.json object
+ * @returns An object with the transformed package.json and a boolean indicating if the build condition was found
+ */
+export declare function transformPackageJson(json: PackageJson): {
+    transformed: PackageJson;
+    hasBuildCondition: boolean;
+};
+export declare function copyWorkerdPackages(options: BuildOptions, nodePackages: Map<string, string>): Promise<void>;
+export {};

package/dist/cli/build/utils/workerd.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "@opennextjs/aws/adapters/config/util.js";
+import logger from "@opennextjs/aws/logger.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+/**
+ * This function transforms the exports (or imports) object from the package.json
+ * to only include the build condition if found (e.g. "workerd") and remove everything else.
+ * If no build condition is found, it keeps everything as is.
+ * It also returns a boolean indicating if the build condition was found.
+ * @param conditionMap The exports (or imports) object from the package.json
+ * @param condition The build condition to look for
+ * @returns An object with the transformed exports and a boolean indicating if the build condition was found
+ */
+export function transformBuildCondition(conditionMap, condition) {
+    const transformed = {};
+    const hasTopLevelBuildCondition = Object.keys(conditionMap).some((key) => key === condition && typeof conditionMap[key] === "string");
+    let hasBuildCondition = hasTopLevelBuildCondition;
+    for (const [key, value] of Object.entries(conditionMap)) {
+        if (typeof value === "object" && value != null) {
+            const { transformedExports, hasBuildCondition: innerBuildCondition } = transformBuildCondition(value, condition);
+            transformed[key] = transformedExports;
+            hasBuildCondition ||= innerBuildCondition;
+        }
+        else {
+            // If it doesn't have the build condition, we need to keep everything as is
+            // If it has the build condition, we need to keep only the build condition
+            // and remove everything else
+            if (!hasTopLevelBuildCondition) {
+                transformed[key] = value;
+            }
+            else if (key === condition) {
+                transformed[key] = value;
+            }
+        }
+    }
+    return { transformedExports: transformed, hasBuildCondition };
+}
+/**
+ *
+ * @param json The package.json object
+ * @returns An object with the transformed package.json and a boolean indicating if the build condition was found
+ */
+export function transformPackageJson(json) {
+    const transformed = structuredClone(json);
+    let hasBuildCondition = false;
+    if (json.exports) {
+        const exp = transformBuildCondition(json.exports, "workerd");
+        transformed.exports = exp.transformedExports;
+        hasBuildCondition ||= exp.hasBuildCondition;
+    }
+    if (json.imports) {
+        const imp = transformBuildCondition(json.imports, "workerd");
+        transformed.imports = imp.transformedExports;
+        hasBuildCondition ||= imp.hasBuildCondition;
+    }
+    return { transformed, hasBuildCondition };
+}
+export async function copyWorkerdPackages(options, nodePackages) {
+    const isNodeModuleRegex = getCrossPlatformPathRegex(`.*/node_modules/(?<pkg>.*)`, { escape: false });
+    // Copy full external packages when they use "workerd" build condition
+    const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
+    const externalPackages = nextConfig.serverExternalPackages ?? [];
+    for (const [src, dst] of nodePackages.entries()) {
+        try {
+            const pkgJson = JSON.parse(await fs.readFile(path.join(src, "package.json"), "utf8"));
+            const { transformed, hasBuildCondition } = transformPackageJson(pkgJson);
+            const match = src.match(isNodeModuleRegex);
+            if (match?.groups?.pkg && externalPackages.includes(match.groups.pkg) && hasBuildCondition) {
+                logger.debug(`Copying package using a workerd condition: ${path.relative(options.appPath, src)} -> ${path.relative(options.appPath, dst)}`);
+                await fs.cp(src, dst, { recursive: true, force: true });
+                // Overwrite with  the transformed package.json
+                await fs.writeFile(path.join(dst, "package.json"), JSON.stringify(transformed), "utf8");
+            }
+        }
+        catch {
+            logger.error(`Failed to copy ${src}`);
+        }
+    }
+}

package/dist/cli/build/utils/workerd.spec.d.ts

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