@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/action/action.d.ts

@@ -1,5 +1,5 @@
 import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context, WriteOperation } from "../core/base";
-import { DataOperation, AssocEdgeInputOptions } from "../core/ent";
+import { DataOperation, AssocEdgeInputOptions } from "./operations";
 import { Queryer } from "../core/db";
 import { TransformedUpdateOperation, UpdateOperation } from "../schema";
 import { FieldInfoMap } from "../schema/schema";
@@ -17,6 +17,7 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
     placeholderID: ID;
     readonly viewer: TViewer;
     build(): Promise<Changeset>;
+    buildWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
     operation: WriteOperation;
     editedEnt?(): Promise<TEnt | null>;
     nodeType: string;
@@ -26,6 +27,8 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
 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>;
@@ -48,9 +51,13 @@ export interface Observer<TEnt extends Ent<TViewer>, TBuilder extends Builder<TE
 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 | 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>;
     getTriggers?(): (Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt> | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[])[];

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, Data, Viewer<Ent<any> | null, ID | null>, 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 changedOps;
     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, Data, Viewer>);
+    private changedOps;
+    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,19 +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.changedOps = new Map();
+        this.builder = options?.builder;
     }
     resolveValue(val) {
         if (val === this.placeholderID && val !== undefined) {
@@ -24,6 +28,10 @@ class ListBasedExecutor {
         }
         return null;
     }
+    builderOpChanged(builder) {
+        const v = this.changedOps.get(builder.placeholderID);
+        return v !== undefined && v !== builder.operation;
+    }
     [Symbol.iterator]() {
         return this;
     }
@@ -33,17 +41,19 @@ class ListBasedExecutor {
         if (createdEnt) {
             this.createdEnt = createdEnt;
         }
-        const done = this.idx === this.operations.length;
-        const op = this.operations[this.idx];
+        maybeFlagOpOperationAsChanged(this.lastOp, this.changedOps);
+        const done = this.idx >= this.operations.length;
+        const op = maybeChangeOp(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;
+        if (done || op === undefined) {
+            return {
+                value: op,
+                done: true,
+            };
         }
         return {
             value: op,
-            done: done,
         };
     }
     async executeObservers() {
@@ -53,7 +63,13 @@ class ListBasedExecutor {
         }
         const builder = this.options.builder;
         await Promise.all(action.getObservers().map(async (observer) => {
-            await observer.observe(builder, action.getInput());
+            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() {
@@ -85,15 +101,28 @@ function getCreatedEnt(viewer, op) {
     }
     return null;
 }
+function maybeFlagOpOperationAsChanged(op, changedOps) {
+    if (!op || !op.updatedOperation) {
+        return;
+    }
+    const r = op.updatedOperation();
+    if (!r || r.builder.operation === r.operation) {
+        return;
+    }
+    changedOps.set(r.builder.placeholderID, r.operation);
+}
 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.changedOps = 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);
@@ -171,25 +200,24 @@ 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();
-        const done = this.idx === this.allOperations.length;
-        const op = this.allOperations[this.idx];
+        maybeFlagOpOperationAsChanged(this.lastOp, this.changedOps);
+        const done = this.idx >= this.allOperations.length;
+        const op = maybeChangeOp(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;
+        if (done || op === undefined) {
+            return {
+                value: op,
+                done: true,
+            };
         }
-        return {
-            value: op,
-            done: done,
-        };
+        return { value: op };
     }
     resolveValue(val) {
         let ent = this.mapper.get(val);
@@ -204,8 +232,15 @@ class ComplexExecutor {
         }
         return null;
     }
+    builderOpChanged(builder) {
+        const v = this.changedOps.get(builder.placeholderID);
+        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;
             }
@@ -248,6 +283,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);
                     }
@@ -262,6 +300,9 @@ async function executeOperations(executor, context, trackOps) {
             (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);
                 }
@@ -277,9 +318,7 @@ async function executeOperations(executor, context, trackOps) {
         if (executor.postFetch) {
             await executor.postFetch(client, context);
         }
-        if (executor.executeObservers) {
-            await executor.executeObservers();
-        }
+        client.release();
     }
     catch (e) {
         if (!isSyncClient(client)) {
@@ -287,12 +326,29 @@ async function executeOperations(executor, context, trackOps) {
             (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 maybeChangeOp(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/index.d.ts

@@ -1,5 +1,6 @@
-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";
+export { AssocEdgeOptions } from "./operations";

package/action/operations.d.ts

@@ -0,0 +1,126 @@
+import { Queryer, SyncQueryer } from "../core/db";
+import { Viewer, Ent, ID, Data, DataOptions, EditRowOptions, LoadEntOptions, Context, CreateRowOptions } from "../core/base";
+import { Executor } from "../action/action";
+import { WriteOperation, Builder } from "../action";
+import { AssocEdgeData, parameterizedQueryOptions } from "../core/ent";
+export interface UpdatedOperation {
+    operation: WriteOperation;
+    builder: Builder<any>;
+}
+export interface DataOperation<T extends Ent = Ent> {
+    builder: Builder<T>;
+    preFetch?(queryer: Queryer, context?: Context): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    placeholderID?: ID;
+    returnedRow?(): Data | null;
+    createdEnt?(viewer: Viewer): T | null;
+    shortCircuit?(executor: Executor): boolean;
+    updatedOperation?(): UpdatedOperation | null;
+    resolve?(executor: Executor): void;
+    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
+}
+export declare class DeleteNodeOperation implements DataOperation {
+    private id;
+    readonly builder: Builder<Ent>;
+    private options;
+    constructor(id: ID, builder: Builder<Ent>, options: DataOptions);
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+}
+export declare class RawQueryOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt> {
+    builder: Builder<TEnt, TViewer>;
+    private queries;
+    constructor(builder: Builder<TEnt, TViewer>, queries: (string | parameterizedQueryOptions)[]);
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+}
+export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
+    fieldsToResolve: string[];
+    loadEntOptions: LoadEntOptions<T>;
+    key: string;
+    onConflict?: CreateRowOptions["onConflict"];
+    builder: Builder<T>;
+}
+export declare class EditNodeOperation<T extends Ent> implements DataOperation {
+    options: EditNodeOptions<T>;
+    private existingEnt;
+    private row;
+    placeholderID?: ID | undefined;
+    private updatedOp;
+    builder: Builder<T>;
+    private resolved;
+    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
+    resolve<T extends Ent>(executor: Executor): void;
+    private hasData;
+    private buildOnConflictQuery;
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    private buildReloadQuery;
+    private reloadRow;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+    returnedRow(): Data | null;
+    createdEnt(viewer: Viewer): T | null;
+    updatedOperation(): UpdatedOperation | null;
+}
+export interface AssocEdgeInputOptions extends AssocEdgeOptions {
+    time?: Date;
+    data?: string | Builder<Ent>;
+}
+export interface AssocEdgeOptions {
+    conditional?: boolean;
+    disableTransformations?: boolean;
+}
+export interface AssocEdgeInput extends AssocEdgeInputOptions {
+    id1: ID;
+    id1Type: string;
+    edgeType: string;
+    id2: ID;
+    id2Type: string;
+}
+export declare class EdgeOperation implements DataOperation {
+    builder: Builder<any>;
+    edgeInput: AssocEdgeInput;
+    private options;
+    private edgeData;
+    private constructor();
+    preFetch(queryer: Queryer, context?: Context): Promise<void>;
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+    private getDeleteRowParams;
+    private performDeleteWrite;
+    private performDeleteWriteSync;
+    private getInsertRowParams;
+    private performInsertWrite;
+    private performInsertWriteSync;
+    private resolveImpl;
+    resolve(executor: Executor): void;
+    symmetricEdge(): EdgeOperation;
+    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
+    private static resolveIDs;
+    private static isBuilder;
+    private static resolveData;
+    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
+    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
+    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation;
+    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation;
+}
+export declare class ConditionalOperation<T extends Ent = Ent> implements DataOperation<T> {
+    protected op: DataOperation<T>;
+    private conditionalBuilder;
+    placeholderID?: ID | undefined;
+    protected shortCircuited: boolean;
+    readonly builder: Builder<T>;
+    constructor(op: DataOperation<T>, conditionalBuilder: Builder<any>);
+    shortCircuit(executor: Executor): boolean;
+    preFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): void;
+    performWrite(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
+    returnedRow(): Data | null;
+    updatedOperation(): UpdatedOperation | null;
+    resolve(executor: Executor): void;
+    postFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
+}
+export declare class ConditionalNodeOperation<T extends Ent> extends ConditionalOperation<T> {
+    createdEnt(viewer: Viewer): T | null;
+    updatedOperation(): UpdatedOperation | null;
+}