Add django-subscriptions-rxdb example

strawberry+django+broadcaster+postgres example, compatible with the RxDB
GraphQL example

Author: AntonOfTheWoods

django-subscriptions-rxdb/Makefile

@@ -0,0 +1,8 @@
+install:
+	poetry install && PYTHONPATH=src poetry run ./manage.py migrate
+
+install-postgres:
+	poetry install -E postgres && PYTHONPATH=src poetry run ./manage.py migrate
+
+run:
+	PYTHONPATH=src poetry run uvicorn demo.asgi:application --reload --debug --reload-dir src

django-subscriptions-rxdb/README.md

@@ -0,0 +1,34 @@
+# django-subscriptions-rxdb
+
+## tl;dr
+This example reproduces the server-side component of the RxDB GraphQL example, with a couple of extras, which can be found [here](https://github.com/pubkey/rxdb/tree/master/examples/graphql). Checkout RxDB and run the GraphQL example. When running Ok, change `export const GRAPHQL_PORT = 10102;` and `export const GRAPHQL_SUBSCRIPTION_PORT = 10103;` ([lines 1 and 3 of this file](https://github.com/pubkey/rxdb/blob/master/examples/graphql/shared.js)) to equal `8000`. Then in the directory of this README file, `make install && make run`. More information about RxDB and GraphQL synchronisation can be found [here](https://rxdb.info/replication-graphql.html).
+
+## Requirements
+- [Clone of RxDB](https://github.com/pubkey/rxdb)
+- [Python 3.8+](https://www.python.org/downloads/) (might work with other versions, not tested)
+- [Poetry](https://python-poetry.org/)
+- `make`
+- [PostgreSQL](https://www.postgresql.org/) (optional)
+
+Tested on Ubuntu 20.04, should work everywhere these are available with no changes.
+
+## Reason for this example
+While connectivity is getting better around the world every year, every user will always at least have moments when their connection is spotty, if not completely absent (at human prices) for certain periods (eg., on a plane). With an offline-first, local database and other offline-first tech (service workers, etc.), it is possible to develop web-technology-based applications  that will continue to offer much of their functionality offline, with realtime sync when they are online. This really is the best of both worlds, and can give much more fluid and friendly usage when connections are spotty.
+
+So you already have a Django-based app, and want to add some rich, client-side, offline-first functionality without starting from scratch? This is an example of some of the server-side code for one way of starting out.
+
+The RxDB component of this is not included here to keep things as light as possible. Offline-first has complexities that need to be mastered, so this is not intended to be a template or even a particularly good way of doing things, just a rough example to get you started with `rxdb`, `strawberry`, `django` and `broadcaster`.
+
+### The full example stack
+
+The example shows how you can do offline-realtime synchronisation of a local, RxDB database with Django. It uses Strawberry GraphQL subscriptions over websockets for the realtime sync capabilities. The default Django database configured in the `settings` file is Sqlite3 but there is also commented-out config for PostgreSQL.
+
+If you use PostgreSQL then you will have to set up a database like you would for any PostgreSQL-powered Django site but if you do, the example will also then use PostgreSQL for the realtime notification functionality. To run the example with `postgres`, comment out the `sqlite3` config and put your `postgres` config in the settings file (src/demo/settings.py). You will also need to install extra deps with:
+
+```
+make install-postgres
+```
+
+Now simply run `make run` as usual to run it.
+
+This extended setup shows how you can have multiple instances of your Django (in a Kubernetes cluster, for example), and realtime notifications will work for any client connected to any of the servers. This example uses [broadcaster](https://github.com/encode/broadcaster) for subscription notifications which, in addition to `postgres`, supports `memory` (for a single node), `redis` and `kafka`. If your `django` is not using `postgres` and/or you are using one of the other options for caching or messaging, you might want to use one of those. It should Just Work if you follow the `broadcaster` docs for the connection string.

django-subscriptions-rxdb/manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'demo.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()

django-subscriptions-rxdb/pyproject.toml

@@ -0,0 +1,28 @@
+[tool.poetry]
+name = "django-subscriptions-rxdb"
+version = "0.1.0"
+description = ""
+authors = ["Patrick Arminio <[email protected]>", "Anton Melser <[email protected]>"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+strawberry-graphql = "^0.46.0"
+Django = "^3.1.7"
+uvicorn = {extras = ["standard"], version = "^0.13.4"}
+django-cors-headers = "^3.7.0"
+psycopg2-binary = {version = "^2.8.6", extras = ["postgres"], optional = true}
+broadcaster = {extras = ["postgres"], version = "^0.2.0"}
+
+[tool.poetry.extras]
+postgres = ["psycopg2-binary"]
+
+
+[tool.poetry.dev-dependencies]
+black = {version = "^20.8b1", allow-prereleases = true}
+flake8 = "^3.8.4"
+isort = "^5.7.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

django-subscriptions-rxdb/src/api/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    name = "api"

django-subscriptions-rxdb/src/api/apps.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+import typing
+
+from starlette.requests import Request
+from starlette.websockets import WebSocket
+from strawberry.asgi import GraphQL
+
+from .context import Context, get_broadcast
+
+
+class MyGraphQL(GraphQL):
+    async def get_context(
+        self, request: typing.Union[Request, WebSocket]
+    ) -> typing.Optional[typing.Any]:
+        broadcast = await get_broadcast()
+
+        return Context(broadcast)

django-subscriptions-rxdb/src/api/asgi.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+
+from broadcaster import Broadcast
+from django.db import connection
+
+broadcast = None
+
+
+async def get_broadcast():
+    global broadcast
+
+    if not broadcast:
+        dbinfo = connection.settings_dict
+        if dbinfo.get("ENGINE") == "django.db.backends.postgresql":
+            host = (
+                f"{dbinfo.get('HOST')}:{dbinfo.get('PORT')}"
+                if dbinfo.get("PORT")
+                else dbinfo.get("HOST")
+            )
+            dsnstr = f"postgresql://{dbinfo.get('USER')}:{dbinfo.get('PASSWORD')}@{host}/{dbinfo.get('NAME')}"
+            broadcast = Broadcast(dsnstr)
+        else:
+            broadcast = Broadcast("memory://")
+
+        await broadcast.connect()
+
+    return broadcast
+
+
+@dataclass
+class Context:
+    broadcast: Broadcast

django-subscriptions-rxdb/src/api/context.py

@@ -0,0 +1,26 @@
+# Generated by Django 3.1.7 on 2021-02-28 03:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="Hero",
+            fields=[
+                (
+                    "id",
+                    models.CharField(max_length=100, primary_key=True, serialize=False),
+                ),
+                ("color", models.CharField(max_length=100)),
+                ("name", models.CharField(max_length=100, null=True)),
+                ("updatedAt", models.FloatField(max_length=100, null=True)),
+                ("deleted", models.BooleanField(default=True)),
+            ],
+        ),
+    ]