@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha12

package/action/orchestrator.d.ts

@@ -1,6 +1,6 @@
 import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
 import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
-import { SchemaInputType } from "../schema/schema";
+import { SchemaInputType, FieldInfoMap } from "../schema/schema";
 import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
 export interface OrchestratorOptions<TEnt extends Ent, TData extends Data> {
@@ -14,6 +14,7 @@ export interface OrchestratorOptions<TEnt extends Ent, TData extends Data> {
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
     updateInput?: (data: TData) => void;
+    fieldInfo: FieldInfoMap;
 }
 interface edgeInputDataOpts {
     edgeType: string;
@@ -44,6 +45,7 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private actualOperation;
     private existingEnt?;
     private disableTransformations;
+    private memoizedGetFields;
     constructor(options: OrchestratorOptions<TEnt, TData>);
     private addEdge;
     setDisableTransformations(val: boolean): void;
@@ -60,12 +62,15 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private getEntForPrivacyPolicyImpl;
     private getSQLStatementOperation;
     private getWriteOpForSQLStamentOp;
-    getPossibleUnsafeEntForPrivacy(): Promise<TEnt | undefined>;
+    getPossibleUnsafeEntForPrivacy(): Promise<TEnt>;
+    getEditedData(): Promise<Data>;
     private getFieldsInfo;
     private validate;
     private triggers;
     private validators;
     private isBuilder;
+    private getInputKey;
+    private getStorageKey;
     private getFieldsWithDefaultValues;
     private hasData;
     private transformFieldValue;

package/action/orchestrator.js

@@ -1,13 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
 const action_1 = require("../action");
-const camel_case_1 = require("camel-case");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
+const memoizee_1 = __importDefault(require("memoizee"));
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -63,6 +66,7 @@ class Orchestrator {
         this.viewer = options.viewer;
         this.actualOperation = this.options.operation;
         this.existingEnt = this.options.builder.existingEnt;
+        this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
     }
     addEdge(edge, op) {
         this.edgeSet.add(edge.edgeType);
@@ -269,9 +273,18 @@ class Orchestrator {
         if (this.actualOperation !== action_1.WriteOperation.Insert) {
             return this.existingEnt;
         }
-        const { editedData } = await this.getFieldsInfo();
+        const { editedData } = await this.memoizedGetFields();
         return this.getEntForPrivacyPolicyImpl(editedData);
     }
+    // this gets the fields that were explicitly set plus any default or transformed values
+    // mainly exists to get default fields e.g. default id to be used in triggers
+    // NOTE: this API may change in the future
+    // doesn't work to get ids for autoincrement keys
+    async getEditedData() {
+        const { editedData } = await this.memoizedGetFields();
+        return editedData;
+    }
+    // Note: this is memoized. call memoizedGetFields instead
     async getFieldsInfo() {
         const action = this.options.action;
         const builder = this.options.builder;
@@ -290,7 +303,7 @@ class Orchestrator {
                     throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
         }
-        const { schemaFields, editedData } = await this.getFieldsInfo();
+        const { schemaFields, editedData } = await this.memoizedGetFields();
         const action = this.options.action;
         const builder = this.options.builder;
         // this runs in following phases:
@@ -348,6 +361,12 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
+    getInputKey(k) {
+        return this.options.fieldInfo[k].inputKey;
+    }
+    getStorageKey(k) {
+        return this.options.fieldInfo[k].dbCol;
+    }
     async getFieldsWithDefaultValues(builder, schemaFields, editedFields, action) {
         let data = {};
         let defaultData = {};
@@ -386,9 +405,8 @@ class Orchestrator {
                     if (field.format) {
                         val = field.format(transformed.data[k]);
                     }
-                    let dbKey = (0, schema_1.getStorageKey)(field, k);
-                    data[dbKey] = val;
-                    this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(k)] = val;
+                    data[this.getStorageKey(k)] = val;
+                    this.defaultFieldsByTSName[this.getInputKey(k)] = val;
                     // hmm do we need this?
                     // TODO how to do this for local tests?
                     // this.defaultFieldsByFieldName[k] = val;
@@ -404,7 +422,7 @@ class Orchestrator {
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
             let defaultValue = undefined;
-            let dbKey = (0, schema_1.getStorageKey)(field, fieldName);
+            let dbKey = this.getStorageKey(fieldName);
             if (value === undefined) {
                 if (this.actualOperation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
@@ -432,8 +450,7 @@ class Orchestrator {
                 updateInput = true;
                 defaultData[dbKey] = defaultValue;
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
-                // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
-                this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
+                this.defaultFieldsByTSName[this.getInputKey(fieldName)] = defaultValue;
             }
         }
         // if there's data changing, add data
@@ -494,8 +511,7 @@ class Orchestrator {
                 }
             }
             if (field.format) {
-                // TODO this could be async e.g. password. handle this better
-                value = await Promise.resolve(field.format(value));
+                value = await field.format(value);
             }
         }
         return value;
@@ -514,7 +530,7 @@ class Orchestrator {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
-            let dbKey = (0, schema_1.getStorageKey)(field, fieldName);
+            let dbKey = this.getStorageKey(fieldName);
             value = await this.transformFieldValue(fieldName, field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
@@ -527,7 +543,7 @@ class Orchestrator {
             for (const fieldName in this.defaultFieldsByFieldName) {
                 const defaultValue = this.defaultFieldsByFieldName[fieldName];
                 let field = schemaFields.get(fieldName);
-                let dbKey = (0, schema_1.getStorageKey)(field, fieldName);
+                let dbKey = this.getStorageKey(fieldName);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
                     const value = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);

package/package.json

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

package/schema/schema.d.ts

@@ -4,6 +4,13 @@ import { Clause } from "../core/clause";
 export declare type FieldMap = {
     [key: string]: Field;
 };
+interface FieldInfo {
+    dbCol: string;
+    inputKey: string;
+}
+export declare type FieldInfoMap = {
+    [key: string]: FieldInfo;
+};
 export default interface Schema {
     fields: FieldMap | Field[];
     tableName?: string;
@@ -185,8 +192,11 @@ export interface SchemaConstructor {
 export declare type SchemaInputType = Schema | SchemaConstructor;
 export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
+/**
+ * @deprecated should only be used by tests
+ */
 export declare function getStorageKey(field: Field, fieldName: string): string;
-export declare function getFieldsWithPrivacy(value: SchemaInputType): Map<string, PrivacyPolicy>;
+export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldMap: FieldInfoMap): Map<string, PrivacyPolicy>;
 export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
 interface objectLoaderOptions {
     clause?: () => Clause | undefined;

package/schema/schema.js

@@ -86,12 +86,15 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
+/**
+ * @deprecated should only be used by tests
+ */
 function getStorageKey(field, fieldName) {
     return field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
 }
 exports.getStorageKey = getStorageKey;
 // returns a mapping of storage key to field privacy
-function getFieldsWithPrivacy(value) {
+function getFieldsWithPrivacy(value, fieldMap) {
     const schema = getSchema(value);
     function addFields(fields) {
         if (Array.isArray(fields)) {
@@ -111,7 +114,11 @@ function getFieldsWithPrivacy(value) {
                     else {
                         privacyPolicy = field.privacyPolicy;
                     }
-                    m.set(getStorageKey(field, name), privacyPolicy);
+                    const info = fieldMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
                 }
             }
         }
@@ -128,7 +135,11 @@ function getFieldsWithPrivacy(value) {
                 else {
                     privacyPolicy = field.privacyPolicy;
                 }
-                m.set(getStorageKey(field, name), privacyPolicy);
+                const info = fieldMap[name];
+                if (!info) {
+                    throw new Error(`field with name ${name} not passed in fieldMap`);
+                }
+                m.set(info.dbCol, privacyPolicy);
             }
         }
     }

package/scripts/move_generated.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/move_generated.js

@@ -0,0 +1,142 @@
+"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 });
+const glob_1 = require("glob");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("../tsc/ast");
+const child_process_1 = require("child_process");
+// src/ent/generated and src/graphql/generated
+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 updateImports(files, target, cwd) {
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let nodes = [];
+        let updated = false;
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            let dirPath = path.join(cwd, file, "..");
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const conv = isGeneratedPath(node, sourceFile, dirPath);
+                if (!conv) {
+                    nodes.push({ node });
+                    return;
+                }
+                updated = true;
+                const newImportPath = path.relative(dirPath, conv.newFile);
+                const v = (0, ast_1.updateImportPath)(contents, node, sourceFile, newImportPath);
+                nodes.push({ rawString: v });
+            }
+            else {
+                nodes.push({ node });
+            }
+        });
+        let newContents = "";
+        for (const node of nodes) {
+            if (node.node) {
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+        }
+        if (updated) {
+            fs.writeFileSync(file, newContents);
+        }
+    });
+}
+function main() {
+    const entFiles = glob_1.glob.sync("src/ent/**/generated/**/**.ts");
+    const graphqlFiles = glob_1.glob.sync("src/graphql/**/generated/**/**.ts");
+    moveFiles(entFiles);
+    moveFiles(graphqlFiles);
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    const entImportFiles = glob_1.glob.sync("src/ent/**/*.ts", {
+        ignore: ["**/generated/**", "node_modules/**"],
+    });
+    const graphqlImportFiles = glob_1.glob.sync("src/graphql/**/*.ts", {
+        ignore: ["**/generated/**", "node_modules/**"],
+    });
+    const cwd = process.cwd();
+    updateImports(entImportFiles, target, cwd);
+    updateImports(graphqlImportFiles, target, cwd);
+    (0, child_process_1.execSync)("prettier src/ent/*.ts --write");
+    (0, child_process_1.execSync)("prettier src/graphql/*.ts --write");
+}
+function isGeneratedPath(node, sourceFile, dirPath) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    // it's relative and has generated in there, continue
+    if (!((text.startsWith("..") || text.startsWith("./")) &&
+        text.indexOf("/generated") !== -1)) {
+        return;
+    }
+    const oldPath = path.join(dirPath, text);
+    const relFromRoot = path.relative(".", oldPath);
+    const conv = transformPath(relFromRoot);
+    if (!conv) {
+        return;
+    }
+    if (relFromRoot === conv.newFile) {
+        return;
+    }
+    return conv;
+}
+main();

package/scripts/transform_code.js

@@ -29,9 +29,8 @@ const ast_1 = require("../tsc/ast");
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 async function main() {
-    const options = (0, compilerOptions_1.readCompilerOptions)(".");
     let files = glob_1.glob.sync("src/ent/*.ts");
-    const target = (0, compilerOptions_1.getTarget)(options.target?.toString());
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
     files.forEach((file) => {
         let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
         let traversed = false;

package/scripts/transform_schema.js

@@ -30,10 +30,8 @@ const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const ast_1 = require("../tsc/ast");
 async function main() {
-    // this assumes this is being run from root of directory
-    const options = (0, compilerOptions_1.readCompilerOptions)(".");
     let files = glob_1.glob.sync("src/schema/*.ts");
-    const target = (0, compilerOptions_1.getTarget)(options.target?.toString());
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
     // filter to only event.ts e.g. for comments and whitespace...
     //  files = files.filter((f) => f.endsWith("event.ts"));
     files.forEach((file) => {

package/testutils/builder.d.ts

@@ -3,6 +3,7 @@ import { Orchestrator } from "../action/orchestrator";
 import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observer } from "../action";
 import { FieldMap, Schema } from "../schema";
 import { SchemaConfig } from "../schema/base_schema";
+import { FieldInfoMap } from "../schema/schema";
 export declare class User implements Ent {
     viewer: Viewer;
     data: Data;
@@ -66,6 +67,7 @@ export declare function getBuilderSchemaFromFields<T extends Ent>(fields: FieldM
 export declare function getBuilderSchemaTZFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
 export declare function getSchemaName(value: BuilderSchema<Ent>): string;
 export declare function getTableName(value: BuilderSchema<Ent>): string;
+export declare function getFieldInfo(value: BuilderSchema<Ent>): FieldInfoMap;
 export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     viewer: Viewer;
     private schema;
@@ -77,6 +79,7 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     fields: Map<string, any>;
     nodeType: string;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
+    updateInput(input: Data): void;
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;

package/testutils/builder.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.SimpleAction = exports.SimpleBuilder = exports.getTableName = exports.getSchemaName = exports.getBuilderSchemaTZFromFields = exports.getBuilderSchemaFromFields = exports.getBuilderSchema = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = void 0;
+exports.SimpleAction = exports.SimpleBuilder = exports.getFieldInfo = exports.getTableName = exports.getSchemaName = exports.getBuilderSchemaTZFromFields = exports.getBuilderSchemaFromFields = exports.getBuilderSchema = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = void 0;
 const privacy_1 = require("../core/privacy");
 const orchestrator_1 = require("../action/orchestrator");
 const action_1 = require("../action");
@@ -15,6 +15,7 @@ const loaders_1 = require("../core/loaders");
 const convert_1 = require("../core/convert");
 const camel_case_1 = require("camel-case");
 const base_schema_1 = require("../schema/base_schema");
+const schema_2 = require("../schema/schema");
 class User {
     constructor(viewer, data) {
         this.viewer = viewer;
@@ -130,6 +131,18 @@ exports.getTableName = getTableName;
 function randomNum() {
     return Math.random().toString(10).substring(2);
 }
+function getFieldInfo(value) {
+    const fields = (0, schema_1.getFields)(value);
+    let ret = {};
+    for (const [k, f] of fields) {
+        ret[k] = {
+            dbCol: (0, schema_2.getStorageKey)(f, k),
+            inputKey: (0, camel_case_1.camelCase)(k),
+        };
+    }
+    return ret;
+}
+exports.getFieldInfo = getFieldInfo;
 // reuses orchestrator and standard things
 class SimpleBuilder {
     constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt = undefined, action) {
@@ -162,11 +175,13 @@ class SimpleBuilder {
         this.ent = schema.ent;
         const tableName = getTableName(schema);
         this.nodeType = (0, camel_case_1.camelCase)(schema.ent.name);
+        const fieldInfo = getFieldInfo(schema);
         this.orchestrator = new orchestrator_1.Orchestrator({
             viewer: this.viewer,
             operation: operation,
             tableName: tableName,
             key,
+            fieldInfo,
             loaderOptions: {
                 loaderFactory: new loaders_1.ObjectLoaderFactory({
                     tableName: tableName,
@@ -176,7 +191,7 @@ class SimpleBuilder {
                 ent: schema.ent,
                 tableName: tableName,
                 fields: [],
-                fieldPrivacy: (0, schema_1.getFieldsWithPrivacy)(schema),
+                fieldPrivacy: (0, schema_1.getFieldsWithPrivacy)(schema, fieldInfo),
             },
             builder: this,
             action: action,
@@ -189,24 +204,25 @@ class SimpleBuilder {
                 }
                 return m;
             },
-            updateInput: (input) => {
-                const knownFields = (0, schema_1.getFields)(this.schema);
-                for (const k in input) {
-                    if (knownFields.has(k)) {
-                        this.fields.set(k, input[k]);
-                    }
-                    else {
-                        // related to #510. we do camelCase to pass fields in here but fields may be snakeCase and we want that to pass in tests
-                        // we do camelCase in
-                        const sc = (0, snake_case_1.snakeCase)(k);
-                        if (knownFields.has(sc)) {
-                            this.fields.set(sc, input[k]);
-                        }
-                    }
-                }
-            },
+            updateInput: this.updateInput.bind(this),
         });
     }
+    updateInput(input) {
+        const knownFields = (0, schema_1.getFields)(this.schema);
+        for (const k in input) {
+            if (knownFields.has(k)) {
+                this.fields.set(k, input[k]);
+            }
+            else {
+                // related to #510. we do camelCase to pass fields in here but fields may be snakeCase and we want that to pass in tests
+                // we do camelCase in
+                const sc = (0, snake_case_1.snakeCase)(k);
+                if (knownFields.has(sc)) {
+                    this.fields.set(sc, input[k]);
+                }
+            }
+        }
+    }
     build() {
         return this.orchestrator.build();
     }

package/tsc/ast.d.ts

@@ -17,4 +17,5 @@ interface transformOpts {
     transform?: transformImportFn;
 }
 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 {};

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.transformImport = exports.getClassInfo = exports.getPreText = void 0;
+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));
@@ -129,3 +129,26 @@ function transformImport(fileContents, importNode, sourceFile, opts) {
         '";');
 }
 exports.transformImport = transformImport;
+function updateImportPath(fileContents, importNode, sourceFile, newPath) {
+    const comment = getPreText(fileContents, importNode, sourceFile);
+    // all this copied from above...
+    const importText = importNode.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    if (start === -1 || end === -1) {
+        return;
+    }
+    const imports = importText
+        .substring(start + 1, end)
+        //    .trim()
+        .split(",");
+    return (comment +
+        "import " +
+        importText.substring(0, start + 1) +
+        Array.from(imports).join(", ") +
+        importText.substring(end) +
+        ' from "' +
+        newPath +
+        '";');
+}
+exports.updateImportPath = updateImportPath;

package/tsc/compilerOptions.d.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;
-export declare function getTarget(target?: string): ts.ScriptTarget.ES3 | ts.ScriptTarget.ES5 | ts.ScriptTarget.ES2015 | ts.ScriptTarget.ES2016 | ts.ScriptTarget.ES2017 | ts.ScriptTarget.ES2018 | ts.ScriptTarget.ES2019 | ts.ScriptTarget.ES2020 | ts.ScriptTarget.ES2021 | ts.ScriptTarget.ESNext;
+export declare function getTarget(target?: string): ts.ScriptTarget;
+export declare function getTargetFromCurrentDir(): ts.ScriptTarget;
 export declare function createSourceFile(target: ts.ScriptTarget, file: string): {
     contents: string;
     sourceFile: ts.SourceFile;

package/tsc/compilerOptions.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceFile = exports.getTarget = exports.readCompilerOptions = void 0;
+exports.createSourceFile = exports.getTargetFromCurrentDir = exports.getTarget = exports.readCompilerOptions = void 0;
 const fs = __importStar(require("fs"));
 const json5_1 = __importDefault(require("json5"));
 const typescript_1 = __importDefault(require("typescript"));
@@ -86,6 +86,11 @@ function getTarget(target) {
     }
 }
 exports.getTarget = getTarget;
+function getTargetFromCurrentDir() {
+    const options = readCompilerOptions(".");
+    return getTarget(options.target?.toString());
+}
+exports.getTargetFromCurrentDir = getTargetFromCurrentDir;
 function createSourceFile(target, file) {
     let contents = fs.readFileSync(file).toString();
     // go through the file and print everything back if not starting immediately after other position