feat: rootPath option

Author: omermecitoglu

src/core/generateOpenApiSpec.test.ts

@@ -205,4 +205,179 @@ describe("generateOpenApiSpec", () => {
 
     readFileSpy.mockRestore();
   });
+
+  it("should handle rootPath option correctly", 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();
+
+    jest.spyOn(next, "findAppFolderPath").mockResolvedValueOnce("/app");
+    (getDirectoryItems as jest.Mock<typeof getDirectoryItems>).mockResolvedValue([
+      "/app/api/v1/test/route.ts",
+      "/app/api/v1/users/route.ts",
+    ]);
+    (filterDirectoryItems as jest.Mock<typeof filterDirectoryItems>).mockReturnValue([
+      "/app/api/v1/test/route.ts",
+      "/app/api/v1/users/route.ts",
+    ]);
+    const readFileSpy = jest.spyOn(fs, "readFile").mockImplementation(routePath => {
+      switch (routePath) {
+        case "/app/api/v1/test/route.ts":
+          return Promise.resolve(example);
+        case "/app/api/v1/users/route.ts":
+          return Promise.resolve("export async function GET(request: Request) {}");
+        default:
+          throw new Error("Unexpected route path");
+      }
+      // do nothing
+    });
+    (getPackageMetadata as jest.Mock).mockReturnValue({
+      serviceName: "Test Service",
+      version: "1.0.0",
+    });
+
+    const result = await generateOpenApiSpec(schemas, { rootPath: "/api/v1" });
+
+    expect(result).toEqual({
+      openapi: "3.1.0",
+      info: {
+        title: "Test Service",
+        version: "1.0.0",
+      },
+      paths: {
+        "/test": {
+          get: {
+            summary: "Get all users",
+            description: "Retrieve a list of users",
+            operationId: "getUsers",
+            parameters: [
+              {
+                description: "List of the column names",
+                in: "query",
+                name: "select",
+                required: false,
+                schema: {
+                  default: [],
+                  description: "List of the column names",
+                  items: {
+                    enum: [
+                      "id",
+                      "name",
+                    ],
+                    type: "string",
+                  },
+                  type: "array",
+                },
+              },
+            ],
+            requestBody: undefined,
+            responses: {
+              200: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      items: {
+                        $ref: "#/components/schemas/UserDTO",
+                      },
+                      type: "array",
+                    },
+                  },
+                },
+                description: "Returns a list of users",
+              },
+              400: {
+                content: undefined,
+                description: "Bad Request",
+              },
+              500: {
+                content: undefined,
+                description: "Internal Server Error",
+              },
+            },
+            tags: [
+              "Users",
+            ],
+          },
+          post: {
+            description: "Create a new user",
+            operationId: "createUser",
+            parameters: undefined,
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    $ref: "#/components/schemas/NewUserDTO",
+                  },
+                },
+              },
+              required: true,
+            },
+            responses: {
+              201: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/UserDTO",
+                    },
+                  },
+                },
+                description: "User created successfully",
+              },
+              400: {
+                content: undefined,
+                description: "Bad Request",
+              },
+              409: {
+                content: undefined,
+                description: "Email already exists",
+              },
+              500: {
+
+                description: "Internal Server Error",
+              },
+            },
+            summary: "Create user",
+            tags: [
+              "Users",
+            ],
+          },
+        },
+      },
+      components: {
+        schemas: {
+          UserDTO: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+              },
+              name: {
+                type: "string",
+              },
+            },
+            additionalProperties: false,
+            required: ["id", "name"],
+          },
+          NewUserDTO: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+              },
+              name: {
+                type: "string",
+              },
+            },
+            additionalProperties: false,
+            required: ["name"],
+          },
+        },
+      },
+      tags: [],
+    });
+
+    readFileSpy.mockRestore();
+  });
 });

src/core/generateOpenApiSpec.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import getPackageMetadata from "@omer-x/package-metadata";
 import { filterDirectoryItems, getDirectoryItems } from "./dir";
 import isDocumentedRoute from "./isDocumentedRoute";
@@ -12,18 +13,21 @@ type GeneratorOptions = {
   include?: string[],
   exclude?: string[],
   routeDefinerName?: string,
+  rootPath?: string,
 };
 
 export default async function generateOpenApiSpec(schemas: Record<string, ZodType>, {
   include: includeOption = [],
   exclude: excludeOption = [],
   routeDefinerName = "defineRoute",
+  rootPath: additionalRootPath,
 }: GeneratorOptions = {}) {
   const verifiedOptions = verifyOptions(includeOption, excludeOption);
   const appFolderPath = await findAppFolderPath();
   if (!appFolderPath) throw new Error("This is not a Next.js application!");
-  const routes = await getDirectoryItems(appFolderPath, "route.ts");
-  const verifiedRoutes = filterDirectoryItems(appFolderPath, routes, verifiedOptions.include, verifiedOptions.exclude);
+  const rootPath = additionalRootPath ? path.resolve(appFolderPath, "./" + additionalRootPath) : appFolderPath;
+  const routes = await getDirectoryItems(rootPath, "route.ts");
+  const verifiedRoutes = filterDirectoryItems(rootPath, routes, verifiedOptions.include, verifiedOptions.exclude);
   const validRoutes: RouteRecord[] = [];
   for (const route of verifiedRoutes) {
     const isDocumented = await isDocumentedRoute(route);
@@ -34,7 +38,7 @@ export default async function generateOpenApiSpec(schemas: Record<string, ZodTyp
       validRoutes.push(createRouteRecord(
         method.toLocaleLowerCase(),
         route,
-        appFolderPath,
+        rootPath,
         routeHandler.apiData,
       ));
     }