convex-ents 0.9.4 → 0.9.5

package/dist/index.js

@@ -134,13 +134,13 @@ function defineEntSchema(schema, options) {
           const edgeTable = defineEnt({
             [forwardId]: import_values.v.id(tableName),
             [inverseId]: import_values.v.id(otherTableName)
-          }).index(forwardId, [forwardId]).index(inverseId, [inverseId]).index(edgeCompoundIndexName(forwardId, inverseId), [
+          }).index(forwardId, [forwardId]).index(inverseId, [inverseId]).index(edgeCompoundIndexNameRaw(forwardId, inverseId), [
             forwardId,
             inverseId
           ]);
           const isSymmetric = inverseEdge === void 0;
           if (!isSymmetric) {
-            edgeTable.index(edgeCompoundIndexName(inverseId, forwardId), [
+            edgeTable.index(edgeCompoundIndexNameRaw(inverseId, forwardId), [
               inverseId,
               forwardId
             ]);
@@ -164,7 +164,10 @@ function defineEntSchema(schema, options) {
   }
   return (0, import_server.defineSchema)(schema, options);
 }
-function edgeCompoundIndexName(idA, idB) {
+function edgeCompoundIndexName(edgeDefinition) {
+  return edgeCompoundIndexNameRaw(edgeDefinition.field, edgeDefinition.ref);
+}
+function edgeCompoundIndexNameRaw(idA, idB) {
   return `${idA}_${idB}`;
 }
 function canBeInverseEdge(tableName, edge, isSelfDirected) {
@@ -522,12 +525,9 @@ var WriterImplBase = class _WriterImplBase {
             }
             if (idOrIds.add !== void 0) {
               await Promise.all(
-                idOrIds.add.map(async (id) => {
+                [...new Set(idOrIds.add)].map(async (id) => {
                   const existing = await this.ctx.db.query(edgeDefinition.table).withIndex(
-                    edgeCompoundIndexName(
-                      edgeDefinition.field,
-                      edgeDefinition.ref
-                    ),
+                    edgeCompoundIndexName(edgeDefinition),
                     (q) => q.eq(edgeDefinition.field, docId).eq(
                       edgeDefinition.ref,
                       id
@@ -1178,10 +1178,7 @@ var PromiseEdgeOrNullImpl = class _PromiseEdgeOrNullImpl extends PromiseEntsOrNu
       return null;
     }
     const edgeDoc = this.ctx.db.query(this.edgeDefinition.table).withIndex(
-      edgeCompoundIndexName(
-        this.edgeDefinition.field,
-        this.edgeDefinition.ref
-      ),
+      edgeCompoundIndexName(this.edgeDefinition),
       (q) => q.eq(this.edgeDefinition.field, sourceId).eq(
         this.edgeDefinition.ref,
         targetId
@@ -1645,19 +1642,19 @@ var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
                 const { add, remove } = value[key];
                 const removeEdges = (await Promise.all(
                   (remove ?? []).map(
-                    async (edgeId) => (await this.ctx.db.query(edgeDefinition.table).withIndex(
-                      edgeDefinition.field,
+                    async (otherId) => (await this.ctx.db.query(edgeDefinition.table).withIndex(
+                      edgeCompoundIndexName(edgeDefinition),
                       (q) => q.eq(edgeDefinition.field, id).eq(
                         edgeDefinition.ref,
-                        edgeId
+                        otherId
                       )
                     ).collect()).concat(
                       edgeDefinition.symmetric ? await this.ctx.db.query(edgeDefinition.table).withIndex(
-                        edgeDefinition.ref,
-                        (q) => q.eq(edgeDefinition.ref, id).eq(
+                        edgeCompoundIndexName(edgeDefinition),
+                        (q) => q.eq(
                           edgeDefinition.field,
-                          edgeId
-                        )
+                          otherId
+                        ).eq(edgeDefinition.ref, id)
                       ).collect() : []
                     )
                   )