convex-ents 0.1.0 → 0.3.0

package/dist/index.js

@@ -24,7 +24,8 @@ __export(src_exports, {
   defineEnt: () => defineEnt,
   defineEntSchema: () => defineEntSchema,
   entsTableFactory: () => entsTableFactory,
-  getEntDefinitions: () => getEntDefinitions
+  getEntDefinitions: () => getEntDefinitions,
+  scheduledDeleteFactory: () => scheduledDeleteFactory
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -35,7 +36,7 @@ function defineEntSchema(schema, options) {
   const tableNames = Object.keys(schema);
   for (const tableName of tableNames) {
     const table = schema[tableName];
-    for (const edge of edgeConfigsFromEntDefinition(table)) {
+    for (const edge of edgeConfigsBeforeDefineSchema(table)) {
       if (
         // Skip inverse edges, we process their forward edges
         edge.cardinality === "multiple" && edge.type === "ref" && edge.inverse !== void 0 || // symmetric is only set by defineEntSchema,
@@ -52,7 +53,7 @@ function defineEntSchema(schema, options) {
         );
       }
       const isSelfDirected = edge.to === tableName;
-      const inverseEdgeCandidates = edgeConfigsFromEntDefinition(
+      const inverseEdgeCandidates = edgeConfigsBeforeDefineSchema(
         otherTable
       ).filter(canBeInverseEdge(tableName, edge, isSelfDirected));
       if (inverseEdgeCandidates.length > 1) {
@@ -61,6 +62,11 @@ function defineEntSchema(schema, options) {
         );
       }
       const inverseEdge = inverseEdgeCandidates[0];
+      if (edge.cardinality === "single" && edge.type === "field" && inverseEdge === void 0) {
+        throw new Error(
+          `Missing inverse edge in table "${otherTableName}" for edge "${edge.name}" in table "${tableName}"`
+        );
+      }
       if (edge.cardinality === "single" && edge.type === "ref") {
         if (inverseEdge === void 0) {
           throw new Error(
@@ -82,6 +88,13 @@ function defineEntSchema(schema, options) {
         }
         inverseEdge.unique = true;
       }
+      if (edge.cardinality === "single" && edge.type === "ref" || edge.cardinality === "multiple" && edge.type === "field") {
+        if (edge.deletion !== void 0 && deletionConfigFromEntDefinition(otherTable) === void 0) {
+          throw new Error(
+            `Cannot specify soft deletion behavior for edge "${edge.name}" in table "${tableName}" because the target table "${otherTableName}" does not have a "soft" or "scheduled" deletion behavior configured.`
+          );
+        }
+      }
       if (edge.cardinality === "multiple") {
         if (!isSelfDirected && inverseEdge === void 0) {
           throw new Error(
@@ -165,11 +178,14 @@ function canBeInverseEdge(tableName, edge, isSelfDirected) {
     return true;
   };
 }
-function edgeConfigsFromEntDefinition(table) {
+function edgeConfigsBeforeDefineSchema(table) {
   return Object.values(
     table.edgeConfigs
   );
 }
+function deletionConfigFromEntDefinition(table) {
+  return table.deletionConfig;
+}
 function defineEnt(documentSchema) {
   return new EntDefinitionImpl(documentSchema);
 }
@@ -187,6 +203,7 @@ var EntDefinitionImpl = class {
   edgeConfigs = {};
   fieldConfigs = {};
   defaults = {};
+  deletionConfig;
   constructor(documentSchema) {
     this.documentSchema = documentSchema;
   }
@@ -292,7 +309,8 @@ var EntDefinitionImpl = class {
       );
     }
     const inverseName = options?.inverse;
-    this.edgeConfigs[name] = ref !== void 0 ? { name, to, cardinality, type: "field", ref } : { name, to, cardinality, type: "ref", table, field, inverseField };
+    const deletion = options?.deletion;
+    this.edgeConfigs[name] = ref !== void 0 ? { name, to, cardinality, type: "field", ref, deletion } : { name, to, cardinality, type: "ref", table, field, inverseField };
     if (inverseName !== void 0) {
       this.edgeConfigs[inverseName] = {
         name: inverseName,
@@ -305,6 +323,22 @@ var EntDefinitionImpl = class {
     }
     return this;
   }
+  deletion(type, options) {
+    if (this.documentSchema.deletionTime !== void 0) {
+      throw new Error(
+        `Cannot enable "${type}" deletion because "deletionTime" field was already defined.`
+      );
+    }
+    if (this.deletionConfig !== void 0) {
+      throw new Error(`Deletion behavior can only be specified once.`);
+    }
+    this.documentSchema = {
+      ...this.documentSchema,
+      deletionTime: import_values.v.optional(import_values.v.number())
+    };
+    this.deletionConfig = { type, ...options };
+    return this;
+  }
 };
 function getEntDefinitions(schema) {
   const tables = schema.tables;
@@ -314,7 +348,8 @@ function getEntDefinitions(schema) {
       [tableName]: {
         defaults: tables[tableName].defaults,
         edges: tables[tableName].edgeConfigs,
-        fields: tables[tableName].fieldConfigs
+        fields: tables[tableName].fieldConfigs,
+        deletionConfig: tables[tableName].deletionConfig
       }
     }),
     {}
@@ -322,79 +357,119 @@ function getEntDefinitions(schema) {
 }
 
 // src/writer.ts
-var WriterImplBase = class {
-  constructor(db, entDefinitions, table) {
-    this.db = db;
+var import_server2 = require("convex/server");
+var WriterImplBase = class _WriterImplBase {
+  constructor(ctx, entDefinitions, table) {
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
   }
-  async writeEdges(docId, changes) {
+  async deleteId(id, behavior) {
+    await this.checkReadAndWriteRule("delete", id, void 0);
+    const deletionConfig = getDeletionConfig(this.entDefinitions, this.table);
+    const isDeletingSoftly = behavior !== "hard" && deletionConfig !== void 0 && (deletionConfig.type === "soft" || deletionConfig.type === "scheduled");
+    if (behavior === "soft" && !isDeletingSoftly) {
+      throw new Error(
+        `Cannot soft delete document with ID "${id}" in table "${this.table}" because it does not have an "allowSoft", "soft" or "scheduled" deletion behavior configured.`
+      );
+    }
+    const edges = {};
     await Promise.all(
-      Object.values(
-        this.entDefinitions[this.table].edges
-      ).map(async (edgeDefinition) => {
-        const idOrIds = changes[edgeDefinition.name];
-        if (idOrIds === void 0) {
-          return;
-        }
-        if (edgeDefinition.cardinality === "single") {
-          if (edgeDefinition.type === "ref") {
-            if (idOrIds.remove !== void 0) {
-              await this.db.delete(idOrIds.remove);
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          const key = edgeDefinition.name;
+          if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
+            if (!isDeletingSoftly || edgeDefinition.deletion === "soft") {
+              const remove = (await this.ctx.db.query(edgeDefinition.to).withIndex(
+                edgeDefinition.ref,
+                (q) => q.eq(edgeDefinition.ref, id)
+              ).collect()).map((doc) => doc._id);
+              edges[key] = { remove };
             }
-            if (idOrIds.add !== void 0) {
-              await this.db.patch(
-                idOrIds.add,
-                { [edgeDefinition.ref]: docId }
-              );
+          } else if (edgeDefinition.cardinality === "multiple") {
+            if (!isDeletingSoftly) {
+              const removeEdges = (await this.ctx.db.query(edgeDefinition.table).withIndex(
+                edgeDefinition.field,
+                (q) => q.eq(edgeDefinition.field, id)
+              ).collect()).concat(
+                edgeDefinition.symmetric ? await this.ctx.db.query(edgeDefinition.table).withIndex(
+                  edgeDefinition.ref,
+                  (q) => q.eq(edgeDefinition.ref, id)
+                ).collect() : []
+              ).map((doc) => doc._id);
+              edges[key] = { removeEdges };
             }
           }
-        } else {
-          if (edgeDefinition.type === "field") {
-            if (idOrIds.remove !== void 0) {
+        }
+      )
+    );
+    const deletionTime = +/* @__PURE__ */ new Date();
+    if (isDeletingSoftly) {
+      await this.ctx.db.patch(id, { deletionTime });
+    } else {
+      try {
+        await this.ctx.db.delete(id);
+      } catch (e) {
+      }
+    }
+    await this.writeEdges(id, edges, isDeletingSoftly);
+    if (deletionConfig !== void 0 && deletionConfig.type === "scheduled") {
+      const fnRef = this.ctx.scheduledDelete ?? (0, import_server2.makeFunctionReference)(
+        "functions:scheduledDelete"
+      );
+      await this.ctx.scheduler.runAfter(deletionConfig.delayMs ?? 0, fnRef, {
+        origin: {
+          id,
+          table: this.table,
+          deletionTime
+        },
+        inProgress: false,
+        stack: []
+      });
+    }
+    return id;
+  }
+  async deletedIdIn(id, table, cascadingSoft) {
+    await new _WriterImplBase(this.ctx, this.entDefinitions, table).deleteId(
+      id,
+      cascadingSoft ? "soft" : "hard"
+    );
+  }
+  async writeEdges(docId, changes, deleteSoftly) {
+    await Promise.all(
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          const idOrIds = changes[edgeDefinition.name];
+          if (idOrIds === void 0) {
+            return;
+          }
+          if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
+            if (idOrIds.remove !== void 0 && idOrIds.remove.length > 0) {
               await Promise.all(
                 idOrIds.remove.map(
-                  (id) => this.db.delete(id)
+                  (id) => this.deletedIdIn(
+                    id,
+                    edgeDefinition.to,
+                    (deleteSoftly ?? false) && edgeDefinition.deletion === "soft"
+                  )
                 )
               );
             }
-            if (idOrIds.add !== void 0) {
+            if (idOrIds.add !== void 0 && idOrIds.add.length > 0) {
               await Promise.all(
                 idOrIds.add.map(
-                  async (id) => this.db.patch(id, {
+                  async (id) => this.ctx.db.patch(id, {
                     [edgeDefinition.ref]: docId
                   })
                 )
               );
             }
-          } else {
-            let removeEdges = [];
-            if (idOrIds.remove !== void 0) {
-              removeEdges = (await Promise.all(
-                idOrIds.remove.map(
-                  async (id) => (await this.db.query(edgeDefinition.table).withIndex(
-                    edgeDefinition.field,
-                    (q) => q.eq(edgeDefinition.field, docId).eq(
-                      edgeDefinition.ref,
-                      id
-                    )
-                  ).collect()).concat(
-                    edgeDefinition.symmetric ? await this.db.query(edgeDefinition.table).withIndex(
-                      edgeDefinition.ref,
-                      (q) => q.eq(edgeDefinition.ref, docId).eq(edgeDefinition.field, id)
-                    ).collect() : []
-                  )
-                )
-              )).map((doc) => doc._id);
-            }
-            if (idOrIds.removeEdges !== void 0) {
-              removeEdges = idOrIds.removeEdges;
-            }
-            if (removeEdges.length > 0) {
+          } else if (edgeDefinition.cardinality === "multiple") {
+            if ((idOrIds.removeEdges ?? []).length > 0) {
               await Promise.all(
-                removeEdges.map(async (id) => {
+                idOrIds.removeEdges.map(async (id) => {
                   try {
-                    await this.db.delete(id);
+                    await this.ctx.db.delete(id);
                   } catch (e) {
                   }
                 })
@@ -403,12 +478,12 @@ var WriterImplBase = class {
             if (idOrIds.add !== void 0) {
               await Promise.all(
                 idOrIds.add.map(async (id) => {
-                  await this.db.insert(edgeDefinition.table, {
+                  await this.ctx.db.insert(edgeDefinition.table, {
                     [edgeDefinition.field]: docId,
                     [edgeDefinition.ref]: id
                   });
                   if (edgeDefinition.symmetric) {
-                    await this.db.insert(edgeDefinition.table, {
+                    await this.ctx.db.insert(edgeDefinition.table, {
                       [edgeDefinition.field]: id,
                       [edgeDefinition.ref]: docId
                     });
@@ -418,7 +493,7 @@ var WriterImplBase = class {
             }
           }
         }
-      })
+      )
     );
   }
   async checkUniqueness(value, id) {
@@ -429,7 +504,7 @@ var WriterImplBase = class {
         if (fieldDefinition.unique) {
           const key = fieldDefinition.name;
           const fieldValue = value[key];
-          const existing = await this.db.query(this.table).withIndex(key, (q) => q.eq(key, value[key])).unique();
+          const existing = await this.ctx.db.query(this.table).withIndex(key, (q) => q.eq(key, value[key])).unique();
           if (existing !== null && (id === void 0 || existing._id !== id)) {
             throw new Error(
               `In table "${this.table}" cannot create a duplicate document with field "${key}" of value \`${fieldValue}\`, existing document with ID "${existing._id}" already has it.`
@@ -439,28 +514,31 @@ var WriterImplBase = class {
       })
     );
     await Promise.all(
-      Object.values(
-        this.entDefinitions[this.table].edges
-      ).map(async (edgeDefinition) => {
-        if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "field" && edgeDefinition.unique) {
-          const key = edgeDefinition.field;
-          if (value[key] === void 0) {
-            return;
-          }
-          const existing = await this.db.query(this.table).withIndex(key, (q) => q.eq(key, value[key])).unique();
-          if (existing !== null && (id === void 0 || existing._id !== id)) {
-            throw new Error(
-              `In table "${this.table}" cannot create a duplicate 1:1 edge "${edgeDefinition.name}" to ID "${value[key]}", existing document with ID "${existing._id}" already has it.`
-            );
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "field" && edgeDefinition.unique) {
+            const key = edgeDefinition.field;
+            if (value[key] === void 0) {
+              return;
+            }
+            const existing = await this.ctx.db.query(this.table).withIndex(key, (q) => q.eq(key, value[key])).unique();
+            if (existing !== null && (id === void 0 || existing._id !== id)) {
+              throw new Error(
+                `In table "${this.table}" cannot create a duplicate 1:1 edge "${edgeDefinition.name}" to ID "${value[key]}", existing document with ID "${existing._id}" already has it.`
+              );
+            }
           }
         }
-      })
+      )
     );
   }
   fieldsOnly(value) {
     const fields = {};
     Object.keys(value).forEach((key) => {
-      const edgeDefinition = this.entDefinitions[this.table].edges[key];
+      const edgeDefinition = getEdgeDefinitions(
+        this.entDefinitions,
+        this.table
+      )[key];
       if (edgeDefinition === void 0) {
         fields[key] = value[key];
       }
@@ -471,7 +549,7 @@ var WriterImplBase = class {
     if (id !== void 0) {
       const readPolicy = getReadRule(this.entDefinitions, this.table);
       if (readPolicy !== void 0) {
-        const doc = await this.db.get(id);
+        const doc = await this.ctx.db.get(id);
         if (doc === null) {
           throw new Error(
             `Cannot update document with ID "${id}" in table "${this.table} because it does not exist"`
@@ -490,8 +568,8 @@ var WriterImplBase = class {
       return;
     }
     const ent = id === void 0 ? void 0 : entWrapper(
-      await this.db.get(id),
-      this.db,
+      await this.ctx.db.get(id),
+      this.ctx,
       this.entDefinitions,
       this.table
     );
@@ -523,17 +601,17 @@ var WriterImplBase = class {
 
 // src/functions.ts
 var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
-  constructor(db, entDefinitions, table, retrieve) {
+  constructor(ctx, entDefinitions, table, retrieve) {
     super(() => {
     });
-    this.db = db;
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
   }
   filter(predicate) {
     return new _PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -545,16 +623,18 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
     );
   }
-  async map(callbackFn) {
-    const array = await this;
-    if (array === null) {
-      return [];
-    }
-    return await Promise.all(array.map(callbackFn));
+  map(callbackFn) {
+    return new PromiseArrayImpl(async () => {
+      const array = await this;
+      if (array === null) {
+        return null;
+      }
+      return await Promise.all(array.map(callbackFn));
+    });
   }
   order(order, indexName) {
     return new _PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -569,17 +649,18 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
     );
   }
-  // TODO: RLS for pagination
-  async paginate(paginationOpts) {
-    const query = await this.retrieve();
-    if (query === null) {
-      return null;
-    }
-    return await query.paginate(paginationOpts);
+  paginate(paginationOpts) {
+    return new PromisePaginationResultOrNullImpl(
+      this.ctx,
+      this.entDefinitions,
+      this.table,
+      this.retrieve,
+      paginationOpts
+    );
   }
   take(n) {
     return new PromiseEntsOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -590,7 +671,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   first() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -606,7 +687,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   firstX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -625,7 +706,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -647,7 +728,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   uniqueX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -674,7 +755,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     }
     const docs = await query.collect();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -684,7 +765,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   then(onfulfilled, onrejected) {
     return this.docs().then(
       (documents) => documents === null ? null : documents.map(
-        (doc) => entWrapper(doc, this.db, this.entDefinitions, this.table)
+        (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
       )
     ).then(onfulfilled, onrejected);
   }
@@ -713,7 +794,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
       docs.push(
         ...(await filterByReadRule(
-          this.db,
+          this.ctx,
           this.entDefinitions,
           this.table,
           page,
@@ -725,9 +806,57 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     return docs;
   }
 };
+var PromisePaginationResultOrNullImpl = class extends Promise {
+  constructor(ctx, entDefinitions, table, retrieve, paginationOpts) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.paginationOpts = paginationOpts;
+  }
+  async map(callbackFn) {
+    const result = await this;
+    if (result === null) {
+      return null;
+    }
+    return {
+      ...result,
+      page: await Promise.all(result.page.map(callbackFn))
+    };
+  }
+  async docs() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const result = await query.paginate(this.paginationOpts);
+    return {
+      ...result,
+      page: await filterByReadRule(
+        this.ctx,
+        this.entDefinitions,
+        this.table,
+        result.page,
+        false
+      )
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (result) => result === null ? null : {
+        ...result,
+        page: result.page.map(
+          (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
+        )
+      }
+    ).then(onfulfilled, onrejected);
+  }
+};
 var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
-  constructor(db, entDefinitions, table) {
-    super(db, entDefinitions, table, async () => db.query(table));
+  constructor(ctx, entDefinitions, table) {
+    super(ctx, entDefinitions, table, async () => ctx.db.query(table));
   }
   get(...args) {
     return this.getImpl(args);
@@ -743,18 +872,18 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   getImpl(args, throwIfNull = false) {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       args.length === 1 ? async () => {
         const id = args[0];
-        if (this.db.normalizeId(this.table, id) === null) {
+        if (this.ctx.db.normalizeId(this.table, id) === null) {
           throw new Error(`Invalid id \`${id}\` for table "${this.table}"`);
         }
         return {
           id,
           doc: async () => {
-            const doc = await this.db.get(id);
+            const doc = await this.ctx.db.get(id);
             if (throwIfNull && doc === null) {
               throw new Error(
                 `Document not found with id \`${id}\` in table "${this.table}"`
@@ -765,7 +894,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         };
       } : async () => {
         const [indexName, value] = args;
-        const doc = await this.db.query(this.table).withIndex(indexName, (q) => q.eq(indexName, value)).unique();
+        const doc = await this.ctx.db.query(this.table).withIndex(indexName, (q) => q.eq(indexName, value)).unique();
         if (throwIfNull && doc === null) {
           throw new Error(
             `Table "${this.table}" does not contain document with field "${indexName}" = \`${value}\``
@@ -778,13 +907,13 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   getManyImpl(args, throwIfNull = false) {
     return new PromiseEntsOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       args.length === 1 ? async () => {
         const ids = args[0];
         ids.forEach((id) => {
-          if (this.db.normalizeId(this.table, id) === null) {
+          if (this.ctx.db.normalizeId(this.table, id) === null) {
             throw new Error(
               `Invalid id \`${id}\` for table "${this.table}"`
             );
@@ -792,7 +921,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         });
         return await Promise.all(
           ids.map(async (id) => {
-            const doc = await this.db.get(id);
+            const doc = await this.ctx.db.get(id);
             if (doc === null) {
               throw new Error(
                 `Document not found with id \`${id}\` in table "${this.table}"`
@@ -805,7 +934,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
         const [indexName, values] = args;
         return await Promise.all(
           values.map(async (value) => {
-            const doc = await this.db.query(this.table).withIndex(indexName, (q) => q.eq(indexName, value)).unique();
+            const doc = await this.ctx.db.query(this.table).withIndex(indexName, (q) => q.eq(indexName, value)).unique();
             if (throwIfNull && doc === null) {
               throw new Error(
                 `Table "${this.table}" does not contain document with field "${indexName}" = \`${value}\``
@@ -819,7 +948,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
     );
   }
   normalizeId(id) {
-    return this.db.normalizeId(this.table, id);
+    return this.ctx.db.normalizeId(this.table, id);
   }
   // normalizeId or throw
   normalizeIdX(id) {
@@ -831,7 +960,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   withIndex(indexName, indexRange) {
     return new PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -842,7 +971,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   search(indexName, searchFilter) {
     return new PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -853,25 +982,27 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
 };
 var PromiseEntsOrNullImpl = class extends Promise {
-  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
+  constructor(ctx, entDefinitions, table, retrieve, throwIfNull) {
     super(() => {
     });
-    this.db = db;
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
     this.throwIfNull = throwIfNull;
   }
-  async map(callbackFn) {
-    const array = await this;
-    if (array === null) {
-      return [];
-    }
-    return await Promise.all(array.map(callbackFn));
+  map(callbackFn) {
+    return new PromiseArrayImpl(async () => {
+      const array = await this;
+      if (array === null) {
+        return null;
+      }
+      return await Promise.all(array.map(callbackFn));
+    });
   }
   first() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -886,7 +1017,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   firstX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -905,7 +1036,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -923,7 +1054,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   uniqueX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -945,7 +1076,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   async docs() {
     const docs = await this.retrieve();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -955,14 +1086,14 @@ var PromiseEntsOrNullImpl = class extends Promise {
   then(onfulfilled, onrejected) {
     return this.docs().then(
       (docs) => docs === null ? null : docs.map(
-        (doc) => entWrapper(doc, this.db, this.entDefinitions, this.table)
+        (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
       )
     ).then(onfulfilled, onrejected);
   }
 };
 var PromiseEdgeOrNullImpl = class extends PromiseEntsOrNullImpl {
-  constructor(db, entDefinitions, table, field, retrieveRange) {
-    super(db, entDefinitions, table, () => retrieveRange((q) => q), false);
+  constructor(ctx, entDefinitions, table, field, retrieveRange) {
+    super(ctx, entDefinitions, table, () => retrieveRange((q) => q), false);
     this.field = field;
     this.retrieveRange = retrieveRange;
   }
@@ -972,10 +1103,10 @@ var PromiseEdgeOrNullImpl = class extends PromiseEntsOrNullImpl {
   }
 };
 var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
-  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
+  constructor(ctx, entDefinitions, table, retrieve, throwIfNull) {
     super(() => {
     });
-    this.db = db;
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
@@ -993,7 +1124,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
     const readPolicy = getReadRule(this.entDefinitions, this.table);
     if (readPolicy !== void 0) {
       const decision = await readPolicy(
-        entWrapper(doc, this.db, this.entDefinitions, this.table)
+        entWrapper(doc, this.ctx, this.entDefinitions, this.table)
       );
       if (this.throwIfNull && !decision) {
         throw new Error(
@@ -1006,7 +1137,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
   }
   then(onfulfilled, onrejected) {
     return this.doc().then(
-      (doc) => doc === null ? null : entWrapper(doc, this.db, this.entDefinitions, this.table)
+      (doc) => doc === null ? null : entWrapper(doc, this.ctx, this.entDefinitions, this.table)
     ).then(onfulfilled, onrejected);
   }
   edge(edge) {
@@ -1016,11 +1147,11 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
     return this.edgeImpl(edge, true);
   }
   edgeImpl(edge, throwIfNull = false) {
-    const edgeDefinition = this.entDefinitions[this.table].edges[edge];
+    const edgeDefinition = getEdgeDefinitions(this.entDefinitions, this.table)[edge];
     if (edgeDefinition.cardinality === "multiple") {
       if (edgeDefinition.type === "ref") {
         return new PromiseEdgeOrNullImpl(
-          this.db,
+          this.ctx,
           this.entDefinitions,
           edgeDefinition.to,
           edgeDefinition.ref,
@@ -1029,13 +1160,13 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
             if (id === null) {
               return null;
             }
-            const edgeDocs = await this.db.query(edgeDefinition.table).withIndex(
+            const edgeDocs = await this.ctx.db.query(edgeDefinition.table).withIndex(
               edgeDefinition.field,
               (q) => indexRange(q.eq(edgeDefinition.field, id))
             ).collect();
             return (await Promise.all(
               edgeDocs.map(
-                (edgeDoc) => this.db.get(edgeDoc[edgeDefinition.ref])
+                (edgeDoc) => this.ctx.db.get(edgeDoc[edgeDefinition.ref])
               )
             )).filter((doc, i) => {
               if (doc === null) {
@@ -1049,7 +1180,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
         );
       }
       return new PromiseQueryOrNullImpl(
-        this.db,
+        this.ctx,
         this.entDefinitions,
         edgeDefinition.to,
         async () => {
@@ -1057,7 +1188,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
           if (id === null) {
             return null;
           }
-          return this.db.query(edgeDefinition.to).withIndex(
+          return this.ctx.db.query(edgeDefinition.to).withIndex(
             edgeDefinition.ref,
             (q) => q.eq(edgeDefinition.ref, id)
           );
@@ -1065,7 +1196,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
       );
     }
     return new _PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       edgeDefinition.to,
       async () => {
@@ -1074,7 +1205,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
           return nullRetriever;
         }
         if (edgeDefinition.type === "ref") {
-          const otherDoc = await this.db.query(edgeDefinition.to).withIndex(
+          const otherDoc = await this.ctx.db.query(edgeDefinition.to).withIndex(
             edgeDefinition.ref,
             (q) => q.eq(edgeDefinition.ref, id)
           ).unique();
@@ -1090,7 +1221,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
         return {
           id: otherId,
           doc: async () => {
-            const otherDoc = await this.db.get(otherId);
+            const otherDoc = await this.ctx.db.get(otherId);
             if (otherDoc === null) {
               throw new Error(
                 `Dangling reference for edge "${edgeDefinition.name}" in table "${this.table}" for document with ID "${id}": Could not find a document with ID "${otherId}" in table "${edgeDefinition.to}".`
@@ -1104,10 +1235,27 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
     );
   }
 };
-function entWrapper(fields, db, entDefinitions, table) {
+var PromiseArrayImpl = class extends Promise {
+  constructor(retrieve) {
+    super(() => {
+    });
+    this.retrieve = retrieve;
+  }
+  async filter(predicate) {
+    const array = await this.retrieve();
+    if (array === null) {
+      return null;
+    }
+    return array.filter(predicate);
+  }
+  then(onfulfilled, onrejected) {
+    return this.retrieve().then(onfulfilled, onrejected);
+  }
+};
+function entWrapper(fields, ctx, entDefinitions, table) {
   const doc = { ...fields };
   const queryInterface = new PromiseEntWriterImpl(
-    db,
+    ctx,
     entDefinitions,
     table,
     async () => ({ id: doc._id, doc: async () => doc }),
@@ -1130,6 +1278,14 @@ function entWrapper(fields, db, entDefinitions, table) {
     writable: false,
     configurable: false
   });
+  Object.defineProperty(doc, "doc", {
+    value: () => {
+      return doc;
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
   Object.defineProperty(doc, "patch", {
     value: (value) => {
       return queryInterface.patch(value);
@@ -1163,54 +1319,58 @@ function entWrapper(fields, db, entDefinitions, table) {
   );
   return doc;
 }
-function entsTableFactory(db, entDefinitions) {
+function entsTableFactory(ctx, entDefinitions, options) {
+  const enrichedCtx = options !== void 0 ? { ...ctx, ...options } : ctx;
   return (table, indexName, indexRange) => {
     if (typeof table !== "string") {
       throw new Error(`Expected table name, got \`${table}\``);
     }
     if (indexName !== void 0) {
-      return new PromiseTableImpl(db, entDefinitions, table).withIndex(
-        indexName,
-        indexRange
-      );
+      return new PromiseTableImpl(
+        enrichedCtx,
+        entDefinitions,
+        table
+      ).withIndex(indexName, indexRange);
     }
-    if (db.insert !== void 0) {
+    if (ctx.db.insert !== void 0) {
       return new PromiseTableWriterImpl(
-        db,
+        enrichedCtx,
         entDefinitions,
         table
       );
     }
-    return new PromiseTableImpl(db, entDefinitions, table);
+    return new PromiseTableImpl(enrichedCtx, entDefinitions, table);
   };
 }
 var PromiseTableWriterImpl = class extends PromiseTableImpl {
-  constructor(db, entDefinitions, table) {
-    super(db, entDefinitions, table);
-    this.db = db;
-    this.base = new WriterImplBase(db, entDefinitions, table);
+  constructor(ctx, entDefinitions, table) {
+    super(ctx, entDefinitions, table);
+    this.ctx = ctx;
+    this.base = new WriterImplBase(ctx, entDefinitions, table);
   }
   base;
   insert(value) {
     return new PromiseEntIdImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
         await this.base.checkReadAndWriteRule("create", void 0, value);
         await this.base.checkUniqueness(value);
         const fields = this.base.fieldsOnly(value);
-        const docId = await this.db.insert(this.table, fields);
+        const docId = await this.ctx.db.insert(this.table, fields);
         const edges = {};
         Object.keys(value).forEach((key) => {
-          const edgeDefinition = this.entDefinitions[this.table].edges[key];
+          const edgeDefinition = getEdgeDefinitions(
+            this.entDefinitions,
+            this.table
+          )[key];
           if (edgeDefinition === void 0 || edgeDefinition.cardinality === "single" && edgeDefinition.type === "field") {
             return;
           }
-          if (edgeDefinition.cardinality === "single") {
-            throw new Error("Cannot set 1:1 edge from optional end.");
-          }
-          edges[key] = { add: value[key] };
+          edges[key] = {
+            add: edgeDefinition.cardinality === "single" ? [value[key]] : value[key]
+          };
         });
         await this.base.writeEdges(docId, edges);
         return docId;
@@ -1223,19 +1383,19 @@ var PromiseTableWriterImpl = class extends PromiseTableImpl {
   }
 };
 var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
-  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
-    super(db, entDefinitions, table, retrieve, throwIfNull);
-    this.db = db;
+  constructor(ctx, entDefinitions, table, retrieve, throwIfNull) {
+    super(ctx, entDefinitions, table, retrieve, throwIfNull);
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
     this.throwIfNull = throwIfNull;
-    this.base = new WriterImplBase(db, entDefinitions, table);
+    this.base = new WriterImplBase(ctx, entDefinitions, table);
   }
   base;
   patch(value) {
     return new PromiseEntIdImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -1244,18 +1404,52 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
         await this.base.checkReadAndWriteRule("update", id, value);
         await this.base.checkUniqueness(value, id);
         const fields = this.base.fieldsOnly(value);
-        await this.db.patch(id, fields);
+        await this.ctx.db.patch(id, fields);
         const edges = {};
         await Promise.all(
           Object.keys(value).map(async (key) => {
-            const edgeDefinition = this.entDefinitions[this.table].edges[key];
+            const edgeDefinition = getEdgeDefinitions(
+              this.entDefinitions,
+              this.table
+            )[key];
             if (edgeDefinition === void 0 || edgeDefinition.cardinality === "single" && edgeDefinition.type === "field") {
               return;
             }
             if (edgeDefinition.cardinality === "single") {
-              throw new Error("Cannot set 1:1 edge from optional end.");
+              throw new Error(
+                `Cannot set 1:1 edge "${edgeDefinition.name}" on ent in table "${this.table}", update the ent in "${edgeDefinition.to}"  table instead.`
+              );
             } else {
-              edges[key] = value[key];
+              if (edgeDefinition.type === "field") {
+                throw new Error(
+                  `Cannot set 1:many edges "${edgeDefinition.name}" on ent in table "${this.table}", update the ents in "${edgeDefinition.to}"  table instead.`
+                );
+              } else {
+                const { add, remove } = value[key];
+                const removeEdges = (await Promise.all(
+                  (remove ?? []).map(
+                    async (edgeId) => (await this.ctx.db.query(edgeDefinition.table).withIndex(
+                      edgeDefinition.field,
+                      (q) => q.eq(edgeDefinition.field, id).eq(
+                        edgeDefinition.ref,
+                        edgeId
+                      )
+                    ).collect()).concat(
+                      edgeDefinition.symmetric ? await this.ctx.db.query(edgeDefinition.table).withIndex(
+                        edgeDefinition.ref,
+                        (q) => q.eq(edgeDefinition.ref, id).eq(
+                          edgeDefinition.field,
+                          edgeId
+                        )
+                      ).collect() : []
+                    )
+                  )
+                )).map((edgeDoc) => edgeDoc._id);
+                edges[key] = {
+                  add,
+                  removeEdges
+                };
+              }
             }
           })
         );
@@ -1266,7 +1460,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   }
   replace(value) {
     return new PromiseEntIdImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -1275,38 +1469,33 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
         await this.base.checkReadAndWriteRule("update", docId, value);
         await this.base.checkUniqueness(value, docId);
         const fields = this.base.fieldsOnly(value);
-        await this.db.replace(docId, fields);
+        await this.ctx.db.replace(docId, fields);
         const edges = {};
         await Promise.all(
           Object.values(
-            this.entDefinitions[this.table].edges
+            getEdgeDefinitions(this.entDefinitions, this.table)
           ).map(async (edgeDefinition) => {
             const key = edgeDefinition.name;
             const idOrIds = value[key];
             if (edgeDefinition.cardinality === "single") {
               if (edgeDefinition.type === "ref") {
-                const oldDoc = await this.db.get(docId);
+                const oldDoc = await this.ctx.db.get(docId);
                 if (oldDoc[key] !== void 0 && oldDoc[key] !== idOrIds) {
                   throw new Error("Cannot set 1:1 edge from optional end.");
                 }
               }
             } else {
               if (edgeDefinition.type === "field") {
-                const existing = (await this.db.query(edgeDefinition.to).withIndex(
-                  edgeDefinition.ref,
-                  (q) => q.eq(edgeDefinition.ref, docId)
-                ).collect()).map((doc) => doc._id);
-                edges[key] = {
-                  add: idOrIds,
-                  remove: existing
-                };
+                if (idOrIds !== void 0) {
+                  throw new Error("Cannot set 1:many edge from many end.");
+                }
               } else {
                 const requested = new Set(idOrIds ?? []);
-                const remove = (await this.db.query(edgeDefinition.table).withIndex(
+                const removeEdges = (await this.ctx.db.query(edgeDefinition.table).withIndex(
                   edgeDefinition.field,
                   (q) => q.eq(edgeDefinition.field, docId)
                 ).collect()).map((doc) => [doc._id, doc[edgeDefinition.ref]]).concat(
-                  edgeDefinition.symmetric ? (await this.db.query(edgeDefinition.table).withIndex(
+                  edgeDefinition.symmetric ? (await this.ctx.db.query(edgeDefinition.table).withIndex(
                     edgeDefinition.ref,
                     (q) => q.eq(edgeDefinition.ref, docId)
                   ).collect()).map(
@@ -1320,8 +1509,8 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
                   return true;
                 }).map(([edgeId]) => edgeId);
                 edges[key] = {
-                  add: Array.from(requested),
-                  removeEdges: remove
+                  add: idOrIds ?? [],
+                  removeEdges
                 };
               }
             }
@@ -1335,70 +1524,26 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   async delete() {
     const { id: docId } = await this.retrieve();
     const id = docId;
-    await this.base.checkReadAndWriteRule("delete", id, void 0);
-    let memoized = void 0;
-    const oldDoc = async () => {
-      if (memoized !== void 0) {
-        return memoized;
-      }
-      return memoized = await this.db.get(id);
-    };
-    const edges = {};
-    await Promise.all(
-      Object.values(
-        this.entDefinitions[this.table].edges
-      ).map(async (edgeDefinition) => {
-        const key = edgeDefinition.name;
-        if (edgeDefinition.cardinality === "single") {
-          if (edgeDefinition.type === "ref") {
-            edges[key] = {
-              remove: (await oldDoc())[key]
-            };
-          }
-        } else {
-          if (edgeDefinition.type === "field") {
-            const existing = (await this.db.query(edgeDefinition.to).withIndex(
-              edgeDefinition.ref,
-              (q) => q.eq(edgeDefinition.ref, id)
-            ).collect()).map((doc) => doc._id);
-            edges[key] = { remove: existing };
-          } else {
-            const existing = (await this.db.query(edgeDefinition.table).withIndex(
-              edgeDefinition.field,
-              (q) => q.eq(edgeDefinition.field, id)
-            ).collect()).concat(
-              edgeDefinition.symmetric ? await this.db.query(edgeDefinition.table).withIndex(
-                edgeDefinition.ref,
-                (q) => q.eq(edgeDefinition.ref, id)
-              ).collect() : []
-            ).map((doc) => doc._id);
-            edges[key] = { removeEdges: existing };
-          }
-        }
-      })
-    );
-    await this.db.delete(id);
-    await this.base.writeEdges(id, edges);
-    return id;
+    return this.base.deleteId(id, "default");
   }
 };
 var PromiseEntIdImpl = class extends Promise {
-  constructor(db, entDefinitions, table, retrieve) {
+  constructor(ctx, entDefinitions, table, retrieve) {
     super(() => {
     });
-    this.db = db;
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
   }
   get() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
         const id = await this.retrieve();
-        return { id, doc: async () => this.db.get(id) };
+        return { id, doc: async () => this.ctx.db.get(id) };
       },
       true
     );
@@ -1420,28 +1565,28 @@ function loadedRetriever(doc) {
 function addEntRules(entDefinitions, rules) {
   return { ...entDefinitions, rules };
 }
-async function filterByReadRule(db, entDefinitions, table, docs, throwIfNull) {
+async function filterByReadRule(ctx, entDefinitions, table, docs, throwIfNull) {
   if (docs === null) {
     return null;
   }
   const readPolicy = getReadRule(entDefinitions, table);
-  if (readPolicy !== void 0) {
-    const decisions = await Promise.all(
-      docs.map(async (doc) => {
-        const decision = await readPolicy(
-          entWrapper(doc, db, entDefinitions, table)
-        );
-        if (throwIfNull && !decision) {
-          throw new Error(
-            `Document cannot be read with id \`${doc._id}\` in table "${table}"`
-          );
-        }
-        return decision;
-      })
-    );
-    return docs.filter((_, i) => decisions[i]);
+  if (readPolicy === void 0) {
+    return docs;
   }
-  return docs;
+  const decisions = await Promise.all(
+    docs.map(async (doc) => {
+      const decision = await readPolicy(
+        entWrapper(doc, ctx, entDefinitions, table)
+      );
+      if (throwIfNull && !decision) {
+        throw new Error(
+          `Document cannot be read with id \`${doc._id}\` in table "${table}"`
+        );
+      }
+      return decision;
+    })
+  );
+  return docs.filter((_, i) => decisions[i]);
 }
 function getReadRule(entDefinitions, table) {
   return entDefinitions.rules?.[table]?.read;
@@ -1449,12 +1594,201 @@ function getReadRule(entDefinitions, table) {
 function getWriteRule(entDefinitions, table) {
   return entDefinitions.rules?.[table]?.write;
 }
+function getEdgeDefinitions(entDefinitions, table) {
+  return entDefinitions[table].edges;
+}
+function getDeletionConfig(entDefinitions, table) {
+  return entDefinitions[table].deletionConfig;
+}
+
+// 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")
+);
+function scheduledDeleteFactory(entDefinitions, options) {
+  const selfRef = options?.scheduledDelete ?? (0, import_server3.makeFunctionReference)(
+    "functions:scheduledDelete"
+  );
+  return (0, import_server3.internalMutationGeneric)({
+    args: {
+      origin: import_values2.v.object({
+        id: import_values2.v.string(),
+        table: import_values2.v.string(),
+        deletionTime: import_values2.v.number()
+      }),
+      stack: import_values2.v.array(
+        import_values2.v.union(
+          import_values2.v.object({
+            id: import_values2.v.string(),
+            table: import_values2.v.string(),
+            edges: import_values2.v.array(
+              import_values2.v.object({
+                approach: vApproach,
+                table: import_values2.v.string(),
+                indexName: import_values2.v.string()
+              })
+            )
+          }),
+          import_values2.v.object({
+            approach: vApproach,
+            cursor: import_values2.v.union(import_values2.v.string(), import_values2.v.null()),
+            table: import_values2.v.string(),
+            indexName: import_values2.v.string(),
+            fieldValue: import_values2.v.any()
+          })
+        )
+      ),
+      inProgress: import_values2.v.boolean()
+    },
+    handler: async (ctx, { origin, stack, inProgress }) => {
+      const originId = ctx.db.normalizeId(origin.table, origin.id);
+      if (originId === null) {
+        throw new Error(`Invalid ID "${origin.id}" for table ${origin.table}`);
+      }
+      const doc = await ctx.db.get(originId);
+      if (doc.deletionTime !== origin.deletionTime) {
+        if (inProgress) {
+          console.error(
+            `[Ents] Already in-progress scheduled deletion for "${origin.id}" was cancelled!`
+          );
+        } else {
+          console.log(
+            `[Ents] Scheduled deletion for "${origin.id}" was cancelled`
+          );
+        }
+        return;
+      }
+      await progressScheduledDeletion(
+        ctx,
+        entDefinitions,
+        selfRef,
+        origin,
+        inProgress ? stack : [
+          {
+            id: originId,
+            table: origin.table,
+            edges: getEdgeArgs(entDefinitions, origin.table)
+          }
+        ]
+      );
+    }
+  });
+}
+function getEdgeArgs(entDefinitions, table) {
+  const edges = getEdgeDefinitions(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 indexName = edgeDefinition.ref;
+      return [{ table: table2, indexName, approach }];
+    } else if (edgeDefinition.cardinality === "multiple") {
+      const table2 = edgeDefinition.table;
+      return [
+        {
+          table: table2,
+          indexName: edgeDefinition.field,
+          approach: "paginate"
+        },
+        ...edgeDefinition.symmetric ? [
+          {
+            table: table2,
+            indexName: edgeDefinition.ref,
+            approach: "paginate"
+          }
+        ] : []
+      ];
+    } else {
+      return [];
+    }
+  });
+}
+async function progressScheduledDeletion(ctx, entDefinitions, selfRef, origin, stack) {
+  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
+        });
+      }
+    } else {
+      const updated = { ...last, edges: last.edges.slice(1) };
+      await paginate(
+        ctx,
+        entDefinitions,
+        selfRef,
+        origin,
+        stack.slice(0, -1).concat(updated),
+        { cursor: null, fieldValue: last.id, ...edgeArgs }
+      );
+    }
+  } else {
+    await paginate(ctx, entDefinitions, selfRef, origin, 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 }
+  });
+  const updated = {
+    approach,
+    table,
+    cursor: continueCursor,
+    indexName,
+    fieldValue
+  };
+  const relevantStack = cursor === null ? stack : stack.slice(0, -1);
+  if (approach === "schedule") {
+    await ctx.scheduler.runAfter(0, selfRef, {
+      origin,
+      stack: isDone ? relevantStack : relevantStack.concat([
+        updated,
+        {
+          id: page[0]._id,
+          table,
+          edges: getEdgeArgs(entDefinitions, table)
+        }
+      ]),
+      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 ctx.scheduler.runAfter(0, selfRef, {
+      origin,
+      stack: isDone ? relevantStack : relevantStack.concat([updated]),
+      inProgress: true
+    });
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addEntRules,
   defineEnt,
   defineEntSchema,
   entsTableFactory,
-  getEntDefinitions
+  getEntDefinitions,
+  scheduledDeleteFactory
 });
 //# sourceMappingURL=index.js.map