@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha90

package/scripts/transform_schema.js

@@ -1,445 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const glob_1 = require("glob");
-const typescript_1 = __importDefault(require("typescript"));
-const fs = __importStar(require("fs"));
-const compilerOptions_1 = require("../tsc/compilerOptions");
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
-function getTarget(target) {
-    switch (target.toLowerCase()) {
-        case "es2015":
-            return typescript_1.default.ScriptTarget.ES2015;
-        case "es2016":
-            return typescript_1.default.ScriptTarget.ES2016;
-        case "es2017":
-            return typescript_1.default.ScriptTarget.ES2017;
-        case "es2018":
-            return typescript_1.default.ScriptTarget.ES2018;
-        case "es2019":
-            return typescript_1.default.ScriptTarget.ES2019;
-        case "es2020":
-            return typescript_1.default.ScriptTarget.ES2020;
-        case "es2021":
-            return typescript_1.default.ScriptTarget.ES2021;
-        case "es3":
-            return typescript_1.default.ScriptTarget.ES3;
-        case "es5":
-            return typescript_1.default.ScriptTarget.ES5;
-        case "esnext":
-            return typescript_1.default.ScriptTarget.ESNext;
-        default:
-            return typescript_1.default.ScriptTarget.ESNext;
-    }
-}
-async function main() {
-    // this assumes this is being run from root of directory
-    const options = (0, compilerOptions_1.readCompilerOptions)(".");
-    let files = glob_1.glob.sync("src/schema/*.ts");
-    const target = options.target
-        ? // @ts-ignore
-            getTarget(options.target)
-        : typescript_1.default.ScriptTarget.ESNext;
-    // filter to only event.ts e.g. for comments and whitespace...
-    //  files = files.filter((f) => f.endsWith("event.ts"));
-    files.forEach((file) => {
-        // assume valid file since we do glob above
-        //    const idx = file.lastIndexOf(".ts");
-        //    const writeFile = file.substring(0, idx) + "2" + ".ts";
-        //    console.debug(file);
-        const writeFile = "src/schema/" + path_1.default.basename(file).slice(0, -3) + "_schema.ts";
-        // const writeFile = file;
-        //    console.debug(file, writeFile);
-        let contents = fs.readFileSync(file).toString();
-        // go through the file and print everything back if not starting immediately after other position
-        const sourceFile = typescript_1.default.createSourceFile(file, contents, target, false, typescript_1.default.ScriptKind.TS);
-        const nodes = [];
-        let updateImport = false;
-        let removeImports = [];
-        const f = {
-            trackNode: function (tni) {
-                nodes.push({
-                    node: tni.node,
-                    importNode: tni.node && typescript_1.default.isImportDeclaration(tni.node),
-                    rawString: tni.rawString,
-                });
-                if (tni.removeImports) {
-                    removeImports.push(...tni.removeImports);
-                }
-            },
-            flagUpdateImport() {
-                updateImport = true;
-            },
-        };
-        if (!traverse(contents, sourceFile, f)) {
-            return;
-        }
-        let newContents = "";
-        for (const node of nodes) {
-            if (updateImport && node.importNode) {
-                const importNode = node.node;
-                const transformedImport = transformImport(importNode, sourceFile, removeImports);
-                if (transformedImport) {
-                    newContents += transformedImport;
-                    continue;
-                }
-            }
-            if (node.node) {
-                newContents += node.node.getFullText(sourceFile);
-            }
-            else if (node.rawString) {
-                newContents += node.rawString;
-            }
-            else {
-                console.error("invalid node");
-            }
-        }
-        //    console.debug(newContents);
-        // ideally there's a flag that indicates if we write
-        fs.writeFileSync(writeFile, newContents);
-        fs.rmSync(file);
-    });
-    (0, child_process_1.execSync)("prettier src/schema/*.ts --write");
-}
-function traverse(fileContents, sourceFile, f) {
-    let traversed = false;
-    typescript_1.default.forEachChild(sourceFile, function (node) {
-        if (typescript_1.default.isClassDeclaration(node)) {
-            traversed = true;
-            // TODO address implicit schema doesn't work here...
-            //        console.debug(sourceFile.fileName, node.kind);
-            if (traverseClass(fileContents, sourceFile, node, f)) {
-                f.flagUpdateImport();
-                return;
-            }
-        }
-        f.trackNode({ node });
-    });
-    return traversed;
-}
-function traverseClass(fileContents, sourceFile, node, f) {
-    const ci = getClassInfo(fileContents, sourceFile, node);
-    if (!ci) {
-        return false;
-    }
-    let klassContents = `${ci.comment}const ${ci.name} = new ${ci.class}({\n`;
-    let removeImports = [];
-    if (ci.implementsSchema) {
-        removeImports.push("Schema");
-    }
-    for (let member of node.members) {
-        const fInfo = getClassElementInfo(fileContents, member, sourceFile);
-        if (!fInfo) {
-            return false;
-        }
-        klassContents += `${fInfo.comment}${fInfo.key}:${fInfo.value},\n`;
-        if (fInfo.type) {
-            removeImports.push(fInfo.type);
-        }
-    }
-    klassContents += "\n})";
-    if (ci.export && ci.default) {
-        klassContents += `\n export default ${ci.name};`;
-    }
-    else if (ci.export) {
-        klassContents = "export " + klassContents;
-    }
-    //  console.debug(klassContents);
-    f.trackNode({ rawString: klassContents, removeImports: removeImports });
-    return true;
-}
-function transformSchema(str) {
-    // only do known class names
-    if (str === "BaseEntSchema" || str === "BaseEntSchemaWithTZ") {
-        return str.substring(4);
-    }
-    return str;
-}
-function getClassInfo(fileContents, sourceFile, node) {
-    let className = node.name?.text;
-    if (!className?.endsWith("Schema")) {
-        className += "Schema";
-    }
-    let classExtends;
-    let implementsSchema = false;
-    if (node.heritageClauses) {
-        for (const hc of node.heritageClauses) {
-            if (hc.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
-                for (const type of hc.types) {
-                    if (type.expression.getText(sourceFile) === "Schema") {
-                        implementsSchema = true;
-                    }
-                }
-                continue;
-            }
-            // ts.SyntaxKind.ExtendsKeyword
-            // can only extend one class
-            for (const type of hc.types) {
-                const text = type.expression.getText(sourceFile);
-                const transformed = transformSchema(text);
-                if (transformed === text) {
-                    return undefined;
-                }
-                classExtends = transformed;
-            }
-        }
-    }
-    if (!className || !node.heritageClauses || !classExtends) {
-        return undefined;
-    }
-    let ci = {
-        name: className,
-        class: classExtends,
-        comment: getPreText(fileContents, node, sourceFile),
-        implementsSchema,
-    };
-    if (node.modifiers) {
-        for (const mod of node.modifiers) {
-            const text = mod.getText(sourceFile);
-            if (text === "export") {
-                ci.export = true;
-            }
-            else if (text === "default") {
-                ci.default = true;
-            }
-        }
-    }
-    return ci;
-}
-// intentionally doesn't parse decorators since we don't need it
-function getClassElementInfo(fileContents, member, sourceFile) {
-    if (isFieldElement(member, sourceFile)) {
-        return getFieldElementInfo(fileContents, member, sourceFile);
-    }
-    if (member.kind === typescript_1.default.SyntaxKind.Constructor) {
-        return getConstructorElementInfo(fileContents, member, sourceFile);
-    }
-    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
-        return;
-    }
-    // other properties
-    const property = member;
-    if (!property.initializer) {
-        return;
-    }
-    const token = property.name;
-    return {
-        key: token.escapedText.toString(),
-        value: property.initializer?.getFullText(sourceFile),
-        comment: getPreText(fileContents, member, sourceFile),
-        type: getType(property, sourceFile),
-    };
-}
-function getType(property, sourceFile) {
-    let propertytype = property.type?.getText(sourceFile) || "";
-    let ends = ["| null", "[]"];
-    for (const end of ends) {
-        if (propertytype.endsWith(end)) {
-            propertytype = propertytype.slice(0, -1 * end.length);
-        }
-    }
-    return propertytype;
-}
-function getFieldElementInfo(fileContents, member, sourceFile) {
-    let fieldMap = "";
-    // need to change to fields: {code: StringType()};
-    const property = member;
-    const initializer = property.initializer;
-    fieldMap += "{";
-    for (const element of initializer.elements) {
-        const parsed = parseFieldElement(element, sourceFile, fileContents);
-        if (parsed === null) {
-            return;
-        }
-        const { callEx, name, nameComment, properties } = parsed;
-        let property = "";
-        const fieldComment = getPreText(fileContents, element, sourceFile).trim();
-        if (fieldComment) {
-            property += "\n" + fieldComment + "\n";
-        }
-        if (nameComment) {
-            property += nameComment + "\n";
-        }
-        // e.g. UUIDType, StringType etc
-        let call = callEx.expression.getText(sourceFile);
-        let fnCall = "";
-        if (properties.length) {
-            fnCall = `{${properties.join(",")}}`;
-        }
-        property += `${name}:${call}(${fnCall}),`;
-        fieldMap += property;
-    }
-    fieldMap += "}";
-    return {
-        key: "fields",
-        value: fieldMap,
-        comment: getPreText(fileContents, member, sourceFile),
-        type: getType(property, sourceFile),
-    };
-}
-function getConstructorElementInfo(fileContents, member, sourceFile) {
-    const c = member;
-    //remove {}
-    let fullText = c.body?.getFullText(sourceFile) || "";
-    fullText = fullText.trim().slice(1, -1).trim();
-    // convert something like
-    /*
-    constructor() {
-      super();
-      this.addPatterns(
-        new Feedback(),
-        new DayOfWeek(),
-        new Feedback(),
-        new DayOfWeek(),
-      );
-    }
-      */
-    // into this.addPatterns(new Feedback(),new DayOfWeek(),new Feedback(),new DayOfWeek(),)
-    const lines = fullText
-        .split("\n")
-        .map((line) => line.trim())
-        .join("")
-        .split(";")
-        .filter((f) => f != "super()" && f != "");
-    // at this point there should be only line for what we handle
-    if (lines.length != 1) {
-        return;
-    }
-    const line = lines[0];
-    const addPatterns = "this.addPatterns(";
-    if (!line.startsWith(addPatterns)) {
-        return;
-    }
-    return {
-        key: "patterns",
-        // remove this.addPatterns at the front, remove trailing ) at the end
-        // if there's a trailing comma, it'll be handled by prettier
-        value: `[${line.slice(addPatterns.length, -1)}]`,
-        comment: "",
-    };
-}
-function isFieldElement(member, sourceFile) {
-    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
-        return false;
-    }
-    const property = member;
-    const token = property.name;
-    if (token.escapedText !== "fields") {
-        return false;
-    }
-    const propertytype = property.type?.getText(sourceFile);
-    if (propertytype !== "Field[]") {
-        return false;
-    }
-    if (property.initializer?.kind !== typescript_1.default.SyntaxKind.ArrayLiteralExpression) {
-        console.error("invalid array type");
-        return false;
-    }
-    return true;
-}
-function parseFieldElement(element, sourceFile, fileContents) {
-    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression) {
-        console.error("skipped non-call expression");
-        return null;
-    }
-    let callEx = element;
-    if (callEx.arguments.length !== 1) {
-        console.error("callExpression with arguments not of length 1");
-        return null;
-    }
-    let arg = callEx.arguments[0];
-    if (arg.kind !== typescript_1.default.SyntaxKind.ObjectLiteralExpression) {
-        console.error("not objectLiteralExpression");
-        return null;
-    }
-    let expr = arg;
-    let name = "";
-    let propertyComment;
-    let properties = [];
-    for (const p of expr.properties) {
-        const p2 = p;
-        // found name property
-        if (p2.name.escapedText === "name") {
-            name = p2.initializer.getText(sourceFile);
-            // check for any comment associated with name: "fooo"
-            propertyComment = getPreText(fileContents, p, sourceFile).trim();
-        }
-        else {
-            properties.push(p.getFullText(sourceFile));
-        }
-    }
-    if (!name) {
-        console.error(`couldn't find name property`);
-        return null;
-    }
-    // remove quotes
-    name = name.slice(1, -1);
-    return {
-        callEx,
-        name,
-        properties,
-        nameComment: propertyComment,
-    };
-}
-function transformImport(importNode, sourceFile, removeImports) {
-    // remove quotes too
-    const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
-    if (text !== "@snowtop/ent" &&
-        text !== "@snowtop/ent/schema" &&
-        text !== "@snowtop/ent/schema/") {
-        return;
-    }
-    const importText = importNode.importClause?.getText(sourceFile) || "";
-    const start = importText.indexOf("{");
-    const end = importText.lastIndexOf("}");
-    if (start === -1 || end === -1) {
-        return;
-    }
-    const imports = importText
-        .substring(start + 1, end)
-        //    .trim()
-        .split(",");
-    let removeImportsMap = {};
-    removeImports.forEach((imp) => (removeImportsMap[imp] = true));
-    let newImports = [];
-    for (let i = 0; i < imports.length; i++) {
-        let imp = transformSchema(imports[i].trim());
-        if (removeImportsMap[imp]) {
-            continue;
-        }
-        newImports.push(imp);
-    }
-    return ("import " +
-        importText.substring(0, start + 1) +
-        newImports.join(", ") +
-        importText.substring(end) +
-        ' from "' +
-        text +
-        '";');
-}
-function getPreText(fileContents, node, sourceFile) {
-    return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
-}
-Promise.resolve(main());