@snowtop/ent 0.0.40-alpha6 → 0.1.0-alpha10

package/schema/field.js

@@ -40,19 +40,25 @@ class UUIDField extends BaseField {
         super();
         this.options = options;
         this.type = { dbType: schema_1.DBType.UUID };
-        const polymorphic = options.polymorphic;
+        if (options?.fieldEdge?.enforceSchema &&
+            !options.fieldEdge.getLoaderInfoFromSchema) {
+            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
+        }
+    }
+    getDerivedFields(fieldName) {
+        const polymorphic = this.options?.polymorphic;
         if (polymorphic) {
             let name = "";
-            if (options.name.endsWith("_id")) {
-                let idx = options.name.indexOf("_id");
-                name = options.name.substring(0, idx) + "_type";
+            if (fieldName.endsWith("_id")) {
+                let idx = fieldName.indexOf("_id");
+                name = fieldName.substring(0, idx) + "_type";
             }
-            else if (options.name.endsWith("ID")) {
-                let idx = options.name.indexOf("ID");
-                name = options.name.substring(0, idx) + "Type";
+            else if (fieldName.endsWith("ID")) {
+                let idx = fieldName.indexOf("ID");
+                name = fieldName.substring(0, idx) + "Type";
             }
             else {
-                throw new Error(`unsupported id polymorhpic type ${options.name}`);
+                throw new Error(`unsupported id polymorhpic type ${fieldName}`);
             }
             // polymorphic field automatically hidden from GraphQL
             // can be made visible with custom fields if user wants to change this behavior
@@ -60,38 +66,33 @@ class UUIDField extends BaseField {
             // intentionally not made private as it doesn't seem like it needs to be hidden
             if (typeof polymorphic === "object" && polymorphic.types) {
                 // an enum with types validated here
-                this.derivedFields = [
-                    EnumType({
-                        name,
+                return {
+                    [name]: EnumType({
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
-                        nullable: options.nullable,
+                        nullable: this.options?.nullable,
                     }),
-                ];
+                };
             }
             else {
                 // just a string field...
-                this.derivedFields = [
-                    StringType({
-                        name,
+                return {
+                    [name]: StringType({
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
-                        nullable: options.nullable,
+                        nullable: this.options?.nullable,
                     }),
-                ];
+                };
             }
         }
-        if (options.fieldEdge?.enforceSchema &&
-            !options.fieldEdge.getLoaderInfoFromSchema) {
-            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
-        }
+        return {};
     }
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
-        if (!this.options.fieldEdge?.enforceSchema) {
+        if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
         const getLoaderInfo = this.options.fieldEdge.getLoaderInfoFromSchema;
@@ -119,7 +120,7 @@ class IntegerField extends BaseField {
         super();
         this.type = { dbType: schema_1.DBType.Int };
         this.validators = [];
-        this.options = { name: "field" };
+        this.options = {};
         // for legacy callers
         this.handleOptions(options || this.options);
     }
@@ -206,9 +207,9 @@ class StringField extends BaseField {
         this.type = { dbType: schema_1.DBType.String };
         this.validators = [];
         this.formatters = [];
-        this.options = { name: "field" };
+        this.options = {};
         // for legacy callers
-        this.handleOptions(options || { name: "field" });
+        this.handleOptions(options || {});
     }
     getOptions() {
         return this.options;
@@ -347,7 +348,7 @@ class TimestampField extends BaseField {
 }
 exports.TimestampField = TimestampField;
 function TimestampType(options) {
-    let result = new TimestampField(options);
+    let result = new TimestampField({ ...options });
     return Object.assign(result, options);
 }
 exports.TimestampType = TimestampType;
@@ -374,7 +375,7 @@ class TimeField extends BaseField {
     constructor(options) {
         super();
         this.type = { dbType: schema_1.DBType.Time };
-        if (options.withTimezone) {
+        if (options?.withTimezone) {
             this.type = {
                 dbType: schema_1.DBType.Timetz,
             };
@@ -451,8 +452,8 @@ class EnumField extends BaseField {
             dbType: options.createEnumType ? schema_1.DBType.Enum : schema_1.DBType.StringEnum,
             values: options.values,
             enumMap: options.map,
-            type: options.tsType || options.name,
-            graphQLType: options.graphQLType || options.name,
+            type: options.tsType,
+            graphQLType: options.graphQLType,
         };
         if (!options.foreignKey) {
             if (!options.values && !options.map) {
@@ -596,13 +597,17 @@ class ListField extends BaseField {
         }
         return JSON.stringify(val);
     }
-    format(val) {
+    format(val, nested) {
         if (!Array.isArray(val)) {
             throw new Error(`need an array to format`);
         }
         const elemDBType = this.type.listElemType.dbType;
         const jsonType = elemDBType === "JSON" || elemDBType === "JSONB";
-        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        // postgres ish doesn't apply when nested
+        const postgres = !nested && db_1.default.getDialect() === db_1.Dialect.Postgres;
+        if (nested && !this.field.format) {
+            return val;
+        }
         if (!postgres && !this.field.format) {
             return JSON.stringify(val);
         }
@@ -611,7 +616,7 @@ class ListField extends BaseField {
         for (let i = 0; i < val.length; i++) {
             let formatted = val[i];
             if (this.field.format) {
-                formatted = this.field.format(val[i]);
+                formatted = this.field.format(val[i], nested);
             }
             // postgres supports arrays natively so we
             // structure it in the expected format
@@ -628,6 +633,10 @@ class ListField extends BaseField {
         if (postgres) {
             return postgresRet + "}";
         }
+        // don't JSON.stringify if nested
+        if (nested) {
+            return ret;
+        }
         return JSON.stringify(ret);
     }
     minLen(l) {

package/schema/index.d.ts

@@ -1,6 +1,8 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
-export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, } from "./base_schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
+export * from "./struct_field";
+export * from "./union_field";

package/schema/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
+exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
@@ -29,5 +29,9 @@ Object.defineProperty(exports, "Timestamps", { enumerable: true, get: function (
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return base_schema_1.Node; } });
 Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: function () { return base_schema_1.BaseEntSchema; } });
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
+Object.defineProperty(exports, "EntSchema", { enumerable: true, get: function () { return base_schema_1.EntSchema; } });
+Object.defineProperty(exports, "EntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.EntSchemaWithTZ; } });
 __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
+__exportStar(require("./struct_field"), exports);
+__exportStar(require("./union_field"), exports);

package/schema/json_field.d.ts

@@ -5,13 +5,13 @@ export interface JSONOptions extends FieldOptions {
     importType?: ImportType;
 }
 export declare class JSONField extends BaseField implements Field {
-    private options;
+    private options?;
     type: Type;
-    constructor(jsonb: boolean, options: JSONOptions);
+    constructor(jsonb: boolean, options?: JSONOptions | undefined);
     format(val: any): string;
     valid(val: any): boolean;
 }
-export declare function JSONType(options: JSONOptions): JSONField;
-export declare function JSONBType(options: JSONOptions): JSONField;
-export declare function JSONBListType(options: JSONOptions): ListField;
-export declare function JSONListType(options: JSONOptions): ListField;
+export declare function JSONType(options?: JSONOptions): JSONField;
+export declare function JSONBType(options?: JSONOptions): JSONField;
+export declare function JSONBListType(options?: JSONOptions): ListField;
+export declare function JSONListType(options?: JSONOptions): ListField;

package/schema/json_field.js

@@ -13,7 +13,7 @@ class JSONField extends field_1.BaseField {
         if (jsonb) {
             this.type.dbType = schema_1.DBType.JSONB;
         }
-        if (options.importType) {
+        if (options?.importType) {
             this.type.importType = options.importType;
         }
     }
@@ -21,7 +21,7 @@ class JSONField extends field_1.BaseField {
         return JSON.stringify(val);
     }
     valid(val) {
-        if (this.options.validator) {
+        if (this.options?.validator) {
             return this.options.validator(val);
         }
         return true;

package/schema/schema.d.ts

@@ -1,8 +1,11 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder } from "../action/action";
 import { Clause } from "../core/clause";
+export declare type FieldMap = {
+    [key: string]: Field;
+};
 export default interface Schema {
-    fields: Field[];
+    fields: FieldMap | Field[];
     tableName?: string;
     patterns?: Pattern[];
     edges?: Edge[];
@@ -58,7 +61,7 @@ export interface AssocEdgeGroup {
 export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
-    fields: Field[];
+    fields: FieldMap | Field[];
     edges?: Edge[];
     transformRead?: () => Clause;
     transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
@@ -117,6 +120,8 @@ export interface Type {
     values?: string[];
     enumMap?: EnumMap;
     importType?: ImportType;
+    subFields?: FieldMap;
+    unionFields?: FieldMap;
 }
 export interface ForeignKey {
     schema: string;
@@ -140,7 +145,6 @@ export interface FieldEdge {
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
-    name: string;
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
@@ -160,8 +164,9 @@ export interface FieldOptions {
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
-    derivedFields?: Field[];
     privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
+    getDerivedFields?(name: string): FieldMap;
+    [x: string]: any;
 }
 export interface PolymorphicOptions {
     types?: string[];
@@ -171,7 +176,7 @@ export interface PolymorphicOptions {
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
-    format?(val: any): any;
+    format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
 export interface SchemaConstructor {
@@ -180,7 +185,7 @@ 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>;
-export declare function getStorageKey(field: Field): string;
+export declare function getStorageKey(field: Field, fieldName: string): string;
 export declare function getFieldsWithPrivacy(value: SchemaInputType): Map<string, PrivacyPolicy>;
 export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
 interface objectLoaderOptions {

package/schema/schema.js

@@ -55,12 +55,25 @@ exports.getSchema = getSchema;
 function getFields(value) {
     const schema = getSchema(value);
     function addFields(fields) {
-        for (const field of fields) {
-            const derivedFields = field.derivedFields;
-            if (derivedFields !== undefined) {
-                addFields(derivedFields);
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                m.set(name, field);
             }
-            m.set(field.name, field);
+            return;
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
+            }
+            m.set(name, field);
         }
     }
     let m = new Map();
@@ -73,18 +86,39 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
-function getStorageKey(field) {
-    return field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+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) {
     const schema = getSchema(value);
     function addFields(fields) {
-        for (const field of fields) {
-            const derivedFields = field.derivedFields;
-            if (derivedFields !== undefined) {
-                addFields(derivedFields);
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!field.name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                if (field.privacyPolicy) {
+                    let privacyPolicy;
+                    if (typeof field.privacyPolicy === "function") {
+                        privacyPolicy = field.privacyPolicy();
+                    }
+                    else {
+                        privacyPolicy = field.privacyPolicy;
+                    }
+                    m.set(getStorageKey(field, name), privacyPolicy);
+                }
+            }
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
             }
             if (field.privacyPolicy) {
                 let privacyPolicy;
@@ -94,7 +128,7 @@ function getFieldsWithPrivacy(value) {
                 else {
                     privacyPolicy = field.privacyPolicy;
                 }
-                m.set(getStorageKey(field), privacyPolicy);
+                m.set(getStorageKey(field, name), privacyPolicy);
             }
         }
     }

package/schema/struct_field.d.ts

@@ -0,0 +1,17 @@
+import { BaseField, ListField } from "./field";
+import { FieldOptions, Field, Type, FieldMap } from "./schema";
+export interface StructOptions extends FieldOptions {
+    tsType: string;
+    fields: FieldMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class StructField extends BaseField implements Field {
+    private options;
+    type: Type;
+    constructor(options: StructOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function StructType(options: StructOptions): StructField & StructOptions;
+export declare function StructListType(options: StructOptions): ListField;

package/schema/struct_field.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructListType = exports.StructType = exports.StructField = void 0;
+const field_1 = require("./field");
+const schema_1 = require("./schema");
+const camel_case_1 = require("camel-case");
+class StructField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.type.subFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    // right now, we store things in the db in lowerCase format
+    // this will lead to issues if field changes.
+    // TODO: use storageKey and convert back...
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        let ret = {};
+        for (const k in this.options.fields) {
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined) {
+                continue;
+            }
+            const field = this.options.fields[k];
+            if (field.format) {
+                // indicate nested so this isn't JSON stringified
+                ret[dbKey] = field.format(val, true);
+            }
+            else {
+                ret[dbKey] = val;
+            }
+        }
+        // don't json.stringify if nested
+        if (nested) {
+            return ret;
+        }
+        return JSON.stringify(ret);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        // TODO probably need to support optional fields...
+        let valid = true;
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined || val === null) {
+                // nullable, nothing to do here
+                if (field.nullable) {
+                    continue;
+                }
+                valid = false;
+                break;
+            }
+            if (!field.valid) {
+                continue;
+            }
+            promises.push(field.valid(val));
+        }
+        if (!valid) {
+            return valid;
+        }
+        const ret = await Promise.all(promises);
+        return ret.every((v) => v);
+    }
+}
+exports.StructField = StructField;
+function StructType(options) {
+    let result = new StructField(options);
+    return Object.assign(result, options);
+}
+exports.StructType = StructType;
+function StructListType(options) {
+    return new field_1.ListField(StructType(options), options);
+}
+exports.StructListType = StructListType;

package/schema/union_field.d.ts

@@ -0,0 +1,23 @@
+import { StructField } from "./struct_field";
+import { FieldOptions, Type } from "./schema";
+import { BaseField, ListField } from "./field";
+export declare type StructMap = {
+    [key: string]: StructField;
+};
+export interface UnionOptions extends FieldOptions {
+    tsType: string;
+    fields: StructMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class UnionField extends BaseField implements FieldOptions {
+    private options;
+    type: Type;
+    m: Map<Object, string>;
+    constructor(options: UnionOptions);
+    format(obj: any): string | Object;
+    private validField;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function UnionType(options: UnionOptions): UnionField & UnionOptions;
+export declare function UnionListType(options: UnionOptions): ListField;

package/schema/union_field.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionListType = exports.UnionType = exports.UnionField = void 0;
+const schema_1 = require("./schema");
+const field_1 = require("./field");
+// used to know which key in the union is valid.
+// maybe there's a better way of doing this eventually
+const KEY = "___valid___key___";
+class UnionField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.m = new Map();
+        this.type.unionFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        // TODO should throw if not nested?
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    format(obj) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        const k = obj[KEY];
+        if (k === undefined) {
+            throw new Error(`need to call valid first`);
+        }
+        // now delete it since we don't need it anymore
+        delete obj[KEY];
+        const field = this.options.fields[k];
+        // always nested for now so pass through
+        return field.format(obj, true);
+    }
+    async validField(k, f, obj) {
+        const valid = await f.valid(obj);
+        return {
+            valid,
+            key: k,
+        };
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            promises.push(this.validField(k, field, obj));
+        }
+        let lastKey;
+        let validCt = 0;
+        const ret = await Promise.all(promises);
+        for (const v of ret) {
+            if (v.valid) {
+                validCt++;
+                lastKey = v.key;
+            }
+        }
+        if (lastKey !== undefined) {
+            obj[KEY] = lastKey;
+        }
+        return validCt == 1;
+    }
+}
+exports.UnionField = UnionField;
+function UnionType(options) {
+    let result = new UnionField(options);
+    return Object.assign(result, options);
+}
+exports.UnionType = UnionType;
+function UnionListType(options) {
+    return new field_1.ListField(UnionType(options), options);
+}
+exports.UnionListType = UnionListType;

package/scripts/custom_compiler.js

@@ -25,9 +25,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const typescript_1 = __importDefault(require("typescript"));
 const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const json5_1 = __importDefault(require("json5"));
 const glob_1 = __importDefault(require("glob"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
 // TODO this should probably be its own package but for now it's here
 class Compiler {
     constructor(sourceFiles, moduleSearchLocations) {
@@ -35,7 +34,7 @@ class Compiler {
         this.moduleSearchLocations = moduleSearchLocations;
         this.regexMap = new Map();
         this.resolvers = [];
-        this.options = this.readCompilerOptions();
+        this.options = (0, compilerOptions_1.readCompilerOptions)(".");
         if (this.options.paths) {
             for (let key in this.options.paths) {
                 if (key === "*") {
@@ -105,22 +104,6 @@ class Compiler {
         }
         return undefined;
     }
-    readCompilerOptions() {
-        let json = {};
-        try {
-            json = json5_1.default.parse(fs.readFileSync("./tsconfig.json", {
-                encoding: "utf8",
-            }));
-        }
-        catch (e) {
-            console.error("couldn't read tsconfig.json file");
-        }
-        let options = json["compilerOptions"] || {};
-        if (options.moduleResolution === "node") {
-            options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
-        }
-        return options;
-    }
     createCompilerHost() {
         return {
             getSourceFile: this.getSourceFile,