@opennextjs/cloudflare 0.2.0 → 0.3.0

package/dist/cli/build/utils/extract-project-env-vars.spec.js

@@ -0,0 +1,57 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+import mockFs from "mock-fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { extractProjectEnvVars } from "./extract-project-env-vars";
+const options = { monorepoRoot: "", appPath: "" };
+describe("extractProjectEnvVars", () => {
+    beforeEach(() => {
+        mockFs({
+            ".env": "ENV_VAR=value",
+            ".env.local": "ENV_LOCAL_VAR=value",
+            ".env.development": "ENV_DEV_VAR=value",
+            ".env.development.local": "ENV_DEV_LOCAL_VAR=value",
+            ".env.production": "ENV_PROD_VAR=value",
+            ".env.production.local": "ENV_PROD_LOCAL_VAR=value",
+        });
+    });
+    afterEach(() => mockFs.restore());
+    it("should extract production env vars", () => {
+        const result = extractProjectEnvVars("production", options);
+        expect(result).toEqual({
+            ENV_LOCAL_VAR: "value",
+            ENV_PROD_LOCAL_VAR: "value",
+            ENV_PROD_VAR: "value",
+            ENV_VAR: "value",
+        });
+    });
+    it("should extract development env vars", () => {
+        writeFileSync(".dev.vars", 'NEXTJS_ENV = "development"');
+        const result = extractProjectEnvVars("development", options);
+        expect(result).toEqual({
+            ENV_LOCAL_VAR: "value",
+            ENV_DEV_LOCAL_VAR: "value",
+            ENV_DEV_VAR: "value",
+            ENV_VAR: "value",
+        });
+    });
+    it("should override env vars with those in a local file", () => {
+        writeFileSync(".env.production.local", "ENV_PROD_VAR=overridden");
+        const result = extractProjectEnvVars("production", options);
+        expect(result).toEqual({
+            ENV_LOCAL_VAR: "value",
+            ENV_PROD_VAR: "overridden",
+            ENV_VAR: "value",
+        });
+    });
+    it("should support referencing variables", () => {
+        appendFileSync(".env.production.local", "\nENV_PROD_LOCAL_VAR_REF=$ENV_PROD_LOCAL_VAR");
+        const result = extractProjectEnvVars("production", options);
+        expect(result).toEqual({
+            ENV_LOCAL_VAR: "value",
+            ENV_PROD_LOCAL_VAR: "value",
+            ENV_PROD_LOCAL_VAR_REF: "value",
+            ENV_PROD_VAR: "value",
+            ENV_VAR: "value",
+        });
+    });
+});

package/dist/cli/build/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./extract-project-env-vars.js";
+export * from "./normalize-path.js";
+export * from "./ts-parse-file.js";

package/dist/cli/build/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./extract-project-env-vars.js";
+export * from "./normalize-path.js";
+export * from "./ts-parse-file.js";

package/dist/cli/build/utils/normalize-path.d.ts

@@ -0,0 +1 @@
+export declare function normalizePath(path: string): string;

package/dist/cli/build/utils/normalize-path.js

@@ -0,0 +1,4 @@
+import { posix, sep } from "node:path";
+export function normalizePath(path) {
+    return path.replaceAll(sep, posix.sep);
+}

package/dist/cli/build/utils/read-paths-recursively.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Recursively reads all file paths in a directory.
+ *
+ * @param dir Directory to recursively read from.
+ * @returns Array of all paths for all files in a directory.
+ */
+export declare function readPathsRecursively(dir: string): string[];

package/dist/cli/build/utils/read-paths-recursively.js

@@ -0,0 +1,20 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Recursively reads all file paths in a directory.
+ *
+ * @param dir Directory to recursively read from.
+ * @returns Array of all paths for all files in a directory.
+ */
+export function readPathsRecursively(dir) {
+    try {
+        const files = readdirSync(dir, { withFileTypes: true });
+        return files.flatMap((file) => {
+            const filePath = join(dir, file.name);
+            return file.isDirectory() ? readPathsRecursively(filePath) : filePath;
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cli/build/utils/ts-parse-file.d.ts

@@ -0,0 +1,8 @@
+import * as ts from "ts-morph";
+/**
+ * Parses a javascript file using ts-morph.
+ *
+ * @param fileContent the content of the file to parse
+ * @returns the parsed result
+ */
+export declare function tsParseFile(fileContent: string): ts.SourceFile;

package/dist/cli/build/utils/ts-parse-file.js

@@ -0,0 +1,12 @@
+import * as ts from "ts-morph";
+/**
+ * Parses a javascript file using ts-morph.
+ *
+ * @param fileContent the content of the file to parse
+ * @returns the parsed result
+ */
+export function tsParseFile(fileContent) {
+    const project = new ts.Project();
+    const sourceFile = project.createSourceFile("file.js", fileContent);
+    return sourceFile;
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,41 @@
+export type Config = {
+    build: {
+        skipNextBuild: boolean;
+        shouldMinify: boolean;
+    };
+    paths: {
+        source: {
+            root: string;
+            dotNext: string;
+            standaloneRoot: string;
+        };
+        output: {
+            root: string;
+            assets: string;
+            dotNext: string;
+            standaloneRoot: string;
+            standaloneApp: string;
+            standaloneAppDotNext: string;
+            standaloneAppServer: string;
+        };
+        internal: {
+            package: string;
+            templates: string;
+        };
+    };
+    internalPackageName: string;
+};
+/**
+ * Computes the configuration.
+ *
+ * @param projectOpts The options for the project
+ * @returns The configuration, see `Config`
+ */
+export declare function getConfig(projectOpts: ProjectOptions): Config;
+export declare function containsDotNextDir(folder: string): boolean;
+export type ProjectOptions = {
+    sourceDir: string;
+    outputDir: string;
+    skipNextBuild: boolean;
+    minify: boolean;
+};

package/dist/cli/config.js

@@ -0,0 +1,92 @@
+import { readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+const PACKAGE_NAME = "@opennextjs/cloudflare";
+/**
+ * Computes the configuration.
+ *
+ * @param projectOpts The options for the project
+ * @returns The configuration, see `Config`
+ */
+export function getConfig(projectOpts) {
+    const sourceDirDotNext = join(projectOpts.sourceDir, ".next");
+    const dotNext = join(projectOpts.outputDir, ".next");
+    const appPath = getNextjsApplicationPath(dotNext).replace(/\/$/, "");
+    const standaloneRoot = join(dotNext, "standalone");
+    const standaloneApp = join(standaloneRoot, appPath);
+    const standaloneAppDotNext = join(standaloneApp, ".next");
+    const standaloneAppServer = join(standaloneAppDotNext, "server");
+    const nodeModules = join(standaloneApp, "node_modules");
+    const internalPackage = join(nodeModules, ...PACKAGE_NAME.split("/"));
+    const internalTemplates = join(internalPackage, "cli", "templates");
+    return {
+        build: {
+            skipNextBuild: projectOpts.skipNextBuild,
+            shouldMinify: projectOpts.minify,
+        },
+        paths: {
+            source: {
+                root: projectOpts.sourceDir,
+                dotNext: sourceDirDotNext,
+                standaloneRoot: join(sourceDirDotNext, "standalone"),
+            },
+            output: {
+                root: projectOpts.outputDir,
+                assets: join(projectOpts.outputDir, "assets"),
+                dotNext,
+                standaloneRoot,
+                standaloneApp,
+                standaloneAppDotNext,
+                standaloneAppServer,
+            },
+            internal: {
+                package: internalPackage,
+                templates: internalTemplates,
+            },
+        },
+        internalPackageName: PACKAGE_NAME,
+    };
+}
+export function containsDotNextDir(folder) {
+    try {
+        return statSync(join(folder, ".next")).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * It basically tries to find the path that the application is under inside the `.next/standalone` directory, using the `.next/server` directory
+ * presence as the condition that needs to be met.
+ *
+ * For example:
+ *  When I build the api application the `.next/server` directory is located in:
+ *  `<dotNextDir>/standalone/next-apps/api/.next/server`
+ *  and the function here given the `dotNextDir` returns `next-apps/api`
+ */
+function getNextjsApplicationPath(dotNextDir) {
+    const serverPath = findServerParentPath(dotNextDir);
+    if (!serverPath) {
+        throw new Error(`Unexpected Error: no \`.next/server\` folder could be found in \`${serverPath}\``);
+    }
+    return relative(join(dotNextDir, "standalone"), serverPath);
+}
+function findServerParentPath(parentPath) {
+    try {
+        if (statSync(join(parentPath, ".next", "server")).isDirectory()) {
+            return parentPath;
+        }
+    }
+    catch {
+        /* empty */
+    }
+    const folders = readdirSync(parentPath);
+    for (const folder of folders) {
+        const subFolder = join(parentPath, folder);
+        if (statSync(join(parentPath, folder)).isDirectory()) {
+            const dirServerPath = findServerParentPath(subFolder);
+            if (dirServerPath) {
+                return dirServerPath;
+            }
+        }
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { getArgs } from "./args.js";
+import { build } from "./build/index.js";
+const nextAppDir = process.cwd();
+const { skipNextBuild, outputDir, minify } = getArgs();
+await build({
+    sourceDir: nextAppDir,
+    outputDir: resolve(outputDir ?? nextAppDir, ".open-next"),
+    skipNextBuild,
+    minify,
+});

package/dist/cli/templates/shims/empty.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/cli/templates/shims/env.d.ts

@@ -0,0 +1 @@
+export declare function loadEnvConfig(): void;

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

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

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,51 @@
+// 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.ts → throw.js}

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

package/dist/cli/templates/worker.d.ts

@@ -0,0 +1,5 @@
+declare const _default: ExportedHandler<{
+    ASSETS: Fetcher;
+    NEXTJS_ENV?: string;
+}>;
+export default _default;

package/dist/cli/templates/worker.js

@@ -0,0 +1,67 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+// @ts-expect-error: resolved by wrangler build
+import { handler as middlewareHandler } from "./middleware/handler.mjs";
+// @ts-expect-error: resolved by wrangler build
+import { handler as serverHandler } from "./server-functions/default/handler.mjs";
+const cloudflareContextALS = new AsyncLocalStorage();
+// Note: this symbol needs to be kept in sync with the one defined in `src/api/get-cloudflare-context.ts`
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+globalThis[Symbol.for("__cloudflare-context__")] = new Proxy({}, {
+    ownKeys: () => Reflect.ownKeys(cloudflareContextALS.getStore()),
+    getOwnPropertyDescriptor: (_, ...args) => Reflect.getOwnPropertyDescriptor(cloudflareContextALS.getStore(), ...args),
+    get: (_, property) => Reflect.get(cloudflareContextALS.getStore(), property),
+    set: (_, property, value) => Reflect.set(cloudflareContextALS.getStore(), property, value),
+});
+export default {
+    async fetch(request, env, ctx) {
+        return cloudflareContextALS.run({ env, ctx, cf: request.cf }, async () => {
+            const url = new URL(request.url);
+            if (process.env.__PROCESS_ENV_POPULATED !== "1") {
+                await populateProcessEnv(url, env.NEXTJS_ENV);
+                process.env.__PROCESS_ENV_POPULATED = "1";
+            }
+            if (url.pathname === "/_next/image") {
+                const imageUrl = url.searchParams.get("url") ?? "";
+                return imageUrl.startsWith("/")
+                    ? env.ASSETS.fetch(new URL(imageUrl, request.url))
+                    : fetch(imageUrl, { cf: { cacheEverything: true } });
+            }
+            // The Middleware handler can return either a `Response` or a `Request`:
+            // - `Response`s should be returned early
+            // - `Request`s are handled by the Next server
+            const reqOrResp = await middlewareHandler(request, env, ctx);
+            if (reqOrResp instanceof Response) {
+                return reqOrResp;
+            }
+            return serverHandler(reqOrResp, env, ctx);
+        });
+    },
+};
+/**
+ * Populate process.env with:
+ * - the variables from Next .env* files
+ * - the origin resolver information
+ *
+ * Note that cloudflare env string values are copied by the middleware handler.
+ */
+async function populateProcessEnv(url, nextJsEnv) {
+    if (process.env.__PROCESS_ENV_POPULATED === "1") {
+        return;
+    }
+    // @ts-expect-error: resolved by wrangler build
+    const nextEnvVars = await import("./.env.mjs");
+    const mode = nextJsEnv ?? "production";
+    if (nextEnvVars[mode]) {
+        for (const key in nextEnvVars[mode]) {
+            process.env[key] = nextEnvVars[mode][key];
+        }
+    }
+    // Set the default Origin for the origin resolver.
+    process.env.OPEN_NEXT_ORIGIN = JSON.stringify({
+        default: {
+            host: url.hostname,
+            protocol: url.protocol.slice(0, -1),
+            port: url.port,
+        },
+    });
+}

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "0.2.0",
-  "bin": "dist/cli/index.mjs",
-  "main": "./dist/api/index.mjs",
-  "types": "./dist/api/index.d.mts",
+  "version": "0.3.0",
+  "type": "module",
+  "bin": {
+    "opennextjs-cloudflare": "dist/cli/index.js"
+  },
+  "main": "./dist/api/index.js",
+  "types": "./dist/api/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/api/index.mjs",
-      "types": "./dist/api/index.d.mts"
+      "import": "./dist/api/index.js",
+      "types": "./dist/api/index.d.ts",
+      "default": "./dist/api/index.js"
+    },
+    "./*": {
+      "import": "./dist/api/*.js",
+      "types": "./dist/api/*.d.ts",
+      "default": "./dist/api/*.js"
     }
   },
   "files": [
@@ -21,6 +30,7 @@
     "directory": "packages/cloudflare"
   },
   "keywords": [
+    "opennextjs-cloudflare",
     "cloudflare",
     "workers",
     "next.js"
@@ -37,25 +47,32 @@
     "@types/node": "^22.2.0",
     "esbuild": "^0.23.0",
     "eslint": "^9.11.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unicorn": "^55.0.0",
     "glob": "^11.0.0",
     "globals": "^15.9.0",
     "next": "14.2.11",
     "package-manager-detector": "^0.2.0",
-    "tsup": "^8.2.4",
     "typescript": "^5.5.4",
     "typescript-eslint": "^8.7.0",
-    "vitest": "^2.1.1"
+    "vitest": "^2.1.1",
+    "mock-fs": "^5.4.1",
+    "@types/mock-fs": "^4.13.4"
   },
   "dependencies": {
-    "ts-morph": "^23.0.0"
+    "@opennextjs/aws": "https://pkg.pr.new/@opennextjs/aws@684",
+    "ts-morph": "^23.0.0",
+    "@dotenvx/dotenvx": "1.31.0"
   },
   "peerDependencies": {
-    "wrangler": "^3.78.10"
+    "rimraf": "^6.0.1",
+    "wrangler": "^3.99.0"
   },
   "scripts": {
-    "build": "tsup",
-    "build:watch": "tsup --watch src",
+    "clean": "rimraf dist",
+    "build": "pnpm clean && tsc",
+    "build:watch": "tsc -w",
     "lint:check": "eslint",
     "lint:fix": "eslint --fix",
     "ts:check": "tsc --noEmit",

package/dist/api/chunk-VTBEIZPQ.mjs

@@ -1,32 +0,0 @@
-// src/api/get-cloudflare-context.ts
-import "server-only";
-var cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
-async function getCloudflareContext() {
-  const global = globalThis;
-  const cloudflareContext = global[cloudflareContextSymbol];
-  if (!cloudflareContext) {
-    return getCloudflareContextInNextDev();
-  }
-  return cloudflareContext;
-}
-var cloudflareContextInNextDevSymbol = Symbol.for("__next-dev/cloudflare-context__");
-async function getCloudflareContextInNextDev() {
-  const global = globalThis;
-  if (!global[cloudflareContextInNextDevSymbol]) {
-    const { getPlatformProxy } = await import(
-      /* webpackIgnore: true */
-      `${"__wrangler".replaceAll("_", "")}`
-    );
-    const { env, cf, ctx } = await getPlatformProxy();
-    global[cloudflareContextInNextDevSymbol] = {
-      env,
-      cf,
-      ctx
-    };
-  }
-  return global[cloudflareContextInNextDevSymbol];
-}
-
-export {
-  getCloudflareContext
-};

package/dist/api/get-cloudflare-context.mjs

@@ -1,6 +0,0 @@
-import {
-  getCloudflareContext
-} from "./chunk-VTBEIZPQ.mjs";
-export {
-  getCloudflareContext
-};

package/dist/api/index.d.mts

@@ -1 +0,0 @@
-export { CloudflareContext, getCloudflareContext } from './get-cloudflare-context.mjs';

package/dist/api/index.mjs

@@ -1,6 +0,0 @@
-import {
-  getCloudflareContext
-} from "./chunk-VTBEIZPQ.mjs";
-export {
-  getCloudflareContext
-};

package/dist/cli/constants/incremental-cache.ts

@@ -1,8 +0,0 @@
-export const RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
-export const RSC_SUFFIX = ".rsc";
-export const NEXT_DATA_SUFFIX = ".json";
-export const NEXT_META_SUFFIX = ".meta";
-export const NEXT_BODY_SUFFIX = ".body";
-export const NEXT_HTML_SUFFIX = ".html";
-
-export const SEED_DATA_DIR = "cdn-cgi/_cf_seed_data";