@snowtop/ent 0.0.2 → 0.0.3-4.alpha

package/action/action.d.ts

@@ -7,13 +7,14 @@ export declare enum WriteOperation {
     Delete = "delete"
 }
 export interface Builder<T extends Ent> {
-    existingEnt?: Ent;
+    existingEnt?: T;
     ent: EntConstructor<T>;
     placeholderID: ID;
     readonly viewer: Viewer;
     build(): Promise<Changeset<T>>;
     operation: WriteOperation;
     editedEnt?(): Promise<T | null>;
+    nodeType: string;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
     placeholderID: ID;
@@ -27,11 +28,10 @@ export interface Changeset<T extends Ent> {
     executor(): Executor;
     viewer: Viewer;
     placeholderID: ID;
-    ent: EntConstructor<T>;
     changesets?: Changeset<Ent>[];
-    dependencies?: Map<ID, Builder<T>>;
+    dependencies?: Map<ID, Builder<Ent>>;
 }
-export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | Changeset<Ent>[] | Changeset<Ent>> | Promise<Changeset<Ent>>[];
+export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | (Changeset<Ent> | void)[]> | Promise<Changeset<Ent>>[];
 export interface Trigger<T extends Ent> {
     changeset(builder: Builder<T>, input: Data): TriggerReturn;
 }
@@ -57,8 +57,8 @@ export interface Action<T extends Ent> {
 export declare function saveBuilder<T extends Ent>(builder: Builder<T>): Promise<void>;
 export declare function saveBuilderX<T extends Ent>(builder: Builder<T>): Promise<void>;
 interface Orchestrator {
-    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): any;
-    removeOutboundEdge(id2: ID, edgeType: string): any;
+    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
+    removeOutboundEdge(id2: ID, edgeType: string): void;
     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>;

package/action/action.js

@@ -23,7 +23,7 @@ async function saveBuilderImpl(builder, throwErr) {
         changeset = await builder.build();
     }
     catch (e) {
-        logger_1.log("error", e);
+        (0, logger_1.log)("error", e);
         if (throwErr) {
             throw e;
         }
@@ -46,7 +46,7 @@ async function saveBuilderImpl(builder, throwErr) {
     }
 }
 async function modifyEdgeSet(orchestrator, id1, id2, inputEnumValue, enumValue, edgeType, nodeType) {
-    let edge = await ent_1.loadEdgeForID2({
+    let edge = await (0, ent_1.loadEdgeForID2)({
         id1: id1,
         id2: id2,
         edgeType: edgeType,

package/action/executor.d.ts

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

package/action/executor.js

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

package/action/experimental_action.d.ts

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

package/action/experimental_action.js

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

package/action/index.d.ts

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

package/action/orchestrator.d.ts

@@ -1,9 +1,9 @@
 import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
 import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType } from "../schema/schema";
-import { Changeset, Executor } from "../action";
+import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
-export interface OrchestratorOptions<T extends Ent> {
+export interface OrchestratorOptions<T extends Ent, TData extends Data> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
@@ -13,6 +13,7 @@ export interface OrchestratorOptions<T extends Ent> {
     action?: Action<T>;
     schema: SchemaInputType;
     editedFields(): Map<string, any>;
+    updateInput?: (data: TData) => void;
 }
 interface edgeInputDataOpts {
     edgeType: string;
@@ -38,7 +39,9 @@ export declare class Orchestrator<T extends Ent> {
     private fieldsToResolve;
     private mainOp;
     viewer: Viewer;
-    constructor(options: OrchestratorOptions<T>);
+    private defaultFieldsByFieldName;
+    private defaultFieldsByTSName;
+    constructor(options: OrchestratorOptions<T, Data>);
     private addEdge;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
@@ -50,11 +53,15 @@ export declare class Orchestrator<T extends Ent> {
     private getEdgeOperation;
     private buildEdgeOps;
     private throwError;
+    private getEntForPrivacyPolicy;
     private validate;
     private triggers;
     private validators;
     private isBuilder;
-    private validateFields;
+    private getFieldsWithDefaultValues;
+    private hasData;
+    private transformFieldValue;
+    private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     build(): Promise<EntChangeset<T>>;
@@ -68,10 +75,11 @@ export declare class EntChangeset<T extends Ent> implements Changeset<T> {
     readonly placeholderID: ID;
     readonly ent: EntConstructor<T>;
     operations: DataOperation[];
-    dependencies?: Map<ID, Builder<T>> | undefined;
+    dependencies?: Map<ID, Builder<Ent>> | undefined;
     changesets?: Changeset<Ent>[] | undefined;
     private options?;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<T>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T> | undefined);
+    private _executor;
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data> | undefined);
     executor(): Executor;
 }
 export {};