@opennextjs/cloudflare 0.0.0-5454280

package/dist/templates/shims/empty.ts

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

package/dist/templates/shims/env.ts

@@ -0,0 +1 @@
+export function loadEnvConfig() {}

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

@@ -0,0 +1,69 @@
+// 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<string, unknown>();
+const MTIME = Date.now();
+
+function existsSync(path: string) {
+  console.log("existsSync", path, new Error().stack?.split("\n").slice(1).join("\n"));
+  return FILES.has(path);
+}
+
+async function readFile(path: string, options: unknown): Promise<any> {
+  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: string, options: unknown) {
+  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: string, data: unknown) {
+  console.log(
+    "writeFile",
+    { file, data }
+    // new Error().stack.split("\n").slice(1).join("\n"),
+  );
+  FILES.set(file, data);
+  return true;
+}
+
+async function mkdir(dir: string) {
+  console.log(
+    "mkdir",
+    dir
+    //new Error().stack.split("\n").slice(1).join("\n"),
+  );
+}
+
+async function stat(file: string) {
+  console.log(
+    "stat",
+    file
+    // new Error().stack.split("\n").slice(1).join("\n"),
+  );
+  return { mtime: new Date(MTIME) };
+}

package/dist/templates/shims/throw.ts

@@ -0,0 +1 @@
+throw new Error();

package/dist/templates/worker.ts

@@ -0,0 +1,128 @@
+import Stream from "node:stream";
+import type { NextConfig } from "next";
+import { NodeNextRequest, NodeNextResponse } from "next/dist/server/base-http/node";
+import { MockedResponse } from "next/dist/server/lib/mock-request";
+import NextNodeServer, { NodeRequestHandler } from "next/dist/server/next-server";
+import type { IncomingMessage } from "node:http";
+
+const NON_BODY_RESPONSES = new Set([101, 204, 205, 304]);
+
+// Injected at build time
+const nextConfig: NextConfig = JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG ?? "{}");
+
+let requestHandler: NodeRequestHandler | null = null;
+
+export default {
+  async fetch(request: Request, env: any, ctx: any) {
+    if (requestHandler == null) {
+      globalThis.process.env = { ...globalThis.process.env, ...env };
+      requestHandler = new NextNodeServer({
+        conf: { ...nextConfig, env },
+        customServer: false,
+        dev: false,
+        dir: "",
+        minimalMode: false,
+      }).getRequestHandler();
+    }
+
+    const url = new URL(request.url);
+
+    if (url.pathname === "/_next/image") {
+      let imageUrl =
+        url.searchParams.get("url") ?? "https://developers.cloudflare.com/_astro/logo.BU9hiExz.svg";
+      if (imageUrl.startsWith("/")) {
+        return env.ASSETS.fetch(new URL(imageUrl, request.url));
+      }
+      return fetch(imageUrl, { cf: { cacheEverything: true } } as any);
+    }
+
+    const { req, res, webResponse } = getWrappedStreams(request, ctx);
+
+    ctx.waitUntil(requestHandler(new NodeNextRequest(req), new NodeNextResponse(res)));
+
+    return await webResponse();
+  },
+};
+
+function getWrappedStreams(request: Request, ctx: any) {
+  const url = new URL(request.url);
+
+  const req = (
+    request.body ? Stream.Readable.fromWeb(request.body as any) : Stream.Readable.from([])
+  ) as IncomingMessage;
+  req.httpVersion = "1.0";
+  req.httpVersionMajor = 1;
+  req.httpVersionMinor = 0;
+  req.url = url.href.slice(url.origin.length);
+  req.headers = Object.fromEntries([...request.headers]);
+  req.method = request.method;
+  Object.defineProperty(req, "__node_stream__", {
+    value: true,
+    writable: false,
+  });
+  Object.defineProperty(req, "headersDistinct", {
+    get() {
+      const headers: Record<string, string[]> = {};
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (!value) continue;
+        headers[key] = Array.isArray(value) ? value : [value];
+      }
+      return headers;
+    },
+  });
+
+  const { readable, writable } = new IdentityTransformStream();
+  const resBodyWriter = writable.getWriter();
+
+  const res = new MockedResponse({
+    resWriter: (chunk) => {
+      resBodyWriter.write(typeof chunk === "string" ? Buffer.from(chunk) : chunk).catch((err: any) => {
+        if (
+          err.message.includes("WritableStream has been closed") ||
+          err.message.includes("Network connection lost")
+        ) {
+          // safe to ignore
+          return;
+        }
+        console.error("Error in resBodyWriter.write");
+        console.error(err);
+      });
+      return true;
+    },
+  });
+
+  // It's implemented as a no-op, but really it should mark the headers as done
+  res.flushHeaders = () => (res as any).headPromiseResolve();
+
+  // Only allow statusCode to be modified if not sent
+  let { statusCode } = res;
+  Object.defineProperty(res, "statusCode", {
+    get: function () {
+      return statusCode;
+    },
+    set: function (val) {
+      if (this.finished || this.headersSent) {
+        console.error("headers already sent");
+        return;
+      }
+      statusCode = val;
+    },
+  });
+
+  // Make sure the writer is eventually closed
+  ctx.waitUntil((res as any).hasStreamed.finally(() => resBodyWriter.close().catch(() => {})));
+
+  return {
+    res,
+    req,
+    webResponse: async () => {
+      await res.headPromise;
+      // TODO: remove this once streaming with compression is working nicely
+      res.setHeader("content-encoding", "identity");
+      return new Response(NON_BODY_RESPONSES.has(res.statusCode) ? null : readable, {
+        status: res.statusCode,
+        headers: (res as any).headers,
+      });
+    },
+  };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@opennextjs/cloudflare",
+  "description": "Cloudflare builder for next apps",
+  "version": "0.0.0-5454280",
+  "bin": "dist/index.mjs",
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flarelabs-net/poc-next.git",
+    "directory": "builder"
+  },
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "next.js"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/flarelabs-net/poc-next/issues"
+  },
+  "homepage": "https://github.com/flarelabs-net/poc-next",
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240909.0",
+    "@types/node": "^22.2.0",
+    "esbuild": "^0.23.0",
+    "glob": "^11.0.0",
+    "next": "14.2.5",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch src"
+  }
+}