@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/action/orchestrator.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 };
 };
@@ -6,11 +29,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
+const operations_1 = require("./operations");
 const action_1 = require("../action");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
 const memoizee_1 = __importDefault(require("memoizee"));
+const clause = __importStar(require("../core/clause"));
+const types_1 = require("util/types");
+const operations_2 = require("./operations");
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -24,31 +51,38 @@ class edgeInputData {
         return id.placeholderID !== undefined;
     }
 }
-function getViewer(action) {
-    if (!action.viewer.viewerID) {
+function getViewer(viewer) {
+    if (!viewer.viewerID) {
         return "Logged out Viewer";
     }
     else {
-        return `Viewer with ID ${action.viewer.viewerID}`;
+        return `Viewer with ID ${viewer.viewerID}`;
     }
 }
 class EntCannotCreateEntError extends Error {
     constructor(privacyPolicy, action) {
-        let msg = `${getViewer(action)} does not have permission to create ${action.builder.ent.name}`;
+        let msg = `${getViewer(action.viewer)} does not have permission to create ${action.builder.ent.name}`;
         super(msg);
         this.privacyPolicy = privacyPolicy;
     }
 }
 class EntCannotEditEntError extends Error {
     constructor(privacyPolicy, action, ent) {
-        let msg = `${getViewer(action)} does not have permission to edit ${ent.constructor.name}`;
+        let msg = `${getViewer(action.viewer)} does not have permission to edit ${ent.constructor.name}`;
+        super(msg);
+        this.privacyPolicy = privacyPolicy;
+    }
+}
+class EntCannotEditEntFieldError extends Error {
+    constructor(privacyPolicy, viewer, field, ent) {
+        let msg = `${getViewer(viewer)} does not have permission to edit field ${field} in ${ent.constructor.name}`;
         super(msg);
         this.privacyPolicy = privacyPolicy;
     }
 }
 class EntCannotDeleteEntError extends Error {
     constructor(privacyPolicy, action, ent) {
-        let msg = `${getViewer(action)} does not have permission to delete ${ent.constructor.name}`;
+        let msg = `${getViewer(action.viewer)} does not have permission to delete ${ent.constructor.name}`;
         super(msg);
         this.privacyPolicy = privacyPolicy;
     }
@@ -58,6 +92,7 @@ class Orchestrator {
         this.options = options;
         this.edgeSet = new Set();
         this.edges = new Map();
+        this.conditionalEdges = new Map();
         this.changesets = [];
         this.dependencies = new Map();
         this.fieldsToResolve = [];
@@ -68,7 +103,11 @@ class Orchestrator {
         this.existingEnt = this.options.builder.existingEnt;
         this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
     }
-    addEdge(edge, op) {
+    // don't type this because we don't care
+    __getOptions() {
+        return this.options;
+    }
+    addEdge(edge, op, conditional) {
         this.edgeSet.add(edge.edgeType);
         let m1 = this.edges.get(edge.edgeType) || new Map();
         let m2 = m1.get(op) || new Map();
@@ -83,11 +122,22 @@ class Orchestrator {
         // set or overwrite the new edge data for said id
         m2.set(id, edge);
         m1.set(op, m2);
-        this.edges.set(edge.edgeType, m1);
+        if (conditional && this.onConflict) {
+            this.conditionalEdges.set(edge.edgeType, m1);
+        }
+        else {
+            this.edges.set(edge.edgeType, m1);
+        }
     }
     setDisableTransformations(val) {
         this.disableTransformations = val;
     }
+    setOnConflictOptions(onConflict) {
+        if (onConflict?.onConflictConstraint && !onConflict.updateCols) {
+            throw new Error(`cannot set onConflictConstraint without updateCols`);
+        }
+        this.onConflict = onConflict;
+    }
     addInboundEdge(id1, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
@@ -95,7 +145,7 @@ class Orchestrator {
             nodeType,
             options,
             direction: edgeDirection.inboundEdge,
-        }), action_1.WriteOperation.Insert);
+        }), action_1.WriteOperation.Insert, options?.conditional);
     }
     addOutboundEdge(id2, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
@@ -104,21 +154,23 @@ class Orchestrator {
             nodeType,
             options,
             direction: edgeDirection.outboundEdge,
-        }), action_1.WriteOperation.Insert);
+        }), action_1.WriteOperation.Insert, options?.conditional);
     }
-    removeInboundEdge(id1, edgeType) {
+    removeInboundEdge(id1, edgeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
             edgeType,
             direction: edgeDirection.inboundEdge,
-        }), action_1.WriteOperation.Delete);
+            options,
+        }), action_1.WriteOperation.Delete, options?.conditional);
     }
-    removeOutboundEdge(id2, edgeType) {
+    removeOutboundEdge(id2, edgeType, options) {
         this.addEdge(new edgeInputData({
             id: id2,
             edgeType,
             direction: edgeDirection.outboundEdge,
-        }), action_1.WriteOperation.Delete);
+            options,
+        }), action_1.WriteOperation.Delete, options?.conditional);
     }
     // this doesn't take a direction as that's an implementation detail
     // it doesn't make any sense to use the same edgeType for inbound and outbound edges
@@ -141,29 +193,39 @@ class Orchestrator {
             m.clear();
         }
     }
-    buildMainOp() {
+    buildMainOp(conditionalBuilder) {
         // this assumes we have validated fields
         switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
-                return new ent_1.DeleteNodeOperation(this.existingEnt.id, {
+                return new operations_1.DeleteNodeOperation(this.existingEnt.id, this.options.builder, {
                     tableName: this.options.tableName,
                 });
             default:
                 if (this.actualOperation === action_1.WriteOperation.Edit && !this.existingEnt) {
                     throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
+                if (this.options.expressions &&
+                    this.actualOperation !== action_1.WriteOperation.Edit) {
+                    throw new Error(`expressions are only supported in edit operations for now`);
+                }
                 const opts = {
                     fields: this.validatedFields,
                     tableName: this.options.tableName,
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
                     loadEntOptions: this.options.loaderOptions,
-                    placeholderID: this.options.builder.placeholderID,
+                    whereClause: clause.Eq(this.options.key, this.existingEnt?.id),
+                    expressions: this.options.expressions,
+                    onConflict: this.onConflict,
+                    builder: this.options.builder,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
                 }
-                this.mainOp = new ent_1.EditNodeOperation(opts, this.existingEnt);
+                this.mainOp = new operations_1.EditNodeOperation(opts, this.existingEnt);
+                if (conditionalBuilder) {
+                    this.mainOp = new operations_1.ConditionalNodeOperation(this.mainOp, conditionalBuilder);
+                }
                 return this.mainOp;
         }
     }
@@ -183,10 +245,10 @@ class Orchestrator {
                 throw new Error(`no nodeType for edge when adding outboundEdge`);
             }
             if (edge.direction === edgeDirection.outboundEdge) {
-                return ent_1.EdgeOperation.outboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
+                return operations_1.EdgeOperation.outboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
             }
             else {
-                return ent_1.EdgeOperation.inboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
+                return operations_1.EdgeOperation.inboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
             }
         }
         else if (op === action_1.WriteOperation.Delete) {
@@ -195,30 +257,55 @@ class Orchestrator {
             }
             let id2 = edge.id;
             if (edge.direction === edgeDirection.outboundEdge) {
-                return ent_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2, edge.options);
             }
             else {
-                return ent_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2, edge.options);
             }
         }
         throw new Error("could not find an edge operation from the given parameters");
     }
-    async buildEdgeOps(ops) {
+    async buildEdgeOps(ops, conditionalBuilder, conditionalOverride) {
         const edgeDatas = await (0, ent_1.loadEdgeDatas)(...Array.from(this.edgeSet.values()));
-        for (const [edgeType, m] of this.edges) {
-            for (const [op, m2] of m) {
-                for (const [_, edge] of m2) {
-                    let edgeOp = this.getEdgeOperation(edgeType, op, edge);
-                    ops.push(edgeOp);
-                    const edgeData = edgeDatas.get(edgeType);
-                    if (!edgeData) {
-                        throw new Error(`could not load edge data for ${edgeType}`);
-                    }
-                    if (edgeData.symmetricEdge) {
-                        ops.push(edgeOp.symmetricEdge());
-                    }
-                    if (edgeData.inverseEdgeType) {
-                        ops.push(edgeOp.inverseEdge(edgeData));
+        const edges = [
+            [this.edges, false],
+            [this.conditionalEdges, true],
+        ];
+        // conditional should only apply if onconflict...
+        // if no upsert and just create, nothing to do here
+        for (const edgeInfo of edges) {
+            const [edges, conditionalEdge] = edgeInfo;
+            const conditional = conditionalOverride || conditionalEdge;
+            for (const [edgeType, m] of edges) {
+                for (const [op, m2] of m) {
+                    for (const [_, edge] of m2) {
+                        let edgeOp = this.getEdgeOperation(edgeType, op, edge);
+                        if (conditional) {
+                            ops.push(new operations_1.ConditionalOperation(edgeOp, conditionalBuilder));
+                        }
+                        else {
+                            ops.push(edgeOp);
+                        }
+                        const edgeData = edgeDatas.get(edgeType);
+                        if (!edgeData) {
+                            throw new Error(`could not load edge data for '${edgeType}'`);
+                        }
+                        // similar logic in EntChangeset.changesetFromEdgeOp
+                        // doesn't support conditional edges
+                        if (edgeData.symmetricEdge) {
+                            let symmetric = edgeOp.symmetricEdge();
+                            if (conditional) {
+                                symmetric = new operations_1.ConditionalOperation(symmetric, conditionalBuilder);
+                            }
+                            ops.push(symmetric);
+                        }
+                        if (edgeData.inverseEdgeType) {
+                            let inverse = edgeOp.inverseEdge(edgeData);
+                            if (conditional) {
+                                inverse = new operations_1.ConditionalOperation(inverse, conditionalBuilder);
+                            }
+                            ops.push(inverse);
+                        }
                     }
                 }
             }
@@ -238,12 +325,50 @@ class Orchestrator {
         }
         return new EntCannotDeleteEntError(privacyPolicy, action, this.existingEnt);
     }
-    getEntForPrivacyPolicyImpl(editedData) {
+    async getRowForPrivacyPolicyImpl(schemaFields, editedData) {
+        // need to format fields if possible because ent constructors expect data that's
+        // in the format that's coming from the db
+        // required for object fields...
+        const formatted = { ...editedData };
+        for (const [fieldName, field] of schemaFields) {
+            if (!field.format) {
+                continue;
+            }
+            let dbKey = this.getStorageKey(fieldName);
+            let val = formatted[dbKey];
+            if (!val) {
+                continue;
+            }
+            if (field.valid) {
+                let valid = field.valid(val);
+                if ((0, types_1.isPromise)(valid)) {
+                    valid = await valid;
+                }
+                // if not valid, don't format and don't pass to ent?
+                // or just early throw here
+                if (!valid) {
+                    continue;
+                    // throw new Error(`invalid field ${fieldName} with value ${val}`);
+                }
+            }
+            // nested so it's not JSON stringified or anything like that
+            val = field.format(formatted[dbKey], true);
+            if ((0, types_1.isPromise)(val)) {
+                val = await val;
+            }
+            formatted[dbKey] = val;
+        }
+        return formatted;
+    }
+    async getEntForPrivacyPolicyImpl(schemaFields, editedData, viewerToUse, rowToUse) {
         if (this.actualOperation !== action_1.WriteOperation.Insert) {
             return this.existingEnt;
         }
+        if (!rowToUse) {
+            rowToUse = await this.getRowForPrivacyPolicyImpl(schemaFields, editedData);
+        }
         // we create an unsafe ent to be used for privacy policies
-        return new this.options.builder.ent(this.options.builder.viewer, editedData);
+        return new this.options.builder.ent(viewerToUse, rowToUse);
     }
     getSQLStatementOperation() {
         switch (this.actualOperation) {
@@ -273,8 +398,8 @@ class Orchestrator {
         if (this.actualOperation !== action_1.WriteOperation.Insert) {
             return this.existingEnt;
         }
-        const { editedData } = await this.memoizedGetFields();
-        return this.getEntForPrivacyPolicyImpl(editedData);
+        const { schemaFields, editedData } = await this.memoizedGetFields();
+        return this.getEntForPrivacyPolicyImpl(schemaFields, editedData, this.options.viewer);
     }
     // this gets the fields that were explicitly set plus any default or transformed values
     // mainly exists to get default fields e.g. default id to be used in triggers
@@ -284,15 +409,41 @@ class Orchestrator {
         const { editedData } = await this.memoizedGetFields();
         return editedData;
     }
+    /**
+     * @returns validated and formatted fields that would be written to the db
+     * throws an error if called before valid() or validX() has been called
+     */
+    getValidatedFields() {
+        if (this.validatedFields === null) {
+            throw new Error(`trying to call getValidatedFields before validating fields`);
+        }
+        return this.validatedFields;
+    }
     // Note: this is memoized. call memoizedGetFields instead
     async getFieldsInfo() {
         const action = this.options.action;
         const builder = this.options.builder;
         // future optimization: can get schemaFields to memoize based on different values
         const schemaFields = (0, schema_1.getFields)(this.options.schema);
+        // also future optimization, no need to go through the list of fields multiple times
+        let editPrivacyFields = new Map();
+        switch (this.actualOperation) {
+            case action_1.WriteOperation.Edit:
+                editPrivacyFields = (0, schema_1.getFieldsWithEditPrivacy)(this.options.schema, this.options.fieldInfo);
+                break;
+            case action_1.WriteOperation.Insert:
+                editPrivacyFields = (0, schema_1.getFieldsForCreateAction)(this.options.schema, this.options.fieldInfo);
+                break;
+        }
         const editedFields = await this.options.editedFields();
-        let editedData = await this.getFieldsWithDefaultValues(builder, schemaFields, editedFields, action);
-        return { editedData, editedFields, schemaFields };
+        let { data: editedData, userDefinedKeys } = await this.getFieldsWithDefaultValues(builder, schemaFields, editedFields, action);
+        return {
+            editedData,
+            editedFields,
+            schemaFields,
+            userDefinedKeys,
+            editPrivacyFields,
+        };
     }
     async validate() {
         // existing ent required for edit or delete operations
@@ -303,7 +454,7 @@ class Orchestrator {
                     throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
         }
-        const { schemaFields, editedData } = await this.memoizedGetFields();
+        const { schemaFields, editedData, userDefinedKeys, editPrivacyFields } = await this.memoizedGetFields();
         const action = this.options.action;
         const builder = this.options.builder;
         // this runs in following phases:
@@ -312,8 +463,40 @@ class Orchestrator {
         // * triggers
         // * validators
         let privacyPolicy = action?.getPrivacyPolicy();
+        const errors = [];
         if (privacyPolicy) {
-            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicyImpl(editedData), this.throwError.bind(this));
+            const ent = await this.getEntForPrivacyPolicyImpl(schemaFields, editedData, this.options.viewer);
+            try {
+                await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, ent, () => this.throwError());
+            }
+            catch (err) {
+                errors.push(err);
+            }
+        }
+        // we have edit privacy fields, so we need to apply privacy policy on those
+        const promises = [];
+        if (editPrivacyFields.size) {
+            // get row based on edited data
+            const row = await this.getRowForPrivacyPolicyImpl(schemaFields, editedData);
+            // get viewer for ent load based on formatted row
+            const viewer = await this.viewerForEntLoad(row);
+            const ent = await this.getEntForPrivacyPolicyImpl(schemaFields, editedData, viewer, row);
+            for (const [k, policy] of editPrivacyFields) {
+                if (editedData[k] === undefined || !userDefinedKeys.has(k)) {
+                    continue;
+                }
+                promises.push((async () => {
+                    const r = await (0, privacy_1.applyPrivacyPolicy)(viewer, policy, ent);
+                    if (!r) {
+                        errors.push(new EntCannotEditEntFieldError(policy, viewer, k, ent));
+                    }
+                })());
+            }
+            await Promise.all(promises);
+        }
+        // privacy or field errors should return first so it's less confusing
+        if (errors.length) {
+            return errors;
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
@@ -327,38 +510,70 @@ class Orchestrator {
         // not ideal we're calling this twice. fix...
         // needed for now. may need to rewrite some of this?
         const editedFields2 = await this.options.editedFields();
-        await Promise.all([
+        const [errs2, errs3] = await Promise.all([
             this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
+        errors.push(...errs2);
+        errors.push(...errs3);
+        return errors;
     }
     async triggers(action, builder, triggers) {
-        await Promise.all(triggers.map(async (trigger) => {
-            let ret = await trigger.changeset(builder, action.getInput());
-            if (Array.isArray(ret)) {
-                ret = await Promise.all(ret);
-            }
-            if (Array.isArray(ret)) {
-                for (const v of ret) {
-                    if (typeof v === "object") {
-                        this.changesets.push(v);
-                    }
+        let groups = [];
+        let lastArray = 0;
+        let prevWasArray = false;
+        for (let i = 0; i < triggers.length; i++) {
+            let t = triggers[i];
+            if (Array.isArray(t)) {
+                if (!prevWasArray) {
+                    // @ts-ignore
+                    groups.push(triggers.slice(lastArray, i));
                 }
+                groups.push(t);
+                prevWasArray = true;
+                lastArray++;
             }
-            else if (ret) {
-                this.changesets.push(ret);
+            else {
+                if (i === triggers.length - 1) {
+                    // @ts-ignore
+                    groups.push(triggers.slice(lastArray, i + 1));
+                }
+                prevWasArray = false;
             }
-        }));
+        }
+        for (const triggers of groups) {
+            await Promise.all(triggers.map(async (trigger) => {
+                let ret = await trigger.changeset(builder, action.getInput());
+                if (Array.isArray(ret)) {
+                    ret = await Promise.all(ret);
+                }
+                if (Array.isArray(ret)) {
+                    for (const v of ret) {
+                        if (typeof v === "object") {
+                            this.changesets.push(v);
+                        }
+                    }
+                }
+                else if (ret) {
+                    this.changesets.push(ret);
+                }
+            }));
+        }
     }
     async validators(validators, action, builder) {
-        let promises = [];
-        validators.forEach((validator) => {
-            let res = validator.validate(builder, action.getInput());
-            if (res) {
-                promises.push(res);
+        const errors = [];
+        await Promise.all(validators.map(async (v) => {
+            try {
+                const r = await v.validate(builder, action.getInput());
+                if (r instanceof Error) {
+                    errors.push(r);
+                }
+            }
+            catch (err) {
+                errors.push(err);
             }
-        });
-        await Promise.all(promises);
+        }));
+        return errors;
     }
     isBuilder(val) {
         return val.placeholderID !== undefined;
@@ -379,23 +594,31 @@ class Orchestrator {
         // if disable transformations set, don't do schema transform and just do the right thing
         // else apply schema tranformation if it exists
         let transformed = null;
+        const sqlOp = this.getSQLStatementOperation();
+        // why is transform write technically different from upsert?
+        // it's create -> update just at the db level...
         if (action?.transformWrite) {
             transformed = await action.transformWrite({
-                viewer: builder.viewer,
-                op: this.getSQLStatementOperation(),
+                builder,
+                input,
+                op: sqlOp,
                 data: editedFields,
-                existingEnt: this.existingEnt,
             });
         }
         else if (!this.disableTransformations) {
             transformed = (0, schema_1.getTransformedUpdateOp)(this.options.schema, {
-                viewer: builder.viewer,
-                op: this.getSQLStatementOperation(),
+                builder,
+                input,
+                op: sqlOp,
                 data: editedFields,
-                existingEnt: this.existingEnt,
             });
         }
         if (transformed) {
+            if (sqlOp === schema_1.SQLStatementOperation.Insert && sqlOp !== transformed.op) {
+                if (!transformed.existingEnt) {
+                    throw new Error(`cannot transform an insert operation without providing an existing ent`);
+                }
+            }
             if (transformed.data) {
                 updateInput = true;
                 for (const k in transformed.data) {
@@ -414,18 +637,29 @@ class Orchestrator {
                     // this.defaultFieldsByFieldName[k] = val;
                 }
             }
+            if (transformed.changeset) {
+                const changeset = await transformed.changeset();
+                this.changesets.push(changeset);
+            }
             this.actualOperation = this.getWriteOpForSQLStamentOp(transformed.op);
             if (transformed.existingEnt) {
                 // @ts-ignore
                 this.existingEnt = transformed.existingEnt;
+                // modify existing ent in builder. it's readonly in generated ents but doesn't apply here
+                builder.existingEnt = transformed.existingEnt;
             }
         }
         // transforming before doing default fields so that we don't create a new id
         // and anything that depends on the type of operations knows what it is
+        const userDefinedKeys = new Set();
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
             let defaultValue = undefined;
             let dbKey = this.getStorageKey(fieldName);
+            let updateOnlyIfOther = field.onlyUpdateIfOtherFieldsBeingSet_BETA;
+            if (value !== undefined) {
+                userDefinedKeys.add(dbKey);
+            }
             if (value === undefined) {
                 if (this.actualOperation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
@@ -439,11 +673,17 @@ class Orchestrator {
                         if (defaultValue === undefined) {
                             throw new Error(`defaultValueOnCreate() returned undefined for field ${fieldName}`);
                         }
+                        if ((0, types_1.isPromise)(defaultValue)) {
+                            defaultValue = await defaultValue;
+                        }
                     }
                 }
                 if (field.defaultValueOnEdit &&
                     this.actualOperation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
+                    if ((0, types_1.isPromise)(defaultValue)) {
+                        defaultValue = await defaultValue;
+                    }
                 }
             }
             if (value !== undefined) {
@@ -451,7 +691,12 @@ class Orchestrator {
             }
             if (defaultValue !== undefined) {
                 updateInput = true;
-                defaultData[dbKey] = defaultValue;
+                if (updateOnlyIfOther) {
+                    defaultData[dbKey] = defaultValue;
+                }
+                else {
+                    data[dbKey] = defaultValue;
+                }
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 this.defaultFieldsByTSName[this.getInputKey(fieldName)] = defaultValue;
             }
@@ -467,7 +712,7 @@ class Orchestrator {
                 this.options.updateInput(this.defaultFieldsByTSName);
             }
         }
-        return data;
+        return { data, userDefinedKeys };
     }
     hasData(data) {
         for (const _k in data) {
@@ -479,7 +724,7 @@ class Orchestrator {
         // now format and validate...
         if (value === null) {
             if (!field.nullable) {
-                throw new Error(`field ${fieldName} set to null for non-nullable field`);
+                return new Error(`field ${fieldName} set to null for non-nullable field`);
             }
         }
         else if (value === undefined) {
@@ -490,14 +735,17 @@ class Orchestrator {
                 // server default allowed
                 field.serverDefault === undefined &&
                 this.actualOperation === action_1.WriteOperation.Insert) {
-                throw new Error(`required field ${fieldName} not set`);
+                return new Error(`required field ${fieldName} not set`);
             }
         }
         else if (this.isBuilder(value)) {
             if (field.valid) {
-                const valid = await field.valid(value);
+                let valid = field.valid(value);
+                if ((0, types_1.isPromise)(valid)) {
+                    valid = await valid;
+                }
                 if (!valid) {
-                    throw new Error(`invalid field ${fieldName} with value ${value}`);
+                    return new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             // keep track of dependencies to resolve
@@ -507,10 +755,12 @@ class Orchestrator {
         }
         else {
             if (field.valid) {
-                // TODO this could be async. handle this better
-                const valid = await field.valid(value);
+                let valid = field.valid(value);
+                if ((0, types_1.isPromise)(valid)) {
+                    valid = await valid;
+                }
                 if (!valid) {
-                    throw new Error(`invalid field ${fieldName} with value ${value}`);
+                    return new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             if (field.format) {
@@ -520,26 +770,52 @@ class Orchestrator {
         return value;
     }
     async formatAndValidateFields(schemaFields, editedFields) {
+        const errors = [];
         const op = this.actualOperation;
         if (op === action_1.WriteOperation.Delete) {
-            return;
+            return [];
         }
         // build up data to be saved...
         let data = {};
         let logValues = {};
+        let needsFullDataChecks = [];
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
+            if (field.validateWithFullData) {
+                needsFullDataChecks.push(fieldName);
+            }
             if (value === undefined && op === action_1.WriteOperation.Insert) {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
             let dbKey = this.getStorageKey(fieldName);
-            value = await this.transformFieldValue(fieldName, field, dbKey, value);
+            let ret = await this.transformFieldValue(fieldName, field, dbKey, value);
+            if (ret instanceof Error) {
+                errors.push(ret);
+            }
+            else {
+                value = ret;
+            }
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        for (const fieldName of needsFullDataChecks) {
+            const field = schemaFields.get(fieldName);
+            let value = editedFields.get(fieldName);
+            // @ts-ignore...
+            // type hackery because it's hard
+            const v = await field.validateWithFullData(value, this.options.builder);
+            if (!v) {
+                if (value === undefined) {
+                    errors.push(new Error(`field ${fieldName} set to undefined when it can't be nullable`));
+                }
+                else {
+                    errors.push(new Error(`field ${fieldName} set to null when it can't be nullable`));
+                }
+            }
+        }
         //  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)) {
@@ -549,41 +825,73 @@ class Orchestrator {
                 let dbKey = this.getStorageKey(fieldName);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
-                    const value = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
-                    data[dbKey] = value;
-                    logValues[dbKey] = field.logValue(value);
+                    const ret = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
+                    if (ret instanceof Error) {
+                        errors.push(ret);
+                    }
+                    else {
+                        data[dbKey] = ret;
+                        logValues[dbKey] = field.logValue(ret);
+                    }
                 }
             }
         }
         this.validatedFields = data;
         this.logValues = logValues;
+        return errors;
     }
     async valid() {
-        try {
-            await this.validate();
-        }
-        catch (e) {
-            (0, logger_1.log)("error", e);
+        const errors = await this.validate();
+        if (errors.length) {
+            errors.map((err) => (0, logger_1.log)("error", err));
             return false;
         }
         return true;
     }
     async validX() {
+        const errors = await this.validate();
+        if (errors.length) {
+            // just throw the first one...
+            // TODO we should ideally throw all of them
+            throw errors[0];
+        }
+    }
+    /**
+     * @experimental API that's not guaranteed to remain in the future which returns
+     * a list of errors encountered
+     * 0 errors indicates valid
+     * NOTE that this currently doesn't catch errors returned by validators().
+     * If those throws, this still throws and doesn't return them
+     */
+    async validWithErrors() {
         return this.validate();
     }
-    async build() {
+    async buildPlusChangeset(conditionalBuilder, conditionalOverride) {
         // validate everything first
         await this.validX();
-        let ops = [this.buildMainOp()];
-        await this.buildEdgeOps(ops);
-        return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
+        let ops = [
+            this.buildMainOp(conditionalOverride ? conditionalBuilder : undefined),
+        ];
+        await this.buildEdgeOps(ops, conditionalBuilder, conditionalOverride);
+        // TODO throw if we try and create a new changeset after previously creating one
+        // TODO test actualOperation value
+        // observers is fine since they're run after and we have the actualOperation value...
+        return new EntChangeset(this.options.viewer, this.options.builder, this.options.builder.placeholderID, conditionalOverride, ops, this.dependencies, this.changesets, this.options);
+    }
+    async build() {
+        return this.buildPlusChangeset(this.options.builder, false);
+    }
+    async buildWithOptions_BETA(options) {
+        // set as dependency so that we do the right order of operations
+        this.dependencies.set(options.conditionalBuilder.placeholderID, options.conditionalBuilder);
+        return this.buildPlusChangeset(options.conditionalBuilder, true);
     }
     async viewerForEntLoad(data) {
         const action = this.options.action;
         if (!action || !action.viewerForEntLoad) {
             return this.options.viewer;
         }
-        return action.viewerForEntLoad(data);
+        return action.viewerForEntLoad(data, action.builder.viewer.context);
     }
     async returnedRow() {
         if (this.mainOp && this.mainOp.returnedRow) {
@@ -618,16 +926,62 @@ class Orchestrator {
     }
 }
 exports.Orchestrator = Orchestrator;
+function randomNum() {
+    return Math.random().toString(10).substring(2);
+}
+// each changeset is required to have a unique placeholderID
+// used in executor. if we end up creating multiple changesets from a builder, we need
+// different placeholders
+// in practice, only applies to Entchangeset::changesetFrom()
 class EntChangeset {
-    constructor(viewer, placeholderID, ent, operations, dependencies, changesets, options) {
+    constructor(viewer, builder, placeholderID, conditionalOverride, operations, dependencies, changesets, options) {
         this.viewer = viewer;
+        this.builder = builder;
         this.placeholderID = placeholderID;
-        this.ent = ent;
+        this.conditionalOverride = conditionalOverride;
         this.operations = operations;
         this.dependencies = dependencies;
         this.changesets = changesets;
         this.options = options;
     }
+    static changesetFrom(builder, ops) {
+        return new EntChangeset(builder.viewer, builder, 
+        // need unique placeholderID different from the builder. see comment above EntChangeset
+        `$ent.idPlaceholderID$ ${randomNum()}-${builder.ent.name}`, false, ops);
+    }
+    static changesetFromQueries(builder, queries) {
+        return EntChangeset.changesetFrom(builder, [
+            new operations_2.RawQueryOperation(builder, queries),
+        ]);
+    }
+    static async changesetFromEdgeOp(builder, op, edgeType) {
+        const edgeData = await (0, ent_1.loadEdgeData)(edgeType);
+        const ops = [op];
+        if (!edgeData) {
+            throw new Error(`could not load edge data for '${edgeType}'`);
+        }
+        // similar logic in Orchestrator.buildEdgeOps
+        // doesn't support conditional edges
+        if (edgeData.symmetricEdge) {
+            ops.push(op.symmetricEdge());
+        }
+        if (edgeData.inverseEdgeType) {
+            ops.push(op.inverseEdge(edgeData));
+        }
+        return EntChangeset.changesetFrom(builder, ops);
+    }
+    static async changesetFromOutboundEdge(builder, edgeType, id2, nodeType, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.outboundEdge(builder, edgeType, id2, nodeType, options), edgeType);
+    }
+    static async changesetFromInboundEdge(builder, edgeType, id1, nodeType, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.inboundEdge(builder, edgeType, id1, nodeType, options), edgeType);
+    }
+    static changesetRemoveFromOutboundEdge(builder, edgeType, id2, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.removeOutboundEdge(builder, edgeType, id2, options), edgeType);
+    }
+    static changesetRemoveFromInboundEdge(builder, edgeType, id1, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.removeInboundEdge(builder, edgeType, id1, options), edgeType);
+    }
     executor() {
         if (this._executor) {
             return this._executor;
@@ -637,9 +991,15 @@ class EntChangeset {
             // 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));
+            return (this._executor = new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.operations, this.options, {
+                conditionalOverride: this.conditionalOverride,
+                builder: this.builder,
+            }));
+        }
+        return (this._executor = new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.operations, this.dependencies || new Map(), this.changesets || [], this.options, {
+            conditionalOverride: this.conditionalOverride,
+            builder: this.builder,
+        }));
     }
 }
 exports.EntChangeset = EntChangeset;