make overrides compatible with the external middleware

Author: Nicolas Dorseuil

packages/gitbook-v2/open-next.config.ts

@@ -1,26 +1,29 @@
-import { defineCloudflareConfig } from '@opennextjs/cloudflare';
-import doShardedTagCache from '@opennextjs/cloudflare/overrides/tag-cache/do-sharded-tag-cache';
-import {
-    softTagFilter,
-    withFilter,
-} from '@opennextjs/cloudflare/overrides/tag-cache/tag-cache-filter';
+import type { OpenNextConfig } from '@opennextjs/cloudflare';
 
-export default defineCloudflareConfig({
-    incrementalCache: () => import('./openNext/incrementalCache').then((m) => m.default),
-    tagCache: withFilter({
-        tagCache: doShardedTagCache({
-            baseShardSize: 12,
-            regionalCache: true,
-            shardReplication: {
-                numberOfSoftReplicas: 2,
-                numberOfHardReplicas: 1,
-            },
-        }),
-        // We don't use `revalidatePath`, so we filter out soft tags
-        filterFn: softTagFilter,
-    }),
-    queue: () => import('./openNext/queue').then((m) => m.default),
-
-    // Performance improvements as we don't use PPR
-    enableCacheInterception: true,
-});
+export default {
+    default: {
+        override: {
+            wrapper: 'cloudflare-node',
+            converter: 'edge',
+            proxyExternalRequest: 'fetch',
+            queue: () => import('./openNext/queue/server').then((m) => m.default),
+            incrementalCache: () => import('./openNext/incrementalCache').then((m) => m.default),
+            tagCache: () => import('./openNext/tagCache/server').then((m) => m.default),
+        },
+    },
+    middleware: {
+        external: true,
+        override: {
+            wrapper: 'cloudflare-edge',
+            converter: 'edge',
+            proxyExternalRequest: 'fetch',
+            queue: () => import('./openNext/queue/middleware').then((m) => m.default),
+            incrementalCache: () => import('./openNext/incrementalCache').then((m) => m.default),
+            tagCache: () => import('./openNext/tagCache/middleware').then((m) => m.default),
+        },
+    },
+    dangerous: {
+        enableCacheInterception: true,
+    },
+    edgeExternals: ['node:crypto'],
+} satisfies OpenNextConfig;

packages/gitbook-v2/openNext/customWorkers/default.js

@@ -6,6 +6,10 @@ export default {
     async fetch(request, env, ctx) {
         return runWithCloudflareRequestContext(request, env, ctx, async () => {
             // - `Request`s are handled by the Next server
+            console.log('Request URL:', request);
+            if (request.url.includes('404')) {
+                await env.MIDDLEWARE_REFERENCE.send('whatever');
+            }
             return handler(request, env, ctx);
         });
     },

packages/gitbook-v2/openNext/customWorkers/middleware.js

@@ -1,6 +1,8 @@
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { runWithCloudflareRequestContext } from '../../.open-next/cloudflare/init.js';
 
+import onConfig from '../../.open-next/middleware/open-next.config.mjs';
+
 import { handler as middlewareHandler } from '../../.open-next/middleware/handler.mjs';
 
 export { DOQueueHandler } from '../../.open-next/.build/durable-objects/queue.js';
@@ -35,5 +37,67 @@ export default class extends WorkerEntrypoint {
         });
     }
 
-    //TODO: Add methods for the DO queue and sharded tag cache so that they can be used in the main function through service bindings
+    /**
+     * Forwards the message from the server to the DO queue.
+     */
+    async send(message) {
+        return runWithCloudflareRequestContext(
+            new Request('http://local'),
+            this.env,
+            this.ctx,
+            async () => {
+                const queue = await onConfig.middleware.override.queue();
+                if (queue) {
+                    return queue.send(message);
+                }
+            }
+        );
+    }
+
+    /**
+     * All the functions below are used to interact with the tag cache.
+     * They are needed for the server who wouldn't be able to access the tag cache directly.
+     */
+
+    async getLastRevalidated() {
+        return runWithCloudflareRequestContext(
+            new Request('http://local'),
+            this.env,
+            this.ctx,
+            async () => {
+                const tagCache = await onConfig.middleware.override.tagCache();
+                if (tagCache) {
+                    return tagCache.getLastRevalidated();
+                }
+            }
+        );
+    }
+
+    async hasBeenRevalidated() {
+        return runWithCloudflareRequestContext(
+            new Request('http://local'),
+            this.env,
+            this.ctx,
+            async () => {
+                const tagCache = await onConfig.middleware.override.tagCache();
+                if (tagCache) {
+                    return tagCache.hasBeenRevalidated();
+                }
+            }
+        );
+    }
+
+    async writeTags(tags) {
+        return runWithCloudflareRequestContext(
+            new Request('http://local'),
+            this.env,
+            this.ctx,
+            async () => {
+                const tagCache = await onConfig.middleware.override.tagCache();
+                if (tagCache) {
+                    return tagCache.writeTags(tags);
+                }
+            }
+        );
+    }
 }

packages/gitbook-v2/openNext/queue.ts renamed to packages/gitbook-v2/openNext/queue/middleware.ts

@@ -0,0 +1,14 @@
+import type { Queue } from '@opennextjs/aws/types/overrides.js';
+import { getCloudflareContext } from '@opennextjs/cloudflare';
+
+interface Env {
+    MIDDLEWARE_REFERENCE?: Pick<Queue, 'send'>;
+}
+
+export default {
+    name: 'GitbookISRQueue',
+    send: async (msg) => {
+        const { env, ctx } = getCloudflareContext();
+        ctx.waitUntil((env as Env).MIDDLEWARE_REFERENCE?.send(msg) ?? Promise.resolve());
+    },
+} satisfies Queue;

packages/gitbook-v2/openNext/queue/server.ts

@@ -0,0 +1,18 @@
+import doShardedTagCache from '@opennextjs/cloudflare/overrides/tag-cache/do-sharded-tag-cache';
+import {
+    softTagFilter,
+    withFilter,
+} from '@opennextjs/cloudflare/overrides/tag-cache/tag-cache-filter';
+
+export default withFilter({
+    tagCache: doShardedTagCache({
+        baseShardSize: 12,
+        regionalCache: true,
+        shardReplication: {
+            numberOfSoftReplicas: 2,
+            numberOfHardReplicas: 1,
+        },
+    }),
+    // We don't use `revalidatePath`, so we filter out soft tags
+    filterFn: softTagFilter,
+});

packages/gitbook-v2/openNext/tagCache/middleware.ts

@@ -0,0 +1,26 @@
+import type { NextModeTagCache } from '@opennextjs/aws/types/overrides.js';
+import { getCloudflareContext } from '@opennextjs/cloudflare';
+
+interface Env {
+    MIDDLEWARE_REFERENCE?: Pick<
+        NextModeTagCache,
+        'getLastRevalidated' | 'hasBeenRevalidated' | 'writeTags' | 'getPathsByTags'
+    >;
+}
+
+export default {
+    name: 'GitbookTagCache',
+    mode: 'nextMode',
+    getLastRevalidated: async (tags: string[]) => {
+        const { env } = getCloudflareContext();
+        return (env as Env).MIDDLEWARE_REFERENCE?.getLastRevalidated(tags) ?? 0;
+    },
+    hasBeenRevalidated: async (tags: string[]) => {
+        const { env } = getCloudflareContext();
+        return (env as Env).MIDDLEWARE_REFERENCE?.hasBeenRevalidated(tags) ?? false;
+    },
+    writeTags: async (tags: string[]) => {
+        const { env } = getCloudflareContext();
+        (env as Env).MIDDLEWARE_REFERENCE?.writeTags(tags);
+    },
+} satisfies NextModeTagCache;