add new feature in config for copying files to a specified server function after the build is done

packages/open-next/package.json

@@ -50,6 +50,7 @@
     "chalk": "^5.3.0",
     "esbuild": "0.19.2",
     "express": "5.0.1",
+    "glob": "catalog:",
     "path-to-regexp": "^6.3.0",
     "urlpattern-polyfill": "^10.0.0",
     "yaml": "^2.7.0"

packages/open-next/src/build/createServerBundle.ts

@@ -329,6 +329,10 @@ CMD ["node", "index.mjs"]
     `,
     );
   }
+
+  if (fnOptions.copyFiles) {
+    buildHelper.copyCustomFiles(fnOptions.copyFiles, outPackagePath);
+  }
 }
 
 function shouldGenerateDockerfile(options: FunctionOptions) {

packages/open-next/src/build/edge/createEdgeBundle.ts

@@ -23,7 +23,11 @@ import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "../../utils/regex.js";
 import { type BuildOptions, isEdgeRuntime } from "../helper.js";
-import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
+import {
+  copyCustomFiles,
+  copyOpenNextConfig,
+  esbuildAsync,
+} from "../helper.js";
 
 type Override = OverrideOptions & {
   originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
@@ -221,6 +225,10 @@ export async function generateEdgeBundle(
     name,
     additionalPlugins,
   });
+
+  if (fnOptions.copyFiles) {
+    copyCustomFiles(fnOptions.copyFiles, outputDir);
+  }
 }
 
 /**

packages/open-next/src/build/helper.ts

@@ -5,7 +5,9 @@ import url from "node:url";
 
 import type { BuildOptions as ESBuildOptions } from "esbuild";
 import { build as buildAsync, buildSync } from "esbuild";
+import { globSync } from "glob";
 import type {
+  CopyFile,
   DefaultOverrideOptions,
   OpenNextConfig,
 } from "types/open-next.js";
@@ -440,3 +442,57 @@ export async function isEdgeRuntime(
 export function getPackagePath(options: BuildOptions) {
   return path.relative(options.monorepoRoot, options.appBuildOutputPath);
 }
+
+/**
+ * Copy files that are specified in the `copyFiles` property into the server functions output directory.
+ *
+ * @param copyFiles - Array of files to copy. Each file should have a `srcPath` and `dstPath` property.
+ * @param outputPath - Path to the output directory.
+ */
+export function copyCustomFiles(copyFiles: CopyFile[], outputPath: string) {
+  copyFiles.forEach(({ srcPath, dstPath }) => {
+    // Find all files matching the pattern
+    const matchedFiles = globSync(srcPath, {
+      nodir: true,
+      windowsPathsNoEscape: true,
+    });
+
+    if (matchedFiles.length === 0) {
+      logger.warn(`No files found for pattern: ${srcPath}`);
+      return;
+    }
+
+    if (matchedFiles.length === 1) {
+      // Single file match - use dstPath as it is
+      const srcFile = matchedFiles[0];
+      const fullDstPath = path.join(outputPath, dstPath);
+
+      copyFile(srcFile, fullDstPath);
+    } else {
+      // Multiple files matched, dstPath will become a directory
+      matchedFiles.forEach((srcFile) => {
+        const filename = path.basename(srcFile);
+        const fullDstPath = path.join(outputPath, dstPath, filename);
+        copyFile(srcFile, fullDstPath);
+      });
+    }
+  });
+}
+/**
+ * Copy a file to the destination path.
+ *
+ * @param srcFile - Path to the source file.
+ * @param fullDstPath - Path to the destination file.
+ */
+function copyFile(srcFile: string, fullDstPath: string) {
+  const dstDir = path.dirname(fullDstPath);
+
+  if (!fs.existsSync(dstDir)) {
+    fs.mkdirSync(dstDir, { recursive: true });
+  }
+  if (fs.existsSync(fullDstPath)) {
+    logger.warn(`File already exists: ${fullDstPath}. It will be overwritten.`);
+  }
+  fs.copyFileSync(srcFile, fullDstPath);
+  logger.debug(`Copied ${srcFile} to ${fullDstPath}`);
+}

packages/open-next/src/types/open-next.ts

@@ -290,6 +290,15 @@ export interface DefaultFunctionOptions<
   install?: InstallOptions;
 }
 
+/**
+ * @srcPath The path to the file to copy. Can be absolute or relative path. Can use glob pattern.
+ * @dstPath The relative path to the destination in the server function. Will become a directory if multiple files are found in srcPath.
+ */
+export interface CopyFile {
+  srcPath: string;
+  dstPath: string;
+}
+
 export interface FunctionOptions extends DefaultFunctionOptions {
   /**
    * Runtime used
@@ -313,6 +322,21 @@ export interface FunctionOptions extends DefaultFunctionOptions {
    * @deprecated This is not supported in 14.2+
    */
   experimentalBundledNextServer?: boolean;
+  /**
+   * Manually copy files into the server function after the build.
+   * If multiple files are found with srcPath, dstPath will become a directory.
+   * @copyFiles The files to copy. Is an array of objects with srcPath and dstPath.
+   * @example
+   * ```ts
+   * copyFiles: [
+   *   {
+   *     srcPath: 'relativefile.txt',
+   *     dstPath: '/this/is/a/folder.txt',
+   *   },
+   * ]
+   * ```
+   */
+  copyFiles?: CopyFile[];
 }
 
 export type RouteTemplate =

packages/tests-unit/package.json

@@ -11,9 +11,11 @@
     "@opennextjs/aws": "workspace:*"
   },
   "devDependencies": {
+    "@types/mock-fs": "^4.13.4",
     "@types/testing-library__jest-dom": "^5.14.9",
     "@vitest/coverage-v8": "^2.1.3",
     "jsdom": "^22.1.0",
+    "mock-fs": "^5.5.0",
     "vite": "5.4.9",
     "vite-tsconfig-paths": "^5.0.1",
     "vitest": "^2.1.3"

packages/tests-unit/tests/build/helper.test.ts

@@ -1,4 +1,13 @@
-import { compareSemver } from "@opennextjs/aws/build/helper.js";
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  compareSemver,
+  copyCustomFiles,
+} from "@opennextjs/aws/build/helper.js";
+import logger from "@opennextjs/aws/logger.js";
+import mockFs from "mock-fs";
+import { vi } from "vitest";
 
 // We don't need to test canary versions, they are stripped out
 describe("compareSemver", () => {
@@ -65,3 +74,175 @@ describe("compareSemver", () => {
     expect(() => compareSemver("14.0.0", "!=" as any, "14.0.0")).toThrow();
   });
 });
+
+const outputFolder = ".open-next/server-functions/default";
+
+describe("copyFiles", () => {
+  beforeEach(() => {
+    mockFs({
+      "this/is/a/fake/dir": {
+        "some-file24214.txt": "some content",
+        "another-fil321313e.txt": "another content",
+        "empty-file321441.txt": "",
+        "important-js": {
+          "another-important.js": "console.log('important!')",
+        },
+      },
+      "this/is/a/real/dir": {
+        "randomfile.txt": "some content",
+        "another-dirfdsf": {
+          "another-filedsfdsf.txt": "another content",
+        },
+        "empty-file.txtfdsf": "",
+        "imporant-files": {
+          "important.js": "console.log('important!')",
+          "super-important.js": "console.log('super important!')",
+        },
+      },
+      [`${outputFolder}/server`]: {
+        "index.mjs": "globalThis.process.env = {}",
+      },
+    });
+
+    vi.spyOn(fs, "copyFileSync");
+    vi.spyOn(fs, "mkdirSync");
+    vi.spyOn(fs, "readFileSync");
+  });
+
+  afterAll(() => {
+    mockFs.restore();
+    vi.restoreAllMocks();
+  });
+
+  it("should work with a glob, dstPath should become a directory", () => {
+    copyCustomFiles(
+      [
+        {
+          srcPath: "**/*.js",
+          dstPath: "functions",
+        },
+      ],
+      outputFolder,
+    );
+
+    const dstDir = path.join(outputFolder, "functions");
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(3);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(dstDir, { recursive: true });
+    expect(fs.mkdirSync).toHaveBeenCalledTimes(1);
+
+    expect(fs.readdirSync(dstDir)).toEqual([
+      "another-important.js",
+      "important.js",
+      "super-important.js",
+    ]);
+
+    expect(
+      fs.readFileSync(path.join(dstDir, "important.js")).toString(),
+    ).toMatchInlineSnapshot(`"console.log('important!')"`);
+  });
+
+  it("should copy a single file when srcPath matches one file", () => {
+    copyCustomFiles(
+      [
+        {
+          srcPath: "this/is/a/real/dir/randomfile.txt",
+          dstPath: "randomfolder/randomfile.txt",
+        },
+      ],
+      outputFolder,
+    );
+
+    const dstDir = path.join(outputFolder, "randomfolder");
+    expect(fs.mkdirSync).toHaveBeenCalledWith(dstDir, { recursive: true });
+    expect(fs.mkdirSync).toHaveBeenCalledTimes(1);
+
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(1);
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "this/is/a/real/dir/randomfile.txt",
+      path.join(outputFolder, "randomfolder/randomfile.txt"),
+    );
+
+    expect(
+      fs.readFileSync(path.join(outputFolder, "randomfolder/randomfile.txt"), {
+        encoding: "utf-8",
+      }),
+    ).toMatchInlineSnapshot(`"some content"`);
+  });
+
+  it("should work with a glob in a sub directory", () => {
+    copyCustomFiles(
+      [
+        {
+          srcPath: "this/is/a/real/dir/imporant-files/**/*.js",
+          dstPath: "super/functions",
+        },
+      ],
+      outputFolder,
+    );
+
+    expect(fs.mkdirSync).toHaveBeenCalledWith(
+      path.join(outputFolder, "super/functions"),
+      { recursive: true },
+    );
+    expect(fs.mkdirSync).toHaveBeenCalledTimes(1);
+
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(2);
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "this/is/a/real/dir/imporant-files/important.js",
+      path.join(outputFolder, "super/functions/important.js"),
+    );
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "this/is/a/real/dir/imporant-files/super-important.js",
+      path.join(outputFolder, "super/functions/super-important.js"),
+    );
+
+    expect(fs.readdirSync(path.join(outputFolder, "super/functions"))).toEqual([
+      "important.js",
+      "super-important.js",
+    ]);
+    expect(
+      fs.readFileSync(
+        path.join(outputFolder, "super/functions/super-important.js"),
+        { encoding: "utf-8" },
+      ),
+    ).toMatchInlineSnapshot(`"console.log('super important!')"`);
+  });
+  it("should warn when file already exists", () => {
+    const logSpy = vi.spyOn(logger, "warn");
+
+    copyCustomFiles(
+      [
+        {
+          srcPath: "this/is/a/fake/dir/some-file24214.txt",
+          dstPath: "server/index.mjs",
+        },
+      ],
+      outputFolder,
+    );
+
+    const fullDstPath = path.join(outputFolder, "server/index.mjs");
+    expect(logSpy).toHaveBeenCalledWith(
+      `File already exists: ${fullDstPath}. It will be overwritten.`,
+    );
+    logSpy.mockRestore();
+  });
+  it("should warn when no files are found", () => {
+    const logSpy = vi.spyOn(logger, "warn");
+    const srcPath = "path/to/dir/does-not-exist.txt";
+
+    copyCustomFiles(
+      [
+        {
+          srcPath: srcPath,
+          dstPath: "server/index.mjs",
+        },
+      ],
+      outputFolder,
+    );
+
+    expect(logSpy).toHaveBeenCalledWith(
+      `No files found for pattern: ${srcPath}`,
+    );
+    logSpy.mockRestore();
+  });
+});