convex-ents 0.3.0 → 0.4.0

package/dist/deletion.js

@@ -28,1062 +28,14 @@ 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")
-);
+var vApproach = import_values.v.union(import_values.v.literal("cascade"), import_values.v.literal("paginate"));
 function scheduledDeleteFactory(entDefinitions, options) {
   const selfRef = options?.scheduledDelete ?? (0, import_server2.makeFunctionReference)(
     "functions:scheduledDelete"
@@ -1138,10 +90,8 @@ function scheduledDeleteFactory(entDefinitions, options) {
         return;
       }
       await progressScheduledDeletion(
-        ctx,
-        entDefinitions,
-        selfRef,
-        origin,
+        { ctx, entDefinitions, selfRef, origin },
+        newCounter(),
         inProgress ? stack : [
           {
             id: originId,
@@ -1158,12 +108,11 @@ function getEdgeArgs(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 approach = hasCascadingEdges ? "cascade" : "paginate";
       const indexName = edgeDefinition.ref;
       return [{ table: table2, indexName, approach }];
     } else if (edgeDefinition.cardinality === "multiple") {
@@ -1187,39 +136,49 @@ function getEdgeArgs(entDefinitions, table) {
     }
   });
 }
-async function progressScheduledDeletion(ctx, entDefinitions, selfRef, origin, stack) {
+async function progressScheduledDeletion(cascade, counter, stack) {
+  const { ctx } = cascade;
   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
-        });
+        await continueOrSchedule(cascade, counter, stack.slice(0, -1));
       }
     } else {
       const updated = { ...last, edges: last.edges.slice(1) };
-      await paginate(
-        ctx,
-        entDefinitions,
-        selfRef,
-        origin,
+      await paginateOrCascade(
+        cascade,
+        counter,
         stack.slice(0, -1).concat(updated),
-        { cursor: null, fieldValue: last.id, ...edgeArgs }
+        {
+          cursor: null,
+          fieldValue: last.id,
+          ...edgeArgs
+        }
       );
     }
   } else {
-    await paginate(ctx, entDefinitions, selfRef, origin, stack, last);
+    await paginateOrCascade(cascade, counter, 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 }
-  });
+var MAXIMUM_DOCUMENTS_READ = 8192 / 4;
+var MAXIMUM_BYTES_READ = 2 ** 18;
+async function paginateOrCascade(cascade, counter, stack, { table, approach, indexName, fieldValue, cursor }) {
+  const { ctx, entDefinitions } = cascade;
+  const { page, continueCursor, isDone, bytesRead } = await paginate(
+    ctx,
+    { table, indexName, fieldValue },
+    {
+      cursor,
+      ...limitsBasedOnCounter(
+        counter,
+        approach === "paginate" ? { numItems: MAXIMUM_DOCUMENTS_READ } : { numItems: 1 }
+      )
+    }
+  );
+  const updatedCounter = incrementCounter(counter, page.length, bytesRead);
   const updated = {
     approach,
     table,
@@ -1228,34 +187,92 @@ async function paginate(ctx, entDefinitions, selfRef, origin, stack, { table, ap
     fieldValue
   };
   const relevantStack = cursor === null ? stack : stack.slice(0, -1);
-  if (approach === "schedule") {
+  const updatedStack = isDone && (approach === "paginate" || page.length === 0) ? relevantStack : relevantStack.concat(
+    approach === "cascade" ? [
+      updated,
+      {
+        id: page[0]._id,
+        table,
+        edges: getEdgeArgs(entDefinitions, table)
+      }
+    ] : [updated]
+  );
+  if (approach === "paginate") {
+    await Promise.all(page.map((doc) => ctx.db.delete(doc._id)));
+  }
+  await continueOrSchedule(cascade, updatedCounter, updatedStack);
+}
+async function continueOrSchedule(cascade, counter, stack) {
+  if (shouldSchedule(counter)) {
+    const { ctx, selfRef, origin } = cascade;
     await ctx.scheduler.runAfter(0, selfRef, {
       origin,
-      stack: isDone ? relevantStack : relevantStack.concat([
-        updated,
-        {
-          id: page[0]._id,
-          table,
-          edges: getEdgeArgs(entDefinitions, table)
-        }
-      ]),
+      stack,
       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 progressScheduledDeletion(cascade, counter, stack);
+  }
+}
+function newCounter() {
+  return {
+    numDocuments: 0,
+    numBytesRead: 0
+  };
+}
+function incrementCounter(counter, numDocuments, numBytesRead) {
+  return {
+    numDocuments: counter.numDocuments + numDocuments,
+    numBytesRead: counter.numBytesRead + numBytesRead
+  };
+}
+function limitsBasedOnCounter(counter, { numItems }) {
+  return {
+    numItems: Math.max(1, numItems - counter.numDocuments),
+    maximumBytesRead: Math.max(1, MAXIMUM_BYTES_READ - counter.numBytesRead)
+  };
+}
+function shouldSchedule(counter) {
+  return counter.numDocuments >= MAXIMUM_DOCUMENTS_READ || counter.numBytesRead >= MAXIMUM_BYTES_READ;
+}
+async function paginate(ctx, {
+  table,
+  indexName,
+  fieldValue
+}, {
+  cursor,
+  numItems,
+  maximumBytesRead
+}) {
+  const query = ctx.db.query(table).withIndex(
+    indexName,
+    (q) => q.eq(indexName, fieldValue).gt(
+      "_creationTime",
+      cursor
+    )
+  );
+  let bytesRead = 0;
+  const results = [];
+  let isDone = true;
+  for await (const doc of query) {
+    if (results.length >= numItems) {
+      isDone = false;
+      break;
     }
-    await ctx.scheduler.runAfter(0, selfRef, {
-      origin,
-      stack: isDone ? relevantStack : relevantStack.concat([updated]),
-      inProgress: true
-    });
+    const size = JSON.stringify((0, import_values.convexToJson)(doc)).length * 8;
+    if (bytesRead + size > maximumBytesRead) {
+      isDone = false;
+      break;
+    }
+    bytesRead += size;
+    results.push(doc);
   }
+  return {
+    page: results,
+    continueCursor: results.length === 0 ? cursor : results[results.length - 1]._creationTime,
+    isDone,
+    bytesRead
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {