@colyseus/schema 3.0.20 → 3.0.22

package/build/cjs/index.js

@@ -600,6 +600,7 @@ class TypeContext {
      * Keeps track of which classes extends which. (parent -> children)
      */
     static { this.inheritedTypes = new Map(); }
+    static { this.cachedContexts = new Map(); }
     static register(target) {
         const parent = Object.getPrototypeOf(target);
         if (parent !== Schema) {
@@ -611,17 +612,20 @@ class TypeContext {
             inherits.add(target);
         }
     }
+    static cache(rootClass) {
+        let context = TypeContext.cachedContexts.get(rootClass);
+        if (!context) {
+            context = new TypeContext(rootClass);
+            TypeContext.cachedContexts.set(rootClass, context);
+        }
+        return context;
+    }
     constructor(rootClass) {
         this.types = {};
         this.schemas = new Map();
         this.hasFilters = false;
         this.parentFiltered = {};
         if (rootClass) {
-            //
-            // TODO:
-            //      cache "discoverTypes" results for each rootClass
-            //      to avoid re-discovering types for each new context/room
-            //
             this.discoverTypes(rootClass);
         }
     }
@@ -3767,10 +3771,12 @@ class Encoder {
     constructor(state) {
         this.sharedBuffer = Buffer.allocUnsafe(Encoder.BUFFER_SIZE);
         //
-        // 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.
+        //
+        // We may need to make this optional in case of dynamically created
+        // schemas - which would lead to memory leaks
         //
-        this.context = new TypeContext(state.constructor);
+        this.context = TypeContext.cache(state.constructor);
         this.root = new Root(this.context);
         this.setState(state);
         // console.log(">>>>>>>>>>>>>>>> Encoder types");
@@ -3917,13 +3923,14 @@ class Encoder {
             const changeTree = this.root.changeTrees[refId];
             if (changeTree === undefined) {
                 // detached instance, remove from view and skip.
+                // console.log("detached instance, remove from view and skip.", refId);
                 view.changes.delete(refId);
                 continue;
             }
             const keys = Object.keys(changes);
             if (keys.length === 0) {
                 // FIXME: avoid having empty changes if no changes were made
-                // console.log("changes.size === 0, skip", changeTree.ref.constructor.name);
+                // console.log("changes.size === 0, skip", refId, changeTree.ref.constructor.name);
                 continue;
             }
             const ref = changeTree.ref;
@@ -4069,7 +4076,7 @@ class ReferenceTracker {
             //
             // Ensure child schema instances have their references removed as well.
             //
-            if (Metadata.isValidInstance(ref)) {
+            if (ref.constructor[Symbol.metadata] !== undefined) {
                 const metadata = ref.constructor[Symbol.metadata];
                 for (const index in metadata) {
                     const field = metadata[index].name;
@@ -4080,7 +4087,7 @@ class ReferenceTracker {
                 }
             }
             else {
-                if (typeof (Object.values(ref[$childType])[0]) === "function") {
+                if (typeof (ref[$childType]) === "function") {
                     Array.from(ref.values())
                         .forEach((child) => {
                         const childRefId = this.refIds.get(child);
@@ -4275,50 +4282,28 @@ class Reflection extends Schema {
         if (rootType > 0) {
             reflection.rootType = rootType;
         }
-        const buildType = (currentType, 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 field = new ReflectionField();
-                field.name = fieldName;
-                let fieldType;
-                const type = metadata[index].type;
-                if (typeof (type) === "string") {
-                    fieldType = type;
+        const includedTypeIds = new Set();
+        const pendingReflectionTypes = {};
+        // add type to reflection in a way that respects inheritance
+        // (parent types should be added before their children)
+        const addType = (type) => {
+            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 {
-                    let childTypeSchema;
-                    //
-                    // TODO: refactor below.
-                    //
-                    if (Schema.is(type)) {
-                        fieldType = "ref";
-                        childTypeSchema = type;
-                    }
-                    else {
-                        fieldType = Object.keys(type)[0];
-                        if (typeof (type[fieldType]) === "string") {
-                            fieldType += ":" + type[fieldType]; // array:string
-                        }
-                        else {
-                            childTypeSchema = type[fieldType];
-                        }
-                    }
-                    field.referencedType = (childTypeSchema)
-                        ? context.getTypeId(childTypeSchema)
-                        : -1;
+            }
+            else {
+                if (pendingReflectionTypes[type.extendsId] === undefined) {
+                    pendingReflectionTypes[type.extendsId] = [];
                 }
-                field.type = fieldType;
-                currentType.fields.push(field);
+                pendingReflectionTypes[type.extendsId].push(type);
             }
-            reflection.types.push(currentType);
         };
-        for (let typeid in context.types) {
-            const klass = context.types[typeid];
+        context.schemas.forEach((typeid, klass) => {
             const type = new ReflectionType();
             type.id = Number(typeid);
             // support inheritance
@@ -4326,7 +4311,57 @@ class Reflection extends Schema {
             if (inheritFrom !== Schema) {
                 type.extendsId = context.schemas.get(inheritFrom);
             }
-            buildType(type, klass[Symbol.metadata]);
+            const metadata = klass[Symbol.metadata];
+            //
+            // 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;
+                    // skip fields from parent classes
+                    if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                        continue;
+                    }
+                    const reflectionField = new ReflectionField();
+                    reflectionField.name = fieldName;
+                    let fieldType;
+                    const field = metadata[index];
+                    if (typeof (field.type) === "string") {
+                        fieldType = field.type;
+                    }
+                    else {
+                        let childTypeSchema;
+                        //
+                        // TODO: refactor below.
+                        //
+                        if (Schema.is(field.type)) {
+                            fieldType = "ref";
+                            childTypeSchema = field.type;
+                        }
+                        else {
+                            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;
+                    }
+                    reflectionField.type = fieldType;
+                    type.fields.push(reflectionField);
+                }
+            }
+            addType(type);
+        });
+        // 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);
         return Buffer.from(buf, 0, it.offset);
@@ -4695,7 +4730,7 @@ class StateView {
     }
     // TODO: allow to set multiple tags at once
     add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
-        if (!obj[$changes]) {
+        if (!obj?.[$changes]) {
             console.warn("StateView#add(), invalid object:", obj);
             return this;
         }
@@ -4817,7 +4852,7 @@ class StateView {
         }
         this.items.delete(changeTree);
         const ref = changeTree.ref;
-        const metadata = ref.constructor[Symbol.metadata];
+        const metadata = ref.constructor[Symbol.metadata]; // ArraySchema/MapSchema do not have metadata
         let changes = this.changes.get(changeTree.refId);
         if (changes === undefined) {
             changes = {};
@@ -4838,12 +4873,12 @@ class StateView {
             }
             else {
                 // delete all "tagged" properties.
-                metadata[$viewFieldIndexes].forEach((index) => changes[index] = exports.OPERATION.DELETE);
+                metadata?.[$viewFieldIndexes].forEach((index) => changes[index] = exports.OPERATION.DELETE);
             }
         }
         else {
             // delete only tagged properties
-            metadata[$fieldIndexesByViewTag][tag].forEach((index) => changes[index] = exports.OPERATION.DELETE);
+            metadata?.[$fieldIndexesByViewTag][tag].forEach((index) => changes[index] = exports.OPERATION.DELETE);
         }
         // remove tag
         if (this.tags && this.tags.has(changeTree)) {