convex-ents 0.1.0

package/dist/writer.js

@@ -0,0 +1,970 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/writer.ts
+var writer_exports = {};
+__export(writer_exports, {
+  WriterImplBase: () => WriterImplBase
+});
+module.exports = __toCommonJS(writer_exports);
+
+// src/functions.ts
+var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
+  constructor(db, entDefinitions, table, retrieve) {
+    super(() => {
+    });
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+  }
+  filter(predicate) {
+    return new _PromiseQueryOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const query = await this.retrieve();
+        if (query === null) {
+          return null;
+        }
+        return query.filter(predicate);
+      }
+    );
+  }
+  async map(callbackFn) {
+    const array = await this;
+    if (array === null) {
+      return [];
+    }
+    return await Promise.all(array.map(callbackFn));
+  }
+  order(order, indexName) {
+    return new _PromiseQueryOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const query = await this.retrieve();
+        if (query === null) {
+          return null;
+        }
+        if (indexName !== void 0) {
+          return query.withIndex(indexName).order(order);
+        }
+        return query.order(order);
+      }
+    );
+  }
+  // TODO: RLS for pagination
+  async paginate(paginationOpts) {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    return await query.paginate(paginationOpts);
+  }
+  take(n) {
+    return new PromiseEntsOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        return await this._take(n);
+      },
+      false
+    );
+  }
+  first() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this._take(1);
+        if (docs === null) {
+          return nullRetriever;
+        }
+        const [doc] = docs;
+        return loadedRetriever(doc);
+      },
+      false
+    );
+  }
+  firstX() {
+    return new PromiseEntWriterImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this._take(1);
+        if (docs === null) {
+          return nullRetriever;
+        }
+        const [doc] = docs;
+        if (doc === void 0) {
+          throw new Error("Query returned no documents");
+        }
+        return loadedRetriever(doc);
+      },
+      false
+    );
+  }
+  unique() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this._take(2);
+        if (docs === null) {
+          return nullRetriever;
+        }
+        if (docs.length === 0) {
+          return nullRetriever;
+        }
+        if (docs.length === 2) {
+          throw new Error("unique() query returned more than one result");
+        }
+        const [doc] = docs;
+        return loadedRetriever(doc);
+      },
+      false
+    );
+  }
+  uniqueX() {
+    return new PromiseEntWriterImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this._take(2);
+        if (docs === null) {
+          return nullRetriever;
+        }
+        if (docs.length === 0) {
+          throw new Error("Query returned no documents");
+        }
+        if (docs.length === 2) {
+          throw new Error("unique() query returned more than one result");
+        }
+        const [doc] = docs;
+        return loadedRetriever(doc);
+      },
+      true
+    );
+  }
+  async docs() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const docs = await query.collect();
+    return filterByReadRule(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      docs,
+      false
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (documents) => documents === null ? null : documents.map(
+        (doc) => entWrapper(doc, this.db, this.entDefinitions, this.table)
+      )
+    ).then(onfulfilled, onrejected);
+  }
+  async _take(n) {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const readPolicy = getReadRule(this.entDefinitions, this.table);
+    if (readPolicy === void 0) {
+      return await query.take(n);
+    }
+    let numItems = n;
+    const docs = [];
+    let hasMore = true;
+    const iterator = query[Symbol.asyncIterator]();
+    while (hasMore && docs.length < n) {
+      const page = [];
+      for (let i = 0; i < numItems; i++) {
+        const { done, value } = await iterator.next();
+        if (done) {
+          hasMore = false;
+          break;
+        }
+        page.push(value);
+      }
+      docs.push(
+        ...(await filterByReadRule(
+          this.db,
+          this.entDefinitions,
+          this.table,
+          page,
+          false
+        )).slice(0, n - docs.length)
+      );
+      numItems = Math.min(64, numItems * 2);
+    }
+    return docs;
+  }
+};
+var PromiseEntsOrNullImpl = class extends Promise {
+  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
+    super(() => {
+    });
+    this.db = db;
+    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));
+  }
+  first() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this.retrieve();
+        if (docs === null) {
+          return nullRetriever;
+        }
+        return loadedRetriever(docs[0] ?? null);
+      },
+      false
+    );
+  }
+  firstX() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this.retrieve();
+        if (docs === null) {
+          return nullRetriever;
+        }
+        const doc = docs[0] ?? void 0;
+        if (doc === void 0) {
+          throw new Error("Query returned no documents");
+        }
+        return loadedRetriever(doc);
+      },
+      true
+    );
+  }
+  unique() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this.retrieve();
+        if (docs === null) {
+          return nullRetriever;
+        }
+        if (docs.length > 1) {
+          throw new Error("unique() query returned more than one result");
+        }
+        return loadedRetriever(docs[0] ?? null);
+      },
+      false
+    );
+  }
+  uniqueX() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const docs = await this.retrieve();
+        if (docs === null) {
+          return nullRetriever;
+        }
+        if (docs.length > 1) {
+          throw new Error("unique() query returned more than one result");
+        }
+        if (docs.length < 1) {
+          throw new Error("unique() query returned no documents");
+        }
+        return loadedRetriever(docs[0]);
+      },
+      true
+    );
+  }
+  async docs() {
+    const docs = await this.retrieve();
+    return filterByReadRule(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      docs,
+      this.throwIfNull
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (docs) => docs === null ? null : docs.map(
+        (doc) => entWrapper(doc, this.db, 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);
+    this.field = field;
+    this.retrieveRange = retrieveRange;
+  }
+  async has(id) {
+    const docs = await this.retrieveRange((q) => q.eq(this.field, id));
+    return (docs?.length ?? 0) > 0;
+  }
+};
+var PromiseEntOrNullImpl = class _PromiseEntOrNullImpl extends Promise {
+  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
+    super(() => {
+    });
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.throwIfNull = throwIfNull;
+  }
+  async doc() {
+    const { id, doc: getDoc } = await this.retrieve();
+    if (id === null) {
+      return null;
+    }
+    const doc = await getDoc();
+    if (doc === null) {
+      return null;
+    }
+    const readPolicy = getReadRule(this.entDefinitions, this.table);
+    if (readPolicy !== void 0) {
+      const decision = await readPolicy(
+        entWrapper(doc, this.db, this.entDefinitions, this.table)
+      );
+      if (this.throwIfNull && !decision) {
+        throw new Error(
+          `Document cannot be read with id \`${doc._id}\` in table "${this.table}"`
+        );
+      }
+      return decision ? doc : null;
+    }
+    return doc;
+  }
+  then(onfulfilled, onrejected) {
+    return this.doc().then(
+      (doc) => doc === null ? null : entWrapper(doc, this.db, this.entDefinitions, this.table)
+    ).then(onfulfilled, onrejected);
+  }
+  edge(edge) {
+    return this.edgeImpl(edge);
+  }
+  edgeX(edge) {
+    return this.edgeImpl(edge, true);
+  }
+  edgeImpl(edge, throwIfNull = false) {
+    const edgeDefinition = this.entDefinitions[this.table].edges[edge];
+    if (edgeDefinition.cardinality === "multiple") {
+      if (edgeDefinition.type === "ref") {
+        return new PromiseEdgeOrNullImpl(
+          this.db,
+          this.entDefinitions,
+          edgeDefinition.to,
+          edgeDefinition.ref,
+          async (indexRange) => {
+            const { id } = await this.retrieve();
+            if (id === null) {
+              return null;
+            }
+            const edgeDocs = await this.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])
+              )
+            )).filter((doc, i) => {
+              if (doc === 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 "${edgeDocs[i][edgeDefinition.field]}" in table "${edgeDefinition.to}" (edge document ID is "${edgeDocs[i]._id}").`
+                );
+              }
+              return true;
+            });
+          }
+        );
+      }
+      return new PromiseQueryOrNullImpl(
+        this.db,
+        this.entDefinitions,
+        edgeDefinition.to,
+        async () => {
+          const { id } = await this.retrieve();
+          if (id === null) {
+            return null;
+          }
+          return this.db.query(edgeDefinition.to).withIndex(
+            edgeDefinition.ref,
+            (q) => q.eq(edgeDefinition.ref, id)
+          );
+        }
+      );
+    }
+    return new _PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      edgeDefinition.to,
+      async () => {
+        const { id, doc: getDoc } = await this.retrieve();
+        if (id === null) {
+          return nullRetriever;
+        }
+        if (edgeDefinition.type === "ref") {
+          const otherDoc = await this.db.query(edgeDefinition.to).withIndex(
+            edgeDefinition.ref,
+            (q) => q.eq(edgeDefinition.ref, id)
+          ).unique();
+          if (throwIfNull && otherDoc === null) {
+            throw new Error(
+              `Edge "${edgeDefinition.name}" does not exist for document with ID "${id}"`
+            );
+          }
+          return loadedRetriever(otherDoc);
+        }
+        const doc = await getDoc();
+        const otherId = doc[edgeDefinition.field];
+        return {
+          id: otherId,
+          doc: async () => {
+            const otherDoc = await this.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}".`
+              );
+            }
+            return otherDoc;
+          }
+        };
+      },
+      throwIfNull
+    );
+  }
+};
+function entWrapper(fields, db, entDefinitions, table) {
+  const doc = { ...fields };
+  const queryInterface = new PromiseEntWriterImpl(
+    db,
+    entDefinitions,
+    table,
+    async () => ({ id: doc._id, doc: async () => doc }),
+    // this `true` doesn't matter, the queryInterface cannot be awaited
+    true
+  );
+  Object.defineProperty(doc, "edge", {
+    value: (edge) => {
+      return queryInterface.edge(edge);
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(doc, "edgeX", {
+    value: (edge) => {
+      return queryInterface.edgeX(edge);
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(doc, "patch", {
+    value: (value) => {
+      return queryInterface.patch(value);
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(doc, "replace", {
+    value: (value) => {
+      return queryInterface.replace(value);
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(doc, "delete", {
+    value: () => {
+      return queryInterface.delete();
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.entries(entDefinitions[table].defaults).map(
+    ([field, value]) => {
+      if (doc[field] === void 0) {
+        doc[field] = value;
+      }
+    }
+  );
+  return doc;
+}
+var PromiseEntWriterImpl = class extends PromiseEntOrNullImpl {
+  constructor(db, entDefinitions, table, retrieve, throwIfNull) {
+    super(db, entDefinitions, table, retrieve, throwIfNull);
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.throwIfNull = throwIfNull;
+    this.base = new WriterImplBase(db, entDefinitions, table);
+  }
+  base;
+  patch(value) {
+    return new PromiseEntIdImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const { id: docId } = await this.retrieve();
+        const id = docId;
+        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);
+        const edges = {};
+        await Promise.all(
+          Object.keys(value).map(async (key) => {
+            const edgeDefinition = this.entDefinitions[this.table].edges[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.");
+            } else {
+              edges[key] = value[key];
+            }
+          })
+        );
+        await this.base.writeEdges(id, edges);
+        return id;
+      }
+    );
+  }
+  replace(value) {
+    return new PromiseEntIdImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const { id } = await this.retrieve();
+        const docId = id;
+        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);
+        const edges = {};
+        await Promise.all(
+          Object.values(
+            this.entDefinitions[this.table].edges
+          ).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);
+                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
+                };
+              } else {
+                const requested = new Set(idOrIds ?? []);
+                const remove = (await this.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.ref,
+                    (q) => q.eq(edgeDefinition.ref, docId)
+                  ).collect()).map(
+                    (doc) => [doc._id, doc[edgeDefinition.field]]
+                  ) : []
+                ).filter(([_edgeId, otherId]) => {
+                  if (requested.has(otherId)) {
+                    requested.delete(otherId);
+                    return false;
+                  }
+                  return true;
+                }).map(([edgeId]) => edgeId);
+                edges[key] = {
+                  add: Array.from(requested),
+                  removeEdges: remove
+                };
+              }
+            }
+          })
+        );
+        await this.base.writeEdges(docId, edges);
+        return docId;
+      }
+    );
+  }
+  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;
+  }
+};
+var PromiseEntIdImpl = class extends Promise {
+  constructor(db, entDefinitions, table, retrieve) {
+    super(() => {
+    });
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+  }
+  get() {
+    return new PromiseEntOrNullImpl(
+      this.db,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const id = await this.retrieve();
+        return { id, doc: async () => this.db.get(id) };
+      },
+      true
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.retrieve().then(onfulfilled, onrejected);
+  }
+};
+var nullRetriever = {
+  id: null,
+  doc: async () => null
+};
+function loadedRetriever(doc) {
+  return {
+    id: doc?._id ?? null,
+    doc: async () => doc
+  };
+}
+async function filterByReadRule(db, 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]);
+  }
+  return docs;
+}
+function getReadRule(entDefinitions, table) {
+  return entDefinitions.rules?.[table]?.read;
+}
+function getWriteRule(entDefinitions, table) {
+  return entDefinitions.rules?.[table]?.write;
+}
+
+// src/writer.ts
+var WriterImplBase = class {
+  constructor(db, entDefinitions, table) {
+    this.db = db;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+  }
+  async writeEdges(docId, changes) {
+    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);
+            }
+            if (idOrIds.add !== void 0) {
+              await this.db.patch(
+                idOrIds.add,
+                { [edgeDefinition.ref]: docId }
+              );
+            }
+          }
+        } else {
+          if (edgeDefinition.type === "field") {
+            if (idOrIds.remove !== void 0) {
+              await Promise.all(
+                idOrIds.remove.map(
+                  (id) => this.db.delete(id)
+                )
+              );
+            }
+            if (idOrIds.add !== void 0) {
+              await Promise.all(
+                idOrIds.add.map(
+                  async (id) => this.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) {
+              await Promise.all(
+                removeEdges.map(async (id) => {
+                  try {
+                    await this.db.delete(id);
+                  } catch (e) {
+                  }
+                })
+              );
+            }
+            if (idOrIds.add !== void 0) {
+              await Promise.all(
+                idOrIds.add.map(async (id) => {
+                  await this.db.insert(edgeDefinition.table, {
+                    [edgeDefinition.field]: docId,
+                    [edgeDefinition.ref]: id
+                  });
+                  if (edgeDefinition.symmetric) {
+                    await this.db.insert(edgeDefinition.table, {
+                      [edgeDefinition.field]: id,
+                      [edgeDefinition.ref]: docId
+                    });
+                  }
+                })
+              );
+            }
+          }
+        }
+      })
+    );
+  }
+  async checkUniqueness(value, id) {
+    await Promise.all(
+      Object.values(
+        this.entDefinitions[this.table].fields
+      ).map(async (fieldDefinition) => {
+        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();
+          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.`
+            );
+          }
+        }
+      })
+    );
+    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.`
+            );
+          }
+        }
+      })
+    );
+  }
+  fieldsOnly(value) {
+    const fields = {};
+    Object.keys(value).forEach((key) => {
+      const edgeDefinition = this.entDefinitions[this.table].edges[key];
+      if (edgeDefinition === void 0) {
+        fields[key] = value[key];
+      }
+    });
+    return fields;
+  }
+  async checkReadAndWriteRule(operation, id, value) {
+    if (id !== void 0) {
+      const readPolicy = getReadRule(this.entDefinitions, this.table);
+      if (readPolicy !== void 0) {
+        const doc = await this.db.get(id);
+        if (doc === null) {
+          throw new Error(
+            `Cannot update document with ID "${id}" in table "${this.table} because it does not exist"`
+          );
+        }
+        const decision2 = await readPolicy(doc);
+        if (!decision2) {
+          throw new Error(
+            `Cannot update document with ID "${id}" from table "${this.table}"`
+          );
+        }
+      }
+    }
+    const writePolicy = getWriteRule(this.entDefinitions, this.table);
+    if (writePolicy === void 0) {
+      return;
+    }
+    const ent = id === void 0 ? void 0 : entWrapper(
+      await this.db.get(id),
+      this.db,
+      this.entDefinitions,
+      this.table
+    );
+    const { _id, _creationTime, ...safeValue } = value ?? {};
+    const decision = await writePolicy({
+      operation,
+      ent,
+      value: value !== void 0 ? safeValue : void 0
+    });
+    if (!decision) {
+      if (id === void 0) {
+        throw new Error(
+          `Cannot insert into table "${this.table}": \`${JSON.stringify(
+            value
+          )}\``
+        );
+      } else if (value === void 0) {
+        throw new Error(
+          `Cannot delete from table "${this.table}" with ID "${id}"`
+        );
+      } else {
+        throw new Error(
+          `Cannot update document with ID "${id}" in table "${this.table}" with: \`${JSON.stringify(value)}\``
+        );
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WriterImplBase
+});
+//# sourceMappingURL=writer.js.map