@colyseus/schema 3.0.19 → 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);
@@ -64,7 +66,7 @@ export class Encoder<T extends Schema = any> {
                     view.invisible.add(changeTree);
                     continue; // skip this change tree
 
-                } else if (view.invisible.has(changeTree)) {
+                } else {
                     view.invisible.delete(changeTree); // remove from invisible list
                 }
             }

package/src/encoder/StateView.ts

@@ -90,6 +90,7 @@ export class StateView {
                 const op = changeTree.indexedOperations[index] ?? OPERATION.ADD;
                 const tagAtIndex = metadata?.[index].tag;
                 if (
+                    !changeTree.isNew && // new structures will be added as part of .encode() call, no need to force it to .encodeView()
                     (
                         isInvisible || // if "invisible", include all
                         tagAtIndex === undefined || // "all change" with no tag
@@ -132,8 +133,8 @@ export class StateView {
                 this.addParentOf(changeTree, tag);
             }
 
-            // parent is already available, no need to add it!
-            if (!this.invisible.has(changeTree)) { return; }
+            // // parent is already available, no need to add it!
+            // if (!this.invisible.has(changeTree)) { return; }
         }
 
         // add parent's tag properties

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);
         }
     }

package/src/types/custom/CollectionSchema.ts

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
 import { ChangeTree } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
@@ -10,8 +10,10 @@ import type { StateView } from "../../encoder/StateView";
 type K = number; // TODO: allow to specify K generic on MapSchema.
 
 export class CollectionSchema<V=any> implements Collection<K, V>{
+
     protected $items: Map<number, V> = new Map<number, V>();
     protected $indexes: Map<number, number> = new Map<number, number>();
+    protected deletedItems: { [field: string]: V } = {};
 
     protected $refId: number = 0;
 
@@ -31,7 +33,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         return (
             !view ||
             typeof (ref[$childType]) === "string" ||
-            view.items.has(ref[$getByIndex](index)[$changes])
+            view.items.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
         );
     }
 
@@ -101,7 +103,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
             return false;
         }
 
-        this[$changes].delete(index);
+        this.deletedItems[index] = this[$changes].delete(index);
         this.$indexes.delete(index);
 
         return this.$items.delete(index);
@@ -162,6 +164,10 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         this.$indexes.delete(index);
     }
 
+    protected [$onEncodeEnd]() {
+        this.deletedItems = {};
+    }
+
     toArray() {
         return Array.from(this.$items.values());
     }

package/src/types/custom/MapSchema.ts

@@ -143,7 +143,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     delete(key: K) {
         const index = this[$changes].indexes[key];
 
-        this.deletedItems[index] = this[$changes].delete(index);;
+        this.deletedItems[index] = this[$changes].delete(index);
 
         return this.$items.delete(key);
     }

package/src/types/custom/SetSchema.ts

@@ -1,6 +1,6 @@
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
-import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
 import { Collection } from "../HelperTypes";
 import { ChangeTree } from "../../encoder/ChangeTree";
 import { encodeKeyValueOperation } from "../../encoder/EncodeOperation";
@@ -11,6 +11,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
 
     protected $items: Map<number, V> = new Map<number, V>();
     protected $indexes: Map<number, number> = new Map<number, number>();
+    protected deletedItems: { [field: string]: V } = {};
 
     protected $refId: number = 0;
 
@@ -30,7 +31,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
         return (
             !view ||
             typeof (ref[$childType]) === "string" ||
-            view.items.has(ref[$getByIndex](index)[$changes])
+            view.items.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
         );
     }
 
@@ -98,7 +99,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
             return false;
         }
 
-        this[$changes].delete(index);
+        this.deletedItems[index] = this[$changes].delete(index);
         this.$indexes.delete(index);
 
         return this.$items.delete(index);
@@ -172,6 +173,10 @@ export class SetSchema<V=any> implements Collection<number, V> {
         this.$indexes.delete(index);
     }
 
+    protected [$onEncodeEnd]() {
+        this.deletedItems = {};
+    }
+
     toArray() {
         return Array.from(this.$items.values());
     }