@snowtop/ent 0.1.0-alpha8 → 0.1.0-alpha80

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;
+}

package/tsc/transform_schema.js

@@ -0,0 +1,379 @@
+"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.TransformSchema = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ast_1 = require("../tsc/ast");
+function traverseClass(fileContents, sourceFile, node, transformSchema) {
+    const ci = getTransformClassInfo(fileContents, sourceFile, node, transformSchema);
+    if (!ci) {
+        return;
+    }
+    let klassContents = `${ci.comment}const ${ci.name} = new ${transformSchema(ci.class)}({\n`;
+    let removeImports = [];
+    if (ci.implementsSchema) {
+        removeImports.push("Schema");
+    }
+    removeImports.push(ci.class);
+    let newImports = [transformSchema(ci.class)];
+    for (let member of node.members) {
+        const fInfo = getClassElementInfo(fileContents, member, sourceFile);
+        if (!fInfo) {
+            return;
+        }
+        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);
+    return {
+        rawString: klassContents,
+        removeImports: removeImports,
+        newImports,
+    };
+}
+function getTransformClassInfo(fileContents, sourceFile, node, transformSchema) {
+    const generic = (0, ast_1.getClassInfo)(fileContents, sourceFile, node);
+    if (!generic) {
+        return;
+    }
+    let className = generic.name;
+    if (!className?.endsWith("Schema")) {
+        className += "Schema";
+    }
+    let implementsSchema = generic.implements?.some((v) => v == "Schema");
+    let classExtends = generic.extends;
+    // nothing transformed here, so nothing to do here
+    if (classExtends && classExtends === transformSchema(classExtends)) {
+        return undefined;
+    }
+    if (!className || !node.heritageClauses || !classExtends) {
+        return undefined;
+    }
+    let ci = {
+        ...generic,
+        name: className,
+        class: classExtends,
+        implementsSchema,
+    };
+    return ci;
+}
+// intentionally doesn't parse decorators since we don't need it
+function getClassElementInfo(fileContents, member, sourceFile) {
+    if (isFieldElement(fileContents, 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: (0, ast_1.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, suffix } = parsed;
+        let property = "";
+        const fieldComment = (0, ast_1.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})${suffix || ""},`;
+        fieldMap += property;
+    }
+    fieldMap += "}";
+    return {
+        key: "fields",
+        value: fieldMap,
+        comment: (0, ast_1.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(fileContents, 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) {
+        throwErr(fileContents, member, "invalid array type");
+        return false;
+    }
+    return true;
+}
+// if there's an error transforming any of the schemas, we should stop...
+function throwErr(fileContents, node, error) {
+    console.error(error);
+    throw new Error(`error transforming this field ${fileContents.substring(node.getFullStart(), node.getEnd())}`);
+}
+function parseFieldElement(element, sourceFile, fileContents, nested) {
+    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression &&
+        element.kind !== typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+        throwErr(fileContents, element, `skipped unknown (non-call|non-property) expression ${element.kind}`);
+        return null;
+    }
+    if (element.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+        const ret = parseFieldElement(element.expression, sourceFile, fileContents, true);
+        if (ret !== null) {
+            if (!nested) {
+                ret.suffix = fileContents.substring(ret.callEx.getEnd(), element.getEnd());
+            }
+            return ret;
+        }
+    }
+    let callEx = element;
+    if (callEx.arguments.length !== 1) {
+        // have a situation like:     StringType({ name: "canonicalName" }).trim().toLowerCase(),
+        // need to keep calling this until we find what we want and then get the suffix we should just add to the end of the transformed code
+        if (callEx.expression.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+            const ret = parseFieldElement(callEx.expression.expression, sourceFile, fileContents, true);
+            if (ret !== null) {
+                if (!nested) {
+                    ret.suffix = fileContents.substring(ret.callEx.getEnd(), callEx.getEnd());
+                }
+                return ret;
+            }
+        }
+        throwErr(fileContents, element, "callExpression with arguments not of length 1");
+    }
+    let arg = callEx.arguments[0];
+    if (arg.kind !== typescript_1.default.SyntaxKind.ObjectLiteralExpression) {
+        // this and the check above for PropertyAccessExpression are to handle things like
+        // FooType({
+        /// ...
+        // }).function(blah)
+        const ret = parseFieldElement(callEx.expression, sourceFile, fileContents, true);
+        if (ret !== null) {
+            if (!nested) {
+                ret.suffix = fileContents.substring(ret.callEx.getEnd(), callEx.getEnd());
+            }
+            return ret;
+        }
+        throwErr(fileContents, element, `not objectLiteralExpression. kind ${arg.kind}`);
+        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 = (0, ast_1.getPreText)(fileContents, p, sourceFile).trim();
+        }
+        else {
+            properties.push(p.getFullText(sourceFile));
+        }
+    }
+    if (!name) {
+        throwErr(fileContents, element, `couldn't find name property`);
+        return null;
+    }
+    // remove quotes
+    name = name.slice(1, -1);
+    return {
+        callEx,
+        name,
+        properties,
+        nameComment: propertyComment,
+    };
+}
+// find which of these importPaths is being used and use that to replace
+function findSchemaImportPath(sourceFile) {
+    const paths = {
+        "@snowtop/ent": true,
+        "@snowtop/ent/schema": true,
+        "@snowtop/ent/schema/": true,
+    };
+    // @ts-ignore
+    const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
+    for (const imp of importStatements) {
+        const impInfo = (0, ast_1.getImportInfo)(imp, sourceFile);
+        if (!impInfo) {
+            continue;
+        }
+        if (paths[impInfo.importPath] !== undefined) {
+            return impInfo.importPath;
+        }
+    }
+}
+class TransformSchema {
+    // we only end up doing this once because we change the schema representation
+    // so safe to run this multiple times
+    constructor(relativeImports, oldBaseClass, newSchemaClass, transformPath) {
+        this.relativeImports = relativeImports;
+        this.oldBaseClass = oldBaseClass;
+        this.newSchemaClass = newSchemaClass;
+        this.transformPath = transformPath;
+        this.glob = "src/schema/*.ts";
+        this.prettierGlob = "src/schema/*.ts";
+    }
+    transformSchema(className) {
+        if (className === "BaseEntSchema" || className === "BaseEntSchemaWithTZ") {
+            return className.substring(4);
+        }
+        if (className === this.oldBaseClass && this.newSchemaClass) {
+            return this.newSchemaClass;
+        }
+        return className;
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isClassDeclaration(node)) {
+            return { node };
+        }
+        // TODO address implicit schema doesn't work here...
+        const ret = traverseClass(contents, sourceFile, node, this.transformSchema.bind(this));
+        if (ret === undefined) {
+            return;
+        }
+        let imports = new Map();
+        const imp = findSchemaImportPath(sourceFile);
+        if (imp) {
+            if (this.transformPath) {
+                imports.set(imp, []);
+            }
+            else {
+                imports.set(imp, ret.newImports);
+            }
+        }
+        if (this.transformPath) {
+            // add new imports to this path
+            imports.set((0, ast_1.transformRelative)(file, this.transformPath, this.relativeImports), ret.newImports);
+        }
+        return {
+            traversed: true,
+            rawString: ret.rawString,
+            removeImports: ret.removeImports,
+            imports: imports,
+        };
+    }
+    fileToWrite(file) {
+        return "src/schema/" + path_1.default.basename(file).slice(0, -3) + "_schema.ts";
+    }
+    postProcess(file) {
+        fs.rmSync(file);
+    }
+}
+exports.TransformSchema = TransformSchema;