@snowtop/ent 0.1.0-alpha13 → 0.1.0-alpha130

package/testutils/parse_sql.d.ts

@@ -9,6 +9,12 @@ export declare class EqOp {
     constructor(col: string, value: any);
     apply(data: Data): boolean;
 }
+export declare class NotEqOp {
+    private col;
+    private value;
+    constructor(col: string, value: any);
+    apply(data: Data): boolean;
+}
 export declare class GreaterOp {
     private col;
     private value;

package/testutils/parse_sql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performQuery = exports.OrOp = exports.AndOp = exports.InOp = exports.LessEqOp = exports.GreaterEqOp = exports.LessOp = exports.GreaterOp = exports.EqOp = exports.getDataToReturn = void 0;
+exports.performQuery = exports.OrOp = exports.AndOp = exports.InOp = exports.LessEqOp = exports.GreaterEqOp = exports.LessOp = exports.GreaterOp = exports.NotEqOp = exports.EqOp = exports.getDataToReturn = void 0;
 const node_sql_parser_1 = require("node-sql-parser");
 function getTableName(table) {
     if (Array.isArray(table)) {
@@ -184,6 +184,16 @@ class EqOp {
     }
 }
 exports.EqOp = EqOp;
+class NotEqOp {
+    constructor(col, value) {
+        this.col = col;
+        this.value = value;
+    }
+    apply(data) {
+        return data[this.col] !== this.value;
+    }
+}
+exports.NotEqOp = NotEqOp;
 class GreaterOp {
     constructor(col, value) {
         this.col = col;
@@ -307,8 +317,12 @@ function getOp(where, values) {
             return new AndOp([getOp(where.left, values), getOp(where.right, values)]);
         case "OR":
             return new OrOp([getOp(where.left, values), getOp(where.right, values)]);
+        case "IS":
+            return new EqOp(getColumnFromRef(where.left), where.right?.value);
+        case "IS NOT":
+            return new NotEqOp(getColumnFromRef(where.left), where.right?.value);
         default:
-            console.log(where);
+            console.debug(where);
             throw new Error(`unsupported op ${where.operator}`);
     }
 }

package/testutils/test_edge_global_schema.d.ts

@@ -0,0 +1,15 @@
+import { EdgeUpdateOperation, TransformedEdgeUpdateOperation } from "../schema";
+import * as clause from "../core/clause";
+import { AssocEdge } from "../core/ent";
+import { Data } from "../core/base";
+export declare class EdgeWithDeletedAt extends AssocEdge {
+    deletedAt: Date | null;
+    constructor(data: Data);
+}
+export declare const testEdgeGlobalSchema: {
+    extraEdgeFields: {
+        deletedAt: import("../schema").TimestampField;
+    };
+    transformEdgeRead(): clause.Clause;
+    transformEdgeWrite(stmt: EdgeUpdateOperation): TransformedEdgeUpdateOperation | null;
+};

package/testutils/test_edge_global_schema.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testEdgeGlobalSchema = exports.EdgeWithDeletedAt = void 0;
+const schema_1 = require("../schema");
+const clause = __importStar(require("../core/clause"));
+const ent_1 = require("../core/ent");
+class EdgeWithDeletedAt extends ent_1.AssocEdge {
+    constructor(data) {
+        super(data);
+        this.deletedAt = data.deleted_at;
+    }
+}
+exports.EdgeWithDeletedAt = EdgeWithDeletedAt;
+exports.testEdgeGlobalSchema = {
+    extraEdgeFields: {
+        // need this to be lowerCamelCase because we do this based on field name
+        // #510
+        deletedAt: (0, schema_1.TimestampType)({
+            nullable: true,
+            index: true,
+            defaultValueOnCreate: () => null,
+        }),
+    },
+    transformEdgeRead() {
+        return clause.Eq("deleted_at", null);
+    },
+    transformEdgeWrite(stmt) {
+        switch (stmt.op) {
+            case schema_1.SQLStatementOperation.Delete:
+                return {
+                    op: schema_1.SQLStatementOperation.Update,
+                    data: {
+                        deleted_at: new Date(),
+                    },
+                };
+        }
+        return null;
+    },
+};

package/testutils/write.d.ts

@@ -1,5 +1,5 @@
-import { EditRowOptions, Data, ID, DataOptions, CreateRowOptions } from "../core/base";
+import { EditRowOptions, Data, DataOptions, CreateRowOptions } from "../core/base";
 import * as clause from "../core/clause";
 export declare function createRowForTest(options: CreateRowOptions, suffix?: string): Promise<Data | null>;
-export declare function editRowForTest(options: EditRowOptions, id: ID, suffix?: string): Promise<Data | null>;
+export declare function editRowForTest(options: EditRowOptions, suffix?: string): Promise<Data | null>;
 export declare function deleteRowsForTest(options: DataOptions, cls: clause.Clause): Promise<void>;

package/testutils/write.js

@@ -1,16 +1,42 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteRowsForTest = exports.editRowForTest = exports.createRowForTest = void 0;
 const ent_1 = require("../core/ent");
-const db_1 = __importDefault(require("../core/db"));
+const db_1 = __importStar(require("../core/db"));
 function isSyncClient(client) {
     return client.execSync !== undefined;
 }
 async function createRowForTest(options, suffix) {
-    const client = await db_1.default.getInstance().getNewClient();
+    let client;
+    if (db_1.Dialect.SQLite === db_1.default.getDialect()) {
+        client = db_1.default.getInstance().getSQLiteClient();
+    }
+    else {
+        client = await db_1.default.getInstance().getNewClient();
+    }
     try {
         if (isSyncClient(client)) {
             return (0, ent_1.createRowSync)(client, options, suffix || "");
@@ -22,13 +48,13 @@ async function createRowForTest(options, suffix) {
     }
 }
 exports.createRowForTest = createRowForTest;
-async function editRowForTest(options, id, suffix) {
+async function editRowForTest(options, suffix) {
     const client = await db_1.default.getInstance().getNewClient();
     try {
         if (isSyncClient(client)) {
-            return (0, ent_1.editRowSync)(client, options, id, suffix || "");
+            return (0, ent_1.editRowSync)(client, options, suffix || "");
         }
-        return await (0, ent_1.editRow)(client, options, id, suffix);
+        return await (0, ent_1.editRow)(client, options, suffix);
     }
     finally {
         client.release();

package/tsc/ast.d.ts

@@ -10,12 +10,35 @@ export interface ClassInfo {
     wrapClassContents(inner: string): string;
 }
 export declare function getClassInfo(fileContents: string, sourceFile: ts.SourceFile, node: ts.ClassDeclaration): ClassInfo | undefined;
-declare type transformImportFn = (imp: string) => string;
+type transformImportFn = (imp: string) => string;
 interface transformOpts {
     removeImports?: string[];
     newImports?: string[];
     transform?: transformImportFn;
+    transformPath: string;
 }
-export declare function transformImport(fileContents: string, importNode: ts.ImportDeclaration, sourceFile: ts.SourceFile, opts?: transformOpts): string | undefined;
+export declare function transformImport(fileContents: string, importNode: ts.ImportDeclaration, sourceFile: ts.SourceFile, opts: transformOpts): string | undefined;
 export declare function updateImportPath(fileContents: string, importNode: ts.ImportDeclaration, sourceFile: ts.SourceFile, newPath: string): string | undefined;
+export declare function isRelativeImport(node: ts.ImportDeclaration, sourceFile: ts.SourceFile): boolean;
+export declare function isRelativeGeneratedImport(node: ts.ImportDeclaration, sourceFile: ts.SourceFile): boolean;
+export declare function isSrcGeneratedImport(node: ts.ImportDeclaration, sourceFile: ts.SourceFile): boolean;
+interface importInfo {
+    imports: string[];
+    start: number;
+    end: number;
+    importText: string;
+    importPath: string;
+    default?: string;
+}
+export declare function getImportInfo(imp: ts.ImportDeclaration, sourceFile: ts.SourceFile): importInfo | undefined;
+export declare function transformRelative(file: string, importPath: string, relative?: boolean): string;
+export interface customInfo {
+    viewerInfo: {
+        path: string;
+        name: string;
+    };
+    relativeImports?: boolean;
+    globalSchemaPath?: string;
+}
+export declare function getCustomInfo(): customInfo;
 export {};

package/tsc/ast.js

@@ -1,10 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
+exports.getCustomInfo = exports.transformRelative = exports.getImportInfo = exports.isSrcGeneratedImport = exports.isRelativeGeneratedImport = exports.isRelativeImport = exports.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
 const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+const fs = __importStar(require("fs"));
+const const_1 = require("../core/const");
 function getPreText(fileContents, node, sourceFile) {
     return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
 }
@@ -31,8 +58,7 @@ function getClassInfo(fileContents, sourceFile, node) {
             }
         }
     }
-    // we probably still don't need all of this...
-    if (!className || !node.heritageClauses || !classExtends) {
+    if (!className) {
         return undefined;
     }
     let hasExport = false;
@@ -82,24 +108,22 @@ exports.getClassInfo = getClassInfo;
 function transformImport(fileContents, importNode, sourceFile, opts) {
     // remove quotes too
     const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
-    if (text !== "@snowtop/ent" &&
-        text !== "@snowtop/ent/schema" &&
-        text !== "@snowtop/ent/schema/") {
+    if (text != opts.transformPath) {
         return;
     }
-    const importText = importNode.importClause?.getText(sourceFile) || "";
-    const start = importText.indexOf("{");
-    const end = importText.lastIndexOf("}");
-    if (start === -1 || end === -1) {
+    const impInfo = getImportInfo(importNode, sourceFile);
+    if (!impInfo) {
         return;
     }
-    const imports = importText
-        .substring(start + 1, end)
-        //    .trim()
-        .split(",");
+    let { imports, start, end, importText, default: def } = impInfo;
     let removeImportsMap = {};
     if (opts?.removeImports) {
-        opts.removeImports.forEach((imp) => (removeImportsMap[imp] = true));
+        opts.removeImports.forEach((imp) => {
+            removeImportsMap[imp] = true;
+            if (def === imp) {
+                def = "";
+            }
+        });
     }
     let finalImports = new Set();
     for (let i = 0; i < imports.length; i++) {
@@ -119,11 +143,18 @@ function transformImport(fileContents, importNode, sourceFile, opts) {
         opts.newImports.forEach((imp) => finalImports.add(imp));
     }
     const comment = getPreText(fileContents, importNode, sourceFile);
+    if (!finalImports.size) {
+        return;
+    }
     return (comment +
         "import " +
-        importText.substring(0, start + 1) +
+        // add default
+        (def || "") +
+        // should probably always be "{" now that we support default
+        (start >= 0 ? importText.substring(0, start + 1) : "{") +
         Array.from(finalImports).join(", ") +
-        importText.substring(end) +
+        // should probably always be "}"
+        (end >= 0 ? importText.substring(end) : "}") +
         ' from "' +
         text +
         '";');
@@ -152,3 +183,96 @@ function updateImportPath(fileContents, importNode, sourceFile, newPath) {
         '";');
 }
 exports.updateImportPath = updateImportPath;
+function isRelativeImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return text.startsWith("..") || text.startsWith("./");
+}
+exports.isRelativeImport = isRelativeImport;
+function isRelativeGeneratedImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return ((text.startsWith("..") || text.startsWith("./")) &&
+        text.indexOf("/generated") !== -1);
+}
+exports.isRelativeGeneratedImport = isRelativeGeneratedImport;
+function isSrcGeneratedImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return text.startsWith("src") && text.includes("/generated");
+}
+exports.isSrcGeneratedImport = isSrcGeneratedImport;
+// TODO doesn't support default + {} yet
+function getImportInfo(imp, sourceFile) {
+    const importText = imp.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if ((start === -1 || end === -1) && !importText.length) {
+        return;
+    }
+    let imports = [];
+    let def;
+    if (start !== -1 && end !== -1) {
+        imports = importText
+            .substring(start + 1, end)
+            //.trim()
+            .split(",");
+    }
+    else {
+        def = importText;
+    }
+    return {
+        importPath: text,
+        importText,
+        start,
+        end,
+        imports,
+        default: def,
+    };
+}
+exports.getImportInfo = getImportInfo;
+function transformRelative(file, importPath, relative) {
+    if (!relative || !importPath.startsWith("src")) {
+        return importPath;
+    }
+    const fileFullPath = path.join(process.cwd(), file);
+    const impFullPath = path.join(process.cwd(), importPath);
+    // relative path is from directory
+    return normalizePath(path.relative(path.dirname(fileFullPath), impFullPath));
+}
+exports.transformRelative = transformRelative;
+function normalizePath(p) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    if (!p.startsWith("..")) {
+        return "./" + p;
+    }
+    return p;
+}
+// also used in parse schema logic
+function getCustomInfo() {
+    let yaml = {};
+    let relativeImports = false;
+    try {
+        yaml = (0, js_yaml_1.load)(fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
+            encoding: "utf8",
+        }));
+        relativeImports = yaml?.codegen?.relativeImports || false;
+        if (yaml?.codegen?.templatizedViewer) {
+            return {
+                viewerInfo: yaml.codegen.templatizedViewer,
+                relativeImports,
+                globalSchemaPath: yaml.globalSchemaPath,
+            };
+        }
+    }
+    catch (e) { }
+    return {
+        viewerInfo: {
+            path: const_1.PACKAGE,
+            name: "Viewer",
+        },
+        relativeImports,
+        globalSchemaPath: yaml.globalSchemaPath,
+    };
+}
+exports.getCustomInfo = getCustomInfo;

package/tsc/compilerOptions.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/tsc/move_generated.d.ts

@@ -0,0 +1 @@
+export declare function moveGenerated(relativeImports: boolean): void;

package/tsc/move_generated.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.moveGenerated = void 0;
+const glob_1 = require("glob");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("./ast");
+const transform_1 = require("./transform");
+class MoveFiles {
+    constructor(globPath) {
+        this.globPath = globPath;
+    }
+    move() {
+        const files = glob_1.glob.sync(this.globPath);
+        moveFiles(files);
+    }
+}
+class TransformImports {
+    constructor(glob, prettierGlob, relativeImports, checkRelativeImportsValid) {
+        this.glob = glob;
+        this.prettierGlob = prettierGlob;
+        this.relativeImports = relativeImports;
+        this.checkRelativeImportsValid = checkRelativeImportsValid;
+        this.globOptions = {
+            ignore: ["node_modules/**"],
+        };
+        this.cwd = process.cwd();
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isImportDeclaration(node)) {
+            return { node };
+        }
+        let dirPath = path.join(this.cwd, file, "..");
+        const newImportPath = this.getNewImportPath(node, file, sourceFile, dirPath);
+        if (!newImportPath) {
+            return { node };
+        }
+        const v = (0, ast_1.updateImportPath)(contents, node, sourceFile, newImportPath);
+        return {
+            traversed: true,
+            rawString: v,
+        };
+    }
+    getNewImportPath(node, file, sourceFile, dirPath) {
+        const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        // it's relative and has generated in there, continue
+        // do relative imports path regardless of if relative imports is on or not
+        if ((0, ast_1.isRelativeGeneratedImport)(node, sourceFile)) {
+            const oldPath = path.join(dirPath, text);
+            const relFromRoot = path.relative(".", oldPath);
+            const conv = transformPath(relFromRoot);
+            if (!conv || conv.newFile === relFromRoot) {
+                return;
+            }
+            return path.relative(dirPath, conv.newFile);
+        }
+        if (this.checkRelativeImportsValid && (0, ast_1.isRelativeImport)(node, sourceFile)) {
+            const parts = file.split(path.sep);
+            if (parts.length === 5 &&
+                parts.slice(0, 3).join(path.sep) ===
+                    ["src", "graphql", "generated"].join(path.sep)) {
+                // we have custom graphql import paths
+                // src/graphql/generated/mutations|resolvers/foo_type.ts
+                // which used to be
+                // src/graphql/mutations|resolvers/generated/foo_type.ts
+                // we probably have a broken import.
+                // try and fix it...
+                let temp = parts[2];
+                parts[2] = parts[3];
+                parts[3] = temp;
+                const oldPath = parts.join(path.sep);
+                let oldDir = path.join(this.cwd, oldPath, "..");
+                let importPath = path.join(oldDir, text);
+                let exists = fs.statSync(importPath + ".ts", { throwIfNoEntry: false });
+                if (!exists) {
+                    // doesn't exist. sadly has to be fixed manually. could theoretically also be a directory but we shouldn't have that
+                    return;
+                }
+                return path.relative(dirPath, importPath);
+            }
+        }
+        // if relative imports, we done.
+        if (this.relativeImports) {
+            return;
+        }
+        // non relative, only transform src paths with generated
+        if ((0, ast_1.isSrcGeneratedImport)(node, sourceFile)) {
+            const conv = transformPath(text);
+            if (!conv || conv.newFile === text) {
+                return;
+            }
+            return conv.newFile;
+        }
+        return;
+    }
+}
+function transformPath(old) {
+    const parts = old.split(path.sep);
+    if (parts.length < 3) {
+        return;
+    }
+    const changedParts = parts
+        .slice(0, 2)
+        .concat("generated")
+        .concat(parts.slice(2).filter((v) => v !== "generated"));
+    const newFile = changedParts.join(path.sep);
+    return { changedParts, newFile };
+}
+function moveFiles(files) {
+    files.forEach((file) => {
+        const conv = transformPath(file);
+        if (!conv) {
+            return;
+        }
+        const { changedParts, newFile } = conv;
+        if (file === newFile) {
+            return;
+        }
+        // check if directory exists, if not, create recursive dir
+        const p = changedParts.slice(0, changedParts.length - 1).join(path.sep);
+        const statInfo = fs.statSync(p, { throwIfNoEntry: false });
+        if (!statInfo) {
+            fs.mkdirSync(p, {
+                recursive: true,
+            });
+        }
+        // move file to new location
+        fs.renameSync(file, newFile);
+    });
+}
+function moveGenerated(relativeImports) {
+    new MoveFiles("src/ent/**/generated/**/**.ts").move();
+    new MoveFiles("src/graphql/**/generated/**/**.ts").move();
+    (0, transform_1.transform)(new TransformImports("src/ent/**/*.ts", "src/ent/**/*.ts", relativeImports));
+    (0, transform_1.transform)(new TransformImports("src/graphql/**/*.ts", "src/graphql/**/*.ts", relativeImports, true));
+}
+exports.moveGenerated = moveGenerated;

package/tsc/transform.d.ts

@@ -0,0 +1,22 @@
+import { IOptions } from "glob";
+import ts from "typescript";
+interface TraverseChildResponse {
+    node?: ts.Node;
+    rawString?: string;
+    traversed?: boolean;
+    imports?: Map<string, string[]>;
+    removeImports?: string[];
+    allowSeenImportsAdded?: boolean;
+}
+export interface TransformFile {
+    glob: string;
+    globOptions?: IOptions;
+    preprocessFile?: (contents: string, file: string, sourceFile: ts.SourceFile) => boolean;
+    traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): TraverseChildResponse | undefined;
+    filter?(files: string[]): string[];
+    fileToWrite?(file: string): string;
+    postProcess?(file: string): void;
+    prettierGlob?: string;
+}
+export declare function transform(transform: TransformFile): void;
+export {};