@snowtop/ent 0.1.0-alpha20 → 0.1.0-alpha26

package/package.json

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

package/schema/field.d.ts

@@ -44,7 +44,7 @@ export declare function IntegerType(options?: IntegerOptions): IntegerField;
 export declare class BigIntegerField extends BaseField implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
+export declare function BigIntegerType(options?: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }

package/schema/schema.js

@@ -121,6 +121,7 @@ function getFieldsWithPrivacy(value, fieldMap) {
                     m.set(info.dbCol, privacyPolicy);
                 }
             }
+            return;
         }
         for (const name in fields) {
             const field = fields[name];

package/scripts/migrate_v0.1.js

@@ -9,35 +9,28 @@ 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 ast_1 = require("../tsc/ast");
+// todo-sqlite
+//  ts-node-script --swc --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/migrate_v0.1.ts --transform_schema --old_base_class BaseEntTodoSchema --new_schema_class TodoEntSchema  --transform_path src/schema/patterns/base
+function main() {
+    const customInfo = (0, ast_1.getCustomInfo)();
     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)();
+        (0, move_generated_1.moveGenerated)(customInfo.relativeImports);
     }
     // codegen  write-all --disable-custom-graphql
     if (options.transform_schema) {
-        (0, transform_1.transform)(new transform_schema_1.TransformSchema());
+        (0, transform_1.transform)(new transform_schema_1.TransformSchema(customInfo.relativeImports, options.old_base_class, options.new_schema_class, options.transform_path));
     }
     // 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());
+        (0, transform_1.transform)(new transform_action_1.TransformAction(customInfo));
     }
     // codegen write-all
 }
-main()
-    .then(() => {
-    process.exit(0);
-})
-    .catch((err) => {
-    console.error(err);
-    process.exit(1);
-});
+main();

package/tsc/ast.d.ts

@@ -15,9 +15,9 @@ interface transformOpts {
     removeImports?: string[];
     newImports?: string[];
     transform?: transformImportFn;
-    transformPath?: string;
+    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;
@@ -28,6 +28,16 @@ interface importInfo {
     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;
+}
+export declare function getCustomInfo(): customInfo;
 export {};

package/tsc/ast.js

@@ -1,10 +1,32 @@
 "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.getImportInfo = exports.isSrcGeneratedImport = exports.isRelativeGeneratedImport = exports.isRelativeImport = 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"));
 function getPreText(fileContents, node, sourceFile) {
     return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
 }
@@ -81,26 +103,22 @@ exports.getClassInfo = getClassInfo;
 function transformImport(fileContents, importNode, sourceFile, opts) {
     // remove quotes too
     const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
-    if (opts?.transformPath) {
-        if (text !== opts.transformPath) {
-            return;
-        }
-    }
-    else {
-        if (text !== "@snowtop/ent" &&
-            text !== "@snowtop/ent/schema" &&
-            text !== "@snowtop/ent/schema/") {
-            return;
-        }
+    if (text != opts.transformPath) {
+        return;
     }
     const impInfo = getImportInfo(importNode, sourceFile);
     if (!impInfo) {
         return;
     }
-    const { imports, start, end, importText } = impInfo;
+    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++) {
@@ -122,9 +140,13 @@ function transformImport(fileContents, importNode, sourceFile, opts) {
     const comment = getPreText(fileContents, importNode, sourceFile);
     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 +
         '";');
@@ -169,23 +191,74 @@ function isSrcGeneratedImport(node, sourceFile) {
     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) {
+    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: importText
-            .substring(start + 1, end)
-            //.trim()
-            .split(","),
+        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 + "/";
+    }
+    return p;
+}
+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,
+            };
+        }
+    }
+    catch (e) { }
+    return {
+        viewerInfo: {
+            path: "@snowtop/ent",
+            name: "Viewer",
+        },
+        relativeImports,
+    };
+}
+exports.getCustomInfo = getCustomInfo;

package/tsc/move_generated.d.ts

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

package/tsc/move_generated.js

@@ -29,7 +29,6 @@ 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;
@@ -40,16 +39,15 @@ class MoveFiles {
     }
 }
 class TransformImports {
-    constructor(glob, prettierGlob, checkRelativeImportsValid) {
+    constructor(glob, prettierGlob, relativeImports, checkRelativeImportsValid) {
         this.glob = glob;
         this.prettierGlob = prettierGlob;
+        this.relativeImports = relativeImports;
         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)) {
@@ -153,23 +151,10 @@ function moveFiles(files) {
         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() {
+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"));
-    (0, transform_1.transform)(new TransformImports("src/graphql/**/*.ts", "src/graphql/**.ts", true));
+    (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.js

@@ -47,7 +47,17 @@ function transform(transform) {
         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;
@@ -82,7 +92,10 @@ function transform(transform) {
                     if (seen.has(imp)) {
                         continue;
                     }
-                    newContents += `\nimport { ${list.join(", ")} } from "${imp}"`;
+                    const final = list.filter((v) => !seenImports.has(v));
+                    if (final.length) {
+                        newContents += `\nimport { ${final.join(", ")} } from "${imp}"`;
+                    }
                 }
                 afterProcessed = true;
             }
@@ -91,10 +104,12 @@ function transform(transform) {
             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);
-                        if (list) {
+                        // 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
@@ -113,7 +128,8 @@ function transform(transform) {
                     }
                 }
                 else {
-                    if (!typescript_1.default.isExportDeclaration(node.node)) {
+                    if (!typescript_1.default.isExportDeclaration(node.node) &&
+                        !isRequireStatement(node.node, sourceFile)) {
                         processAfterImport();
                     }
                 }
@@ -131,7 +147,6 @@ function transform(transform) {
         if (transform.fileToWrite) {
             writeFile = transform.fileToWrite(file);
         }
-        // TODO new file
         fs.writeFileSync(writeFile, newContents);
         if (transform.postProcess) {
             transform.postProcess(file);
@@ -142,3 +157,11 @@ function transform(transform) {
     }
 }
 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

@@ -1,17 +1,11 @@
 import ts from "typescript";
+import { customInfo } from "../tsc/ast";
 import { TransformFile } from "./transform";
-interface customInfo {
-    viewerInfo: {
-        path: string;
-        name: string;
-    };
-    relativeImports?: boolean;
-}
 export declare class TransformAction implements TransformFile {
+    private customInfo;
     glob: string;
-    customInfo: customInfo;
     prettierGlob: string;
-    constructor();
+    constructor(customInfo: customInfo);
     traverseChild(sourceFile: ts.SourceFile, contents: string, file: string, node: ts.Node): {
         node: ts.Node;
         rawString?: undefined;
@@ -24,4 +18,3 @@ export declare class TransformAction implements TransformFile {
         node?: undefined;
     } | undefined;
 }
-export {};

package/tsc/transform_action.js

@@ -25,35 +25,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformAction = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const ast_1 = require("../tsc/ast");
-const fs = __importStar(require("fs"));
 const action_1 = require("../action");
 const viewer_1 = require("../core/viewer");
 const path = __importStar(require("path"));
-const js_yaml_1 = require("js-yaml");
-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,
-            };
-        }
-    }
-    catch (e) { }
-    return {
-        viewerInfo: {
-            path: "@snowtop/ent",
-            name: "Viewer",
-        },
-        relativeImports,
-    };
-}
+const snake_case_1 = require("snake-case");
 function findInput(file, classInfo, sourceFile) {
     // @ts-ignore
     const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
@@ -116,26 +91,11 @@ function getConversionInfo(mm) {
         interface: v.i,
     };
 }
-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));
-}
-function normalizePath(p) {
-    if (p.endsWith("..")) {
-        return p + "/";
-    }
-    return p;
-}
 class TransformAction {
-    constructor() {
+    constructor(customInfo) {
+        this.customInfo = customInfo;
         this.glob = "src/ent/**/actions/**/*_action.ts";
         this.prettierGlob = "src/ent/**/actions/**.ts";
-        this.customInfo = getCustomInfo();
     }
     traverseChild(sourceFile, contents, file, node) {
         if (!typescript_1.default.isClassDeclaration(node) || !node.heritageClauses) {
@@ -182,16 +142,21 @@ class TransformAction {
                 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([
             [
-                transformRelative(file, this.customInfo.viewerInfo.path, this.customInfo.relativeImports),
+                (0, ast_1.transformRelative)(file, this.customInfo.viewerInfo.path, this.customInfo.relativeImports),
                 [viewer],
             ],
             [
-                transformRelative(file, "src/ent", this.customInfo.relativeImports),
+                (0, ast_1.transformRelative)(file, "src/ent", this.customInfo.relativeImports),
                 [nodeName],
             ],
             ["@snowtop/ent/action", newImports],
+            [
+                (0, ast_1.transformRelative)(file, builderPath, this.customInfo.relativeImports),
+                [builder],
+            ],
         ]);
         // wrap comments and transform to export class Foo extends Bar { ${inner} }
         return {

package/tsc/transform_schema.d.ts

@@ -1,7 +1,13 @@
 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;

package/tsc/transform_schema.js

@@ -27,8 +27,8 @@ 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) {
-    const ci = getTransformClassInfo(fileContents, sourceFile, node);
+function traverseClass(fileContents, sourceFile, node, transformSchema) {
+    const ci = getTransformClassInfo(fileContents, sourceFile, node, transformSchema);
     if (!ci) {
         return;
     }
@@ -63,17 +63,7 @@ function traverseClass(fileContents, sourceFile, node) {
         newImports,
     };
 }
-function transformSchema(str) {
-    // only do known class names
-    if (str === "BaseEntSchema" || str === "BaseEntSchemaWithTZ") {
-        return str.substring(4);
-    }
-    return str;
-}
-// TODO need to generify this...
-// and then have a schema specific version
-// may make sense to just duplicate this logic...
-function getTransformClassInfo(fileContents, sourceFile, node) {
+function getTransformClassInfo(fileContents, sourceFile, node, transformSchema) {
     const generic = (0, ast_1.getClassInfo)(fileContents, sourceFile, node);
     if (!generic) {
         return;
@@ -84,6 +74,7 @@ function getTransformClassInfo(fileContents, sourceFile, node) {
     }
     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;
     }
@@ -285,7 +276,7 @@ function parseFieldElement(element, sourceFile, fileContents, nested) {
     };
 }
 // find which of these importPaths is being used and use that to replace
-function findImportPath(sourceFile) {
+function findSchemaImportPath(sourceFile) {
     const paths = {
         "@snowtop/ent": true,
         "@snowtop/ent/schema": true,
@@ -304,25 +295,47 @@ function findImportPath(sourceFile) {
     }
 }
 class TransformSchema {
-    constructor() {
-        // we only end up doing this once because we change the schema representation
-        // so safe to run this multiple times
+    // 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);
+        const ret = traverseClass(contents, sourceFile, node, this.transformSchema.bind(this));
         if (ret === undefined) {
             return;
         }
         let imports = new Map();
-        const imp = findImportPath(sourceFile);
+        const imp = findSchemaImportPath(sourceFile);
         if (imp) {
-            imports.set(imp, ret.newImports);
+            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,