feat(javascript): simplify the definition of object type description (#2058)

## What does this PR do?
It is hard to describe the type of a object, we should write some code
like this:
```JavaScript
Type.object("example.foo", {
    a: Type.string()
})
```
 The `Type.xxx` APIs are very flexible but not easy to use.

This PR add improve these APIS to help simplifing the type definition.
Now we can definition object type like this:

```JavaScript
    @Type.object("example.foo")
    class Foo {
      @Type.int32()
      a: number;
    }

    const fury = new Fury({ refTracking: true });
    const { serialize, deserialize } = fury.registerSerializer(Foo);
    const foo = new Foo();
    foo.a = 123;
    const input = serialize(foo);
    const result = deserialize(
      input
    );

    expect(result instanceof Foo);
    expect(result).toEqual({ a: 123 })

```

The result of `Type.xxx()` serves both as a decorator function and as a
description object. It is totally compatible with
`Type.object("example.foo", {
    a: Type.string()
})`

Note that decoration APIs can not detect the type of a anonymous object.
providing anonymous object like `{a: 123}` still will cause error.

Author: theweipeng

javascript/jest.config.js

@@ -32,7 +32,8 @@ module.exports = {
   transform: {
     '\\.ts$': ['ts-jest', {
       tsconfig: {
-        target: "ES2021"
+        target: "ES2021",
+        experimentalDecorators: true
       },
       diagnostics: {
         ignoreCodes: [151001]

javascript/packages/fury/lib/classResolver.ts

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { InternalSerializerType, Serializer } from "./type";
+import { FuryClsInfoSymbol, InternalSerializerType, ObjectFuryClsInfo, Serializer } from "./type";
 import { fromString } from "./platformBuffer";
 import { x64hash128 } from "./murmurHash3";
 import { BinaryWriter } from "./writer";
@@ -78,9 +78,7 @@ const uninitSerialize = {
 
 export default class SerializerResolver {
   private internalSerializer: Serializer[] = new Array(300);
-  private customSerializer: { [key: string]: Serializer } = {
-  };
-
+  private customSerializer: Map<string | (new () => any), Serializer> = new Map();
   private readStringPool: LazyString[] = [];
   private writeStringCount = 0;
   private writeStringIndex: number[] = [];
@@ -161,17 +159,25 @@ export default class SerializerResolver {
     return this.internalSerializer[id];
   }
 
-  registerSerializerByTag(tag: string, serializer: Serializer = uninitSerialize) {
-    if (this.customSerializer[tag]) {
-      Object.assign(this.customSerializer[tag], serializer);
+  private registerCustomSerializer(tagOrConstructor: string | (new () => any), serializer: Serializer = uninitSerialize) {
+    if (this.customSerializer.has(tagOrConstructor)) {
+      Object.assign(this.customSerializer.get(tagOrConstructor)!, serializer);
     } else {
-      this.customSerializer[tag] = { ...serializer };
+      this.customSerializer.set(tagOrConstructor, { ...serializer });
     }
-    return this.customSerializer[tag];
+    return this.customSerializer.get(tagOrConstructor);
+  }
+
+  registerSerializerByTag(tag: string, serializer: Serializer = uninitSerialize) {
+    this.registerCustomSerializer(tag, serializer);
+  }
+
+  registerSerializerByConstructor(constructor: new () => any, serializer: Serializer = uninitSerialize) {
+    this.registerCustomSerializer(constructor, serializer);
   }
 
   getSerializerByTag(tag: string) {
-    return this.customSerializer[tag];
+    return this.customSerializer.get(tag)!;
   }
 
   static tagBuffer(tag: string) {
@@ -232,6 +238,7 @@ export default class SerializerResolver {
   }
 
   getSerializerByData(v: any) {
+    // internal types
     if (typeof v === "number") {
       return this.numberSerializer;
     }
@@ -263,6 +270,12 @@ export default class SerializerResolver {
     if (v instanceof Set) {
       return this.setSerializer;
     }
+
+    // custome types
+    if (typeof v === "object" && v !== null && FuryClsInfoSymbol in v) {
+      return this.customSerializer.get((v[FuryClsInfoSymbol] as ObjectFuryClsInfo).constructor)!;
+    }
+
     throw new Error(`Failed to detect the Fury type from JavaScript type: ${typeof v}`);
   }
 

javascript/packages/fury/lib/description.ts

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { InternalSerializerType } from "./type";
+import { FuryClsInfoSymbol, InternalSerializerType, ObjectFuryClsInfo } from "./type";
 
 export interface TypeDescription {
   type: InternalSerializerType;
@@ -28,6 +28,7 @@ export interface ObjectTypeDescription extends TypeDescription {
   options: {
     props: { [key: string]: TypeDescription };
     tag: string;
+    withConstructor?: false;
   };
 }
 
@@ -274,181 +275,234 @@ export type ResultType<T> = T extends {
                               type: InternalSerializerType.ONEOF;
                             } ? OneofResult<T> : unknown;
 
+type DecorationWithDescription<T> = ((target: any, key?: string | { name?: string }) => void) & T;
+
+const makeDescriptionWithDecoration = <T extends TypeDescription>(description: T): DecorationWithDescription<T> => {
+  function decoration(target: any, key?: string | { name?: string }) {
+    if (key === undefined) {
+      initMeta(target, description as unknown as ObjectTypeDescription);
+    } else {
+      const keyString = typeof key === "string" ? key : key?.name;
+      if (!keyString) {
+        throw new Error("Decorators can only be placed on classes and fields");
+      }
+      addField(target.constructor, keyString, description);
+    }
+  }
+  decoration.toJSON = function () {
+    return JSON.stringify(description);
+  };
+  Object.entries(description).map(([key, value]: any) => {
+    Object.defineProperty(decoration, key, {
+      enumerable: true,
+      get() {
+        return value;
+      },
+    });
+  });
+  return decoration as unknown as DecorationWithDescription<T>;
+};
+
 export const Type = {
   any() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.ANY as const,
-    };
+    });
   },
   enum<T1 extends { [key: string]: any }>(t1: T1) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.ENUM as const,
       options: {
         inner: t1,
       },
-    };
+    });
   },
   oneof<T extends { [key: string]: TypeDescription }>(inner?: T) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.ONEOF as const,
       options: {
         inner,
       },
-    };
+    });
   },
   string() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.STRING as const,
-    };
+    });
   },
   array<T extends TypeDescription>(def: T) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.ARRAY as const,
       options: {
         inner: def,
       },
-    };
+    });
   },
   tuple<T1 extends readonly [...readonly TypeDescription[]]>(t1: T1) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.TUPLE as const,
       options: {
         inner: t1,
       },
-    };
+    });
   },
   map<T1 extends TypeDescription, T2 extends TypeDescription>(
     key: T1,
     value: T2
   ) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.MAP as const,
       options: {
         key,
         value,
       },
-    };
+    });
   },
   set<T extends TypeDescription>(key: T) {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.SET as const,
       options: {
         key,
       },
-    };
+    });
   },
   bool() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.BOOL as const,
-    };
+    });
   },
-  object<T extends { [key: string]: TypeDescription }>(tag: string, props?: T) {
-    return {
+  object<T extends { [key: string]: TypeDescription }>(tag: string, props?: T, withConstructor = false) {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.OBJECT as const,
       options: {
         tag,
         props,
+        withConstructor,
       },
-    };
+    });
   },
   int8() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT8 as const,
-    };
+    });
   },
   int16() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT16 as const,
-    };
+    });
   },
   int32() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT32 as const,
-    };
+    });
   },
   varInt32() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.VAR_INT32 as const,
-    };
+    });
   },
   int64() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT64 as const,
-    };
+    });
   },
   sliInt64() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.SLI_INT64 as const,
-    };
+    });
   },
   float16() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT16 as const,
-    };
+    });
   },
   float32() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT32 as const,
-    };
+    });
   },
   float64() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT64 as const,
-    };
+    });
   },
   binary() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.BINARY as const,
-    };
+    });
   },
   duration() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.DURATION as const,
-    };
+    });
   },
   timestamp() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.TIMESTAMP as const,
-    };
+    });
   },
   boolArray() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.BOOL_ARRAY as const,
-    };
+    });
   },
   int8Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT8_ARRAY as const,
-    };
+    });
   },
   int16Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT16_ARRAY as const,
-    };
+    });
   },
   int32Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT32_ARRAY as const,
-    };
+    });
   },
   int64Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.INT64_ARRAY as const,
-    };
+    });
   },
   float16Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT16_ARRAY as const,
-    };
+    });
   },
   float32Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT32_ARRAY as const,
-    };
+    });
   },
   float64Array() {
-    return {
+    return makeDescriptionWithDecoration({
       type: InternalSerializerType.FLOAT64_ARRAY as const,
-    };
+    });
   },
 };
+
+const initMeta = (target: new () => any, description: ObjectTypeDescription) => {
+  if (!target.prototype) {
+    target.prototype = {};
+  }
+  target.prototype[FuryClsInfoSymbol] = {
+    toObjectDescription() {
+      if (targetFields.has(target)) {
+        return Type.object(description.options.tag, targetFields.get(target), true);
+      }
+      return Type.object(description.options.tag, {}, true);
+    },
+    constructor: target,
+  } as ObjectFuryClsInfo;
+};
+
+const targetFields = new WeakMap<new () => any, { [key: string]: TypeDescription }>();
+
+const addField = (target: new () => any, key: string, des: TypeDescription) => {
+  if (!targetFields.has(target)) {
+    targetFields.set(target, {});
+  }
+  targetFields.get(target)![key] = des;
+};