@snowtop/ent 0.0.27 → 0.0.29

package/action/action.d.ts

@@ -27,9 +27,8 @@ export interface Changeset<T extends Ent> {
     executor(): Executor;
     viewer: Viewer;
     placeholderID: ID;
-    ent: EntConstructor<T>;
     changesets?: Changeset<Ent>[];
-    dependencies?: Map<ID, Builder<T>>;
+    dependencies?: Map<ID, Builder<Ent>>;
 }
 export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | (Changeset<Ent> | void)[]> | Promise<Changeset<Ent>>[];
 export interface Trigger<T extends Ent> {

package/action/executor.d.ts

@@ -1,22 +1,21 @@
-import { ID, Data, Ent, Viewer, EntConstructor, Context } from "../core/base";
+import { ID, Data, Ent, Viewer, Context } from "../core/base";
 import { DataOperation } from "../core/ent";
-import { Changeset, Executor } from "../action";
+import { Changeset, Executor } from "../action/action";
 import { Builder } from "../action";
 import { OrchestratorOptions } from "./orchestrator";
 import { Queryer } from "../core/db";
 export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private viewer;
     placeholderID: ID;
-    private ent;
     private operations;
     private options?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], options?: OrchestratorOptions<T, Data> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;
     [Symbol.iterator](): this;
-    next(): IteratorResult<DataOperation>;
+    next(): IteratorResult<DataOperation<T>>;
     executeObservers(): Promise<void>;
     execute(): Promise<void>;
     preFetch?(queryer: Queryer, context: Context): Promise<void>;
@@ -25,23 +24,19 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
 export declare class ComplexExecutor<T extends Ent> implements Executor {
     private viewer;
     placeholderID: ID;
-    private ent;
-    private options?;
     private idx;
     private mapper;
     private lastOp;
     private allOperations;
-    private changesetMap;
-    private nodeOpMap;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T, Data> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T, Data>);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
-    next(): IteratorResult<DataOperation>;
+    next(): IteratorResult<DataOperation<Ent>>;
     resolveValue(val: ID): Ent | null;
     executeObservers(): Promise<void>;
     execute(): Promise<void>;
     preFetch?(queryer: Queryer, context: Context): Promise<void>;
     postFetch?(queryer: Queryer, context: Context): Promise<void>;
 }
-export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent>[]>;

package/action/executor.js

@@ -9,10 +9,9 @@ const db_1 = __importDefault(require("../core/db"));
 const logger_1 = require("../core/logger");
 // private to ent
 class ListBasedExecutor {
-    constructor(viewer, placeholderID, ent, operations, options) {
+    constructor(viewer, placeholderID, operations, options) {
         this.viewer = viewer;
         this.placeholderID = placeholderID;
-        this.ent = ent;
         this.operations = operations;
         this.options = options;
         this.idx = 0;
@@ -27,8 +26,9 @@ class ListBasedExecutor {
     [Symbol.iterator]() {
         return this;
     }
+    // returns true and null|undefined when done
     next() {
-        let createdEnt = getCreatedEnt(this.viewer, this.lastOp, this.ent);
+        let createdEnt = getCreatedEnt(this.viewer, this.lastOp);
         if (createdEnt) {
             this.createdEnt = createdEnt;
         }
@@ -36,6 +36,10 @@ class ListBasedExecutor {
         const op = this.operations[this.idx];
         this.idx++;
         this.lastOp = op;
+        // reset since this could be called multiple times. not needed if we have getSortedOps or something like that
+        if (done) {
+            this.idx = 0;
+        }
         return {
             value: op,
             done: done,
@@ -74,30 +78,24 @@ class ListBasedExecutor {
     }
 }
 exports.ListBasedExecutor = ListBasedExecutor;
-function getCreatedEnt(viewer, op, ent) {
-    if (op && op.returnedEntRow) {
-        let row = op.returnedEntRow();
-        if (row) {
-            return new ent(viewer, row);
-        }
+function getCreatedEnt(viewer, op) {
+    if (op && op.createdEnt) {
+        return op.createdEnt(viewer);
     }
     return null;
 }
 class ComplexExecutor {
-    constructor(viewer, placeholderID, ent, operations, dependencies, changesets, options) {
+    constructor(viewer, placeholderID, operations, dependencies, changesets, options) {
         this.viewer = viewer;
         this.placeholderID = placeholderID;
-        this.ent = ent;
-        this.options = options;
         this.idx = 0;
         this.mapper = new Map();
         this.allOperations = [];
-        this.changesetMap = new Map();
-        this.nodeOpMap = new Map();
         this.executors = [];
         let graph = (0, graph_data_structure_1.default)();
+        const changesetMap = new Map();
         const impl = (c) => {
-            this.changesetMap.set(c.placeholderID.toString(), c);
+            changesetMap.set(c.placeholderID.toString(), c);
             graph.addNode(c.placeholderID.toString());
             if (c.dependencies) {
                 for (let [key, builder] of c.dependencies) {
@@ -117,20 +115,19 @@ class ComplexExecutor {
         impl({
             viewer: this.viewer,
             placeholderID: this.placeholderID,
-            ent: this.ent,
             changesets: changesets,
             dependencies: dependencies,
             executor: () => {
-                return new ListBasedExecutor(this.viewer, this.placeholderID, this.ent, operations, this.options);
+                return new ListBasedExecutor(this.viewer, this.placeholderID, operations, options);
             },
         });
         // use a set to handle repeated ops because of how the executor logic currently works
-        // TODO: this logic can be rewritten to be smarter and probably not need a set
+        // TODO: can this logic be rewritten to not have a set yet avoid duplicates?
         let nodeOps = new Set();
         let remainOps = new Set();
         let sorted = graph.topologicalSort(graph.nodes());
         sorted.forEach((node) => {
-            let c = this.changesetMap.get(node);
+            let c = changesetMap.get(node);
             if (!c) {
                 // phew. expect it to be handled somewhere else
                 // we can just skip it and expect the resolver to handle this correctly
@@ -143,9 +140,8 @@ class ComplexExecutor {
             // get ordered list of ops
             let executor = c.executor();
             for (let op of executor) {
-                if (op.returnedEntRow) {
+                if (op.createdEnt) {
                     nodeOps.add(op);
-                    this.nodeOpMap.set(op, c);
                 }
                 else {
                     remainOps.add(op);
@@ -165,26 +161,30 @@ class ComplexExecutor {
         return this;
     }
     handleCreatedEnt() {
-        let c = this.nodeOpMap.get(this.lastOp);
-        if (!c) {
-            // nothing to do here
+        if (!this.lastOp) {
             return;
         }
-        let createdEnt = getCreatedEnt(this.viewer, this.lastOp, c.ent);
+        let createdEnt = getCreatedEnt(this.viewer, this.lastOp);
         if (!createdEnt) {
             return;
         }
-        let placeholderID = c.placeholderID;
+        const placeholderID = this.lastOp.placeholderID;
+        if (!placeholderID) {
+            console.error(`op ${this.lastOp} which implements getCreatedEnt doesn't have a placeholderID`);
+            return;
+        }
         this.mapper.set(placeholderID, createdEnt);
     }
     next() {
-        if (this.lastOp) {
-            this.handleCreatedEnt();
-        }
+        this.handleCreatedEnt();
         const done = this.idx === this.allOperations.length;
         const op = this.allOperations[this.idx];
         this.idx++;
         this.lastOp = op;
+        // reset since this could be called multiple times. not needed if we have getSortedOps or something like that
+        if (done) {
+            this.idx = 0;
+        }
         return {
             value: op,
             done: done,
@@ -195,6 +195,12 @@ class ComplexExecutor {
         if (ent) {
             return ent;
         }
+        for (const c of this.executors) {
+            const ent = c.resolveValue(val);
+            if (ent) {
+                return ent;
+            }
+        }
         return null;
     }
     async executeObservers() {

package/action/index.d.ts

@@ -1,3 +1,3 @@
-export { WriteOperation, Builder, Executor, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, } from "./action";
+export { WriteOperation, Builder, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, } from "./action";
 export { OrchestratorOptions, Orchestrator, EntChangeset, EdgeInputData, } from "./orchestrator";
 export { DenyIfBuilder, AllowIfBuilder } from "./privacy";

package/action/orchestrator.d.ts

@@ -1,7 +1,7 @@
 import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
 import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType } from "../schema/schema";
-import { Changeset, Executor } from "../action";
+import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
 export interface OrchestratorOptions<T extends Ent, TData extends Data> {
     viewer: Viewer;
@@ -64,7 +64,7 @@ export declare class Orchestrator<T extends Ent> {
     validX(): Promise<void>;
     build(): Promise<EntChangeset<T>>;
     private viewerForEntLoad;
-    returnedRow(): Promise<Data | null>;
+    private returnedRow;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
 }
@@ -73,10 +73,11 @@ export declare class EntChangeset<T extends Ent> implements Changeset<T> {
     readonly placeholderID: ID;
     readonly ent: EntConstructor<T>;
     operations: DataOperation[];
-    dependencies?: Map<ID, Builder<T>> | undefined;
+    dependencies?: Map<ID, Builder<Ent>> | undefined;
     changesets?: Changeset<Ent>[] | undefined;
     private options?;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<T>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data> | undefined);
+    private _executor;
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data> | undefined);
     executor(): Executor;
 }
 export {};

package/action/orchestrator.js

@@ -146,6 +146,8 @@ class Orchestrator {
                     tableName: this.options.tableName,
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
+                    ent: this.options.loaderOptions.ent,
+                    placeholderID: this.options.builder.placeholderID,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
@@ -432,8 +434,8 @@ class Orchestrator {
         return action.viewerForEntLoad(data);
     }
     async returnedRow() {
-        if (this.mainOp && this.mainOp.returnedEntRow) {
-            return this.mainOp.returnedEntRow();
+        if (this.mainOp && this.mainOp.returnedRow) {
+            return this.mainOp.returnedRow();
         }
         return null;
     }
@@ -475,13 +477,17 @@ class EntChangeset {
         this.options = options;
     }
     executor() {
-        // TODO: write comment here similar to go
-        // if we have dependencies but no changesets, we just need a simple
-        // executor and depend on something else in the stack to handle this correctly
-        if (this.changesets?.length) {
-            return new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.ent, this.operations, this.dependencies, this.changesets, this.options);
+        if (this._executor) {
+            return this._executor;
         }
-        return new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.ent, this.operations, this.options);
+        if (!this.changesets?.length) {
+            // if we have dependencies but no changesets, we just need a simple
+            // executor and depend on something else in the stack to handle this correctly
+            // ComplexExecutor which could be a parent of this should make sure the dependency
+            // is resolved beforehand
+            return (this._executor = new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.operations, this.options));
+        }
+        return (this._executor = new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.operations, this.dependencies || new Map(), this.changesets || [], this.options));
     }
 }
 exports.EntChangeset = EntChangeset;

package/core/clause.js

@@ -177,7 +177,7 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
-// todo?
+// TODO this breaks if values.length ===1 and array. todo fix
 function In(col, ...values) {
     return new inClause(col, values);
 }

package/core/ent.d.ts

@@ -1,6 +1,6 @@
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions } from "./base";
-import { Executor } from "../action";
+import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions, EntConstructor } from "./base";
+import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
@@ -39,27 +39,33 @@ interface GroupQueryOptions {
     limit: number;
 }
 export declare function buildGroupQuery(options: GroupQueryOptions): [string, clause.Clause];
-export interface DataOperation {
+export interface DataOperation<T extends Ent = Ent> {
     preFetch?(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    returnedEntRow?(): Data | null;
+    placeholderID?: ID;
+    returnedRow?(): Data | null;
+    createdEnt?(viewer: Viewer): T | null;
     resolve?(executor: Executor): void;
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
 }
-export interface EditNodeOptions extends EditRowOptions {
+export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
     fieldsToResolve: string[];
+    ent: EntConstructor<T>;
+    placeholderID?: ID;
 }
-export declare class EditNodeOperation implements DataOperation {
-    options: EditNodeOptions;
+export declare class EditNodeOperation<T extends Ent> implements DataOperation {
+    options: EditNodeOptions<T>;
     private existingEnt;
     row: Data | null;
-    constructor(options: EditNodeOptions, existingEnt?: Ent | null);
+    placeholderID?: ID | undefined;
+    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
     resolve<T extends Ent>(executor: Executor): void;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    reloadRow(queryer: SyncQueryer, id: ID, options: EditNodeOptions): void;
+    private reloadRow;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    returnedEntRow(): Data | null;
+    returnedRow(): Data | null;
+    createdEnt(viewer: Viewer): T | null;
 }
 export declare class EdgeOperation implements DataOperation {
     edgeInput: AssocEdgeInput;

package/core/ent.js

@@ -401,6 +401,7 @@ class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;
         this.existingEnt = existingEnt;
+        this.placeholderID = options.placeholderID;
     }
     resolve(executor) {
         if (!this.options.fieldsToResolve.length) {
@@ -463,9 +464,15 @@ class EditNodeOperation {
             this.reloadRow(queryer, id, options);
         }
     }
-    returnedEntRow() {
+    returnedRow() {
         return this.row;
     }
+    createdEnt(viewer) {
+        if (!this.row) {
+            return null;
+        }
+        return new this.options.ent(viewer, this.row);
+    }
 }
 exports.EditNodeOperation = EditNodeOperation;
 class EdgeOperation {

package/graphql/builtins/connection.js

@@ -5,6 +5,7 @@ const graphql_1 = require("graphql");
 const node_1 = require("./node");
 const edge_1 = require("./edge");
 const page_info_1 = require("../query/page_info");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLConnectionInterface = new graphql_1.GraphQLInterfaceType({
     name: "Connection",
     description: "connection interface",

package/graphql/builtins/edge.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLEdgeInterface = void 0;
 const graphql_1 = require("graphql");
 const node_1 = require("./node");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLEdgeInterface = new graphql_1.GraphQLInterfaceType({
     name: "Edge",
     description: "edge interface",

package/graphql/builtins/node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLNodeInterface = void 0;
 const graphql_1 = require("graphql");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLNodeInterface = new graphql_1.GraphQLInterfaceType({
     name: "Node",
     description: "node interface",

package/graphql/graphql.d.ts

@@ -8,6 +8,7 @@ export interface CustomType {
     importPath: string;
     tsType?: string;
     tsImportPath?: string;
+    [x: string]: any;
 }
 declare type Type = GraphQLScalarType | ClassType | string | CustomType;
 export declare type GraphQLConnection<T> = {
@@ -81,6 +82,7 @@ declare enum NullableResult {
     CONTENTS_AND_LIST = "contentsAndList",
     ITEM = "true"
 }
+export declare const addCustomType: (type: CustomType) => void;
 export declare class GQLCapture {
     private static enabled;
     static enable(enabled: boolean): void;

package/graphql/graphql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = exports.GQLCapture = exports.CustomFieldType = void 0;
+exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = exports.GQLCapture = exports.addCustomType = exports.CustomFieldType = void 0;
 require("reflect-metadata");
 // export interface gqlTopLevelOptions
 //   name?: string;
@@ -20,6 +20,88 @@ var NullableResult;
     NullableResult["CONTENTS_AND_LIST"] = "contentsAndList";
     NullableResult["ITEM"] = "true";
 })(NullableResult || (NullableResult = {}));
+const isArray = (type) => {
+    if (typeof type === "function") {
+        return false;
+    }
+    return type.push !== undefined;
+};
+const isConnection = (type) => {
+    if (typeof type !== "object") {
+        return false;
+    }
+    return type.node !== undefined;
+};
+const isString = (type) => {
+    if (type.lastIndexOf !== undefined) {
+        return true;
+    }
+    return false;
+};
+const isCustomType = (type) => {
+    return type.importPath !== undefined;
+};
+const isGraphQLScalarType = (type) => {
+    return type.serialize !== undefined;
+};
+const addCustomType = (type) => {
+    // TODO these should return ReadOnly objects...
+    const customType = GQLCapture.getCustomTypes().get(type.type);
+    if (customType && customType !== type) {
+        throw new Error(`cannot add multiple custom types of name ${type.type}`);
+    }
+    if (customType) {
+        return;
+    }
+    try {
+        const r = require(type.importPath);
+        const ct = r[type.type];
+        // this gets us the information needed for scalars
+        if (ct && isGraphQLScalarType(ct)) {
+            type.scalarInfo = {
+                description: ct.description,
+                name: ct.name,
+            };
+            if (ct.specifiedByUrl) {
+                type.scalarInfo.specifiedByUrl = ct.specifiedByUrl;
+            }
+        }
+    }
+    catch (e) {
+        return;
+    }
+    GQLCapture.getCustomTypes().set(type.type, type);
+};
+exports.addCustomType = addCustomType;
+const getType = (typ, result) => {
+    if (isConnection(typ)) {
+        result.connection = true;
+        return getType(typ.node, result);
+    }
+    if (isArray(typ)) {
+        result.list = true;
+        return getType(typ[0], result);
+    }
+    if (isString(typ)) {
+        if (typ.lastIndexOf("]") !== -1) {
+            result.list = true;
+            result.type = typ.substr(1, typ.length - 2);
+        }
+        else {
+            result.type = typ;
+        }
+        return;
+    }
+    if (isCustomType(typ)) {
+        result.type = typ.type;
+        (0, exports.addCustomType)(typ);
+        return;
+    }
+    // GraphQLScalarType or ClassType
+    result.scalarType = isGraphQLScalarType(typ);
+    result.type = typ.name;
+    return;
+};
 class GQLCapture {
     static enable(enabled) {
         this.enabled = enabled;
@@ -104,66 +186,6 @@ class GQLCapture {
         if ((type === "Number" || type === "Object") && !options?.type) {
             throw new Error(`type is required when accessor/function/property returns a ${type}`);
         }
-        const isArray = (type) => {
-            if (typeof type === "function") {
-                return false;
-            }
-            return type.push !== undefined;
-        };
-        const isConnection = (type) => {
-            if (typeof type !== "object") {
-                return false;
-            }
-            return type.node !== undefined;
-        };
-        const isString = (type) => {
-            if (type.lastIndexOf !== undefined) {
-                return true;
-            }
-            return false;
-        };
-        const isCustomType = (type) => {
-            return type.importPath !== undefined;
-        };
-        const isGraphQLScalarType = (type) => {
-            return type.serialize !== undefined;
-        };
-        const addCustomType = (type) => {
-            const customType = this.customTypes.get(type.type);
-            if (customType && customType !== type) {
-                throw new Error(`cannot add multiple custom types of name ${type.type}`);
-            }
-            this.customTypes.set(type.type, type);
-        };
-        const getType = (typ, result) => {
-            if (isConnection(typ)) {
-                result.connection = true;
-                return getType(typ.node, result);
-            }
-            if (isArray(typ)) {
-                result.list = true;
-                return getType(typ[0], result);
-            }
-            if (isString(typ)) {
-                if (typ.lastIndexOf("]") !== -1) {
-                    result.list = true;
-                    result.type = typ.substr(1, typ.length - 2);
-                }
-                else {
-                    result.type = typ;
-                }
-                return;
-            }
-            if (isCustomType(typ)) {
-                result.type = typ.type;
-                addCustomType(typ);
-                return;
-            }
-            // GraphQLScalarType or ClassType
-            result.scalarType = isGraphQLScalarType(typ);
-            result.type = typ.name;
-            return;
-        };
         let list;
         let scalarType = false;
         let connection;

package/graphql/query/page_info.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLPageInfo = void 0;
 const graphql_1 = require("graphql");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLPageInfo = new graphql_1.GraphQLObjectType({
     name: "PageInfo",
     fields: () => ({

package/imports/index.d.ts

@@ -10,7 +10,7 @@ interface classResult {
     class: classInfo;
     file: file;
 }
-export declare function parseCustomInput(filePath: string, opts?: Options): PathResult;
+export declare function parseCustomImports(filePath: string, opts?: Options): PathResult;
 export declare function findTSConfigFile(filePath: string): string | null;
 export interface importInfo {
     name: string;

package/imports/index.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.findTSConfigFile = exports.parseCustomInput = void 0;
+exports.findTSConfigFile = exports.parseCustomImports = void 0;
 const glob_1 = __importDefault(require("glob"));
 const typescript_1 = __importDefault(require("typescript"));
 const json5_1 = __importDefault(require("json5"));
@@ -42,10 +42,9 @@ function getFiles(filePath, opts) {
     }
     return files;
 }
-function parseCustomInput(filePath, opts) {
+function parseCustomImports(filePath, opts) {
     const files = getFiles(filePath, opts);
     const options = readCompilerOptions(filePath);
-    // classMap
     let classMap = new Map();
     files.forEach((file) => {
         const sourceFile = typescript_1.default.createSourceFile(file, fs.readFileSync(file).toString(), options.target || typescript_1.default.ScriptTarget.ES2015);
@@ -77,7 +76,7 @@ function parseCustomInput(filePath, opts) {
         },
     };
 }
-exports.parseCustomInput = parseCustomInput;
+exports.parseCustomImports = parseCustomImports;
 function findTSConfigFile(filePath) {
     while (filePath != "/") {
         let configPath = `${filePath}/tsconfig.json`;
@@ -95,7 +94,6 @@ function readCompilerOptions(filePath) {
     if (!configPath) {
         return {};
     }
-    const root = path.join(filePath, "..");
     let json = {};
     try {
         json = json5_1.default.parse(fs.readFileSync(configPath, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -39,7 +39,7 @@
     }
   },
   "engines": {
-    "node": "^16.1.0"
+    "node": ">=14.0"
   },
   "devDependencies": {},
   "scripts": {},

package/scripts/custom_graphql.js

@@ -25,6 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob_1 = __importDefault(require("glob"));
 const minimist_1 = __importDefault(require("minimist"));
+const graphql_1 = require("../graphql/graphql");
 const readline = __importStar(require("readline"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -52,7 +53,17 @@ async function readInputs() {
         });
     });
 }
-async function captureCustom(filePath) {
+async function captureCustom(filePath, filesCsv) {
+    if (filesCsv !== undefined) {
+        let files = filesCsv.split(",");
+        for (let i = 0; i < files.length; i++) {
+            // TODO fix. we have "src" in the path we get here
+            files[i] = path.join(filePath, "..", files[i]);
+        }
+        await requireFiles(files);
+        return;
+    }
+    // TODO delete all of this eventually
     // TODO configurable paths eventually
     // for now only files that are in the include path of the roots are allowed
     const rootFiles = [
@@ -81,18 +92,28 @@ async function captureCustom(filePath) {
         ignore: ignore,
     });
     const files = rootFiles.concat(customGQLResolvers, customGQLMutations);
-    //console.log(files);
-    let promises = [];
-    files.forEach((file) => {
+    await requireFiles(files);
+}
+async function requireFiles(files) {
+    await Promise.all(files.map(async (file) => {
         if (fs.existsSync(file)) {
-            promises.push(require(file));
+            try {
+                await require(file);
+            }
+            catch (e) {
+                throw new Error(`${e.message} loading ${file}`);
+            }
+        }
+        else {
+            throw new Error(`file ${file} doesn't exist`);
         }
+    })).catch((err) => {
+        throw new Error(err);
     });
-    await Promise.all(promises);
 }
 async function parseImports(filePath) {
     // only do graphql files...
-    return (0, imports_1.parseCustomInput)(path.join(filePath, "graphql"), {
+    return (0, imports_1.parseCustomImports)(path.join(filePath, "graphql"), {
         ignore: ["**/generated/**", "**/tests/**"],
     });
 }
@@ -110,6 +131,20 @@ function findGraphQLPath(filePath) {
     return undefined;
 }
 async function main() {
+    // known custom types that are not required
+    // if not in the schema, will be ignored
+    // something like GraphQLUpload gotten via gqlArg({type: gqlFileUpload})
+    // these 2 need this because they're added by the schema
+    // if this list grows too long, need to build this into golang types and passed here
+    // TODO foreign non-scalars eventually
+    (0, graphql_1.addCustomType)({
+        importPath: "../graphql/scalars/time",
+        type: "GraphQLTime",
+    });
+    (0, graphql_1.addCustomType)({
+        importPath: "graphql-type-json",
+        type: "GraphQLJSON",
+    });
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
         throw new Error("path required");
@@ -126,7 +161,7 @@ async function main() {
     GQLCapture.enable(true);
     const [inputsRead, _, imports] = await Promise.all([
         readInputs(),
-        captureCustom(options.path),
+        captureCustom(options.path, options.files),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;

package/testutils/builder.d.ts

@@ -93,7 +93,7 @@ export declare class SimpleAction<T extends Ent> implements Action<T> {
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy;
-    getInput(): Map<string, any>;
+    getInput(): Data;
     changeset(): Promise<Changeset<T>>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;

package/testutils/builder.js

@@ -185,7 +185,11 @@ class SimpleAction {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
     getInput() {
-        return this.fields;
+        const ret = {};
+        for (const [k, v] of this.fields) {
+            ret[k] = v;
+        }
+        return ret;
     }
     changeset() {
         return this.builder.build();

package/testutils/db_mock.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryRecorder = exports.queryType = void 0;
 const uuid_1 = require("uuid");
-const utils_1 = require("ts-jest/utils");
+const jest_mock_1 = require("jest-mock");
 const parse_sql_1 = require("./parse_sql");
 const eventEmitter = {
     on: jest.fn(),
@@ -185,7 +185,7 @@ class QueryRecorder {
         }
     }
     static mockPool(pool) {
-        const mockedPool = (0, utils_1.mocked)(pool, true);
+        const mockedPool = (0, jest_mock_1.mocked)(pool, true);
         mockedPool.mockImplementation(() => {
             return {
                 totalCount: 1,

package/testutils/ent-graphql-tests/index.js

@@ -286,11 +286,11 @@ async function expectFromRoot(config, ...options) {
     let fields = query?.getFields();
     if (!fields) {
         // TODO custom error?
-        fail("schema doesn't have query or fields");
+        throw new Error("schema doesn't have query or fields");
     }
     let field = fields[config.root];
     if (!field) {
-        fail(`could not find field ${config.root} in GraphQL query schema`);
+        throw new Error(`could not find field ${config.root} in GraphQL query schema`);
     }
     let fieldArgs = field.args;
     let queryParams = [];
@@ -361,7 +361,7 @@ async function expectFromRoot(config, ...options) {
             expect(errors[0].message).toMatch(config.expectedError);
         }
         else {
-            fail(`unhandled error ${JSON.stringify(errors)}`);
+            throw new Error(`unhandled error ${JSON.stringify(errors)}`);
         }
         return st;
     }
@@ -416,7 +416,7 @@ async function expectFromRoot(config, ...options) {
             if (idx !== -1) {
                 let endIdx = part.indexOf("]");
                 if (endIdx === -1) {
-                    fail("can't have a beginning index without an end index");
+                    throw new Error("can't have a beginning index without an end index");
                 }
                 // get the idx we care about
                 listIdx = parseInt(part.substr(idx + 1, endIdx - idx), 10);
@@ -428,7 +428,7 @@ async function expectFromRoot(config, ...options) {
             if (idx !== -1) {
                 let endIdx = part.indexOf(")");
                 if (endIdx === -1) {
-                    fail("can't have a beginning index without an end index");
+                    throw new Error("can't have a beginning index without an end index");
                 }
                 // update part
                 part = part.substr(0, idx);

package/testutils/fake_data/test_helpers.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAllEvents = exports.tempDBTables = exports.setupTempDB = exports.createTestEvent = exports.edgeTableNames = exports.createEdges = exports.verifyUserToContacts = exports.verifyUserToContactRawData = exports.verifyUserToContactEdges = exports.addEdge = exports.createUserPlusFriendRequests = exports.createAllContacts = exports.inputs = exports.createTestUser = exports.getEventInput = exports.getUserInput = exports.getContactInput = void 0;
-const assert_1 = require("assert");
 const jest_date_mock_1 = require("jest-date-mock");
 const viewer_1 = require("../../core/viewer");
 const ent_1 = require("../../core/ent");
@@ -56,7 +55,7 @@ async function createTestUser(input) {
         ...input,
     });
     if (!user) {
-        (0, assert_1.fail)("error creating user");
+        throw new Error("error creating user");
     }
     return user;
 }

package/testutils/parse_sql.js

@@ -74,7 +74,7 @@ function getColumns(cols) {
                 count = true;
             }
             else {
-                fail("unsupported expr type");
+                throw new Error("unsupported expr type");
             }
         }
     }