@colyseus/schema 2.0.31 → 3.0.0-alpha.0

package/src/Reflection.ts

@@ -1,58 +1,55 @@
-import { type, PrimitiveType, Context, DefinitionType } from "./annotations";
-import { Schema } from "./Schema";
-import { ArraySchema } from "./types/ArraySchema";
-import { getType } from "./types/typeRegistry";
+import { type, PrimitiveType, DefinitionType, TypeContext } from "./annotations";
+import { Metadata } from "./Metadata";
+import { ArraySchema } from "./types/custom/ArraySchema";
 import { Iterator } from "./encoding/decode";
-
-const reflectionContext = { context: new Context() };
+import { Encoder } from "./encoder/Encoder";
+import { Decoder } from "./decoder/Decoder";
+import { Schema } from "./Schema";
 
 /**
  * Reflection
  */
 export class ReflectionField extends Schema {
-    @type("string", reflectionContext)
-    name: string;
-
-    @type("string", reflectionContext)
-    type: string;
-
-    @type("number", reflectionContext)
-    referencedType: number;
+    @type("string") name: string;
+    @type("string") type: string;
+    @type("number") referencedType: number;
 }
 
 export class ReflectionType extends Schema {
-    @type("number", reflectionContext)
-    id: number;
-
-    @type([ ReflectionField ], reflectionContext)
-    fields: ArraySchema<ReflectionField> = new ArraySchema<ReflectionField>();
+    @type("number") id: number;
+    @type("number") extendsId: number;
+    @type([ ReflectionField ]) fields = new ArraySchema<ReflectionField>();
 }
 
 export class Reflection extends Schema {
-    @type([ ReflectionType ], reflectionContext)
-    types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
+    @type([ ReflectionType ]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
 
-    @type("number", reflectionContext)
-    rootType: number;
-
-    static encode (instance: Schema) {
-        const rootSchemaType = instance.constructor as typeof Schema;
+    static encode (instance: Schema, context?: TypeContext) {
+        if (!context) {
+            context = new TypeContext(instance.constructor as typeof Schema);
+        }
 
         const reflection = new Reflection();
-        reflection.rootType = rootSchemaType._typeid;
+        const encoder = new Encoder(reflection);
+
+        const buildType = (currentType: ReflectionType, metadata: Metadata) => {
+            for (const fieldName in metadata) {
+                // skip fields from parent classes
+                if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                    continue;
+                }
 
-        const buildType = (currentType: ReflectionType, schema: any) => {
-            for (let fieldName in schema) {
                 const field = new ReflectionField();
                 field.name = fieldName;
 
                 let fieldType: string;
 
-                if (typeof (schema[fieldName]) === "string") {
-                    fieldType = schema[fieldName];
+                const type = metadata[fieldName].type;
+
+                if (typeof (type) === "string") {
+                    fieldType = type;
 
                 } else {
-                    const type = schema[fieldName];
                     let childTypeSchema: typeof Schema;
 
                     //
@@ -60,7 +57,7 @@ export class Reflection extends Schema {
                     //
                     if (Schema.is(type)) {
                         fieldType = "ref";
-                        childTypeSchema = schema[fieldName];
+                        childTypeSchema = type as typeof Schema;
 
                     } else {
                         fieldType = Object.keys(type)[0];
@@ -74,7 +71,7 @@ export class Reflection extends Schema {
                     }
 
                     field.referencedType = (childTypeSchema)
-                        ? childTypeSchema._typeid
+                        ? context.getTypeId(childTypeSchema)
                         : -1;
                 }
 
@@ -85,24 +82,44 @@ export class Reflection extends Schema {
             reflection.types.push(currentType);
         }
 
-        const types = rootSchemaType._context?.types;
-        for (let typeid in types) {
+        for (let typeid in context.types) {
+            const klass = context.types[typeid];
             const type = new ReflectionType();
             type.id = Number(typeid);
-            buildType(type, types[typeid]._definition.schema);
+
+            // support inheritance
+            const inheritFrom = Object.getPrototypeOf(klass);
+            if (inheritFrom !== Schema) {
+                type.extendsId = context.schemas.get(inheritFrom);
+            }
+
+            buildType(type, klass[Symbol.metadata]);
         }
 
-        return reflection.encodeAll();
+        const it = { offset: 0 };
+        const buf = encoder.encodeAll(it);
+        return Buffer.from(buf, 0, it.offset);
     }
 
-    static decode<T extends Schema = Schema>(bytes: number[], it?: Iterator): T {
-        const context = new Context();
-
+    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): T {
         const reflection = new Reflection();
-        reflection.decode(bytes, it);
+
+        const reflectionDecoder = new Decoder(reflection);
+        reflectionDecoder.decode(bytes, it);
+
+        const context = new TypeContext();
 
         const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const schema: typeof Schema = class _ extends Schema {};
+            const parentKlass: typeof Schema = types[reflectionType.extendsId] || Schema;
+            const schema: typeof Schema = class _ extends parentKlass {};
+
+            // 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 })
+
+            // register for inheritance support
+            TypeContext.register(schema);
+
             const typeid = reflectionType.id;
             types[typeid] = schema
             context.add(schema, typeid);
@@ -111,8 +128,14 @@ export class Reflection extends 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;
+
+            reflectionType.fields.forEach((field, i) => {
+                const fieldIndex = parentFieldIndex + i;
 
-            reflectionType.fields.forEach(field => {
                 if (field.referencedType !== undefined) {
                     let fieldType = field.type;
                     let refType = schemaTypes[field.referencedType];
@@ -125,35 +148,21 @@ export class Reflection extends Schema {
                     }
 
                     if (fieldType === "ref") {
-                        type(refType, { context })(schemaType.prototype, field.name);
+                        // type(refType)(schemaType.prototype, field.name);
+                        Metadata.addField(metadata, fieldIndex, field.name, refType);
 
                     } else {
-                        type({ [fieldType]: refType } as DefinitionType, { context })(schemaType.prototype, field.name);
+                        // 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, { context })(schemaType.prototype, field.name);
+                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
+                    Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
                 }
             });
-        })
-
-        const rootType: any = schemaTypes[reflection.rootType];
-        const rootInstance = new rootType();
-
-        /**
-         * auto-initialize referenced types on root type
-         * to allow registering listeners immediatelly on client-side
-         */
-        for (let fieldName in rootType._definition.schema) {
-            const fieldType = rootType._definition.schema[fieldName];
-
-            if (typeof(fieldType) !== "string") {
-                rootInstance[fieldName] = (typeof (fieldType) === "function")
-                    ? new (fieldType as any)() // is a schema reference
-                    : new (getType(Object.keys(fieldType)[0])).constructor(); // is a "collection"
-            }
-        }
+        });
 
-        return rootInstance;
+        return new (schemaTypes[0])();
     }
 }