Support/help with promise-based resolvers

I think I have a good use-case for non-async, promise-based resolution.

We are making django ORM from our dataloaders. We moved away from using async in django 3.0 because django would force us to isolate ORM calls and wrap them in `sync_to_async`. Instead, we ditched async and used promises with a generator based syntax. Examples below:

**What we'd like to do, but django doesn't allow**

```python
class MyDataLoader(...):
async def batch_load(self, ids):
data_from_other_loader = await other_loader.load_many(ids)
data_from_orm = MyModel.objects.filter(id__in=ids) # error! can't call django ORM from async context.
# return processed combination of orm/loader data
```

**What django would like us to do**

```python
class MyDataLoader(...):
async def batch_load(self, ids):
data_from_other_loader = await other_loader.load_many(ids)
data_from_orm = await get_orm_data()
# return processed combination of orm/loader data

@sync_to_async
def get_orm_data(ids):
return MyModel.objects.filter(id__in=ids)
```

**What we settled on instead (ditch async, use generator-syntax around promises)**

```python
class MyDataLoader(...):
def batch_load(self,ids):
data_from_other_loader = yield other_loader.load_many(ids)
data_from_orm = MyModel.objects.filter(id__in=ids)
# return processed combination of orm/loader data

```

I have a `generator_function_to_promise` tool that allows this syntax, as well as a middleware that converts generators returned from resolvers into promises. I have hundreds of dataloaders following this pattern. I don't want to be stuck isolating all the ORM calls as per django's recommendations because it's noisy and decreases legibility.

If it's not difficult to re-add promise support, I'd really appreciate it. If not, can anyone think of a solution to my problem?