@colyseus/schema 3.0.0-alpha.37 → 3.0.0-alpha.38

package/src/Metadata.ts

@@ -41,7 +41,11 @@ export const Metadata = {
         );
 
         // create "descriptors" map
-        metadata[$descriptors] ??= {};
+        Object.defineProperty(metadata, $descriptors, {
+            value: metadata[$descriptors] || {},
+            enumerable: false,
+            configurable: true,
+        });
 
         if (descriptor) {
             // for encoder
@@ -128,7 +132,7 @@ export const Metadata = {
 
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass && parentClass[Symbol.metadata];
-        const metadata = Metadata.initialize(constructor, parentMetadata);
+        const metadata = Metadata.initialize(constructor);
 
         // Use Schema's methods if not defined in the class
         if (!constructor[$track]) { constructor[$track] = Schema[$track]; }
@@ -185,28 +189,71 @@ export const Metadata = {
         });
     },
 
-    initialize(constructor: any, parentMetadata?: Metadata) {
+    initialize(constructor: any) {
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata: Metadata = parentClass[Symbol.metadata];
+
         let metadata: Metadata = constructor[Symbol.metadata] ?? Object.create(null);
 
         // make sure inherited classes have their own metadata object.
-        if (constructor[Symbol.metadata] === parentMetadata) {
+        if (parentClass !== Schema && metadata === parentMetadata) {
             metadata = Object.create(null);
 
             if (parentMetadata) {
+                //
                 // assign parent metadata to current
-                Object.assign(metadata, parentMetadata);
+                //
+                Object.setPrototypeOf(metadata, parentMetadata);
+
+                // Object.keys(parentMetadata).forEach((fieldIndex) => {
+                //     const index = Number(fieldIndex);
+                //     const field = parentMetadata[index];
+                //     metadata[index] = field;
+
+                //     // Object.defineProperty(metadata, field.name, {
+                //     //     value: index,
+                //     //     enumerable: false,
+                //     //     configurable: true,
+                //     // });
+                // });
+
+                // $numFields
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
 
-                for (let i = 0; i <= parentMetadata[$numFields]; i++) {
-                    const fieldName = parentMetadata[i].name;
-                    Object.defineProperty(metadata, fieldName, {
-                        value: parentMetadata[fieldName],
+                // $viewFieldIndexes / $fieldIndexesByViewTag
+                if (parentMetadata[$viewFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $viewFieldIndexes, {
+                        value: [...parentMetadata[$viewFieldIndexes]],
                         enumerable: false,
                         configurable: true,
+                        writable: true,
+                    });
+                    Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                        value: { ...parentMetadata[$fieldIndexesByViewTag] },
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
                     });
                 }
 
-                Object.defineProperty(metadata, $numFields, {
-                    value: parentMetadata[$numFields],
+                // $refTypeFieldIndexes
+                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                        value: [...parentMetadata[$refTypeFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+
+                // $descriptors
+                Object.defineProperty(metadata, $descriptors, {
+                    value: { ...parentMetadata[$descriptors] },
                     enumerable: false,
                     configurable: true,
                     writable: true,

package/src/Reflection.ts

@@ -6,6 +6,7 @@ import { Iterator } from "./encoding/decode";
 import { Encoder } from "./encoder/Encoder";
 import { Decoder } from "./decoder/Decoder";
 import { Schema } from "./Schema";
+import { $numFields } from "./types/symbols";
 
 /**
  * Reflection
@@ -127,24 +128,17 @@ export class Reflection extends Schema {
             const parentClass: typeof Schema = typeContext.get(reflectionType.extendsId) ?? Schema;
             const schema: typeof Schema = class _ extends parentClass {};
 
-            const parentMetadata = parentClass[Symbol.metadata];
-
             // register for inheritance support
             TypeContext.register(schema);
 
-            // for inheritance support
-            Metadata.initialize(schema, parentMetadata);
+            // // for inheritance support
+            // Metadata.initialize(schema);
 
             typeContext.add(schema, reflectionType.id);
         }, {});
 
-        // 2nd pass, set fields
-        reflection.types.forEach((reflectionType) => {
-            const schemaType = typeContext.get(reflectionType.id);
-            const metadata = schemaType[Symbol.metadata];
-
-            const parentFieldIndex = 0;
-
+        // define fields
+        const addFields = (metadata: Metadata, reflectionType: ReflectionType, parentFieldIndex: number) => {
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
 
@@ -170,6 +164,31 @@ export class Reflection extends Schema {
                     Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
                 }
             });
+        };
+
+        // 2nd pass, set fields
+        reflection.types.forEach((reflectionType) => {
+            const schema = typeContext.get(reflectionType.id);
+
+            // for inheritance support
+            const metadata = Metadata.initialize(schema);
+
+            const inheritedTypes: ReflectionType[] = [];
+
+            let parentType: ReflectionType = reflectionType;
+            do {
+                inheritedTypes.push(parentType);
+                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+            } while (parentType);
+
+            let parentFieldIndex = 0;
+
+            inheritedTypes.reverse().forEach((reflectionType) => {
+                // add fields from all inherited classes
+                // TODO: refactor this to avoid adding fields from parent classes
+                addFields(metadata, reflectionType, parentFieldIndex);
+                parentFieldIndex += reflectionType.fields.length;
+            });
         });
 
         const state: T = new (typeContext.get(0) as unknown as any)();

package/src/annotations.ts

@@ -286,15 +286,15 @@ export function type (
         TypeContext.register(constructor);
 
         const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass && parentClass[Symbol.metadata];
-        const metadata = Metadata.initialize(constructor, parentMetadata);
+        const parentMetadata =  parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor);
 
         let fieldIndex: number = metadata[field];
 
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[fieldIndex]) {
+        if (metadata[fieldIndex] !== undefined) {
             if (metadata[fieldIndex].deprecated) {
                 // do not create accessors for deprecated properties.
                 return;