@colyseus/schema 3.0.0-alpha.38 → 3.0.0-alpha.39

package/src/Reflection.ts

@@ -24,19 +24,27 @@ export class ReflectionType extends Schema {
 }
 
 export class Reflection extends Schema {
-    @type([ ReflectionType ]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
+    @type([ReflectionType]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
+    @type("number") rootType: number;
 
     /**
      * Encodes the TypeContext of an Encoder into a buffer.
      *
-     * @param context TypeContext instance
+     * @param encoder Encoder instance
      * @param it
      * @returns
      */
-    static encode(context: TypeContext, it: Iterator = { offset: 0 }) {
+    static encode(encoder: Encoder, it: Iterator = { offset: 0 }) {
+        const context = encoder.context;
+
         const reflection = new 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 fieldIndex in metadata) {
                 const index = Number(fieldIndex);
@@ -157,7 +165,7 @@ export class Reflection extends Schema {
                         Metadata.addField(metadata, fieldIndex, field.name, refType);
 
                     } else {
-                        Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType } as DefinitionType);
+                        Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                     }
 
                 } else {
@@ -191,7 +199,7 @@ export class Reflection extends Schema {
             });
         });
 
-        const state: T = new (typeContext.get(0) as unknown as any)();
+        const state: T = new (typeContext.get(reflection.rootType || 0) as unknown as any)();
 
         return new Decoder<T>(state, typeContext);
     }

package/src/Schema.ts

@@ -1,5 +1,5 @@
 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';
 
@@ -15,7 +15,7 @@ import { getIndent } from './utils';
 /**
  * Schema encoder / decoder
  */
-export abstract class Schema {
+export class Schema {
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
@@ -147,7 +147,6 @@ export abstract class Schema {
 
     toJSON () {
         const obj: unknown = {};
-
         const metadata = this.constructor[Symbol.metadata];
         for (const index in metadata) {
             const field = metadata[index];

package/src/annotations.ts

@@ -9,12 +9,11 @@ import { OPERATION } from "./encoding/spec";
 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";
 
-/**
- * Data types
- */
-export type PrimitiveType =
-    "string" |
+export type RawPrimitiveType = "string" |
     "number" |
     "boolean" |
     "int8" |
@@ -26,16 +25,18 @@ export type PrimitiveType =
     "int64" |
     "uint64" |
     "float32" |
-    "float64" |
-    typeof Schema |
-    object;
+    "float64";
+
+export type PrimitiveType = RawPrimitiveType | typeof Schema | object;
 
-export type DefinitionType = PrimitiveType
-    | PrimitiveType[]
-    | { array: PrimitiveType }
-    | { map: PrimitiveType }
-    | { collection: PrimitiveType }
-    | { set: PrimitiveType };
+// 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 };
 
@@ -479,7 +480,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) {
@@ -487,3 +488,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/codegen/parser.ts

@@ -148,6 +148,49 @@ function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
                     defineProperty(property, typeArgument);
                 }
 
+            } else if (
+                node.getText() === "setFields" &&
+                (
+                    node.parent.kind === ts.SyntaxKind.CallExpression ||
+                    node.parent.kind === ts.SyntaxKind.PropertyAccessExpression
+                )
+            ) {
+                /**
+                 * Metadata.setFields(klassName, { ... })
+                 */
+                const callExpression = (node.parent.kind === ts.SyntaxKind.PropertyAccessExpression)
+                    ? node.parent.parent as ts.CallExpression
+                    : node.parent as ts.CallExpression;
+
+                if (callExpression.kind !== ts.SyntaxKind.CallExpression) {
+                    break;
+                }
+
+                const classNameNode = callExpression.arguments[0];
+                const className = ts.isClassExpression(classNameNode)
+                    ? classNameNode.name?.escapedText.toString()
+                    : classNameNode.getText();
+
+                // skip if no className is provided
+                if (!className) { break; }
+
+                if (currentStructure.name !== className) {
+                    currentStructure = new Class();
+                }
+                context.addStructure(currentStructure);
+                (currentStructure as Class).extends = "Schema"; // force extends to Schema
+                currentStructure.name = className;
+
+                const types = callExpression.arguments[1] as any;
+                for (let i = 0; i < types.properties.length; i++) {
+                    const prop = types.properties[i];
+
+                    const property = currentProperty || new Property();
+                    property.name = prop.name.escapedText;
+
+                    currentStructure.addProperty(property);
+                    defineProperty(property, prop.initializer);
+                }
 
             } else if (
                 node.getText() === "defineTypes" &&
@@ -192,6 +235,70 @@ function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
 
             break;
 
+        case ts.SyntaxKind.CallExpression:
+            /**
+             * Defining schema via `schema.schema({ ... })`
+             * - schema.schema({})
+             * - schema({})
+             * - ClassName.extends({})
+             */
+            if (
+                (
+                    (
+                        (node as ts.CallExpression).expression?.getText() === "schema.schema" ||
+                        (node as ts.CallExpression).expression?.getText() === "schema"
+                    ) ||
+                    (
+                        (node as ts.CallExpression).expression?.getText().indexOf(".extends") !== -1
+                    )
+                ) &&
+                (node as ts.CallExpression).arguments[0].kind === ts.SyntaxKind.ObjectLiteralExpression
+            ) {
+                const callExpression = node as ts.CallExpression;
+
+                let className = callExpression.arguments[1]?.getText();
+
+                if (!className && callExpression.parent.kind === ts.SyntaxKind.VariableDeclaration) {
+                    className = (callExpression.parent as ts.VariableDeclaration).name?.getText();
+                }
+
+                // skip if no className is provided
+                if (!className) { break; }
+
+                if (currentStructure.name !== className) {
+                    currentStructure = new Class();
+                    context.addStructure(currentStructure);
+                }
+
+                if ((node as ts.CallExpression).expression?.getText().indexOf(".extends") !== -1) {
+                    // if it's using `.extends({})`
+                    const extendsClass = (node as any).expression?.expression?.escapedText;
+
+                    // skip if no extendsClass is provided
+                    if (!extendsClass) { break; }
+                    (currentStructure as Class).extends = extendsClass;
+
+                } else {
+                    // if it's using `schema({})`
+                    (currentStructure as Class).extends = "Schema"; // force extends to Schema
+                }
+
+                currentStructure.name = className;
+
+                const types = callExpression.arguments[0] as any;
+                for (let i = 0; i < types.properties.length; i++) {
+                    const prop = types.properties[i];
+
+                    const property = currentProperty || new Property();
+                    property.name = prop.name.escapedText;
+
+                    currentStructure.addProperty(property);
+                    defineProperty(property, prop.initializer);
+                }
+            }
+
+            break;
+
         case ts.SyntaxKind.EnumMember:
             if (currentStructure instanceof Enum) {
                 const initializer = (node as any).initializer?.text;

package/src/codegen/types.ts

@@ -39,6 +39,7 @@ export class Context {
     }
 
     addStructure(structure: IStructure) {
+        if (structure.context === this) { return; } // skip if already added.
         structure.context = this;
 
         if (structure instanceof Class) {

package/src/decoder/DecodeOperation.ts

@@ -327,6 +327,10 @@ export const decodeArray: DecodeOperation = function (
         (ref as ArraySchema).clear();
         return;
 
+    } else if (operation === OPERATION.REVERSE) {
+        (ref as ArraySchema).reverse();
+        return;
+
     } else if (operation === OPERATION.DELETE_BY_REFID) {
         // TODO: refactor here, try to follow same flow as below
         const refId = decode.number(bytes, it);

package/src/decoder/strategy/StateCallbacks.ts

@@ -4,8 +4,8 @@ import { Ref } from "../../encoder/ChangeTree";
 import { Decoder } from "../Decoder";
 import { DataChange } from "../DecodeOperation";
 import { OPERATION } from "../../encoding/spec";
-import { DefinitionType } from "../../annotations";
 import { Schema } from "../../Schema";
+import type { DefinitionType } from "../../annotations";
 import type { CollectionSchema } from "../../types/custom/CollectionSchema";
 
 //

package/src/encoder/EncodeOperation.ts

@@ -79,7 +79,6 @@ export const encodeSchemaOperation: EncodeOperation = function (
     }
 
     const ref = changeTree.ref;
-    // const metadata: Metadata = ref.constructor[Symbol.metadata];
     const field = metadata[index];
 
     // TODO: inline this function call small performance gain
@@ -200,7 +199,10 @@ export const encodeArray: EncodeOperation = function (
     bytes[it.offset++] = operation & 255;
 
     // custom operations
-    if (operation === OPERATION.CLEAR) {
+    if (
+        operation === OPERATION.CLEAR ||
+        operation === OPERATION.REVERSE
+    ) {
         return;
     }
 

package/src/index.ts

@@ -41,7 +41,7 @@ export {
 
 // Annotations, Metadata and TypeContext
 export { Metadata } from "./Metadata";
-export { type, deprecated, defineTypes, view, } from "./annotations";
+export { type, deprecated, defineTypes, view, schema, type SchemaWithExtends, } from "./annotations";
 export { TypeContext } from "./types/TypeContext";
 
 // Annotation types

package/src/types/HelperTypes.ts

@@ -1,5 +1,11 @@
-import { ArraySchema } from "./custom/ArraySchema";
-import { MapSchema } from "./custom/MapSchema";
+import type { Definition, DefinitionType, PrimitiveType, RawPrimitiveType } from "../annotations";
+import type { Schema } from "../Schema";
+import type { ArraySchema } from "./custom/ArraySchema";
+import type { CollectionSchema } from "./custom/CollectionSchema";
+import type { MapSchema } from "./custom/MapSchema";
+import type { SetSchema } from "./custom/SetSchema";
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export interface Collection<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
@@ -7,6 +13,52 @@ export interface Collection<K = any, V = any, IT = V> {
     entries(): IterableIterator<[K, V]>;
 }
 
+export type InferValueType<T extends DefinitionType> =
+    T extends "string" ? string
+    : T extends "number" ? number
+    : T extends "int8" ? number
+    : T extends "uint8" ? number
+    : T extends "int16" ? number
+    : T extends "uint16" ? number
+    : T extends "int32" ? number
+    : T extends "uint32" ? number
+    : T extends "int64" ? number
+    : T extends "uint64" ? number
+    : T extends "float32" ? number
+    : T extends "float64" ? number
+    : T extends "boolean" ? boolean
+
+    : T extends { type: infer ChildType extends Constructor } ? InstanceType<ChildType>
+    : T extends { type: infer ChildType extends PrimitiveType } ? ChildType
+
+    : T extends Array<infer ChildType extends Constructor> ? InstanceType<ChildType>[]
+    : T extends Array<infer ChildType extends RawPrimitiveType> ? ChildType[]
+
+    : T extends { array: infer ChildType extends Constructor } ? InstanceType<ChildType>[]
+    : T extends { array: infer ChildType extends PrimitiveType } ? ChildType[]
+
+    : T extends { map: infer ChildType extends Constructor } ? MapSchema<InstanceType<ChildType>>
+    : T extends { map: infer ChildType extends PrimitiveType } ? MapSchema<ChildType>
+
+    : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
+    : T extends { set: infer ChildType extends PrimitiveType } ? SetSchema<ChildType>
+
+    : T extends { collection: infer ChildType extends Constructor } ? CollectionSchema<InstanceType<ChildType>>
+    : T extends { collection: infer ChildType extends PrimitiveType } ? CollectionSchema<ChildType>
+
+    : T extends Constructor ? InstanceType<T>
+    : T extends PrimitiveType ? T
+
+    : never;
+
+export type InferSchemaInstanceType<T extends Definition> = {
+    [K in keyof T]: InferValueType<T[K]>
+} & Schema;
+
+export type DefinedSchemaType<T extends Definition, P extends typeof Schema> = {
+    new (): InferSchemaInstanceType<T> & InstanceType<P>;
+} & typeof Schema;
+
 export type NonFunctionProps<T> = Omit<T, {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T]>;

package/src/types/TypeContext.ts

@@ -53,7 +53,7 @@ export class TypeContext {
         // Workaround to allow using an empty Schema (with no `@type()` fields)
         //
         if (schema[Symbol.metadata] === undefined) {
-            Metadata.init(schema);
+            Metadata.initialize(schema);
         }
 
         this.schemas.set(schema, typeid);
@@ -74,6 +74,16 @@ export class TypeContext {
             this.discoverTypes(child, parentIndex, parentFieldViewTag);
         });
 
+        // add parent classes
+        let parent: any = klass;
+        while (
+            (parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
+        }
+
         const metadata: Metadata = (klass[Symbol.metadata] ??= {});
 
         // if any schema/field has filters, mark "context" as having filters.