@snowtop/ent 0.0.28 → 0.0.31

package/action/action.d.ts

@@ -7,7 +7,7 @@ export declare enum WriteOperation {
     Delete = "delete"
 }
 export interface Builder<T extends Ent> {
-    existingEnt?: Ent;
+    existingEnt?: T;
     ent: EntConstructor<T>;
     placeholderID: ID;
     readonly viewer: Viewer;
@@ -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/experimental_action.d.ts

@@ -1,4 +1,4 @@
-import { Viewer, Ent } from "../core/base";
+import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
 export interface ActionOptions<T extends Ent> {
     existingEnt?: T | null;
@@ -35,4 +35,6 @@ export declare class BaseAction<T extends Ent> implements Action<T> {
 interface BuilderConstructor<T extends Ent> {
     new (viewer: Viewer, operation: WriteOperation, action: Action<T>, existingEnt?: T | undefined): EntBuilder<T>;
 }
+export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Action<TEnt>;
 export {};

package/action/experimental_action.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAction = void 0;
+exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
@@ -66,3 +66,28 @@ class BaseAction {
     }
 }
 exports.BaseAction = BaseAction;
+// this provides a way to just update a row in the database.
+// skips privacy, triggers, observers, etc
+// does do field validation
+// note that only editable fields in the builder can be passed here
+async function updateRawObject(viewer, builderCtr, existingEnt, input) {
+    const action = new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+    return action.saveX();
+}
+exports.updateRawObject = updateRawObject;
+// creates an action which has no privacy, triggers, observers etc
+// does do field validation
+// useful to batch a bunch of writes together with BaseAction.bulkAction
+// note that only editable fields in the builder can be passed here
+function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+}
+exports.getSimpleEditAction = getSimpleEditAction;

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;
@@ -59,12 +59,14 @@ export declare class Orchestrator<T extends Ent> {
     private validators;
     private isBuilder;
     private getFieldsWithDefaultValues;
+    private hasData;
+    private transformFieldValue;
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     build(): Promise<EntChangeset<T>>;
     private viewerForEntLoad;
-    returnedRow(): Promise<Data | null>;
+    private returnedRow;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
 }
@@ -73,10 +75,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;
@@ -301,6 +303,7 @@ class Orchestrator {
     getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
         let data = {};
+        let defaultData = {};
         let input = action?.getInput() || {};
         let updateInput = false;
         for (const [fieldName, field] of schemaFields) {
@@ -328,23 +331,79 @@ class Orchestrator {
                     // TODO special case this if this is the only thing changing and don't do the write.
                 }
             }
-            data[dbKey] = value;
+            if (value !== undefined) {
+                data[dbKey] = value;
+            }
             if (defaultValue !== undefined) {
                 updateInput = true;
-                data[dbKey] = defaultValue;
+                defaultData[dbKey] = defaultValue;
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
                 this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
             }
         }
-        if (updateInput && this.options.updateInput) {
-            // this basically fixes #605. just needs to be exposed correctly
-            this.options.updateInput(this.defaultFieldsByTSName);
+        // if there's data changing, add data
+        if (this.hasData(data)) {
+            data = {
+                ...data,
+                ...defaultData,
+            };
+            if (updateInput && this.options.updateInput) {
+                // this basically fixes #605. just needs to be exposed correctly
+                this.options.updateInput(this.defaultFieldsByTSName);
+            }
         }
         return data;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
+    async transformFieldValue(field, dbKey, value) {
+        // now format and validate...
+        if (value === null) {
+            if (!field.nullable) {
+                throw new Error(`field ${field.name} set to null for non-nullable field`);
+            }
+        }
+        else if (value === undefined) {
+            if (!field.nullable &&
+                // required field can be skipped if server default set
+                // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
+                // not setting server default as we're depending on the database handling that.
+                // server default allowed
+                field.serverDefault === undefined &&
+                this.options.operation === action_1.WriteOperation.Insert) {
+                throw new Error(`required field ${field.name} not set`);
+            }
+        }
+        else if (this.isBuilder(value)) {
+            let builder = value;
+            // keep track of dependencies to resolve
+            this.dependencies.set(builder.placeholderID, builder);
+            // keep track of fields to resolve
+            this.fieldsToResolve.push(dbKey);
+        }
+        else {
+            if (field.valid) {
+                // TODO this could be async. handle this better
+                let valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                }
+            }
+            if (field.format) {
+                // TODO this could be async e.g. password. handle this better
+                value = await Promise.resolve(field.format(value));
+            }
+        }
+        return value;
+    }
     async formatAndValidateFields(schemaFields) {
-        if (this.options.operation == action_1.WriteOperation.Delete) {
+        const op = this.options.operation;
+        if (op === action_1.WriteOperation.Delete) {
             return;
         }
         const editedFields = this.options.editedFields();
@@ -353,53 +412,32 @@ class Orchestrator {
         let logValues = {};
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
-            if (value === undefined) {
+            if (value === undefined && op === action_1.WriteOperation.Insert) {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
             let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
-            // now format and validate...
-            if (value === null) {
-                if (!field.nullable) {
-                    throw new Error(`field ${field.name} set to null for non-nullable field`);
-                }
-            }
-            else if (value === undefined) {
-                if (!field.nullable &&
-                    // required field can be skipped if server default set
-                    // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
-                    // not setting server default as we're depending on the database handling that.
-                    // server default allowed
-                    field.serverDefault === undefined &&
-                    this.options.operation === action_1.WriteOperation.Insert) {
-                    throw new Error(`required field ${field.name} not set`);
-                }
-            }
-            else if (this.isBuilder(value)) {
-                let builder = value;
-                // keep track of dependencies to resolve
-                this.dependencies.set(builder.placeholderID, builder);
-                // keep track of fields to resolve
-                this.fieldsToResolve.push(dbKey);
-            }
-            else {
-                if (field.valid) {
-                    // TODO this could be async. handle this better
-                    let valid = await Promise.resolve(field.valid(value));
-                    if (!valid) {
-                        throw new Error(`invalid field ${field.name} with value ${value}`);
-                    }
-                }
-                if (field.format) {
-                    // TODO this could be async e.g. password. handle this better
-                    value = await Promise.resolve(field.format(value));
-                }
-            }
+            value = await this.transformFieldValue(field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        //  we ignored default values while editing.
+        // if we're editing and there's data, add default values
+        if (op === action_1.WriteOperation.Edit && this.hasData(data)) {
+            for (const fieldName in this.defaultFieldsByFieldName) {
+                const defaultValue = this.defaultFieldsByFieldName[fieldName];
+                let field = schemaFields.get(fieldName);
+                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                // no value, let's just default
+                if (data[dbKey] === undefined) {
+                    const value = await this.transformFieldValue(field, dbKey, defaultValue);
+                    data[dbKey] = value;
+                    logValues[dbKey] = field.logValue(value);
+                }
+            }
+        }
         this.validatedFields = data;
         this.logValues = logValues;
     }
@@ -432,8 +470,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 +513,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;
+        }
+        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 new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.ent, 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,34 @@ 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;
+    private hasData;
     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) {
@@ -420,13 +421,24 @@ class EditNodeOperation {
         });
         this.options.fields = fields;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
     async performWrite(queryer, context) {
         let options = {
             ...this.options,
             context,
         };
         if (this.existingEnt) {
-            this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            if (this.hasData(options.fields)) {
+                this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             this.row = await createRow(queryer, options, "RETURNING *");
@@ -454,8 +466,13 @@ class EditNodeOperation {
             context,
         };
         if (this.existingEnt) {
-            editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
-            this.reloadRow(queryer, this.existingEnt.id, options);
+            if (this.hasData(this.options.fields)) {
+                editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
+                this.reloadRow(queryer, this.existingEnt.id, options);
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             createRowSync(queryer, options, "RETURNING *");
@@ -463,9 +480,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/package.json

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

package/schema/schema.d.ts

@@ -168,6 +168,10 @@ export interface Action {
     graphQLName?: string;
     hideFromGraphQL?: boolean;
     actionOnlyFields?: ActionField[];
+    excludedFields?: string[];
+    optionalFields?: string[];
+    requiredFields?: string[];
+    noFields?: boolean;
 }
 export declare const NoFields = "__NO_FIELDS__";
 export declare function requiredField(field: string): string;

package/testutils/builder.d.ts

@@ -66,12 +66,12 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
-    existingEnt: Ent | undefined;
+    existingEnt: T | undefined;
     ent: EntConstructor<T>;
     placeholderID: ID;
     orchestrator: Orchestrator<T>;
     fields: Map<string, any>;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: Ent | undefined, action?: Action<T> | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T> | undefined);
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -93,12 +93,13 @@ 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>;
     save(): Promise<T | null>;
     saveX(): Promise<T>;
     editedEnt(): Promise<T | null>;
+    editedEntX(): Promise<T>;
 }
 export {};

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();
@@ -199,16 +203,19 @@ class SimpleAction {
     async save() {
         await (0, action_1.saveBuilder)(this.builder);
         if (this.builder.operation !== action_1.WriteOperation.Delete) {
-            return await this.builder.orchestrator.editedEnt();
+            return this.builder.orchestrator.editedEnt();
         }
         return null;
     }
     async saveX() {
         await (0, action_1.saveBuilderX)(this.builder);
-        return await this.builder.orchestrator.editedEntX();
+        return this.builder.orchestrator.editedEntX();
     }
     async editedEnt() {
-        return await this.builder.orchestrator.editedEnt();
+        return this.builder.orchestrator.editedEnt();
+    }
+    async editedEntX() {
+        return this.builder.orchestrator.editedEntX();
     }
 }
 exports.SimpleAction = SimpleAction;

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");
             }
         }
     }