@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha73

package/tsc/transform.js

@@ -0,0 +1,167 @@
+"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 });
+exports.transform = void 0;
+const glob_1 = require("glob");
+const typescript_1 = __importDefault(require("typescript"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const ast_1 = require("./ast");
+const compilerOptions_1 = require("./compilerOptions");
+function normalizePath(p) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    return p;
+}
+function transform(transform) {
+    let files = glob_1.glob.sync(transform.glob, transform.globOptions);
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    if (transform.filter) {
+        files = transform.filter(files);
+    }
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let nodes = [];
+        let imports = new Map();
+        let removeImports = [];
+        let traversed = false;
+        let seenImports = new Map();
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const imp = (0, ast_1.getImportInfo)(node, sourceFile);
+                if (imp) {
+                    imp.imports.forEach((v) => {
+                        v = v.trim();
+                        v && seenImports.set(v, true);
+                    });
+                }
+            }
+            const ret = transform.traverseChild(sourceFile, contents, file, node);
+            if (!ret) {
+                return;
+            }
+            if (ret.node || ret.rawString) {
+                nodes.push(ret);
+            }
+            if (ret.imports) {
+                for (const [k, v] of ret.imports) {
+                    imports.set(k, v);
+                }
+            }
+            if (ret.traversed) {
+                traversed = ret.traversed;
+            }
+            if (ret.removeImports?.length) {
+                removeImports.push(...ret.removeImports);
+            }
+        });
+        if (!traversed) {
+            return;
+        }
+        let newContents = "";
+        let afterProcessed = false;
+        let seen = new Map();
+        const processAfterImport = () => {
+            // do this for the first non-import node we see
+            // we want to add new imports to end of imports and there's an assumption that imports are ordered
+            // at top of file
+            if (!afterProcessed) {
+                for (const [imp, list] of imports) {
+                    if (seen.has(imp)) {
+                        continue;
+                    }
+                    const final = list.filter((v) => !seenImports.has(v));
+                    if (final.length) {
+                        newContents += `\nimport { ${final.join(", ")} } from "${imp}"`;
+                    }
+                }
+                afterProcessed = true;
+            }
+        };
+        for (const node of nodes) {
+            if (node.node) {
+                if (typescript_1.default.isImportDeclaration(node.node)) {
+                    const impInfo = (0, ast_1.getImportInfo)(node.node, sourceFile);
+                    //          console.debug(impInfo);
+                    if (impInfo) {
+                        const impPath = normalizePath(impInfo.importPath);
+                        const list = imports.get(impPath);
+                        // path exists, we care about it
+                        if (list !== undefined) {
+                            let transformed = (0, ast_1.transformImport)(contents, node.node, sourceFile, {
+                                // if we've done this path before, don't try and add
+                                // but still try and do any removals since we don't know which of the imports
+                                // has it
+                                newImports: seen.has(impPath) ? undefined : list,
+                                removeImports,
+                                // don't use normalized path here, we wanna use the path that's in code...
+                                transformPath: impInfo.importPath,
+                            });
+                            if (transformed) {
+                                newContents += transformed;
+                                seen.set(impPath, true);
+                                continue;
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (!typescript_1.default.isExportDeclaration(node.node) &&
+                        !isRequireStatement(node.node, sourceFile)) {
+                        processAfterImport();
+                    }
+                }
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                processAfterImport();
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+        }
+        let writeFile = file;
+        if (transform.fileToWrite) {
+            writeFile = transform.fileToWrite(file);
+        }
+        fs.writeFileSync(writeFile, newContents);
+        if (transform.postProcess) {
+            transform.postProcess(file);
+        }
+    });
+    if (transform.prettierGlob) {
+        (0, child_process_1.execSync)(`prettier ${transform.prettierGlob} --write`);
+    }
+}
+exports.transform = transform;
+function isRequireStatement(node, sourceFile) {
+    if (node.kind !== typescript_1.default.SyntaxKind.VariableStatement) {
+        return false;
+    }
+    const v = node;
+    const text = v.declarationList.declarations[0].getFullText(sourceFile);
+    return text.includes("require(");
+}

package/tsc/transform_action.d.ts

@@ -0,0 +1,22 @@
+import ts from "typescript";
+import { customInfo } from "../tsc/ast";
+import { TransformFile } from "./transform";
+export declare class TransformAction implements TransformFile {
+    private customInfo;
+    glob: string;
+    prettierGlob: string;
+    constructor(customInfo: customInfo);
+    traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): {
+        node: ts.Node;
+        rawString?: undefined;
+        traversed?: undefined;
+        imports?: undefined;
+        removeImports?: undefined;
+    } | {
+        rawString: string;
+        traversed: boolean;
+        imports: Map<string, string[]>;
+        removeImports: string[];
+        node?: undefined;
+    } | undefined;
+}

package/tsc/transform_action.js

@@ -0,0 +1,179 @@
+"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 });
+exports.TransformAction = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("../tsc/ast");
+const viewer_1 = require("../core/viewer");
+const path = __importStar(require("path"));
+const snake_case_1 = require("snake-case");
+// returns input and importPath
+function getBaseFileInfo(file, classInfo, sourceFile) {
+    // @ts-ignore
+    const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
+    for (const imp of importStatements) {
+        const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        if ((0, ast_1.isSrcGeneratedImport)(imp, sourceFile) ||
+            (0, ast_1.isRelativeGeneratedImport)(imp, sourceFile)) {
+            // base file and we're importing from it
+            // e.g. in create_user_action, we're importing from create_user_action_base
+            if (path.basename(file).slice(0, -3) + "_base" !== path.basename(text)) {
+                continue;
+            }
+            const impInfo = (0, ast_1.getImportInfo)(imp, sourceFile);
+            if (!impInfo) {
+                continue;
+            }
+            let inputs = impInfo.imports
+                .filter((imp) => imp.trim() && imp.endsWith("Input"))
+                .map((v) => v.trim());
+            if (inputs.length === 1) {
+                return {
+                    input: inputs[0],
+                    importPath: impInfo.importPath,
+                };
+            }
+            if (inputs.length && classInfo.name.endsWith("Action")) {
+                const prefix = classInfo.name.slice(0, classInfo.name.length - 6);
+                inputs = inputs.filter((imp) => imp.slice(0, imp.length - 5) === prefix);
+                if (inputs.length === 1) {
+                    return {
+                        input: inputs[0],
+                        importPath: impInfo.importPath,
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+let m = {
+    triggers: {
+        m: "getTriggers",
+        i: "Trigger",
+        suffix: "Triggers",
+    },
+    observers: {
+        m: "getObservers",
+        i: "Observer",
+        suffix: "Observers",
+    },
+    validators: {
+        m: "getValidators",
+        i: "Validator",
+        suffix: "Validators",
+    },
+};
+function getConversionInfo(mm, actionName) {
+    if (mm.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return null;
+    }
+    const text = mm.name.escapedText;
+    const v = m[text];
+    if (v === undefined) {
+        return null;
+    }
+    return {
+        text,
+        method: v.m,
+        interface: v.i,
+        // CreateFooActionTriggers etc
+        methodType: actionName + v.suffix,
+    };
+}
+class TransformAction {
+    constructor(customInfo) {
+        this.customInfo = customInfo;
+        this.glob = "src/ent/**/actions/**/*_action.ts";
+        this.prettierGlob = "src/ent/**/actions/**.ts";
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isClassDeclaration(node) || !node.heritageClauses) {
+            return { node };
+        }
+        let classInfo = (0, ast_1.getClassInfo)(contents, sourceFile, node);
+        // only do classes
+        if (!classInfo || !classInfo.default) {
+            return;
+        }
+        // require action
+        const p = require(path.join(process.cwd(), "./" + file.slice(0, -3)));
+        const action = new p.default(new viewer_1.LoggedOutViewer(), {});
+        const actionName = action.constructor.name;
+        const builder = action.builder.constructor.name;
+        const nodeName = action.builder.ent.name;
+        const viewer = this.customInfo.viewerInfo.name;
+        const baseInfo = getBaseFileInfo(file, classInfo, sourceFile);
+        if (!baseInfo) {
+            return;
+        }
+        let klassContents = "";
+        let traversed = false;
+        let newImports = [];
+        for (const mm of node.members) {
+            const conv = getConversionInfo(mm, actionName);
+            if (conv !== null) {
+                const property = mm;
+                // if invalid, bounce
+                if (!property.initializer) {
+                    return;
+                }
+                traversed = true;
+                const pp = property.initializer.getFullText(sourceFile).trim();
+                const code = `${conv.method}(): ${conv.methodType} {
+            return ${pp}
+          }`;
+                newImports.push(conv.methodType);
+                klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
+            }
+            else {
+                klassContents += mm.getFullText(sourceFile);
+            }
+        }
+        const builderPath = `src/ent/generated/${(0, snake_case_1.snakeCase)(nodeName)}/actions/${(0, snake_case_1.snakeCase)(builder)}`;
+        let imports = new Map([
+            [
+                (0, ast_1.transformRelative)(file, this.customInfo.viewerInfo.path, this.customInfo.relativeImports),
+                [viewer],
+            ],
+            [
+                (0, ast_1.transformRelative)(file, baseInfo.importPath, this.customInfo.relativeImports),
+                newImports,
+            ],
+            [
+                (0, ast_1.transformRelative)(file, builderPath, this.customInfo.relativeImports),
+                [builder],
+            ],
+        ]);
+        // wrap comments and transform to export class Foo extends Bar { ${inner} }
+        return {
+            rawString: classInfo.wrapClassContents(klassContents),
+            traversed,
+            imports,
+            removeImports: ["Trigger", "Observer", "Validator"],
+            // not removing FooBuilder incase it's still somehow used in type of inline builders
+        };
+    }
+}
+exports.TransformAction = TransformAction;

package/tsc/transform_ent.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { TransformFile } from "./transform";
+export declare class TransformEnt implements TransformFile {
+    glob: string;
+    traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): {
+        node: ts.Node;
+        rawString?: undefined;
+        traversed?: undefined;
+        imports?: undefined;
+    } | {
+        rawString: string;
+        traversed: boolean;
+        imports: Map<string, string[]>;
+        node?: undefined;
+    } | undefined;
+    prettierGlob: string;
+}

package/tsc/transform_ent.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformEnt = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("./ast");
+function isPrivacyPolicy(mm) {
+    return (mm.kind === typescript_1.default.SyntaxKind.PropertyDeclaration &&
+        mm.name.escapedText === "privacyPolicy");
+}
+class TransformEnt {
+    constructor() {
+        this.glob = "src/ent/*.ts";
+        this.prettierGlob = "src/ent/*.ts";
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isClassDeclaration(node) || !node.heritageClauses) {
+            return { node };
+        }
+        let classInfo = (0, ast_1.getClassInfo)(contents, sourceFile, node);
+        if (!classInfo) {
+            return;
+        }
+        // different class. ignore
+        // only do classes which extend a base class e.g. User extends UserBase
+        // if different class (e.g. privacy rule), just return it
+        if (classInfo.extends !== classInfo.name + "Base") {
+            return { node };
+        }
+        let klassContents = "";
+        let traversed = false;
+        for (const mm of node.members) {
+            if (isPrivacyPolicy(mm)) {
+                const property = mm;
+                // if invalid privacy policy, bounce
+                if (!property.initializer) {
+                    return;
+                }
+                const pp = property.initializer.getFullText(sourceFile);
+                const code = `getPrivacyPolicy(): PrivacyPolicy<this> {
+            return ${pp}
+          }`;
+                klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
+                traversed = true;
+            }
+            else {
+                klassContents += mm.getFullText(sourceFile);
+            }
+        }
+        return {
+            rawString: classInfo.wrapClassContents(klassContents),
+            traversed,
+            imports: new Map([["@snowtop/ent", ["PrivacyPolicy"]]]),
+        };
+    }
+}
+exports.TransformEnt = TransformEnt;

package/tsc/transform_schema.d.ts

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import { TransformFile } from "./transform";
+export declare class TransformSchema implements TransformFile {
+    private relativeImports;
+    private oldBaseClass?;
+    private newSchemaClass?;
+    private transformPath?;
+    constructor(relativeImports: boolean, oldBaseClass?: string | undefined, newSchemaClass?: string | undefined, transformPath?: string | undefined);
+    glob: string;
+    private transformSchema;
+    traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): {
+        node: ts.Node;
+        traversed?: undefined;
+        rawString?: undefined;
+        removeImports?: undefined;
+        imports?: undefined;
+    } | {
+        traversed: boolean;
+        rawString: string;
+        removeImports: string[];
+        imports: Map<string, string[]>;
+        node?: undefined;
+    } | undefined;
+    fileToWrite(file: string): string;
+    postProcess(file: string): void;
+    prettierGlob: string;
+}