@colyseus/schema 3.0.20 → 3.0.21

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");
@@ -4275,50 +4281,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 +4310,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);