@snowtop/ent 0.1.0-alpha12 → 0.1.0-alpha15

package/action/action.d.ts

@@ -7,14 +7,16 @@ export declare enum WriteOperation {
     Edit = "edit",
     Delete = "delete"
 }
-export interface Builder<T extends Ent> {
-    existingEnt?: T;
-    ent: EntConstructor<T>;
+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: Viewer;
-    build(): Promise<Changeset<T>>;
+    readonly viewer: TViewer;
+    build(): Promise<Changeset>;
     operation: WriteOperation;
-    editedEnt?(): Promise<T | null>;
+    editedEnt?(): Promise<TEnt | null>;
     nodeType: string;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
@@ -25,39 +27,39 @@ export interface Executor extends Iterable<DataOperation>, Iterator<DataOperatio
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
     executeObservers?(): Promise<void>;
 }
-export interface Changeset<T extends Ent> {
+export interface Changeset {
     executor(): Executor;
     viewer: Viewer;
     placeholderID: ID;
-    changesets?: Changeset<Ent>[];
+    changesets?: Changeset[];
     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 declare 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;
 }
-export interface Observer<TBuilder extends Builder<Ent>, TData extends Data> {
-    observe(builder: TBuilder, input: TData): void | Promise<void>;
+export interface Observer<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, 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<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;
 }
-export interface Action<TEnt extends Ent, TBuilder extends Builder<TEnt>, TData extends Data> {
+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<TEnt>>;
+    changeset(): Promise<Changeset>;
     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, TViewer, TInput, TExistingEnt>[];
+    observers?: Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    validators?: Validator<TEnt, TBuilder, TViewer, 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>;
+    viewerForEntLoad?(data: Data): TViewer | Promise<TViewer>;
 }
-export declare function saveBuilder<T extends Ent>(builder: Builder<T>): Promise<void>;
-export declare function saveBuilderX<T extends Ent>(builder: Builder<T>): Promise<void>;
+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>;
 interface Orchestrator {
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string): void;

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, Viewer<Ent<any> | null, ID | null>, Data, T | null> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;
@@ -29,7 +29,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private lastOp;
     private allOperations;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T, Data>);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Viewer, Data>);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
@@ -39,4 +39,4 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     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>[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;

package/action/experimental_action.d.ts

@@ -5,36 +5,37 @@ export interface ActionOptions<T extends Ent, TData extends Data> {
     input?: TData;
     operation?: WriteOperation;
 }
-interface EntBuilder<T extends Ent> extends Builder<T> {
+interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> extends Builder<TEnt, TViewer> {
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<void>;
     saveX(): Promise<void>;
-    editedEnt(): Promise<T | null>;
-    editedEntX(): Promise<T>;
+    editedEnt(): Promise<TEnt | null>;
+    editedEntX(): Promise<TEnt>;
+    getInput(): TInput;
 }
-export declare class BaseAction<TEnt extends Ent, TData extends Data> implements Action<TEnt, EntBuilder<TEnt>, TData> {
-    viewer: Viewer;
-    builderCtr: BuilderConstructor<TEnt, TData>;
-    builder: EntBuilder<TEnt>;
+export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput> {
+    viewer: TViewer;
+    builderCtr: BuilderConstructor<TEnt, TViewer, TInput>;
+    builder: EntBuilder<TEnt, TViewer, TInput>;
     private input;
-    triggers: Trigger<EntBuilder<TEnt>, TData>[];
-    observers: Observer<EntBuilder<TEnt>, TData>[];
-    validators: Validator<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>;
-    static bulkAction<TEnt extends Ent, TData extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TData>, ...actions: Action<Ent, Builder<Ent>, Data>[]): BaseAction<TEnt, TData>;
-    changeset(): Promise<Changeset<TEnt>>;
+    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>;
+    changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<TEnt | null>;
     saveX(): Promise<TEnt>;
-    getInput(): TData;
+    getInput(): TInput;
 }
-interface BuilderConstructor<TEnt extends Ent, TData extends Data> {
-    new (viewer: Viewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt>, TData>, existingEnt?: TEnt | undefined): EntBuilder<TEnt>;
+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 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>;
+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 {};

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,17 +3,19 @@ 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<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
-    loaderOptions: LoadEntOptions<TEnt>;
+    loaderOptions: LoadEntOptions<TEnt, TViewer>;
     key: string;
-    builder: Builder<TEnt>;
-    action?: Action<TEnt, Builder<TEnt>, TData>;
+    builder: Builder<TEnt, TViewer, TExistingEnt>;
+    action?: Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
-    updateInput?: (data: TData) => void;
+    updateInput?: (data: TInput) => void;
     fieldInfo: FieldInfoMap;
 }
 interface edgeInputDataOpts {
@@ -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<TViewer>, TInput extends Data, TViewer extends Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     private options;
     private edgeSet;
     private edges;
@@ -43,14 +45,14 @@ 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, TViewer, TInput, TExistingEnt>);
     private addEdge;
     setDisableTransformations(val: boolean): void;
-    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;
+    addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
+    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string): void;
     removeOutboundEdge(id2: ID, edgeType: string): void;
     getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
@@ -83,16 +85,16 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
 }
-export declare class EntChangeset<T extends Ent> implements Changeset<T> {
+export declare class EntChangeset<T extends Ent> implements Changeset {
     viewer: Viewer;
     readonly placeholderID: ID;
     readonly ent: EntConstructor<T>;
     operations: DataOperation[];
-    dependencies?: Map<ID, Builder<Ent>> | undefined;
-    changesets?: Changeset<Ent>[] | undefined;
+    dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined;
+    changesets?: Changeset[] | 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<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Viewer<Ent<any> | null, ID | null>, 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<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | 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<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | null> | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }

package/core/base.d.ts

@@ -30,27 +30,27 @@ interface queryOptions {
     clause: clause.Clause;
     orderby?: string;
 }
-export interface Context {
-    getViewer(): Viewer;
+export interface Context<TViewer extends Viewer = Viewer> {
+    getViewer(): TViewer;
     cache?: cache;
 }
-export interface Viewer {
-    viewerID: ID | null;
-    viewer: () => Promise<Ent | null>;
+export interface Viewer<TEnt extends any = Ent<any> | null, TID extends any = ID | null> {
+    viewerID: TID;
+    viewer: () => Promise<TEnt>;
     instanceKey: () => string;
-    context?: Context;
+    context?: Context<any>;
 }
-export interface Ent {
+export interface Ent<TViewer extends Viewer = Viewer> {
     id: ID;
-    viewer: Viewer;
-    getPrivacyPolicy(): PrivacyPolicy<this>;
+    viewer: TViewer;
+    getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
 }
 export declare type Data = {
     [key: string]: any;
 };
-export interface EntConstructor<T extends Ent> {
-    new (viewer: Viewer, data: Data): T;
+export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewer> {
+    new (viewer: TViewer, data: Data): TEnt;
 }
 export declare type ID = string | number;
 export interface DataOptions {
@@ -84,15 +84,15 @@ export interface CreateRowOptions extends DataOptions {
 export interface EditRowOptions extends CreateRowOptions {
     key: string;
 }
-interface LoadableEntOptions<T extends Ent> {
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     loaderFactory: LoaderFactory<any, Data | null>;
-    ent: EntConstructor<T>;
+    ent: EntConstructor<TEnt, TViewer>;
 }
-export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, SelectBaseDataOptions {
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
-    ent: EntConstructor<T>;
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectBaseDataOptions {
+    ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoaderInfo {
@@ -121,10 +121,10 @@ export declare function Allow(): PrivacyResult;
 export declare function Skip(): PrivacyResult;
 export declare function Deny(): PrivacyResult;
 export declare function DenyWithReason(e: PrivacyError | string): PrivacyResult;
-export interface PrivacyPolicyRule<TEnt extends Ent = Ent> {
-    apply(v: Viewer, ent?: TEnt): Promise<PrivacyResult>;
+export interface PrivacyPolicyRule<TEnt extends Ent = Ent, TViewer = Viewer> {
+    apply(v: TViewer, ent?: TEnt): Promise<PrivacyResult>;
 }
-export interface PrivacyPolicy<TEnt extends Ent = Ent> {
-    rules: PrivacyPolicyRule<TEnt>[];
+export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
+    rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
 export {};

package/core/context.d.ts

@@ -3,8 +3,8 @@ import { Viewer, Data, Loader } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
-export interface RequestContext extends Context {
-    authViewer(viewer: Viewer): Promise<void>;
+export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
+    authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
     request: IncomingMessage;
     response: ServerResponse;

package/core/ent.d.ts

@@ -4,16 +4,16 @@ import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
-export declare function loadEnt<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T | null>;
-export declare function loadEntViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T | null>;
-export declare function loadEntX<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T>;
-export declare function loadEntXViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T>;
-export declare function loadEntFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T | null>;
-export declare function loadEntXFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T>;
-export declare function loadEnts<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<Map<ID, T>>;
-export declare function loadEntsList<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<T[]>;
-export declare function loadEntsFromClause<T extends Ent>(viewer: Viewer, clause: clause.Clause, options: LoadEntOptions<T>): Promise<Map<ID, T>>;
-export declare function loadCustomEnts<T extends Ent>(viewer: Viewer, options: LoadCustomEntOptions<T>, query: CustomQuery): Promise<T[]>;
+export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
+export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
+export declare function loadEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
+export declare function loadEntXViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
+export declare function loadEntFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt | null>;
+export declare function loadEntXFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt>;
+export declare function loadEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<Map<ID, TEnt>>;
+export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<TEnt[]>;
+export declare function loadEntsFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, clause: clause.Clause, options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
+export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery): Promise<TEnt[]>;
 interface rawQueryOptions {
     query: string;
     values?: any[];
@@ -21,8 +21,8 @@ interface rawQueryOptions {
 }
 export declare type CustomQuery = string | rawQueryOptions | clause.Clause | QueryDataOptions;
 export declare function loadCustomData(options: SelectBaseDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
-export declare function loadDerivedEnt<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T | null>;
-export declare function loadDerivedEntX<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T>;
+export declare function loadDerivedEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt | null>;
+export declare function loadDerivedEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt>;
 export declare function loadRowX(options: LoadRowOptions): Promise<Data>;
 export declare function loadRow(options: LoadRowOptions): Promise<Data | null>;
 export declare function performRawQuery(query: string, values: any[], logValues?: any[]): Promise<Data[]>;
@@ -165,7 +165,7 @@ export declare function defaultEdgeQueryOptions(id1: ID, edgeType: string): Edge
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;
 export declare function loadUniqueEdge(options: loadEdgesOptions): Promise<AssocEdge | null>;
-export declare function loadUniqueNode<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T | null>;
+export declare function loadUniqueNode<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id1: ID, edgeType: string, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadRawEdgeCountX(options: loadEdgesOptions): Promise<number>;
 interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptions<T> {
     id2: ID;

package/core/loaders/assoc_count_loader.d.ts

@@ -1,10 +1,10 @@
 import { ID, Context, Loader, LoaderFactory } from "../base";
 export declare class AssocEdgeCountLoader implements Loader<ID, number> {
     private edgeType;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loaderFn;
     private loader;
-    constructor(edgeType: string, context?: Context | undefined);
+    constructor(edgeType: string, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private getLoader;
     load(id: ID): Promise<number>;
     clearAll(): void;

package/core/loaders/assoc_edge_loader.d.ts

@@ -20,8 +20,8 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeType;
     private edgeCtr;
     private options?;
-    context?: Context | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context | undefined);
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;

package/core/loaders/object_loader.d.ts

@@ -1,12 +1,12 @@
-import { Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
+import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
 export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
     load(key: T): Promise<Data | null>;

package/core/loaders/query_loader.d.ts

@@ -10,12 +10,12 @@ export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[
 }
 export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private queryOptions?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    constructor(options: QueryOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;

package/core/loaders/raw_count_loader.d.ts

@@ -9,9 +9,9 @@ interface QueryCountOptions {
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
 export declare class RawCountLoader<K extends any> implements Loader<K, number> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loader;
-    constructor(options: QueryCountOptions, context?: Context | undefined);
+    constructor(options: QueryCountOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: K): Promise<number>;
     clearAll(): void;
 }

package/core/privacy.d.ts

@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;

package/core/query/assoc_query.d.ts

@@ -3,15 +3,15 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
-export declare type EdgeQuerySource<TSource extends Ent, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
-export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
-    viewer: Viewer;
-    src: EdgeQuerySource<TSource, TDest>;
+export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
+    viewer: TViewer;
+    src: EdgeQuerySource<TSource, TDest, TViewer>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private getSingleID;

package/core/query/custom_query.d.ts

@@ -1,17 +1,17 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<TDest>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
+    viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
     queryRawCount(): Promise<number>;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;

package/core/viewer.d.ts

@@ -1,7 +1,7 @@
 import { ID, Ent, Viewer, Context } from "./base";
 export declare class LoggedOutViewer implements Viewer {
-    context?: Context | undefined;
-    constructor(context?: Context | undefined);
+    context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined;
+    constructor(context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined);
     viewerID: null;
     viewer(): Promise<null>;
     instanceKey(): string;
@@ -18,6 +18,6 @@ export declare class IDViewer implements Viewer {
     constructor(viewerID: ID, opts?: Partial<IDViewerOptions>);
     constructor(opts: IDViewerOptions);
     setContext(ctx: Context): this;
-    viewer(): Promise<Ent | null>;
+    viewer(): Promise<Ent<Viewer<Ent<any> | null, ID | null>> | null>;
     instanceKey(): string;
 }

package/graphql/query/edge_connection.d.ts

@@ -1,30 +1,30 @@
 import { EdgeQuery, PaginationInfo } from "../../core/query/query";
-import { Data, Ent, Viewer } from "../../core/base";
+import { Data, Ent, ID, Viewer } from "../../core/base";
 export interface GraphQLEdge<T extends Data> {
     edge: T;
     node: Ent;
     cursor: string;
 }
-interface edgeQueryCtr<T extends Ent, TEdge extends Data> {
-    (v: Viewer, src: T): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer, src: T): EdgeQuery<T, Ent, TEdge>;
 }
-interface edgeQueryCtr2<T extends Ent, TEdge extends Data> {
-    (v: Viewer): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr2<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer): EdgeQuery<T, Ent, TEdge>;
 }
-export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data> {
+export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data, TViewer extends Viewer = Viewer> {
     query: EdgeQuery<TSource, Ent, TEdge>;
     private results;
     private viewer;
     private source?;
     private args?;
-    constructor(viewer: Viewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge>, args?: Data);
-    constructor(viewer: Viewer, getQuery: edgeQueryCtr2<TSource, TEdge>, args?: Data);
+    constructor(viewer: TViewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge, TViewer>, args?: Data);
+    constructor(viewer: TViewer, getQuery: edgeQueryCtr2<TSource, TEdge, TViewer>, args?: Data);
     first(limit: number, cursor?: string): void;
     last(limit: number, cursor?: string): void;
     modifyQuery(fn: (query: EdgeQuery<TSource, Ent, TEdge>) => EdgeQuery<TSource, Ent, TEdge>): void;
     queryTotalCount(): Promise<number>;
     queryEdges(): Promise<GraphQLEdge<TEdge>[]>;
-    queryNodes(): Promise<Ent[]>;
+    queryNodes(): Promise<Ent<Viewer<Ent<any> | null, ID | null>>[]>;
     private defaultPageInfo;
     queryPageInfo(): Promise<PaginationInfo>;
     private queryData;

package/graphql/query/page_info.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLObjectType } from "graphql";
 import { RequestContext } from "../../core/context";
 import { PaginationInfo } from "../../core/query/query";
-export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext>;
+export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext<import("../..").Viewer<import("../..").Ent<any> | null, import("../..").ID | null>>>;

package/package.json

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

package/parse_schema/parse.d.ts

@@ -24,6 +24,7 @@ declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" |
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
     fields: ProcessedField[];
     schemaPath?: string;
+    patternNames?: string[];
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -38,6 +39,7 @@ interface ProcessedPattern {
     name: string;
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
+    disableMixin?: boolean;
 }
 declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
     subFields?: ProcessedField[];

package/parse_schema/parse.js

@@ -130,6 +130,7 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
@@ -202,9 +203,11 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
                 const ret = processPattern(patterns, pattern, processedSchema);
+                patternNames.push(pattern.name);
                 if (ret.transformsSelect) {
                     if (processedSchema.transformsSelect) {
                         throw new Error(`can only have one pattern which transforms default querying behavior`);
@@ -221,6 +224,7 @@ function parseSchema(potentialSchemas) {
         }
         const fields = processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);

package/schema/base_schema.js

@@ -66,6 +66,7 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
 // Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
@@ -95,6 +96,7 @@ class EntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
         this.fields = cfg.fields;
@@ -131,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/schema.d.ts

@@ -69,9 +69,10 @@ export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
     fields: FieldMap | Field[];
+    disableMixin?: boolean;
     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 +84,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 +204,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,19 +68,22 @@ 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>;
+    orchestrator: Orchestrator<T, Data, Viewer>;
     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>, Viewer, Data> | undefined);
+    getInput(): Data;
     updateInput(input: Data): void;
-    build(): Promise<Changeset<T>>;
+    build(): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
     save(): Promise<void>;
@@ -91,18 +94,18 @@ 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>, Viewer, 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>>[];
+    triggers: Trigger<T, SimpleBuilder<T>>[];
+    observers: Observer<T, SimpleBuilder<T>>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
-    changeset(): Promise<Changeset<T>>;
+    changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<T | null>;

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;
@@ -207,6 +207,13 @@ class SimpleBuilder {
             updateInput: this.updateInput.bind(this),
         });
     }
+    getInput() {
+        let ret = {};
+        for (const [k, v] of this.fields) {
+            ret[k] = v;
+        }
+        return ret;
+    }
     updateInput(input) {
         const knownFields = (0, schema_1.getFields)(this.schema);
         for (const k in input) {
@@ -247,7 +254,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);

package/testutils/fake_data/user_query.d.ts

@@ -53,7 +53,7 @@ export declare class UserToFriendRequestsQuery extends AssocEdgeQueryBase<FakeUs
 }
 export declare class UserToIncomingFriendRequestsQuery extends AssocEdgeQueryBase<FakeUser, FakeUser, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     sourceEnt(id: ID): Promise<FakeUser | null>;
     static query(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>): UserToIncomingFriendRequestsQuery;
     queryContacts(): UserToContactsQuery;
@@ -90,7 +90,7 @@ export declare class UserToEventsInNextWeekQuery extends CustomEdgeQueryBase<Fak
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToEventsInNextWeekQuery;
     sourceEnt(id: ID): Promise<FakeUser | null>;
-    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): import("../../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
 }
 export declare class UserToFollowingQuery extends AssocEdgeQueryBase<FakeUser, Ent, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser, FakeUser>);

package/testutils/fake_log.d.ts

@@ -1,4 +1,4 @@
-import { Ent } from "../core/base";
+import { Ent, Viewer } from "../core/base";
 import { Builder } from "./../action";
 export declare class FakeLogger {
     private static logs;
@@ -8,6 +8,6 @@ export declare class FakeLogger {
     static contains(line: string): boolean;
     static clear(): void;
 }
-export declare class EntCreationObserver<T extends Ent> {
-    observe(builder: Builder<T>): Promise<void>;
+export declare class EntCreationObserver<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    observe(builder: Builder<TEnt, TViewer>): Promise<void>;
 }