Merge pull request #208 from colyseus/plain-schema-definition

Implement schema init() method

Author: endel

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.62",
+  "version": "3.0.63",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "bin/schema-codegen",
@@ -81,7 +81,7 @@
     "ts-node": "^10.9.2",
     "tslib": "^2.1.0",
     "tsx": "^3.13.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.9.3"
   },
   "nyc": {
     "extension": [

package.json

@@ -22,7 +22,7 @@ export type Metadata =
     { [field: string]: number; } & // field name => field metadata
     { [$descriptors]: { [field: string]: PropertyDescriptor } }  // property descriptors
 
-export function getNormalizedType(type: DefinitionType): DefinitionType  {
+export function getNormalizedType(type: any): DefinitionType  {
     if (Array.isArray(type)) {
         return { array: getNormalizedType(type[0]) };
 
@@ -308,7 +308,7 @@ export const Metadata = {
 
     getFields(klass: any) {
         const metadata: Metadata = klass[Symbol.metadata];
-        const fields = {};
+        const fields: any = {};
         for (let i = 0; i <= metadata[$numFields]; i++) {
             fields[metadata[i].name] = metadata[i].type;
         }

src/Metadata.ts

@@ -117,11 +117,11 @@ export class Reflection extends Schema {
                         } else {
                             fieldType = Object.keys(field.type)[0];
 
-                            if (typeof (field.type[fieldType]) === "string") {
-                                fieldType += ":" + field.type[fieldType]; // array:string
+                            if (typeof (field.type[fieldType as keyof typeof field.type]) === "string") {
+                                fieldType += ":" + field.type[fieldType as keyof typeof field.type]; // array:string
 
                             } else {
-                                childTypeSchema = field.type[fieldType];
+                                childTypeSchema = field.type[fieldType as keyof typeof field.type];
                             }
                         }
 
@@ -145,7 +145,8 @@ export class Reflection extends Schema {
         }
 
         const buf = reflectionEncoder.encodeAll(it);
-        return Buffer.from(buf, 0, it.offset);
+        return buf.slice(0, it.offset)
+        // return Buffer.from(buf, 0, it.offset);
     }
 
     /**

src/Reflection.ts

@@ -1,23 +1,24 @@
 import { OPERATION } from './encoding/spec';
 import { DEFAULT_VIEW_TAG, type DefinitionType } from "./annotations";
 
-import { NonFunctionPropNames, ToJSON } from './types/HelperTypes';
+import { AssignableProps, NonFunctionPropNames, ToJSON } from './types/HelperTypes';
 
-import { ChangeSet, ChangeSetName, ChangeTree, Ref } from './encoder/ChangeTree';
+import { ChangeSet, ChangeSetName, ChangeTree, IRef, 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';
 import { decodeSchemaOperation } from './decoder/DecodeOperation';
 
 import type { Decoder } from './decoder/Decoder';
-import type { Metadata } from './Metadata';
+import type { Metadata, MetadataField } from './Metadata';
 import { getIndent } from './utils';
 
 /**
  * Schema encoder / decoder
  */
-export class Schema {
+export class Schema<C = any> implements IRef {
+    static [Symbol.metadata]: Metadata;
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
@@ -36,9 +37,7 @@ export class Schema {
     }
 
     static is(type: DefinitionType) {
-        return typeof(type[Symbol.metadata]) === "object";
-        // const metadata = type[Symbol.metadata];
-        // return metadata && Object.prototype.hasOwnProperty.call(metadata, -1);
+        return typeof((type as typeof Schema)[Symbol.metadata]) === "object";
     }
 
     /**
@@ -58,7 +57,7 @@ export class Schema {
      * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
      */
     static [$filter] (ref: Schema, index: number, view: StateView) {
-        const metadata: Metadata = ref.constructor[Symbol.metadata];
+        const metadata: Metadata = (ref.constructor as typeof Schema)[Symbol.metadata];
         const tag = metadata[index]?.tag;
 
         if (view === undefined) {
@@ -81,7 +80,7 @@ export class Schema {
     }
 
     // allow inherited classes to have a constructor
-    constructor(...args: any[]) {
+    constructor(arg?: C) {
         //
         // inline
         // Schema.initialize(this);
@@ -91,14 +90,14 @@ export class Schema {
         //
         // Assign initial values
         //
-        if (args[0]) {
-            Object.assign(this, args[0]);
+        if (arg) {
+            Object.assign(this, arg);
         }
     }
 
-    public assign(
-        props: { [prop in NonFunctionPropNames<this>]?: this[prop] } | ToJSON<this>,
-    ) {
+    public assign<T extends Partial<this>>(
+        props: AssignableProps<T>,
+    ): this {
         Object.assign(this, props);
         return this;
     }
@@ -110,7 +109,7 @@ export 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];
+        const metadata: Metadata = (this.constructor as typeof Schema)[Symbol.metadata];
         this[$changes].change(
             metadata[metadata[property as string]].index,
             operation
@@ -119,22 +118,21 @@ export class Schema {
 
     clone (): this {
         const cloned = new ((this as any).constructor);
-        const metadata: Metadata = this.constructor[Symbol.metadata];
+        const metadata: Metadata = (this.constructor as typeof Schema)[Symbol.metadata];
 
         //
         // TODO: clone all properties, not only annotated ones
         //
         // for (const field in this) {
         for (const fieldIndex in metadata) {
-            // const field = metadata[metadata[fieldIndex]].name;
-            const field = metadata[fieldIndex as any as number].name;
+            const field = metadata[fieldIndex as any as number].name as keyof this;
 
             if (
                 typeof (this[field]) === "object" &&
-                typeof (this[field]?.clone) === "function"
+                typeof ((this[field] as any)?.clone) === "function"
             ) {
                 // deep clone
-                cloned[field] = this[field].clone();
+                cloned[field] = (this[field] as any).clone();
 
             } else {
                 // primitive values
@@ -145,11 +143,11 @@ export class Schema {
         return cloned;
     }
 
-    toJSON () {
-        const obj: unknown = {};
+    toJSON (this: any) {
+        const obj: any = {};
         const metadata = this.constructor[Symbol.metadata];
         for (const index in metadata) {
-            const field = metadata[index];
+            const field = metadata[index] as MetadataField;
             const fieldName = field.name;
             if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                 obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
@@ -168,14 +166,14 @@ export class Schema {
         this[$changes].discardAll();
     }
 
-    protected [$getByIndex](index: number) {
-        const metadata: Metadata = this.constructor[Symbol.metadata];
-        return this[metadata[index].name];
+    [$getByIndex](index: number): any {
+        const metadata: Metadata = (this.constructor as typeof Schema)[Symbol.metadata];
+        return this[metadata[index].name as keyof this];
     }
 
-    protected [$deleteByIndex](index: number) {
-        const metadata: Metadata = this.constructor[Symbol.metadata];
-        this[metadata[index].name] = undefined;
+    [$deleteByIndex](index: number): void {
+        const metadata: Metadata = (this.constructor as typeof Schema)[Symbol.metadata];
+        this[metadata[index].name as keyof this] = undefined;
     }
 
     /**
@@ -185,7 +183,7 @@ export class Schema {
      * @param showContents display JSON contents of the instance
      * @returns
      */
-    static debugRefIds(ref: Ref, showContents: boolean = false, level: number = 0, decoder?: Decoder, keyPrefix: string = "") {
+    static debugRefIds<T extends Schema>(ref: T, showContents: boolean = false, level: number = 0, decoder?: Decoder, keyPrefix: string = "") {
         const contents = (showContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
         const changeTree: ChangeTree = ref[$changes];
 
@@ -201,18 +199,18 @@ export class Schema {
 
         changeTree.forEachChild((childChangeTree, indexOrKey) => {
             let key = indexOrKey;
-            if (typeof indexOrKey === 'number' && ref['$indexes']) {
+            if (typeof indexOrKey === 'number' && (ref as any)['$indexes']) {
                 // MapSchema
-                key = ref['$indexes'].get(indexOrKey) ?? indexOrKey;
+                key = (ref as any)['$indexes'].get(indexOrKey) ?? indexOrKey;
             }
-            const keyPrefix = (ref['forEach'] !== undefined && key !== undefined) ? `["${key}"]: ` : "";
+            const keyPrefix = ((ref as any)['forEach'] !== undefined && key !== undefined) ? `["${key}"]: ` : "";
             output += this.debugRefIds(childChangeTree.ref, showContents, level + 1, decoder, keyPrefix);
         });
 
         return output;
     }
 
-    static debugRefIdEncodingOrder(ref: Ref, changeSet: ChangeSetName = 'allChanges') {
+    static debugRefIdEncodingOrder<T extends Ref>(ref: T, changeSet: ChangeSetName = 'allChanges') {
         let encodeOrder: number[] = [];
         let current = ref[$changes].root[changeSet].next;
         while (current) {
@@ -236,7 +234,7 @@ export class Schema {
      * @param isEncodeAll Return "full encode" instead of current change set.
      * @returns
      */
-    static debugChanges(instance: Ref, isEncodeAll: boolean = false) {
+    static debugChanges<T extends Ref>(instance: T, isEncodeAll: boolean = false) {
         const changeTree: ChangeTree = instance[$changes];
 
         const changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
@@ -278,7 +276,7 @@ export class Schema {
         return output;
     }
 
-    static debugChangesDeep(ref: Ref, changeSetName: "changes" | "allChanges" | "allFilteredChanges" | "filteredChanges" = "changes") {
+    static debugChangesDeep<T extends Schema>(ref: T, changeSetName: "changes" | "allChanges" | "allFilteredChanges" | "filteredChanges" = "changes") {
         let output = "";
 
         const rootChangeTree: ChangeTree = ref[$changes];
@@ -290,7 +288,7 @@ export class Schema {
 
         // TODO: FIXME: this method is not working as expected
         for (const [refId, changes] of Object.entries(root[changeSetName])) {
-            const changeTree = root.changeTrees[refId];
+            const changeTree = root.changeTrees[refId as any as number];
             if (!changeTree) { continue; }
 
             let includeChangeTree = false;