@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha20

package/action/action.d.ts

@@ -49,9 +49,9 @@ export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt
     changeset(): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    triggers?: Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    observers?: Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    validators?: Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getTriggers?(): Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
     getInput(): TInput;
     transformWrite?: (stmt: UpdateOperation<TEnt>) => Promise<TransformedUpdateOperation<TEnt>> | TransformedUpdateOperation<TEnt> | null;
     valid(): Promise<boolean>;

package/action/executor.js

@@ -47,11 +47,11 @@ class ListBasedExecutor {
     }
     async executeObservers() {
         const action = this.options?.action;
-        if (!this.options || !action || !action.observers) {
+        if (!this.options || !action || !action.getObservers) {
             return;
         }
         const builder = this.options.builder;
-        await Promise.all(action.observers.map(async (observer) => {
+        await Promise.all(action.getObservers().map(async (observer) => {
             await observer.observe(builder, action.getInput());
         }));
     }

package/action/experimental_action.d.ts

@@ -19,10 +19,10 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     builderCtr: BuilderConstructor<TEnt, TViewer, TInput>;
     builder: EntBuilder<TEnt, TViewer, TInput>;
     private input;
-    triggers: Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    observers: Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    validators: Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
+    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
+    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
+    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
     constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null);
     static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null): Builder<TEnt>;
     static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput>;

package/action/experimental_action.js

@@ -7,9 +7,6 @@ class BaseAction {
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
-        this.triggers = [];
-        this.observers = [];
-        this.validators = [];
         let operation = options?.operation;
         if (!operation) {
             if (options?.existingEnt) {
@@ -25,6 +22,15 @@ class BaseAction {
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
+    getTriggers() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
     static createBuilder(viewer, builderCtr, options) {
         let action = new BaseAction(viewer, builderCtr, options);
         return action.builder;
@@ -35,7 +41,7 @@ class BaseAction {
         let action = new BaseAction(ent.viewer, builderCtr, {
             existingEnt: ent,
         });
-        action.triggers = [
+        action.getTriggers = () => [
             {
                 changeset: () => {
                     return actions.map((action) => action.changeset());

package/action/orchestrator.js

@@ -317,11 +317,13 @@ class Orchestrator {
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
-        let triggers = action?.triggers;
-        if (triggers) {
-            await this.triggers(action, builder, triggers);
+        if (action?.getTriggers) {
+            await this.triggers(action, builder, action.getTriggers());
+        }
+        let validators = [];
+        if (action?.getValidators) {
+            validators = action.getValidators();
         }
-        let validators = action?.validators || [];
         // not ideal we're calling this twice. fix...
         // needed for now. may need to rewrite some of this?
         const editedFields2 = await this.options.editedFields();

package/core/config.d.ts

@@ -35,6 +35,7 @@ interface CodegenConfig {
     schemaSQLFilePath?: boolean;
     databaseToCompareTo?: string;
     fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
+    templatizedViewer?: templatizedViewer;
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -45,5 +46,9 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
+interface templatizedViewer {
+    path: string;
+    name: string;
+}
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/core/ent.d.ts

@@ -145,7 +145,7 @@ export declare class AssocEdgeData {
     edgeTable: string;
     constructor(data: Data);
 }
-export declare const assocEdgeLoader: DataLoader<any, any, any>;
+export declare const assocEdgeLoader: DataLoader<ID, Data | null, ID>;
 export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
 export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
 export interface AssocEdgeConstructor<T extends AssocEdge> {
@@ -172,8 +172,8 @@ interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptio
 }
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
-export declare function applyPrivacyPolicyForRow<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data | null): Promise<T | null>;
-export declare function applyPrivacyPolicyForRowX<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data): Promise<T>;
-export declare function applyPrivacyPolicyForRows<T extends Ent>(viewer: Viewer, rows: Data[], options: LoadEntOptions<T>): Promise<Map<ID, T>>;
+export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data | null): Promise<TEnt | null>;
+export declare function applyPrivacyPolicyForRowX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt>;
+export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};

package/core/ent.js

@@ -61,6 +61,7 @@ function createDataLoader(options) {
     if ((0, logger_1.logEnabled)("query")) {
         loaderOptions.cacheMap = new cacheMap(options);
     }
+    // something here brokwn with strict:true
     return new dataloader_1.default(async (ids) => {
         if (!ids.length) {
             return [];
@@ -436,6 +437,7 @@ class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;
         this.existingEnt = existingEnt;
+        this.row = null;
         this.placeholderID = options.placeholderID;
     }
     resolve(executor) {
@@ -474,6 +476,7 @@ class EditNodeOperation {
                 this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
             }
             else {
+                // @ts-ignore
                 this.row = this.existingEnt["data"];
             }
         }
@@ -524,6 +527,7 @@ class EditNodeOperation {
                 this.reloadRow(queryer, this.existingEnt.id, options);
             }
             else {
+                // @ts-ignore
                 this.row = this.existingEnt["data"];
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha15",
+  "version": "0.1.0-alpha20",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/scripts/migrate_v0.1.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const transform_1 = require("../tsc/transform");
+const transform_schema_1 = require("../tsc/transform_schema");
+const transform_ent_1 = require("../tsc/transform_ent");
+const move_generated_1 = require("../tsc/move_generated");
+const transform_action_1 = require("../tsc/transform_action");
+const minimist_1 = __importDefault(require("minimist"));
+// call from docker
+// since clients [sh/w]ouldn't have ts-node...
+// locally
+// ts-node --swc --project ./tsconfig.json -r tsconfig-paths/register ../../../ts/src/scripts/migrate_v0.1.ts
+async function main() {
+    const options = (0, minimist_1.default)(process.argv.slice(2));
+    // install 0.1.x dependencies
+    // maybe provide options to make this easier if someone wants to do this in steps to see what's happening
+    if (options.move_generated) {
+        (0, move_generated_1.moveGenerated)();
+    }
+    // codegen  write-all --disable-custom-graphql
+    if (options.transform_schema) {
+        (0, transform_1.transform)(new transform_schema_1.TransformSchema());
+    }
+    // codegen write-all --disable-custom-graphql
+    if (options.transform_ent) {
+        (0, transform_1.transform)(new transform_ent_1.TransformEnt());
+    }
+    if (options.transform_action) {
+        (0, transform_1.transform)(new transform_action_1.TransformAction());
+    }
+    // codegen write-all
+}
+main()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/testutils/builder.d.ts

@@ -98,11 +98,11 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     viewer: Viewer;
     private fields;
     builder: SimpleBuilder<T, TExistingEnt>;
-    validators: Validator<T, SimpleBuilder<T>>[];
-    triggers: Trigger<T, SimpleBuilder<T>>[];
-    observers: Observer<T, SimpleBuilder<T>>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
+    getTriggers(): Trigger<T, SimpleBuilder<T>>[];
+    getValidators(): Validator<T, SimpleBuilder<T>>[];
+    getObservers(): Observer<T, SimpleBuilder<T>>[];
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
     changeset(): Promise<Changeset>;

package/testutils/builder.js

@@ -257,11 +257,17 @@ class SimpleAction {
     constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt) {
         this.viewer = viewer;
         this.fields = fields;
-        this.validators = [];
-        this.triggers = [];
-        this.observers = [];
         this.builder = new SimpleBuilder(this.viewer, schema, fields, operation, existingEnt, this);
     }
+    getTriggers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }

package/tsc/ast.d.ts

@@ -15,7 +15,19 @@ 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 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;
+}
+export declare function getImportInfo(imp: ts.ImportDeclaration, sourceFile: ts.SourceFile): importInfo | undefined;
 export {};

package/tsc/ast.js

@@ -3,7 +3,7 @@ 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.getImportInfo = exports.isSrcGeneratedImport = exports.isRelativeGeneratedImport = exports.isRelativeImport = exports.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 function getPreText(fileContents, node, sourceFile) {
     return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
@@ -31,8 +31,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,21 +81,23 @@ 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/") {
-        return;
+    if (opts?.transformPath) {
+        if (text !== opts.transformPath) {
+            return;
+        }
     }
-    const importText = importNode.importClause?.getText(sourceFile) || "";
-    const start = importText.indexOf("{");
-    const end = importText.lastIndexOf("}");
-    if (start === -1 || end === -1) {
+    else {
+        if (text !== "@snowtop/ent" &&
+            text !== "@snowtop/ent/schema" &&
+            text !== "@snowtop/ent/schema/") {
+            return;
+        }
+    }
+    const impInfo = getImportInfo(importNode, sourceFile);
+    if (!impInfo) {
         return;
     }
-    const imports = importText
-        .substring(start + 1, end)
-        //    .trim()
-        .split(",");
+    const { imports, start, end, importText } = impInfo;
     let removeImportsMap = {};
     if (opts?.removeImports) {
         opts.removeImports.forEach((imp) => (removeImportsMap[imp] = true));
@@ -152,3 +153,39 @@ 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;
+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) {
+        return;
+    }
+    return {
+        importPath: text,
+        importText,
+        start,
+        end,
+        imports: importText
+            .substring(start + 1, end)
+            //.trim()
+            .split(","),
+    };
+}
+exports.getImportInfo = getImportInfo;

package/tsc/move_generated.d.ts

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

package/tsc/move_generated.js

@@ -0,0 +1,175 @@
+"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.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");
+const js_yaml_1 = require("js-yaml");
+class MoveFiles {
+    constructor(globPath) {
+        this.globPath = globPath;
+    }
+    move() {
+        const files = glob_1.glob.sync(this.globPath);
+        moveFiles(files);
+    }
+}
+class TransformImports {
+    constructor(glob, prettierGlob, checkRelativeImportsValid) {
+        this.glob = glob;
+        this.prettierGlob = prettierGlob;
+        this.checkRelativeImportsValid = checkRelativeImportsValid;
+        this.relativeImports = false;
+        this.globOptions = {
+            ignore: ["node_modules/**"],
+        };
+        this.cwd = process.cwd();
+        this.relativeImports = relativeImports();
+    }
+    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 relativeImports() {
+    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;
+        return yaml?.codegen?.relativeImports || false;
+    }
+    catch (e) { }
+    return false;
+}
+function moveGenerated() {
+    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"));
+    (0, transform_1.transform)(new TransformImports("src/graphql/**/*.ts", "src/graphql/**.ts", true));
+}
+exports.moveGenerated = moveGenerated;

package/tsc/transform.d.ts

@@ -0,0 +1,21 @@
+import { IOptions } from "glob";
+import ts from "typescript";
+interface TraverseChildResponse {
+    node?: ts.Node;
+    rawString?: string;
+    traversed?: boolean;
+    imports?: Map<string, string[]>;
+    removeImports?: string[];
+}
+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 {};