@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha75

package/testutils/fake_data/fake_user.js

@@ -8,9 +8,10 @@ const schema_1 = require("../../schema");
 const internal_1 = require("./internal");
 const const_1 = require("./const");
 const viewer_1 = require("../../core/viewer");
-const test_db_1 = require("../db/test_db");
+const temp_db_1 = require("../db/temp_db");
 const loaders_1 = require("../../core/loaders");
 const convert_1 = require("../../core/convert");
+const action_1 = require("../../action");
 class ViewerWithAccessToken extends viewer_1.IDViewer {
     constructor(viewerID, opts) {
         super(viewerID, opts);
@@ -26,7 +27,18 @@ class FakeUser {
     constructor(viewer, data) {
         this.viewer = viewer;
         this.nodeType = const_1.NodeType.FakeUser;
-        this.privacyPolicy = {
+        this.data = data;
+        this.id = data.id;
+        this.createdAt = (0, convert_1.convertDate)(data.created_at);
+        this.updatedAt = (0, convert_1.convertDate)(data.updated_at);
+        this.firstName = data.first_name;
+        this.lastName = data.last_name;
+        this.emailAddress = data.email_address;
+        this.phoneNumber = data.phone_number;
+        this.password = data.password;
+    }
+    getPrivacyPolicy() {
+        return {
             rules: [
                 privacy_1.AllowIfViewerRule,
                 //can view user if friends
@@ -48,15 +60,6 @@ class FakeUser {
                 privacy_1.AlwaysDenyRule,
             ],
         };
-        this.data = data;
-        this.id = data.id;
-        this.createdAt = (0, convert_1.convertDate)(data.created_at);
-        this.updatedAt = (0, convert_1.convertDate)(data.updated_at);
-        this.firstName = data.first_name;
-        this.lastName = data.last_name;
-        this.emailAddress = data.email_address;
-        this.phoneNumber = data.phone_number;
-        this.password = data.password;
     }
     static getFields() {
         return [
@@ -71,7 +74,7 @@ class FakeUser {
         ];
     }
     static getTestTable() {
-        return (0, test_db_1.table)("fake_users", (0, test_db_1.uuid)("id", { primaryKey: true }), (0, test_db_1.timestamptz)("created_at"), (0, test_db_1.timestamptz)("updated_at"), (0, test_db_1.text)("first_name"), (0, test_db_1.text)("last_name"), (0, test_db_1.text)("email_address"), (0, test_db_1.text)("phone_number"), (0, test_db_1.text)("password"));
+        return (0, temp_db_1.table)("fake_users", (0, temp_db_1.uuid)("id", { primaryKey: true }), (0, temp_db_1.timestamptz)("created_at"), (0, temp_db_1.timestamptz)("updated_at"), (0, temp_db_1.text)("first_name"), (0, temp_db_1.text)("last_name"), (0, temp_db_1.text)("email_address"), (0, temp_db_1.text)("phone_number"), (0, temp_db_1.text)("password"));
     }
     static loaderOptions() {
         return {
@@ -89,22 +92,15 @@ class FakeUser {
     }
 }
 exports.FakeUser = FakeUser;
-class FakeUserSchema extends schema_1.BaseEntSchema {
-    constructor() {
-        super(...arguments);
-        this.ent = FakeUser;
-        this.fields = {
-            firstName: (0, schema_1.StringType)(),
-            lastName: (0, schema_1.StringType)(),
-            emailAddress: (0, schema_1.StringType)(),
-            phoneNumber: (0, schema_1.StringType)(),
-            password: (0, schema_1.StringType)({
-                nullable: true,
-            }),
-        };
-    }
-}
-exports.FakeUserSchema = FakeUserSchema;
+exports.FakeUserSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    firstName: (0, schema_1.StringType)(),
+    lastName: (0, schema_1.StringType)(),
+    emailAddress: (0, schema_1.StringType)(),
+    phoneNumber: (0, schema_1.StringType)(),
+    password: (0, schema_1.StringType)({
+        nullable: true,
+    }),
+}, FakeUser);
 function getUserBuilder(viewer, input) {
     const action = getUserAction(viewer, input);
     return action.builder;
@@ -115,7 +111,7 @@ function getUserAction(viewer, input) {
     for (const key in input) {
         m.set(key, input[key]);
     }
-    const action = new builder_1.SimpleAction(viewer, new FakeUserSchema(), m);
+    const action = new builder_1.SimpleAction(viewer, exports.FakeUserSchema, m, action_1.WriteOperation.Insert, null);
     action.viewerForEntLoad = (data) => {
         // load the created ent using a VC of the newly created user.
         return new viewer_1.IDViewer(data.id);

package/testutils/fake_data/test_helpers.d.ts

@@ -1,6 +1,6 @@
 import { Data, Ent } from "../../core/base";
 import { AssocEdge } from "../../core/ent";
-import { TempDB } from "../db/test_db";
+import { TempDB } from "../db/temp_db";
 import { FakeUser, UserCreateInput, ContactCreateInput, FakeContact } from ".";
 import { EventCreateInput, FakeEvent } from "./fake_event";
 import { BuilderSchema } from "../builder";
@@ -20,7 +20,7 @@ export declare function createEdges(): Promise<void>;
 export declare function edgeTableNames(): string[];
 export declare function createTestEvent(user: FakeUser, input?: Partial<EventCreateInput>): Promise<FakeEvent>;
 export declare function setupTempDB(): Promise<TempDB>;
-export declare function tempDBTables(): import("../db/test_db").Table[];
+export declare function tempDBTables(global?: boolean): import("../db/temp_db").Table[];
 interface options {
     howMany: number;
     interval: number;

package/testutils/fake_data/test_helpers.js

@@ -6,7 +6,7 @@ const viewer_1 = require("../../core/viewer");
 const ent_1 = require("../../core/ent");
 const snake_case_1 = require("snake-case");
 const write_1 = require("../write");
-const test_db_1 = require("../db/test_db");
+const temp_db_1 = require("../db/temp_db");
 const _1 = require(".");
 const fake_event_1 = require("./fake_event");
 const const_1 = require("./const");
@@ -107,7 +107,7 @@ async function createUserPlusFriendRequests(input, slice) {
         return createTestUser(input);
     }));
     expect(friendRequests.length).toBe(userInputs.length);
-    await addEdge(user, new _1.FakeUserSchema(), _1.EdgeType.UserToFriendRequests, true, ...friendRequests);
+    await addEdge(user, _1.FakeUserSchema, _1.EdgeType.UserToFriendRequests, true, ...friendRequests);
     return [user, friendRequests];
 }
 exports.createUserPlusFriendRequests = createUserPlusFriendRequests;
@@ -209,21 +209,21 @@ async function createTestEvent(user, input) {
 }
 exports.createTestEvent = createTestEvent;
 async function setupTempDB() {
-    const tdb = new test_db_1.TempDB(tempDBTables());
+    const tdb = new temp_db_1.TempDB(tempDBTables());
     await tdb.beforeAll();
     // create once
     await createEdges();
     return tdb;
 }
 exports.setupTempDB = setupTempDB;
-function tempDBTables() {
+function tempDBTables(global = false) {
     const tables = [
         _1.FakeUser.getTestTable(),
         _1.FakeContact.getTestTable(),
         fake_event_1.FakeEvent.getTestTable(),
-        (0, test_db_1.assoc_edge_config_table)(),
+        (0, temp_db_1.assoc_edge_config_table)(),
     ];
-    edgeTableNames().forEach((tableName) => tables.push((0, test_db_1.assoc_edge_table)(tableName)));
+    edgeTableNames().forEach((tableName) => tables.push((0, temp_db_1.assoc_edge_table)(tableName, global)));
     return tables;
 }
 exports.tempDBTables = tempDBTables;

package/testutils/fake_data/user_query.d.ts

@@ -53,7 +53,7 @@ export declare class UserToFriendRequestsQuery extends AssocEdgeQueryBase<FakeUs
 }
 export declare class UserToIncomingFriendRequestsQuery extends AssocEdgeQueryBase<FakeUser, FakeUser, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     sourceEnt(id: ID): Promise<FakeUser | null>;
     static query(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>): UserToIncomingFriendRequestsQuery;
     queryContacts(): UserToContactsQuery;
@@ -90,7 +90,7 @@ export declare class UserToEventsInNextWeekQuery extends CustomEdgeQueryBase<Fak
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToEventsInNextWeekQuery;
     sourceEnt(id: ID): Promise<FakeUser | null>;
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
 }
 export declare class UserToFollowingQuery extends AssocEdgeQueryBase<FakeUser, Ent, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);

package/testutils/fake_log.d.ts

@@ -1,4 +1,4 @@
-import { Ent } from "../core/base";
+import { Ent, Viewer } from "../core/base";
 import { Builder } from "./../action";
 export declare class FakeLogger {
     private static logs;
@@ -8,6 +8,6 @@ export declare class FakeLogger {
     static contains(line: string): boolean;
     static clear(): void;
 }
-export declare class EntCreationObserver<T extends Ent> {
-    observe(builder: Builder<T>): Promise<void>;
+export declare class EntCreationObserver<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    observe(builder: Builder<TEnt, TViewer>): Promise<void>;
 }

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,58 @@
+"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;
+};
+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

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

@@ -0,0 +1,44 @@
+import ts from "typescript";
+export declare function getPreText(fileContents: string, node: ts.Node, sourceFile: ts.SourceFile): string;
+export interface ClassInfo {
+    extends?: string;
+    comment: string;
+    name: string;
+    export?: boolean;
+    default?: boolean;
+    implements?: string[];
+    wrapClassContents(inner: string): string;
+}
+export declare function getClassInfo(fileContents: string, sourceFile: ts.SourceFile, node: ts.ClassDeclaration): ClassInfo | undefined;
+declare 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 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

@@ -0,0 +1,267 @@
+"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.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));
+}
+exports.getPreText = getPreText;
+function getClassInfo(fileContents, sourceFile, node) {
+    let className = node.name?.text;
+    let classExtends;
+    let impl = [];
+    if (node.heritageClauses) {
+        for (const hc of node.heritageClauses) {
+            switch (hc.token) {
+                case typescript_1.default.SyntaxKind.ImplementsKeyword:
+                    for (const type of hc.types) {
+                        impl.push(type.expression.getText(sourceFile));
+                    }
+                    break;
+                case typescript_1.default.SyntaxKind.ExtendsKeyword:
+                    // can only extend one class
+                    for (const type of hc.types) {
+                        const text = type.expression.getText(sourceFile);
+                        classExtends = text;
+                    }
+                    break;
+            }
+        }
+    }
+    if (!className) {
+        return undefined;
+    }
+    let hasExport = false;
+    let hasDefault = false;
+    let comment = getPreText(fileContents, node, sourceFile);
+    const wrapClassContents = (inner) => {
+        let ret = `${comment}`;
+        if (hasExport) {
+            ret += "export ";
+        }
+        if (hasDefault) {
+            ret += "default ";
+        }
+        ret += `class ${className} `;
+        if (classExtends) {
+            ret += `extends ${classExtends} `;
+        }
+        if (impl.length) {
+            ret += `implements ${impl.join(", ")}`;
+        }
+        return `${ret}{
+      ${inner}
+    }`;
+    };
+    if (node.modifiers) {
+        for (const mod of node.modifiers) {
+            const text = mod.getText(sourceFile);
+            if (text === "export") {
+                hasExport = true;
+            }
+            else if (text === "default") {
+                hasDefault = true;
+            }
+        }
+    }
+    return {
+        name: className,
+        extends: classExtends,
+        comment,
+        implements: impl,
+        wrapClassContents,
+        export: hasExport,
+        default: hasDefault,
+    };
+}
+exports.getClassInfo = getClassInfo;
+function transformImport(fileContents, importNode, sourceFile, opts) {
+    // remove quotes too
+    const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if (text != opts.transformPath) {
+        return;
+    }
+    const impInfo = getImportInfo(importNode, sourceFile);
+    if (!impInfo) {
+        return;
+    }
+    let { imports, start, end, importText, default: def } = impInfo;
+    let removeImportsMap = {};
+    if (opts?.removeImports) {
+        opts.removeImports.forEach((imp) => {
+            removeImportsMap[imp] = true;
+            if (def === imp) {
+                def = "";
+            }
+        });
+    }
+    let finalImports = new Set();
+    for (let i = 0; i < imports.length; i++) {
+        let imp = imports[i].trim();
+        if (imp === "") {
+            continue;
+        }
+        if (opts?.transform) {
+            imp = opts.transform(imp);
+        }
+        if (removeImportsMap[imp]) {
+            continue;
+        }
+        finalImports.add(imp);
+    }
+    if (opts?.newImports) {
+        opts.newImports.forEach((imp) => finalImports.add(imp));
+    }
+    const comment = getPreText(fileContents, importNode, sourceFile);
+    return (comment +
+        "import " +
+        // add default
+        (def || "") +
+        // should probably always be "{" now that we support default
+        (start >= 0 ? importText.substring(0, start + 1) : "{") +
+        Array.from(finalImports).join(", ") +
+        // should probably always be "}"
+        (end >= 0 ? importText.substring(end) : "}") +
+        ' from "' +
+        text +
+        '";');
+}
+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;
+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 + "/";
+    }
+    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: "@snowtop/ent",
+            name: "Viewer",
+        },
+        relativeImports,
+        globalSchemaPath: yaml.globalSchemaPath,
+    };
+}
+exports.getCustomInfo = getCustomInfo;

package/tsc/compilerOptions.d.ts

@@ -1,2 +1,8 @@
 import ts from "typescript";
 export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;
+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;
+};