precompile the durable object

Author: conico974

packages/cloudflare/src/api/durable-objects/queue.spec.ts

@@ -30,7 +30,7 @@ const createDurableObjectQueue = ({
       getAlarm: vi.fn(),
       sql: {
         exec: vi.fn().mockImplementation(() => ({
-          one: vi.fn()
+          one: vi.fn(),
         })),
       },
     },
@@ -67,6 +67,7 @@ const createMessage = (dedupId: string, lastModified = Date.now()) => ({
 describe("DurableObjectQueue", () => {
   describe("successful revalidation", () => {
     it("should process a single revalidation", async () => {
+      process.env.__NEXT_PREVIEW_MODE_ID = "test";
       const queue = createDurableObjectQueue({ fetchDuration: 10 });
       const firstRequest = await queue.revalidate(createMessage("id"));
       expect(firstRequest).toBeUndefined();

packages/cloudflare/src/api/durable-objects/queue.ts

@@ -11,12 +11,8 @@ import { DurableObject } from "cloudflare:workers";
 const MAX_REVALIDATION_BY_DURABLE_OBJECT = 5;
 const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 
-interface ExtendedQueueMessage extends QueueMessage {
-  previewModeId: string;
-}
-
 interface FailedState {
-  msg: ExtendedQueueMessage;
+  msg: QueueMessage;
   retryCount: number;
   nextAlarm: number;
 }
@@ -48,7 +44,7 @@ export class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
     ctx.blockConcurrencyWhile(() => this.initState());
   }
 
-  async revalidate(msg: ExtendedQueueMessage) {
+  async revalidate(msg: QueueMessage) {
     // If there is already an ongoing revalidation, we don't need to revalidate again
     if (this.ongoingRevalidations.has(msg.MessageDeduplicationId)) return;
 
@@ -76,25 +72,24 @@ export class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
     this.ctx.waitUntil(revalidationPromise);
   }
 
-  private async executeRevalidation(msg: ExtendedQueueMessage) {
+  private async executeRevalidation(msg: QueueMessage) {
     try {
       const {
         MessageBody: { host, url },
-        previewModeId,
       } = msg;
       const protocol = host.includes("localhost") ? "http" : "https";
 
       const response = await this.service.fetch(`${protocol}://${host}${url}`, {
         method: "HEAD",
         headers: {
-          "x-prerender-revalidate": previewModeId,
+          // This is defined during build
+          "x-prerender-revalidate": process.env.__NEXT_PREVIEW_MODE_ID!,
           "x-isr": "1",
         },
         signal: AbortSignal.timeout(DEFAULT_REVALIDATION_TIMEOUT_MS),
       });
       // Now we need to handle errors from the fetch
       if (response.status === 200 && response.headers.get("x-nextjs-cache") !== "REVALIDATED") {
-        // TODO: when restoring from the failed state during a new deployment, previewModeId will be different and we'll be in this case. Figure out how to handle this.
         this.routeInFailedState.delete(msg.MessageDeduplicationId);
         throw new FatalError(
           `The revalidation for ${host}${url} cannot be done. This error should never happen.`
@@ -122,7 +117,7 @@ export class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
         throw new RecoverableError(`An unknown error occurred while revalidating ${host}${url}`);
       }
       // Everything went well, we can update the sync table
-      // We use unixepoch here because without IO the date doesn't change and it will make the e2e tests fail
+      // We use unixepoch here,it also works with Date.now()/1000, but not with Date.now() alone- we need to investigate this
       this.sql.exec(
         "INSERT OR REPLACE INTO sync (id, lastSuccess) VALUES (?, unixepoch())",
         // We cannot use the deduplication id because it's not unique per route - every time a route is revalidated, the deduplication id is different.
@@ -159,7 +154,7 @@ export class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
     }
   }
 
-  async addToFailedState(msg: ExtendedQueueMessage) {
+  async addToFailedState(msg: QueueMessage) {
     const existingFailedState = this.routeInFailedState.get(msg.MessageDeduplicationId);
     let nextAlarm = Date.now() + 2_000;
 
@@ -233,21 +228,21 @@ export class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
   }
 
   /**
-   * 
-   * @param msg 
+   *
+   * @param msg
    * @returns `true` if the route has been revalidated since the lastModified from the message, `false` otherwise
    */
-  checkSyncTable(msg: ExtendedQueueMessage) {
+  checkSyncTable(msg: QueueMessage) {
     try {
-      const isNewer = this.sql.exec<{ isNewer: number }>(
-        "SELECT COUNT(*) as isNewer FROM sync WHERE id = ? AND lastSuccess > ?",
-        `${msg.MessageBody.host}${msg.MessageBody.url}`,
-       Math.round(msg.MessageBody.lastModified/1000)
-      ).one().isNewer;
+      const isNewer = this.sql
+        .exec<{
+          isNewer: number;
+        }>("SELECT COUNT(*) as isNewer FROM sync WHERE id = ? AND lastSuccess > ?", `${msg.MessageBody.host}${msg.MessageBody.url}`, Math.round(msg.MessageBody.lastModified / 1000))
+        .one().isNewer;
 
       return isNewer > 0;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }catch(e: unknown){
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (e: unknown) {
       return false;
     }
   }

packages/cloudflare/src/api/durable-queue.ts

@@ -11,10 +11,8 @@ export default {
 
     const id = durableObject.idFromName(msg.MessageGroupId);
     const stub = durableObject.get(id);
-    const previewModeId = process.env.__NEXT_PREVIEW_MODE_ID!;
     await stub.revalidate({
       ...msg,
-      previewModeId,
     });
   },
 } satisfies Queue;

packages/cloudflare/src/cli/build/build.ts

@@ -14,6 +14,7 @@ import type { ProjectOptions } from "../project-options.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 { compileDurableObjects } from "./open-next/compileDurableObjects.js";
 import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
 import { createServerBundle } from "./open-next/createServerBundle.js";
 import {
@@ -97,6 +98,8 @@ export async function build(projectOpts: ProjectOptions): Promise<void> {
 
   await createServerBundle(options);
 
+  await compileDurableObjects(options);
+
   await bundleServer(options);
 
   if (!projectOpts.skipWranglerConfigCheck) {

packages/cloudflare/src/cli/build/bundle-server.ts

@@ -58,14 +58,6 @@ export async function bundleServer(buildOpts: BuildOptions): Promise<void> {
   const serverFiles = path.join(baseManifestPath, "required-server-files.json");
   const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
 
-  // TODO: This is a temporary solution to get the previewModeId from the prerender-manifest.json
-  //       We should find a better way to get this value, probably directly provided from aws
-  //       probably in an env variable exactly as for BUILD_ID
-  const prerenderManifest = path.join(baseManifestPath, "prerender-manifest.json");
-  const prerenderManifestContent = fs.readFileSync(prerenderManifest, "utf-8");
-  const prerenderManifestJson = JSON.parse(prerenderManifestContent);
-  const previewModeId = prerenderManifestJson.preview.previewModeId;
-
   console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
 
   await patchWebpackRuntime(buildOpts);
@@ -153,8 +145,6 @@ export async function bundleServer(buildOpts: BuildOptions): Promise<void> {
       "process.env.TURBOPACK": "false",
       // 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)}`,
-      // Used for the durable object queue handler
-      "process.env.__NEXT_PREVIEW_MODE_ID": `"${previewModeId}"`,
     },
     platform: "node",
     banner: {

packages/cloudflare/src/cli/build/open-next/compileDurableObjects.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+import { type BuildOptions, getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { build } from "esbuild";
+
+export function compileDurableObjects(buildOpts: BuildOptions) {
+  const _require = createRequire(import.meta.url);
+  const entryPoints = [_require.resolve("@opennextjs/cloudflare/durable-objects/queue")];
+
+  const { outputDir } = buildOpts;
+
+  const baseManifestPath = path.join(
+    outputDir,
+    "server-functions/default",
+    getPackagePath(buildOpts),
+    ".next"
+  );
+
+  // TODO: Reuse the manifest
+  const prerenderManifest = path.join(baseManifestPath, "prerender-manifest.json");
+  const prerenderManifestContent = fs.readFileSync(prerenderManifest, "utf-8");
+  const prerenderManifestJson = JSON.parse(prerenderManifestContent);
+  const previewModeId = prerenderManifestJson.preview.previewModeId;
+
+  const BUILD_ID = fs.readFileSync(path.join(baseManifestPath, "BUILD_ID"), "utf-8");
+
+  return build({
+    entryPoints,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    outdir: path.join(buildOpts.buildDir, "durable-objects"),
+    external: ["cloudflare:workers"],
+    define: {
+      "process.env.__NEXT_PREVIEW_MODE_ID": `"${previewModeId}"`,
+      "process.env.__NEXT_BUILD_ID": `"${BUILD_ID}"`,
+    },
+  });
+}

packages/cloudflare/src/cli/templates/worker.ts

@@ -18,7 +18,7 @@ Object.defineProperty(globalThis, Symbol.for("__cloudflare-context__"), {
 });
 
 //@ts-expect-error: Will be resolved by wrangler build
-export { DurableObjectQueueHandler } from "@opennextjs/cloudflare/durable-objects/queue";
+export { DurableObjectQueueHandler } from "./.build/durable-objects/queue.js";
 
 // Populate process.env on the first request
 let processEnvPopulated = false;