@colyseus/schema 1.0.34 → 1.0.38

package/src/codegen/languages/js.ts

@@ -0,0 +1,115 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } 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(klass => ({
+        name: klass.name + ".js",
+        content: generateClass(klass, 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")) {
+            allRefs.push(property);
+        }
+    });
+
+    return `${getCommentHeader()}
+
+const schema = require("@colyseus/schema");
+const Schema = schema.Schema;
+const type = schema.type;
+${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 => `const ${childType} = require("./${childType}");`).
+    join("\n")}
+
+class ${klass.name} extends ${klass.extends} {
+    constructor () {
+        super();
+${klass.properties.
+    filter(prop => prop.childType !== undefined).
+    map(prop => "        " + generatePropertyInitializer(prop)).join("\n")}
+    }
+}
+${klass.properties.map(prop => generatePropertyDeclaration(klass.name, prop)).join("\n")}
+
+export default ${klass.name};
+`;
+}
+
+function generatePropertyDeclaration(className: string, prop: Property) {
+    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") {
+            typeArgs = `${prop.childType}`;
+
+        } else if(prop.type === "array") {
+            typeArgs = (isUpcaseFirst)
+                ? `[ ${prop.childType} ]`
+                : `[ "${prop.childType}" ]`;
+
+        } else if(prop.type === "map") {
+            typeArgs = (isUpcaseFirst)
+                ? `{ map: ${prop.childType} }`
+                : `{ map: "${prop.childType}" }`;
+        }
+
+    } else {
+        typeArgs = `"${prop.type}"`;
+    }
+
+    return `type(${typeArgs})(${className}.prototype, "${prop.name}");`;
+}
+
+function generatePropertyInitializer(prop: Property) {
+    let initializer = "";
+
+    if(prop.type === "ref") {
+        initializer = `new ${prop.childType}()`;
+
+    } else if(prop.type === "array") {
+        initializer = `new schema.ArraySchema()`;
+
+    } else if(prop.type === "map") {
+        initializer = `new schema.MapSchema()`;
+    }
+
+    return `this.${prop.name} = ${initializer}`;
+}

package/src/codegen/languages/lua.ts

@@ -0,0 +1,125 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types";
+import { GenerateOptions } from "../api";
+
+/**
+    TODO:
+    - Support inheritance
+    - Support importing Schema dependencies
+*/
+
+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(klass => ({
+        name: klass.name + ".lua",
+        content: generateClass(klass, 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")) {
+            allRefs.push(property);
+        }
+    });
+
+// TOOD: inheritance
+
+    return `${getCommentHeader().replace(/\/\//mg, "--")}
+
+local schema = require 'colyseus.serialization.schema.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 => `local ${childType} = require '${(namespace ? `${namespace}.` : '')}${childType}'`).
+    join("\n")}
+
+local ${klass.name} = schema.define({
+${klass.properties.map(prop => generatePropertyDeclaration(prop)).join(",\n")},
+    ["_fields_by_index"] = { ${klass.properties.map(prop => `"${prop.name}"`).join(", ")} },
+})
+
+return ${klass.name}
+`;
+
+    // ["on_change"] = function(changes)
+    //     -- on change logic here
+    // end,
+
+    // ["on_add"] = function()
+    //     -- on add logic here
+    //  end,
+
+    // ["on_remove"] = function()
+    //     -- on remove logic here
+    // end,
+}
+
+function generatePropertyDeclaration(prop: Property) {
+    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") {
+            typeArgs = (isUpcaseFirst)
+                ? `${prop.childType}`
+                : `"${prop.childType}"`;
+
+        } else {
+            typeArgs = (isUpcaseFirst)
+                ? `{ ${prop.type} = ${prop.childType} }`
+                : `{ ${prop.type} = "${prop.childType}" }`;
+        }
+
+    } else {
+        typeArgs = `"${prop.type}"`;
+    }
+
+    return `    ["${prop.name}"] = ${typeArgs}`;
+}
+
+// function generatePropertyInitializer(prop: Property) {
+//     let initializer = "";
+
+//     if(prop.type === "ref") {
+//         initializer = `new ${prop.childType}()`;
+
+//     } else if(prop.type === "array") {
+//         initializer = `new schema.ArraySchema()`;
+
+//     } else if(prop.type === "map") {
+//         initializer = `new schema.MapSchema()`;
+//     }
+
+//     return `this.${prop.name} = ${initializer}`;
+// }

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,251 @@
+import * as ts from "typescript";
+import * as path from "path";
+import { readFileSync } from "fs";
+import { IStructure, Class, Interface, Property, Context } 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.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 = prop?.decorators;
+                const hasExpression = prop?.expression?.arguments;
+
+                /**
+                 * neither a `@type()` decorator or `type()` call. skip.
+                 */
+                if (!propDecorator && !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;
+    }
+
+    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();
+}