@opennextjs/cloudflare 0.5.12 → 0.6.1

package/dist/cli/build/patches/plugins/fetch-cache-wait-until.spec.js

@@ -1,453 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { patchCode } from "../ast/util.js";
-import { rule } from "./fetch-cache-wait-until.js";
-describe("patchFetchCacheSetMissingWaitUntil", () => {
-    test("on minified code", () => {
-        const code = `
-{
-  let [o4, a2] = (0, d2.cloneResponse)(e3);
-  return o4.arrayBuffer().then(async (e4) => {
-    var a3;
-    let i4 = Buffer.from(e4), s3 = { headers: Object.fromEntries(o4.headers.entries()), body: i4.toString("base64"), status: o4.status, url: o4.url };
-    null == $ || null == (a3 = $.serverComponentsHmrCache) || a3.set(n2, s3), F && await H.set(n2, { kind: c2.CachedRouteKind.FETCH, data: s3, revalidate: t5 }, { fetchCache: true, revalidate: r4, fetchUrl: _, fetchIdx: q, tags: A2 });
-  }).catch((e4) => console.warn("Failed to set fetch cache", u4, e4)).finally(X), a2;
-}`;
-        expect(patchCode(code, rule)).toMatchInlineSnapshot(`
-      "{
-        let [o4, a2] = (0, d2.cloneResponse)(e3);
-        return globalThis.__openNextAls?.getStore()?.waitUntil?.(o4.arrayBuffer().then(async (e4) => {
-          var a3;
-          let i4 = Buffer.from(e4), s3 = { headers: Object.fromEntries(o4.headers.entries()), body: i4.toString("base64"), status: o4.status, url: o4.url };
-          null == $ || null == (a3 = $.serverComponentsHmrCache) || a3.set(n2, s3), F && await H.set(n2, { kind: c2.CachedRouteKind.FETCH, data: s3, revalidate: t5 }, { fetchCache: true, revalidate: r4, fetchUrl: _, fetchIdx: q, tags: A2 });
-        }).catch((e4) => console.warn("Failed to set fetch cache", u4, e4)).finally(X))
-      , a2;
-      }"
-    `);
-    });
-    describe("on non-minified code", () => {
-        test("15.1.0", () => {
-            // source: https://github.com/vercel/next.js/blob/fe45b74fdac83d3/packages/next/src/server/lib/patch-fetch.ts#L627-L732
-            const code = `if (
-                res.status === 200 &&
-                incrementalCache &&
-                cacheKey &&
-                (isCacheableRevalidate ||
-                  useCacheOrRequestStore?.serverComponentsHmrCache)
-              ) {
-                const normalizedRevalidate =
-                  finalRevalidate >= INFINITE_CACHE
-                    ? CACHE_ONE_YEAR
-                    : finalRevalidate
-                const externalRevalidate =
-                  finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
-
-                if (workUnitStore && workUnitStore.type === 'prerender') {
-                  // We are prerendering at build time or revalidate time with dynamicIO so we need to
-                  // buffer the response so we can guarantee it can be read in a microtask
-                  const bodyBuffer = await res.arrayBuffer()
-
-                  const fetchedData = {
-                    headers: Object.fromEntries(res.headers.entries()),
-                    body: Buffer.from(bodyBuffer).toString('base64'),
-                    status: res.status,
-                    url: res.url,
-                  }
-
-                  // We can skip checking the serverComponentsHmrCache because we aren't in
-                  // dev mode.
-
-                  await incrementalCache.set(
-                    cacheKey,
-                    {
-                      kind: CachedRouteKind.FETCH,
-                      data: fetchedData,
-                      revalidate: normalizedRevalidate,
-                    },
-                    {
-                      fetchCache: true,
-                      revalidate: externalRevalidate,
-                      fetchUrl,
-                      fetchIdx,
-                      tags,
-                    }
-                  )
-                  await handleUnlock()
-
-                  // We return a new Response to the caller.
-                  return new Response(bodyBuffer, {
-                    headers: res.headers,
-                    status: res.status,
-                    statusText: res.statusText,
-                  })
-                } else {
-                  // We're cloning the response using this utility because there
-                  // exists a bug in the undici library around response cloning.
-                  // See the following pull request for more details:
-                  // https://github.com/vercel/next.js/pull/73274
-
-                  const [cloned1, cloned2] = cloneResponse(res)
-
-                  // We are dynamically rendering including dev mode. We want to return
-                  // the response to the caller as soon as possible because it might stream
-                  // over a very long time.
-                  cloned1
-                    .arrayBuffer()
-                    .then(async (arrayBuffer) => {
-                      const bodyBuffer = Buffer.from(arrayBuffer)
-
-                      const fetchedData = {
-                        headers: Object.fromEntries(cloned1.headers.entries()),
-                        body: bodyBuffer.toString('base64'),
-                        status: cloned1.status,
-                        url: cloned1.url,
-                      }
-
-                      useCacheOrRequestStore?.serverComponentsHmrCache?.set(
-                        cacheKey,
-                        fetchedData
-                      )
-
-                      if (isCacheableRevalidate) {
-                        await incrementalCache.set(
-                          cacheKey,
-                          {
-                            kind: CachedRouteKind.FETCH,
-                            data: fetchedData,
-                            revalidate: normalizedRevalidate,
-                          },
-                          {
-                            fetchCache: true,
-                            revalidate: externalRevalidate,
-                            fetchUrl,
-                            fetchIdx,
-                            tags,
-                          }
-                        )
-                      }
-                    })
-                    .catch((error) =>
-                      console.warn(\`Failed to set fetch cache\`, input, error)
-                    )
-                    .finally(handleUnlock)
-
-                  return cloned2
-                }
-              }
-      `;
-            expect(patchCode(code, rule)).toMatchInlineSnapshot(`
-        "if (
-                        res.status === 200 &&
-                        incrementalCache &&
-                        cacheKey &&
-                        (isCacheableRevalidate ||
-                          useCacheOrRequestStore?.serverComponentsHmrCache)
-                      ) {
-                        const normalizedRevalidate =
-                          finalRevalidate >= INFINITE_CACHE
-                            ? CACHE_ONE_YEAR
-                            : finalRevalidate
-                        const externalRevalidate =
-                          finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
-
-                        if (workUnitStore && workUnitStore.type === 'prerender') {
-                          // We are prerendering at build time or revalidate time with dynamicIO so we need to
-                          // buffer the response so we can guarantee it can be read in a microtask
-                          const bodyBuffer = await res.arrayBuffer()
-
-                          const fetchedData = {
-                            headers: Object.fromEntries(res.headers.entries()),
-                            body: Buffer.from(bodyBuffer).toString('base64'),
-                            status: res.status,
-                            url: res.url,
-                          }
-
-                          // We can skip checking the serverComponentsHmrCache because we aren't in
-                          // dev mode.
-
-                          await incrementalCache.set(
-                            cacheKey,
-                            {
-                              kind: CachedRouteKind.FETCH,
-                              data: fetchedData,
-                              revalidate: normalizedRevalidate,
-                            },
-                            {
-                              fetchCache: true,
-                              revalidate: externalRevalidate,
-                              fetchUrl,
-                              fetchIdx,
-                              tags,
-                            }
-                          )
-                          await handleUnlock()
-
-                          // We return a new Response to the caller.
-                          return new Response(bodyBuffer, {
-                            headers: res.headers,
-                            status: res.status,
-                            statusText: res.statusText,
-                          })
-                        } else {
-                          // We're cloning the response using this utility because there
-                          // exists a bug in the undici library around response cloning.
-                          // See the following pull request for more details:
-                          // https://github.com/vercel/next.js/pull/73274
-
-                          const [cloned1, cloned2] = cloneResponse(res)
-
-                          // We are dynamically rendering including dev mode. We want to return
-                          // the response to the caller as soon as possible because it might stream
-                          // over a very long time.
-                          globalThis.__openNextAls?.getStore()?.waitUntil?.(cloned1
-                            .arrayBuffer()
-                            .then(async (arrayBuffer) => {
-                              const bodyBuffer = Buffer.from(arrayBuffer)
-
-                              const fetchedData = {
-                                headers: Object.fromEntries(cloned1.headers.entries()),
-                                body: bodyBuffer.toString('base64'),
-                                status: cloned1.status,
-                                url: cloned1.url,
-                              }
-
-                              useCacheOrRequestStore?.serverComponentsHmrCache?.set(
-                                cacheKey,
-                                fetchedData
-                              )
-
-                              if (isCacheableRevalidate) {
-                                await incrementalCache.set(
-                                  cacheKey,
-                                  {
-                                    kind: CachedRouteKind.FETCH,
-                                    data: fetchedData,
-                                    revalidate: normalizedRevalidate,
-                                  },
-                                  {
-                                    fetchCache: true,
-                                    revalidate: externalRevalidate,
-                                    fetchUrl,
-                                    fetchIdx,
-                                    tags,
-                                  }
-                                )
-                              }
-                            })
-                            .catch((error) =>
-                              console.warn(\`Failed to set fetch cache\`, input, error)
-                            )
-                            .finally(handleUnlock))
-
-
-                          return cloned2
-                        }
-                      }
-              "
-      `);
-        });
-        test("Next.js 15.0.4", () => {
-            // source: https://github.com/vercel/next.js/blob/d6a6aa14069/packages/next/src/server/lib/patch-fetch.ts#L627-L725
-            const code = `if (
-      res.status === 200 &&
-      incrementalCache &&
-      cacheKey &&
-      (isCacheableRevalidate || requestStore?.serverComponentsHmrCache)
-    ) {
-      const normalizedRevalidate =
-        finalRevalidate >= INFINITE_CACHE
-          ? CACHE_ONE_YEAR
-          : finalRevalidate
-      const externalRevalidate =
-        finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
-
-      if (workUnitStore && workUnitStore.type === 'prerender') {
-        // We are prerendering at build time or revalidate time with dynamicIO so we need to
-        // buffer the response so we can guarantee it can be read in a microtask
-        const bodyBuffer = await res.arrayBuffer()
-
-        const fetchedData = {
-          headers: Object.fromEntries(res.headers.entries()),
-          body: Buffer.from(bodyBuffer).toString('base64'),
-          status: res.status,
-          url: res.url,
-        }
-
-        // We can skip checking the serverComponentsHmrCache because we aren't in
-        // dev mode.
-
-        await incrementalCache.set(
-          cacheKey,
-          {
-            kind: CachedRouteKind.FETCH,
-            data: fetchedData,
-            revalidate: normalizedRevalidate,
-          },
-          {
-            fetchCache: true,
-            revalidate: externalRevalidate,
-            fetchUrl,
-            fetchIdx,
-            tags,
-          }
-        )
-        await handleUnlock()
-
-        // We we return a new Response to the caller.
-        return new Response(bodyBuffer, {
-          headers: res.headers,
-          status: res.status,
-          statusText: res.statusText,
-        })
-      } else {
-        // We are dynamically rendering including dev mode. We want to return
-        // the response to the caller as soon as possible because it might stream
-        // over a very long time.
-        res
-          .clone()
-          .arrayBuffer()
-          .then(async (arrayBuffer) => {
-            const bodyBuffer = Buffer.from(arrayBuffer)
-
-            const fetchedData = {
-              headers: Object.fromEntries(res.headers.entries()),
-              body: bodyBuffer.toString('base64'),
-              status: res.status,
-              url: res.url,
-            }
-
-            requestStore?.serverComponentsHmrCache?.set(
-              cacheKey,
-              fetchedData
-            )
-
-            if (isCacheableRevalidate) {
-              await incrementalCache.set(
-                cacheKey,
-                {
-                  kind: CachedRouteKind.FETCH,
-                  data: fetchedData,
-                  revalidate: normalizedRevalidate,
-                },
-                {
-                  fetchCache: true,
-                  revalidate: externalRevalidate,
-                  fetchUrl,
-                  fetchIdx,
-                  tags,
-                }
-              )
-            }
-          })
-          .catch((error) =>
-            console.warn(\`Failed to set fetch cache\`, input, error)
-          )
-          .finally(handleUnlock)
-
-        return res
-      }
-    }`;
-            expect(patchCode(code, rule)).toMatchInlineSnapshot(`
-        "if (
-              res.status === 200 &&
-              incrementalCache &&
-              cacheKey &&
-              (isCacheableRevalidate || requestStore?.serverComponentsHmrCache)
-            ) {
-              const normalizedRevalidate =
-                finalRevalidate >= INFINITE_CACHE
-                  ? CACHE_ONE_YEAR
-                  : finalRevalidate
-              const externalRevalidate =
-                finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
-
-              if (workUnitStore && workUnitStore.type === 'prerender') {
-                // We are prerendering at build time or revalidate time with dynamicIO so we need to
-                // buffer the response so we can guarantee it can be read in a microtask
-                const bodyBuffer = await res.arrayBuffer()
-
-                const fetchedData = {
-                  headers: Object.fromEntries(res.headers.entries()),
-                  body: Buffer.from(bodyBuffer).toString('base64'),
-                  status: res.status,
-                  url: res.url,
-                }
-
-                // We can skip checking the serverComponentsHmrCache because we aren't in
-                // dev mode.
-
-                await incrementalCache.set(
-                  cacheKey,
-                  {
-                    kind: CachedRouteKind.FETCH,
-                    data: fetchedData,
-                    revalidate: normalizedRevalidate,
-                  },
-                  {
-                    fetchCache: true,
-                    revalidate: externalRevalidate,
-                    fetchUrl,
-                    fetchIdx,
-                    tags,
-                  }
-                )
-                await handleUnlock()
-
-                // We we return a new Response to the caller.
-                return new Response(bodyBuffer, {
-                  headers: res.headers,
-                  status: res.status,
-                  statusText: res.statusText,
-                })
-              } else {
-                // We are dynamically rendering including dev mode. We want to return
-                // the response to the caller as soon as possible because it might stream
-                // over a very long time.
-                globalThis.__openNextAls?.getStore()?.waitUntil?.(res
-                  .clone()
-                  .arrayBuffer()
-                  .then(async (arrayBuffer) => {
-                    const bodyBuffer = Buffer.from(arrayBuffer)
-
-                    const fetchedData = {
-                      headers: Object.fromEntries(res.headers.entries()),
-                      body: bodyBuffer.toString('base64'),
-                      status: res.status,
-                      url: res.url,
-                    }
-
-                    requestStore?.serverComponentsHmrCache?.set(
-                      cacheKey,
-                      fetchedData
-                    )
-
-                    if (isCacheableRevalidate) {
-                      await incrementalCache.set(
-                        cacheKey,
-                        {
-                          kind: CachedRouteKind.FETCH,
-                          data: fetchedData,
-                          revalidate: normalizedRevalidate,
-                        },
-                        {
-                          fetchCache: true,
-                          revalidate: externalRevalidate,
-                          fetchUrl,
-                          fetchIdx,
-                          tags,
-                        }
-                      )
-                    }
-                  })
-                  .catch((error) =>
-                    console.warn(\`Failed to set fetch cache\`, input, error)
-                  )
-                  .finally(handleUnlock))
-
-
-                return res
-              }
-            }"
-      `);
-        });
-    });
-});

package/dist/cli/templates/shims/node-fs.d.ts

@@ -1,17 +0,0 @@
-export declare const nodeFs: {
-    existsSync: typeof existsSync;
-    readFile: typeof readFile;
-    readFileSync: typeof readFileSync;
-    writeFile: typeof writeFile;
-    mkdir: typeof mkdir;
-    stat: typeof stat;
-};
-declare function existsSync(path: string): boolean;
-declare function readFile(path: string, options: unknown): Promise<unknown>;
-declare function readFileSync(path: string, options: unknown): unknown;
-declare function writeFile(file: string, data: unknown): Promise<boolean>;
-declare function mkdir(dir: string): Promise<void>;
-declare function stat(file: string): Promise<{
-    mtime: Date;
-}>;
-export {};

package/dist/cli/templates/shims/node-fs.js

@@ -1,51 +0,0 @@
-// https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/node-fs-methods.ts
-export const nodeFs = {
-    existsSync,
-    readFile,
-    readFileSync,
-    writeFile,
-    mkdir,
-    stat,
-};
-const FILES = new Map();
-const MTIME = Date.now();
-function existsSync(path) {
-    console.log("existsSync", path, new Error().stack?.split("\n").slice(1).join("\n"));
-    return FILES.has(path);
-}
-async function readFile(path, options) {
-    console.log("readFile", { path, options }
-    // new Error().stack.split("\n").slice(1).join("\n"),
-    );
-    if (!FILES.has(path)) {
-        throw new Error(path + "does not exist");
-    }
-    return FILES.get(path);
-}
-function readFileSync(path, options) {
-    console.log("readFileSync", { path, options }
-    // new Error().stack.split("\n").slice(1).join("\n"),
-    );
-    if (!FILES.has(path)) {
-        throw new Error(path + "does not exist");
-    }
-    return FILES.get(path);
-}
-async function writeFile(file, data) {
-    console.log("writeFile", { file, data }
-    // new Error().stack.split("\n").slice(1).join("\n"),
-    );
-    FILES.set(file, data);
-    return true;
-}
-async function mkdir(dir) {
-    console.log("mkdir", dir
-    //new Error().stack.split("\n").slice(1).join("\n"),
-    );
-}
-async function stat(file) {
-    console.log("stat", file
-    // new Error().stack.split("\n").slice(1).join("\n"),
-    );
-    return { mtime: new Date(MTIME) };
-}

package/dist/cli/templates/shims/throw.js

@@ -1,2 +0,0 @@
-"use strict";
-throw new Error();