convex-ents 0.3.0 → 0.4.0

package/dist/index.js

@@ -1604,11 +1604,7 @@ function getDeletionConfig(entDefinitions, table) {
 // src/deletion.ts
 var import_server3 = require("convex/server");
 var import_values2 = require("convex/values");
-var vApproach = import_values2.v.union(
-  import_values2.v.literal("schedule"),
-  import_values2.v.literal("deleteOne"),
-  import_values2.v.literal("paginate")
-);
+var vApproach = import_values2.v.union(import_values2.v.literal("cascade"), import_values2.v.literal("paginate"));
 function scheduledDeleteFactory(entDefinitions, options) {
   const selfRef = options?.scheduledDelete ?? (0, import_server3.makeFunctionReference)(
     "functions:scheduledDelete"
@@ -1663,10 +1659,8 @@ function scheduledDeleteFactory(entDefinitions, options) {
         return;
       }
       await progressScheduledDeletion(
-        ctx,
-        entDefinitions,
-        selfRef,
-        origin,
+        { ctx, entDefinitions, selfRef, origin },
+        newCounter(),
         inProgress ? stack : [
           {
             id: originId,
@@ -1683,12 +1677,11 @@ function getEdgeArgs(entDefinitions, table) {
   return Object.values(edges).flatMap((edgeDefinition) => {
     if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
       const table2 = edgeDefinition.to;
-      const targetDeletionConfig = getDeletionConfig(entDefinitions, table2);
       const targetEdges = getEdgeDefinitions(entDefinitions, table2);
       const hasCascadingEdges = Object.values(targetEdges).some(
         (edgeDefinition2) => edgeDefinition2.cardinality === "single" && edgeDefinition2.type === "ref" || edgeDefinition2.cardinality === "multiple"
       );
-      const approach = targetDeletionConfig !== void 0 && hasCascadingEdges ? "schedule" : hasCascadingEdges ? "deleteOne" : "paginate";
+      const approach = hasCascadingEdges ? "cascade" : "paginate";
       const indexName = edgeDefinition.ref;
       return [{ table: table2, indexName, approach }];
     } else if (edgeDefinition.cardinality === "multiple") {
@@ -1712,39 +1705,49 @@ function getEdgeArgs(entDefinitions, table) {
     }
   });
 }
-async function progressScheduledDeletion(ctx, entDefinitions, selfRef, origin, stack) {
+async function progressScheduledDeletion(cascade, counter, stack) {
+  const { ctx } = cascade;
   const last = stack[stack.length - 1];
   if ("id" in last) {
     const edgeArgs = last.edges[0];
     if (edgeArgs === void 0) {
       await ctx.db.delete(last.id);
       if (stack.length > 1) {
-        await ctx.scheduler.runAfter(0, selfRef, {
-          origin,
-          stack: stack.slice(0, -1),
-          inProgress: true
-        });
+        await continueOrSchedule(cascade, counter, stack.slice(0, -1));
       }
     } else {
       const updated = { ...last, edges: last.edges.slice(1) };
-      await paginate(
-        ctx,
-        entDefinitions,
-        selfRef,
-        origin,
+      await paginateOrCascade(
+        cascade,
+        counter,
         stack.slice(0, -1).concat(updated),
-        { cursor: null, fieldValue: last.id, ...edgeArgs }
+        {
+          cursor: null,
+          fieldValue: last.id,
+          ...edgeArgs
+        }
       );
     }
   } else {
-    await paginate(ctx, entDefinitions, selfRef, origin, stack, last);
+    await paginateOrCascade(cascade, counter, stack, last);
   }
 }
-async function paginate(ctx, entDefinitions, selfRef, origin, stack, { table, approach, indexName, fieldValue, cursor }) {
-  const { page, continueCursor, isDone } = await ctx.db.query(table).withIndex(indexName, (q) => q.eq(indexName, fieldValue)).paginate({
-    cursor,
-    ...approach === "paginate" ? { numItems: 8192 / 4, maximumBytesRead: 2 ** 18 } : { numItems: 1 }
-  });
+var MAXIMUM_DOCUMENTS_READ = 8192 / 4;
+var MAXIMUM_BYTES_READ = 2 ** 18;
+async function paginateOrCascade(cascade, counter, stack, { table, approach, indexName, fieldValue, cursor }) {
+  const { ctx, entDefinitions } = cascade;
+  const { page, continueCursor, isDone, bytesRead } = await paginate(
+    ctx,
+    { table, indexName, fieldValue },
+    {
+      cursor,
+      ...limitsBasedOnCounter(
+        counter,
+        approach === "paginate" ? { numItems: MAXIMUM_DOCUMENTS_READ } : { numItems: 1 }
+      )
+    }
+  );
+  const updatedCounter = incrementCounter(counter, page.length, bytesRead);
   const updated = {
     approach,
     table,
@@ -1753,34 +1756,92 @@ async function paginate(ctx, entDefinitions, selfRef, origin, stack, { table, ap
     fieldValue
   };
   const relevantStack = cursor === null ? stack : stack.slice(0, -1);
-  if (approach === "schedule") {
+  const updatedStack = isDone && (approach === "paginate" || page.length === 0) ? relevantStack : relevantStack.concat(
+    approach === "cascade" ? [
+      updated,
+      {
+        id: page[0]._id,
+        table,
+        edges: getEdgeArgs(entDefinitions, table)
+      }
+    ] : [updated]
+  );
+  if (approach === "paginate") {
+    await Promise.all(page.map((doc) => ctx.db.delete(doc._id)));
+  }
+  await continueOrSchedule(cascade, updatedCounter, updatedStack);
+}
+async function continueOrSchedule(cascade, counter, stack) {
+  if (shouldSchedule(counter)) {
+    const { ctx, selfRef, origin } = cascade;
     await ctx.scheduler.runAfter(0, selfRef, {
       origin,
-      stack: isDone ? relevantStack : relevantStack.concat([
-        updated,
-        {
-          id: page[0]._id,
-          table,
-          edges: getEdgeArgs(entDefinitions, table)
-        }
-      ]),
+      stack,
       inProgress: true
     });
   } else {
-    if (approach === "deleteOne") {
-      await new WriterImplBase(ctx, entDefinitions, origin.table).deleteId(
-        page[0].id,
-        "hard"
-      );
-    } else {
-      await Promise.all(page.map((doc) => ctx.db.delete(doc._id)));
+    await progressScheduledDeletion(cascade, counter, stack);
+  }
+}
+function newCounter() {
+  return {
+    numDocuments: 0,
+    numBytesRead: 0
+  };
+}
+function incrementCounter(counter, numDocuments, numBytesRead) {
+  return {
+    numDocuments: counter.numDocuments + numDocuments,
+    numBytesRead: counter.numBytesRead + numBytesRead
+  };
+}
+function limitsBasedOnCounter(counter, { numItems }) {
+  return {
+    numItems: Math.max(1, numItems - counter.numDocuments),
+    maximumBytesRead: Math.max(1, MAXIMUM_BYTES_READ - counter.numBytesRead)
+  };
+}
+function shouldSchedule(counter) {
+  return counter.numDocuments >= MAXIMUM_DOCUMENTS_READ || counter.numBytesRead >= MAXIMUM_BYTES_READ;
+}
+async function paginate(ctx, {
+  table,
+  indexName,
+  fieldValue
+}, {
+  cursor,
+  numItems,
+  maximumBytesRead
+}) {
+  const query = ctx.db.query(table).withIndex(
+    indexName,
+    (q) => q.eq(indexName, fieldValue).gt(
+      "_creationTime",
+      cursor
+    )
+  );
+  let bytesRead = 0;
+  const results = [];
+  let isDone = true;
+  for await (const doc of query) {
+    if (results.length >= numItems) {
+      isDone = false;
+      break;
     }
-    await ctx.scheduler.runAfter(0, selfRef, {
-      origin,
-      stack: isDone ? relevantStack : relevantStack.concat([updated]),
-      inProgress: true
-    });
+    const size = JSON.stringify((0, import_values2.convexToJson)(doc)).length * 8;
+    if (bytesRead + size > maximumBytesRead) {
+      isDone = false;
+      break;
+    }
+    bytesRead += size;
+    results.push(doc);
   }
+  return {
+    page: results,
+    continueCursor: results.length === 0 ? cursor : results[results.length - 1]._creationTime,
+    isDone,
+    bytesRead
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {