@colyseus/schema 3.0.0-alpha.9 → 3.0.0

package/src/annotations.ts

@@ -3,15 +3,17 @@ 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, $numFields, $track } from "./types/symbols";
 import { TypeDefinition, getType } from "./types/registry";
 import { OPERATION } from "./encoding/spec";
-
-/**
- * Data types
- */
-export type PrimitiveType =
-    "string" |
+import { TypeContext } from "./types/TypeContext";
+import { assertInstanceType, assertType } from "./encoding/assert";
+import type { Ref } from "./encoder/ChangeTree";
+import type { DefinedSchemaType, InferValueType } from "./types/HelperTypes";
+import type { CollectionSchema } from "./types/custom/CollectionSchema";
+import type { SetSchema } from "./types/custom/SetSchema";
+
+export type RawPrimitiveType = "string" |
     "number" |
     "boolean" |
     "int8" |
@@ -24,15 +26,19 @@ export type PrimitiveType =
     "uint64" |
     "float32" |
     "float64" |
-    typeof Schema |
-    object;
+    "bigint64" |
+    "biguint64";
 
-export type DefinitionType = PrimitiveType
-    | PrimitiveType[]
-    | { array: PrimitiveType }
-    | { map: PrimitiveType }
-    | { collection: PrimitiveType }
-    | { set: PrimitiveType };
+export type PrimitiveType = RawPrimitiveType | typeof Schema | object;
+
+// TODO: infer "default" value type correctly.
+export type DefinitionType<T extends PrimitiveType = PrimitiveType> = T
+    | T[]
+    | { type: T, default?: InferValueType<T>, view?: boolean | number }
+    | { array: T, default?: ArraySchema<InferValueType<T>>, view?: boolean | number }
+    | { map: T, default?: MapSchema<InferValueType<T>>, view?: boolean | number }
+    | { collection: T, default?: CollectionSchema<InferValueType<T>>, view?: boolean | number }
+    | { set: T, default?: SetSchema<InferValueType<T>>, view?: boolean | number };
 
 export type Definition = { [field: string]: DefinitionType };
 
@@ -42,119 +48,8 @@ export interface TypeOptions {
 
 export const DEFAULT_VIEW_TAG = -1;
 
-export class TypeContext {
-    types: {[id: number]: typeof Schema} = {};
-    schemas = new Map<typeof Schema, number>();
-
-    hasFilters: boolean = false;
-
-    /**
-     * For inheritance support
-     * Keeps track of which classes extends which. (parent -> children)
-     */
-    static inheritedTypes = new Map<typeof Schema, Set<typeof Schema>>();
-
-    static register(target: typeof Schema) {
-        const parent = Object.getPrototypeOf(target);
-        if (parent !== Schema) {
-            let inherits = TypeContext.inheritedTypes.get(parent);
-            if (!inherits) {
-                inherits = new Set<typeof Schema>();
-                TypeContext.inheritedTypes.set(parent, inherits);
-            }
-            inherits.add(target);
-        }
-    }
-
-    constructor(rootClass?: typeof Schema) {
-        if (rootClass) {
-            this.discoverTypes(rootClass);
-        }
-    }
-
-    has(schema: typeof Schema) {
-        return this.schemas.has(schema);
-    }
-
-    get(typeid: number) {
-        return this.types[typeid];
-    }
-
-    add(schema: typeof Schema, typeid: number = this.schemas.size) {
-        // skip if already registered
-        if (this.schemas.has(schema)) {
-            return false;
-        }
-
-        this.types[typeid] = schema;
-        this.schemas.set(schema, typeid);
-        return true;
-    }
-
-    getTypeId(klass: typeof Schema) {
-        return this.schemas.get(klass);
-    }
-
-    private discoverTypes(klass: typeof Schema) {
-        if (!this.add(klass)) {
-            return;
-        }
-
-        // add classes inherited from this base class
-        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child);
-        });
-
-        // skip if no fields are defined for this class.
-        if (klass[Symbol.metadata] === undefined) {
-            klass[Symbol.metadata] = {};
-        }
-
-        // const metadata = Metadata.getFor(klass);
-        const metadata = klass[Symbol.metadata];
-
-        // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[-2]) {
-            this.hasFilters = true;
-        }
-
-        for (const field in metadata) {
-            const fieldType = metadata[field].type;
-
-            if (typeof(fieldType) === "string") {
-                continue;
-            }
-
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-                if (type === "string") {
-                    continue;
-                }
-                this.discoverTypes(type as typeof Schema);
-
-            } else if (typeof(fieldType) === "function") {
-                this.discoverTypes(fieldType);
-
-            } else {
-                const type = Object.values(fieldType)[0];
-
-                // skip primitive types
-                if (typeof(type) === "string") {
-                    continue;
-                }
-
-                this.discoverTypes(type as typeof Schema);
-            }
-        }
-    }
-}
-
-export function entity(constructor, context: ClassDecoratorContext) {
-    if (!constructor._definition) {
-        // for inheritance support
-        TypeContext.register(constructor);
-    }
-
+export function entity(constructor) {
+    TypeContext.register(constructor);
     return constructor;
 }
 
@@ -186,8 +81,8 @@ export function entity(constructor, context: ClassDecoratorContext) {
 //         // detect index for this field, considering inheritance
 //         //
 //         const parent = Object.getPrototypeOf(context.metadata);
-//         let fieldIndex: number = context.metadata[-1] // current structure already has fields defined
-//             ?? (parent && parent[-1]) // parent structure has fields defined
+//         let fieldIndex: number = context.metadata[$numFields] // current structure already has fields defined
+//             ?? (parent && parent[$numFields]) // parent structure has fields defined
 //             ?? -1; // no fields defined
 //         fieldIndex++;
 
@@ -330,19 +225,22 @@ export function view<T> (tag: number = DEFAULT_VIEW_TAG) {
 
         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[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
-            }
-        }
+        // TODO: use Metadata.initialize()
+        const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
+        // const fieldIndex = metadata[fieldName];
+
+        // if (!metadata[fieldIndex]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[fieldIndex] = {
+        //         type: undefined,
+        //         index: (metadata[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
 
         Metadata.setTag(metadata, fieldName, tag);
     }
@@ -356,22 +254,24 @@ export function unreliable<T> (target: T, field: string) {
 
     const parentClass = Object.getPrototypeOf(constructor);
     const parentMetadata = parentClass[Symbol.metadata];
+
+    // 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[$numFields] // current structure already has fields defined
+    //             ?? (parentMetadata && parentMetadata[$numFields]) // 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 (
@@ -389,20 +289,20 @@ export function type (
         TypeContext.register(constructor);
 
         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)));
+        const parentMetadata =  parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor);
 
-        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] !== undefined) {
+            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 {
@@ -412,28 +312,31 @@ export function type (
                     const definitionAtLine = e.stack.split("\n")[4].trim();
                     throw new Error(`${e.message} ${definitionAtLine}`);
                 }
-
-            } else {
-                fieldIndex = metadata[field].index;
             }
 
         } else {
             //
             // detect index for this field, considering inheritance
             //
-            fieldIndex = metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+            fieldIndex = metadata[$numFields] // current structure already has fields defined
+                ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
                 ?? -1; // no fields defined
             fieldIndex++;
         }
 
         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))
@@ -449,7 +352,7 @@ export function type (
                 fieldIndex,
                 field,
                 type,
-                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass, metadata, field)
+                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass)
             );
         }
     }
@@ -460,13 +363,11 @@ export function getPropertyDescriptor(
     fieldIndex: number,
     type: DefinitionType,
     complexTypeKlass: TypeDefinition,
-    metadata: Metadata,
-    field: string,
 ) {
     return {
         get: function () { return this[fieldCached]; },
         set: function (this: Schema, value: any) {
-            const previousValue = this[fieldCached] || undefined;
+            const previousValue = this[fieldCached] ?? undefined;
 
             // skip if value is the same as cached.
             if (value === previousValue) { return; }
@@ -487,30 +388,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) {
                 //
@@ -542,23 +445,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[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // 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,
@@ -567,8 +472,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
         });
@@ -577,7 +482,7 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
 
 export function defineTypes(
     target: typeof Schema,
-    fields: { [property: string]: DefinitionType },
+    fields: Definition,
     options?: TypeOptions
 ) {
     for (let field in fields) {
@@ -585,3 +490,52 @@ export function defineTypes(
     }
     return target;
 }
+
+export interface SchemaWithExtends<T extends Definition, P extends typeof Schema> extends DefinedSchemaType<T, P> {
+    extends: <T2 extends Definition>(
+        fields: T2,
+        name?: string
+    ) => SchemaWithExtends<T & T2, typeof this>;
+}
+
+export function schema<T extends Definition, P extends typeof Schema = typeof Schema>(
+    fields: T,
+    name?: string,
+    inherits: P = Schema as P
+): SchemaWithExtends<T, P> {
+    const defaultValues: any = {};
+    const viewTagFields: any = {};
+
+    for (let fieldName in fields) {
+        const field = fields[fieldName] as DefinitionType;
+        if (typeof (field) === "object") {
+            if (field['default'] !== undefined) {
+                defaultValues[fieldName] = field['default'];
+            }
+            if (field['view'] !== undefined) {
+                viewTagFields[fieldName] = (typeof (field['view']) === "boolean")
+                    ? DEFAULT_VIEW_TAG
+                    : field['view'];
+            }
+        }
+    }
+
+    const klass = Metadata.setFields(class extends inherits {
+        constructor (...args: any[]) {
+            args[0] = Object.assign({}, defaultValues, args[0]);
+            super(...args);
+        }
+    }, fields) as SchemaWithExtends<T, P>;
+
+    for (let fieldName in viewTagFields) {
+        view(viewTagFields[fieldName])(klass.prototype, fieldName);
+    }
+
+    if (name) {
+        Object.defineProperty(klass, "name", { value: name });
+    }
+
+    klass.extends = (fields, name) => schema(fields, name, klass);
+
+    return klass;
+}

package/src/bench_encode.ts

@@ -0,0 +1,108 @@
+import { nanoid } from "nanoid";
+import { Schema, type, MapSchema, ArraySchema, Encoder } from ".";
+
+class Attribute extends Schema {
+    @type("string") name: string;
+    @type("number") value: number;
+}
+
+class Item extends Schema {
+    @type("number") price: number;
+    @type([ Attribute ]) attributes = new ArraySchema<Attribute>();
+}
+
+class Position extends Schema {
+    @type("number") x: number;
+    @type("number") y: number;
+}
+
+class Player extends Schema {
+    @type(Position) position = new Position();
+    @type({ map: Item }) items = new MapSchema<Item>();
+}
+
+class State extends Schema {
+    @type({ map: Player }) players = new MapSchema<Player>();
+    @type("string") currentTurn;
+}
+
+const state = new State();
+
+Encoder.BUFFER_SIZE = 4096 * 4096;
+const encoder = new Encoder(state);
+
+
+let now = Date.now();
+
+// for (let i = 0; i < 10000; i++) {
+//     const player = new Player();
+//     state.players.set(`p-${nanoid()}`, player);
+//
+//     player.position.x = (i + 1) * 100;
+//     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);
+//         }
+//     }
+// }
+// console.log("time to make changes:", Date.now() - now);
+
+
+// measure time to .encodeAll()
+
+now = Date.now();
+// for (let i = 0; i < 1000; i++) {
+//     encoder.encodeAll();
+// }
+// console.log(Date.now() - now);
+
+const total = 100;
+const allEncodes = Date.now();
+
+let avgTimeToEncode = 0;
+let avgTimeToMakeChanges = 0;
+
+for (let i = 0; i < total; i++) {
+    now = Date.now();
+    for (let j = 0; j < 50; j++) {
+        const player = new Player();
+        state.players.set(`p-${nanoid()}`, player);
+
+        player.position.x = (j + 1) * 100;
+        player.position.y = (j + 1) * 100;
+        for (let k = 0; k < 10; k++) {
+            const item = new Item();
+            item.price = (j + 1) * 50;
+            for (let l = 0; l < 5; l++) {
+                const attr = new Attribute();
+                attr.name = `Attribute ${l}`;
+                attr.value = l;
+                item.attributes.push(attr);
+            }
+            player.items.set(`item-${k}`, item);
+        }
+    }
+    const timeToMakeChanges = Date.now() - now;
+    console.log("time to make changes:", timeToMakeChanges);
+    avgTimeToMakeChanges += timeToMakeChanges;
+
+    now = Date.now();
+    encoder.encode();
+    encoder.discardChanges();
+
+    const timeToEncode = Date.now() - now;
+    console.log("time to encode:", timeToEncode);
+    avgTimeToEncode += timeToEncode;
+}
+console.log("avg time to encode:", (avgTimeToEncode) / total);
+console.log("avg time to make changes:", (avgTimeToMakeChanges) / total);
+console.log("time for all encodes:", Date.now() - allEncodes);
+
+console.log(Array.from(encoder.encodeAll()).length, "bytes");