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

package/src/annotations.ts

@@ -3,10 +3,12 @@ import { Schema } from './Schema';
 import { ArraySchema } from './types/custom/ArraySchema';
 import { MapSchema } from './types/custom/MapSchema';
 import { Metadata } from "./Metadata";
-import { $changes, $childType, $track } from "./types/symbols";
+import { $changes, $childType, $descriptors, $track } from "./types/symbols";
 import { TypeDefinition, getType } from "./types/registry";
 import { OPERATION } from "./encoding/spec";
 import { TypeContext } from "./types/TypeContext";
+import { assertInstanceType, assertType } from "./encoding/assert";
+import type { Ref } from "./encoder/ChangeTree";
 
 /**
  * Data types
@@ -227,18 +229,19 @@ export function view<T> (tag: number = DEFAULT_VIEW_TAG) {
 
         // TODO: use Metadata.initialize()
         const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-
-        if (!metadata[fieldName]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[fieldName] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            }
-        }
+        // const fieldIndex = metadata[fieldName];
+
+        // if (!metadata[fieldIndex]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[fieldIndex] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
 
         Metadata.setTag(metadata, fieldName, tag);
     }
@@ -256,20 +259,20 @@ export function unreliable<T> (target: T, field: string) {
     // TODO: use Metadata.initialize()
     const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
 
-    if (!metadata[field]) {
-        //
-        // detect index for this field, considering inheritance
-        //
-        metadata[field] = {
-            type: undefined,
-            index: (metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                ?? -1) + 1 // no fields defined
-        }
-    }
+    // if (!metadata[field]) {
+    //     //
+    //     // detect index for this field, considering inheritance
+    //     //
+    //     metadata[field] = {
+    //         type: undefined,
+    //         index: (metadata[-1] // current structure already has fields defined
+    //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+    //             ?? -1) + 1 // no fields defined
+    //     }
+    // }
 
     // add owned flag to the field
-    metadata[field].unreliable = true;
+    metadata[metadata[field]].unreliable = true;
 }
 
 export function type (
@@ -290,17 +293,17 @@ export function type (
         const parentMetadata = parentClass && parentClass[Symbol.metadata];
         const metadata = Metadata.initialize(constructor, parentMetadata);
 
-        let fieldIndex: number;
+        let fieldIndex: number = metadata[field];
 
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[field]) {
-            if (metadata[field].deprecated) {
+        if (metadata[fieldIndex]) {
+            if (metadata[fieldIndex].deprecated) {
                 // do not create accessors for deprecated properties.
                 return;
 
-            } else if (metadata[field].descriptor !== undefined) {
+            } else if (metadata[fieldIndex].type !== undefined) {
                 // trying to define same property multiple times across inheritance.
                 // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
                 try {
@@ -310,9 +313,6 @@ export function type (
                     const definitionAtLine = e.stack.split("\n")[4].trim();
                     throw new Error(`${e.message} ${definitionAtLine}`);
                 }
-
-            } else {
-                fieldIndex = metadata[field].index;
             }
 
         } else {
@@ -326,12 +326,18 @@ export function type (
         }
 
         if (options && options.manual) {
-            Metadata.addField(metadata, fieldIndex, field, type, {
-                // do not declare getter/setter descriptor
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
+            Metadata.addField(
+                metadata,
+                fieldIndex,
+                field,
+                type,
+                {
+                    // do not declare getter/setter descriptor
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                }
+            );
 
         } else {
             const complexTypeKlass = (Array.isArray(type))
@@ -347,7 +353,7 @@ export function type (
                 fieldIndex,
                 field,
                 type,
-                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass, metadata, field)
+                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass)
             );
         }
     }
@@ -358,8 +364,6 @@ export function getPropertyDescriptor(
     fieldIndex: number,
     type: DefinitionType,
     complexTypeKlass: TypeDefinition,
-    metadata: Metadata,
-    field: string,
 ) {
     return {
         get: function () { return this[fieldCached]; },
@@ -385,30 +389,32 @@ export function getPropertyDescriptor(
                     }
 
                     value[$childType] = type;
+
+                } else if (typeof (type) !== "string") {
+                    assertInstanceType(value, type as typeof Schema, this, fieldCached.substring(1));
+
+                } else {
+                    assertType(value, type, this, fieldCached.substring(1));
                 }
 
+                const changeTree = this[$changes];
+
                 //
                 // Replacing existing "ref", remove it from root.
                 // TODO: if there are other references to this instance, we should not remove it from root.
                 //
                 if (previousValue !== undefined && previousValue[$changes]) {
-                    this[$changes].root?.remove(previousValue[$changes]);
+                    changeTree.root?.remove(previousValue[$changes]);
                 }
 
                 // flag the change for encoding.
-                this.constructor[$track](this[$changes], fieldIndex, OPERATION.ADD);
+                this.constructor[$track](changeTree, fieldIndex, OPERATION.ADD);
 
                 //
                 // call setParent() recursively for this and its child
                 // structures.
                 //
-                if (value[$changes]) {
-                    value[$changes].setParent(
-                        this,
-                        this[$changes].root,
-                        metadata[field].index,
-                    );
-                }
+                (value as Ref)[$changes]?.setParent(this, changeTree.root, fieldIndex);
 
             } else if (previousValue !== undefined) {
                 //
@@ -440,23 +446,25 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
         const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-
-        if (!metadata[field]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[field] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            }
-        }
-
-        metadata[field].deprecated = true;
+        const fieldIndex = metadata[field];
+
+        // if (!metadata[field]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[field] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
+
+        metadata[fieldIndex].deprecated = true;
 
         if (throws) {
-            metadata[field].descriptor = {
+            metadata[$descriptors] ??= {};
+            metadata[$descriptors][field] = {
                 get: function () { throw new Error(`${field} is deprecated.`); },
                 set: function (this: Schema, value: any) { /* throw new Error(`${field} is deprecated.`); */ },
                 enumerable: false,
@@ -465,8 +473,8 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
         }
 
         // flag metadata[field] as non-enumerable
-        Object.defineProperty(metadata, field, {
-            value: metadata[field],
+        Object.defineProperty(metadata, fieldIndex, {
+            value: metadata[fieldIndex],
             enumerable: false,
             configurable: true
         });

package/src/bench_encode.ts

@@ -31,7 +31,33 @@ class State extends Schema {
 
 const state = new State();
 
-for (let i = 0; i < 50; i++) {
+Encoder.BUFFER_SIZE = 4096 * 4096;
+const encoder = new Encoder(state);
+
+// // SINGLE TESTING
+// console.log("> Will create player...");
+// const player = new Player();
+// console.log("... players.set()")
+// state.players.set(`p-${nanoid()}`, player);
+// player.position.x = 100;
+// player.position.y = 100;
+// console.log("> Will create Item...");
+// const item = new Item();
+// item.price = 50;
+
+// console.log("> Will create Attribute...");
+// const attr = new Attribute();
+// attr.name = `Attribute 1`;
+// attr.value = 1;
+// console.log("... item.attributes.push()")
+// item.attributes.push(attr);
+
+// console.log("... player.items.set()")
+// player.items.set(`item-1`, item);
+
+let now = Date.now();
+for (let i = 0; i < 10000; i++) {
+// for (let i = 0; i < 10; i++) {
     const player = new Player();
     state.players.set(`p-${nanoid()}`, player);
 
@@ -39,29 +65,28 @@ for (let i = 0; i < 50; i++) {
     player.position.y = (i + 1) * 100;
     for (let j = 0; j < 10; j++) {
         const item = new Item();
+        player.items.set(`item-${j}`, item);
         item.price = (i + 1) * 50;
         for (let k = 0; k < 5; k++) {
             const attr = new Attribute();
             attr.name = `Attribute ${k}`;
             attr.value = k;
             item.attributes.push(attr);
-
         }
-        player.items.set(`item-${j}`, item);
     }
 }
+console.log("time to make changes:", Date.now() - now);
 
+// process.exit();
 
-Encoder.BUFFER_SIZE = 4096 * 4096;
-const encoder = new Encoder(state);
 
 // measure time to .encodeAll()
 
-let now = Date.now();
-for (let i = 0; i < 1000; i++) {
-    encoder.encodeAll();
-}
-console.log(Date.now() - now);
+now = Date.now();
+// for (let i = 0; i < 1000; i++) {
+//     encoder.encodeAll();
+// }
+// console.log(Date.now() - now);
 
 const allEncodes = Date.now();
 for (let i = 0; i < 100; i++) {
@@ -80,7 +105,6 @@ for (let i = 0; i < 100; i++) {
                 attr.name = `Attribute ${l}`;
                 attr.value = l;
                 item.attributes.push(attr);
-
             }
             player.items.set(`item-${k}`, item);
         }
@@ -88,10 +112,10 @@ for (let i = 0; i < 100; i++) {
     console.log("time to make changes:", Date.now() - now);
 
     now = Date.now();
-    encoder.encode();
+    // encoder.encode();
     encoder.discardChanges();
     console.log("time to encode:", Date.now() - now);
 }
 console.log("time for all encodes:", Date.now() - allEncodes);
 
-console.log(Array.from(encoder.encodeAll()).length, "bytes");
+// console.log(Array.from(encoder.encodeAll()).length, "bytes");

package/src/decoder/DecodeOperation.ts

@@ -174,7 +174,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
     allChanges: DataChange[],
 ) {
     const first_byte = bytes[it.offset++];
-    const metadata: Metadata = ref['constructor'][Symbol.metadata];
+    const metadata: Metadata = ref.constructor[Symbol.metadata];
 
     // "compressed" index + operation
     const operation = (first_byte >> 6) << 6
@@ -192,14 +192,14 @@ export const decodeSchemaOperation: DecodeOperation = function (
         operation,
         ref,
         index,
-        metadata[field].type,
+        field.type,
         bytes,
         it,
         allChanges,
     );
 
     if (value !== null && value !== undefined) {
-        ref[field] = value;
+        ref[field.name] = value;
     }
 
     // add change
@@ -208,7 +208,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
             ref,
             refId: decoder.currentRefId,
             op: operation,
-            field: field,
+            field: field.name,
             value,
             previousValue,
         });
@@ -308,8 +308,6 @@ export const decodeArray: DecodeOperation = function (
 ) {
     // "uncompressed" index + operation (array/map items)
     let operation = bytes[it.offset++];
-
-    let isSchemaChild: boolean;
     let index: number;
 
     if (operation === OPERATION.CLEAR) {
@@ -341,9 +339,6 @@ export const decodeArray: DecodeOperation = function (
         return;
 
     } else if (operation === OPERATION.ADD_BY_REFID) {
-        isSchemaChild = true;
-        // operation = OPERATION.ADD;
-
         const refId = decode.number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
 
@@ -353,7 +348,6 @@ export const decodeArray: DecodeOperation = function (
             : ref.length;
 
     } else {
-        isSchemaChild = false;
         index = decode.number(bytes, it);
     }
 

package/src/decoder/ReferenceTracker.ts

@@ -98,8 +98,9 @@ export class ReferenceTracker {
             // Ensure child schema instances have their references removed as well.
             //
             if (Metadata.isValidInstance(ref)) {
-                const metadata: Metadata = ref['constructor'][Symbol.metadata];
-                for (const field in metadata) {
+                const metadata: Metadata = ref.constructor[Symbol.metadata];
+                for (const index in metadata) {
+                    const field = metadata[index as any as number].name;
                     const childRefId = typeof(ref[field]) === "object" && this.refIds.get(ref[field]);
                     if (childRefId) {
                         this.removeRef(childRefId);

package/src/decoder/strategy/StateCallbacks.ts

@@ -264,7 +264,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 //
                 bindTo: function bindTo(targetObject: any, properties?: string[]) {
                     if (!properties) {
-                        properties = Object.keys(metadata);
+                        properties = Object.keys(metadata).map((index) => metadata[index as any as number].name);
                     }
                     return $root.addCallback(
                         $root.refIds.get(context.instance),
@@ -277,7 +277,8 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 }
             }, {
                 get(target, prop: string) {
-                    if (metadata[prop]) {
+                    const metadataField = metadata[metadata[prop]];
+                    if (metadataField) {
                         const instance = context.instance?.[prop];
                         const onInstanceAvailable: OnInstanceAvailableCallback = (
                             (callback: (ref: Ref, existing: boolean) => void) => {
@@ -297,7 +298,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                                 }
                             }
                         );
-                        return getProxy(metadata[prop].type, {
+                        return getProxy(metadataField.type, {
                             // make sure refId is available, otherwise need to wait for the instance to be available.
                             instance: ($root.refIds.get(instance) && instance),
                             parentInstance: context.instance,