@snowtop/ent 0.1.0-alpha12 → 0.1.0-alpha13

package/action/action.d.ts

@@ -7,8 +7,10 @@ export declare enum WriteOperation {
     Edit = "edit",
     Delete = "delete"
 }
-export interface Builder<T extends Ent> {
-    existingEnt?: T;
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface Builder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> {
+    existingEnt: TExistingEnt;
     ent: EntConstructor<T>;
     placeholderID: ID;
     readonly viewer: Viewer;
@@ -33,25 +35,25 @@ export interface Changeset<T extends Ent> {
     dependencies?: Map<ID, Builder<Ent>>;
 }
 export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | (Changeset<Ent> | void)[]> | Promise<Changeset<Ent>>[];
-export interface Trigger<TBuilder extends Builder<Ent>, TData extends Data> {
-    changeset(builder: TBuilder, input: TData): TriggerReturn;
+export interface Trigger<TEnt extends Ent, TBuilder extends Builder<TEnt, TExistingEnt>, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    changeset(builder: TBuilder, input: TInput): TriggerReturn;
 }
-export interface Observer<TBuilder extends Builder<Ent>, TData extends Data> {
-    observe(builder: TBuilder, input: TData): void | Promise<void>;
+export interface Observer<TEnt extends Ent, TBuilder extends Builder<TEnt, TExistingEnt>, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    observe(builder: TBuilder, input: TInput): void | Promise<void>;
 }
-export interface Validator<TBuilder extends Builder<Ent>, TData extends Data> {
-    validate(builder: TBuilder, input: TData): Promise<void> | void;
+export interface Validator<TEnt extends Ent, TBuilder extends Builder<TEnt, TExistingEnt>, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    validate(builder: TBuilder, input: TInput): Promise<void> | void;
 }
-export interface Action<TEnt extends Ent, TBuilder extends Builder<TEnt>, TData extends Data> {
+export interface Action<TEnt extends Ent, TBuilder extends Builder<TEnt, TExistingEnt>, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     readonly viewer: Viewer;
     changeset(): Promise<Changeset<TEnt>>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    triggers?: Trigger<TBuilder, TData>[];
-    observers?: Observer<TBuilder, TData>[];
-    validators?: Validator<TBuilder, TData>[];
-    getInput(): TData;
-    transformWrite?: <T2 extends Ent>(stmt: UpdateOperation<T2>) => Promise<TransformedUpdateOperation<T2>> | TransformedUpdateOperation<T2> | undefined;
+    triggers?: Trigger<TEnt, TBuilder, TInput, TExistingEnt>[];
+    observers?: Observer<TEnt, TBuilder, TInput, TExistingEnt>[];
+    validators?: Validator<TEnt, TBuilder, TInput, TExistingEnt>[];
+    getInput(): TInput;
+    transformWrite?: (stmt: UpdateOperation<TEnt>) => Promise<TransformedUpdateOperation<TEnt>> | TransformedUpdateOperation<TEnt> | null;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;

package/action/executor.d.ts

@@ -10,7 +10,7 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private operations;
     private options?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, T | null> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;

package/action/experimental_action.d.ts

@@ -18,9 +18,9 @@ export declare class BaseAction<TEnt extends Ent, TData extends Data> implements
     builderCtr: BuilderConstructor<TEnt, TData>;
     builder: EntBuilder<TEnt>;
     private input;
-    triggers: Trigger<EntBuilder<TEnt>, TData>[];
-    observers: Observer<EntBuilder<TEnt>, TData>[];
-    validators: Validator<EntBuilder<TEnt>, TData>[];
+    triggers: Trigger<TEnt, EntBuilder<TEnt>, TData>[];
+    observers: Observer<TEnt, EntBuilder<TEnt>, TData>[];
+    validators: Validator<TEnt, EntBuilder<TEnt>, TData>[];
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent>;
     constructor(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null);
     static createBuilder<TEnt extends Ent, TData extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null): Builder<TEnt>;
@@ -33,7 +33,7 @@ export declare class BaseAction<TEnt extends Ent, TData extends Data> implements
     getInput(): TData;
 }
 interface BuilderConstructor<TEnt extends Ent, TData extends Data> {
-    new (viewer: Viewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt>, TData>, existingEnt?: TEnt | undefined): EntBuilder<TEnt>;
+    new (viewer: Viewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt>, TData>, existingEnt: TEnt | null): EntBuilder<TEnt>;
 }
 export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
 export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt>, TInput>;

package/action/experimental_action.js

@@ -20,7 +20,7 @@ class BaseAction {
             }
         }
         this.input = options?.input || {};
-        this.builder = new builderCtr(viewer, operation, this, options?.existingEnt || undefined);
+        this.builder = new builderCtr(viewer, operation, this, options?.existingEnt || null);
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;

package/action/orchestrator.d.ts

@@ -3,13 +3,15 @@ import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType, FieldInfoMap } from "../schema/schema";
 import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
-export interface OrchestratorOptions<TEnt extends Ent, TData extends Data> {
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface OrchestratorOptions<TEnt extends Ent, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
     loaderOptions: LoadEntOptions<TEnt>;
     key: string;
-    builder: Builder<TEnt>;
+    builder: Builder<TEnt, TExistingEnt>;
     action?: Action<TEnt, Builder<TEnt>, TData>;
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
@@ -29,7 +31,7 @@ export declare enum edgeDirection {
     inboundEdge = 0,
     outboundEdge = 1
 }
-export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
+export declare class Orchestrator<TEnt extends Ent, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     private options;
     private edgeSet;
     private edges;
@@ -43,10 +45,10 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private defaultFieldsByFieldName;
     private defaultFieldsByTSName;
     private actualOperation;
-    private existingEnt?;
+    private existingEnt;
     private disableTransformations;
     private memoizedGetFields;
-    constructor(options: OrchestratorOptions<TEnt, TData>);
+    constructor(options: OrchestratorOptions<TEnt, TData, TExistingEnt>);
     private addEdge;
     setDisableTransformations(val: boolean): void;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
@@ -88,11 +90,11 @@ export declare class EntChangeset<T extends Ent> implements Changeset<T> {
     readonly placeholderID: ID;
     readonly ent: EntConstructor<T>;
     operations: DataOperation[];
-    dependencies?: Map<ID, Builder<Ent>> | undefined;
+    dependencies?: Map<ID, Builder<Ent, Ent | null>> | undefined;
     changesets?: Changeset<Ent>[] | undefined;
     private options?;
     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);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent, Ent | null>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data, MaybeNull<T>> | undefined);
     executor(): Executor;
 }
 export {};

package/action/orchestrator.js

@@ -376,7 +376,7 @@ class Orchestrator {
         // if action transformations. always do it
         // if disable transformations set, don't do schema transform and just do the right thing
         // else apply schema tranformation if it exists
-        let transformed;
+        let transformed = null;
         if (action?.transformWrite) {
             transformed = await action.transformWrite({
                 viewer: builder.viewer,
@@ -414,6 +414,7 @@ class Orchestrator {
             }
             this.actualOperation = this.getWriteOpForSQLStamentOp(transformed.op);
             if (transformed.existingEnt) {
+                // @ts-ignore
                 this.existingEnt = transformed.existingEnt;
             }
         }

package/action/privacy.d.ts

@@ -2,11 +2,11 @@ import { Builder } from "./action";
 import { Viewer, ID, Ent, PrivacyResult, PrivacyPolicyRule } from "../core/base";
 export declare class DenyIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent> | undefined);
+    constructor(id?: ID | Builder<Ent, Ent | null> | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent> | undefined);
+    constructor(id?: ID | Builder<Ent, Ent | null> | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }

package/package.json

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

package/schema/schema.d.ts

@@ -71,7 +71,7 @@ export interface Pattern {
     fields: FieldMap | Field[];
     edges?: Edge[];
     transformRead?: () => Clause;
-    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
     transformsDelete?: boolean;
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
@@ -83,14 +83,14 @@ export declare enum SQLStatementOperation {
 }
 export interface UpdateOperation<T extends Ent> {
     op: SQLStatementOperation;
-    existingEnt?: T;
+    existingEnt: T | null;
     viewer: Viewer;
     data?: Map<string, any>;
 }
 export interface TransformedUpdateOperation<T extends Ent> {
     op: SQLStatementOperation;
     data?: Data;
-    existingEnt?: T;
+    existingEnt?: T | null;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -203,7 +203,7 @@ interface objectLoaderOptions {
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | undefined;
+export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,

package/schema/schema.js

@@ -178,13 +178,14 @@ exports.getObjectLoaderProperties = getObjectLoaderProperties;
 function getTransformedUpdateOp(value, stmt) {
     const schema = getSchema(value);
     if (!schema.patterns) {
-        return;
+        return null;
     }
     for (const p of schema.patterns) {
         if (p.transformWrite) {
             return p.transformWrite(stmt);
         }
     }
+    return null;
 }
 exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go

package/testutils/builder.d.ts

@@ -68,17 +68,19 @@ export declare function getBuilderSchemaTZFromFields<T extends Ent>(fields: Fiel
 export declare function getSchemaName(value: BuilderSchema<Ent>): string;
 export declare function getTableName(value: BuilderSchema<Ent>): string;
 export declare function getFieldInfo(value: BuilderSchema<Ent>): FieldInfoMap;
-export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
-    existingEnt: T | undefined;
+    existingEnt: TExistingEnt;
     ent: EntConstructor<T>;
     placeholderID: ID;
     orchestrator: Orchestrator<T, Data>;
     fields: Map<string, any>;
     nodeType: string;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
     updateInput(input: Data): void;
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
@@ -91,15 +93,15 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
 interface viewerEntLoadFunc {
     (data: Data): Viewer | Promise<Viewer>;
 }
-export declare class SimpleAction<T extends Ent> implements Action<T, SimpleBuilder<T>, Data> {
+export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Action<T, SimpleBuilder<T, TExistingEnt>, Data, TExistingEnt> {
     viewer: Viewer;
     private fields;
-    builder: SimpleBuilder<T>;
-    validators: Validator<SimpleBuilder<T>, Data>[];
-    triggers: Trigger<SimpleBuilder<T>, Data>[];
-    observers: Observer<SimpleBuilder<T>, Data>[];
+    builder: SimpleBuilder<T, TExistingEnt>;
+    validators: Validator<T, SimpleBuilder<T>, Data>[];
+    triggers: Trigger<T, SimpleBuilder<T>, Data>[];
+    observers: Observer<T, SimpleBuilder<T>, Data>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
     getPrivacyPolicy(): PrivacyPolicy<Ent>;
     getInput(): Data;
     changeset(): Promise<Changeset<T>>;

package/testutils/builder.js

@@ -145,7 +145,7 @@ function getFieldInfo(value) {
 exports.getFieldInfo = getFieldInfo;
 // reuses orchestrator and standard things
 class SimpleBuilder {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt = undefined, action) {
+    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt, action) {
         this.viewer = viewer;
         this.schema = schema;
         this.operation = operation;
@@ -247,7 +247,7 @@ class SimpleBuilder {
 }
 exports.SimpleBuilder = SimpleBuilder;
 class SimpleAction {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt = undefined) {
+    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt) {
         this.viewer = viewer;
         this.fields = fields;
         this.validators = [];

package/testutils/fake_data/fake_contact.d.ts

@@ -28,6 +28,6 @@ export interface ContactCreateInput {
     emailAddress: string;
     userID: ID;
 }
-export declare function getContactBuilder(viewer: Viewer, input: ContactCreateInput): SimpleBuilder<FakeContact>;
+export declare function getContactBuilder(viewer: Viewer, input: ContactCreateInput): SimpleBuilder<FakeContact, null>;
 export declare function createContact(viewer: Viewer, input: ContactCreateInput): Promise<void>;
 export declare const contactLoader: ObjectLoaderFactory<unknown>;

package/testutils/fake_data/fake_contact.js

@@ -9,6 +9,7 @@ const const_1 = require("./const");
 const test_db_1 = require("../db/test_db");
 const loaders_1 = require("../../core/loaders");
 const convert_1 = require("../../core/convert");
+const action_1 = require("../../action");
 class FakeContact {
     constructor(viewer, data) {
         this.viewer = viewer;
@@ -77,7 +78,7 @@ function getContactBuilder(viewer, input) {
     //To lock in the value of Date now incase of advanceTo/advanceBy
     m.set("createdAt", new Date());
     m.set("updatedAt", new Date());
-    return new builder_1.SimpleBuilder(viewer, exports.FakeContactSchema, m);
+    return new builder_1.SimpleBuilder(viewer, exports.FakeContactSchema, m, action_1.WriteOperation.Insert, null);
 }
 exports.getContactBuilder = getContactBuilder;
 async function createContact(viewer, input) {

package/testutils/fake_data/fake_event.d.ts

@@ -31,5 +31,5 @@ export interface EventCreateInput {
     description?: string | null;
     userID: ID;
 }
-export declare function getEventBuilder(viewer: Viewer, input: EventCreateInput): SimpleBuilder<FakeEvent>;
+export declare function getEventBuilder(viewer: Viewer, input: EventCreateInput): SimpleBuilder<FakeEvent, null>;
 export declare function createEvent(viewer: Viewer, input: EventCreateInput): Promise<void>;

package/testutils/fake_data/fake_event.js

@@ -9,6 +9,7 @@ const const_1 = require("./const");
 const test_db_1 = require("../db/test_db");
 const loaders_1 = require("../../core/loaders");
 const convert_1 = require("../../core/convert");
+const action_1 = require("../../action");
 class FakeEvent {
     constructor(viewer, data) {
         this.viewer = viewer;
@@ -86,7 +87,7 @@ function getEventBuilder(viewer, input) {
     for (const key in input) {
         m.set(key, input[key]);
     }
-    return new builder_1.SimpleBuilder(viewer, exports.FakeEventSchema, m);
+    return new builder_1.SimpleBuilder(viewer, exports.FakeEventSchema, m, action_1.WriteOperation.Insert, null);
 }
 exports.getEventBuilder = getEventBuilder;
 async function createEvent(viewer, input) {

package/testutils/fake_data/fake_user.d.ts

@@ -40,8 +40,8 @@ export interface UserCreateInput {
     password: string | null;
 }
 export declare type UserEditInput = Partial<UserCreateInput>;
-export declare function getUserBuilder(viewer: Viewer, input: UserCreateInput): import("../builder").SimpleBuilder<FakeUser>;
-export declare function getUserAction(viewer: Viewer, input: UserCreateInput): SimpleAction<FakeUser>;
+export declare function getUserBuilder(viewer: Viewer, input: UserCreateInput): import("../builder").SimpleBuilder<FakeUser, null>;
+export declare function getUserAction(viewer: Viewer, input: UserCreateInput): SimpleAction<FakeUser, null>;
 export declare function createUser(viewer: Viewer, input: UserCreateInput): Promise<FakeUser>;
 export declare const userLoader: ObjectLoaderFactory<unknown>;
 export declare const userEmailLoader: ObjectLoaderFactory<unknown>;

package/testutils/fake_data/fake_user.js

@@ -11,6 +11,7 @@ const viewer_1 = require("../../core/viewer");
 const test_db_1 = require("../db/test_db");
 const loaders_1 = require("../../core/loaders");
 const convert_1 = require("../../core/convert");
+const action_1 = require("../../action");
 class ViewerWithAccessToken extends viewer_1.IDViewer {
     constructor(viewerID, opts) {
         super(viewerID, opts);
@@ -110,7 +111,7 @@ function getUserAction(viewer, input) {
     for (const key in input) {
         m.set(key, input[key]);
     }
-    const action = new builder_1.SimpleAction(viewer, exports.FakeUserSchema, m);
+    const action = new builder_1.SimpleAction(viewer, exports.FakeUserSchema, m, action_1.WriteOperation.Insert, null);
     action.viewerForEntLoad = (data) => {
         // load the created ent using a VC of the newly created user.
         return new viewer_1.IDViewer(data.id);