@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test2

package/action/operations.d.ts

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