Cannot use Proxy connection_context decorator.
While `Proxy` is primarily indicated for use with deferred database objects, it is in a sense a general abstraction. Adding such a method to `Proxy` produces a bit more tight-coupling to `Database`, which I'd prefer to avoid.

The issue is that `database.connection_context()` is evaluated as an import-time side-effect. And at import-time we don't necessarily have an initialized Proxy, as you point out.

We actually could rewrite the code as:

```python
database = Proxy()

def get_all_users():
    return list(User.select())

get_all_users = database.connection_context()(get_all_users)
```

When we do that, it's clear that we're calling a function on the uninitialized proxy, asking that it be evaluated immediately. I know you understand all this, but I figure it's worth writing out as I'm thinking this through.

So a way to work around this would be to use the context-manager instead, within the function:

```python
def get_all_users():
    with database.connection_context():
        return list(User.select())
```

Also note that `connection_context()` isn't the only database decorator you might use. There are also:

* `database` (the object itself supports use as a decorator or context manager)
* `database.atomic` and related functions

I think my preference will be to create a subclass, `DatabaseProxy`, which will implement placeholders for connection_context as the other decorators.
Defining methods or functions with the `connection_context` decorator does not work with Proxies.

It throws `AttributeError: Cannot use uninitialized Proxy`.

Although I see no reason, why this should be necessary at definition time.

```python
from peewee import Proxy, Model, TextField

database = Proxy()

class User(Model):
    username = TextField(unique=True)

    class Meta:
        database = database

@database.connection_context()
def get_all_users():
   return list(User.select())

```