@snowtop/ent 0.1.0-alpha138 → 0.1.0-alpha139

package/action/orchestrator.d.ts

@@ -1,7 +1,7 @@
-import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
-import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
+import { ID, Data, Ent, Viewer, LoadEntOptions, CreateRowOptions } from "../core/base";
 import { SchemaInputType, FieldInfoMap } from "../schema/schema";
-import { Changeset, Executor } from "../action/action";
+import { Changeset, ChangesetOptions, Executor } from "../action/action";
+import { AssocEdgeInputOptions, DataOperation, AssocEdgeOptions } from "./operations";
 import { WriteOperation, Builder, Action } from "../action";
 import * as clause from "../core/clause";
 type MaybeNull<T extends Ent> = T | null;
@@ -37,6 +37,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private options;
     private edgeSet;
     private edges;
+    private conditionalEdges;
     private validatedFields;
     private logValues;
     private changesets;
@@ -49,15 +50,17 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private actualOperation;
     private existingEnt;
     private disableTransformations;
+    private onConflict;
     private memoizedGetFields;
     constructor(options: OrchestratorOptions<TEnt, TInput, TViewer, TExistingEnt>);
     __getOptions(): OrchestratorOptions<any, any, any, any>;
     private addEdge;
     setDisableTransformations(val: boolean): void;
+    setOnConflictOptions(onConflict: CreateRowOptions["onConflict"]): 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;
+    removeInboundEdge(id1: ID, edgeType: string, options?: AssocEdgeOptions): void;
+    removeOutboundEdge(id2: ID, edgeType: string, options?: AssocEdgeOptions): void;
     getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
     clearInputEdges(edgeType: string, op: WriteOperation, id?: ID): void;
     private buildMainOp;
@@ -95,7 +98,9 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
      * If those throws, this still throws and doesn't return them
      */
     validWithErrors(): Promise<Error[]>;
+    private buildPlusChangeset;
     build(): Promise<EntChangeset<TEnt>>;
+    buildWithOptions_BETA(options: ChangesetOptions): Promise<EntChangeset<TEnt>>;
     private viewerForEntLoad;
     returnedRow(): Promise<Data | null>;
     editedEnt(): Promise<TEnt | null>;
@@ -103,14 +108,15 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
 }
 export declare class EntChangeset<T extends Ent> implements Changeset {
     viewer: Viewer;
+    private builder;
     readonly placeholderID: ID;
-    readonly ent: EntConstructor<T>;
+    private conditionalOverride;
     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, 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, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
+    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>;
     executor(): Executor;
 }

package/action/orchestrator.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
+const operations_1 = require("./operations");
 const action_1 = require("../action");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
@@ -83,6 +84,7 @@ class Orchestrator {
         this.options = options;
         this.edgeSet = new Set();
         this.edges = new Map();
+        this.conditionalEdges = new Map();
         this.changesets = [];
         this.dependencies = new Map();
         this.fieldsToResolve = [];
@@ -97,7 +99,7 @@ class Orchestrator {
     __getOptions() {
         return this.options;
     }
-    addEdge(edge, op) {
+    addEdge(edge, op, conditional) {
         this.edgeSet.add(edge.edgeType);
         let m1 = this.edges.get(edge.edgeType) || new Map();
         let m2 = m1.get(op) || new Map();
@@ -112,11 +114,22 @@ class Orchestrator {
         // set or overwrite the new edge data for said id
         m2.set(id, edge);
         m1.set(op, m2);
-        this.edges.set(edge.edgeType, m1);
+        if (conditional && this.onConflict) {
+            this.conditionalEdges.set(edge.edgeType, m1);
+        }
+        else {
+            this.edges.set(edge.edgeType, m1);
+        }
     }
     setDisableTransformations(val) {
         this.disableTransformations = val;
     }
+    setOnConflictOptions(onConflict) {
+        if (onConflict?.onConflictConstraint && !onConflict.updateCols) {
+            throw new Error(`cannot set onConflictConstraint without updateCols`);
+        }
+        this.onConflict = onConflict;
+    }
     addInboundEdge(id1, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
@@ -124,7 +137,7 @@ class Orchestrator {
             nodeType,
             options,
             direction: edgeDirection.inboundEdge,
-        }), action_1.WriteOperation.Insert);
+        }), action_1.WriteOperation.Insert, options?.conditional);
     }
     addOutboundEdge(id2, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
@@ -133,21 +146,21 @@ class Orchestrator {
             nodeType,
             options,
             direction: edgeDirection.outboundEdge,
-        }), action_1.WriteOperation.Insert);
+        }), action_1.WriteOperation.Insert, options?.conditional);
     }
-    removeInboundEdge(id1, edgeType) {
+    removeInboundEdge(id1, edgeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
             edgeType,
             direction: edgeDirection.inboundEdge,
-        }), action_1.WriteOperation.Delete);
+        }), action_1.WriteOperation.Delete, options?.conditional);
     }
-    removeOutboundEdge(id2, edgeType) {
+    removeOutboundEdge(id2, edgeType, options) {
         this.addEdge(new edgeInputData({
             id: id2,
             edgeType,
             direction: edgeDirection.outboundEdge,
-        }), action_1.WriteOperation.Delete);
+        }), action_1.WriteOperation.Delete, options?.conditional);
     }
     // this doesn't take a direction as that's an implementation detail
     // it doesn't make any sense to use the same edgeType for inbound and outbound edges
@@ -170,11 +183,11 @@ class Orchestrator {
             m.clear();
         }
     }
-    buildMainOp() {
+    buildMainOp(conditionalBuilder) {
         // this assumes we have validated fields
         switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
-                return new ent_1.DeleteNodeOperation(this.existingEnt.id, {
+                return new operations_1.DeleteNodeOperation(this.existingEnt.id, this.options.builder, {
                     tableName: this.options.tableName,
                 });
             default:
@@ -191,14 +204,18 @@ class Orchestrator {
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
                     loadEntOptions: this.options.loaderOptions,
-                    placeholderID: this.options.builder.placeholderID,
                     whereClause: clause.Eq(this.options.key, this.existingEnt?.id),
                     expressions: this.options.expressions,
+                    onConflict: this.onConflict,
+                    builder: this.options.builder,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
                 }
-                this.mainOp = new ent_1.EditNodeOperation(opts, this.existingEnt);
+                this.mainOp = new operations_1.EditNodeOperation(opts, this.existingEnt);
+                if (conditionalBuilder) {
+                    this.mainOp = new operations_1.ConditionalNodeOperation(this.mainOp, conditionalBuilder);
+                }
                 return this.mainOp;
         }
     }
@@ -218,10 +235,10 @@ class Orchestrator {
                 throw new Error(`no nodeType for edge when adding outboundEdge`);
             }
             if (edge.direction === edgeDirection.outboundEdge) {
-                return ent_1.EdgeOperation.outboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
+                return operations_1.EdgeOperation.outboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
             }
             else {
-                return ent_1.EdgeOperation.inboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
+                return operations_1.EdgeOperation.inboundEdge(this.options.builder, edgeType, edge.id, edge.nodeType, edge.options);
             }
         }
         else if (op === action_1.WriteOperation.Delete) {
@@ -230,30 +247,53 @@ class Orchestrator {
             }
             let id2 = edge.id;
             if (edge.direction === edgeDirection.outboundEdge) {
-                return ent_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2);
             }
             else {
-                return ent_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2);
             }
         }
         throw new Error("could not find an edge operation from the given parameters");
     }
-    async buildEdgeOps(ops) {
+    async buildEdgeOps(ops, conditionalBuilder, conditionalOverride) {
         const edgeDatas = await (0, ent_1.loadEdgeDatas)(...Array.from(this.edgeSet.values()));
-        for (const [edgeType, m] of this.edges) {
-            for (const [op, m2] of m) {
-                for (const [_, edge] of m2) {
-                    let edgeOp = this.getEdgeOperation(edgeType, op, edge);
-                    ops.push(edgeOp);
-                    const edgeData = edgeDatas.get(edgeType);
-                    if (!edgeData) {
-                        throw new Error(`could not load edge data for '${edgeType}'`);
-                    }
-                    if (edgeData.symmetricEdge) {
-                        ops.push(edgeOp.symmetricEdge());
-                    }
-                    if (edgeData.inverseEdgeType) {
-                        ops.push(edgeOp.inverseEdge(edgeData));
+        const edges = [
+            [this.edges, false],
+            [this.conditionalEdges, true],
+        ];
+        // conditional should only apply if onconflict...
+        // if no upsert and just create, nothing to do here
+        for (const edgeInfo of edges) {
+            const [edges, conditionalEdge] = edgeInfo;
+            const conditional = conditionalOverride || conditionalEdge;
+            for (const [edgeType, m] of edges) {
+                for (const [op, m2] of m) {
+                    for (const [_, edge] of m2) {
+                        let edgeOp = this.getEdgeOperation(edgeType, op, edge);
+                        if (conditional) {
+                            ops.push(new operations_1.ConditionalOperation(edgeOp, conditionalBuilder));
+                        }
+                        else {
+                            ops.push(edgeOp);
+                        }
+                        const edgeData = edgeDatas.get(edgeType);
+                        if (!edgeData) {
+                            throw new Error(`could not load edge data for '${edgeType}'`);
+                        }
+                        if (edgeData.symmetricEdge) {
+                            let symmetric = edgeOp.symmetricEdge();
+                            if (conditional) {
+                                symmetric = new operations_1.ConditionalOperation(symmetric, conditionalBuilder);
+                            }
+                            ops.push(symmetric);
+                        }
+                        if (edgeData.inverseEdgeType) {
+                            let inverse = edgeOp.inverseEdge(edgeData);
+                            if (conditional) {
+                                inverse = new operations_1.ConditionalOperation(inverse, conditionalBuilder);
+                            }
+                            ops.push(inverse);
+                        }
                     }
                 }
             }
@@ -498,6 +538,8 @@ class Orchestrator {
         // else apply schema tranformation if it exists
         let transformed = null;
         const sqlOp = this.getSQLStatementOperation();
+        // why is transform write technically different from upsert?
+        // it's create -> update just at the db level...
         if (action?.transformWrite) {
             transformed = await action.transformWrite({
                 builder,
@@ -539,8 +581,8 @@ class Orchestrator {
                 }
             }
             if (transformed.changeset) {
-                const ct = await transformed.changeset();
-                this.changesets.push(ct);
+                const changeset = await transformed.changeset();
+                this.changesets.push(changeset);
             }
             this.actualOperation = this.getWriteOpForSQLStamentOp(transformed.op);
             if (transformed.existingEnt) {
@@ -758,13 +800,25 @@ class Orchestrator {
     async validWithErrors() {
         return this.validate();
     }
-    async build() {
+    async buildPlusChangeset(conditionalBuilder, conditionalOverride) {
         // validate everything first
         await this.validX();
-        let ops = [this.buildMainOp()];
-        await this.buildEdgeOps(ops);
+        let ops = [
+            this.buildMainOp(conditionalOverride ? conditionalBuilder : undefined),
+        ];
+        await this.buildEdgeOps(ops, conditionalBuilder, conditionalOverride);
         // TODO throw if we try and create a new changeset after previously creating one
-        return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
+        // TODO test actualOperation value
+        // observers is fine since they're run after and we have the actualOperation value...
+        return new EntChangeset(this.options.viewer, this.options.builder, this.options.builder.placeholderID, conditionalOverride, ops, this.dependencies, this.changesets, this.options);
+    }
+    async build() {
+        return this.buildPlusChangeset(this.options.builder, false);
+    }
+    async buildWithOptions_BETA(options) {
+        // set as dependency so that we do the right order of operations
+        this.dependencies.set(options.conditionalBuilder.placeholderID, options.conditionalBuilder);
+        return this.buildPlusChangeset(options.conditionalBuilder, true);
     }
     async viewerForEntLoad(data) {
         const action = this.options.action;
@@ -809,18 +863,25 @@ exports.Orchestrator = Orchestrator;
 function randomNum() {
     return Math.random().toString(10).substring(2);
 }
+// each changeset is required to have a unique placeholderID
+// used in executor. if we end up creating multiple changesets from a builder, we need
+// different placeholders
+// in practice, only applies to Entchangeset::changesetFrom()
 class EntChangeset {
-    constructor(viewer, placeholderID, ent, operations, dependencies, changesets, options) {
+    constructor(viewer, builder, placeholderID, conditionalOverride, operations, dependencies, changesets, options) {
         this.viewer = viewer;
+        this.builder = builder;
         this.placeholderID = placeholderID;
-        this.ent = ent;
+        this.conditionalOverride = conditionalOverride;
         this.operations = operations;
         this.dependencies = dependencies;
         this.changesets = changesets;
         this.options = options;
     }
     static changesetFrom(builder, ops) {
-        return new EntChangeset(builder.viewer, `$ent.idPlaceholderID$ ${randomNum()}-${builder.ent.name}`, builder.ent, ops);
+        return new EntChangeset(builder.viewer, builder, 
+        // need unique placeholderID different from the builder. see comment above EntChangeset
+        `$ent.idPlaceholderID$ ${randomNum()}-${builder.ent.name}`, false, ops);
     }
     executor() {
         if (this._executor) {
@@ -831,9 +892,15 @@ class EntChangeset {
             // executor and depend on something else in the stack to handle this correctly
             // ComplexExecutor which could be a parent of this should make sure the dependency
             // is resolved beforehand
-            return (this._executor = new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.operations, this.options));
+            return (this._executor = new executor_1.ListBasedExecutor(this.viewer, this.placeholderID, this.operations, this.options, {
+                conditionalOverride: this.conditionalOverride,
+                builder: this.builder,
+            }));
         }
-        return (this._executor = new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.operations, this.dependencies || new Map(), this.changesets || [], this.options));
+        return (this._executor = new executor_1.ComplexExecutor(this.viewer, this.placeholderID, this.operations, this.dependencies || new Map(), this.changesets || [], this.options, {
+            conditionalOverride: this.conditionalOverride,
+            builder: this.builder,
+        }));
     }
 }
 exports.EntChangeset = EntChangeset;

package/core/base.d.ts

@@ -88,11 +88,17 @@ export interface LoadRowOptions extends QueryableDataOptions {
 }
 export interface LoadRowsOptions extends QueryableDataOptions {
 }
+interface OnConflictOptions {
+    onConflictCols: string[];
+    onConflictConstraint?: string;
+    updateCols?: string[];
+}
 export interface CreateRowOptions extends DataOptions {
     fields: Data;
     fieldsToLog?: Data;
+    onConflict?: OnConflictOptions;
 }
-export interface EditRowOptions extends CreateRowOptions {
+export interface EditRowOptions extends Omit<CreateRowOptions, "onConflict"> {
     whereClause: clause.Clause;
     expressions?: Map<string, clause.Clause>;
 }

package/core/db.js

@@ -238,6 +238,8 @@ class Sqlite {
             r = this.db.prepare(query).get(this.convertValues(values));
         }
         else {
+            // TODO querySync() with no values seems to do the wrong thing...
+            // e.g. querySync('select count(*) as count from table') returns nonsense
             r = this.db.prepare(query).run();
         }
         return {

package/core/ent.d.ts

@@ -1,8 +1,6 @@
 import { Queryer, SyncQueryer } from "./db";
 import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions } from "./base";
-import { Executor } from "../action/action";
 import * as clause from "./clause";
-import { Builder } from "../action";
 import DataLoader from "dataloader";
 export declare function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): string;
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
@@ -24,7 +22,7 @@ export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends
  */
 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, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer, TResultData>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
-interface parameterizedQueryOptions {
+export interface parameterizedQueryOptions {
     query: string;
     values?: any[];
     logValues?: any[];
@@ -81,69 +79,6 @@ interface GroupQueryOptions<T extends Data, K = keyof T> {
     limit: number;
 }
 export declare function buildGroupQuery<T extends Data = Data, K = keyof T>(options: GroupQueryOptions<T, K>): [string, clause.Clause<T, K>];
-export interface DataOperation<T extends Ent = Ent> {
-    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;
-    resolve?(executor: Executor): void;
-    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
-}
-export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
-    fieldsToResolve: string[];
-    loadEntOptions: LoadEntOptions<T>;
-    placeholderID?: ID;
-    key: string;
-}
-export declare class RawQueryOperation implements DataOperation {
-    private queries;
-    constructor(queries: (string | parameterizedQueryOptions)[]);
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-}
-export declare class EditNodeOperation<T extends Ent> implements DataOperation {
-    options: EditNodeOptions<T>;
-    private existingEnt;
-    row: Data | null;
-    placeholderID?: ID | undefined;
-    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
-    resolve<T extends Ent>(executor: Executor): void;
-    private hasData;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    private reloadRow;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    returnedRow(): Data | null;
-    createdEnt(viewer: Viewer): T | null;
-}
-export declare class EdgeOperation implements DataOperation {
-    private builder;
-    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): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID): EdgeOperation;
-}
 export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
 export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
 export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
@@ -152,13 +87,6 @@ export declare function editRow(queryer: Queryer, options: EditRowOptions, suffi
 export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, suffix?: string): Data | null;
 export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
 export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
-export declare class DeleteNodeOperation implements DataOperation {
-    private id;
-    private options;
-    constructor(id: ID, options: DataOptions);
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-}
 export declare class AssocEdge {
     id1: ID;
     id1Type: string;
@@ -179,17 +107,6 @@ interface cursorOptions {
     conv?: (any: any) => any;
 }
 export declare function getCursor(opts: cursorOptions): string;
-export interface AssocEdgeInputOptions {
-    time?: Date;
-    data?: string | Builder<Ent>;
-}
-export interface AssocEdgeInput extends AssocEdgeInputOptions {
-    id1: ID;
-    id1Type: string;
-    edgeType: string;
-    id2: ID;
-    id2Type: string;
-}
 export declare class AssocEdgeData {
     edgeType: string;
     edgeName: string;