fix(dispatcher): Fix dispatcher.findOperation to use case insensitive…

… match

src/server/dispatcher.ts

@@ -97,15 +97,28 @@ export class Dispatcher {
     return types;
   }
 
+  private findOperation(
+    path: string,
+    method: HttpMethods,
+  ): OpenApiOperation | undefined {
+    for (const key in this.openApiDocument?.paths) {
+      if (key.toLowerCase() === path.toLowerCase()) {
+        return this.openApiDocument.paths[key]?.[
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          method.toLowerCase() as Lowercase<HttpMethods>
+        ];
+        break;
+      }
+    }
+
+    return undefined;
+  }
+
   public operationForPathAndMethod(
     path: string,
     method: HttpMethods,
   ): OpenApiOperation | undefined {
-    const operation: OpenApiOperation | undefined =
-      this.openApiDocument?.paths[path]?.[
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        method.toLowerCase() as Lowercase<HttpMethods>
-      ];
+    const operation = this.findOperation(path, method);
 
     if (operation === undefined) {
       return undefined;
@@ -207,13 +220,15 @@ export class Dispatcher {
   // eslint-disable-next-line sonarjs/cognitive-complexity, max-statements
   public async request({
     body,
+    config,
     headers = {},
     method,
     path,
     query,
     req,
   }: {
     body: unknown;
+    config?: Config;
     headers: {
       [key: string]: string;
     };
@@ -238,7 +253,11 @@ export class Dispatcher {
     }
 
     const { matchedPath } = this.registry.handler(path);
-    const operation = this.operationForPathAndMethod(matchedPath, method);
+    const operation = this.operationForPathAndMethod(
+      matchedPath,
+      method,
+      config?.ignorePathCase,
+    );
 
     const response = await this.registry.endpoint(
       method,

test/server/dispatcher.test.ts

@@ -818,3 +818,51 @@ describe("given a request that contains the OpenApi basePath", () => {
     expect(response.body).toBe("ok");
   });
 });
+
+describe("given a request that contains the differently cased path", () => {
+  it("correctly returns the desired path response even when case of path does not match", async () => {
+    const registry = new Registry();
+
+    registry.add("/abc", {
+      POST() {
+        return {
+          body: "ok",
+          status: 200,
+        };
+      },
+    });
+
+    const dispatcher = new Dispatcher(registry, new ContextRegistry(), {
+      paths: {
+        "/Abc": {
+          post: {
+            responses: {
+              200: {
+                content: {
+                  "text/plain": {
+                    schema: {
+                      type: "string",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const response = await dispatcher.request({
+      body: "",
+      headers: {},
+      method: "POST",
+      path: "/abc",
+      query: {},
+      req: { path: "/abc" },
+    });
+
+    expect(response.status).toBe(200);
+
+    expect(response.body).toBe("ok");
+  });
+});