convex-ents 0.2.0 → 0.4.0

package/dist/functions.js

@@ -23,138 +23,127 @@ __export(functions_exports, {
   addEntRules: () => addEntRules,
   entWrapper: () => entWrapper,
   entsTableFactory: () => entsTableFactory,
+  getDeletionConfig: () => getDeletionConfig,
+  getEdgeDefinitions: () => getEdgeDefinitions,
   getReadRule: () => getReadRule,
   getWriteRule: () => getWriteRule
 });
 module.exports = __toCommonJS(functions_exports);
 
 // src/writer.ts
+var import_server = require("convex/server");
 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) {
                   }
                 })
@@ -163,12 +152,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
                     });
@@ -178,7 +167,7 @@ var WriterImplBase = class _WriterImplBase {
             }
           }
         }
-      })
+      )
     );
   }
   async checkUniqueness(value, id) {
@@ -189,7 +178,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.`
@@ -199,28 +188,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];
       }
@@ -231,7 +223,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"`
@@ -250,8 +242,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
     );
@@ -283,17 +275,17 @@ var WriterImplBase = class _WriterImplBase {
 
 // 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 () => {
@@ -305,16 +297,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 () => {
@@ -331,7 +325,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   paginate(paginationOpts) {
     return new PromisePaginationResultOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       this.retrieve,
@@ -340,7 +334,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   take(n) {
     return new PromiseEntsOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -351,7 +345,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   first() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -367,7 +361,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   firstX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -386,7 +380,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -408,7 +402,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
   }
   uniqueX() {
     return new PromiseEntWriterImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -435,7 +429,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
     }
     const docs = await query.collect();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -445,7 +439,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);
   }
@@ -474,7 +468,7 @@ var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
       }
       docs.push(
         ...(await filterByReadRule(
-          this.db,
+          this.ctx,
           this.entDefinitions,
           this.table,
           page,
@@ -487,10 +481,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;
@@ -515,7 +509,7 @@ var PromisePaginationResultOrNullImpl = class extends Promise {
     return {
       ...result,
       page: await filterByReadRule(
-        this.db,
+        this.ctx,
         this.entDefinitions,
         this.table,
         result.page,
@@ -528,15 +522,15 @@ 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 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);
@@ -552,18 +546,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}"`
@@ -574,7 +568,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}\``
@@ -587,13 +581,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}"`
             );
@@ -601,7 +595,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}"`
@@ -614,7 +608,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}\``
@@ -628,7 +622,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) {
@@ -640,7 +634,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   withIndex(indexName, indexRange) {
     return new PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -651,7 +645,7 @@ var PromiseTableImpl = class extends PromiseQueryOrNullImpl {
   }
   search(indexName, searchFilter) {
     return new PromiseQueryOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -662,25 +656,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 () => {
@@ -695,7 +691,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   firstX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -714,7 +710,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   unique() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -732,7 +728,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   }
   uniqueX() {
     return new PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -754,7 +750,7 @@ var PromiseEntsOrNullImpl = class extends Promise {
   async docs() {
     const docs = await this.retrieve();
     return filterByReadRule(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       docs,
@@ -764,14 +760,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;
   }
@@ -781,10 +777,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;
@@ -802,7 +798,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(
@@ -815,7 +811,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) {
@@ -825,11 +821,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,
@@ -838,13 +834,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) {
@@ -858,7 +854,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
         );
       }
       return new PromiseQueryOrNullImpl(
-        this.db,
+        this.ctx,
         this.entDefinitions,
         edgeDefinition.to,
         async () => {
@@ -866,7 +862,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)
           );
@@ -874,7 +870,7 @@ var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
       );
     }
     return new _PromiseEntOrNullImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       edgeDefinition.to,
       async () => {
@@ -883,7 +879,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();
@@ -899,7 +895,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}".`
@@ -913,10 +909,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 }),
@@ -939,6 +952,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);
@@ -972,54 +993,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;
@@ -1032,19 +1057,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 () => {
@@ -1053,18 +1078,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
+                };
+              }
             }
           })
         );
@@ -1075,7 +1134,7 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
   }
   replace(value) {
     return new PromiseEntIdImpl(
-      this.db,
+      this.ctx,
       this.entDefinitions,
       this.table,
       async () => {
@@ -1084,38 +1143,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(
@@ -1129,8 +1183,8 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
                   return true;
                 }).map(([edgeId]) => edgeId);
                 edges[key] = {
-                  add: Array.from(requested),
-                  removeEdges: remove
+                  add: idOrIds ?? [],
+                  removeEdges
                 };
               }
             }
@@ -1144,26 +1198,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
     );
@@ -1185,7 +1239,7 @@ 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;
   }
@@ -1196,7 +1250,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(
@@ -1214,11 +1268,19 @@ 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addEntRules,
   entWrapper,
   entsTableFactory,
+  getDeletionConfig,
+  getEdgeDefinitions,
   getReadRule,
   getWriteRule
 });