@colyseus/schema 3.0.0-alpha.30 → 3.0.0-alpha.32

package/src/encoder/ChangeTree.ts

@@ -32,66 +32,80 @@ export class ChangeTree<T extends Ref=any> {
     refId: number;
 
     root?: Root;
-
-    isFiltered?: boolean;
-    isPartiallyFiltered?: boolean;
-
     parent?: Ref;
     parentIndex?: number;
 
-    indexes: {[index: string]: any} = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
+    isFiltered: boolean = false;
+    isPartiallyFiltered: boolean = false;
+
     currentOperationIndex: number = 0;
 
+    changes = new Map<number, OPERATION>();
     allChanges = new Map<number, OPERATION>();
-    allFilteredChanges = new Map<number, OPERATION>();
 
-    changes = new Map<number, OPERATION>();
-    filteredChanges = new Map<number, OPERATION>();;
+    allFilteredChanges: Map<number, OPERATION>;
+    filteredChanges: Map<number, OPERATION>;
+
+    indexes: {[index: string]: any}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
 
     [$isNew] = true;
 
     constructor(ref: T) {
         this.ref = ref;
+
+        //
+        // Does this structure have "filters" declared?
+        //
+        if (ref.constructor[Symbol.metadata]?.[-2]) {
+            this.allFilteredChanges = new Map<number, OPERATION>();
+            this.filteredChanges = new Map<number, OPERATION>();
+        }
     }
 
     setRoot(root: Root) {
         this.root = root;
         this.root.add(this);
 
-        //
-        // At Schema initialization, the "root" structure might not be available
-        // yet, as it only does once the "Encoder" has been set up.
-        //
-        // So the "parent" may be already set without a "root".
-        //
-        this.checkIsFiltered(this.parent, this.parentIndex);
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
 
-        // unique refId for the ChangeTree.
-        this.ensureRefId();
-
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-        }
+        if (this.root.types.hasFilters) {
+            //
+            // At Schema initialization, the "root" structure might not be available
+            // yet, as it only does once the "Encoder" has been set up.
+            //
+            // So the "parent" may be already set without a "root".
+            //
+            this.checkIsFiltered(metadata, this.parent, this.parentIndex);
 
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
+            if (this.isFiltered || this.isPartiallyFiltered) {
+                this.root.allFilteredChanges.set(this, this.allFilteredChanges);
+                this.root.filteredChanges.set(this, this.filteredChanges);
+            }
         }
 
         if (!this.isFiltered) {
+            this.root.changes.set(this, this.changes);
             this.root.allChanges.set(this, this.allChanges);
         }
 
-        this.forEachChild((changeTree, _) => {
-            changeTree.setRoot(root);
-        });
+        this.ensureRefId();
+
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index as any as number];
+                const value = this.ref[field.name];
+                if (value) {
+                    value[$changes].setRoot(root);
+                }
+            });
+
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            (this.ref as MapSchema).forEach((value, key) => {
+                value[$changes].setRoot(root);
+            });
+        }
 
-        // this.allChanges.forEach((_, index) => {
-        //     const childRef = this.ref[$getByIndex](index);
-        //     if (childRef && childRef[$changes]) {
-        //         childRef[$changes].setRoot(root);
-        //     }
-        // });
     }
 
     setParent(
@@ -107,56 +121,71 @@ export class ChangeTree<T extends Ref=any> {
 
         root.add(this);
 
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
+
         // skip if parent is already set
-        if (root === this.root) {
-            this.forEachChild((changeTree, atIndex) => {
-                changeTree.setParent(this.ref, root, atIndex);
-            });
-            return;
-        }
+        if (root !== this.root) {
+            this.root = root;
 
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
+            if (root.types.hasFilters) {
+                this.checkIsFiltered(metadata, parent, parentIndex);
 
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-            this.root.allChanges.set(this, this.allChanges);
-        }
+                if (this.isFiltered || this.isPartiallyFiltered) {
+                    this.root.filteredChanges.set(this, this.filteredChanges);
+                    this.root.allFilteredChanges.set(this, this.filteredChanges);
+                }
+            }
 
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            this.root.allFilteredChanges.set(this, this.filteredChanges);
+            if (!this.isFiltered) {
+                this.root.changes.set(this, this.changes);
+                this.root.allChanges.set(this, this.allChanges);
+            }
+
+            this.ensureRefId();
         }
 
-        this.ensureRefId();
+        // assign same parent on child structures
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index as any as number];
+                const value = this.ref[field.name];
+                value?.[$changes].setParent(this.ref, root, index);
+
+                // console.log(this.ref.constructor.name, field.name, value);
+
+                // try { throw new Error(); } catch (e) {
+                //     console.log(e.stack);
+                // }
+
+            });
+
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            (this.ref as MapSchema).forEach((value, key) => {
+                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+            });
+        }
 
-        this.forEachChild((changeTree, atIndex) => {
-            changeTree.setParent(this.ref, root, atIndex);
-        });
     }
 
     forEachChild(callback: (change: ChangeTree, atIndex: number) => void) {
         //
         // assign same parent on child structures
         //
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata: Metadata = this.ref['constructor'][Symbol.metadata];
-
-            // FIXME: need to iterate over parent metadata instead.
-            for (const field in metadata) {
-                const value = this.ref[field];
-
-                if (value && value[$changes]) {
-                    callback(value[$changes], metadata[field].index);
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index as any as number];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[$changes], index);
                 }
-            }
+            });
 
-        } else if (typeof (this.ref) === "object") {
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             (this.ref as MapSchema).forEach((value, key) => {
-                if (Metadata.isValidInstance(value)) {
-                    callback(value[$changes], this.ref[$changes].indexes[key] ?? key);
-                }
+                callback(value[$changes], this.indexes[key] ?? key);
             });
         }
     }
@@ -167,9 +196,9 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     change(index: number, operation: OPERATION = OPERATION.ADD) {
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
+        const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
 
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
         const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
@@ -181,17 +210,15 @@ export class ChangeTree<T extends Ref=any> {
                 : (previousOperation === OPERATION.DELETE)
                     ? OPERATION.DELETE_AND_ADD
                     : operation
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
             changeSet.set(index, op);
         }
 
-        //
-        // TODO: are DELETE operations being encoded as ADD here ??
-        //
-
         if (isFiltered) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-
             this.allFilteredChanges.set(index, OPERATION.ADD);
+            this.root?.filteredChanges.set(this, this.filteredChanges);
             this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
 
         } else {
@@ -244,10 +271,7 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     indexedOperation(index: number, operation: OPERATION, allChangesIndex = index) {
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-
-        if (isFiltered) {
+        if (this.filteredChanges !== undefined) {
             this.allFilteredChanges.set(allChangesIndex, OPERATION.ADD);
             this.filteredChanges.set(index, operation);
             this.root?.filteredChanges.set(this, this.filteredChanges);
@@ -261,8 +285,8 @@ export class ChangeTree<T extends Ref=any> {
 
     getType(index?: number) {
         if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-            return metadata[metadata[index]].type;
+            const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
+            return metadata[index].type;
 
         } else {
             //
@@ -277,7 +301,7 @@ export class ChangeTree<T extends Ref=any> {
 
     getChange(index: number) {
         // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges.get(index);
+        return this.changes.get(index) ?? this.filteredChanges?.get(index);
     }
 
     //
@@ -300,9 +324,7 @@ export class ChangeTree<T extends Ref=any> {
             return;
         }
 
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        const changeSet = (isFiltered)
+        const changeSet = (this.filteredChanges)
             ? this.filteredChanges
             : this.changes;
 
@@ -312,8 +334,6 @@ export class ChangeTree<T extends Ref=any> {
 
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
-            previousValue[$changes].root = undefined;
-
             //
             // FIXME: this.root is "undefined"
             //
@@ -324,13 +344,20 @@ export class ChangeTree<T extends Ref=any> {
             //
             // (the property descriptors should NOT be used at decoding time. only at encoding time.)
             //
-            this.root?.remove(previousValue[$changes]);
+            const refCount = this.root?.remove(previousValue[$changes]);
+
+            //
+            // Only remove "root" reference if it's the last reference
+            //
+            if (refCount <= 0) {
+                previousValue[$changes].root = undefined;
+            }
         }
 
         //
         // FIXME: this is looking a bit ugly (and repeated from `.change()`)
         //
-        if (isFiltered) {
+        if (this.filteredChanges) {
             this.root?.filteredChanges.set(this, this.filteredChanges);
             this.allFilteredChanges.delete(allChangesIndex);
 
@@ -342,6 +369,8 @@ export class ChangeTree<T extends Ref=any> {
 
     endEncode() {
         this.changes.clear();
+
+        // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
 
         // Not a new instance anymore
@@ -357,14 +386,14 @@ export class ChangeTree<T extends Ref=any> {
         this.ref[$onEncodeEnd]?.();
 
         this.changes.clear();
-        this.filteredChanges.clear();
+        this.filteredChanges?.clear();
 
         // reset operation index
         this.currentOperationIndex = 0;
 
         if (discardAll) {
             this.allChanges.clear();
-            this.allFilteredChanges.clear();
+            this.allFilteredChanges?.clear();
 
             // remove children references
             this.forEachChild((changeTree, _) =>
@@ -400,60 +429,47 @@ export class ChangeTree<T extends Ref=any> {
         return this.changes.size > 0;
     }
 
-    protected checkIsFiltered(parent: Ref, parentIndex: number) {
+    protected checkIsFiltered(metadata: Metadata, parent: Ref, parentIndex: number) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = (this.ref['constructor']?.[Symbol.metadata]?.[-2] !== undefined);
+        this.isPartiallyFiltered = metadata?.[-2] !== undefined;
 
-        if (parent && !Metadata.isValidInstance(parent)) {
-            const parentChangeTree = parent[$changes];
-            parent = parentChangeTree.parent;
-            parentIndex = parentChangeTree.parentIndex;
+        if (this.isPartiallyFiltered) {
+            this.filteredChanges = this.filteredChanges || new Map<number, OPERATION>();
+            this.allFilteredChanges = this.allFilteredChanges || new Map<number, OPERATION>();
         }
 
-        const parentMetadata = parent?.['constructor']?.[Symbol.metadata];
-
-        this.isFiltered = (
-            parent &&
-            parentMetadata?.[-2]?.includes(parentIndex)
-        );
-
-        // this.isFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-4];
-
-        // // Detect if parent has "filters" declared
-        // while (parent && !this.isFiltered) {
-        //     const metadata: Metadata = parent['constructor'][Symbol.metadata];
-        //     // this.isFiltered = metadata?.[-4];
-
-        //     const fieldName = metadata?.[parentIndex];
-        //     const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
-        //     this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
-
-        //     parent = parent[$changes].parent;
-        // };
+        if (parent) {
+            if (!Metadata.isValidInstance(parent)) {
+                const parentChangeTree = parent[$changes];
+                parent = parentChangeTree.parent;
+                parentIndex = parentChangeTree.parentIndex;
+            }
 
-        // console.log("ChangeTree.checkIsFiltered", {
-        //     parent: parent?.constructor.name,
-        //     ref: this.ref.constructor.name,
-        //     isFiltered: this.isFiltered,
-        //     isPartiallyFiltered: this.isPartiallyFiltered,
-        // });
+            const parentMetadata = parent?.constructor?.[Symbol.metadata];
+            this.isFiltered = (parent && parentMetadata?.[-2]?.includes(parentIndex));
 
-        //
-        // TODO: refactor this!
-        //
-        //      swapping `changes` and `filteredChanges` is required here
-        //      because "isFiltered" may not be imedialely available on `change()`
-        //
-        if (this.isFiltered && this.changes.size > 0) {
-            // swap changes reference
-            const changes = this.changes;
-            this.changes = this.filteredChanges;
-            this.filteredChanges = changes;
-
-            // swap "all changes" reference
-            const allFilteredChanges = this.allFilteredChanges;
-            this.allFilteredChanges = this.allChanges;
-            this.allChanges = allFilteredChanges;
+            //
+            // TODO: refactor this!
+            //
+            //      swapping `changes` and `filteredChanges` is required here
+            //      because "isFiltered" may not be imedialely available on `change()`
+            //
+            if (this.isFiltered) {
+                this.filteredChanges = new Map<number, OPERATION>();
+                this.allFilteredChanges = new Map<number, OPERATION>();
+
+                if (this.changes.size > 0) {
+                    // swap changes reference
+                    const changes = this.changes;
+                    this.changes = this.filteredChanges;
+                    this.filteredChanges = changes;
+
+                    // swap "all changes" reference
+                    const allFilteredChanges = this.allFilteredChanges;
+                    this.allFilteredChanges = this.allChanges;
+                    this.allChanges = allFilteredChanges;
+                }
+            }
         }
     }
 

package/src/encoder/EncodeOperation.ts

@@ -1,9 +1,9 @@
 import { OPERATION } from "../encoding/spec";
-import { $changes } from "../types/symbols";
+import { $changes, $childType, $getByIndex } from "../types/symbols";
 import { getType } from "../types/registry";
 
 import * as encode from "../encoding/encode";
-import { EncodeSchemaError, assertInstanceType, assertType } from "../encoding/assert";
+// import { EncodeSchemaError, assertInstanceType, assertType } from "../encoding/assert";
 
 import type { ChangeTree, Ref } from "./ChangeTree";
 import type { Encoder } from "./Encoder";
@@ -12,6 +12,7 @@ import type { PrimitiveType } from "../annotations";
 
 import type { Iterator } from "../encoding/decode";
 import type { ArraySchema } from "../types/custom/ArraySchema";
+import type { Metadata } from "../Metadata";
 
 export type EncodeOperation<T extends Ref = any> = (
     encoder: Encoder,
@@ -24,41 +25,18 @@ export type EncodeOperation<T extends Ref = any> = (
     hasView: boolean,
 ) => void;
 
-export function encodePrimitiveType(
-    type: PrimitiveType,
-    bytes: Buffer,
-    value: any,
-    klass: Schema,
-    field: string | number,
-    it: Iterator,
-) {
-    assertType(value, type as string, klass, field);
-
-    const encodeFunc = encode[type as string];
-
-    if (encodeFunc) {
-        encodeFunc(bytes, value, it);
-        // encodeFunc(bytes, value);
-
-    } else {
-        throw new EncodeSchemaError(`a '${type}' was expected, but ${value} was provided in ${klass.constructor.name}#${field}`);
-    }
-};
-
 export function encodeValue(
     encoder: Encoder,
     bytes: Buffer,
-    ref: Ref,
     type: any,
     value: any,
-    field: string | number,
     operation: OPERATION,
     it: Iterator,
 ) {
-    if (type[Symbol.metadata] !== undefined) {
-        // TODO: move this to the `@type()` annotation
-        assertInstanceType(value, type as typeof Schema, ref as Schema, field);
+    if (typeof (type) === "string") {
+        encode[type]?.(bytes, value, it);
 
+    } else if (type[Symbol.metadata] !== undefined) {
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -70,23 +48,7 @@ export function encodeValue(
             encoder.tryEncodeTypeId(bytes, type as typeof Schema, value.constructor as typeof Schema, it);
         }
 
-    } else if (typeof (type) === "string") {
-        //
-        // Primitive values
-        //
-        encodePrimitiveType(type as PrimitiveType, bytes, value, ref as Schema, field, it);
-
     } else {
-        //
-        // Custom type (MapSchema, ArraySchema, etc)
-        //
-        const definition = getType(Object.keys(type)[0]);
-
-        //
-        // ensure a ArraySchema has been provided
-        //
-        assertInstanceType(ref[field], definition.constructor, ref as Schema, field);
-
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -107,13 +69,6 @@ export const encodeSchemaOperation: EncodeOperation = function (
     operation: OPERATION,
     it: Iterator,
 ) {
-    const ref = changeTree.ref;
-    const metadata = ref['constructor'][Symbol.metadata];
-
-    const field = metadata[index];
-    const type = metadata[field].type;
-    const value = ref[field];
-
     // "compress" field index + operation
     bytes[it.offset++] = (index | operation) & 255;
 
@@ -122,8 +77,19 @@ export const encodeSchemaOperation: EncodeOperation = function (
         return;
     }
 
+    const ref = changeTree.ref;
+    const metadata: Metadata = ref.constructor[Symbol.metadata];
+    const field = metadata[index];
+
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(
+        encoder,
+        bytes,
+        metadata[index].type,
+        ref[field.name],
+        operation,
+        it
+    );
 }
 
 /**
@@ -134,12 +100,10 @@ export const encodeKeyValueOperation: EncodeOperation = function (
     encoder: Encoder,
     bytes: Buffer,
     changeTree: ChangeTree,
-    field: number,
+    index: number,
     operation: OPERATION,
     it: Iterator,
 ) {
-    const ref = changeTree.ref;
-
     // encode operation
     bytes[it.offset++] = operation & 255;
 
@@ -149,28 +113,30 @@ export const encodeKeyValueOperation: EncodeOperation = function (
     }
 
     // encode index
-    encode.number(bytes, field, it);
+    encode.number(bytes, index, it);
 
     // Do not encode value for DELETE operations
     if (operation === OPERATION.DELETE) {
         return;
     }
 
+    const ref = changeTree.ref;
+
     //
     // encode "alias" for dynamic fields (maps)
     //
-    if ((operation & OPERATION.ADD) == OPERATION.ADD) { // ADD or DELETE_AND_ADD
+    if ((operation & OPERATION.ADD) === OPERATION.ADD) { // ADD or DELETE_AND_ADD
         if (typeof(ref['set']) === "function") {
             //
             // MapSchema dynamic key
             //
-            const dynamicIndex = changeTree.ref['$indexes'].get(field);
+            const dynamicIndex = changeTree.ref['$indexes'].get(index);
             encode.string(bytes, dynamicIndex, it);
         }
     }
 
-    const type = changeTree.getType(field);
-    const value = changeTree.getValue(field);
+    const type = ref[$childType];
+    const value = ref[$getByIndex](index);
 
     // try { throw new Error(); } catch (e) {
     //     // only print if not coming from Reflection.ts
@@ -186,7 +152,14 @@ export const encodeKeyValueOperation: EncodeOperation = function (
     // }
 
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(
+        encoder,
+        bytes,
+        type,
+        value,
+        operation,
+        it
+    );
 }
 
 /**
@@ -250,5 +223,12 @@ export const encodeArray: EncodeOperation = function (
     // });
 
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(
+        encoder,
+        bytes,
+        type,
+        value,
+        operation,
+        it
+    );
 }