@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha14

package/core/loaders/raw_count_loader.d.ts

@@ -9,9 +9,9 @@ interface QueryCountOptions {
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
 export declare class RawCountLoader<K extends any> implements Loader<K, number> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loader;
-    constructor(options: QueryCountOptions, context?: Context | undefined);
+    constructor(options: QueryCountOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: K): Promise<number>;
     clearAll(): void;
 }

package/core/privacy.d.ts

@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;

package/core/query/assoc_query.d.ts

@@ -3,15 +3,15 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
-export declare type EdgeQuerySource<TSource extends Ent, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
-export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
-    viewer: Viewer;
-    src: EdgeQuerySource<TSource, TDest>;
+export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
+    viewer: TViewer;
+    src: EdgeQuerySource<TSource, TDest, TViewer>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private getSingleID;

package/core/query/custom_query.d.ts

@@ -1,17 +1,17 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<TDest>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
+    viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
     queryRawCount(): Promise<number>;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;

package/core/viewer.d.ts

@@ -1,7 +1,7 @@
 import { ID, Ent, Viewer, Context } from "./base";
 export declare class LoggedOutViewer implements Viewer {
-    context?: Context | undefined;
-    constructor(context?: Context | undefined);
+    context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined;
+    constructor(context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined);
     viewerID: null;
     viewer(): Promise<null>;
     instanceKey(): string;
@@ -18,6 +18,6 @@ export declare class IDViewer implements Viewer {
     constructor(viewerID: ID, opts?: Partial<IDViewerOptions>);
     constructor(opts: IDViewerOptions);
     setContext(ctx: Context): this;
-    viewer(): Promise<Ent | null>;
+    viewer(): Promise<Ent<Viewer<Ent<any> | null, ID | null>> | null>;
     instanceKey(): string;
 }

package/graphql/query/edge_connection.d.ts

@@ -1,30 +1,30 @@
 import { EdgeQuery, PaginationInfo } from "../../core/query/query";
-import { Data, Ent, Viewer } from "../../core/base";
+import { Data, Ent, ID, Viewer } from "../../core/base";
 export interface GraphQLEdge<T extends Data> {
     edge: T;
     node: Ent;
     cursor: string;
 }
-interface edgeQueryCtr<T extends Ent, TEdge extends Data> {
-    (v: Viewer, src: T): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer, src: T): EdgeQuery<T, Ent, TEdge>;
 }
-interface edgeQueryCtr2<T extends Ent, TEdge extends Data> {
-    (v: Viewer): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr2<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer): EdgeQuery<T, Ent, TEdge>;
 }
-export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data> {
+export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data, TViewer extends Viewer = Viewer> {
     query: EdgeQuery<TSource, Ent, TEdge>;
     private results;
     private viewer;
     private source?;
     private args?;
-    constructor(viewer: Viewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge>, args?: Data);
-    constructor(viewer: Viewer, getQuery: edgeQueryCtr2<TSource, TEdge>, args?: Data);
+    constructor(viewer: TViewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge, TViewer>, args?: Data);
+    constructor(viewer: TViewer, getQuery: edgeQueryCtr2<TSource, TEdge, TViewer>, args?: Data);
     first(limit: number, cursor?: string): void;
     last(limit: number, cursor?: string): void;
     modifyQuery(fn: (query: EdgeQuery<TSource, Ent, TEdge>) => EdgeQuery<TSource, Ent, TEdge>): void;
     queryTotalCount(): Promise<number>;
     queryEdges(): Promise<GraphQLEdge<TEdge>[]>;
-    queryNodes(): Promise<Ent[]>;
+    queryNodes(): Promise<Ent<Viewer<Ent<any> | null, ID | null>>[]>;
     private defaultPageInfo;
     queryPageInfo(): Promise<PaginationInfo>;
     private queryData;

package/graphql/query/page_info.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLObjectType } from "graphql";
 import { RequestContext } from "../../core/context";
 import { PaginationInfo } from "../../core/query/query";
-export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext>;
+export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext<import("../..").Viewer<import("../..").Ent<any> | null, import("../..").ID | null>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha10",
+  "version": "0.1.0-alpha14",
   "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;
@@ -64,7 +71,7 @@ export interface Pattern {
     fields: FieldMap | Field[];
     edges?: Edge[];
     transformRead?: () => Clause;
-    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
     transformsDelete?: boolean;
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
@@ -76,14 +83,14 @@ export declare enum SQLStatementOperation {
 }
 export interface UpdateOperation<T extends Ent> {
     op: SQLStatementOperation;
-    existingEnt?: T;
+    existingEnt: T | null;
     viewer: Viewer;
     data?: Map<string, any>;
 }
 export interface TransformedUpdateOperation<T extends Ent> {
     op: SQLStatementOperation;
     data?: Data;
-    existingEnt?: T;
+    existingEnt?: T | null;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -185,15 +192,18 @@ 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;
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | undefined;
+export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,

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);
             }
         }
     }
@@ -167,13 +178,14 @@ exports.getObjectLoaderProperties = getObjectLoaderProperties;
 function getTransformedUpdateOp(value, stmt) {
     const schema = getSchema(value);
     if (!schema.patterns) {
-        return;
+        return null;
     }
     for (const p of schema.patterns) {
         if (p.transformWrite) {
             return p.transformWrite(stmt);
         }
     }
+    return null;
 }
 exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go

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,18 +67,23 @@ 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 class SimpleBuilder<T extends Ent> implements Builder<T> {
+export declare function getFieldInfo(value: BuilderSchema<Ent>): FieldInfoMap;
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
-    existingEnt: T | undefined;
+    existingEnt: TExistingEnt;
     ent: EntConstructor<T>;
     placeholderID: ID;
-    orchestrator: Orchestrator<T, Data>;
+    orchestrator: Orchestrator<T, Data, Viewer>;
     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);
-    build(): Promise<Changeset<T>>;
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Viewer, Data> | undefined);
+    getInput(): Data;
+    updateInput(input: Data): void;
+    build(): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
     save(): Promise<void>;
@@ -88,18 +94,18 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
 interface viewerEntLoadFunc {
     (data: Data): Viewer | Promise<Viewer>;
 }
-export declare class SimpleAction<T extends Ent> implements Action<T, SimpleBuilder<T>, Data> {
+export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt> {
     viewer: Viewer;
     private fields;
-    builder: SimpleBuilder<T>;
-    validators: Validator<SimpleBuilder<T>, Data>[];
-    triggers: Trigger<SimpleBuilder<T>, Data>[];
-    observers: Observer<SimpleBuilder<T>, Data>[];
+    builder: SimpleBuilder<T, TExistingEnt>;
+    validators: Validator<T, SimpleBuilder<T>>[];
+    triggers: Trigger<T, SimpleBuilder<T>>[];
+    observers: Observer<T, SimpleBuilder<T>>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
-    changeset(): Promise<Changeset<T>>;
+    changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<T | null>;