@opennextjs/cloudflare 1.3.0 → 1.3.1

package/dist/api/durable-objects/queue.spec.js

@@ -1,287 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DOQueueHandler } from "./queue";
-vi.mock("cloudflare:workers", () => ({
-    DurableObject: class {
-        ctx;
-        env;
-        constructor(ctx, env) {
-            this.ctx = ctx;
-            this.env = env;
-        }
-    },
-}));
-const createDurableObjectQueue = ({ fetchDuration, statusCode, headers, disableSQLite, }) => {
-    const mockState = {
-        waitUntil: vi.fn(),
-        blockConcurrencyWhile: vi.fn().mockImplementation(async (fn) => fn()),
-        storage: {
-            setAlarm: vi.fn(),
-            getAlarm: vi.fn(),
-            sql: {
-                exec: vi.fn().mockImplementation(() => ({
-                    one: vi.fn(),
-                })),
-            },
-        },
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new DOQueueHandler(mockState, {
-        WORKER_SELF_REFERENCE: {
-            fetch: vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(new Response(null, {
-                status: statusCode,
-                headers: headers ?? new Headers([["x-nextjs-cache", "REVALIDATED"]]),
-            })), fetchDuration))),
-            connect: vi.fn(),
-        },
-        NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE: disableSQLite ? "true" : undefined,
-    });
-};
-const createMessage = (dedupId, lastModified = Date.now()) => ({
-    MessageBody: { host: "test.local", url: "/test", eTag: "test", lastModified },
-    MessageGroupId: "test.local/test",
-    MessageDeduplicationId: dedupId,
-    previewModeId: "test",
-});
-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();
-            expect(queue.ongoingRevalidations.size).toBe(1);
-            expect(queue.ongoingRevalidations.has("id")).toBe(true);
-            await queue.ongoingRevalidations.get("id");
-            expect(queue.ongoingRevalidations.size).toBe(0);
-            expect(queue.ongoingRevalidations.has("id")).toBe(false);
-            expect(queue.service.fetch).toHaveBeenCalledWith("https://test.local/test", {
-                method: "HEAD",
-                headers: {
-                    "x-prerender-revalidate": "test",
-                    "x-isr": "1",
-                },
-                signal: expect.any(AbortSignal),
-            });
-        });
-        it("should dedupe revalidations", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.revalidate(createMessage("id"));
-            await queue.revalidate(createMessage("id"));
-            expect(queue.ongoingRevalidations.size).toBe(1);
-            expect(queue.ongoingRevalidations.has("id")).toBe(true);
-        });
-        it("should block concurrency", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.revalidate(createMessage("id"));
-            await queue.revalidate(createMessage("id2"));
-            await queue.revalidate(createMessage("id3"));
-            await queue.revalidate(createMessage("id4"));
-            await queue.revalidate(createMessage("id5"));
-            // the next one should block until one of the previous ones finishes
-            const blockedReq = queue.revalidate(createMessage("id6"));
-            expect(queue.ongoingRevalidations.size).toBe(queue.maxRevalidations);
-            expect(queue.ongoingRevalidations.has("id6")).toBe(false);
-            expect(Array.from(queue.ongoingRevalidations.keys())).toEqual(["id", "id2", "id3", "id4", "id5"]);
-            // Here we await the blocked request to ensure it's resolved
-            await blockedReq;
-            // We then need to await for the actual revalidation to finish
-            await Promise.all(Array.from(queue.ongoingRevalidations.values()));
-            expect(queue.ongoingRevalidations.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(6);
-        });
-    });
-    describe("failed revalidation", () => {
-        it("should not put it in failed state for an incorrect 200", async () => {
-            const queue = createDurableObjectQueue({
-                fetchDuration: 10,
-                statusCode: 200,
-                headers: new Headers([["x-nextjs-cache", "MISS"]]),
-            });
-            await queue.revalidate(createMessage("id"));
-            await queue.ongoingRevalidations.get("id");
-            expect(queue.routeInFailedState.size).toBe(0);
-        });
-        it("should not put it in failed state for a failed revalidation with 404", async () => {
-            const queue = createDurableObjectQueue({
-                fetchDuration: 10,
-                statusCode: 404,
-            });
-            await queue.revalidate(createMessage("id"));
-            await queue.ongoingRevalidations.get("id");
-            expect(queue.routeInFailedState.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-            await queue.revalidate(createMessage("id"));
-            expect(queue.routeInFailedState.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
-        });
-        it("should put it in failed state if revalidation fails with 500", async () => {
-            const queue = createDurableObjectQueue({
-                fetchDuration: 10,
-                statusCode: 500,
-            });
-            await queue.revalidate(createMessage("id"));
-            await queue.ongoingRevalidations.get("id");
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.routeInFailedState.has("id")).toBe(true);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-            await queue.revalidate(createMessage("id"));
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-        });
-        it("should put it in failed state if revalidation fetch throw", async () => {
-            const queue = createDurableObjectQueue({
-                fetchDuration: 10,
-            });
-            // @ts-expect-error - This is mocked above
-            queue.service.fetch.mockImplementationOnce(() => Promise.reject(new Error("fetch error")));
-            await queue.revalidate(createMessage("id"));
-            await queue.ongoingRevalidations.get("id");
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.routeInFailedState.has("id")).toBe(true);
-            expect(queue.ongoingRevalidations.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-            await queue.revalidate(createMessage("id"));
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe("addAlarm", () => {
-        const getStorage = (queue) => {
-            // @ts-expect-error - ctx is a protected field
-            return queue.ctx.storage;
-        };
-        it("should not add an alarm if there are no failed states", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.addAlarm();
-            expect(getStorage(queue).setAlarm).not.toHaveBeenCalled();
-        });
-        it("should add an alarm if there are failed states", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            const nextAlarmMs = Date.now() + 1000;
-            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs });
-            await queue.addAlarm();
-            expect(getStorage(queue).setAlarm).toHaveBeenCalledWith(nextAlarmMs);
-        });
-        it("should not add an alarm if there is already an alarm set", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs: 1000 });
-            // @ts-expect-error
-            queue.ctx.storage.getAlarm.mockResolvedValueOnce(1000);
-            await queue.addAlarm();
-            expect(getStorage(queue).setAlarm).not.toHaveBeenCalled();
-        });
-        it("should set the alarm to the lowest nextAlarm", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            const nextAlarmMs = Date.now() + 1000;
-            const firstAlarm = Date.now() + 500;
-            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs });
-            queue.routeInFailedState.set("id2", {
-                msg: createMessage("id2"),
-                retryCount: 0,
-                nextAlarmMs: firstAlarm,
-            });
-            await queue.addAlarm();
-            expect(getStorage(queue).setAlarm).toHaveBeenCalledWith(firstAlarm);
-        });
-    });
-    describe("addToFailedState", () => {
-        it("should add a failed state", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.addToFailedState(createMessage("id"));
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.routeInFailedState.has("id")).toBe(true);
-            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(1);
-        });
-        it("should add a failed state with the correct nextAlarm", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.addToFailedState(createMessage("id"));
-            expect(queue.routeInFailedState.get("id")?.nextAlarmMs).toBeGreaterThan(Date.now());
-            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(1);
-        });
-        it("should add a failed state with the correct nextAlarm for a retry", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            await queue.addToFailedState(createMessage("id"));
-            await queue.addToFailedState(createMessage("id"));
-            expect(queue.routeInFailedState.get("id")?.nextAlarmMs).toBeGreaterThan(Date.now());
-            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(2);
-        });
-        it("should not add a failed state if it has been retried 6 times", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 6, nextAlarmMs: 1000 });
-            await queue.addToFailedState(createMessage("id"));
-            expect(queue.routeInFailedState.size).toBe(0);
-        });
-    });
-    describe("alarm", () => {
-        it("should execute revalidations for expired events", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            queue.routeInFailedState.set("id", {
-                msg: createMessage("id"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() - 1000,
-            });
-            queue.routeInFailedState.set("id2", {
-                msg: createMessage("id2"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() - 1000,
-            });
-            await queue.alarm();
-            expect(queue.routeInFailedState.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
-        });
-        it("should execute revalidations for the next event to retry", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            queue.routeInFailedState.set("id", {
-                msg: createMessage("id"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() + 1000,
-            });
-            queue.routeInFailedState.set("id2", {
-                msg: createMessage("id2"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() + 500,
-            });
-            await queue.alarm();
-            expect(queue.routeInFailedState.size).toBe(1);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
-            expect(queue.routeInFailedState.has("id2")).toBe(false);
-        });
-        it("should execute revalidations for the next event to retry and expired events", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10 });
-            queue.routeInFailedState.set("id", {
-                msg: createMessage("id"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() + 1000,
-            });
-            queue.routeInFailedState.set("id2", {
-                msg: createMessage("id2"),
-                retryCount: 0,
-                nextAlarmMs: Date.now() - 1000,
-            });
-            await queue.alarm();
-            expect(queue.routeInFailedState.size).toBe(0);
-            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe("disableSQLite", () => {
-        it("should not initialize the sqlite storage", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
-            expect(queue.sql.exec).not.toHaveBeenCalled();
-        });
-        it("should not write to the sqlite storage on failed state", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
-            await queue.addToFailedState(createMessage("id"));
-            expect(queue.sql.exec).not.toHaveBeenCalled();
-        });
-        it("should not read from the sqlite storage on checkSyncTable", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
-            queue.checkSyncTable(createMessage("id"));
-            expect(queue.sql.exec).not.toHaveBeenCalled();
-        });
-        it("should not write to sql on successful revalidation", async () => {
-            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
-            await queue.revalidate(createMessage("id"));
-            expect(queue.sql.exec).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/api/durable-objects/sharded-tag-cache.spec.d.ts

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

package/dist/api/durable-objects/sharded-tag-cache.spec.js

@@ -1,37 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DOShardedTagCache } from "./sharded-tag-cache";
-vi.mock("cloudflare:workers", () => ({
-    DurableObject: class {
-        ctx;
-        env;
-        constructor(ctx, env) {
-            this.ctx = ctx;
-            this.env = env;
-        }
-    },
-}));
-const createDOShardedTagCache = () => {
-    const mockState = {
-        waitUntil: vi.fn(),
-        blockConcurrencyWhile: vi.fn().mockImplementation(async (fn) => fn()),
-        storage: {
-            setAlarm: vi.fn(),
-            getAlarm: vi.fn(),
-            sql: {
-                exec: vi.fn().mockImplementation(() => ({
-                    one: vi.fn(),
-                })),
-            },
-        },
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new DOShardedTagCache(mockState, {});
-};
-describe("DOShardedTagCache class", () => {
-    it("should block concurrency while creating the table", async () => {
-        const cache = createDOShardedTagCache();
-        // @ts-expect-error - testing private method
-        expect(cache.ctx.blockConcurrencyWhile).toHaveBeenCalled();
-        expect(cache.sql.exec).toHaveBeenCalledWith(`CREATE TABLE IF NOT EXISTS revalidations (tag TEXT PRIMARY KEY, revalidatedAt INTEGER)`);
-    });
-});

package/dist/api/overrides/queue/memory-queue.spec.d.ts

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

package/dist/api/overrides/queue/memory-queue.spec.js

@@ -1,76 +0,0 @@
-import { generateMessageGroupId } from "@opennextjs/aws/core/routing/queue.js";
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-import cache, { DEFAULT_REVALIDATION_TIMEOUT_MS } from "./memory-queue.js";
-vi.mock("./.next/prerender-manifest.json", () => Promise.resolve({ preview: { previewModeId: "id" } }));
-const mockServiceWorkerFetch = vi.fn();
-vi.mock("../../cloudflare-context", () => ({
-    getCloudflareContext: () => ({
-        env: { WORKER_SELF_REFERENCE: { fetch: mockServiceWorkerFetch } },
-    }),
-}));
-const generateMessageBody = ({ host, url }) => ({
-    host,
-    url,
-    eTag: "etag",
-    lastModified: Date.now(),
-});
-describe("MemoryQueue", () => {
-    beforeAll(() => {
-        vi.useFakeTimers();
-        globalThis.internalFetch = vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(true), 1)));
-    });
-    afterEach(() => vi.clearAllMocks());
-    it("should process revalidations for a path", async () => {
-        const firstRequest = cache.send({
-            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-            MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "/test",
-        });
-        vi.advanceTimersByTime(DEFAULT_REVALIDATION_TIMEOUT_MS);
-        await firstRequest;
-        expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(1);
-        const secondRequest = cache.send({
-            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-            MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "/test",
-        });
-        vi.advanceTimersByTime(1);
-        await secondRequest;
-        expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(2);
-    });
-    it("should process revalidations for multiple paths", async () => {
-        const firstRequest = cache.send({
-            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-            MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "/test",
-        });
-        vi.advanceTimersByTime(1);
-        await firstRequest;
-        expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(1);
-        const secondRequest = cache.send({
-            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-            MessageGroupId: generateMessageGroupId("/other"),
-            MessageDeduplicationId: "/other",
-        });
-        vi.advanceTimersByTime(1);
-        await secondRequest;
-        expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(2);
-    });
-    it("should de-dupe revalidations", async () => {
-        const requests = [
-            cache.send({
-                MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-                MessageGroupId: generateMessageGroupId("/test"),
-                MessageDeduplicationId: "/test",
-            }),
-            cache.send({
-                MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
-                MessageGroupId: generateMessageGroupId("/test"),
-                MessageDeduplicationId: "/test",
-            }),
-        ];
-        vi.advanceTimersByTime(1);
-        await Promise.all(requests);
-        expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/api/overrides/queue/queue-cache.spec.d.ts

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

package/dist/api/overrides/queue/queue-cache.spec.js

@@ -1,92 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import queueCache from "./queue-cache";
-const mockedQueue = {
-    name: "mocked-queue",
-    send: vi.fn(),
-};
-const generateMessage = () => ({
-    MessageGroupId: "test",
-    MessageBody: {
-        eTag: "test",
-        url: "test",
-        host: "test",
-        lastModified: Date.now(),
-    },
-    MessageDeduplicationId: "test",
-});
-const mockedPut = vi.fn();
-const mockedMatch = vi.fn().mockReturnValue(null);
-describe("queue-cache", () => {
-    beforeEach(() => {
-        // @ts-ignore
-        globalThis.caches = {
-            open: vi.fn().mockReturnValue({
-                put: mockedPut,
-                match: mockedMatch,
-            }),
-        };
-    });
-    afterEach(() => {
-        vi.resetAllMocks();
-    });
-    test("should send the message to the original queue", async () => {
-        const msg = generateMessage();
-        const queue = queueCache(mockedQueue, {});
-        expect(queue.name).toBe("cached-mocked-queue");
-        await queue.send(msg);
-        expect(mockedQueue.send).toHaveBeenCalledWith(msg);
-    });
-    test("should use the local cache", async () => {
-        const msg = generateMessage();
-        const queue = queueCache(mockedQueue, {});
-        await queue.send(msg);
-        expect(queue.localCache.size).toBe(1);
-        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
-        expect(mockedPut).toHaveBeenCalled();
-        const spiedHas = vi.spyOn(queue.localCache, "has");
-        await queue.send(msg);
-        expect(spiedHas).toHaveBeenCalled();
-        expect(mockedQueue.send).toHaveBeenCalledTimes(1);
-        expect(mockedMatch).toHaveBeenCalledTimes(1);
-    });
-    test("should clear the local cache after 5s", async () => {
-        vi.useFakeTimers();
-        const msg = generateMessage();
-        const queue = queueCache(mockedQueue, {});
-        await queue.send(msg);
-        expect(queue.localCache.size).toBe(1);
-        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
-        vi.advanceTimersByTime(5001);
-        const alteredMsg = generateMessage();
-        alteredMsg.MessageGroupId = "test2";
-        await queue.send(alteredMsg);
-        expect(queue.localCache.size).toBe(1);
-        console.log(queue.localCache);
-        expect(queue.localCache.has(`queue/test2/test`)).toBe(true);
-        expect(queue.localCache.has(`queue/test/test`)).toBe(false);
-        vi.useRealTimers();
-    });
-    test("should use the regional cache if not in local cache", async () => {
-        const msg = generateMessage();
-        const queue = queueCache(mockedQueue, {});
-        await queue.send(msg);
-        expect(mockedMatch).toHaveBeenCalledTimes(1);
-        expect(mockedPut).toHaveBeenCalledTimes(1);
-        expect(queue.localCache.size).toBe(1);
-        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
-        // We need to delete the local cache to test the regional cache
-        queue.localCache.delete(`queue/test/test`);
-        const spiedHas = vi.spyOn(queue.localCache, "has");
-        await queue.send(msg);
-        expect(spiedHas).toHaveBeenCalled();
-        expect(mockedMatch).toHaveBeenCalledTimes(2);
-    });
-    test("should return early if the message is in the regional cache", async () => {
-        const msg = generateMessage();
-        const queue = queueCache(mockedQueue, {});
-        mockedMatch.mockReturnValueOnce(new Response(null, { status: 200 }));
-        const spiedSend = mockedQueue.send;
-        await queue.send(msg);
-        expect(spiedSend).not.toHaveBeenCalled();
-    });
-});

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

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