convex-ents 0.2.0 → 0.3.0

package/dist/deletion.js

@@ -0,0 +1,1264 @@
+"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/deletion.ts
+var deletion_exports = {};
+__export(deletion_exports, {
+  scheduledDeleteFactory: () => scheduledDeleteFactory
+});
+module.exports = __toCommonJS(deletion_exports);
+var import_server2 = require("convex/server");
+var import_values = require("convex/values");
+
+// src/writer.ts
+var import_server = require("convex/server");
+var WriterImplBase = class _WriterImplBase {
+  constructor(ctx, entDefinitions, table) {
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+  }
+  async deleteId(id, behavior) {
+    await this.checkReadAndWriteRule("delete", id, void 0);
+    const deletionConfig = getDeletionConfig(this.entDefinitions, this.table);
+    const isDeletingSoftly = behavior !== "hard" && deletionConfig !== void 0 && (deletionConfig.type === "soft" || deletionConfig.type === "scheduled");
+    if (behavior === "soft" && !isDeletingSoftly) {
+      throw new Error(
+        `Cannot soft delete document with ID "${id}" in table "${this.table}" because it does not have an "allowSoft", "soft" or "scheduled" deletion behavior configured.`
+      );
+    }
+    const edges = {};
+    await Promise.all(
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          const key = edgeDefinition.name;
+          if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
+            if (!isDeletingSoftly || edgeDefinition.deletion === "soft") {
+              const remove = (await this.ctx.db.query(edgeDefinition.to).withIndex(
+                edgeDefinition.ref,
+                (q) => q.eq(edgeDefinition.ref, id)
+              ).collect()).map((doc) => doc._id);
+              edges[key] = { remove };
+            }
+          } 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 };
+            }
+          }
+        }
+      )
+    );
+    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, cascadingSoft) {
+    await new _WriterImplBase(this.ctx, this.entDefinitions, table).deleteId(
+      id,
+      cascadingSoft ? "soft" : "hard"
+    );
+  }
+  async writeEdges(docId, changes, deleteSoftly) {
+    await Promise.all(
+      Object.values(getEdgeDefinitions(this.entDefinitions, this.table)).map(
+        async (edgeDefinition) => {
+          const idOrIds = changes[edgeDefinition.name];
+          if (idOrIds === void 0) {
+            return;
+          }
+          if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
+            if (idOrIds.remove !== void 0 && idOrIds.remove.length > 0) {
+              await Promise.all(
+                idOrIds.remove.map(
+                  (id) => this.deletedIdIn(
+                    id,
+                    edgeDefinition.to,
+                    (deleteSoftly ?? false) && edgeDefinition.deletion === "soft"
+                  )
+                )
+              );
+            }
+            if (idOrIds.add !== void 0 && idOrIds.add.length > 0) {
+              await Promise.all(
+                idOrIds.add.map(
+                  async (id) => this.ctx.db.patch(id, {
+                    [edgeDefinition.ref]: docId
+                  })
+                )
+              );
+            }
+          } else if (edgeDefinition.cardinality === "multiple") {
+            if ((idOrIds.removeEdges ?? []).length > 0) {
+              await Promise.all(
+                idOrIds.removeEdges.map(async (id) => {
+                  try {
+                    await this.ctx.db.delete(id);
+                  } catch (e) {
+                  }
+                })
+              );
+            }
+            if (idOrIds.add !== void 0) {
+              await Promise.all(
+                idOrIds.add.map(async (id) => {
+                  await this.ctx.db.insert(edgeDefinition.table, {
+                    [edgeDefinition.field]: docId,
+                    [edgeDefinition.ref]: id
+                  });
+                  if (edgeDefinition.symmetric) {
+                    await this.ctx.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.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.`
+            );
+          }
+        }
+      })
+    );
+    await Promise.all(
+      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 = getEdgeDefinitions(
+        this.entDefinitions,
+        this.table
+      )[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.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"`
+          );
+        }
+        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.ctx.db.get(id),
+      this.ctx,
+      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)}\``
+        );
+      }
+    }
+  }
+};
+
+// src/functions.ts
+var PromiseQueryOrNullImpl = class _PromiseQueryOrNullImpl extends Promise {
+  constructor(ctx, entDefinitions, table, retrieve) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+  }
+  filter(predicate) {
+    return new _PromiseQueryOrNullImpl(
+      this.ctx,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const query = await this.retrieve();
+        if (query === null) {
+          return null;
+        }
+        return query.filter(predicate);
+      }
+    );
+  }
+  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.ctx,
+      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);
+      }
+    );
+  }
+  paginate(paginationOpts) {
+    return new PromisePaginationResultOrNullImpl(
+      this.ctx,
+      this.entDefinitions,
+      this.table,
+      this.retrieve,
+      paginationOpts
+    );
+  }
+  take(n) {
+    return new PromiseEntsOrNullImpl(
+      this.ctx,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        return await this._take(n);
+      },
+      false
+    );
+  }
+  first() {
+    return new PromiseEntOrNullImpl(
+      this.ctx,
+      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.ctx,
+      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.ctx,
+      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.ctx,
+      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.ctx,
+      this.entDefinitions,
+      this.table,
+      docs,
+      false
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (documents) => documents === null ? null : documents.map(
+        (doc) => entWrapper(doc, this.ctx, 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.ctx,
+          this.entDefinitions,
+          this.table,
+          page,
+          false
+        )).slice(0, n - docs.length)
+      );
+      numItems = Math.min(64, numItems * 2);
+    }
+    return docs;
+  }
+};
+var PromisePaginationResultOrNullImpl = class extends Promise {
+  constructor(ctx, entDefinitions, table, retrieve, paginationOpts) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.paginationOpts = paginationOpts;
+  }
+  async map(callbackFn) {
+    const result = await this;
+    if (result === null) {
+      return null;
+    }
+    return {
+      ...result,
+      page: await Promise.all(result.page.map(callbackFn))
+    };
+  }
+  async docs() {
+    const query = await this.retrieve();
+    if (query === null) {
+      return null;
+    }
+    const result = await query.paginate(this.paginationOpts);
+    return {
+      ...result,
+      page: await filterByReadRule(
+        this.ctx,
+        this.entDefinitions,
+        this.table,
+        result.page,
+        false
+      )
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (result) => result === null ? null : {
+        ...result,
+        page: result.page.map(
+          (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
+        )
+      }
+    ).then(onfulfilled, onrejected);
+  }
+};
+var PromiseEntsOrNullImpl = class extends Promise {
+  constructor(ctx, entDefinitions, table, retrieve, throwIfNull) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+    this.throwIfNull = throwIfNull;
+  }
+  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.ctx,
+      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.ctx,
+      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.ctx,
+      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.ctx,
+      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.ctx,
+      this.entDefinitions,
+      this.table,
+      docs,
+      this.throwIfNull
+    );
+  }
+  then(onfulfilled, onrejected) {
+    return this.docs().then(
+      (docs) => docs === null ? null : docs.map(
+        (doc) => entWrapper(doc, this.ctx, this.entDefinitions, this.table)
+      )
+    ).then(onfulfilled, onrejected);
+  }
+};
+var PromiseEdgeOrNullImpl = class extends PromiseEntsOrNullImpl {
+  constructor(ctx, entDefinitions, table, field, retrieveRange) {
+    super(ctx, 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(ctx, entDefinitions, table, retrieve, throwIfNull) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    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.ctx, 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.ctx, 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 = getEdgeDefinitions(this.entDefinitions, this.table)[edge];
+    if (edgeDefinition.cardinality === "multiple") {
+      if (edgeDefinition.type === "ref") {
+        return new PromiseEdgeOrNullImpl(
+          this.ctx,
+          this.entDefinitions,
+          edgeDefinition.to,
+          edgeDefinition.ref,
+          async (indexRange) => {
+            const { id } = await this.retrieve();
+            if (id === null) {
+              return null;
+            }
+            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.ctx.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.ctx,
+        this.entDefinitions,
+        edgeDefinition.to,
+        async () => {
+          const { id } = await this.retrieve();
+          if (id === null) {
+            return null;
+          }
+          return this.ctx.db.query(edgeDefinition.to).withIndex(
+            edgeDefinition.ref,
+            (q) => q.eq(edgeDefinition.ref, id)
+          );
+        }
+      );
+    }
+    return new _PromiseEntOrNullImpl(
+      this.ctx,
+      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.ctx.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.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}".`
+              );
+            }
+            return otherDoc;
+          }
+        };
+      },
+      throwIfNull
+    );
+  }
+};
+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(
+    ctx,
+    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, "doc", {
+    value: () => {
+      return doc;
+    },
+    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(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(ctx, entDefinitions, table);
+  }
+  base;
+  patch(value) {
+    return new PromiseEntIdImpl(
+      this.ctx,
+      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.ctx.db.patch(id, fields);
+        const edges = {};
+        await Promise.all(
+          Object.keys(value).map(async (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 "${edgeDefinition.name}" on ent in table "${this.table}", update the ent in "${edgeDefinition.to}"  table instead.`
+              );
+            } else {
+              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
+                };
+              }
+            }
+          })
+        );
+        await this.base.writeEdges(id, edges);
+        return id;
+      }
+    );
+  }
+  replace(value) {
+    return new PromiseEntIdImpl(
+      this.ctx,
+      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.ctx.db.replace(docId, fields);
+        const edges = {};
+        await Promise.all(
+          Object.values(
+            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.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") {
+                if (idOrIds !== void 0) {
+                  throw new Error("Cannot set 1:many edge from many end.");
+                }
+              } else {
+                const requested = new Set(idOrIds ?? []);
+                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.ctx.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: idOrIds ?? [],
+                  removeEdges
+                };
+              }
+            }
+          })
+        );
+        await this.base.writeEdges(docId, edges);
+        return docId;
+      }
+    );
+  }
+  async delete() {
+    const { id: docId } = await this.retrieve();
+    const id = docId;
+    return this.base.deleteId(id, "default");
+  }
+};
+var PromiseEntIdImpl = class extends Promise {
+  constructor(ctx, entDefinitions, table, retrieve) {
+    super(() => {
+    });
+    this.ctx = ctx;
+    this.entDefinitions = entDefinitions;
+    this.table = table;
+    this.retrieve = retrieve;
+  }
+  get() {
+    return new PromiseEntOrNullImpl(
+      this.ctx,
+      this.entDefinitions,
+      this.table,
+      async () => {
+        const id = await this.retrieve();
+        return { id, doc: async () => this.ctx.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(ctx, entDefinitions, table, docs, throwIfNull) {
+  if (docs === null) {
+    return null;
+  }
+  const readPolicy = getReadRule(entDefinitions, table);
+  if (readPolicy === void 0) {
+    return docs;
+  }
+  const decisions = await Promise.all(
+    docs.map(async (doc) => {
+      const decision = await readPolicy(
+        entWrapper(doc, ctx, entDefinitions, table)
+      );
+      if (throwIfNull && !decision) {
+        throw new Error(
+          `Document cannot be read with id \`${doc._id}\` in table "${table}"`
+        );
+      }
+      return decision;
+    })
+  );
+  return docs.filter((_, i) => decisions[i]);
+}
+function getReadRule(entDefinitions, table) {
+  return entDefinitions.rules?.[table]?.read;
+}
+function getWriteRule(entDefinitions, table) {
+  return entDefinitions.rules?.[table]?.write;
+}
+function getEdgeDefinitions(entDefinitions, table) {
+  return entDefinitions[table].edges;
+}
+function getDeletionConfig(entDefinitions, table) {
+  return entDefinitions[table].deletionConfig;
+}
+
+// src/deletion.ts
+var vApproach = import_values.v.union(
+  import_values.v.literal("schedule"),
+  import_values.v.literal("deleteOne"),
+  import_values.v.literal("paginate")
+);
+function scheduledDeleteFactory(entDefinitions, options) {
+  const selfRef = options?.scheduledDelete ?? (0, import_server2.makeFunctionReference)(
+    "functions:scheduledDelete"
+  );
+  return (0, import_server2.internalMutationGeneric)({
+    args: {
+      origin: import_values.v.object({
+        id: import_values.v.string(),
+        table: import_values.v.string(),
+        deletionTime: import_values.v.number()
+      }),
+      stack: import_values.v.array(
+        import_values.v.union(
+          import_values.v.object({
+            id: import_values.v.string(),
+            table: import_values.v.string(),
+            edges: import_values.v.array(
+              import_values.v.object({
+                approach: vApproach,
+                table: import_values.v.string(),
+                indexName: import_values.v.string()
+              })
+            )
+          }),
+          import_values.v.object({
+            approach: vApproach,
+            cursor: import_values.v.union(import_values.v.string(), import_values.v.null()),
+            table: import_values.v.string(),
+            indexName: import_values.v.string(),
+            fieldValue: import_values.v.any()
+          })
+        )
+      ),
+      inProgress: import_values.v.boolean()
+    },
+    handler: async (ctx, { origin, stack, inProgress }) => {
+      const originId = ctx.db.normalizeId(origin.table, origin.id);
+      if (originId === null) {
+        throw new Error(`Invalid ID "${origin.id}" for table ${origin.table}`);
+      }
+      const doc = await ctx.db.get(originId);
+      if (doc.deletionTime !== origin.deletionTime) {
+        if (inProgress) {
+          console.error(
+            `[Ents] Already in-progress scheduled deletion for "${origin.id}" was cancelled!`
+          );
+        } else {
+          console.log(
+            `[Ents] Scheduled deletion for "${origin.id}" was cancelled`
+          );
+        }
+        return;
+      }
+      await progressScheduledDeletion(
+        ctx,
+        entDefinitions,
+        selfRef,
+        origin,
+        inProgress ? stack : [
+          {
+            id: originId,
+            table: origin.table,
+            edges: getEdgeArgs(entDefinitions, origin.table)
+          }
+        ]
+      );
+    }
+  });
+}
+function getEdgeArgs(entDefinitions, table) {
+  const edges = getEdgeDefinitions(entDefinitions, table);
+  return Object.values(edges).flatMap((edgeDefinition) => {
+    if (edgeDefinition.cardinality === "single" && edgeDefinition.type === "ref" || edgeDefinition.cardinality === "multiple" && edgeDefinition.type === "field") {
+      const table2 = edgeDefinition.to;
+      const targetDeletionConfig = getDeletionConfig(entDefinitions, table2);
+      const targetEdges = getEdgeDefinitions(entDefinitions, table2);
+      const hasCascadingEdges = Object.values(targetEdges).some(
+        (edgeDefinition2) => edgeDefinition2.cardinality === "single" && edgeDefinition2.type === "ref" || edgeDefinition2.cardinality === "multiple"
+      );
+      const approach = targetDeletionConfig !== void 0 && hasCascadingEdges ? "schedule" : hasCascadingEdges ? "deleteOne" : "paginate";
+      const indexName = edgeDefinition.ref;
+      return [{ table: table2, indexName, approach }];
+    } else if (edgeDefinition.cardinality === "multiple") {
+      const table2 = edgeDefinition.table;
+      return [
+        {
+          table: table2,
+          indexName: edgeDefinition.field,
+          approach: "paginate"
+        },
+        ...edgeDefinition.symmetric ? [
+          {
+            table: table2,
+            indexName: edgeDefinition.ref,
+            approach: "paginate"
+          }
+        ] : []
+      ];
+    } else {
+      return [];
+    }
+  });
+}
+async function progressScheduledDeletion(ctx, entDefinitions, selfRef, origin, stack) {
+  const last = stack[stack.length - 1];
+  if ("id" in last) {
+    const edgeArgs = last.edges[0];
+    if (edgeArgs === void 0) {
+      await ctx.db.delete(last.id);
+      if (stack.length > 1) {
+        await ctx.scheduler.runAfter(0, selfRef, {
+          origin,
+          stack: stack.slice(0, -1),
+          inProgress: true
+        });
+      }
+    } else {
+      const updated = { ...last, edges: last.edges.slice(1) };
+      await paginate(
+        ctx,
+        entDefinitions,
+        selfRef,
+        origin,
+        stack.slice(0, -1).concat(updated),
+        { cursor: null, fieldValue: last.id, ...edgeArgs }
+      );
+    }
+  } else {
+    await paginate(ctx, entDefinitions, selfRef, origin, stack, last);
+  }
+}
+async function paginate(ctx, entDefinitions, selfRef, origin, stack, { table, approach, indexName, fieldValue, cursor }) {
+  const { page, continueCursor, isDone } = await ctx.db.query(table).withIndex(indexName, (q) => q.eq(indexName, fieldValue)).paginate({
+    cursor,
+    ...approach === "paginate" ? { numItems: 8192 / 4, maximumBytesRead: 2 ** 18 } : { numItems: 1 }
+  });
+  const updated = {
+    approach,
+    table,
+    cursor: continueCursor,
+    indexName,
+    fieldValue
+  };
+  const relevantStack = cursor === null ? stack : stack.slice(0, -1);
+  if (approach === "schedule") {
+    await ctx.scheduler.runAfter(0, selfRef, {
+      origin,
+      stack: isDone ? relevantStack : relevantStack.concat([
+        updated,
+        {
+          id: page[0]._id,
+          table,
+          edges: getEdgeArgs(entDefinitions, table)
+        }
+      ]),
+      inProgress: true
+    });
+  } else {
+    if (approach === "deleteOne") {
+      await new WriterImplBase(ctx, entDefinitions, origin.table).deleteId(
+        page[0].id,
+        "hard"
+      );
+    } else {
+      await Promise.all(page.map((doc) => ctx.db.delete(doc._id)));
+    }
+    await ctx.scheduler.runAfter(0, selfRef, {
+      origin,
+      stack: isDone ? relevantStack : relevantStack.concat([updated]),
+      inProgress: true
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scheduledDeleteFactory
+});
+//# sourceMappingURL=deletion.js.map