feat: add parameter serialization option to factory method

Author: mnorlin

src/openapi-typescript/fetch-factory.ts

@@ -16,6 +16,7 @@ function fetchFactory<Paths>(options?: InitParameters) {
   const basePath = options?.baseUrl ?? "";
   const defaultInit = options?.defaultInit ?? {};
   const fetchMethod = options?.fetchMethod ?? fetch;
+  const serialization = options?.parameterSerialization;
 
   async function fetcher<
     Path extends keyof Paths,
@@ -25,7 +26,10 @@ function fetchFactory<Paths>(options?: InitParameters) {
     const options = init as unknown as { method: Method } & AllFetchOptions;
 
     const path = getPath(input as string, options.parameters?.path);
-    const query = getQuery(options.parameters?.query);
+    const query = getQuery(
+      options.parameters?.query ?? null,
+      serialization?.explode
+    );
     const url = basePath + path + query;
 
     const fetchInit = buildInit(defaultInit, options);
@@ -66,17 +70,26 @@ function getPath(path: string, pathParams?: Record<string, string | number>) {
 }
 
 function getQuery(
-  params?: Record<string, string | number | string[] | number[]>
+  params: Record<string, string | number | string[] | number[]> | null,
+  explode?: boolean
 ): string {
   if (!params) {
     return "";
   }
 
   const searchParams = Object.entries(params).map(([key, value]) => {
     if (Array.isArray(value)) {
-      return value
-        .map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(`${v}`)}`)
-        .join("&");
+      if (explode) {
+        return value
+          .map(
+            (v) => `${encodeURIComponent(key)}=${encodeURIComponent(`${v}`)}`
+          )
+          .join("&");
+      } else {
+        return `${encodeURIComponent(key)}=${value
+          .map((v) => encodeURIComponent(`${v}`))
+          .join(",")}`;
+      }
     }
     return `${encodeURIComponent(key)}=${encodeURIComponent(`${params[key]}`)}`;
   });

src/types/common.ts

@@ -2,6 +2,7 @@ export type InitParameters = {
   baseUrl?: string;
   defaultInit?: Omit<RequestInit, "method">;
   fetchMethod?: typeof fetch;
+  parameterSerialization?: { explode?: boolean };
 };
 
 export type HttpMethod =

test/openapi-typescript/fetch-factory.test.ts

@@ -197,18 +197,6 @@ describe("Generated fetch request", () => {
     );
   });
 
-  it("resolves array query parameter", () => {
-    customFetch("/pet/findByStatus", {
-      method: "get",
-      // @ts-ignore
-      parameters: { query: { status: ["available", "free"] } },
-    });
-
-    expect((mockedFetch.mock.calls[0] as any)[0]).toBe(
-      "https://petstore3.swagger.io/pet/findByStatus?status=available&status=free"
-    );
-  });
-
   it("merges headers with default headers", () => {
     customFetch("/store/inventory", {
       method: "get",
@@ -284,6 +272,38 @@ describe("Generated fetch request", () => {
   });
 });
 
+describe("Handles parameter serialization", () => {
+  const queryFetch = FetchFactory.build<paths>({ fetchMethod: mockedFetch });
+  const explodeQueryFetch = FetchFactory.build<paths>({
+    parameterSerialization: { explode: true },
+    fetchMethod: mockedFetch,
+  });
+
+  it("resolves query array as comma separated when default", () => {
+    queryFetch("/pet/findByStatus", {
+      method: "get",
+      // @ts-ignore
+      parameters: { query: { status: ["available", "free"] } },
+    });
+
+    expect((mockedFetch.mock.calls[0] as any)[0]).toBe(
+      "/pet/findByStatus?status=available,free"
+    );
+  });
+
+  it("resolves query array as comma separated when set to explode", () => {
+    explodeQueryFetch("/pet/findByStatus", {
+      method: "get",
+      // @ts-ignore
+      parameters: { query: { status: ["available", "free"] } },
+    });
+
+    expect((mockedFetch.mock.calls[0] as any)[0]).toBe(
+      "/pet/findByStatus?status=available&status=free"
+    );
+  });
+});
+
 describe("Generated fetch response", () => {
   it("calls json() of response", async () => {
     const response = await customFetch("/store/inventory", { method: "get" });