refactor: replace path variable metadata type

Author: jbl428

lib/builders/path-variable.builder.spec.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { PathVariableBuilder } from "./path-variable.builder";
+
+describe("PathVariableBuilder", () => {
+  it("should replace url with given variable", () => {
+    // given
+    const builder = new PathVariableBuilder(0, "id");
+    const args = [123];
+
+    // when
+    const actual = builder.build("/user/{id}", args);
+
+    // then
+    expect(actual).toBe("/user/123");
+  });
+
+  it("should replace multiple variables in url", () => {
+    // given
+    const builder = new PathVariableBuilder(0, "id");
+    builder.add(1, "name");
+    const url = "/user/{id}/profile/{name}";
+    const args = [123, "john"];
+
+    // when
+    const actual = builder.build(url, args);
+
+    // then
+    expect(actual).toBe("/user/123/profile/john");
+  });
+
+  it("should handle url without variables", () => {
+    // given
+    const builder = new PathVariableBuilder(0, "id");
+    const args = [123];
+
+    // when
+    const actual = builder.build("/user/profile", args);
+
+    // then
+    expect(actual).toBe("/user/profile");
+  });
+
+  it("should handle variables not replaced in url", () => {
+    // given
+    const builder = new PathVariableBuilder(0, "id");
+    const args = [123];
+
+    // when
+    const actual = builder.build("/user/{id}/profile/{name}", args);
+
+    // then
+    expect(actual).toBe("/user/123/profile/{name}");
+  });
+
+  it("should replace multiple variables with same name", () => {
+    // given
+    const builder = new PathVariableBuilder(0, "id");
+    const args = [123];
+
+    // when
+    const actual = builder.build("/user/{id}/profile/{id}", args);
+
+    // then
+    expect(actual).toBe("/user/123/profile/123");
+  });
+});

lib/builders/path-variable.builder.ts

@@ -0,0 +1,19 @@
+export class PathVariableBuilder {
+  metadata: Array<[index: number, key: string]> = [];
+
+  constructor(index: number, key: string) {
+    this.add(index, key);
+  }
+
+  add(index: number, key: string): void {
+    this.metadata.push([index, key]);
+  }
+
+  build(url: string, args: any[]): string {
+    return this.metadata.reduce<string>(
+      (acc, [index, key]) =>
+        acc.replace(new RegExp(`{${key}}`, "g"), args[index]),
+      url
+    );
+  }
+}

lib/builders/request-param.builder.ts

@@ -5,22 +5,14 @@ export class RequestParamBuilder {
   metadata: Array<[index: number, key: string | undefined]> = [];
 
   constructor(index: number, key?: string) {
-    this.metadata.push([index, key]);
-  }
-
-  get length(): number {
-    return this.metadata.length;
+    this.add(index, key);
   }
 
   add(index: number, key?: string): void {
     this.metadata.push([index, key]);
   }
 
   build(args: any[]): string {
-    if (this.metadata.length === 0) {
-      return "";
-    }
-
     const result = this.metadata.reduce<Record<string, any>>(
       (acc, [index, key]) => {
         if (key != null) {

lib/builders/url.builder.spec.ts

@@ -1,8 +1,7 @@
 import { describe, test, expect } from "vitest";
+import { PathVariableBuilder } from "./path-variable.builder";
 import { RequestParamBuilder } from "./request-param.builder";
 import { UrlBuilder } from "./url.builder";
-import { type PathVariableMetadata } from "../decorators";
-import { MetadataMap } from "../types/metadata-map";
 
 describe("UrlBuilder", () => {
   test("should build with base url", () => {
@@ -24,7 +23,7 @@ describe("UrlBuilder", () => {
     const host = "https://example.com";
     const path = "api/users/{id}";
     const args = [1, 2];
-    const pathParam: PathVariableMetadata = new MetadataMap([[1, "id"]]);
+    const pathParam = new PathVariableBuilder(1, "id");
     const urlBuilder = new UrlBuilder(host, path, args, { pathParam });
 
     // when

lib/builders/url.builder.ts

@@ -1,42 +1,34 @@
+import { type PathVariableBuilder } from "./path-variable.builder";
 import { type RequestParamBuilder } from "./request-param.builder";
-import { type PathVariableMetadata } from "../decorators";
 
 export class UrlBuilder {
-  #pathParams: Array<[number, string]> = [];
+  #pathVariableBuilder: PathVariableBuilder | undefined;
   #requestParamBuilder: RequestParamBuilder | undefined;
 
   constructor(
     private readonly host: string,
     private readonly path: string,
     private readonly args: any[],
     metadata: {
-      pathParam?: PathVariableMetadata;
+      pathParam?: PathVariableBuilder;
       queryParam?: RequestParamBuilder;
     } = {}
   ) {
     if (this.host.length === 0) {
       this.host = this.path;
       this.path = "";
     }
-    this.#pathParams = metadata.pathParam?.toArray() ?? [];
+    this.#pathVariableBuilder = metadata.pathParam;
     this.#requestParamBuilder = metadata.queryParam;
   }
 
   build(): string {
     return (
-      this.replacePathVariable() +
+      (this.#pathVariableBuilder?.build(this.url, this.args) ?? this.url) +
       (this.#requestParamBuilder?.build(this.args) ?? "")
     );
   }
 
-  private replacePathVariable(): string {
-    return this.#pathParams.reduce(
-      (url, [index, value]) =>
-        url.replace(new RegExp(`{${value}}`, "g"), this.args[index]),
-      this.url
-    );
-  }
-
   get url(): string {
     if (this.path === "") {
       return this.host;

lib/decorators/path-variable.decorator.spec.ts

@@ -1,9 +1,7 @@
 import { describe, test, expect } from "vitest";
 import { PATH_VARIABLE_METADATA } from "./constants";
-import {
-  PathVariable,
-  type PathVariableMetadata,
-} from "./path-variable.decorator";
+import { PathVariable } from "./path-variable.decorator";
+import { type PathVariableBuilder } from "../builders/path-variable.builder";
 
 describe("PathVariable", () => {
   test("should set path variable metadata", () => {
@@ -18,15 +16,16 @@ describe("PathVariable", () => {
     }
 
     // when
-    const result: PathVariableMetadata = Reflect.getMetadata(
+    const result: PathVariableBuilder = Reflect.getMetadata(
       PATH_VARIABLE_METADATA,
       TestService.prototype,
       "request"
     );
 
     // then
-    expect(result).toHaveLength(2);
-    expect(result.get(0)).toBe("foo");
-    expect(result.get(1)).toBe("bar");
+    expect(result.metadata).toEqual([
+      [1, "bar"],
+      [0, "foo"],
+    ]);
   });
 });

lib/decorators/path-variable.decorator.ts

@@ -1,23 +1,26 @@
 import { PATH_VARIABLE_METADATA } from "./constants";
-import { MetadataMap } from "../types/metadata-map";
-
-export type PathVariableMetadata = MetadataMap<number, string>;
+import { PathVariableBuilder } from "../builders/path-variable.builder";
 
 export function PathVariable(name: string): ParameterDecorator {
   return (target, propertyKey, parameterIndex) => {
-    if (typeof propertyKey === "undefined") {
+    if (propertyKey == null) {
       return;
     }
 
-    const metadata: PathVariableMetadata =
-      Reflect.getMetadata(PATH_VARIABLE_METADATA, target, propertyKey) ??
-      new MetadataMap();
+    const builder: PathVariableBuilder | undefined = Reflect.getMetadata(
+      PATH_VARIABLE_METADATA,
+      target,
+      propertyKey
+    );
 
-    metadata.set(parameterIndex, name);
+    if (builder != null) {
+      builder.add(parameterIndex, name);
+      return;
+    }
 
     Reflect.defineMetadata(
       PATH_VARIABLE_METADATA,
-      metadata,
+      new PathVariableBuilder(parameterIndex, name),
       target,
       propertyKey
     );

lib/decorators/request-param.decorator.ts

@@ -7,14 +7,14 @@ export function RequestParam(key?: string): ParameterDecorator {
       return;
     }
 
-    const metadata: RequestParamBuilder | undefined = Reflect.getMetadata(
+    const builder: RequestParamBuilder | undefined = Reflect.getMetadata(
       REQUEST_PARAM_METADATA,
       target,
       propertyKey
     );
 
-    if (metadata != null) {
-      metadata.add(parameterIndex, key);
+    if (builder != null) {
+      builder.add(parameterIndex, key);
       return;
     }
 

lib/node-fetch.injector.ts

@@ -1,6 +1,7 @@
 import { Injectable, type OnModuleInit } from "@nestjs/common";
 import { DiscoveryService, MetadataScanner } from "@nestjs/core";
 import { type InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
+import { type PathVariableBuilder } from "./builders/path-variable.builder";
 import { type RequestParamBuilder } from "./builders/request-param.builder";
 import { TupleArrayBuilder } from "./builders/tuple-array.builder";
 import { UrlBuilder } from "./builders/url.builder";
@@ -9,7 +10,6 @@ import {
   HTTP_INTERFACE_METADATA,
   type HttpExchangeMetadata,
   PATH_VARIABLE_METADATA,
-  type PathVariableMetadata,
   REQUEST_BODY_METADATA,
   REQUEST_PARAM_METADATA,
   type RequestBodyMetadata,
@@ -50,7 +50,7 @@ export class NodeFetchInjector implements OnModuleInit {
             return;
           }
 
-          const pathMetadata = getMetadata<PathVariableMetadata>(
+          const pathMetadata = getMetadata<PathVariableBuilder>(
             PATH_VARIABLE_METADATA
           );
           const requestParamMetadata = getMetadata<RequestParamBuilder>(