@colyseus/schema 3.0.0-alpha.4 → 3.0.0-alpha.41

package/src/Reflection.ts

@@ -1,10 +1,12 @@
-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";
 import { Encoder } from "./encoder/Encoder";
 import { Decoder } from "./decoder/Decoder";
 import { Schema } from "./Schema";
+import { $numFields } from "./types/symbols";
 
 /**
  * Reflection
@@ -22,18 +24,32 @@ 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);
-        }
+    @type([ReflectionType]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
+    @type("number") rootType: number;
+
+    /**
+     * Encodes the TypeContext of an Encoder into a buffer.
+     *
+     * @param encoder Encoder instance
+     * @param it
+     * @returns
+     */
+    static encode(encoder: Encoder, it: Iterator = { offset: 0 }) {
+        const context = encoder.context;
 
         const reflection = new Reflection();
-        const encoder = new Encoder(reflection);
+        const reflectionEncoder = new Encoder(reflection);
+
+        // rootType is usually the first schema passed to the Encoder
+        // (unless it inherits from another schema)
+        const rootType = context.schemas.get(encoder.state.constructor);
+        if (rootType > 0) { reflection.rootType = rootType; }
 
         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 +60,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,73 +112,95 @@ export class Reflection extends Schema {
             buildType(type, klass[Symbol.metadata]);
         }
 
-        const it = { offset: 0 };
-        const buf = encoder.encodeAll(it);
+        const buf = reflectionEncoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }
 
-    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): T {
+    /**
+     * Decodes the TypeContext from a buffer into a Decoder instance.
+     *
+     * @param bytes Reflection.encode() output
+     * @param it
+     * @returns Decoder instance
+     */
+    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): Decoder<T> {
         const reflection = new Reflection();
 
         const reflectionDecoder = new Decoder(reflection);
         reflectionDecoder.decode(bytes, it);
 
-        const context = new TypeContext();
-
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const parentKlass: typeof Schema = types[reflectionType.extendsId] || Schema;
-            const schema: typeof Schema = class _ extends parentKlass {};
+        const typeContext = new TypeContext();
 
-            // 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 })
+        // 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 {};
 
             // 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);
 
-        reflection.types.forEach((reflectionType) => {
-            const schemaType = schemaTypes[reflectionType.id];
-            const metadata = schemaType[Symbol.metadata];
-
-            const parentKlass = reflection.types[reflectionType.extendsId];
-            const parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
+            typeContext.add(schema, reflectionType.id);
+        }, {});
 
+        // define fields
+        const addFields = (metadata: Metadata, reflectionType: ReflectionType, parentFieldIndex: number) => {
             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);
+                        Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                     }
 
                 } else {
-                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
                     Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
                 }
             });
+        };
+
+        // 2nd pass, set fields
+        reflection.types.forEach((reflectionType) => {
+            const schema = typeContext.get(reflectionType.id);
+
+            // for inheritance support
+            const metadata = Metadata.initialize(schema);
+
+            const inheritedTypes: ReflectionType[] = [];
+
+            let parentType: ReflectionType = reflectionType;
+            do {
+                inheritedTypes.push(parentType);
+                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+            } while (parentType);
+
+            let parentFieldIndex = 0;
+
+            inheritedTypes.reverse().forEach((reflectionType) => {
+                // add fields from all inherited classes
+                // TODO: refactor this to avoid adding fields from parent classes
+                addFields(metadata, reflectionType, parentFieldIndex);
+                parentFieldIndex += reflectionType.fields.length;
+            });
         });
 
-        return new (schemaTypes[0])();
+        const state: T = new (typeContext.get(reflection.rootType || 0) as unknown as any)();
+
+        return new Decoder<T>(state, typeContext);
     }
 }

package/src/Schema.ts

@@ -1,10 +1,10 @@
 import { OPERATION } from './encoding/spec';
-import { DEFAULT_VIEW_TAG, DefinitionType } from "./annotations";
+import { DEFAULT_VIEW_TAG, type 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 { ChangeSet, ChangeTree, Ref } from './encoder/ChangeTree';
+import { $changes, $decoder, $deleteByIndex, $descriptors, $encoder, $filter, $getByIndex, $track } from './types/symbols';
 import { StateView } from './encoder/StateView';
 
 import { encodeSchemaOperation } from './encoder/EncodeOperation';
@@ -15,11 +15,12 @@ import { getIndent } from './utils';
 /**
  * Schema encoder / decoder
  */
-export abstract class Schema {
-
+export class Schema {
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
+    // public [$changes]: ChangeTree;
+
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -31,37 +32,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 +59,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 +82,17 @@ export abstract class Schema {
 
     // allow inherited classes to have a constructor
     constructor(...args: any[]) {
+        //
+        // inline
+        // Schema.initialize(this);
+        //
         Schema.initialize(this);
 
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
 
@@ -135,21 +110,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 +141,16 @@ 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 +165,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) {
@@ -199,7 +181,7 @@ export abstract class Schema {
         const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
 
         let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (${ref[$changes].refId})${contents}\n`;
+        output += `${getIndent(level)}${ref.constructor.name} (refId: ${ref[$changes].refId})${contents}\n`;
 
         changeTree.forEachChild((childChangeTree) =>
             output += this.debugRefIds(childChangeTree.ref, jsonContents, level + 1));
@@ -216,31 +198,41 @@ export abstract class Schema {
      * @returns
      */
     static debugChanges(instance: Ref, isEncodeAll: boolean = false) {
-        const changeTree = instance[$changes];
+        const changeTree: ChangeTree = instance[$changes];
 
         const changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
         const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
 
         let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
 
-        function dumpChangeSet(changeSet: Map<number, OPERATION>) {
-            Array.from(changeSet)
-                .sort((a, b) => a[0] - b[0])
-                .forEach(([index, operation]) =>
-                    output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(index, isEncodeAll))})\n`
-                );
+        function dumpChangeSet(changeSet: ChangeSet) {
+            changeSet.operations
+                .filter(op => op)
+                .forEach((index) => {
+                    const operation = changeTree.indexedOperations[index];
+                    console.log({ index, operation })
+                    output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(Number(index), isEncodeAll))})\n`
+                });
         }
 
         dumpChangeSet(changeSet);
 
         // display filtered changes
-        if (!isEncodeAll && changeTree.filteredChanges?.size > 0) {
+        if (
+            !isEncodeAll &&
+            changeTree.filteredChanges &&
+            (changeTree.filteredChanges.operations).filter(op => op).length > 0
+        ) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
             dumpChangeSet(changeTree.filteredChanges);
         }
 
         // display filtered changes
-        if (isEncodeAll && changeTree.allFilteredChanges?.size > 0) {
+        if (
+            isEncodeAll &&
+            changeTree.allFilteredChanges &&
+            (changeTree.allFilteredChanges.operations).filter(op => op).length > 0
+        ) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
             dumpChangeSet(changeTree.allFilteredChanges);
         }
@@ -248,16 +240,19 @@ 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];
+        const root = rootChangeTree.root;
         const changeTrees: Map<ChangeTree, ChangeTree[]> = new Map();
 
         let totalInstances = 0;
         let totalOperations = 0;
 
-        for (const [changeTree, changes] of (rootChangeTree.root.changes.entries())) {
+        for (const [refId, changes] of Object.entries(root[changeSetName])) {
+            const changeTree = root.changeTrees[refId];
+
             let includeChangeTree = false;
             let parentChangeTrees: ChangeTree[] = [];
             let parentChangeTree = changeTree.parent?.[$changes];
@@ -278,7 +273,7 @@ export abstract class Schema {
 
             if (includeChangeTree) {
                 totalInstances += 1;
-                totalOperations += changes.size;
+                totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
@@ -299,17 +294,17 @@ export abstract class Schema {
                 }
             });
 
-            const changes = changeTree.changes;
+            const changes = changeTree.indexedOperations;
             const level = parentChangeTrees.length;
             const indent = getIndent(level);
 
             const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
-            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${changes.size}\n`;
+            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${Object.keys(changes).length}\n`;
 
-            for (const [index, operation] of changes) {
+            for (const index in changes) {
+                const operation = changes[index];
                 output += `${getIndent(level + 1)}${OPERATION[operation]}: ${index}\n`;
             }
-
         }
 
         return `${output}`;