@edgeone/opennextjs-pages 0.0.1

package/dist/build/content/server.js

@@ -0,0 +1,236 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "../../esm-chunks/chunk-5J3FID2N.js";
+import {
+  trace,
+  wrapTracer
+} from "../../esm-chunks/chunk-FKDTZJRV.js";
+import {
+  require_semver
+} from "../../esm-chunks/chunk-TLQCAGE2.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/content/server.ts
+import { existsSync } from "node:fs";
+import {
+  access,
+  cp,
+  mkdir,
+  readdir,
+  readFile,
+  readlink,
+  symlink,
+  writeFile
+} from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, resolve, sep } from "node:path";
+import { join as posixJoin, sep as posixSep } from "node:path/posix";
+var import_fast_glob = __toESM(require_out(), 1);
+var import_semver = __toESM(require_semver(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var RUN_CONFIG_FILE = "run-config.json";
+var toPosixPath = (path) => path.split(sep).join(posixSep);
+function isError(error) {
+  return error instanceof Error;
+}
+var copyNextServerCode = async (ctx) => {
+  const reqServerFilesPath = join(
+    ctx.standaloneRootDir,
+    ctx.relativeAppDir,
+    ctx.requiredServerFiles.config.distDir,
+    "required-server-files.json"
+  );
+  try {
+    await access(reqServerFilesPath);
+  } catch (error) {
+    if (isError(error) && error.code === "ENOENT") {
+      ctx.failBuild(
+        `Failed creating server handler. required-server-files.json file not found at expected location "${reqServerFilesPath}". Your repository setup is currently not yet supported.`
+      );
+    } else {
+      throw error;
+    }
+  }
+  const reqServerFiles = JSON.parse(
+    await readFile(reqServerFilesPath, "utf-8")
+  );
+  if (toPosixPath(ctx.distDir).replace(new RegExp(`^${ctx.relativeAppDir}/?`), "") !== reqServerFiles.config.distDir) {
+    reqServerFiles.config.distDir = ctx.nextDistDir;
+    await writeFile(reqServerFilesPath, JSON.stringify(reqServerFiles));
+  }
+  await mkdir(ctx.serverHandlerDir, { recursive: true });
+  await writeFile(
+    join(ctx.serverHandlerDir, RUN_CONFIG_FILE),
+    JSON.stringify({
+      nextConfig: reqServerFiles.config,
+      // only enable setting up 'use cache' handler when Next.js supports CacheHandlerV2 as we don't have V1 compatible implementation
+      // see https://github.com/vercel/next.js/pull/76687 first released in v15.3.0-canary.13
+      enableUseCacheHandler: ctx.nextVersion ? (0, import_semver.satisfies)(ctx.nextVersion, ">=15.3.0-canary.13", {
+        includePrerelease: true
+      }) : false
+    }),
+    "utf-8"
+  );
+  const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
+  const nextFolder = toPosixPath(ctx.distDir) === toPosixPath(ctx.buildConfig.distDir) ? ctx.distDir : ctx.nextDistDir;
+  const destDir = join(ctx.serverHandlerDir, nextFolder);
+  const paths = await (0, import_fast_glob.default)(
+    [`*`, `server/*`, `server/**/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
+    {
+      cwd: srcDir,
+      extglob: true
+    }
+  );
+  await Promise.all(
+    paths.map(async (path) => {
+      const srcPath = join(srcDir, path);
+      const destPath = join(destDir, path);
+      if (path === "server/middleware-manifest.json") {
+        try {
+          await replaceMiddlewareManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch middleware manifest file", { cause: error });
+        }
+        return;
+      }
+      await cp(srcPath, destPath, { recursive: true, force: true });
+    })
+  );
+};
+async function recreateNodeModuleSymlinks(src, dest, org) {
+  const dirents = await readdir(join(src, org || ""), { withFileTypes: true });
+  await Promise.all(
+    dirents.map(async (dirent) => {
+      if (dirent.name.startsWith("@")) {
+        return recreateNodeModuleSymlinks(src, dest, dirent.name);
+      }
+      if (dirent.isSymbolicLink()) {
+        const symlinkSrc = join(dest, org || "", dirent.name);
+        const symlinkTarget = await readlink(join(src, org || "", dirent.name));
+        const symlinkDest = join(dest, org || "", symlinkTarget);
+        if (existsSync(symlinkDest) && !existsSync(symlinkSrc)) {
+          if (org) {
+            await mkdir(join(dest, org), { recursive: true });
+          }
+          await symlink(symlinkTarget, symlinkSrc);
+        }
+      }
+    })
+  );
+}
+var nextInternalModuleReplacements = [
+  {
+    // standalone is loading expensive Telemetry module that is not actually used
+    // so this replace that module with lightweight no-op shim that doesn't load additional modules
+    // see https://github.com/vercel/next.js/pull/63574 that removed need for this shim
+    ongoing: false,
+    minVersion: "13.5.0-canary.0",
+    // perf released in https://github.com/vercel/next.js/releases/tag/v14.2.0-canary.43
+    maxVersion: "14.2.0-canary.42",
+    nextModule: "next/dist/telemetry/storage.js",
+    shimModule: "./next-shims/telemetry-storage.cjs"
+  }
+];
+function getPatchesToApply(nextVersion, patches = nextInternalModuleReplacements) {
+  return patches.filter((patch) => {
+    if ((0, import_semver.lt)(nextVersion, patch.minVersion)) {
+      return false;
+    }
+    if (patch.ongoing) {
+      if ((0, import_semver.prerelease)(nextVersion)) {
+        return true;
+      }
+      return (0, import_semver.lte)(nextVersion, patch.maxStableVersion);
+    }
+    return (0, import_semver.lte)(nextVersion, patch.maxVersion);
+  });
+}
+async function patchNextModules(ctx, nextVersion, serverHandlerRequireResolve) {
+  const moduleReplacementsToApply = getPatchesToApply(nextVersion);
+  if (moduleReplacementsToApply.length !== 0) {
+    await Promise.all(
+      moduleReplacementsToApply.map(async ({ nextModule, shimModule }) => {
+        try {
+          const nextModulePath = serverHandlerRequireResolve(nextModule);
+          const shimModulePath = posixJoin(ctx.pluginDir, "dist", "build", "content", shimModule);
+          await cp(shimModulePath, nextModulePath, { force: true });
+        } catch {
+        }
+      })
+    );
+  }
+}
+var copyNextDependencies = async (ctx) => {
+  const entries = await readdir(ctx.standaloneDir);
+  const promises = entries.map(async (entry) => {
+    if (entry === ctx.nextDistDir) {
+      return;
+    }
+    const src = join(ctx.standaloneDir, entry);
+    const dest = join(ctx.serverHandlerDir, entry);
+    await cp(src, dest, { recursive: true, verbatimSymlinks: true, force: true });
+    if (entry === "node_modules") {
+      await recreateNodeModuleSymlinks(ctx.resolveFromSiteDir("node_modules"), dest);
+    }
+  });
+  const rootSrcDir = join(ctx.standaloneRootDir, "node_modules");
+  const rootDestDir = join(ctx.serverHandlerRootDir, "node_modules");
+  if (existsSync(rootSrcDir) && ctx.standaloneRootDir !== ctx.standaloneDir) {
+    promises.push(
+      cp(rootSrcDir, rootDestDir, { recursive: true, verbatimSymlinks: true }).then(
+        () => recreateNodeModuleSymlinks(resolve("node_modules"), rootDestDir)
+      )
+    );
+  }
+  await Promise.all(promises);
+  const serverHandlerRequire = createRequire(posixJoin(ctx.serverHandlerDir, ":internal:"));
+  if (ctx.nextVersion) {
+    await patchNextModules(ctx, ctx.nextVersion, serverHandlerRequire.resolve);
+  }
+  try {
+    const nextEntryAbsolutePath = serverHandlerRequire.resolve("next");
+    const nextRequire = createRequire(nextEntryAbsolutePath);
+    nextRequire.resolve("styled-jsx");
+  } catch {
+    throw new Error(
+      "node_modules are not installed correctly, if you are using pnpm please set the public hoist pattern to: `public-hoist-pattern[]=*`.\n"
+    );
+  }
+};
+var replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
+  };
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
+};
+var verifyHandlerDirStructure = async (ctx) => {
+  const { nextConfig } = JSON.parse(
+    await readFile(join(ctx.serverHandlerDir, RUN_CONFIG_FILE), "utf-8")
+  );
+  const expectedBuildIDPath = join(ctx.serverHandlerDir, nextConfig.distDir, "BUILD_ID");
+  if (!existsSync(expectedBuildIDPath)) {
+    ctx.failBuild(
+      `Failed creating server handler. BUILD_ID file not found at expected location "${expectedBuildIDPath}".`
+    );
+  }
+};
+export {
+  RUN_CONFIG_FILE,
+  copyNextDependencies,
+  copyNextServerCode,
+  getPatchesToApply,
+  verifyHandlerDirStructure
+};

package/dist/build/content/static.js

@@ -0,0 +1,119 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "../../esm-chunks/chunk-5J3FID2N.js";
+import {
+  trace,
+  wrapTracer
+} from "../../esm-chunks/chunk-FKDTZJRV.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/content/static.ts
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, join, dirname } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var copyStaticContent = async (ctx) => {
+  return tracer.withActiveSpan("copyStaticContent", async () => {
+    const srcDir = join(ctx.publishDir, "server/pages");
+    const destDir = ctx.staticDir;
+    const paths = await (0, import_fast_glob.default)("**/*.+(html|json)", {
+      cwd: srcDir,
+      extglob: true
+    });
+    try {
+      await mkdir(destDir, { recursive: true });
+      await Promise.all(
+        paths.filter((path) => !paths.includes(`${path.slice(0, -5)}.json`)).map(async (path) => {
+          const html = await readFile(join(srcDir, path));
+          await mkdir(dirname(join(destDir, path)), { recursive: true });
+          await writeFile(join(destDir, path), html);
+        })
+      );
+    } catch (error) {
+      ctx.failBuild("Failed assembling static pages for upload", error);
+    }
+  });
+};
+var copyStaticAssets = async (ctx) => {
+  return tracer.withActiveSpan(
+    "copyStaticAssets",
+    async (span) => {
+      try {
+        const { basePath } = await ctx.getRoutesManifest();
+        if (existsSync(ctx.resolveFromSiteDir("public"))) {
+          await cp(
+            ctx.resolveFromSiteDir("public"),
+            join(ctx.staticDir, basePath),
+            {
+              recursive: true
+            }
+          );
+        }
+        if (existsSync(join(ctx.publishDir, "static"))) {
+          await cp(
+            join(ctx.publishDir, "static"),
+            join(ctx.staticDir, basePath, "_next/static"),
+            {
+              recursive: true
+            }
+          );
+        }
+      } catch (error) {
+        span.end();
+        ctx.failBuild("Failed copying static assets", error);
+      }
+    }
+  );
+};
+var copyStaticExport = async (ctx) => {
+  await tracer.withActiveSpan("copyStaticExport", async () => {
+    if (!ctx.exportDetail?.outDirectory) {
+      ctx.failBuild("Export directory not found");
+    }
+    try {
+      await cp(ctx.exportDetail.outDirectory, ctx.staticDir, {
+        recursive: true
+      });
+    } catch (error) {
+      ctx.failBuild("Failed copying static export", error);
+    }
+  });
+};
+var publishStaticDir = async (ctx) => {
+  try {
+    await rm(ctx.tempPublishDir, { recursive: true, force: true });
+    await mkdir(basename(ctx.tempPublishDir), { recursive: true });
+    await rename(ctx.publishDir, ctx.tempPublishDir);
+    await rename(ctx.staticDir, ctx.publishDir);
+  } catch (error) {
+    ctx.failBuild(
+      "Failed publishing static content",
+      error instanceof Error ? { error } : {}
+    );
+  }
+};
+var unpublishStaticDir = async (ctx) => {
+  try {
+    if (existsSync(ctx.tempPublishDir)) {
+      await rename(ctx.publishDir, ctx.staticDir);
+      await rename(ctx.tempPublishDir, ctx.publishDir);
+    }
+  } catch {
+  }
+};
+export {
+  copyStaticAssets,
+  copyStaticContent,
+  copyStaticExport,
+  publishStaticDir,
+  unpublishStaticDir
+};

package/dist/build/functions/server.js

@@ -0,0 +1,133 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "../../esm-chunks/chunk-5J3FID2N.js";
+import {
+  trace,
+  wrapTracer
+} from "../../esm-chunks/chunk-FKDTZJRV.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/server.ts
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { join as posixJoin } from "node:path/posix";
+var import_fast_glob = __toESM(require_out(), 1);
+import {
+  copyNextDependencies,
+  copyNextServerCode,
+  verifyHandlerDirStructure
+} from "../content/server.js";
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var copyHandlerDependencies = async (ctx) => {
+  const promises = [];
+  const { included_files: includedFiles = [] } = {};
+  includedFiles.push(
+    posixJoin(ctx.relativeAppDir, ".env"),
+    posixJoin(ctx.relativeAppDir, ".env.production"),
+    posixJoin(ctx.relativeAppDir, ".env.local"),
+    posixJoin(ctx.relativeAppDir, ".env.production.local")
+  );
+  const resolvedFiles = await Promise.all(
+    includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
+  );
+  for (const filePath of resolvedFiles.flat()) {
+    promises.push(
+      cp(
+        join(process.cwd(), filePath),
+        // the serverHandlerDir is aware of the dist dir.
+        // The distDir must not be the package path therefore we need to rely on the
+        // serverHandlerDir instead of the serverHandlerRootDir
+        // therefore we need to remove the package path from the filePath
+        join(ctx.serverHandlerDir, relative(ctx.relativeAppDir, filePath)),
+        {
+          recursive: true,
+          force: true
+        }
+      )
+    );
+  }
+  promises.push(
+    writeFile(
+      join(ctx.serverHandlerRuntimeModulesDir, "package.json"),
+      JSON.stringify({ type: "module" })
+    )
+  );
+  const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+  for (const filePath of fileList) {
+    promises.push(
+      cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerRuntimeModulesDir, filePath), {
+        recursive: true,
+        force: true
+      })
+    );
+  }
+  await Promise.all(promises);
+};
+var writeHandlerManifest = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerRootDir, `app.json`),
+    JSON.stringify({
+      config: {
+        name: "Next.js Server Handler",
+        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
+        nodeBundler: "none",
+        // the folders can vary in monorepos based on the folder structure of the user so we have to glob all
+        includedFiles: ["**"],
+        includedFilesBasePath: ctx.serverHandlerRootDir
+      },
+      version: 1
+    }),
+    "utf-8"
+  );
+};
+var applyTemplateVariables = (template, variables) => {
+  return Object.entries(variables).reduce((acc, [key, value]) => {
+    return acc.replaceAll(key, value);
+  }, template);
+};
+var getHandlerFile = async (ctx) => {
+  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
+  const templateVariables = {
+    "{{useRegionalBlobs}}": ctx.useRegionalBlobs.toString()
+  };
+  if (ctx.relativeAppDir.length !== 0) {
+    const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
+    console.log("ctx.lambdaWorkingDirectory", ctx.lambdaWorkingDirectory);
+    console.log("ctx.nextServerHandler", ctx.nextServerHandler);
+    templateVariables["{{cwd}}"] = posixJoin(ctx.lambdaWorkingDirectory);
+    templateVariables["{{nextServerHandler}}"] = posixJoin(ctx.nextServerHandler);
+    return applyTemplateVariables(template, templateVariables);
+  }
+  return applyTemplateVariables(
+    await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8"),
+    templateVariables
+  );
+};
+var writeHandlerFile = async (ctx) => {
+  const handler = await getHandlerFile(ctx);
+  await writeFile(join(ctx.serverHandlerRootDir, `index.mjs`), handler);
+};
+var clearStaleServerHandlers = async (ctx) => {
+  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
+};
+var createServerHandler = async (ctx) => {
+  await mkdir(join(ctx.serverHandlerRuntimeModulesDir), { recursive: true });
+  await copyNextServerCode(ctx);
+  await copyNextDependencies(ctx);
+  await copyHandlerDependencies(ctx);
+  await writeHandlerManifest(ctx);
+  await writeHandlerFile(ctx);
+  await verifyHandlerDirStructure(ctx);
+};
+export {
+  clearStaleServerHandlers,
+  createServerHandler
+};