convex-ents 0.2.0 → 0.3.0

package/dist/writer.js

@@ -23,20 +23,21 @@ __export(writer_exports, {
   WriterImplBase: () => WriterImplBase
 });
 module.exports = __toCommonJS(writer_exports);
+var import_server = require("convex/server");
 
 // 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 () => {
@@ -48,16 +49,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 () => {
@@ -74,7 +77,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   paginate(paginationOpts) {
     return new PromisePaginationResultOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       this.retrieve,
@@ -83,7 +86,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   take(n) {
     return new PromiseEntsOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -94,7 +97,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   first() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -110,7 +113,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   firstX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -129,7 +132,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -151,7 +154,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   uniqueX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -178,7 +181,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     }
     const docs = await query.collect();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -188,7 +191,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);
   }
@@ -217,7 +220,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
       docs.push(
         ...(await filterByReadRule(
-          this.db,
+          this.ctx,
           this.entDefinitions,
           this.table,
           page,
@@ -230,10 +233,10 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
 };
 var PromisePaginationResultOrNullImpl = class extends Promise {
-  constructor(db, entDefinitions, table, retrieve, paginationOpts) {
+  constructor(ctx, entDefinitions, table, retrieve, paginationOpts) {
     super(() => {
     });
-    this.db = db;
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
     this.retrieve = retrieve;
@@ -258,7 +261,7 @@ var PromisePaginationResultOrNullImpl = class extends Promise {
     return {
       ...result,
       page: await filterByReadRule(
-        this.db,
+        this.ctx,
         this.entDefinitions,
         this.table,
         result.page,
@@ -271,32 +274,34 @@ var PromisePaginationResultOrNullImpl = class extends Promise {
       (result) => result === null ? null : {
         ...result,
         page: result.page.map(
-          (doc) => entWrapper(doc, this.db, this.entDefinitions, this.table)
+          (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
         )
       }
     ).then(onfulfilled, onrejected);
   }
 };
 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 () => {
@@ -311,7 +316,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   firstX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -330,7 +335,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -348,7 +353,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   uniqueX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -370,7 +375,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   async docs() {
     const docs = await this.retrieve();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -380,14 +385,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;
   }
@@ -397,10 +402,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;
@@ -418,7 +423,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(
@@ -431,7 +436,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) {
@@ -441,11 +446,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,
@@ -454,13 +459,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) {
@@ -474,7 +479,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
         );
       }
       return new PromiseQueryOrNullImpl(
-        this.db,
+        this.ctx,
         this.entDefinitions,
         edgeDefinition.to,
         async () => {
@@ -482,7 +487,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)
           );
@@ -490,7 +495,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
       );
     }
     return new _PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       edgeDefinition.to,
       async () => {
@@ -499,7 +504,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();
@@ -515,7 +520,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}".`
@@ -529,10 +534,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 }),
@@ -555,6 +577,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);
@@ -589,19 +619,19 @@ function entWrapper(fields, db, entDefinitions, table) {
   return doc;
 }
 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 () => {
@@ -610,18 +640,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
+                };
+              }
             }
           })
         );
@@ -632,7 +696,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   }
   replace(value) {
     return new PromiseEntIdImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -641,38 +705,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(
@@ -686,8 +745,8 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
                   return true;
                 }).map(([edgeId]) => edgeId);
                 edges[key] = {
-                  add: Array.from(requested),
-                  removeEdges: remove
+                  add: idOrIds ?? [],
+                  removeEdges
                 };
               }
             }
@@ -701,26 +760,26 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   async delete() {
     const { id: docId } = await this.retrieve();
     const id = docId;
-    return this.base.deleteId(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
     );
@@ -739,7 +798,7 @@ function loadedRetriever(doc) {
     doc: async () => doc
   };
 }
-async function filterByReadRule(db, entDefinitions, table, docs, throwIfNull) {
+async function filterByReadRule(ctx, entDefinitions, table, docs, throwIfNull) {
   if (docs === null) {
     return null;
   }
@@ -750,7 +809,7 @@ async function filterByReadRule(db, entDefinitions, table, docs, throwIfNull) {
   const decisions = await Promise.all(
     docs.map(async (doc) => {
       const decision = await readPolicy(
-        entWrapper(doc, db, entDefinitions, table)
+        entWrapper(doc, ctx, entDefinitions, table)
       );
       if (throwIfNull && !decision) {
         throw new Error(
@@ -768,134 +827,126 @@ 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/writer.ts
 var WriterImplBase = class _WriterImplBase {
-  constructor(db, entDefinitions, table) {
-    this.db = db;
+  constructor(ctx, entDefinitions, table) {
+    this.ctx = ctx;
     this.entDefinitions = entDefinitions;
     this.table = table;
   }
-  async deleteId(id) {
+  async deleteId(id, behavior) {
     await this.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 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 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(
+      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] = { removeEdges: existing };
+              ).collect()).map((doc) => doc._id);
+              edges[key] = { remove };
+            }
+          } 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 };
+            }
           }
         }
-      })
+      )
     );
-    await this.db.delete(id);
-    await this.writeEdges(id, edges);
+    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_server.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) {
-    await new _WriterImplBase(this.db, this.entDefinitions, table).deleteId(id);
+  async deletedIdIn(id, table, cascadingSoft) {
+    await new _WriterImplBase(this.ctx, this.entDefinitions, table).deleteId(
+      id,
+      cascadingSoft ? "soft" : "hard"
+    );
   }
-  async writeEdges(docId, changes) {
+  async writeEdges(docId, changes, deleteSoftly) {
     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.deletedIdIn(
-                idOrIds.remove,
-                edgeDefinition.to
-              );
-            }
-            if (idOrIds.add !== void 0) {
-              await this.db.patch(
-                idOrIds.add,
-                { [edgeDefinition.ref]: docId }
-              );
-            }
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          const idOrIds = changes[edgeDefinition.name];
+          if (idOrIds === void 0) {
+            return;
           }
-        } else {
-          if (edgeDefinition.type === "field") {
-            if (idOrIds.remove !== void 0) {
+          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.deletedIdIn(id, edgeDefinition.to)
+                  (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) {
                   }
                 })
@@ -904,12 +955,12 @@ var WriterImplBase = class _WriterImplBase {
             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
                     });
@@ -919,7 +970,7 @@ var WriterImplBase = class _WriterImplBase {
             }
           }
         }
-      })
+      )
     );
   }
   async checkUniqueness(value, id) {
@@ -930,7 +981,7 @@ var WriterImplBase = class _WriterImplBase {
         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.`
@@ -940,28 +991,31 @@ var WriterImplBase = class _WriterImplBase {
       })
     );
     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];
       }
@@ -972,7 +1026,7 @@ var WriterImplBase = class _WriterImplBase {
     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"`
@@ -991,8 +1045,8 @@ var WriterImplBase = class _WriterImplBase {
       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
     );