@opennextjs/cloudflare 1.2.1 → 1.3.1

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

@@ -1,413 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import shardedDOTagCache, { AVAILABLE_REGIONS, DOId } from "./do-sharded-tag-cache";
-const hasBeenRevalidatedMock = vi.fn();
-const writeTagsMock = vi.fn();
-const idFromNameMock = vi.fn();
-const getMock = vi
-    .fn()
-    .mockReturnValue({ hasBeenRevalidated: hasBeenRevalidatedMock, writeTags: writeTagsMock });
-const waitUntilMock = vi.fn().mockImplementation(async (fn) => fn());
-// @ts-expect-error - We define it here only for the test
-globalThis.continent = undefined;
-const sendDLQMock = vi.fn();
-vi.mock("../../cloudflare-context", () => ({
-    getCloudflareContext: () => ({
-        env: {
-            NEXT_TAG_CACHE_DO_SHARDED: { idFromName: idFromNameMock, get: getMock },
-            NEXT_TAG_CACHE_DO_SHARDED_DLQ: {
-                send: sendDLQMock,
-            },
-        },
-        ctx: { waitUntil: waitUntilMock },
-        cf: {
-            // @ts-expect-error - We define it here only for the test
-            continent: globalThis.continent,
-        },
-    }),
-}));
-describe("DOShardedTagCache", () => {
-    afterEach(() => vi.clearAllMocks());
-    describe("generateShardId", () => {
-        it("should generate a shardId", () => {
-            const cache = shardedDOTagCache();
-            const expectedResult = [
-                { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1"] },
-                { doId: expect.objectContaining({ shardId: "tag-hard;shard-2" }), tags: ["tag2"] },
-            ];
-            const result = cache.groupTagsByDO({ tags: ["tag1", "tag2"] });
-            expect(result).toEqual(expectedResult);
-            expect(result[0]?.doId.key).toBe("tag-hard;shard-1;replica-1");
-            expect(result[1]?.doId.key).toBe("tag-hard;shard-2;replica-1");
-        });
-        it("should group tags by shard", () => {
-            const cache = shardedDOTagCache();
-            const expectedResult = [
-                { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1", "tag6"] },
-            ];
-            const result = cache.groupTagsByDO({ tags: ["tag1", "tag6"] });
-            expect(result).toEqual(expectedResult);
-            expect(result[0]?.doId.key).toBe("tag-hard;shard-1;replica-1");
-        });
-        it("should generate the same shardId for the same tag", () => {
-            const cache = shardedDOTagCache();
-            const firstResult = cache.groupTagsByDO({ tags: ["tag1"] });
-            const secondResult = cache.groupTagsByDO({ tags: ["tag1", "tag3", "tag4"] });
-            expect(firstResult[0]).toEqual(secondResult[0]);
-        });
-        it("should split hard and soft tags", () => {
-            const cache = shardedDOTagCache();
-            const expectedResult = [
-                { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
-                { doId: expect.objectContaining({ shardId: "tag-hard;shard-1", replicaId: 1 }), tags: ["tag1"] },
-            ];
-            const result = cache.groupTagsByDO({ tags: ["tag1", "_N_T_/tag1"] });
-            expect(result).toEqual(expectedResult);
-            expect(result[1]?.doId.key).toBe("tag-hard;shard-1;replica-1");
-            expect(result[0]?.doId.key).toBe("tag-soft;shard-3;replica-1");
-        });
-        describe("with shard replication", () => {
-            it("should generate all doIds if generateAllReplicas is true", () => {
-                const cache = shardedDOTagCache({
-                    baseShardSize: 4,
-                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
-                });
-                const expectedResult = [
-                    { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
-                    { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
-                    { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
-                    { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
-                    { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1"] },
-                    { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1"] },
-                ];
-                const result = cache.groupTagsByDO({ tags: ["tag1", "_N_T_/tag1"], generateAllReplicas: true });
-                expect(result).toEqual(expectedResult);
-            });
-            it("should generate only one doIds by tag type if generateAllReplicas is false", () => {
-                const cache = shardedDOTagCache({
-                    baseShardSize: 4,
-                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
-                });
-                const shardedTagCollection = cache.groupTagsByDO({
-                    tags: ["tag1", "_N_T_/tag1"],
-                    generateAllReplicas: false,
-                });
-                expect(shardedTagCollection.length).toBe(2);
-                const firstDOId = shardedTagCollection[0]?.doId;
-                const secondDOId = shardedTagCollection[1]?.doId;
-                expect(firstDOId?.shardId).toBe("tag-soft;shard-3");
-                expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
-                // We still need to check if the last part is between the correct boundaries
-                expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(firstDOId?.replicaId).toBeLessThanOrEqual(4);
-                expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
-            });
-            it("should generate one doIds, but in the default region", () => {
-                const cache = shardedDOTagCache({
-                    baseShardSize: 4,
-                    shardReplication: {
-                        numberOfSoftReplicas: 2,
-                        numberOfHardReplicas: 2,
-                        regionalReplication: {
-                            defaultRegion: "enam",
-                        },
-                    },
-                });
-                const shardedTagCollection = cache.groupTagsByDO({
-                    tags: ["tag1", "_N_T_/tag1"],
-                    generateAllReplicas: false,
-                });
-                expect(shardedTagCollection.length).toBe(2);
-                const firstDOId = shardedTagCollection[0]?.doId;
-                const secondDOId = shardedTagCollection[1]?.doId;
-                expect(firstDOId?.shardId).toBe("tag-soft;shard-3");
-                expect(firstDOId?.region).toBe("enam");
-                expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
-                expect(secondDOId?.region).toBe("enam");
-                // We still need to check if the last part is between the correct boundaries
-                expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(firstDOId?.replicaId).toBeLessThanOrEqual(2);
-                expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
-            });
-            it("should generate one doIds, but in the correct region", () => {
-                // @ts-expect-error - We define it here only for the test
-                globalThis.continent = "EU";
-                const cache = shardedDOTagCache({
-                    baseShardSize: 4,
-                    shardReplication: {
-                        numberOfSoftReplicas: 2,
-                        numberOfHardReplicas: 2,
-                        regionalReplication: {
-                            defaultRegion: "enam",
-                        },
-                    },
-                });
-                const shardedTagCollection = cache.groupTagsByDO({
-                    tags: ["tag1", "_N_T_/tag1"],
-                    generateAllReplicas: false,
-                });
-                expect(shardedTagCollection.length).toBe(2);
-                expect(shardedTagCollection[0]?.doId.region).toBe("weur");
-                expect(shardedTagCollection[1]?.doId.region).toBe("weur");
-                //@ts-expect-error - We need to reset the global variable
-                globalThis.continent = undefined;
-            });
-            it("should generate all the appropriate replicas in all the regions with enableRegionalReplication", () => {
-                const cache = shardedDOTagCache({
-                    baseShardSize: 4,
-                    shardReplication: {
-                        numberOfSoftReplicas: 2,
-                        numberOfHardReplicas: 2,
-                        regionalReplication: {
-                            defaultRegion: "enam",
-                        },
-                    },
-                });
-                const shardedTagCollection = cache.groupTagsByDO({
-                    tags: ["tag1", "_N_T_/tag1"],
-                    generateAllReplicas: true,
-                });
-                // 6 regions times 4 shards replica
-                expect(shardedTagCollection.length).toBe(24);
-                shardedTagCollection.forEach(({ doId }) => {
-                    expect(AVAILABLE_REGIONS).toContain(doId.region);
-                    // It should end with the region
-                    expect(doId.key).toMatch(/tag-(soft|hard);shard-\d;replica-\d;region-(enam|weur|sam|afr|apac|oc)$/);
-                });
-            });
-        });
-    });
-    describe("hasBeenRevalidated", () => {
-        beforeEach(() => {
-            globalThis.openNextConfig = {
-                dangerous: { disableTagCache: false },
-            };
-        });
-        it("should return false if the cache is disabled", async () => {
-            globalThis.openNextConfig = {
-                dangerous: { disableTagCache: true },
-            };
-            const cache = shardedDOTagCache();
-            const result = await cache.hasBeenRevalidated(["tag1"]);
-            expect(result).toBe(false);
-            expect(idFromNameMock).not.toHaveBeenCalled();
-        });
-        it("should return false if stub return false", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn();
-            hasBeenRevalidatedMock.mockImplementationOnce(() => false);
-            const result = await cache.hasBeenRevalidated(["tag1"], 123456);
-            expect(cache.getFromRegionalCache).toHaveBeenCalled();
-            expect(idFromNameMock).toHaveBeenCalled();
-            expect(hasBeenRevalidatedMock).toHaveBeenCalled();
-            expect(result).toBe(false);
-        });
-        it("should return true if stub return true", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn();
-            hasBeenRevalidatedMock.mockImplementationOnce(() => true);
-            const result = await cache.hasBeenRevalidated(["tag1"], 123456);
-            expect(cache.getFromRegionalCache).toHaveBeenCalled();
-            expect(idFromNameMock).toHaveBeenCalled();
-            expect(hasBeenRevalidatedMock).toHaveBeenCalledWith(["tag1"], 123456);
-            expect(result).toBe(true);
-        });
-        it("should return false if it throws", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn();
-            hasBeenRevalidatedMock.mockImplementationOnce(() => {
-                throw new Error("error");
-            });
-            const result = await cache.hasBeenRevalidated(["tag1"], 123456);
-            expect(cache.getFromRegionalCache).toHaveBeenCalled();
-            expect(idFromNameMock).toHaveBeenCalled();
-            expect(hasBeenRevalidatedMock).toHaveBeenCalled();
-            expect(result).toBe(false);
-        });
-        it("Should return from the cache if it was found there", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn().mockReturnValueOnce(new Response("true"));
-            const result = await cache.hasBeenRevalidated(["tag1"], 123456);
-            expect(result).toBe(true);
-            expect(idFromNameMock).not.toHaveBeenCalled();
-            expect(hasBeenRevalidatedMock).not.toHaveBeenCalled();
-        });
-        it("should try to put the result in the cache if it was not revalidated", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn();
-            cache.putToRegionalCache = vi.fn();
-            hasBeenRevalidatedMock.mockImplementationOnce(() => false);
-            const result = await cache.hasBeenRevalidated(["tag1"], 123456);
-            expect(result).toBe(false);
-            expect(waitUntilMock).toHaveBeenCalled();
-            expect(cache.putToRegionalCache).toHaveBeenCalled();
-        });
-        it("should call all the durable object instance", async () => {
-            const cache = shardedDOTagCache();
-            cache.getFromRegionalCache = vi.fn();
-            const result = await cache.hasBeenRevalidated(["tag1", "tag2"], 123456);
-            expect(result).toBe(false);
-            expect(idFromNameMock).toHaveBeenCalledTimes(2);
-            expect(hasBeenRevalidatedMock).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe("writeTags", () => {
-        beforeEach(() => {
-            globalThis.openNextConfig = {
-                dangerous: { disableTagCache: false },
-            };
-            vi.useFakeTimers();
-            vi.setSystemTime(1000);
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-        it("should return early if the cache is disabled", async () => {
-            globalThis.openNextConfig = {
-                dangerous: { disableTagCache: true },
-            };
-            const cache = shardedDOTagCache();
-            await cache.writeTags(["tag1"]);
-            expect(idFromNameMock).not.toHaveBeenCalled();
-            expect(writeTagsMock).not.toHaveBeenCalled();
-        });
-        it("should write the tags to the cache", async () => {
-            const cache = shardedDOTagCache();
-            await cache.writeTags(["tag1"]);
-            expect(idFromNameMock).toHaveBeenCalled();
-            expect(writeTagsMock).toHaveBeenCalled();
-            expect(writeTagsMock).toHaveBeenCalledWith(["tag1"], 1000);
-        });
-        it("should write the tags to the cache for multiple shards", async () => {
-            const cache = shardedDOTagCache();
-            await cache.writeTags(["tag1", "tag2"]);
-            expect(idFromNameMock).toHaveBeenCalledTimes(2);
-            expect(writeTagsMock).toHaveBeenCalledTimes(2);
-            expect(writeTagsMock).toHaveBeenCalledWith(["tag1"], 1000);
-            expect(writeTagsMock).toHaveBeenCalledWith(["tag2"], 1000);
-        });
-        it('should write to all the replicated shards if "generateAllReplicas" is true', async () => {
-            const cache = shardedDOTagCache({
-                baseShardSize: 4,
-                shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
-            });
-            await cache.writeTags(["tag1", "_N_T_/tag1"]);
-            expect(idFromNameMock).toHaveBeenCalledTimes(6);
-            expect(writeTagsMock).toHaveBeenCalledTimes(6);
-            expect(writeTagsMock).toHaveBeenCalledWith(["tag1"], 1000);
-            expect(writeTagsMock).toHaveBeenCalledWith(["_N_T_/tag1"], 1000);
-        });
-        it("should call deleteRegionalCache", async () => {
-            const cache = shardedDOTagCache();
-            cache.deleteRegionalCache = vi.fn();
-            await cache.writeTags(["tag1"]);
-            expect(cache.deleteRegionalCache).toHaveBeenCalled();
-            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"]);
-        });
-    });
-    describe("getCacheInstance", () => {
-        it("should return undefined by default", async () => {
-            const cache = shardedDOTagCache();
-            expect(await cache.getCacheInstance()).toBeUndefined();
-        });
-        it("should try to return the cache instance if regional cache is enabled", async () => {
-            // @ts-expect-error - Defined on cloudfare context
-            globalThis.caches = {
-                open: vi.fn().mockResolvedValue("cache"),
-            };
-            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
-            expect(cache.localCache).toBeUndefined();
-            expect(await cache.getCacheInstance()).toBe("cache");
-            expect(cache.localCache).toBe("cache");
-            // @ts-expect-error - Defined on cloudfare context
-            globalThis.caches = undefined;
-        });
-    });
-    describe("getFromRegionalCache", () => {
-        it("should return undefined if regional cache is disabled", async () => {
-            const cache = shardedDOTagCache();
-            const doId = new DOId({
-                baseShardId: "shard-1",
-                numberOfReplicas: 1,
-                shardType: "hard",
-            });
-            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
-            globalThis.caches = {
-                open: vi.fn().mockResolvedValue({
-                    match: vi.fn().mockResolvedValue("response"),
-                }),
-            };
-            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
-            const doId = new DOId({
-                baseShardId: "shard-1",
-                numberOfReplicas: 1,
-                shardType: "hard",
-            });
-            expect(await cache.getFromRegionalCache({ doId, tags: ["tag1"], type: "boolean" })).toBe("response");
-            // @ts-expect-error - Defined on cloudfare context
-            globalThis.caches = undefined;
-        });
-    });
-    describe("getCacheKey", () => {
-        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({ 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({ doId: doId2, tags: ["tag1"], type: "boolean" })).toBe("http://local.cache/shard/tag-hard;shard-1?type=boolean&tags=tag1");
-        });
-    });
-    describe("performWriteTagsWithRetry", () => {
-        it("should retry if it fails", async () => {
-            vi.useFakeTimers();
-            vi.setSystemTime(1000);
-            const cache = shardedDOTagCache();
-            writeTagsMock.mockImplementationOnce(() => {
-                throw new Error("error");
-            });
-            const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            const doId = new DOId({
-                baseShardId: "shard-1",
-                numberOfReplicas: 1,
-                shardType: "hard",
-            });
-            await cache.performWriteTagsWithRetry(doId, ["tag1"], Date.now());
-            expect(writeTagsMock).toHaveBeenCalledTimes(2);
-            expect(spiedFn).toHaveBeenCalledTimes(2);
-            expect(spiedFn).toHaveBeenCalledWith(doId, ["tag1"], 1000, 1);
-            expect(sendDLQMock).not.toHaveBeenCalled();
-            vi.useRealTimers();
-        });
-        it("should stop retrying after 3 times", async () => {
-            vi.useFakeTimers();
-            vi.setSystemTime(1000);
-            const cache = shardedDOTagCache();
-            writeTagsMock.mockImplementationOnce(() => {
-                throw new Error("error");
-            });
-            const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            await cache.performWriteTagsWithRetry(new DOId({ baseShardId: "shard-1", numberOfReplicas: 1, shardType: "hard" }), ["tag1"], Date.now(), 3);
-            expect(writeTagsMock).toHaveBeenCalledTimes(1);
-            expect(spiedFn).toHaveBeenCalledTimes(1);
-            expect(sendDLQMock).toHaveBeenCalledWith({
-                failingShardId: "tag-hard;shard-1;replica-1",
-                failingTags: ["tag1"],
-                lastModified: 1000,
-            });
-            vi.useRealTimers();
-        });
-    });
-});

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

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

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

@@ -1,97 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-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(),
-};
-const filterFn = (tag) => tag.startsWith("valid_");
-describe("withFilter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should filter out tags based on writeTags", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["valid_tag", "invalid_tag"];
-        await tagCache.writeTags(tags);
-        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
-    });
-    it("should not call writeTags if no tags are valid", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["invalid_tag"];
-        await tagCache.writeTags(tags);
-        expect(mockedTagCache.writeTags).not.toHaveBeenCalled();
-    });
-    it("should filter out tags based on hasBeenRevalidated", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["valid_tag", "invalid_tag"];
-        const lastModified = Date.now();
-        await tagCache.hasBeenRevalidated(tags, lastModified);
-        expect(mockedTagCache.hasBeenRevalidated).toHaveBeenCalledWith(["valid_tag"], lastModified);
-    });
-    it("should not call hasBeenRevalidated if no tags are valid", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["invalid_tag"];
-        const lastModified = Date.now();
-        await tagCache.hasBeenRevalidated(tags, lastModified);
-        expect(mockedTagCache.hasBeenRevalidated).not.toHaveBeenCalled();
-    });
-    it("should filter out tags based on getPathsByTags", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["valid_tag", "invalid_tag"];
-        await tagCache.getPathsByTags?.(tags);
-        expect(mockedTagCache.getPathsByTags).toHaveBeenCalledWith(["valid_tag"]);
-    });
-    it("should not call getPathsByTags if no tags are valid", async () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        const tags = ["invalid_tag"];
-        await tagCache.getPathsByTags?.(tags);
-        expect(mockedTagCache.getPathsByTags).not.toHaveBeenCalled();
-    });
-    it("should return the correct name", () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn,
-        });
-        expect(tagCache.name).toBe("filtered-mocked");
-    });
-    it("should not create a function if getPathsByTags is not defined", async () => {
-        const tagCache = withFilter({
-            tagCache: {
-                ...mockedTagCache,
-                getPathsByTags: undefined,
-            },
-            filterFn,
-        });
-        expect(tagCache.getPathsByTags).toBeUndefined();
-    });
-    it("should filter soft tags", () => {
-        const tagCache = withFilter({
-            tagCache: mockedTagCache,
-            filterFn: softTagFilter,
-        });
-        tagCache.writeTags(["valid_tag", "_N_T_/", "_N_T_/test", "_N_T_/layout"]);
-        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
-    });
-});

package/dist/cli/build/patches/ast/patch-vercel-og-library.spec.d.ts

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

package/dist/cli/build/patches/ast/patch-vercel-og-library.spec.js

@@ -1,50 +0,0 @@
-import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import mockFs from "mock-fs";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { patchVercelOgLibrary } from "./patch-vercel-og-library";
-const nodeModulesVercelOgDir = "node_modules/.pnpm/next@14.2.11/node_modules/next/dist/compiled/@vercel/og";
-const nextServerOgNftPath = "examples/api/.next/server/app/og/route.js.nft.json";
-const openNextFunctionDir = "examples/api/.open-next/server-functions/default/examples/api";
-const openNextOgRoutePath = path.join(openNextFunctionDir, ".next/server/app/og/route.js");
-const openNextVercelOgDir = path.join(openNextFunctionDir, "node_modules/next/dist/compiled/@vercel/og");
-const buildOpts = {
-    appBuildOutputPath: "examples/api",
-    monorepoRoot: "",
-    outputDir: "examples/api/.open-next",
-};
-describe("patchVercelOgLibrary", () => {
-    beforeAll(() => {
-        mockFs();
-        mkdirSync(nodeModulesVercelOgDir, { recursive: true });
-        mkdirSync(path.dirname(nextServerOgNftPath), { recursive: true });
-        mkdirSync(path.dirname(openNextOgRoutePath), { recursive: true });
-        mkdirSync(openNextVercelOgDir, { recursive: true });
-        writeFileSync(nextServerOgNftPath, JSON.stringify({ version: 1, files: [`../../../../../../${nodeModulesVercelOgDir}/index.node.js`] }));
-        writeFileSync(path.join(nodeModulesVercelOgDir, "index.edge.js"), `var fallbackFont = fetch(new URL("./noto-sans-v27-latin-regular.ttf", import.meta.url)).then((res) => res.arrayBuffer());`);
-        writeFileSync(openNextOgRoutePath, `e.exports=import("next/dist/compiled/@vercel/og/index.node.js")`);
-        writeFileSync(path.join(openNextVercelOgDir, "index.node.js"), "");
-        writeFileSync(path.join(openNextVercelOgDir, "noto-sans-v27-latin-regular.ttf"), "");
-    });
-    afterAll(() => mockFs.restore());
-    it("should patch the open-next files correctly", () => {
-        patchVercelOgLibrary(buildOpts);
-        expect(readdirSync(openNextVercelOgDir)).toMatchInlineSnapshot(`
-      [
-        "index.edge.js",
-        "index.node.js",
-        "noto-sans-v27-latin-regular.ttf.bin",
-      ]
-    `);
-        expect(readFileSync(path.join(openNextVercelOgDir, "index.edge.js"), { encoding: "utf-8" }))
-            .toMatchInlineSnapshot(`
-      "async function getFallbackFont() {
-        // .bin is used so that a loader does not need to be configured for .ttf files
-        return (await import("./noto-sans-v27-latin-regular.ttf.bin")).default;
-      }
-
-      var fallbackFont = getFallbackFont();"
-    `);
-        expect(readFileSync(openNextOgRoutePath, { encoding: "utf-8" })).toMatchInlineSnapshot(`"e.exports=import("next/dist/compiled/@vercel/og/index.edge.js")"`);
-    });
-});

package/dist/cli/build/patches/ast/vercel-og.spec.d.ts

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

package/dist/cli/build/patches/ast/vercel-og.spec.js

@@ -1,22 +0,0 @@
-import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
-import { describe, expect, it } from "vitest";
-import { vercelOgFallbackFontRule, vercelOgImportRule } from "./vercel-og";
-describe("vercelOgImportRule", () => {
-    it("should rewrite a node import to an edge import", () => {
-        const code = `e.exports=import("next/dist/compiled/@vercel/og/index.node.js")`;
-        expect(patchCode(code, vercelOgImportRule)).toMatchInlineSnapshot(`"e.exports=import("next/dist/compiled/@vercel/og/index.edge.js")"`);
-    });
-});
-describe("vercelOgFallbackFontRule", () => {
-    it("should replace a fetch call for a font with an import", () => {
-        const code = `var fallbackFont = fetch(new URL("./noto-sans-v27-latin-regular.ttf", import.meta.url)).then((res) => res.arrayBuffer());`;
-        expect(patchCode(code, vercelOgFallbackFontRule)).toMatchInlineSnapshot(`
-      "async function getFallbackFont() {
-        // .bin is used so that a loader does not need to be configured for .ttf files
-        return (await import("./noto-sans-v27-latin-regular.ttf.bin")).default;
-      }
-
-      var fallbackFont = getFallbackFont();"
-    `);
-    });
-});

package/dist/cli/build/patches/ast/webpack-runtime.spec.d.ts

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