feat: implement url builder

Co-authored-by: imdudu1 <[email protected]>

Author: jbl428

lib/utils/url-builder.spec.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from "vitest";
+import { URLBuilder } from "./url-builder";
+import {
+  type PathVariableMetadata,
+  type RequestParamMetadata,
+} from "../decorators";
+
+describe("URLBuilder", () => {
+  test("should build with base url", () => {
+    // given
+    const host = "https://example.com";
+    const path = "//api/1";
+    const args = [1];
+    const urlBuilder = new URLBuilder(host, path, args);
+
+    // when
+    const actual = urlBuilder.build();
+
+    // then
+    expect(actual).toBe("https://example.com/api/1");
+  });
+
+  test("should replace url with given path variable metadata", () => {
+    // given
+    const host = "https://example.com";
+    const path = "api/users/{id}";
+    const args = [1, 2];
+    const pathParam: PathVariableMetadata = new Map([[1, "id"]]);
+    const urlBuilder = new URLBuilder(host, path, args, { pathParam });
+
+    // when
+    const actual = urlBuilder.build();
+
+    // then
+    expect(actual).toBe("https://example.com/api/users/2");
+  });
+
+  test("should append query string", () => {
+    // given
+    const host = "https://example.com";
+    const path = "";
+    const args = ["search"];
+    const queryParam: RequestParamMetadata = new Map([[0, "keyword"]]);
+    const urlBuilder = new URLBuilder(host, path, args, { queryParam });
+
+    // when
+    const actual = urlBuilder.build();
+
+    // then
+    expect(actual).toBe("https://example.com?keyword=search");
+  });
+
+  test("should append query string when provided as json", () => {
+    // given
+    const host = "https://example.com";
+    const path = "api/user";
+    const args = [{ keyword: "search" }];
+    const queryParam: RequestParamMetadata = new Map([[0, undefined]]);
+    const urlBuilder = new URLBuilder(host, path, args, { queryParam });
+
+    // when
+    const actual = urlBuilder.build();
+
+    // then
+    expect(actual).toBe("https://example.com/api/user?keyword=search");
+  });
+});

lib/utils/url-builder.ts

@@ -0,0 +1,94 @@
+import {
+  type PathVariableMetadata,
+  type RequestParamMetadata,
+} from "../decorators";
+
+export class URLBuilder {
+  #pathParams: Array<[number, string]> = [];
+  #queryParams: Array<[number, string | undefined]> = [];
+
+  constructor(
+    private readonly host: string,
+    private readonly path: string,
+    private readonly args: any[],
+    metadata: {
+      pathParam?: PathVariableMetadata;
+      queryParam?: RequestParamMetadata;
+    } = {}
+  ) {
+    this.#pathParams = this.toArray(metadata.pathParam);
+    this.#queryParams = this.toArray(metadata.queryParam);
+  }
+
+  build(): string {
+    return this.replacePathVariable() + this.appendQueryParams();
+  }
+
+  private replacePathVariable(): string {
+    return this.#pathParams.reduce(
+      (url, [index, value]) =>
+        url.replace(new RegExp(`{${value}}`, "g"), this.args[index]),
+      this.url
+    );
+  }
+
+  private appendQueryParams(): string {
+    if (this.#queryParams.length === 0) {
+      return "";
+    }
+
+    const searchParams = new URLSearchParams();
+    this.#queryParams.forEach(([paramIndex, queryParamKey]) => {
+      if (typeof queryParamKey !== "undefined") {
+        searchParams.set(queryParamKey, this.args[paramIndex]);
+        return;
+      }
+
+      this.toArray<string, unknown>(this.args[paramIndex]).forEach(
+        ([key, value]) => {
+          searchParams.set(key, `${value?.toString() ?? ""}`);
+        }
+      );
+    });
+
+    return "?" + searchParams.toString();
+  }
+
+  get url(): string {
+    if (this.path === "") {
+      return this.host;
+    }
+
+    if (this.isStartProtocol()) {
+      const [protocol, host] = this.host.split("://");
+
+      return protocol + "://" + this.replaceSlash(`${host}/${this.path}`);
+    }
+
+    return this.replaceSlash(`${this.host}/${this.path}`);
+  }
+
+  private isStartProtocol(): boolean {
+    return this.host.match(/^https?:\/\//) != null;
+  }
+
+  private replaceSlash(url: string): string {
+    return url.replace(/\/{2,}/g, "/");
+  }
+
+  private toArray<A, B>(value: unknown): Array<[A, B]> {
+    if (typeof value === "undefined") {
+      return [];
+    }
+
+    if (value instanceof Map) {
+      return [...value.entries()];
+    }
+
+    if (typeof value === "object" && value !== null) {
+      return Object.entries(value) as Array<[A, B]>;
+    }
+
+    return [];
+  }
+}