remove String extension in LazyJsonString

Author: kuhe

.changeset/warm-dragons-wash.md

@@ -0,0 +1,5 @@
+---
+"@smithy/smithy-client": major
+---
+
+remove String extension in LazyJsonString

packages/smithy-client/src/lazy-json.spec.ts

@@ -2,37 +2,26 @@ import { describe, expect, test as it } from "vitest";
 
 import { LazyJsonString } from "./lazy-json";
 describe("LazyJsonString", () => {
-  it("should has string methods", () => {
-    const jsonValue = new LazyJsonString('"foo"');
-    expect(jsonValue.length).toBe(5);
-    expect(jsonValue.toString()).toBe('"foo"');
-  });
-
-  it("should deserialize json properly", () => {
-    const jsonValue = new LazyJsonString('"foo"');
-    expect(jsonValue.deserializeJSON()).toBe("foo");
-    const wrongJsonValue = new LazyJsonString("foo");
-    expect(() => wrongJsonValue.deserializeJSON()).toThrow();
-  });
-
-  it("should get JSON string properly", () => {
-    const jsonValue = new LazyJsonString('{"foo", "bar"}');
-    expect(jsonValue.toJSON()).toBe('{"foo", "bar"}');
+  it("returns identical values for toString(), valueOf(), and toJSON()", () => {
+    const jsonValue = LazyJsonString.from({ foo: "bar" });
+    expect(jsonValue.valueOf()).toBe(JSON.stringify({ foo: "bar" }));
+    expect(jsonValue.toString()).toBe(JSON.stringify({ foo: "bar" }));
+    expect(jsonValue.toJSON()).toBe(JSON.stringify({ foo: "bar" }));
   });
 
   it("can instantiate from LazyJsonString class", () => {
-    const original = new LazyJsonString('"foo"');
-    const newOne = LazyJsonString.fromObject(original);
+    const original = LazyJsonString.from('"foo"');
+    const newOne = LazyJsonString.from(original);
     expect(newOne.toString()).toBe('"foo"');
   });
 
   it("can instantiate from String class", () => {
-    const jsonValue = LazyJsonString.fromObject(new String('"foo"'));
+    const jsonValue = LazyJsonString.from('"foo"');
     expect(jsonValue.toString()).toBe('"foo"');
   });
 
   it("can instantiate from object", () => {
-    const jsonValue = LazyJsonString.fromObject({ foo: "bar" });
+    const jsonValue = LazyJsonString.from({ foo: "bar" });
     expect(jsonValue.toString()).toBe('{"foo":"bar"}');
   });
 });

packages/smithy-client/src/lazy-json.ts

@@ -1,57 +1,39 @@
 /**
- * Lazy String holder for JSON typed contents.
- */
-
-interface StringWrapper {
-  new (arg: any): String;
-}
-
-/**
- * Because of https://github.com/microsoft/tslib/issues/95,
- * TS 'extends' shim doesn't support extending native types like String.
- * So here we create StringWrapper that duplicate everything from String
- * class including its prototype chain. So we can extend from here.
- *
  * @internal
+ *
+ * This class allows the usage of data objects in fields that expect
+ * JSON strings. It serializes the data object into JSON
+ * if needed during the request serialization step.
+ *
  */
-// @ts-ignore StringWrapper implementation is not a simple constructor
-export const StringWrapper: StringWrapper = function () {
-  //@ts-ignore 'this' cannot be assigned to any, but Object.getPrototypeOf accepts any
-  const Class = Object.getPrototypeOf(this).constructor;
-  const Constructor = Function.bind.apply(String, [null as any, ...arguments]);
-  //@ts-ignore Call wrapped String constructor directly, don't bother typing it.
-  const instance = new Constructor();
-  Object.setPrototypeOf(instance, Class.prototype);
-  return instance as String;
-};
-StringWrapper.prototype = Object.create(String.prototype, {
-  constructor: {
-    value: StringWrapper,
-    enumerable: false,
-    writable: true,
-    configurable: true,
-  },
-});
-Object.setPrototypeOf(StringWrapper, String);
+export class LazyJsonString {
+  private constructor(private value: string) {}
 
-/**
- * @internal
- */
-export class LazyJsonString extends StringWrapper {
-  deserializeJSON(): any {
-    return JSON.parse(super.toString());
+  public toString(): string {
+    return this.value;
   }
 
-  toJSON(): string {
-    return super.toString();
+  public valueOf(): string {
+    return this.value;
   }
 
-  static fromObject(object: any): LazyJsonString {
+  public toJSON(): string {
+    return this.value;
+  }
+
+  public static from(object: any): LazyJsonString {
     if (object instanceof LazyJsonString) {
       return object;
-    } else if (object instanceof String || typeof object === "string") {
+    } else if (typeof object === "string") {
       return new LazyJsonString(object);
     }
     return new LazyJsonString(JSON.stringify(object));
   }
+
+  /**
+   * @deprecated call from() instead.
+   */
+  public static fromObject(object: any): LazyJsonString {
+    return LazyJsonString.from(object);
+  }
 }