@colyseus/schema 2.0.4 → 2.0.6

package/src/codegen/languages/ts.ts

@@ -0,0 +1,129 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context, Interface } from "../types";
+import { GenerateOptions } from "../api";
+
+const typeMaps = {
+    "string": "string",
+    "number": "number",
+    "boolean": "boolean",
+    "int8": "number",
+    "uint8": "number",
+    "int16": "number",
+    "uint16": "number",
+    "int32": "number",
+    "uint32": "number",
+    "int64": "number",
+    "uint64": "number",
+    "float32": "number",
+    "float64": "number",
+}
+
+const distinct = (value, index, self) => self.indexOf(value) === index;
+
+export function generate (context: Context, options: GenerateOptions): File[] {
+    return [
+        ...context.classes.map(structure => ({
+            name: structure.name + ".ts",
+            content: generateClass(structure, options.namespace, context.classes)
+        })),
+        ...context.interfaces.map(structure => ({
+            name: structure.name + ".ts",
+            content: generateInterface(structure, options.namespace, context.classes),
+        }))
+    ];
+}
+
+function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
+    const allRefs: Property[] = [];
+    klass.properties.forEach(property => {
+        let type = property.type;
+
+        // keep all refs list
+        if ((type === "ref" || type === "array" || type === "map" || type === "set")) {
+            allRefs.push(property);
+        }
+    });
+
+    return `${getCommentHeader()}
+
+import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';
+${allRefs.
+    filter(ref => ref.childType && typeMaps[ref.childType] === undefined).
+    map(ref => ref.childType).
+    concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
+    filter(distinct).
+    map(childType => `import { ${childType} } from './${childType}'`).
+    join("\n")}
+
+export class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => `    ${generateProperty(prop)}`).join("\n")}
+}
+`;
+}
+
+function generateProperty(prop: Property) {
+    let langType: string;
+    let initializer = "";
+    let typeArgs: string;
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        if (isUpcaseFirst) {
+            typeArgs += `, ${prop.childType}`;
+
+        } else {
+            typeArgs += `, "${prop.childType}"`;
+        }
+
+        if(prop.type === "ref") {
+            langType = `${prop.childType}`;
+            initializer = `new ${prop.childType}()`;
+            typeArgs = `${prop.childType}`;
+
+        } else if(prop.type === "array") {
+            langType = (isUpcaseFirst)
+                ? `ArraySchema<${prop.childType}>`
+                : `ArraySchema<${typeMaps[prop.childType]}>`;
+            initializer = `new ${langType}()`;
+            typeArgs = (isUpcaseFirst)
+                ? `[ ${prop.childType} ]`
+                : `[ "${prop.childType}" ]`;
+
+        } else if(prop.type === "map") {
+            langType = (isUpcaseFirst)
+                ? `MapSchema<${prop.childType}>`
+                : `MapSchema<${typeMaps[prop.childType]}>`;
+            initializer = `new ${langType}()`;
+            typeArgs = (isUpcaseFirst)
+                ? `{ map: ${prop.childType} }`
+                : `{ map: "${prop.childType}" }`;
+        } else if (prop.type === "set") {
+            langType = (isUpcaseFirst)
+                ? `SetSchema<${prop.childType}>`
+                : `SetSchema<${typeMaps[prop.childType]}>`;
+            initializer = `new ${langType}()`;
+            typeArgs = (isUpcaseFirst)
+                ? `{ set: ${prop.childType} }`
+                : `{ set: "${prop.childType}" }`;
+        }
+
+    } else {
+        langType = typeMaps[prop.type];
+        typeArgs = `"${prop.type}"`;
+    }
+
+    // TS1263: "Declarations with initializers cannot also have definite assignment assertions"
+    const definiteAssertion = initializer ? "" : "!";
+
+    return `@type(${typeArgs}) public ${prop.name}${definiteAssertion}: ${langType}${(initializer) ? ` = ${initializer}` : ""};`
+}
+
+
+function generateInterface(structure: Interface, namespace: string, allClasses: Class[]) {
+    return `${getCommentHeader()}
+
+export interface ${structure.name} {
+${structure.properties.map(prop => `    ${prop.name}: ${prop.type};`).join("\n")}
+}
+`;
+}

package/src/codegen/parser.ts

@@ -0,0 +1,299 @@
+import * as ts from "typescript";
+import * as path from "path";
+import { readFileSync } from "fs";
+import { IStructure, Class, Interface, Property, Context, Enum } from "./types";
+
+let currentStructure: IStructure;
+let currentProperty: Property;
+
+let globalContext: Context;
+
+function defineProperty(property: Property, initializer: any) {
+    if (ts.isIdentifier(initializer)) {
+        property.type = "ref";
+        property.childType = initializer.text;
+
+    } else if (initializer.kind == ts.SyntaxKind.ObjectLiteralExpression) {
+        property.type = initializer.properties[0].name.text;
+        property.childType = initializer.properties[0].initializer.text;
+
+    } else if (initializer.kind == ts.SyntaxKind.ArrayLiteralExpression) {
+        property.type = "array";
+        property.childType = initializer.elements[0].text;
+
+    } else {
+        property.type = initializer.text;
+    }
+}
+
+function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
+    switch (node.kind) {
+        case ts.SyntaxKind.ImportClause:
+            const specifier = (node.parent as any).moduleSpecifier;
+            if (specifier && (specifier.text as string).startsWith('.'))  {
+                const currentDir = path.dirname(node.getSourceFile().fileName);
+                const pathToImport = path.resolve(currentDir, specifier.text);
+                parseFiles([pathToImport], decoratorName, globalContext);
+            }
+            break;
+
+        case ts.SyntaxKind.ClassDeclaration:
+            currentStructure = new Class();
+
+            const heritageClauses = (node as ts.ClassLikeDeclarationBase).heritageClauses;
+            if (heritageClauses && heritageClauses.length > 0) {
+                (currentStructure as Class).extends = heritageClauses[0].types[0].expression.getText();
+            }
+
+            context.addStructure(currentStructure);
+            break;
+
+        case ts.SyntaxKind.InterfaceDeclaration:
+            //
+            // Only generate Interfaces if it has "Message" on its name.
+            // Example: MyMessage
+            //
+            const interfaceName = (node as ts.TypeParameterDeclaration).name.escapedText.toString();
+            if (interfaceName.indexOf("Message") !== -1) {
+                currentStructure = new Interface();
+                currentStructure.name = interfaceName;
+
+                context.addStructure(currentStructure);
+            }
+            break;
+
+        case ts.SyntaxKind.EnumDeclaration:
+            const enumName = (
+                node as ts.EnumDeclaration
+            ).name.escapedText.toString();
+            currentStructure = new Enum();
+            currentStructure.name = enumName;
+            context.addStructure(currentStructure);
+            break;
+
+        case ts.SyntaxKind.ExtendsKeyword:
+            // console.log(node.getText());
+            break;
+
+        case ts.SyntaxKind.PropertySignature:
+            if (currentStructure instanceof Interface) {
+                const interfaceDeclaration = node.parent;
+
+                if (
+                    currentStructure.name !== (interfaceDeclaration as ts.TypeParameterDeclaration).name.escapedText.toString()
+                ) {
+                    // skip if property if for a another interface than the one we're interested in.
+                    break;
+                }
+
+                // define a property of an interface
+                const property = new Property();
+                property.name = (node as any).name.escapedText.toString();
+                property.type = (node as any).type.getText();
+                currentStructure.addProperty(property);
+            }
+            break;
+
+        case ts.SyntaxKind.Identifier:
+            if (
+                node.getText() === "deprecated" &&
+                node.parent.kind !== ts.SyntaxKind.ImportSpecifier
+            ) {
+                currentProperty = new Property();
+                currentProperty.deprecated = true;
+                break;
+            }
+
+            if (node.getText() === decoratorName) {
+                const prop: any = node.parent?.parent?.parent;
+                const propDecorator =  getDecorators(prop);
+                const hasExpression = prop?.expression?.arguments;
+                const hasDecorator = (propDecorator?.length > 0);
+
+                /**
+                 * neither a `@type()` decorator or `type()` call. skip.
+                 */
+                if (!hasDecorator && !hasExpression) {
+                    break;
+                }
+
+                // using as decorator
+                if (propDecorator) {
+                    /**
+                     * Calling `@type()` as decorator
+                     */
+                    const typeDecorator: any = propDecorator.find((decorator => {
+                        return (decorator.expression as any).expression.escapedText === decoratorName;
+                    })).expression;
+
+                    const property = currentProperty || new Property();
+                    property.name = prop.name.escapedText;
+                    currentStructure.addProperty(property);
+
+                    const typeArgument = typeDecorator.arguments[0];
+                    defineProperty(property, typeArgument);
+
+                } else if (
+                    prop.expression.arguments?.[1] &&
+                    prop.expression.expression.arguments?.[0]
+                ) {
+                    /**
+                     * Calling `type()` as a regular method
+                     */
+                    const property = currentProperty || new Property();
+                    property.name = prop.expression.arguments[1].text;
+                    currentStructure.addProperty(property);
+
+                    const typeArgument = prop.expression.expression.arguments[0];
+                    defineProperty(property, typeArgument);
+                }
+
+
+            } else if (
+                node.getText() === "defineTypes" &&
+                (
+                    node.parent.kind === ts.SyntaxKind.CallExpression ||
+                    node.parent.kind === ts.SyntaxKind.PropertyAccessExpression
+                )
+            ) {
+                /**
+                 * JavaScript source file (`.js`)
+                 * Using `defineTypes()`
+                 */
+                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 className = callExpression.arguments[0].getText()
+                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);
+                }
+
+            }
+
+            if (node.parent.kind === ts.SyntaxKind.ClassDeclaration) {
+                currentStructure.name = node.getText();
+            }
+
+            currentProperty = undefined;
+
+            break;
+
+        case ts.SyntaxKind.EnumMember:
+            if (currentStructure instanceof Enum) {
+                const initializer = (node as any).initializer?.getText();
+                const name = node.getFirstToken().getText();
+                const property = currentProperty || new Property();
+                property.name = name;
+                if (initializer !== undefined) {
+                    property.type = initializer;
+                }
+                currentStructure.addProperty(property);
+                currentProperty = undefined;
+            }
+            break;
+    }
+
+    ts.forEachChild(node, (n) => inspectNode(n, context, decoratorName));
+}
+
+let parsedFiles: { [filename: string]: boolean };
+
+export function parseFiles(
+    fileNames: string[],
+    decoratorName: string = "type",
+    context: Context = new Context()
+) {
+    /**
+     * Re-set globalContext for each test case
+     */
+    if (globalContext !== context) {
+        parsedFiles = {};
+        globalContext = context;
+    }
+
+    fileNames.forEach((fileName) => {
+        let sourceFile: ts.Node;
+        let sourceFileName: string;
+
+        const fileNameAlternatives = [];
+
+        if (
+            !fileName.endsWith(".ts") &&
+            !fileName.endsWith(".js") &&
+            !fileName.endsWith(".mjs")
+        ) {
+            fileNameAlternatives.push(`${fileName}.ts`);
+            fileNameAlternatives.push(`${fileName}/index.ts`);
+
+        } else {
+            fileNameAlternatives.push(fileName);
+        }
+
+        for (let i = 0; i < fileNameAlternatives.length; i++) {
+            try {
+                sourceFileName = path.resolve(fileNameAlternatives[i]);
+
+                if (parsedFiles[sourceFileName]) {
+                    break;
+                }
+
+                sourceFile = ts.createSourceFile(
+                    sourceFileName,
+                    readFileSync(sourceFileName).toString(),
+                    ts.ScriptTarget.Latest,
+                    true
+                );
+
+                parsedFiles[sourceFileName] = true;
+
+                break;
+            } catch (e) {
+                // console.log(`${fileNameAlternatives[i]} => ${e.message}`);
+            }
+        }
+
+        if (sourceFile) {
+            inspectNode(sourceFile, context, decoratorName);
+        }
+    });
+
+    return context.getStructures();
+}
+
+/**
+ * TypeScript 4.8+ has introduced a change on how to access decorators.
+ * - https://github.com/microsoft/TypeScript/pull/49089
+ * - https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#decorators-are-placed-on-modifiers-on-typescripts-syntax-trees
+ */
+export function getDecorators(node: ts.Node | null | undefined,): undefined | ts.Decorator[] {
+    if (node == undefined) { return undefined; }
+
+    // TypeScript 4.7 and below
+    // @ts-ignore
+    if (node.decorators) { return node.decorators; }
+
+    // TypeScript 4.8 and above
+    // @ts-ignore
+    if (ts.canHaveDecorators && ts.canHaveDecorators(node)) {
+        // @ts-ignore
+        const decorators = ts.getDecorators(node);
+        return decorators ? Array.from(decorators) : undefined;
+    }
+
+    // @ts-ignore
+    return node.modifiers?.filter(ts.isDecorator);
+}

package/src/codegen/types.ts

@@ -0,0 +1,177 @@
+import * as fs from "fs";
+
+const VERSION = JSON.parse(fs.readFileSync(__dirname + "/../../package.json").toString()).version;
+const COMMENT_HEADER = `
+THIS FILE HAS BEEN GENERATED AUTOMATICALLY
+DO NOT CHANGE IT MANUALLY UNLESS YOU KNOW WHAT YOU'RE DOING
+
+GENERATED USING @colyseus/schema ${VERSION}
+`;
+
+export function getCommentHeader(singleLineComment: string = "//") {
+    return `${COMMENT_HEADER.split("\n").map(line => `${singleLineComment} ${line}`).join("\n")}`;
+}
+
+export class Context {
+    classes: Class[] = [];
+    interfaces: Interface[] = [];
+    enums: Enum[] = [];
+
+    getStructures() {
+        return {
+            classes: this.classes.filter(klass => {
+                if (this.isSchemaClass(klass)) {
+                    return true;
+
+                } else {
+                    let parentClass = klass;
+                    while (parentClass = this.getParentClass(parentClass)) {
+                        if (this.isSchemaClass(parentClass)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }),
+            interfaces: this.interfaces,
+            enums: this.enums,
+        };
+    }
+
+    addStructure(structure: IStructure) {
+        structure.context = this;
+
+        if (structure instanceof Class) {
+            this.classes.push(structure);
+        } else if (structure instanceof Interface) {
+            this.interfaces.push(structure);
+        } else if (structure instanceof Enum) {
+            this.enums.push(structure);
+        }
+    }
+
+    private getParentClass(klass: Class) {
+        return this.classes.find(c => c.name === klass.extends);
+    }
+
+    private isSchemaClass(klass: Class) {
+        let isSchema: boolean = false;
+
+        let currentClass = klass;
+        while (!isSchema && currentClass) {
+            //
+            // TODO: ideally we should check for actual @colyseus/schema module
+            // reference rather than arbitrary strings.
+            //
+            isSchema = (
+                currentClass.extends === "Schema" ||
+                currentClass.extends === "schema.Schema" ||
+                currentClass.extends === "Schema.Schema"
+            );
+
+            //
+            // When extending from `schema.Schema`, it is required to
+            // normalize as "Schema" for code generation.
+            //
+            if (currentClass === klass && isSchema) {
+                klass.extends = "Schema";
+            }
+
+            currentClass = this.getParentClass(currentClass);
+        }
+
+        return isSchema;
+    }
+}
+
+export interface IStructure {
+    context: Context;
+    name: string;
+    properties: Property[];
+    addProperty(property: Property);
+}
+
+export class Interface implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+
+    addProperty(property: Property) {
+        if (property.type.indexOf("[]") >= 0) {
+            // is array!
+            property.childType = property.type.match(/([^\[]+)/i)[1];
+            property.type = "array";
+            this.properties.push(property);
+
+        } else {
+            this.properties.push(property);
+        }
+    }
+}
+
+export class Class implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+    extends: string;
+
+    addProperty(property: Property) {
+        property.index = this.properties.length;
+        this.properties.push(property);
+    }
+
+    postProcessing() {
+        /**
+         * Ensure the proprierties `index` are correct using inheritance
+         */
+        let parentKlass: Class = this;
+
+        while (
+            parentKlass &&
+            (parentKlass = this.context.classes.find(k => k.name === parentKlass.extends))
+        ) {
+            this.properties.forEach(prop => {
+                prop.index += parentKlass.properties.length;
+            });
+        }
+    }
+}
+
+export class Enum implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+
+    addProperty(property: Property) {
+        this.properties.push(property);
+    }
+}
+
+export class Property {
+    index: number;
+    name: string;
+    type: string;
+    childType: string;
+    deprecated?: boolean;
+}
+
+export interface File {
+    name: string
+    content: string;
+}
+
+export function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf: boolean = true) {
+    let currentClass = klass;
+    let inheritanceTree: Class[] = [];
+
+    if (includeSelf) {
+        inheritanceTree.push(currentClass);
+    }
+
+    while (currentClass.extends !== "Schema") {
+        currentClass = allClasses.find(klass => klass.name == currentClass.extends);
+        inheritanceTree.push(currentClass);
+    }
+
+    return inheritanceTree;
+}