fix: esm runtime evaluation

Author: omermecitoglu

src/core/generateOpenApiSpec.test.ts

@@ -78,11 +78,13 @@ describe("generateOpenApiSpec", () => {
             operationId: "getUsers",
             parameters: [
               {
+                description: "List of the column names",
                 in: "query",
                 name: "select",
                 required: true,
                 schema: {
                   default: [],
+                  description: "List of the column names",
                   items: {
                     enum: [
                       "id",
@@ -243,11 +245,13 @@ describe("generateOpenApiSpec", () => {
             operationId: "getUsers",
             parameters: [
               {
+                description: "List of the column names",
                 in: "query",
                 name: "select",
                 required: true,
                 schema: {
                   default: [],
+                  description: "List of the column names",
                   items: {
                     enum: [
                       "id",

src/core/next.ts

@@ -1,5 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { defineRoute } from "@omer-x/next-openapi-route-handler";
+import { z } from "zod";
 import { directoryExists } from "./dir";
 import injectSchemas from "./injectSchemas";
 import { detectMiddlewareName } from "./middleware";
@@ -18,9 +20,12 @@ export async function findAppFolderPath() {
   return null;
 }
 
-function safeEval(code: string, routePath: string) {
+async function safeEval(code: string, routePath: string) {
   try {
-    return eval(code);
+    if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
+      return eval(code);
+    }
+    return await import(/* webpackIgnore: true */ `data:text/javascript,${encodeURIComponent(code)}`);
   } catch (error) {
     // eslint-disable-next-line no-console
     console.log(`An error occured while evaluating the route exports from "${routePath}"`);
@@ -31,10 +36,16 @@ function safeEval(code: string, routePath: string) {
 export async function getRouteExports(routePath: string, routeDefinerName: string, schemas: Record<string, unknown>) {
   const rawCode = await fs.readFile(routePath, "utf-8");
   const middlewareName = detectMiddlewareName(rawCode);
-  const code = transpile(rawCode, routeDefinerName, middlewareName);
+  const isCommonJS = typeof module !== "undefined" && typeof module.exports !== "undefined";
+  const { transpileModule } = await import(/* webpackIgnore: true */ "typescript");
+  const code = transpile(isCommonJS, rawCode, middlewareName, transpileModule);
   const fixedCode = Object.keys(schemas).reduce(injectSchemas, code);
+  (global as Record<string, unknown>)[routeDefinerName] = defineRoute;
+  (global as Record<string, unknown>).z = z;
   (global as Record<string, unknown>).schemas = schemas;
-  const result = safeEval(fixedCode, routePath);
+  const result = await safeEval(fixedCode, routePath);
   delete (global as Record<string, unknown>).schemas;
+  delete (global as Record<string, unknown>)[routeDefinerName];
+  delete (global as Record<string, unknown>).z;
   return result as Record<string, { apiData?: OperationObject } | undefined>;
 }

src/core/transpile.test.ts

@@ -3,7 +3,7 @@ import { transpile } from "./transpile";
 
 describe("transpile", () => {
   it("should inject export fixers", () => {
-    const result = transpile("", "defineRoute", null);
+    const result = transpile(true, "", null);
     expect(result).toContain("exports.GET = void 0;");
     expect(result).toContain("exports.POST = void 0;");
     expect(result).toContain("exports.PUT = void 0;");
@@ -13,40 +13,8 @@ describe("transpile", () => {
     expect(result).toContain("module.exports = { GET: exports.GET, POST: exports.POST, PUT: exports.PUT, PATCH: exports.PATCH, DELETE: exports.DELETE };");
   });
 
-  it("should inject '@omer-x/next-openapi-route-handler' while it is necessary", async () => {
-    const repoName = "omermecitoglu/example-user-service";
-    const branchName = "main";
-    const filePath = "src/app/users/route.ts";
-    const response = await fetch(`https://raw.githubusercontent.com/${repoName}/refs/heads/${branchName}/${filePath}`);
-    const example = await response.text();
-    const result = transpile(example, "defineRoute", null);
-    expect(result).toContain("require(\"@omer-x/next-openapi-route-handler\");");
-  });
-
-  it("should not inject '@omer-x/next-openapi-route-handler' while it is not necessary", () => {
-    const result = transpile("", "defineRoute", null);
-    expect(result).not.toContain("require(\"@omer-x/next-openapi-route-handler\");");
-  });
-
-  it("should inject 'zod' while it is necessary", () => {
-    const rawCodeExample = `
-      import z from "zod";
-
-      const schema = z.object({
-        name: z.string().min(3).max(255).optional(),
-      });
-    `;
-    const result = transpile(rawCodeExample, "defineRoute", null);
-    expect(result).toContain("require(\"zod\");");
-  });
-
-  it("should not inject 'zod' while it is not necessary", () => {
-    const result = transpile("", "defineRoute", null);
-    expect(result).not.toContain("require(\"zod\");");
-  });
-
   it("should inject a placeholder function for the middleware", () => {
-    const result = transpile("", "defineRoute", "myAwesomeMiddleware");
-    expect(result).toContain("var myAwesomeMiddleware = function (handler) { return handler; };");
+    const result = transpile(true, "", "myAwesomeMiddleware");
+    expect(result).toContain("const myAwesomeMiddleware = (handler) => handler;");
   });
 });

src/core/transpile.ts

@@ -1,24 +1,38 @@
-import { transpile as tsTranspile } from "typescript";
 import removeImports from "~/utils/removeImports";
+import type ts from "typescript";
 
-function fixExports(code: string) {
+function fixExportsInCommonJS(code: string) {
   const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
-  const exportFixer1 = validMethods.map(method => `exports.${method} = void 0;\n`);
-  const exportFixer2 = `module.exports = { ${validMethods.map(m => `${m}: exports.${m}`).join(", ")} }`;
+  const exportFixer1 = validMethods.map(method => `exports.${method} = void 0;\n`).join("\n");
+  const exportFixer2 = `module.exports = { ${validMethods.map(m => `${m}: exports.${m}`).join(", ")} };`;
   return `${exportFixer1}\n${code}\n${exportFixer2}`;
 }
 
 function injectMiddlewareFixer(middlewareName: string) {
   return `const ${middlewareName} = (handler) => handler;`;
 }
 
-export function transpile(rawCode: string, routeDefinerName: string, middlewareName: string | null) {
-  const code = fixExports(removeImports(rawCode));
+export function transpile(
+  isCommonJS: boolean,
+  rawCode: string,
+  middlewareName: string | null,
+  transpileModule: (input: string, transpileOptions: ts.TranspileOptions) => ts.TranspileOutput,
+) {
   const parts = [
-    `import ${routeDefinerName} from '@omer-x/next-openapi-route-handler';`,
-    "import z from 'zod';",
     middlewareName ? injectMiddlewareFixer(middlewareName) : "",
-    code,
+    removeImports(rawCode),
   ];
-  return tsTranspile(parts.join("\n"));
+  const output = transpileModule(parts.join("\n"), {
+    compilerOptions: {
+      module: isCommonJS ? 3 : 99,
+      target: 99,
+      sourceMap: false,
+      inlineSourceMap: false,
+      inlineSources: false,
+    },
+  });
+  if (isCommonJS) {
+    return fixExportsInCommonJS(output.outputText);
+  }
+  return output.outputText;
 }