@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha150

package/action/action.d.ts

@@ -1,27 +1,34 @@
-import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context } from "../core/base";
-import { DataOperation, AssocEdgeInputOptions } from "../core/ent";
+import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context, WriteOperation } from "../core/base";
+import { DataOperation, AssocEdgeInputOptions } from "./operations";
 import { Queryer } from "../core/db";
 import { TransformedUpdateOperation, UpdateOperation } from "../schema";
-export declare enum WriteOperation {
-    Insert = "insert",
-    Edit = "edit",
-    Delete = "delete"
+import { FieldInfoMap } from "../schema/schema";
+export { WriteOperation };
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+interface BuilderOrchestrator {
+    __getOptions(): {
+        fieldInfo: FieldInfoMap;
+    };
 }
-declare type MaybeNull<T extends Ent> = T | null;
-declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
 export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     existingEnt: TExistingEnt;
     ent: EntConstructor<TEnt, TViewer>;
     placeholderID: ID;
     readonly viewer: TViewer;
     build(): Promise<Changeset>;
+    buildWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
     operation: WriteOperation;
     editedEnt?(): Promise<TEnt | null>;
     nodeType: string;
+    getInput(): Data;
+    orchestrator: BuilderOrchestrator;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
     placeholderID: ID;
     resolveValue(val: any): Ent | null;
+    builderOpChanged(builder: Builder<any>): boolean;
+    builder?: Builder<Ent>;
     execute(): Promise<void>;
     preFetch?(queryer: Queryer, context?: Context): Promise<void>;
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
@@ -34,7 +41,7 @@ export interface Changeset {
     changesets?: Changeset[];
     dependencies?: Map<ID, Builder<Ent>>;
 }
-export declare type TriggerReturn = void | Promise<Changeset | void | (Changeset | void)[]> | Promise<Changeset>[];
+export type TriggerReturn = void | Promise<Changeset | void | (Changeset | void)[]> | Promise<Changeset>[];
 export interface Trigger<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     changeset(builder: TBuilder, input: TInput): TriggerReturn;
 }
@@ -42,21 +49,25 @@ export interface Observer<TEnt extends Ent<TViewer>, TBuilder extends Builder<TE
     observe(builder: TBuilder, input: TInput): void | Promise<void>;
 }
 export interface Validator<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
-    validate(builder: TBuilder, input: TInput): Promise<void> | void;
+    validate(builder: TBuilder, input: TInput): Promise<void | undefined | Error> | void | Error | undefined;
+}
+export interface ChangesetOptions {
+    conditionalBuilder: Builder<any, any>;
 }
 export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     readonly viewer: Viewer;
     changeset(): Promise<Changeset>;
+    changesetWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    triggers?: Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    observers?: Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    validators?: Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getTriggers?(): (Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt> | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[])[];
+    getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
     getInput(): TInput;
-    transformWrite?: (stmt: UpdateOperation<TEnt>) => Promise<TransformedUpdateOperation<TEnt>> | TransformedUpdateOperation<TEnt> | null;
+    transformWrite?: (stmt: UpdateOperation<TEnt, TViewer>) => Promise<TransformedUpdateOperation<TEnt, TViewer>> | TransformedUpdateOperation<TEnt, TViewer> | null;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
-    viewerForEntLoad?(data: Data): TViewer | Promise<TViewer>;
+    viewerForEntLoad?(data: Data, context?: Context<TViewer>): TViewer | Promise<TViewer>;
 }
 export declare function saveBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer>(builder: Builder<TEnt, TViewer>): Promise<void>;
 export declare function saveBuilderX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(builder: Builder<TEnt, TViewer>): Promise<void>;
@@ -66,4 +77,4 @@ interface Orchestrator {
     viewer: Viewer;
 }
 export declare function setEdgeTypeInGroup<T extends string>(orchestrator: Orchestrator, inputEnumValue: string, id1: ID, id2: ID, nodeType: string, m: Map<T, string>): Promise<void>;
-export {};
+export declare function clearEdgeTypeInGroup<T extends string>(orchestrator: Orchestrator, id1: ID, id2: ID, m: Map<T, string>): Promise<void>;

package/action/action.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+exports.clearEdgeTypeInGroup = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+const base_1 = require("../core/base");
+Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return base_1.WriteOperation; } });
 const ent_1 = require("../core/ent");
 const logger_1 = require("../core/logger");
-var WriteOperation;
-(function (WriteOperation) {
-    WriteOperation["Insert"] = "insert";
-    WriteOperation["Edit"] = "edit";
-    WriteOperation["Delete"] = "delete";
-})(WriteOperation = exports.WriteOperation || (exports.WriteOperation = {}));
 async function saveBuilder(builder) {
     await saveBuilderImpl(builder, false);
 }
@@ -88,3 +84,22 @@ async function setEdgeTypeInGroup(orchestrator, inputEnumValue, id1, id2, nodeTy
     await Promise.all(promises);
 }
 exports.setEdgeTypeInGroup = setEdgeTypeInGroup;
+async function clearEdgeTypeInGroup(orchestrator, id1, id2, m) {
+    let promises = [];
+    for (const [_, edgeType] of m) {
+        promises.push((async () => {
+            let edge = await (0, ent_1.loadEdgeForID2)({
+                id1,
+                id2,
+                edgeType,
+                ctr: ent_1.AssocEdge,
+                context: orchestrator.viewer.context,
+            });
+            if (edge) {
+                orchestrator.removeOutboundEdge(id2, edgeType);
+            }
+        })());
+    }
+    await Promise.all(promises);
+}
+exports.clearEdgeTypeInGroup = clearEdgeTypeInGroup;

package/action/executor.d.ts

@@ -1,19 +1,23 @@
 import { ID, Ent, Viewer, Context, Data } from "../core/base";
-import { DataOperation } from "../core/ent";
 import { Changeset, Executor } from "../action/action";
 import { Builder } from "../action";
 import { OrchestratorOptions } from "./orchestrator";
 import { Queryer } from "../core/db";
+import { DataOperation } from "./operations";
 export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private viewer;
     placeholderID: ID;
     private operations;
     private options?;
+    private complexOptions?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Viewer<Ent<any> | null, ID | null>, Data, T | null> | undefined);
+    builder?: Builder<Ent> | undefined;
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, T | null> | undefined, complexOptions?: ComplexExecutorOptions | undefined);
     private lastOp;
     private createdEnt;
+    private updatedOps;
     resolveValue(val: ID): Ent | null;
+    builderOpChanged(builder: Builder<any>): boolean;
     [Symbol.iterator](): this;
     next(): IteratorResult<DataOperation<T>>;
     executeObservers(): Promise<void>;
@@ -21,22 +25,31 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     preFetch?(queryer: Queryer, context: Context): Promise<void>;
     postFetch?(queryer: Queryer, context: Context): Promise<void>;
 }
+interface ComplexExecutorOptions {
+    conditionalOverride: boolean;
+    builder: Builder<any, any>;
+}
 export declare class ComplexExecutor<T extends Ent> implements Executor {
     private viewer;
     placeholderID: ID;
+    private complexOptions?;
     private idx;
     private mapper;
     private lastOp;
     private allOperations;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Viewer, Data>);
+    private updatedOps;
+    builder?: Builder<Ent> | undefined;
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
     resolveValue(val: ID): Ent | null;
+    builderOpChanged(builder: Builder<any>): boolean;
     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<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;
+export {};

package/action/executor.js

@@ -4,18 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeOperations = exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
-const graph_data_structure_1 = __importDefault(require("graph-data-structure"));
+const graph_data_structure_1 = require("graph-data-structure");
+const ent_1 = require("../core/ent");
 const db_1 = __importDefault(require("../core/db"));
 const logger_1 = require("../core/logger");
+const operations_1 = require("./operations");
 // private to ent
 class ListBasedExecutor {
-    constructor(viewer, placeholderID, operations, options) {
+    constructor(viewer, placeholderID, operations, options, complexOptions) {
         this.viewer = viewer;
         this.placeholderID = placeholderID;
         this.operations = operations;
         this.options = options;
+        this.complexOptions = complexOptions;
         this.idx = 0;
         this.createdEnt = null;
+        this.updatedOps = new Map();
+        this.builder = options?.builder;
     }
     resolveValue(val) {
         if (val === this.placeholderID && val !== undefined) {
@@ -23,6 +28,10 @@ class ListBasedExecutor {
         }
         return null;
     }
+    builderOpChanged(builder) {
+        const v = this.updatedOps.get(builder.placeholderID);
+        return v !== undefined && v !== builder.operation;
+    }
     [Symbol.iterator]() {
         return this;
     }
@@ -32,13 +41,15 @@ class ListBasedExecutor {
         if (createdEnt) {
             this.createdEnt = createdEnt;
         }
+        maybeUpdateOperationForOp(this.lastOp, this.updatedOps);
         const done = this.idx === this.operations.length;
-        const op = this.operations[this.idx];
+        const op = changeOp(this.operations[this.idx], this.complexOptions);
         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;
+            // TODO need to figure this out
+            // this.idx = 0;
         }
         return {
             value: op,
@@ -47,12 +58,18 @@ class ListBasedExecutor {
     }
     async executeObservers() {
         const action = this.options?.action;
-        if (!this.options || !action || !action.observers) {
+        if (!this.options || !action || !action.getObservers) {
             return;
         }
         const builder = this.options.builder;
-        await Promise.all(action.observers.map(async (observer) => {
-            await observer.observe(builder, action.getInput());
+        await Promise.all(action.getObservers().map(async (observer) => {
+            try {
+                await observer.observe(builder, action.getInput());
+            }
+            catch (err) {
+                // TODO we eventually want a global observer error handler so that this can be logged or whatever...
+                // TODO https://github.com/lolopinto/ent/issues/1429
+            }
         }));
     }
     async execute() {
@@ -84,21 +101,35 @@ function getCreatedEnt(viewer, op) {
     }
     return null;
 }
+function maybeUpdateOperationForOp(op, updatedOps) {
+    if (!op || !op.updatedOperation) {
+        return;
+    }
+    const r = op.updatedOperation();
+    if (!r || r.builder.operation === r.operation) {
+        return;
+    }
+    updatedOps.set(r.builder.placeholderID, r.operation);
+    // console.debug(updatedOps);
+}
 class ComplexExecutor {
-    constructor(viewer, placeholderID, operations, dependencies, changesets, options) {
+    constructor(viewer, placeholderID, operations, dependencies, changesets, options, complexOptions) {
         this.viewer = viewer;
         this.placeholderID = placeholderID;
+        this.complexOptions = complexOptions;
         this.idx = 0;
         this.mapper = new Map();
         this.allOperations = [];
         this.executors = [];
-        let graph = (0, graph_data_structure_1.default)();
+        this.updatedOps = new Map();
+        this.builder = options?.builder;
+        let graph = (0, graph_data_structure_1.Graph)();
         const changesetMap = new Map();
         const impl = (c) => {
             changesetMap.set(c.placeholderID.toString(), c);
             graph.addNode(c.placeholderID.toString());
             if (c.dependencies) {
-                for (let [key, builder] of c.dependencies) {
+                for (let [_, builder] of c.dependencies) {
                     // dependency should go first...
                     graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString(), 1);
                 }
@@ -140,6 +171,11 @@ class ComplexExecutor {
             // get ordered list of ops
             let executor = c.executor();
             for (let op of executor) {
+                if (!op) {
+                    // TODO what is happening...
+                    // change in behavior in next() leading to needing to do this
+                    break;
+                }
                 if (op.createdEnt) {
                     nodeOps.add(op);
                 }
@@ -170,25 +206,23 @@ class ComplexExecutor {
         }
         const placeholderID = this.lastOp.placeholderID;
         if (!placeholderID) {
-            console.error(`op ${this.lastOp} which implements getCreatedEnt doesn't have a placeholderID`);
-            return;
+            throw new Error(`op ${this.lastOp} which implements getCreatedEnt doesn't have a placeholderID`);
         }
         this.mapper.set(placeholderID, createdEnt);
     }
     next() {
         this.handleCreatedEnt();
+        maybeUpdateOperationForOp(this.lastOp, this.updatedOps);
         const done = this.idx === this.allOperations.length;
-        const op = this.allOperations[this.idx];
+        const op = changeOp(this.allOperations[this.idx], this.complexOptions);
         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;
+            // TODO need to figure this out
+            // this.idx = 0;
         }
-        return {
-            value: op,
-            done: done,
-        };
+        return { value: op, done };
     }
     resolveValue(val) {
         let ent = this.mapper.get(val);
@@ -203,8 +237,16 @@ class ComplexExecutor {
         }
         return null;
     }
+    builderOpChanged(builder) {
+        const v = this.updatedOps.get(builder.placeholderID);
+        // console.debug(this.updatedOps, builder.placeholderID, v, builder.operation);
+        return v !== undefined && v !== builder.operation;
+    }
     async executeObservers() {
         await Promise.all(this.executors.map((executor) => {
+            if (executor.builder && this.builderOpChanged(executor.builder)) {
+                return null;
+            }
             if (!executor.executeObservers) {
                 return null;
             }
@@ -247,6 +289,9 @@ async function executeOperations(executor, context, trackOps) {
         if (isSyncClient(client)) {
             client.runInTransaction(() => {
                 for (const operation of executor) {
+                    if (operation.shortCircuit && operation.shortCircuit(executor)) {
+                        continue;
+                    }
                     if (trackOps) {
                         operations.push(operation);
                     }
@@ -258,8 +303,12 @@ async function executeOperations(executor, context, trackOps) {
             });
         }
         else {
+            (0, ent_1.logQuery)("BEGIN", []);
             await client.query("BEGIN");
             for (const operation of executor) {
+                if (operation.shortCircuit && operation.shortCircuit(executor)) {
+                    continue;
+                }
                 if (trackOps) {
                     operations.push(operation);
                 }
@@ -269,25 +318,43 @@ async function executeOperations(executor, context, trackOps) {
                 }
                 await operation.performWrite(client, context);
             }
+            (0, ent_1.logQuery)("COMMIT", []);
             await client.query("COMMIT");
         }
         if (executor.postFetch) {
             await executor.postFetch(client, context);
         }
-        if (executor.executeObservers) {
-            await executor.executeObservers();
-        }
+        client.release();
     }
     catch (e) {
         if (!isSyncClient(client)) {
+            // TODO these changes break tests
+            (0, ent_1.logQuery)("ROLLBACK", []);
             await client.query("ROLLBACK");
         }
+        client.release(e);
         (0, logger_1.log)("error", e);
         throw e;
     }
-    finally {
-        client.release();
+    if (executor.executeObservers) {
+        try {
+            await executor.executeObservers();
+        }
+        catch (e) { }
     }
     return operations;
 }
 exports.executeOperations = executeOperations;
+function changeOp(op, complexOptions) {
+    if (!op ||
+        !complexOptions?.conditionalOverride ||
+        op instanceof operations_1.ConditionalNodeOperation) {
+        return op;
+    }
+    if (op.createdEnt) {
+        return new operations_1.ConditionalNodeOperation(op, complexOptions.builder);
+    }
+    else {
+        return new operations_1.ConditionalOperation(op, complexOptions.builder);
+    }
+}

package/action/experimental_action.d.ts

@@ -1,11 +1,14 @@
+import { Orchestrator } from "./orchestrator";
 import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
-export interface ActionOptions<T extends Ent, TData extends Data> {
-    existingEnt?: T | null;
+export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    existingEnt: TExistingEnt;
     input?: TData;
     operation?: WriteOperation;
 }
-interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> extends Builder<TEnt, TViewer> {
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> extends Builder<TEnt, TViewer, TExistingEnt> {
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<void>;
@@ -13,19 +16,23 @@ interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput e
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
     getInput(): TInput;
+    orchestrator: Orchestrator<TEnt, TInput, TViewer, TExistingEnt>;
 }
-export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput> {
+export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt> {
     viewer: TViewer;
-    builderCtr: BuilderConstructor<TEnt, TViewer, TInput>;
-    builder: EntBuilder<TEnt, TViewer, TInput>;
+    builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>;
+    builder: EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
     private input;
-    triggers: Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    observers: Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    validators: Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
-    constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null);
-    static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null): Builder<TEnt>;
-    static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput>;
+    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>);
+    static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>): Builder<TEnt>;
+    /**
+     * @deprecated use Transaction
+     */
+    static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput, TEnt>;
     changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
@@ -33,9 +40,11 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     saveX(): Promise<TEnt>;
     getInput(): TInput;
 }
-interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> {
-    new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>, existingEnt: TEnt | null): EntBuilder<TEnt, TViewer, TInput>;
+export interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, any, TViewer, TInput, TExistingEnt>, existingEnt: TExistingEnt): EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
 }
-export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
-export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
+export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleDeleteAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleInsertAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, null>, input: TInput): BaseAction<TEnt, TViewer, TInput, null>;
 export {};

package/action/experimental_action.js

@@ -1,15 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
+exports.getSimpleInsertAction = exports.getSimpleDeleteAction = exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
+    getPrivacyPolicy() {
+        return privacy_1.AlwaysAllowPrivacyPolicy;
+    }
+    getTriggers() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
-        this.triggers = [];
-        this.observers = [];
-        this.validators = [];
         let operation = options?.operation;
         if (!operation) {
             if (options?.existingEnt) {
@@ -20,10 +29,7 @@ class BaseAction {
             }
         }
         this.input = options?.input || {};
-        this.builder = new builderCtr(viewer, operation, this, options?.existingEnt || null);
-    }
-    getPrivacyPolicy() {
-        return privacy_1.AlwaysAllowPrivacyPolicy;
+        this.builder = new builderCtr(viewer, operation, this, options.existingEnt);
     }
     static createBuilder(viewer, builderCtr, options) {
         let action = new BaseAction(viewer, builderCtr, options);
@@ -31,11 +37,14 @@ class BaseAction {
     }
     // perform a bulk action in a transaction rooted on ent T
     // it ends up creating triggers and having all the given actions performed in a transaction
+    /**
+     * @deprecated use Transaction
+     */
     static bulkAction(ent, builderCtr, ...actions) {
         let action = new BaseAction(ent.viewer, builderCtr, {
             existingEnt: ent,
         });
-        action.triggers = [
+        action.getTriggers = () => [
             {
                 changeset: () => {
                     return actions.map((action) => action.changeset());
@@ -79,6 +88,7 @@ async function updateRawObject(viewer, builderCtr, existingEnt, input) {
     return action.saveX();
 }
 exports.updateRawObject = updateRawObject;
+// TODO need to fix types for all these
 // 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
@@ -91,3 +101,19 @@ function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
     });
 }
 exports.getSimpleEditAction = getSimpleEditAction;
+function getSimpleDeleteAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Delete,
+        input,
+    });
+}
+exports.getSimpleDeleteAction = getSimpleDeleteAction;
+function getSimpleInsertAction(viewer, builderCtr, input) {
+    return new BaseAction(viewer, builderCtr, {
+        operation: action_1.WriteOperation.Insert,
+        input,
+        existingEnt: null,
+    });
+}
+exports.getSimpleInsertAction = getSimpleInsertAction;

package/action/index.d.ts

@@ -1,3 +1,5 @@
-export { WriteOperation, Builder, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, } from "./action";
+export { WriteOperation, Builder, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, ChangesetOptions, } from "./action";
 export { OrchestratorOptions, Orchestrator, EntChangeset, EdgeInputData, } from "./orchestrator";
 export { DenyIfBuilder, AllowIfBuilder } from "./privacy";
+export { RelativeFieldValue, RelativeNumberValue, NumberOps, convertRelativeInput, maybeConvertRelativeInputPlusExpressions, } from "./relative_value";
+export { Transaction } from "./transaction";

package/action/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfBuilder = exports.DenyIfBuilder = exports.EntChangeset = exports.Orchestrator = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+exports.Transaction = exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = exports.AllowIfBuilder = exports.DenyIfBuilder = exports.EntChangeset = exports.Orchestrator = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
 var action_1 = require("./action");
 Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return action_1.WriteOperation; } });
 Object.defineProperty(exports, "saveBuilder", { enumerable: true, get: function () { return action_1.saveBuilder; } });
@@ -12,3 +12,9 @@ Object.defineProperty(exports, "EntChangeset", { enumerable: true, get: function
 var privacy_1 = require("./privacy");
 Object.defineProperty(exports, "DenyIfBuilder", { enumerable: true, get: function () { return privacy_1.DenyIfBuilder; } });
 Object.defineProperty(exports, "AllowIfBuilder", { enumerable: true, get: function () { return privacy_1.AllowIfBuilder; } });
+var relative_value_1 = require("./relative_value");
+Object.defineProperty(exports, "NumberOps", { enumerable: true, get: function () { return relative_value_1.NumberOps; } });
+Object.defineProperty(exports, "convertRelativeInput", { enumerable: true, get: function () { return relative_value_1.convertRelativeInput; } });
+Object.defineProperty(exports, "maybeConvertRelativeInputPlusExpressions", { enumerable: true, get: function () { return relative_value_1.maybeConvertRelativeInputPlusExpressions; } });
+var transaction_1 = require("./transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });