Merge branch 'feat/root-path-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 clearUnusedSchemas from "./clearUnusedSchemas";
 import { filterDirectoryItems, getDirectoryItems } from "./dir";
@@ -13,18 +14,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);
@@ -35,7 +39,7 @@ export default async function generateOpenApiSpec(schemas: Record<string, ZodTyp
       validRoutes.push(createRouteRecord(
         method.toLocaleLowerCase(),
         route,
-        appFolderPath,
+        rootPath,
         routeHandler.apiData,
       ));
     }

src/core/getRoutePathName.test.ts

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { describe, expect, it, jest } from "@jest/globals";
+import getRoutePathName from "./getRoutePathName";
+
+describe("getRoutePathName", () => {
+  const rootPath = "/home/omer/Projects/nextjs-app/src/app";
+
+  it("should return correct route path by removing rootPath and adjusting path", () => {
+    const result = getRoutePathName(
+      "/home/omer/Projects/nextjs-app/src/app/users/[id]/route.ts",
+      rootPath
+    );
+    expect(result).toBe("/users/{id}");
+  });
+
+  it("should replace backslashes with forward slashes", () => {
+    jest.spyOn(path, "dirname").mockReturnValueOnce("C:\\users\\omer\\Projects\\nextjs-app\\src\\app\\users\\[id]");
+    jest.spyOn(path, "relative").mockReturnValueOnce("users\\[id]");
+    const result = getRoutePathName(
+      "C:\\users\\omer\\Projects\\nextjs-app\\src\\app\\users\\[id]\\route.ts",
+      "C:\\users\\omer\\Projects\\nextjs-app\\src\\app",
+    );
+    expect(result).toBe("/users/{id}");
+  });
+
+  it("should handle nested folders with parameters", () => {
+    const result = getRoutePathName(
+      "/home/omer/Projects/nextjs-app/src/app/users/[user]/[post]/route.ts",
+      rootPath
+    );
+    expect(result).toBe("/users/{user}/{post}");
+  });
+
+  it("should remove '/route.ts' if present", () => {
+    const result = getRoutePathName(
+      "/home/omer/Projects/nextjs-app/src/app/users/test/route.ts",
+      rootPath
+    );
+    expect(result).toBe("/users/test");
+  });
+
+  it("should handle cases with no parameters", () => {
+    const result = getRoutePathName(
+      "/home/omer/Projects/nextjs-app/src/app/users/home/route.ts",
+      rootPath
+    );
+    expect(result).toBe("/users/home");
+  });
+});

src/core/getRoutePathName.ts

@@ -0,0 +1,9 @@
+import path from "node:path";
+
+export default function getRoutePathName(filePath: string, rootPath: string) {
+  const dirName = path.dirname(filePath);
+  return "/" + path.relative(rootPath, dirName)
+    .replaceAll("[", "{")
+    .replaceAll("]", "}")
+    .replaceAll("\\", "/");
+}

src/core/route.ts

@@ -1,3 +1,4 @@
+import getRoutePathName from "./getRoutePathName";
 import maskOperationSchemas from "./operation-mask";
 import type { OperationObject } from "@omer-x/openapi-types/operation";
 import type { PathsObject } from "@omer-x/openapi-types/paths";
@@ -9,15 +10,6 @@ export type RouteRecord = {
   apiData: OperationObject,
 };
 
-function getRoutePathName(filePath: string, rootPath: string) {
-  return filePath
-    .replace(rootPath, "")
-    .replace("[", "{")
-    .replace("]", "}")
-    .replaceAll("\\", "/")
-    .replace("/route.ts", "");
-}
-
 export function createRouteRecord(method: string, filePath: string, rootPath: string, apiData: OperationObject) {
   return {
     method: method.toLocaleLowerCase(),