@opennextjs/cloudflare 1.3.0 → 1.4.0

package/dist/api/durable-objects/bucket-cache-purge.spec.js

@@ -1,121 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import * as internal from "../overrides/internal";
-import { BucketCachePurge } from "./bucket-cache-purge";
-vi.mock("cloudflare:workers", () => ({
-    DurableObject: class {
-        ctx;
-        env;
-        constructor(ctx, env) {
-            this.ctx = ctx;
-            this.env = env;
-        }
-    },
-}));
-const createBucketCachePurge = () => {
-    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(),
-                    toArray: vi.fn().mockReturnValue([]),
-                })),
-            },
-        },
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new BucketCachePurge(mockState, {});
-};
-describe("BucketCachePurge", () => {
-    it("should block concurrency while creating the table", async () => {
-        const cache = createBucketCachePurge();
-        // @ts-expect-error - testing private method
-        expect(cache.ctx.blockConcurrencyWhile).toHaveBeenCalled();
-        // @ts-expect-error - testing private method
-        expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("CREATE TABLE IF NOT EXISTS cache_purge"));
-    });
-    describe("purgeCacheByTags", () => {
-        it("should insert tags into the sql table", async () => {
-            const cache = createBucketCachePurge();
-            const tags = ["tag1", "tag2"];
-            await cache.purgeCacheByTags(tags);
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("INSERT OR REPLACE INTO cache_purge"), [tags[0]]);
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("INSERT OR REPLACE INTO cache_purge"), [tags[1]]);
-        });
-        it("should set an alarm if no alarm is set", async () => {
-            const cache = createBucketCachePurge();
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.getAlarm.mockResolvedValueOnce(null);
-            await cache.purgeCacheByTags(["tag"]);
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.setAlarm).toHaveBeenCalled();
-        });
-        it("should not set an alarm if one is already set", async () => {
-            const cache = createBucketCachePurge();
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.getAlarm.mockResolvedValueOnce(true);
-            await cache.purgeCacheByTags(["tag"]);
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.setAlarm).not.toHaveBeenCalled();
-        });
-    });
-    describe("alarm", () => {
-        it("should purge cache by tags and delete them from the sql table", async () => {
-            const cache = createBucketCachePurge();
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.sql.exec.mockReturnValueOnce({
-                toArray: () => [{ tag: "tag1" }, { tag: "tag2" }],
-            });
-            await cache.alarm();
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("DELETE FROM cache_purge"), ["tag1", "tag2"]);
-        });
-        it("should not purge cache if no tags are found", async () => {
-            const cache = createBucketCachePurge();
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.sql.exec.mockReturnValueOnce({
-                toArray: () => [],
-            });
-            await cache.alarm();
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.sql.exec).not.toHaveBeenCalledWith(expect.stringContaining("DELETE FROM cache_purge"), []);
-        });
-        it("should call internalPurgeCacheByTags with the correct tags", async () => {
-            const cache = createBucketCachePurge();
-            const tags = ["tag1", "tag2"];
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.sql.exec.mockReturnValueOnce({
-                toArray: () => tags.map((tag) => ({ tag })),
-            });
-            const internalPurgeCacheByTagsSpy = vi.spyOn(internal, "internalPurgeCacheByTags");
-            await cache.alarm();
-            expect(internalPurgeCacheByTagsSpy).toHaveBeenCalledWith(
-            // @ts-expect-error - testing private method
-            cache.env, tags);
-            // @ts-expect-error - testing private method 1st is constructor, 2nd is to get the tags and 3rd is to delete them
-            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledTimes(3);
-        });
-        it("should continue until all tags are purged", async () => {
-            const cache = createBucketCachePurge();
-            const tags = Array.from({ length: 100 }, (_, i) => `tag${i}`);
-            // @ts-expect-error - testing private method
-            cache.ctx.storage.sql.exec.mockReturnValueOnce({
-                toArray: () => tags.map((tag) => ({ tag })),
-            });
-            const internalPurgeCacheByTagsSpy = vi.spyOn(internal, "internalPurgeCacheByTags");
-            await cache.alarm();
-            expect(internalPurgeCacheByTagsSpy).toHaveBeenCalledWith(
-            // @ts-expect-error - testing private method
-            cache.env, tags);
-            // @ts-expect-error - testing private method 1st is constructor, 2nd is to get the tags and 3rd is to delete them, 4th is to get the next 100 tags
-            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledTimes(4);
-            // @ts-expect-error - testing private method
-            expect(cache.ctx.storage.sql.exec).toHaveBeenLastCalledWith(expect.stringContaining("SELECT * FROM cache_purge LIMIT 100"));
-        });
-    });
-});

package/dist/api/durable-objects/queue.spec.d.ts

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

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 {};