refactor more operations to share code

Author: ianmacartney

src/client/index.ts

@@ -71,13 +71,6 @@ type BufferedOperation =
       summand?: number;
       namespace?: any;
       newNamespace?: any;
-    }
-  | {
-      type: "insertIfDoesNotExist";
-      key: any;
-      value: any;
-      summand?: number;
-      namespace?: any;
     };
 
 /**
@@ -556,16 +549,6 @@ export class Aggregate<
     id: ID,
     summand?: number,
   ): Promise<void> {
-    if (this.isBuffering) {
-      this.operationQueue.push({
-        type: "insertIfDoesNotExist",
-        key: keyToPosition(key, id),
-        value: id,
-        summand,
-        namespace,
-      });
-      return;
-    }
     await this._replaceOrInsert(
       ctx,
       namespace,

src/component/_generated/component.ts

@@ -202,13 +202,6 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
                 type: "replaceOrInsert";
                 value: any;
               }
-            | {
-                key: any;
-                namespace?: any;
-                summand?: number;
-                type: "insertIfDoesNotExist";
-                value: any;
-              }
           >;
         },
         null,

src/component/public.ts

@@ -1,13 +1,16 @@
-import { ConvexError, v } from "convex/values";
-import { mutation } from "./_generated/server.js";
+import { ConvexError, v, type Value } from "convex/values";
+import { mutation, type DatabaseWriter } from "./_generated/server.js";
 import {
   DEFAULT_MAX_NODE_SIZE,
   deleteHandler,
   getOrCreateTree,
   getTree,
   insertHandler,
+  type Key,
+  type Namespace,
 } from "./btree.js";
 import { internal } from "./_generated/api.js";
+import type { Doc } from "./_generated/dataModel.js";
 
 export const init = mutation({
   args: {
@@ -78,34 +81,62 @@ export const replace = mutation({
     newNamespace: v.optional(v.any()),
   },
   returns: v.null(),
-  handler: async (ctx, args) => {
-    await deleteHandler(ctx, {
+  handler: replaceHandler,
+});
+
+async function replaceHandler(
+  ctx: { db: DatabaseWriter },
+  args: {
+    currentKey: Key;
+    newKey: Key;
+    value: Value;
+    summand?: number;
+    namespace?: Namespace;
+    newNamespace?: Namespace;
+  },
+  treeArg?: Doc<"btree">,
+  newTreeArg?: Doc<"btree">,
+) {
+  await deleteHandler(
+    ctx,
+    {
       key: args.currentKey,
       namespace: args.namespace,
-    });
-    await insertHandler(ctx, {
+    },
+    treeArg,
+  );
+  await insertHandler(
+    ctx,
+    {
       key: args.newKey,
       value: args.value,
       summand: args.summand,
       namespace: args.newNamespace,
-    });
-  },
-});
+    },
+    newTreeArg,
+  );
+}
 
 export const deleteIfExists = mutation({
   args: { key: v.any(), namespace: v.optional(v.any()) },
-  handler: async (ctx, { key, namespace }) => {
-    try {
-      await deleteHandler(ctx, { key, namespace });
-    } catch (e) {
-      if (e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY") {
-        return;
-      }
-      throw e;
-    }
-  },
+  handler: deleteIfExistsHandler,
 });
 
+async function deleteIfExistsHandler(
+  ctx: { db: DatabaseWriter },
+  args: { key: Key; namespace?: Namespace },
+  treeArg?: Doc<"btree">,
+) {
+  try {
+    await deleteHandler(ctx, args, treeArg);
+  } catch (e) {
+    if (e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY") {
+      return;
+    }
+    throw e;
+  }
+}
+
 export const replaceOrInsert = mutation({
   args: {
     currentKey: v.any(),
@@ -115,27 +146,47 @@ export const replaceOrInsert = mutation({
     namespace: v.optional(v.any()),
     newNamespace: v.optional(v.any()),
   },
-  handler: async (ctx, args) => {
-    try {
-      await deleteHandler(ctx, {
+  handler: replaceOrInsertHandler,
+});
+
+async function replaceOrInsertHandler(
+  ctx: { db: DatabaseWriter },
+  args: {
+    currentKey: Key;
+    newKey: Key;
+    value: Value;
+    summand?: number;
+    namespace?: Namespace;
+    newNamespace?: Namespace;
+  },
+  treeArg?: Doc<"btree">,
+  newTreeArg?: Doc<"btree">,
+) {
+  try {
+    await deleteHandler(
+      ctx,
+      {
         key: args.currentKey,
         namespace: args.namespace,
-      });
-    } catch (e) {
-      if (
-        !(e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY")
-      ) {
-        throw e;
-      }
+      },
+      treeArg,
+    );
+  } catch (e) {
+    if (!(e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY")) {
+      throw e;
     }
-    await insertHandler(ctx, {
+  }
+  await insertHandler(
+    ctx,
+    {
       key: args.newKey,
       value: args.value,
       summand: args.summand,
       namespace: args.newNamespace,
-    });
-  },
-});
+    },
+    newTreeArg,
+  );
+}
 
 /**
  * Reinitialize the aggregate data structure, clearing all data.
@@ -215,13 +266,6 @@ export const batch = mutation({
           namespace: v.optional(v.any()),
           newNamespace: v.optional(v.any()),
         }),
-        v.object({
-          type: v.literal("insertIfDoesNotExist"),
-          key: v.any(),
-          value: v.any(),
-          summand: v.optional(v.number()),
-          namespace: v.optional(v.any()),
-        }),
       ),
     ),
   },
@@ -271,102 +315,42 @@ export const batch = mutation({
       } else if (op.type === "replace") {
         // Handle delete from original namespace
         const deleteTree = await getTreeForNamespace(op.namespace);
-        await deleteHandler(
-          ctx,
-          {
-            key: op.currentKey,
-            namespace: op.namespace,
-          },
-          deleteTree,
-        );
         // Handle insert to new namespace (which might be different)
         const insertTree = await getTreeForNamespace(op.newNamespace);
-        await insertHandler(
+        await replaceHandler(
           ctx,
           {
-            key: op.newKey,
+            currentKey: op.currentKey,
+            newKey: op.newKey,
             value: op.value,
             summand: op.summand,
-            namespace: op.newNamespace,
           },
+          deleteTree,
           insertTree,
         );
       } else if (op.type === "deleteIfExists") {
         const tree = await getTreeForNamespace(op.namespace);
-        try {
-          await deleteHandler(
-            ctx,
-            { key: op.key, namespace: op.namespace },
-            tree,
-          );
-        } catch (e) {
-          if (
-            e instanceof ConvexError &&
-            e.data?.code === "DELETE_MISSING_KEY"
-          ) {
-            continue;
-          }
-          throw e;
-        }
+        await deleteIfExistsHandler(
+          ctx,
+          { key: op.key, namespace: op.namespace },
+          tree,
+        );
       } else if (op.type === "replaceOrInsert") {
         // Handle delete from original namespace
         const deleteTree = await getTreeForNamespace(op.namespace);
-        try {
-          await deleteHandler(
-            ctx,
-            {
-              key: op.currentKey,
-              namespace: op.namespace,
-            },
-            deleteTree,
-          );
-        } catch (e) {
-          if (
-            !(e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY")
-          ) {
-            throw e;
-          }
-        }
-        // Handle insert to new namespace (which might be different)
-        const insertTree = await getTreeForNamespace(op.newNamespace);
-        await insertHandler(
-          ctx,
-          {
-            key: op.newKey,
-            value: op.value,
-            summand: op.summand,
-            namespace: op.newNamespace,
-          },
-          insertTree,
-        );
-      } else if (op.type === "insertIfDoesNotExist") {
-        const tree = await getTreeForNamespace(op.namespace);
-        // insertIfDoesNotExist is implemented as replaceOrInsert
-        try {
-          await deleteHandler(
-            ctx,
-            {
-              key: op.key,
-              namespace: op.namespace,
-            },
-            tree,
-          );
-        } catch (e) {
-          if (
-            !(e instanceof ConvexError && e.data?.code === "DELETE_MISSING_KEY")
-          ) {
-            throw e;
-          }
-        }
-        await insertHandler(
+        const newTree = await getTreeForNamespace(op.newNamespace);
+        await replaceOrInsertHandler(
           ctx,
           {
-            key: op.key,
+            currentKey: op.currentKey,
+            newKey: op.newKey,
             value: op.value,
             summand: op.summand,
             namespace: op.namespace,
+            newNamespace: op.newNamespace,
           },
-          tree,
+          deleteTree,
+          newTree,
         );
       }
     }