@colyseus/schema 3.0.20 → 3.0.21

package/src/Reflection.ts

@@ -44,71 +44,104 @@ export class Reflection extends Schema {
         const rootType = context.schemas.get(encoder.state.constructor);
         if (rootType > 0) { reflection.rootType = rootType; }
 
-        const buildType = (currentType: ReflectionType, metadata: Metadata) => {
-            for (const fieldIndex in metadata) {
-                const index = Number(fieldIndex);
-                const fieldName = metadata[index].name;
-
-                // skip fields from parent classes
-                if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
-                    continue;
+        const includedTypeIds = new Set<number>();
+        const pendingReflectionTypes: { [typeid: number]: ReflectionType[] } = {};
+
+        // add type to reflection in a way that respects inheritance
+        // (parent types should be added before their children)
+        const addType = (type: ReflectionType) => {
+            if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
+                includedTypeIds.add(type.id);
+
+                reflection.types.push(type);
+
+                const deps = pendingReflectionTypes[type.id];
+                if (deps !== undefined) {
+                    delete pendingReflectionTypes[type.id];
+                    deps.forEach((childType) => addType(childType));
                 }
+            } else {
+                if (pendingReflectionTypes[type.extendsId] === undefined) {
+                    pendingReflectionTypes[type.extendsId] = [];
+                }
+                pendingReflectionTypes[type.extendsId].push(type);
+            }
+        };
 
-                const field = new ReflectionField();
-                field.name = fieldName;
+        context.schemas.forEach((typeid, klass) => {
+            const type = new ReflectionType();
+            type.id = Number(typeid);
 
-                let fieldType: string;
+            // support inheritance
+            const inheritFrom = Object.getPrototypeOf(klass);
+            if (inheritFrom !== Schema) {
+                type.extendsId = context.schemas.get(inheritFrom);
+            }
 
-                const type = metadata[index].type;
+            const metadata = klass[Symbol.metadata];
 
-                if (typeof (type) === "string") {
-                    fieldType = type;
+            //
+            // FIXME: this is a workaround for inherited types without additional fields
+            // if metadata is the same reference as the parent class - it means the class has no own metadata
+            //
+            if (metadata !== inheritFrom[Symbol.metadata]) {
+                for (const fieldIndex in metadata) {
+                    const index = Number(fieldIndex);
+                    const fieldName = metadata[index].name;
 
-                } else {
-                    let childTypeSchema: typeof Schema;
+                    // skip fields from parent classes
+                    if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                        continue;
+                    }
+
+                    const reflectionField = new ReflectionField();
+                    reflectionField.name = fieldName;
+
+                    let fieldType: string;
 
-                    //
-                    // TODO: refactor below.
-                    //
-                    if (Schema.is(type)) {
-                        fieldType = "ref";
-                        childTypeSchema = type as typeof Schema;
+                    const field = metadata[index];
+
+                    if (typeof (field.type) === "string") {
+                        fieldType = field.type;
 
                     } else {
-                        fieldType = Object.keys(type)[0];
+                        let childTypeSchema: typeof Schema;
 
-                        if (typeof(type[fieldType]) === "string") {
-                            fieldType += ":" + type[fieldType]; // array:string
+                        //
+                        // TODO: refactor below.
+                        //
+                        if (Schema.is(field.type)) {
+                            fieldType = "ref";
+                            childTypeSchema = field.type as typeof Schema;
 
                         } else {
-                            childTypeSchema = type[fieldType];
+                            fieldType = Object.keys(field.type)[0];
+
+                            if (typeof (field.type[fieldType]) === "string") {
+                                fieldType += ":" + field.type[fieldType]; // array:string
+
+                            } else {
+                                childTypeSchema = field.type[fieldType];
+                            }
                         }
+
+                        reflectionField.referencedType = (childTypeSchema)
+                            ? context.getTypeId(childTypeSchema)
+                            : -1;
                     }
 
-                    field.referencedType = (childTypeSchema)
-                        ? context.getTypeId(childTypeSchema)
-                        : -1;
+                    reflectionField.type = fieldType;
+                    type.fields.push(reflectionField);
                 }
-
-                field.type = fieldType;
-                currentType.fields.push(field);
             }
 
-            reflection.types.push(currentType);
-        }
-
-        for (let typeid in context.types) {
-            const klass = context.types[typeid];
-            const type = new ReflectionType();
-            type.id = Number(typeid);
-
-            // support inheritance
-            const inheritFrom = Object.getPrototypeOf(klass);
-            if (inheritFrom !== Schema) {
-                type.extendsId = context.schemas.get(inheritFrom);
-            }
+            addType(type);
+        });
 
-            buildType(type, klass[Symbol.metadata]);
+        // in case there are types that were not added due to inheritance
+        for (const typeid in pendingReflectionTypes) {
+            pendingReflectionTypes[typeid].forEach((type) =>
+                reflection.types.push(type))
         }
 
         const buf = reflectionEncoder.encodeAll(it);

package/src/encoder/Encoder.ts

@@ -23,10 +23,12 @@ export class Encoder<T extends Schema = any> {
 
     constructor(state: T) {
         //
-        // TODO: cache and restore "Context" based on root schema
-        // (to avoid creating a new context for every new room)
+        // Use .cache() here to avoid re-creating a new context for every new room instance.
         //
-        this.context = new TypeContext(state.constructor as typeof Schema);
+        // We may need to make this optional in case of dynamically created
+        // schemas - which would lead to memory leaks
+        //
+        this.context = TypeContext.cache(state.constructor as typeof Schema);
         this.root = new Root(this.context);
 
         this.setState(state);

package/src/types/TypeContext.ts

@@ -14,6 +14,7 @@ export class TypeContext {
      * Keeps track of which classes extends which. (parent -> children)
      */
     static inheritedTypes = new Map<typeof Schema, Set<typeof Schema>>();
+    static cachedContexts = new Map<typeof Schema, TypeContext>();
 
     static register(target: typeof Schema) {
         const parent = Object.getPrototypeOf(target);
@@ -27,13 +28,17 @@ export class TypeContext {
         }
     }
 
+    static cache (rootClass: typeof Schema) {
+        let context = TypeContext.cachedContexts.get(rootClass);
+        if (!context) {
+            context = new TypeContext(rootClass);
+            TypeContext.cachedContexts.set(rootClass, context);
+        }
+        return context;
+    }
+
     constructor(rootClass?: typeof Schema) {
         if (rootClass) {
-            //
-            // TODO:
-            //      cache "discoverTypes" results for each rootClass
-            //      to avoid re-discovering types for each new context/room
-            //
             this.discoverTypes(rootClass);
         }
     }