@snowtop/ent 0.1.14-test3 → 0.1.14

package/action/action.d.ts

@@ -24,7 +24,7 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
     getInput(): Data;
     orchestrator: BuilderOrchestrator;
 }
-export interface Executor extends Iterable<DataOperation<Ent>>, Iterator<DataOperation<Ent>> {
+export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
     placeholderID: ID;
     resolveValue(val: any): Ent | null;
     builderOpChanged(builder: Builder<any>): boolean;

package/action/executor.d.ts

@@ -40,7 +40,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private executors;
     private changedOps;
     builder?: Builder<Ent> | undefined;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
@@ -51,5 +51,5 @@ 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<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;
 export {};

package/action/operations.d.ts

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

package/action/orchestrator.d.ts

@@ -21,14 +21,14 @@ export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends D
     expressions?: Map<string, clause.Clause>;
     fieldInfo: FieldInfoMap;
 }
-interface edgeInputDataOpts<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+interface edgeInputDataOpts {
     edgeType: string;
-    id: Builder<TEnt, TViewer> | ID;
+    id: Builder<Ent> | ID;
     nodeType?: string;
     options?: AssocEdgeInputOptions;
 }
-export interface EdgeInputData<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends edgeInputDataOpts<TEnt, TViewer> {
-    isBuilder(id: Builder<TEnt, TViewer> | ID): id is Builder<TEnt, TViewer>;
+export interface EdgeInputData extends edgeInputDataOpts {
+    isBuilder(id: Builder<Ent> | ID): id is Builder<Ent>;
 }
 export declare enum edgeDirection {
     inboundEdge = 0,
@@ -62,7 +62,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string, options?: AssocEdgeOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string, options?: AssocEdgeOptions): void;
-    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData<any, TViewer>[];
+    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
     clearInputEdges(edgeType: string, op: WriteOperation, id?: ID): void;
     private buildMainOp;
     private getEdgeOperation;
@@ -108,24 +108,24 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
 }
-export declare class EntChangeset<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements Changeset {
+export declare class EntChangeset<T extends Ent> implements Changeset {
     viewer: Viewer;
     private builder;
     readonly placeholderID: ID;
     private conditionalOverride;
-    operations: DataOperation<any, TViewer>[];
+    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;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, builder: Builder<TEnt, TViewer>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation<any, TViewer>[], 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<TEnt, Data, TViewer, MaybeNull<TEnt>> | undefined);
-    static changesetFrom<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, ops: DataOperation<any, TViewer>[]): EntChangeset<any, TViewer>;
-    static changesetFromQueries<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any, TViewer>;
+    constructor(viewer: Viewer, builder: Builder<T>, placeholderID: ID, conditionalOverride: boolean, 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, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
+    static changesetFrom(builder: Builder<any, any, any>, ops: DataOperation[]): EntChangeset<any>;
+    static changesetFromQueries(builder: Builder<any, any, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any>;
     private static changesetFromEdgeOp;
-    static changesetFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
-    static changesetFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
-    static changesetRemoveFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
-    static changesetRemoveFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetRemoveFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetRemoveFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
     executor(): Executor;
 }
 export {};

package/action/transaction.d.ts

@@ -1,13 +1,10 @@
-import { Ent, Viewer, Data } from "../core/base";
-import { Action } from "./action";
-import { EntBuilder } from "./experimental_action";
-type MaybeNull<T extends Ent> = T | null;
-type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
-type ActionAny<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> = Action<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>;
+import { Ent, Viewer } from "../core/base";
+import { Action, Builder } from "./action";
+type ActionAny<TViewer extends Viewer = Viewer> = Action<Ent<TViewer>, Builder<Ent<TViewer>, TViewer, any>, Viewer<any, any>, any, any>;
 export declare class Transaction<TViewer extends Viewer = Viewer> {
     private viewer;
     private actions;
-    constructor(viewer: TViewer, actions: ActionAny<any, TViewer, Data>[]);
+    constructor(viewer: TViewer, actions: ActionAny<TViewer>[]);
     run(): Promise<void>;
 }
 export {};

package/package.json

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

package/testutils/action/complex_schemas.d.ts

@@ -7,7 +7,7 @@ import { MockLogs } from "../../testutils/mock_log";
 import { Table } from "../db/temp_db";
 export declare function setupTest(): void;
 export declare function getML(): MockLogs;
-export declare function getOperations(): DataOperation<any, Viewer<Ent<any> | null, ID | null>>[];
+export declare function getOperations(): DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[];
 export declare const UserSchema: BuilderSchema<User>;
 export declare class UserWithBalance extends User {
 }
@@ -45,7 +45,7 @@ export declare class UserAction extends SimpleAction<User> {
     getTriggers(): Trigger<User, SimpleBuilder<User>>[];
     getObservers(): Observer<User, SimpleBuilder<User>>[];
 }
-type getMembershipFunction = (viewer: Viewer, edge: EdgeInputData<Ent, Viewer>) => SimpleAction<Ent>;
+type getMembershipFunction = (viewer: Viewer, edge: EdgeInputData) => SimpleAction<Ent>;
 export declare class GroupMembershipTrigger implements Trigger<Group, SimpleBuilder<Group>> {
     private getter;
     constructor(getter: getMembershipFunction);