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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.31",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "./bin/schema-codegen"
   },
   "scripts": {
-    "build": "tsc && rollup -c rollup.config.js",
+    "build": "tsc && rollup -c rollup.config.mjs",
     "watch": "tsc -w",
     "test": "mocha --require ts-node/register test/*.test.ts test/**/*.test.ts",
     "coverage": "nyc mocha --require ts-node/register --require source-map-support/register --recursive test/**Test.ts",
@@ -73,13 +73,13 @@
     "nanoid": "^3.1.10",
     "nyc": "^14.1.1",
     "rimraf": "^3.0.0",
-    "rollup": "^2.40.0",
+    "rollup": "^4.18.0",
     "sinon": "^7.2.2",
     "source-map-support": "^0.5.13",
     "ts-node": "^10.9.2",
     "tslib": "^2.1.0",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
+    "tsx": "^3.13.0",
+    "typescript": "^5.4.5"
   },
   "nyc": {
     "extension": [

package/src/Metadata.ts

@@ -1,40 +1,65 @@
 import { getPropertyDescriptor, type DefinitionType } from "./annotations";
 import { getType } from "./types/registry";
+import { $descriptors } from "./types/symbols";
 
 export type MetadataField = {
     type: DefinitionType,
+    name: string,
     index: number,
     tag?: number,
     unreliable?: boolean,
     deprecated?: boolean,
-    descriptor?: PropertyDescriptor,
 };
 
 export type Metadata =
     { [-1]: number; } & // number of fields
     { [-2]: number[]; } & // all field indexes with "view" tag
     { [-3]: {[tag: number]: number[]}; } & // field indexes by "view" tag
-    { [field: number]: string; } & // index => field name
-    { [field: string]: MetadataField; } // field name => field metadata
+    { [-4]: number[]; } & // all field indexes containing Ref types (Schema, ArraySchema, MapSchema, etc)
+    { [field: number]: MetadataField; } & // index => field name
+    { [field: string]: number; } & // field name => field metadata
+    { [$descriptors]: { [field: string]: PropertyDescriptor } }  // property descriptors
 
 export const Metadata = {
 
-    addField(metadata: any, index: number, field: string, type: DefinitionType, descriptor?: PropertyDescriptor) {
+    addField(metadata: any, index: number, name: string, type: DefinitionType, descriptor?: PropertyDescriptor) {
         if (index > 64) {
-            throw new Error(`Can't define field '${field}'.\nSchema instances may only have up to 64 fields.`);
+            throw new Error(`Can't define field '${name}'.\nSchema instances may only have up to 64 fields.`);
         }
 
-        metadata[field] = Object.assign(
-            metadata[field] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
+        metadata[index] = Object.assign(
+            metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
             {
                 type: (Array.isArray(type))
                     ? { array: type[0] }
                     : type,
                 index,
-                descriptor,
+                name,
             }
         );
 
+        // create "descriptors" map
+        metadata[$descriptors] ??= {};
+
+        if (descriptor) {
+            // for encoder
+            metadata[$descriptors][name] = descriptor;
+            metadata[$descriptors][`_${name}`] = {
+                value: undefined,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            };
+        } else {
+            // for decoder
+            metadata[$descriptors][name] = {
+                value: undefined,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            };
+        }
+
         // map -1 as last field index
         Object.defineProperty(metadata, -1, {
             value: index,
@@ -42,17 +67,31 @@ export const Metadata = {
             configurable: true
         });
 
-        // map index => field name (non enumerable)
-        Object.defineProperty(metadata, index, {
-            value: field,
+        // map field name => index (non enumerable)
+        Object.defineProperty(metadata, name, {
+            value: index,
             enumerable: false,
             configurable: true,
         });
+
+        // if child Ref/complex type, add to -4
+        if (typeof (metadata[index].type) !== "string") {
+            if (metadata[-4] === undefined) {
+                Object.defineProperty(metadata, -4, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                });
+            }
+            metadata[-4].push(index);
+        }
     },
 
     setTag(metadata: Metadata, fieldName: string, tag: number) {
+        const index = metadata[fieldName];
+        const field = metadata[index];
+
         // add 'tag' to the field
-        const field = metadata[fieldName];
         field.tag = tag;
 
         if (!metadata[-2]) {
@@ -71,27 +110,18 @@ export const Metadata = {
             });
         }
 
-        metadata[-2].push(field.index);
+        metadata[-2].push(index);
 
         if (!metadata[-3][tag]) {
             metadata[-3][tag] = [];
         }
 
-        metadata[-3][tag].push(field.index);
+        metadata[-3][tag].push(index);
     },
 
     setFields(target: any, fields: { [field: string]: DefinitionType }) {
         const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
 
-        // target[$track] = function (changeTree, index: number, operation: OPERATION = OPERATION.ADD) {
-        //     changeTree.change(index, operation, encodeSchemaOperation);
-        // };
-
-        // target[$encoder] = encodeSchemaOperation;
-        // target[$decoder] = decodeSchemaOperation;
-
-        // if (!target.prototype.toJSON) { target.prototype.toJSON = Schema.prototype.toJSON; }
-
         let index = 0;
         for (const field in fields) {
             const type = fields[field];
@@ -106,7 +136,7 @@ export const Metadata = {
                 index,
                 field,
                 type,
-                getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass, metadata, field)
+                getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass)
             );
 
             index++;
@@ -117,6 +147,54 @@ export const Metadata = {
         return metadata[field].deprecated === true;
     },
 
+    init(klass: any) {
+        //
+        // Used only to initialize an empty Schema (Encoder#constructor)
+        // TODO: remove/refactor this...
+        //
+        const metadata = {};
+        klass[Symbol.metadata] = metadata;
+        Object.defineProperty(metadata, -1, {
+            value: 0,
+            enumerable: false,
+            configurable: true,
+        });
+    },
+
+    initialize(constructor: any, parentMetadata?: Metadata) {
+        let metadata: Metadata = constructor[Symbol.metadata] ?? Object.create(null);
+
+        // make sure inherited classes have their own metadata object.
+        if (constructor[Symbol.metadata] === parentMetadata) {
+            metadata = Object.create(null);
+
+            if (parentMetadata) {
+                // assign parent metadata to current
+                Object.assign(metadata, parentMetadata);
+
+                for (let i = 0; i <= parentMetadata[-1]; i++) {
+                    const fieldName = parentMetadata[i].name;
+                    Object.defineProperty(metadata, fieldName, {
+                        value: parentMetadata[fieldName],
+                        enumerable: false,
+                        configurable: true,
+                    });
+                }
+
+                Object.defineProperty(metadata, -1, {
+                    value: parentMetadata[-1],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+        }
+
+        constructor[Symbol.metadata] = metadata;
+
+        return metadata;
+    },
+
     isValidInstance(klass: any) {
         return (
             klass.constructor[Symbol.metadata] &&
@@ -125,10 +203,10 @@ export const Metadata = {
     },
 
     getFields(klass: any) {
-        const metadata = klass[Symbol.metadata];
+        const metadata: Metadata = klass[Symbol.metadata];
         const fields = {};
         for (let i = 0; i <= metadata[-1]; i++) {
-            fields[metadata[i]] = metadata[metadata[i]].type;
+            fields[metadata[i].name] = metadata[i].type;
         }
         return fields;
     }

package/src/Reflection.ts

@@ -1,4 +1,5 @@
-import { type, PrimitiveType, DefinitionType, TypeContext } from "./annotations";
+import { type, PrimitiveType, DefinitionType } from "./annotations";
+import { TypeContext } from "./types/TypeContext";
 import { Metadata } from "./Metadata";
 import { ArraySchema } from "./types/custom/ArraySchema";
 import { Iterator } from "./encoding/decode";
@@ -24,16 +25,17 @@ export class ReflectionType extends Schema {
 export class Reflection extends Schema {
     @type([ ReflectionType ]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
 
-    static encode (instance: Schema, context?: TypeContext) {
-        if (!context) {
-            context = new TypeContext(instance.constructor as typeof Schema);
-        }
+    static encode(instance: Schema, context?: TypeContext, it: Iterator = { offset: 0 }) {
+        context ??= new TypeContext(instance.constructor as typeof Schema);
 
         const reflection = new Reflection();
         const encoder = new Encoder(reflection);
 
         const buildType = (currentType: ReflectionType, metadata: Metadata) => {
-            for (const fieldName in 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;
@@ -44,7 +46,7 @@ export class Reflection extends Schema {
 
                 let fieldType: string;
 
-                const type = metadata[fieldName].type;
+                const type = metadata[index].type;
 
                 if (typeof (type) === "string") {
                     fieldType = type;
@@ -96,7 +98,6 @@ export class Reflection extends Schema {
             buildType(type, klass[Symbol.metadata]);
         }
 
-        const it = { offset: 0 };
         const buf = encoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }
@@ -107,62 +108,59 @@ export class Reflection extends Schema {
         const reflectionDecoder = new Decoder(reflection);
         reflectionDecoder.decode(bytes, it);
 
-        const context = new TypeContext();
+        const typeContext = new TypeContext();
 
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const parentKlass: typeof Schema = types[reflectionType.extendsId] || Schema;
-            const schema: typeof Schema = class _ extends parentKlass {};
+        // 1st pass, initialize metadata + inheritance
+        reflection.types.forEach((reflectionType) => {
+            const parentClass: typeof Schema = typeContext.get(reflectionType.extendsId) ?? Schema;
+            const schema: typeof Schema = class _ extends parentClass {};
 
-            // const _metadata = Object.create(_classSuper[Symbol.metadata] ?? null);
-            const _metadata = parentKlass && parentKlass[Symbol.metadata] || Object.create(null);
-            Object.defineProperty(schema, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata })
+            const parentMetadata = parentClass[Symbol.metadata];
 
             // register for inheritance support
             TypeContext.register(schema);
 
-            const typeid = reflectionType.id;
-            types[typeid] = schema
-            context.add(schema, typeid);
-            return types;
+            // for inheritance support
+            Metadata.initialize(schema, parentMetadata);
+
+            typeContext.add(schema, reflectionType.id);
         }, {});
 
+        // 2nd pass, set fields
         reflection.types.forEach((reflectionType) => {
-            const schemaType = schemaTypes[reflectionType.id];
+            const schemaType = typeContext.get(reflectionType.id);
             const metadata = schemaType[Symbol.metadata];
 
-            const parentKlass = reflection.types[reflectionType.extendsId];
-            const parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
+            const parentFieldIndex = 0;
 
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
 
                 if (field.referencedType !== undefined) {
                     let fieldType = field.type;
-                    let refType = schemaTypes[field.referencedType];
+                    let refType: PrimitiveType = typeContext.get(field.referencedType);
 
                     // map or array of primitive type (-1)
                     if (!refType) {
                         const typeInfo = field.type.split(":");
                         fieldType = typeInfo[0];
-                        refType = typeInfo[1];
+                        refType = typeInfo[1] as PrimitiveType; // string
                     }
 
                     if (fieldType === "ref") {
-                        // type(refType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, refType);
 
                     } else {
-                        // type({ [fieldType]: refType } as DefinitionType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType } as DefinitionType);
                     }
 
                 } else {
-                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
                     Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
                 }
             });
         });
 
-        return new (schemaTypes[0])();
+        // @ts-ignore
+        return new (typeContext.get(0))();
     }
 }

package/src/Schema.ts

@@ -4,7 +4,7 @@ import { DEFAULT_VIEW_TAG, DefinitionType } from "./annotations";
 import { NonFunctionPropNames, ToJSON } from './types/HelperTypes';
 
 import { ChangeTree, Ref } from './encoder/ChangeTree';
-import { $changes, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $track } from './types/symbols';
+import { $changes, $decoder, $deleteByIndex, $descriptors, $encoder, $filter, $getByIndex, $track } from './types/symbols';
 import { StateView } from './encoder/StateView';
 
 import { encodeSchemaOperation } from './encoder/EncodeOperation';
@@ -16,7 +16,6 @@ import { getIndent } from './utils';
  * Schema encoder / decoder
  */
 export abstract class Schema {
-
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
@@ -31,37 +30,7 @@ export abstract class Schema {
             writable: true
         });
 
-        const metadata = instance.constructor[Symbol.metadata];
-
-        // Define property descriptors
-        for (const field in metadata) {
-            if (metadata[field].descriptor) {
-                // for encoder
-                Object.defineProperty(instance, `_${field}`, {
-                    value: undefined,
-                    writable: true,
-                    enumerable: false,
-                    configurable: true,
-                });
-                Object.defineProperty(instance, field, metadata[field].descriptor);
-
-            } else {
-                // for decoder
-                Object.defineProperty(instance, field,  {
-                    value: undefined,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
-
-            // Object.defineProperty(instance, field, {
-            //     ...instance.constructor[Symbol.metadata][field].descriptor
-            // });
-            // if (args[0]?.hasOwnProperty(field)) {
-            //     instance[field] = args[0][field];
-            // }
-        }
+        Object.defineProperties(instance, instance.constructor[Symbol.metadata]?.[$descriptors] || {});
     }
 
     static is(type: DefinitionType) {
@@ -88,7 +57,7 @@ export abstract class Schema {
      */
     static [$filter] (ref: Schema, index: number, view: StateView) {
         const metadata: Metadata = ref.constructor[Symbol.metadata];
-        const tag = metadata[metadata[index]].tag;
+        const tag = metadata[index]?.tag;
 
         if (view === undefined) {
             // shared pass/encode: encode if doesn't have a tag
@@ -111,13 +80,24 @@ export abstract class Schema {
 
     // allow inherited classes to have a constructor
     constructor(...args: any[]) {
-        Schema.initialize(this);
+        //
+        // inline
+        // Schema.initialize(this);
+        //
+
+        Object.defineProperty(this, $changes, {
+            value: new ChangeTree(this),
+            enumerable: false,
+            writable: true
+        });
+
+        Object.defineProperties(this, this.constructor[Symbol.metadata]?.[$descriptors] || {});
 
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
 
@@ -135,21 +115,25 @@ export abstract class Schema {
      * @param operation OPERATION to perform (detected automatically)
      */
     public setDirty<K extends NonFunctionPropNames<this>>(property: K | number, operation?: OPERATION) {
+        const metadata: Metadata = this.constructor[Symbol.metadata];
         this[$changes].change(
-            this.constructor[Symbol.metadata][property as string].index,
+            metadata[metadata[property as string]].index,
             operation
         );
     }
 
     clone (): this {
         const cloned = new ((this as any).constructor);
-        const metadata = this.constructor[Symbol.metadata];
+        const metadata: Metadata = this.constructor[Symbol.metadata];
 
         //
         // TODO: clone all properties, not only annotated ones
         //
         // for (const field in this) {
-        for (const field in metadata) {
+        for (const fieldIndex in metadata) {
+            // const field = metadata[metadata[fieldIndex]].name;
+            const field = metadata[fieldIndex as any as number].name;
+
             if (
                 typeof (this[field]) === "object" &&
                 typeof (this[field]?.clone) === "function"
@@ -162,15 +146,17 @@ export abstract class Schema {
                 cloned[field] = this[field];
             }
         }
+
         return cloned;
     }
 
     toJSON () {
-        const metadata = this.constructor[Symbol.metadata];
-
         const obj: unknown = {};
-        for (const fieldName in metadata) {
-            const field = metadata[fieldName];
+
+        const metadata = this.constructor[Symbol.metadata];
+        for (const index in metadata) {
+            const field = metadata[index];
+            const fieldName = field.name;
             if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                 obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
                     ? this[fieldName]['toJSON']()
@@ -185,11 +171,13 @@ export abstract class Schema {
     }
 
     protected [$getByIndex](index: number) {
-        return this[this.constructor[Symbol.metadata][index]];
+        const metadata: Metadata = this.constructor[Symbol.metadata];
+        return this[metadata[index].name];
     }
 
     protected [$deleteByIndex](index: number) {
-        this[this.constructor[Symbol.metadata][index]] = undefined;
+        const metadata: Metadata = this.constructor[Symbol.metadata];
+        this[metadata[index].name] = undefined;
     }
 
     static debugRefIds(instance: Ref, jsonContents: boolean = true, level: number = 0) {
@@ -248,7 +236,7 @@ export abstract class Schema {
         return output;
     }
 
-    static debugChangesDeep(ref: Ref) {
+    static debugChangesDeep(ref: Ref, changeSetName: "changes" | "allChanges" | "allFilteredChanges" | "filteredChanges" = "changes") {
         let output = "";
 
         const rootChangeTree = ref[$changes];
@@ -257,7 +245,7 @@ export abstract class Schema {
         let totalInstances = 0;
         let totalOperations = 0;
 
-        for (const [changeTree, changes] of (rootChangeTree.root.changes.entries())) {
+        for (const [changeTree, changes] of (rootChangeTree.root[changeSetName].entries())) {
             let includeChangeTree = false;
             let parentChangeTrees: ChangeTree[] = [];
             let parentChangeTree = changeTree.parent?.[$changes];