77 |
84 |
85 | Now this same query:
86 | ```graphql
87 | {
88 | accountByUsername(username: "Cameron") {
89 | id
90 | username
91 | watchlist(limit: 100) {
92 | __typename
93 | ...on Movie {
94 | id
95 | title
96 | releaseYear
97 | actors {
98 | name
99 | }
100 | }
101 | ... on Show {
102 | id
103 | title
104 | }
105 | }
106 | }
107 | }
108 | ```
109 | executes with only one call to the database that looks like this:
110 | ```
111 | select Account { id, username, watchlist: { typename := .__type__.name, Movie := (select [is Movie] { __typename := .__type__.name, id, release_year, title, actors: { name } }), Show := (select [is Show] { __typename := .__type__.name, id, title }) } LIMIT Full file 👀
78 | 79 | ```Python 80 | {!./docs_src/tutorial/movies_qb.py!} 81 | ``` 82 | 83 |
40 |
41 | **SQLModel** is designed to simplify interacting with SQL databases in FastAPI applications, it was created by the same author. 😁
42 |
43 | It combines SQLAlchemy and Pydantic and tries to simplify the code you write as much as possible, allowing you to reduce the **code duplication to a minimum**, but while getting the **best developer experience** possible.
44 |
45 | **SQLModel** is, in fact, a thin layer on top of **Pydantic** and **SQLAlchemy**, carefully designed to be compatible with both.
46 |
47 | ## Requirements
48 |
49 | A recent and currently supported version of Python.
50 |
51 | As **SQLModel** is based on **Pydantic** and **SQLAlchemy**, it requires them. They will be automatically installed when you install SQLModel.
52 |
53 | ## Installation
54 |
55 |
56 |
57 | ```console
58 | $ pip install sqlmodel
59 | ---> 100%
60 | Successfully installed sqlmodel
61 | ```
62 |
63 |
64 |
65 | ## Example
66 |
67 | For an introduction to databases, SQL, and everything else, see the SQLModel documentation.
68 |
69 | Here's a quick example. ✨
70 |
71 | ### A SQL Table
72 |
73 | Imagine you have a SQL table called `hero` with:
74 |
75 | - `id`
76 | - `name`
77 | - `secret_name`
78 | - `age`
79 |
80 | And you want it to have this data:
81 |
82 | | id | name | secret_name | age |
83 | | --- | ---------- | ---------------- | ---- |
84 | | 1 | Deadpond | Dive Wilson | null |
85 | | 2 | Spider-Boy | Pedro Parqueador | null |
86 | | 3 | Rusty-Man | Tommy Sharp | 48 |
87 |
88 | ### Create a SQLModel Model
89 |
90 | Then you could create a **SQLModel** model like this:
91 |
92 | ```Python
93 | from typing import Optional
94 |
95 | from sqlmodel import Field, SQLModel
96 |
97 |
98 | class Hero(SQLModel, table=True):
99 | id: Optional[int] = Field(default=None, primary_key=True)
100 | name: str
101 | secret_name: str
102 | age: Optional[int] = None
103 | ```
104 |
105 | That class `Hero` is a **SQLModel** model, the equivalent of a SQL table in Python code.
106 |
107 | And each of those class attributes is equivalent to each **table column**.
108 |
109 | ### Create Rows
110 |
111 | Then you could **create each row** of the table as an **instance** of the model:
112 |
113 | ```Python
114 | hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
115 | hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
116 | hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
117 | ```
118 |
119 | This way, you can use conventional Python code with **classes** and **instances** that represent **tables** and **rows**, and that way communicate with the **SQL database**.
120 |
121 | ### Editor Support
122 |
123 | Everything is designed for you to get the best developer experience possible, with the best editor support.
124 |
125 | Including **autocompletion**:
126 |
127 | 
128 |
129 | And **inline errors**:
130 |
131 | 
132 |
133 | ### Write to the Database
134 |
135 | You can learn a lot more about **SQLModel** by quickly following the **tutorial**, but if you need a taste right now of how to put all that together and save to the database, you can do this:
136 |
137 | ```Python hl_lines="18 21 23-27"
138 | from typing import Optional
139 |
140 | from sqlmodel import Field, Session, SQLModel, create_engine
141 |
142 |
143 | class Hero(SQLModel, table=True):
144 | id: Optional[int] = Field(default=None, primary_key=True)
145 | name: str
146 | secret_name: str
147 | age: Optional[int] = None
148 |
149 |
150 | hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
151 | hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
152 | hero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)
153 |
154 |
155 | engine = create_engine("sqlite:///database.db")
156 |
157 |
158 | SQLModel.metadata.create_all(engine)
159 |
160 | with Session(engine) as session:
161 | session.add(hero_1)
162 | session.add(hero_2)
163 | session.add(hero_3)
164 | session.commit()
165 | ```
166 |
167 | That will save a **SQLite** database with the 3 heroes.
168 |
169 | ### Select from the Database
170 |
171 | Then you could write queries to select from that same database, for example with:
172 |
173 | ```Python hl_lines="15-18"
174 | from typing import Optional
175 |
176 | from sqlmodel import Field, Session, SQLModel, create_engine, select
177 |
178 |
179 | class Hero(SQLModel, table=True):
180 | id: Optional[int] = Field(default=None, primary_key=True)
181 | name: str
182 | secret_name: str
183 | age: Optional[int] = None
184 |
185 |
186 | engine = create_engine("sqlite:///database.db")
187 |
188 | with Session(engine) as session:
189 | statement = select(Hero).where(Hero.name == "Spider-Boy")
190 | hero = session.exec(statement).first()
191 | print(hero)
192 | ```
193 |
194 | ### Editor Support Everywhere
195 |
196 | **SQLModel** was carefully designed to give you the best developer experience and editor support, **even after selecting data** from the database:
197 |
198 | 
199 |
200 | ## SQLAlchemy and Pydantic
201 |
202 | That class `Hero` is a **SQLModel** model.
203 |
204 | But at the same time, ✨ it is a **SQLAlchemy** model ✨. So, you can combine it and use it with other SQLAlchemy models, or you could easily migrate applications with SQLAlchemy to **SQLModel**.
205 |
206 | And at the same time, ✨ it is also a **Pydantic** model ✨. You can use inheritance with it to define all your **data models** while avoiding code duplication. That makes it very easy to use with **FastAPI**.
207 |
208 | ## License
209 |
210 | This project is licensed under the terms of the [MIT license](https://github.com/tiangolo/sqlmodel/blob/main/LICENSE).
211 |
--------------------------------------------------------------------------------
/docs/old/index.md:
--------------------------------------------------------------------------------
1 | # Homepage
2 |
3 | FastGQL is a modern, fast (high-performance), web framework for building GraphQL APIs with Python 3.11+ based on standard Python type hints.
4 |
5 | The key features are:
6 |
7 | - **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
8 | - **Fast to code**: Increase the speed to develop features by about 200% to 300%. \*
9 | - **Fewer bugs**: Reduce about 40% of human (developer) induced errors. \*
10 | - **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
11 | - **Easy**: Designed to be easy to use and learn. Less time reading docs.
12 | - **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
13 | - **Robust**: Get production-ready code. With automatic interactive documentation -- via graphiql.
14 |
15 | \* estimation based on tests on an internal development team, building production applications.
16 |
17 | ## Installation
18 |
19 |
20 |
21 | ```console
22 | $ pip install fastgql
23 |
24 | ---> 100%
25 | ```
26 |
27 |
28 |
29 | You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
30 |
31 |
32 |
33 | ```console
34 | $ pip install "uvicorn[standard]"
35 |
36 | ---> 100%
37 | ```
38 |
39 |
40 |
41 | ## Example
42 |
43 | ### Create it
44 |
45 | - Create a file `main.py` with:
46 |
47 | ```Python
48 | from typing import Union
49 |
50 | from fastapi import FastAPI
51 |
52 | app = FastAPI()
53 |
54 |
55 | @app.get("/")
56 | def read_root():
57 | return {"Hello": "World"}
58 |
59 |
60 | @app.get("/items/{item_id}")
61 | def read_item(item_id: int, q: Union[str, None] = None):
62 | return {"item_id": item_id, "q": q}
63 | ```
64 |
65 |
66 | Or use
67 |
68 | If your code uses `async` / `await`, use `async def`:
69 |
70 | ```Python hl_lines="9 14"
71 | from typing import Union
72 |
73 | from fastapi import FastAPI
74 |
75 | app = FastAPI()
76 |
77 |
78 | @app.get("/")
79 | async def read_root():
80 | return {"Hello": "World"}
81 |
82 |
83 | @app.get("/items/{item_id}")
84 | async def read_item(item_id: int, q: Union[str, None] = None):
85 | return {"item_id": item_id, "q": q}
86 | ```
87 |
88 | **Note**:
89 |
90 | If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
91 |
92 |
93 |
94 | ### Run it
95 |
96 | Run the server with:
97 |
98 | Or use async def...
67 |
68 | If your code uses `async` / `await`, use `async def`:
69 |
70 | ```Python hl_lines="9 14"
71 | from typing import Union
72 |
73 | from fastapi import FastAPI
74 |
75 | app = FastAPI()
76 |
77 |
78 | @app.get("/")
79 | async def read_root():
80 | return {"Hello": "World"}
81 |
82 |
83 | @app.get("/items/{item_id}")
84 | async def read_item(item_id: int, q: Union[str, None] = None):
85 | return {"item_id": item_id, "q": q}
86 | ```
87 |
88 | **Note**:
89 |
90 | If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
91 |
92 |
99 |
100 | ```console
101 | $ uvicorn main:app --reload
102 |
103 | INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
104 | INFO: Started reloader process [28720]
105 | INFO: Started server process [28722]
106 | INFO: Waiting for application startup.
107 | INFO: Application startup complete.
108 | ```
109 |
110 |
111 |
112 |
113 | About the command
114 |
115 | The command `uvicorn main:app` refers to:
116 |
117 | - `main`: the file `main.py` (the Python "module").
118 | - `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
119 | - `--reload`: make the server restart after code changes. Only do this for development.
120 |
121 |
122 |
123 | ### Check it
124 |
125 | Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
126 |
127 | You will see the JSON response as:
128 |
129 | ```JSON
130 | {"item_id": 5, "q": "somequery"}
131 | ```
132 |
133 | You already created an API that:
134 |
135 | - Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
136 | - Both _paths_ take `GET` operations (also known as HTTP _methods_).
137 | - The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
138 | - The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
139 |
140 | ### Interactive API docs
141 |
142 | Now go to http://127.0.0.1:8000/docs.
143 |
144 | You will see the automatic interactive API documentation (provided by Swagger UI):
145 |
146 | 
147 |
148 | ### Alternative API docs
149 |
150 | And now, go to http://127.0.0.1:8000/redoc.
151 |
152 | You will see the alternative automatic documentation (provided by ReDoc):
153 |
154 | 
155 |
156 | ## Example upgrade
157 |
158 | Now modify the file `main.py` to receive a body from a `PUT` request.
159 |
160 | Declare the body using standard Python types, thanks to Pydantic.
161 |
162 | ```Python hl_lines="4 9-12 25-27"
163 | from typing import Union
164 |
165 | from fastapi import FastAPI
166 | from pydantic import BaseModel
167 |
168 | app = FastAPI()
169 |
170 |
171 | class Item(BaseModel):
172 | name: str
173 | price: float
174 | is_offer: Union[bool, None] = None
175 |
176 |
177 | @app.get("/")
178 | def read_root():
179 | return {"Hello": "World"}
180 |
181 |
182 | @app.get("/items/{item_id}")
183 | def read_item(item_id: int, q: Union[str, None] = None):
184 | return {"item_id": item_id, "q": q}
185 |
186 |
187 | @app.put("/items/{item_id}")
188 | def update_item(item_id: int, item: Item):
189 | return {"item_name": item.name, "item_id": item_id}
190 | ```
191 |
192 | The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
193 |
194 | ### Interactive API docs upgrade
195 |
196 | Now go to http://127.0.0.1:8000/docs.
197 |
198 | - The interactive API documentation will be automatically updated, including the new body:
199 |
200 | 
201 |
202 | - Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
203 |
204 | 
205 |
206 | - Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
207 |
208 | 
209 |
210 | ### Alternative API docs upgrade
211 |
212 | And now, go to http://127.0.0.1:8000/redoc.
213 |
214 | - The alternative documentation will also reflect the new query parameter and body:
215 |
216 | 
217 |
218 | ### Recap
219 |
220 | In summary, you declare **once** the types of parameters, body, etc. as function parameters.
221 |
222 | You do that with standard modern Python types.
223 |
224 | You don't have to learn a new syntax, the methods or classes of a specific library, etc.
225 |
226 | Just standard **Python 3.7+**.
227 |
228 | For example, for an `int`:
229 |
230 | ```Python
231 | item_id: int
232 | ```
233 |
234 | or for a more complex `Item` model:
235 |
236 | ```Python
237 | item: Item
238 | ```
239 |
240 | ...and with that single declaration you get:
241 |
242 | - Editor support, including:
243 | - Completion.
244 | - Type checks.
245 | - Validation of data:
246 | - Automatic and clear errors when the data is invalid.
247 | - Validation even for deeply nested JSON objects.
248 | - Conversion of input data: coming from the network to Python data and types. Reading from:
249 | - JSON.
250 | - Path parameters.
251 | - Query parameters.
252 | - Cookies.
253 | - Headers.
254 | - Forms.
255 | - Files.
256 | - Conversion of output data: converting from Python data and types to network data (as JSON):
257 | - Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
258 | - `datetime` objects.
259 | - `UUID` objects.
260 | - Database models.
261 | - ...and many more.
262 | - Automatic interactive API documentation, including 2 alternative user interfaces:
263 | - Swagger UI.
264 | - ReDoc.
265 |
266 | ---
267 |
268 | Coming back to the previous code example, **FastAPI** will:
269 |
270 | - Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
271 | - Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
272 | - If it is not, the client will see a useful, clear error.
273 | - Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
274 | - As the `q` parameter is declared with `= None`, it is optional.
275 | - Without the `None` it would be required (as is the body in the case with `PUT`).
276 | - For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
277 | - Check that it has a required attribute `name` that should be a `str`.
278 | - Check that it has a required attribute `price` that has to be a `float`.
279 | - Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
280 | - All this would also work for deeply nested JSON objects.
281 | - Convert from and to JSON automatically.
282 | - Document everything with OpenAPI, that can be used by:
283 | - Interactive documentation systems.
284 | - Automatic client code generation systems, for many languages.
285 | - Provide 2 interactive documentation web interfaces directly.
286 |
287 | ---
288 |
289 | We just scratched the surface, but you already get the idea of how it all works.
290 |
291 | Try changing the line with:
292 |
293 | ```Python
294 | return {"item_name": item.name, "item_id": item_id}
295 | ```
296 |
297 | ...from:
298 |
299 | ```Python
300 | ... "item_name": item.name ...
301 | ```
302 |
303 | ...to:
304 |
305 | ```Python
306 | ... "item_price": item.price ...
307 | ```
308 |
309 | ...and see how your editor will auto-complete the attributes and know their types:
310 |
311 | 
312 |
313 | For a more complete example including more features, see the Tutorial - User Guide.
314 |
315 | **Spoiler alert**: the tutorial - user guide includes:
316 |
317 | - Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
318 | - How to set **validation constraints** as `maximum_length` or `regex`.
319 | - A very powerful and easy to use **Dependency Injection** system.
320 | - Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
321 | - More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
322 | - **GraphQL** integration with Strawberry and other libraries.
323 | - Many extra features (thanks to Starlette) as:
324 | - **WebSockets**
325 | - extremely easy tests based on HTTPX and `pytest`
326 | - **CORS**
327 | - **Cookie Sessions**
328 | - ...and more.
329 |
330 | ## Performance
331 |
332 | Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (\*)
333 |
334 | To understand more about it, see the section Benchmarks.
335 |
336 | ## Optional Dependencies
337 |
338 | Used by Pydantic:
339 |
340 | - About the command uvicorn main:app --reload...
114 |
115 | The command `uvicorn main:app` refers to:
116 |
117 | - `main`: the file `main.py` (the Python "module").
118 | - `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
119 | - `--reload`: make the server restart after code changes. Only do this for development.
120 |
121 | email_validator - for email validation.
341 | - pydantic-settings - for settings management.
342 | - pydantic-extra-types - for extra types to be used with Pydantic.
343 |
344 | Used by Starlette:
345 |
346 | - httpx - Required if you want to use the `TestClient`.
347 | - jinja2 - Required if you want to use the default template configuration.
348 | - python-multipart - Required if you want to support form "parsing", with `request.form()`.
349 | - itsdangerous - Required for `SessionMiddleware` support.
350 | - pyyaml - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
351 | - ujson - Required if you want to use `UJSONResponse`.
352 |
353 | Used by FastAPI / Starlette:
354 |
355 | - uvicorn - for the server that loads and serves your application.
356 | - orjson - Required if you want to use `ORJSONResponse`.
357 |
358 | You can install all of these with `pip install "fastapi[all]"`.
359 |
360 | ## License
361 |
362 | This project is licensed under the terms of the MIT license.
363 |
--------------------------------------------------------------------------------
/docs/old/index_old.md:
--------------------------------------------------------------------------------
1 | # Welcome to MkDocs
2 |
3 | For full documentation visit [mkdocs.org](https://www.mkdocs.org).
4 |
5 | ## Commands
6 |
7 | * `mkdocs new [dir-name]` - Create a new project.
8 | * `mkdocs serve` - Start the live-reloading docs server.
9 | * `mkdocs build` - Build the documentation site.
10 | * `mkdocs -h` - Print help message and exit.
11 |
12 | ## Project layout
13 |
14 | mkdocs.yml # The configuration file.
15 | docs/
16 | index.md # The documentation homepage.
17 | ... # Other markdown pages, images and other files.
18 |
--------------------------------------------------------------------------------
/docs/old/tutorial_index_old.md:
--------------------------------------------------------------------------------
1 | # Intro, Installation, and First Steps
2 |
3 | ## Many of these sections were taken from the [SQLModel docs](https://sqlmodel.tiangolo.com/tutorial/), which are very good at explaining Python concepts. I'm including them here to make things easier.
4 |
5 | ## Type hints (From SQLModel)
6 |
7 | If you need a refresher about how to use Python type hints (type annotations), check FastAPI's Python types intro.
8 |
9 | You can also check the mypy cheat sheet.
10 |
11 | **FastGQL** uses type annotations for everything, this way you can use a familiar Python syntax and get all the editor support possible, with autocompletion and in-editor error checking.
12 |
13 | ## Create a Project (from SQLModel)
14 |
15 | Please go ahead and create a directory for the project we will work on on this tutorial.
16 |
17 | What I normally do is that I create a directory named `code` inside my home/user directory.
18 |
19 | And inside of that I create one directory per project.
20 |
21 | So, for example:
22 |
23 |
24 |
25 | ```console
26 | // Go to the home directory
27 | $ cd
28 | // Create a directory for all your code projects
29 | $ mkdir code
30 | // Enter into that code directory
31 | $ cd code
32 | // Create a directory for this project
33 | $ mkdir fastgql-tutorial
34 | // Enter into that directory
35 | $ cd fastgql-tutorial
36 | ```
37 |
38 |
39 |
40 | Make sure you don't name it also `fastgql`, so that you don't end up overriding the name of the package.
41 |
42 | ### Make sure you have Python
43 |
44 | Make sure you have an officially supported version of Python.
45 |
46 | You can check which version you have with:
47 |
48 |
49 |
50 | ```console
51 | $ python3 --version
52 | Python 3.12
53 | ```
54 |
55 |
56 |
57 | For now, FastGQL only supports python 3.10 and up.
58 |
59 | If you don't have python 3.10 or up installed, go and install that first.
60 |
61 | ### Create a Python virtual environment (from SQLModel)
62 |
63 | When writing Python code, you should **always** use virtual environments in one way or another.
64 |
65 | If you don't know what that is, you can read the official tutorial for virtual environments, it's quite simple.
66 |
67 | In very short, a virtual environment is a small directory that contains a copy of Python and all the libraries you need to run your code.
68 |
69 | And when you "activate" it, any package that you install, for example with `pip`, will be installed in that virtual environment.
70 |
71 | !!! tip " There are other tools to manage virtual environments, like Poetry. "
72 |
73 | And there are alternatives that are particularly useful for deployment like Docker and other types of containers. In this case, the "virtual environment" is not just the Python standard files and the installed packages, but the whole system.
74 |
75 | Go ahead and create a Python virtual environment for this project. And make sure to also upgrade `pip`.
76 |
77 | Here are the commands you could use:
78 |
79 | === "Linux, macOS, Linux in Windows"
80 |
81 |
82 |
83 | ```console
84 | // Remember that you might need to use python3.9 or similar 💡
85 | // Create the virtual environment using the module "venv"
86 | $ python3 -m venv env
87 | // ...here it creates the virtual environment in the directory "env"
88 | // Activate the virtual environment
89 | $ source ./env/bin/activate
90 | // Verify that the virtual environment is active
91 | # (env) $$ which python
92 | // The important part is that it is inside the project directory, at "code/fastgql-tutorial/env/bin/python"
93 | /home/leela/code/fastgql-tutorial/env/bin/python
94 | // Use the module "pip" to install and upgrade the package "pip" 🤯
95 | # (env) $$ python -m pip install --upgrade pip
96 | ---> 100%
97 | Successfully installed pip
98 | ```
99 |
100 |
101 |
102 | === "Windows PowerShell"
103 |
104 |
105 |
106 | ```console
107 | // Create the virtual environment using the module "venv"
108 | # >$ python3 -m venv env
109 | // ...here it creates the virtual environment in the directory "env"
110 | // Activate the virtual environment
111 | # >$ .\env\Scripts\Activate.ps1
112 | // Verify that the virtual environment is active
113 | # (env) >$ Get-Command python
114 | // The important part is that it is inside the project directory, at "code\fastgql-tutorial\env\python.exe"
115 | CommandType Name Version Source
116 | ----------- ---- ------- ------
117 | Application python 0.0.0.0 C:\Users\leela\code\fastgql-tutorial\env\python.exe
118 | // Use the module "pip" to install and upgrade the package "pip" 🤯
119 | # (env) >$ python3 -m pip install --upgrade pip
120 | ---> 100%
121 | Successfully installed pip
122 | ```
123 |
124 |
125 |
126 | ## Install **FastGQL**
127 |
128 | Now, after making sure we are inside of a virtual environment in some way, we can install **FastGQL**:
129 |
130 |
131 |
132 | ```console
133 | # (env) $$ python -m pip install fastgql
134 | ---> 100%
135 | Successfully installed fastgql
136 | ```
137 |
138 |
139 |
--------------------------------------------------------------------------------
/fastgql/__init__.py:
--------------------------------------------------------------------------------
1 | from .gql_models import GQL, GQLInput, GQLError, GQLConfigDict, GQLInterface
2 | from .schema_builder import SchemaBuilder
3 | from .info import Info
4 | from .context import BaseContext
5 | from .depends import Depends
6 | from .query_builders.edgedb.logic import get_qb
7 | from .query_builders.edgedb.query_builder import QueryBuilder, ChildEdge
8 | from .query_builders.edgedb.config import Link, Property, QueryBuilderConfig
9 | from .gql_ast.models import (
10 | Node,
11 | FieldNode,
12 | FieldNodeModel,
13 | FieldNodeField,
14 | FieldNodeMethod,
15 | OperationNode,
16 | )
17 | from .utils import node_from_path
18 |
19 | build_router = SchemaBuilder.build_router
20 |
21 | __all__ = [
22 | "SchemaBuilder",
23 | "build_router",
24 | "GQL",
25 | "GQLInterface",
26 | "GQLInput",
27 | "GQLError",
28 | "GQLConfigDict",
29 | "Info",
30 | "BaseContext",
31 | "Depends",
32 | "get_qb",
33 | "QueryBuilder",
34 | "ChildEdge",
35 | "Link",
36 | "Property",
37 | "QueryBuilderConfig",
38 | "Node",
39 | "FieldNode",
40 | "FieldNodeModel",
41 | "FieldNodeField",
42 | "FieldNodeMethod",
43 | "OperationNode",
44 | "node_from_path",
45 | ]
46 |
--------------------------------------------------------------------------------
/fastgql/context.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | from fastapi import Request, Response, BackgroundTasks
3 | from fastgql import GQLError
4 | from fastgql.gql_ast.models import Node
5 |
6 |
7 | class BaseContext:
8 | def __init__(
9 | self,
10 | request: Request,
11 | response: Response,
12 | background_tasks: BackgroundTasks,
13 | errors: list[GQLError],
14 | variables: dict[str, T.Any],
15 | ):
16 | self.request = request
17 | self.response = response
18 | self.background_tasks = background_tasks
19 | self.errors = errors
20 | self.variables = variables
21 |
22 | self.overwrite_return_value_map: dict[Node, T.Any] = {}
23 |
--------------------------------------------------------------------------------
/fastgql/depends.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 |
3 |
4 | class Depends:
5 | def __init__(self, dependency: T.Callable):
6 | self.dependency = dependency
7 |
8 |
9 | __all__ = ["Depends"]
10 |
--------------------------------------------------------------------------------
/fastgql/execute/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jerber/fastgql/064c1e846b1758a967d1464c50d7fef6b9f095b9/fastgql/execute/__init__.py
--------------------------------------------------------------------------------
/fastgql/execute/executor.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import time
3 |
4 | import graphql
5 | from fastapi import Request, Response, BackgroundTasks
6 |
7 | from fastgql.gql_ast import models as M
8 | from fastgql.gql_ast.translator import Translator
9 | from fastgql.gql_models import GQL, GQLError
10 | from fastgql.execute.utils import (
11 | build_is_not_nullable_map,
12 | CacheDict,
13 | Result,
14 | InfoType,
15 | ContextType,
16 | gql_errors_to_graphql_errors,
17 | RESULT_WRAPPERS,
18 | )
19 | from fastgql.execute.resolver import Resolver
20 |
21 | DISPLAY_TO_PYTHON_MAP: dict[str, str] = {}
22 |
23 |
24 | class Executor:
25 | """this class has the un-changing config"""
26 |
27 | def __init__(
28 | self,
29 | python_to_display_map: dict[str, str],
30 | schema: graphql.GraphQLSchema,
31 | query_model: GQL | None,
32 | mutation_model: GQL | None,
33 | root_nodes_cache_size: int = 100,
34 | process_errors: T.Optional[T.Callable[[list[GQLError]], list[GQLError]]] = None,
35 | result_wrappers: RESULT_WRAPPERS = None,
36 | ):
37 | self.python_to_display_map = python_to_display_map
38 | self.display_to_python_map = {
39 | v: k for k, v in self.python_to_display_map.items()
40 | }
41 | self.schema = schema
42 | self.is_not_nullable_map = build_is_not_nullable_map(schema)
43 | self.operation_type_to_model: dict[M.OperationType, GQL | None] = {
44 | M.OperationType.query: query_model,
45 | M.OperationType.mutation: mutation_model,
46 | }
47 | self.root_nodes_cache: dict[str, list[M.OperationNode]] = CacheDict(
48 | cache_len=root_nodes_cache_size
49 | )
50 | self.process_errors = process_errors
51 | self.result_wrappers = result_wrappers
52 |
53 | DISPLAY_TO_PYTHON_MAP.update(self.display_to_python_map)
54 |
55 | async def execute(
56 | self,
57 | *,
58 | source: str,
59 | variable_values: dict[str, T.Any] | None,
60 | operation_name: str | None,
61 | validate_schema: bool = True,
62 | validate_query: bool = True,
63 | validate_variables: bool = True,
64 | info_cls: T.Type[InfoType],
65 | context_cls: T.Type[ContextType],
66 | request: Request,
67 | response: Response,
68 | bt: BackgroundTasks,
69 | use_cache: bool,
70 | print_timings: bool = False,
71 | ) -> Result:
72 | start_for_root_nodes = time.time()
73 | if use_cache:
74 | root_nodes = self.root_nodes_cache.get(source)
75 | else:
76 | root_nodes = None
77 | if not root_nodes:
78 | if validate_schema:
79 | schema_validation_errors = graphql.validate_schema(self.schema)
80 | if schema_validation_errors:
81 | return Result(
82 | data=None, errors=schema_validation_errors, extensions=None
83 | )
84 | try:
85 | document = graphql.parse(source)
86 | except graphql.GraphQLError as error:
87 | return Result(data=None, errors=[error], extensions=None)
88 | if validate_query:
89 | validation_errors = graphql.validation.validate(self.schema, document)
90 | if validation_errors:
91 | return Result(data=None, errors=validation_errors, extensions=None)
92 | if validate_variables:
93 | from graphql.execution.execute import assert_valid_execution_arguments
94 |
95 | assert_valid_execution_arguments(self.schema, document, variable_values)
96 |
97 | start_translate = time.time()
98 | root_nodes = Translator(
99 | document=document,
100 | schema=self.schema,
101 | display_to_python_map=self.display_to_python_map,
102 | ).translate()
103 | if print_timings:
104 | print(
105 | f"[TRANSLATING] took {(time.time() - start_translate) * 1_000} ms"
106 | )
107 | if use_cache:
108 | self.root_nodes_cache[source] = root_nodes
109 | if print_timings:
110 | print(
111 | f"[ROOT NODES] parsing took {(time.time() - start_for_root_nodes) * 1_000} ms"
112 | )
113 | resolver = Resolver(
114 | operation_name=operation_name,
115 | display_to_python_map=self.display_to_python_map,
116 | info_cls=info_cls,
117 | context_cls=context_cls,
118 | is_not_nullable_map=self.is_not_nullable_map,
119 | variables=variable_values,
120 | request=request,
121 | response=response,
122 | bt=bt,
123 | )
124 | d = await resolver.resolve_root_nodes(
125 | root_nodes=root_nodes, operation_type_to_model=self.operation_type_to_model
126 | )
127 | # now process errors
128 | if self.process_errors:
129 | errors = self.process_errors(resolver.errors)
130 | else:
131 | errors = resolver.errors
132 | return Result(
133 | data=d, errors=gql_errors_to_graphql_errors(errors), extensions=None
134 | )
135 |
--------------------------------------------------------------------------------
/fastgql/execute/resolver.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import traceback
3 | import asyncio
4 | import inspect
5 |
6 | from fastapi import Request, Response, BackgroundTasks
7 | from pydantic import TypeAdapter, ValidationError
8 |
9 | from fastgql.gql_ast import models as M
10 | from fastgql.gql_models import GQL, GQLError
11 | from fastgql.depends import Depends
12 | from fastgql.execute.utils import InfoType, parse_value, Info, ContextType
13 | from fastgql.utils import node_from_path
14 | import pydantic_core
15 |
16 |
17 | class Resolver:
18 | def __init__(
19 | self,
20 | *,
21 | operation_name: str | None,
22 | display_to_python_map: dict[str, str],
23 | info_cls: T.Type[InfoType],
24 | context_cls: T.Type[ContextType],
25 | is_not_nullable_map: dict[str, dict[str, bool]],
26 | variables: dict[str, T.Any] | None,
27 | request: Request,
28 | response: Response,
29 | bt: BackgroundTasks,
30 | ):
31 | self.operation_name = operation_name
32 | self.display_to_python_map = display_to_python_map
33 | self.info_cls = info_cls
34 | self.is_not_nullable_map = is_not_nullable_map
35 | self.variables = variables
36 |
37 | self.request = request
38 | self.response = response
39 | self.bt = bt
40 |
41 | self.errors: list[GQLError] = []
42 |
43 | self.context: ContextType = context_cls(
44 | request=self.request,
45 | response=self.response,
46 | background_tasks=self.bt,
47 | errors=self.errors,
48 | variables=self.variables,
49 | )
50 |
51 | async def inject_dependencies(
52 | self, func: T.Callable[..., T.Any], kwargs: dict[str, T.Any], info: InfoType
53 | ) -> T.Any:
54 | # if you need to build kwargs, do it. Then execute
55 | new_kwargs = await self.build_kwargs(func=func, kwargs=kwargs, info=info)
56 | res = func(**new_kwargs)
57 | if inspect.isawaitable(res):
58 | res = await res
59 | return res
60 |
61 | async def build_kwargs(
62 | self, func: T.Callable[..., T.Any], kwargs: dict[str, T.Any], info: InfoType
63 | ) -> dict[str, T.Any]:
64 | new_kwargs: dict[str, T.Any] = {}
65 | sig = inspect.signature(func)
66 | for name, param in sig.parameters.items():
67 | if name in kwargs:
68 | val = kwargs[name]
69 | if val is not None:
70 | try:
71 | val = TypeAdapter(param.annotation).validate_python(
72 | val,
73 | context={
74 | "_display_to_python_map": self.display_to_python_map
75 | },
76 | )
77 | except ValidationError as e:
78 | if e.errors()[0]["type"] == "list_type" and not isinstance(
79 | val, list
80 | ):
81 | val = TypeAdapter(param.annotation).validate_python(
82 | [val],
83 | context={
84 | "_display_to_python_map": self.display_to_python_map
85 | },
86 | )
87 | else:
88 | raise e
89 | new_kwargs[name] = val
90 | else:
91 | if isinstance(param.default, Depends):
92 | new_kwargs[name] = await self.inject_dependencies(
93 | func=param.default.dependency, kwargs=kwargs, info=info
94 | )
95 | elif inspect.isclass(param.annotation):
96 | if issubclass(param.annotation, Info):
97 | new_kwargs[name] = info
98 | elif issubclass(param.annotation, Request):
99 | new_kwargs[name] = self.request
100 | elif issubclass(param.annotation, Response):
101 | new_kwargs[name] = self.response
102 | elif issubclass(param.annotation, BackgroundTasks):
103 | new_kwargs[name] = self.bt
104 | # just continue, the value is not given and that is okay
105 | return new_kwargs
106 |
107 | def get_info_key(self, func: T.Callable[..., T.Any]) -> str | None:
108 | sig = inspect.signature(func)
109 | for name, param in sig.parameters.items():
110 | if param.annotation == self.info_cls:
111 | return name
112 |
113 | async def inject_dependencies_and_execute(
114 | self,
115 | node: M.FieldNode,
116 | parent: M.Node,
117 | method: T.Callable | T.Awaitable,
118 | kwargs: dict[str, T.Any],
119 | new_path: tuple[str, ...],
120 | ) -> dict[str, T.Any] | list[dict[str, T.Any]] | T.Any | None:
121 | # TODO if inefficient, lazily create info! Or maybe even cache it... or come up with a better way
122 | info = self.info_cls(
123 | node=node,
124 | parent_node=parent,
125 | path=new_path,
126 | context=self.context,
127 | )
128 | new_kwargs = await self.build_kwargs(func=method, kwargs=kwargs, info=info)
129 | child_model_s = method(**new_kwargs)
130 | if inspect.isawaitable(child_model_s):
131 | child_model_s = await child_model_s
132 | if child_model_s:
133 | if node.children:
134 | return await self.resolve_node_s(
135 | node=node, model_s=child_model_s, path=new_path
136 | )
137 | else:
138 | return child_model_s
139 | return child_model_s
140 |
141 | async def resolve_node_s(
142 | self,
143 | node: M.FieldNode | M.OperationNode,
144 | model_s: list[GQL] | GQL,
145 | path: tuple[str, ...],
146 | ) -> dict[str, T.Any] | None | list[dict[str, T.Any] | None]:
147 | if isinstance(model_s, list):
148 | return list(
149 | await asyncio.gather(
150 | *[
151 | self.resolve_node(node=node, model=model, path=path)
152 | for model in model_s
153 | ]
154 | )
155 | )
156 | return await self.resolve_node(node=node, model=model_s, path=path)
157 |
158 | async def resolve_node(
159 | self,
160 | node: M.FieldNode | M.OperationNode,
161 | model: GQL,
162 | path: tuple[str, ...],
163 | ) -> dict[str, T.Any] | None:
164 | if model is None:
165 | return None
166 | if not isinstance(model, GQL):
167 | raise Exception(
168 | f"Model {model.__class__.__name__} must be an instance of GQL."
169 | )
170 | # return final dict, or array of dicts, for the node
171 | final_d: dict[str, T.Any] = {}
172 | fields_to_include: dict[str, str] = {}
173 | name_to_return_to_display_name: dict[str, str] = {}
174 | children_q = [*node.children]
175 | proms_map: dict[str, T.Awaitable] = {}
176 | while len(children_q) > 0:
177 | child = children_q.pop(0)
178 | if isinstance(child, M.InlineFragmentNode):
179 | if child.type_condition == model.gql_type_name():
180 | children_q[:0] = child.children
181 | continue
182 | name_to_return = child.alias or child.display_name
183 | name_to_return_to_display_name[name_to_return] = child.display_name
184 | if child in self.context.overwrite_return_value_map:
185 | final_d[name_to_return] = self.context.overwrite_return_value_map[child]
186 | continue
187 | new_path = (*path, name_to_return)
188 | if child.name == "__typename":
189 | final_d[name_to_return] = model.gql_type_name()
190 | else:
191 | if child.name not in model.model_fields:
192 | # this must be a function
193 |
194 | kwargs = {}
195 | for arg in child.arguments:
196 | _v = parse_value(variables=self.variables, v=arg.value)
197 | if _v != pydantic_core.PydanticUndefined:
198 | kwargs[arg.name] = _v
199 |
200 | proms_map[name_to_return] = self.inject_dependencies_and_execute(
201 | method=getattr(model, child.name),
202 | node=child,
203 | parent=node,
204 | kwargs=kwargs,
205 | new_path=new_path,
206 | )
207 | else:
208 | if not child.children:
209 | # this is a property
210 | fields_to_include[child.name] = name_to_return
211 | else:
212 | # this is either a BaseModel or a list of BaseModel
213 | proms_map[name_to_return] = self.resolve_node_s(
214 | node=child,
215 | path=new_path,
216 | model_s=getattr(model, child.name),
217 | )
218 |
219 | # now gather the await-ables
220 | if proms_map:
221 | vals = await asyncio.gather(*proms_map.values(), return_exceptions=True)
222 | for name, val in zip(proms_map.keys(), vals):
223 | if isinstance(val, Exception):
224 | if isinstance(val, GQLError):
225 | self.errors.append(val)
226 | else:
227 | # do not expose this error to client
228 | # include stack trace and send to sentry
229 | node_that_errored = node_from_path(
230 | node=node,
231 | path=[name],
232 | use_field_to_use=True,
233 | )
234 | self.errors.append(
235 | GQLError(
236 | message="Internal Server Error",
237 | node=node_that_errored,
238 | original_error=val,
239 | path=(*path, name),
240 | )
241 | )
242 | traceback.print_exception(val)
243 | val = None
244 | final_d[name] = val
245 | model_d = model.model_dump(mode="json", include=set(fields_to_include))
246 | for name, name_to_use in fields_to_include.items():
247 | final_d[name_to_use] = model_d[name]
248 | if name_to_use != name:
249 | final_d[name] = model_d[name]
250 |
251 | # now null check and order property
252 | sorted_d = {}
253 | for name_to_return, name in name_to_return_to_display_name.items():
254 | val = final_d[name_to_return]
255 | if (
256 | val is None or isinstance(val, list) and None in val
257 | ): # TODO speed test, must go thru every list?
258 | if self.is_not_nullable_map[model.gql_type_name()][name]:
259 | # get the actual node from the path
260 | null_node = node_from_path(
261 | node=node, path=[name_to_return], use_field_to_use=True
262 | )
263 | if (
264 | null_node not in self.context.overwrite_return_value_map
265 | and path
266 | ):
267 | full_path_to_error = (*path, name_to_return)
268 | self.errors.append(
269 | GQLError(
270 | message=f"Cannot return null for non-nullable field {'.'.join(full_path_to_error)}",
271 | path=full_path_to_error,
272 | node=null_node,
273 | )
274 | )
275 | if node not in self.context.overwrite_return_value_map:
276 | self.context.overwrite_return_value_map[node] = None
277 | return None
278 | sorted_d[name_to_return] = val
279 | del final_d
280 | return sorted_d
281 |
282 | async def resolve_root_nodes(
283 | self,
284 | root_nodes: list[M.OperationNode],
285 | operation_type_to_model: dict[M.OperationType, GQL | None],
286 | ) -> dict[str, T.Any] | None:
287 | proms = []
288 | for root_node in root_nodes:
289 | model = operation_type_to_model[root_node.type]
290 | if not model:
291 | raise Exception(f"{root_node.type} type required.")
292 | proms.append(
293 | self.resolve_node(
294 | node=root_node,
295 | model=operation_type_to_model[root_node.type],
296 | path=(),
297 | )
298 | )
299 | d_list = await asyncio.gather(*proms)
300 | final_d = {}
301 | for d in d_list:
302 | if d is None:
303 | return None
304 | final_d.update(d)
305 | return final_d
306 |
--------------------------------------------------------------------------------
/fastgql/execute/utils.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 |
3 | import pydantic_core
4 | from fastapi import Request, Response, BackgroundTasks
5 | from collections import OrderedDict
6 | from dataclasses import dataclass
7 |
8 | from pydantic import create_model
9 | import graphql
10 |
11 | from fastgql.info import Info, ContextType
12 | from fastgql.gql_models import GQL, GQLError
13 |
14 | InfoType = T.TypeVar("InfoType", bound=Info)
15 |
16 |
17 | @dataclass
18 | class GraphQLRequestData:
19 | # query is optional here as it can be added by an extensions
20 | # (for example an extension for persisted queries)
21 | query: str | None
22 | variables: dict[str, T.Any] | None
23 | operation_name: str | None
24 |
25 |
26 | @dataclass
27 | class Result:
28 | data: T.Any | None
29 | errors: list[graphql.GraphQLError] | None
30 | extensions: list[T.Any] | None
31 |
32 |
33 | RESULT_WRAPPERS = T.Optional[
34 | T.List[
35 | T.Callable[
36 | [GraphQLRequestData, Result, dict[str, T.Any], Request, Response, BackgroundTasks],
37 | T.Coroutine[T.Any, T.Any, Result],
38 | ]
39 | ]
40 | ]
41 |
42 |
43 | def gql_errors_to_graphql_errors(
44 | gql_errors: list[GQLError],
45 | ) -> list[graphql.GraphQLError]:
46 | graphql_errors: list[graphql.GraphQLError] = []
47 | for e in gql_errors:
48 | graphql_errors.append(
49 | graphql.GraphQLError(
50 | message=e.message,
51 | nodes=e.node.original_node if e.node else None,
52 | path=e.path,
53 | original_error=e.original_error,
54 | extensions=e.extensions,
55 | )
56 | )
57 | return graphql_errors
58 |
59 |
60 | class CacheDict(OrderedDict):
61 | """Dict with a limited length, ejecting LRUs as needed."""
62 |
63 | def __init__(self, *args, cache_len: int, **kwargs):
64 | assert cache_len > 0
65 | self.cache_len = cache_len
66 |
67 | super().__init__(*args, **kwargs)
68 |
69 | def __setitem__(self, key, value):
70 | super().__setitem__(key, value)
71 | super().move_to_end(key)
72 |
73 | while len(self) > self.cache_len:
74 | oldkey = next(iter(self))
75 | super().__delitem__(oldkey)
76 |
77 | def __getitem__(self, key):
78 | val = super().__getitem__(key)
79 | super().move_to_end(key)
80 |
81 | return val
82 |
83 |
84 | def combine_models(name: str, *models: T.Type[GQL]) -> T.Type[GQL]:
85 | combined_model = create_model(name, __base__=GQL)
86 |
87 | seen_fields = set()
88 | excluded_methods = set(dir(GQL))
89 |
90 | for model in models:
91 | for field_name, field_value in model.model_fields.items():
92 | if field_name in seen_fields:
93 | raise ValueError(f"Conflicting field: {field_name}")
94 | setattr(combined_model, field_name, field_value)
95 | seen_fields.add(field_name)
96 |
97 | for method_name in dir(model):
98 | if (
99 | not method_name.startswith("_")
100 | and callable(getattr(model, method_name))
101 | and method_name not in excluded_methods
102 | ):
103 | method = getattr(model, method_name)
104 | if isinstance(model.__dict__.get(method_name), staticmethod):
105 | method = staticmethod(method)
106 | elif isinstance(model.__dict__.get(method_name), classmethod):
107 | method = classmethod(method)
108 | if method_name in dir(combined_model):
109 | raise ValueError(f"Conflicting method: {method_name}")
110 | setattr(combined_model, method_name, method)
111 |
112 | combined_model.model_rebuild()
113 | return combined_model
114 |
115 |
116 | def parse_value(variables: dict[str, T.Any] | None, v: T.Any) -> T.Any:
117 | if isinstance(v, dict):
118 | return {
119 | k: parse_value(variables=variables, v=inner_v) for k, inner_v in v.items()
120 | }
121 | if isinstance(v, list):
122 | return [parse_value(variables=variables, v=inner_v) for inner_v in v]
123 | if isinstance(v, graphql.VariableNode):
124 | if v.name.value not in variables:
125 | return pydantic_core.PydanticUndefined
126 | return variables[v.name.value]
127 | return v
128 |
129 |
130 | def build_is_not_nullable_map(
131 | schema: graphql.GraphQLSchema,
132 | ) -> dict[str, dict[str, bool]]:
133 | is_not_nullable_map: dict[str, dict[str, bool]] = {}
134 | for type_name, gql_type in schema.type_map.items():
135 | if isinstance(gql_type, graphql.GraphQLObjectType):
136 | is_not_nullable_map[type_name] = {}
137 | type_map = is_not_nullable_map[type_name]
138 | for field_name, field_val in gql_type.fields.items():
139 | field_val: graphql.GraphQLField
140 | type_map[field_name] = isinstance(
141 | field_val.type, graphql.GraphQLNonNull
142 | )
143 | return is_not_nullable_map
144 |
145 |
146 | def get_root_type(
147 | gql_field: graphql.GraphQLField | graphql.GraphQLObjectType,
148 | ) -> graphql.GraphQLObjectType | list[graphql.GraphQLObjectType]:
149 | if isinstance(gql_field, graphql.GraphQLObjectType):
150 | return gql_field
151 | t = gql_field.type
152 | while True:
153 | if isinstance(t, graphql.GraphQLUnionType):
154 | return [get_root_type(gql_field=tt) for tt in t.types]
155 | if isinstance(t, graphql.GraphQLObjectType):
156 | return t
157 | t = t.of_type
158 |
159 |
160 | __all__ = [
161 | "InfoType",
162 | "ContextType",
163 | "get_root_type",
164 | "build_is_not_nullable_map",
165 | "parse_value",
166 | "combine_models",
167 | "Result",
168 | "gql_errors_to_graphql_errors",
169 | "CacheDict",
170 | "Info",
171 | "GraphQLRequestData",
172 | "RESULT_WRAPPERS",
173 | ]
174 |
--------------------------------------------------------------------------------
/fastgql/gql_ast/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jerber/fastgql/064c1e846b1758a967d1464c50d7fef6b9f095b9/fastgql/gql_ast/__init__.py
--------------------------------------------------------------------------------
/fastgql/gql_ast/models.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import uuid
3 | from dataclasses import dataclass, field
4 | from enum import Enum
5 | import graphql
6 | from pydantic import BaseModel
7 | from pydantic.fields import FieldInfo
8 |
9 |
10 | class OperationType(str, Enum):
11 | query = "query"
12 | mutation = "mutation"
13 |
14 |
15 | @dataclass
16 | class Argument:
17 | name: str
18 | display_name: str
19 | value: T.Any | None
20 |
21 |
22 | @dataclass(frozen=True)
23 | class Node:
24 | id: uuid.UUID
25 | original_node: graphql.Node
26 | children: list[T.Union["FieldNode", "InlineFragmentNode"]] | None
27 |
28 | def __hash__(self):
29 | return hash(self.id)
30 |
31 |
32 | @dataclass(frozen=True)
33 | class FieldNode(Node):
34 | name: str
35 | alias: str | None
36 | display_name: str
37 | arguments: list[Argument]
38 | annotation: T.Any
39 |
40 | def __hash__(self):
41 | return hash(self.id)
42 |
43 |
44 | @dataclass(frozen=True)
45 | class FieldNodeField(FieldNode):
46 | field: FieldInfo
47 |
48 | def __hash__(self):
49 | return hash(self.id)
50 |
51 |
52 | @dataclass(frozen=True)
53 | class FieldNodeMethod(FieldNode):
54 | method: T.Callable
55 |
56 | def __hash__(self):
57 | return hash(self.id)
58 |
59 |
60 | @dataclass(frozen=True)
61 | class FieldNodeModel(FieldNode):
62 | models: list[T.Type[BaseModel]]
63 |
64 | def __hash__(self):
65 | return hash(self.id)
66 |
67 |
68 | @dataclass(frozen=True)
69 | class InlineFragmentNode(Node):
70 | type_condition: str
71 | annotation: T.Any
72 |
73 | def __hash__(self):
74 | return hash(self.id)
75 |
76 |
77 | @dataclass(frozen=True)
78 | class OperationNode(Node):
79 | name: str | None
80 | type: OperationType
81 |
82 | def __hash__(self):
83 | return hash(self.id)
84 |
85 |
86 | __all__ = [
87 | "OperationType",
88 | "Argument",
89 | "Node",
90 | "FieldNode",
91 | "FieldNodeField",
92 | "FieldNodeModel",
93 | "FieldNodeMethod",
94 | "InlineFragmentNode",
95 | "OperationNode",
96 | ]
97 |
--------------------------------------------------------------------------------
/fastgql/gql_ast/translator.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import uuid
3 | import graphql
4 | from graphql.type.definition import GraphQLNullableType
5 | from .models import (
6 | FieldNode,
7 | FieldNodeModel,
8 | FieldNodeMethod,
9 | FieldNodeField,
10 | OperationNode,
11 | OperationType,
12 | InlineFragmentNode,
13 | Argument,
14 | )
15 |
16 |
17 | class Translator:
18 | def __init__(
19 | self,
20 | document: graphql.DocumentNode,
21 | schema: graphql.GraphQLSchema,
22 | display_to_python_map: dict[str, str],
23 | ):
24 | self.document = document
25 | self.schema = schema
26 | self.display_to_python_map = display_to_python_map
27 | self.query_definitions: list[graphql.OperationDefinitionNode] = []
28 | self.mutation_definitions: list[graphql.OperationDefinitionNode] = []
29 | self.subscription_definitions: list[graphql.OperationDefinitionNode] = []
30 | self.fragment_definitions: dict[str, graphql.FragmentDefinitionNode] = {}
31 |
32 | def parse_val(self, val: graphql.ValueNode) -> T.Any:
33 | if isinstance(val, graphql.VariableNode):
34 | return val
35 | if isinstance(val, graphql.IntValueNode):
36 | return int(val.value)
37 | if isinstance(val, graphql.FloatValueNode):
38 | return float(val.value)
39 | if isinstance(val, graphql.StringValueNode):
40 | return val.value
41 | if isinstance(val, graphql.BooleanValueNode):
42 | return bool(val.value)
43 | if isinstance(val, graphql.ObjectValueNode):
44 | return {
45 | field.name.value: self.parse_val(field.value) for field in val.fields
46 | }
47 | if isinstance(val, graphql.ListValueNode):
48 | return [self.parse_val(v) for v in val.values]
49 | if isinstance(val, graphql.NullValueNode):
50 | return None
51 | # TODO for enums, lists... might need to use pydantic validate call here...anoying w return types and all
52 | return val.value
53 |
54 | @staticmethod
55 | def combine_sels(
56 | a: graphql.InlineFragmentNode | graphql.FieldNode,
57 | b: graphql.InlineFragmentNode | graphql.FieldNode,
58 | ) -> graphql.InlineFragmentNode | graphql.FieldNode:
59 | new_node: graphql.InlineFragmentNode | graphql.FieldNode = a.__copy__()
60 | if isinstance(a, graphql.FieldNode):
61 | new_node.arguments = (*a.arguments, *b.arguments)
62 | if not new_node.selection_set:
63 | new_node.selection_set = graphql.SelectionNode()
64 | new_node.selection_set.selections = (
65 | *(a.selection_set.selections if a.selection_set else []),
66 | *(b.selection_set.selections if b.selection_set else []),
67 | )
68 | return new_node
69 |
70 | def children_from_node(
71 | self,
72 | gql_field: graphql.GraphQLField | graphql.GraphQLObjectType,
73 | node: graphql.FieldNode | graphql.InlineFragmentNode,
74 | path_to_children: tuple[str, ...],
75 | ) -> list[FieldNode | InlineFragmentNode] | None:
76 | if node.selection_set is None:
77 | return None
78 | children: list[FieldNode | InlineFragmentNode] = []
79 | root_field = self.get_root_type(type_=gql_field)
80 | selection_q = list({*node.selection_set.selections})
81 |
82 | # first, flatten and combine them
83 | has_seen: dict[str, graphql.InlineFragmentNode | graphql.FieldNode] = {}
84 | while len(selection_q) > 0:
85 | sel = selection_q.pop(0)
86 | if isinstance(sel, graphql.FragmentSpreadNode):
87 | frag = self.fragment_definitions[sel.name.value]
88 | selection_q.extend(frag.selection_set.selections)
89 | continue
90 | if isinstance(sel, graphql.FieldNode):
91 | key = sel.alias.value if sel.alias else sel.name.value
92 | elif isinstance(sel, graphql.InlineFragmentNode):
93 | key = sel.type_condition.name
94 | else:
95 | raise Exception(f"Invalid sel: {sel=}")
96 | if existing := has_seen.get(key):
97 | sel = self.combine_sels(existing, sel)
98 | has_seen[key] = sel
99 |
100 | for sel in has_seen.values():
101 | if isinstance(sel, graphql.InlineFragmentNode):
102 | gql_field = self.get_root_type(
103 | root_field, type_condition=sel.type_condition.name.value
104 | )
105 | else:
106 | sel_name = sel.name.value
107 | if sel_name == "__typename":
108 | gql_field = None
109 | else:
110 | gql_field = root_field.fields[sel_name]
111 | child_s = self.from_node(
112 | gql_field=gql_field, node=sel, path=path_to_children
113 | )
114 | children.extend(child_s if isinstance(child_s, list) else [child_s])
115 | return children
116 |
117 | # @cache #TODO cache but these models are not hashable...
118 | def get_root_type(
119 | self,
120 | type_: T.Union[
121 | GraphQLNullableType,
122 | graphql.GraphQLNonNull,
123 | graphql.GraphQLField,
124 | graphql.GraphQLUnionType,
125 | ],
126 | type_condition: str = None,
127 | ) -> graphql.GraphQLObjectType | tuple[graphql.GraphQLUnionType] | None:
128 | if hasattr(type_, "of_type"):
129 | return self.get_root_type(type_.of_type, type_condition=type_condition)
130 | if hasattr(type_, "type"):
131 | return self.get_root_type(type_.type, type_condition=type_condition)
132 | if type_condition:
133 | if hasattr(type_, "types"):
134 | types = [self.get_root_type(t) for t in type_.types]
135 | for t in types:
136 | if t.name == type_condition:
137 | return t
138 | raise Exception("Type condition was not found.")
139 |
140 | return type_
141 |
142 | def from_node(
143 | self,
144 | gql_field: graphql.GraphQLField | graphql.GraphQLObjectType | None,
145 | node: graphql.SelectionNode,
146 | path: tuple[str, ...],
147 | ) -> FieldNode | InlineFragmentNode | list[FieldNode | InlineFragmentNode]:
148 | """if this is a fragment, return many nodes"""
149 | if isinstance(node, graphql.FragmentSpreadNode):
150 | frag = self.fragment_definitions[node.name.value]
151 | return [
152 | self.from_node(
153 | gql_field=gql_field,
154 | node=sel,
155 | path=path,
156 | )
157 | for sel in frag.selection_set.selections
158 | ]
159 |
160 | if not gql_field:
161 | annotation = None
162 | elif isinstance(gql_field, graphql.GraphQLObjectType):
163 | annotation = gql_field._pydantic_model
164 | else:
165 | annotation = gql_field.type._anno
166 |
167 | if isinstance(node, graphql.InlineFragmentNode):
168 | type_condition = node.type_condition.name.value
169 | return InlineFragmentNode(
170 | id=uuid.uuid4(),
171 | children=self.children_from_node(
172 | gql_field=gql_field,
173 | node=node,
174 | path_to_children=(*path, type_condition),
175 | ),
176 | original_node=node,
177 | type_condition=type_condition,
178 | annotation=annotation,
179 | )
180 | elif isinstance(node, graphql.FieldNode):
181 | # build args
182 | arguments: list[Argument] = []
183 | for argument in node.arguments:
184 | arguments.append(
185 | Argument(
186 | display_name=argument.name.value,
187 | name=self.display_to_python_map[argument.name.value],
188 | value=self.parse_val(argument.value),
189 | )
190 | )
191 | alias = node.alias.value if node.alias else None
192 | try:
193 | name = self.display_to_python_map[node.name.value]
194 | except KeyError as e:
195 | if node.name.value == "__typename":
196 | name = node.name.value
197 | else:
198 | raise e
199 |
200 | children = self.children_from_node(
201 | gql_field=gql_field,
202 | node=node,
203 | path_to_children=(*path, node.name.value),
204 | )
205 | display_name = node.name.value
206 | # gql_field_type = self.get_root_type(gql_field)
207 | if not gql_field:
208 | # this is __typename
209 | return FieldNode(
210 | id=uuid.uuid4(),
211 | original_node=node,
212 | children=children,
213 | name=name,
214 | alias=alias,
215 | display_name=display_name,
216 | arguments=arguments,
217 | annotation=annotation,
218 | )
219 | gql_field_type = gql_field.type
220 | if hasattr(gql_field_type, "_field_info"):
221 | return FieldNodeField(
222 | id=uuid.uuid4(),
223 | original_node=node,
224 | children=children,
225 | name=name,
226 | alias=alias,
227 | display_name=display_name,
228 | arguments=arguments,
229 | annotation=annotation,
230 | field=gql_field_type._field_info,
231 | )
232 | elif hasattr(gql_field_type, "_method"):
233 | return FieldNodeMethod(
234 | id=uuid.uuid4(),
235 | original_node=node,
236 | children=children,
237 | name=name,
238 | alias=alias,
239 | display_name=display_name,
240 | arguments=arguments,
241 | annotation=annotation,
242 | method=gql_field_type._method,
243 | )
244 | else:
245 | root_type = self.get_root_type(gql_field)
246 | if isinstance(root_type, graphql.GraphQLUnionType):
247 | models = [t._pydantic_model for t in root_type.types]
248 | elif hasattr(root_type, "_pydantic_model"):
249 | models = [root_type._pydantic_model]
250 | else:
251 | # hacky fix because the enum wasn't being registered
252 | if isinstance(root_type, graphql.GraphQLEnumType):
253 | gql_field_temp = getattr(gql_field_type, "of_type")
254 | while not hasattr(gql_field_temp, "_field_info"):
255 | # TODO not sure if this is okay
256 | if not hasattr(gql_field_temp, "of_type"):
257 | return FieldNodeField(
258 | id=uuid.uuid4(),
259 | original_node=node,
260 | children=children,
261 | name=name,
262 | alias=alias,
263 | display_name=display_name,
264 | arguments=arguments,
265 | annotation=annotation,
266 | field=None,
267 | )
268 | gql_field_temp = getattr(gql_field_temp, "of_type")
269 | return FieldNodeField(
270 | id=uuid.uuid4(),
271 | original_node=node,
272 | children=children,
273 | name=name,
274 | alias=alias,
275 | display_name=display_name,
276 | arguments=arguments,
277 | annotation=annotation,
278 | field=gql_field_temp._field_info,
279 | )
280 | # otherwise, this will be an object type
281 | return FieldNodeModel(
282 | id=uuid.uuid4(),
283 | original_node=node,
284 | children=children,
285 | name=name,
286 | alias=alias,
287 | display_name=display_name,
288 | arguments=arguments,
289 | models=models,
290 | annotation=annotation,
291 | )
292 | else:
293 | raise Exception(f"Invalid node type: {type(node)=}, {node=}")
294 |
295 | def from_operation_node(
296 | self, node: graphql.OperationDefinitionNode
297 | ) -> OperationNode:
298 | # first, build children, and then their children
299 | children: list[FieldNode | InlineFragmentNode] = []
300 | # TODO possible inline frags?
301 | for sel in node.selection_set.selections:
302 | if node.operation == graphql.OperationType.MUTATION:
303 | gql_field = self.schema.mutation_type
304 | elif node.operation == graphql.OperationType.QUERY:
305 | gql_field = self.schema.query_type
306 | else:
307 | raise Exception(f"Unimplemented operation type: {node.operation=}")
308 | child_s = self.from_node(
309 | gql_field=gql_field.fields[sel.name.value],
310 | node=sel,
311 | path=(node.operation.value,),
312 | )
313 | if type(child_s) is list:
314 | children.extend(child_s)
315 | else:
316 | children.append(child_s)
317 |
318 | op = OperationNode(
319 | id=uuid.uuid4(),
320 | name=node.name.value if node.name else None,
321 | type=OperationType(node.operation.value),
322 | children=children,
323 | original_node=node,
324 | )
325 |
326 | return op
327 |
328 | def translate(self) -> list[OperationNode]:
329 | for definition in self.document.definitions:
330 | if isinstance(definition, graphql.FragmentDefinitionNode):
331 | self.fragment_definitions[definition.name.value] = definition
332 | elif isinstance(definition, graphql.OperationDefinitionNode):
333 | if definition.operation == graphql.OperationType.QUERY:
334 | self.query_definitions.append(definition)
335 | elif definition.operation == graphql.OperationType.MUTATION:
336 | self.mutation_definitions.append(definition)
337 | else:
338 | self.subscription_definitions.append(definition)
339 | else:
340 | raise Exception(
341 | f"Unknown type of definition: {definition=}, {type(definition)=}"
342 | )
343 |
344 | # start with the operations
345 | op_nodes: list[OperationNode] = []
346 | for operation in [*self.query_definitions, *self.mutation_definitions]:
347 | op_nodes.append(self.from_operation_node(operation))
348 | return op_nodes
349 |
--------------------------------------------------------------------------------
/fastgql/gql_models.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | from pydantic import BaseModel, ValidationInfo, model_validator
3 | from fastgql.gql_ast.models import Node
4 |
5 |
6 | class GQLConfigDict(T.TypedDict, total=False):
7 | """A TypedDict for configuring FastGQL behaviour."""
8 |
9 | type_name: str
10 | input_type_name: str
11 | description: str
12 |
13 |
14 | class GQL(BaseModel):
15 | gql_config: T.ClassVar[GQLConfigDict] = {}
16 |
17 | @classmethod
18 | def gql_type_name(cls) -> str:
19 | return cls.gql_config.get("type_name", cls.__name__)
20 |
21 | @classmethod
22 | def gql_description(cls) -> str | None:
23 | return cls.gql_config.get("description")
24 |
25 |
26 | class GQLInterface(GQL):
27 | pass
28 |
29 |
30 | class GQLInput(GQL):
31 | @classmethod
32 | def gql_input_type_name(cls) -> str:
33 | return cls.gql_config.get("input_type_name", cls.__name__)
34 |
35 | @model_validator(mode="before")
36 | @classmethod
37 | def _to_snake_case(cls, data: T.Any, info: ValidationInfo) -> T.Any:
38 | if context := info.context:
39 | if display_to_python_map := context.get("_display_to_python_map"):
40 | return {display_to_python_map[k]: v for k, v in data.items()}
41 | return data
42 |
43 |
44 | class GQLError(Exception):
45 | def __init__(
46 | self,
47 | message: str,
48 | *,
49 | node: Node | list[Node] | None = None,
50 | path: tuple[str, ...] | None = None,
51 | original_error: Exception | None = None,
52 | extensions: dict[str, T.Any] | None = None,
53 | capture_exception: bool = True,
54 | ):
55 | super().__init__(message)
56 | self.message = message
57 | self.node = node
58 | self.path = path
59 | self.original_error = original_error
60 | self.extensions = extensions
61 | self.capture_exception = capture_exception
62 |
63 |
64 | __all__ = ["GQL", "GQLInput", "GQLConfigDict", "GQLError", "GQLInterface"]
65 |
--------------------------------------------------------------------------------
/fastgql/info.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import dataclasses
3 | from fastgql.gql_ast import models as M
4 | from fastgql.context import BaseContext
5 |
6 | ContextType = T.TypeVar("ContextType", bound=BaseContext)
7 |
8 |
9 | @dataclasses.dataclass
10 | class Info(T.Generic[ContextType]):
11 | """needed to make this a raw dataclass because context needs to be kept as a reference... pydantic copies dicts"""
12 |
13 | node: M.FieldNode | M.InlineFragmentNode
14 | parent_node: M.FieldNode | M.InlineFragmentNode | M.OperationNode
15 | path: tuple[str, ...]
16 |
17 | context: ContextType
18 |
19 |
20 | __all__ = ["Info", "ContextType"]
21 |
--------------------------------------------------------------------------------
/fastgql/logs.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import logging
3 | from enum import Enum
4 |
5 | FORMAT_STR = "%(asctime)s | %(process)d | %(name)s | %(levelname)s: %(message)s"
6 |
7 |
8 | class Color(str, Enum):
9 | BLACK = 0
10 | RED = 1
11 | GREEN = 2
12 | YELLOW = 3
13 | BLUE = 4
14 | PURPLE = 5
15 | TEAL = 6
16 | GREY = 7
17 |
18 |
19 | RESET_STR = "\x1b[0m"
20 |
21 |
22 | def format_str_from_color(color: Color, bold: bool = False) -> str:
23 | bold_str = "20" if not bold else "1"
24 | color_str = f"\x1b[3{color.value};{bold_str}m"
25 | format_str = f"{color_str} {FORMAT_STR} {RESET_STR}"
26 | return format_str
27 |
28 |
29 | COLORS = dict[int, Color]
30 | FORMATS = dict[int, str]
31 |
32 | DEFAULT_FORMATS: FORMATS = {
33 | logging.DEBUG: format_str_from_color(Color.TEAL),
34 | logging.INFO: format_str_from_color(Color.PURPLE),
35 | logging.WARNING: format_str_from_color(Color.YELLOW),
36 | logging.ERROR: format_str_from_color(Color.RED, bold=False),
37 | logging.CRITICAL: format_str_from_color(Color.RED, bold=True),
38 | }
39 |
40 |
41 | def formats_from_colors(color_map: COLORS) -> FORMATS:
42 | return {k: format_str_from_color(v) for k, v in color_map.items()}
43 |
44 |
45 | def formats_from_color(color: Color) -> FORMATS:
46 | format_str = format_str_from_color(color)
47 | return {k: format_str for k in DEFAULT_FORMATS.keys()}
48 |
49 |
50 | class CustomFormatter(logging.Formatter):
51 | def __init__(
52 | self,
53 | formats: FORMATS | None = None,
54 | no_colors: bool = False,
55 | *args: T.Any,
56 | **kwargs: T.Any,
57 | ):
58 | super().__init__(*args, **kwargs)
59 | self.formats = formats or DEFAULT_FORMATS
60 | self.no_colors = no_colors
61 |
62 | def format(self, record: logging.LogRecord) -> str:
63 | if self.no_colors:
64 | format_str = FORMAT_STR
65 | else:
66 | format_str = self.formats[record.levelno]
67 | formatter = logging.Formatter(format_str)
68 | return formatter.format(record)
69 |
70 |
71 | def create_logger(
72 | name: str,
73 | level: T.Optional[T.Any] = logging.DEBUG,
74 | colors_map: T.Optional[COLORS] = None,
75 | no_colors: T.Optional[bool] = False,
76 | one_color: T.Optional[Color] = None,
77 | ) -> logging.Logger:
78 | logger = logging.getLogger(name)
79 | logger.setLevel(level=level)
80 | handler = logging.StreamHandler()
81 | if one_color:
82 | formats = formats_from_color(one_color)
83 | elif colors_map:
84 | formats = formats_from_colors(colors_map)
85 | else:
86 | formats = None
87 | handler.setFormatter(CustomFormatter(formats=formats, no_colors=no_colors))
88 | logger.addHandler(handler)
89 | return logger
90 |
91 |
92 | __all__ = ["FORMATS", "Color", "create_logger"]
93 |
--------------------------------------------------------------------------------
/fastgql/query_builders/edgedb/config.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import inspect
3 | from dataclasses import dataclass
4 |
5 | from fastgql.info import Info
6 | from fastgql.gql_ast import models as M
7 | from fastgql.execute.utils import parse_value
8 | from fastgql.utils import node_from_path
9 | from .query_builder import QueryBuilder, ChildEdge
10 |
11 |
12 | def combine_qbs(
13 | *qbs: QueryBuilder,
14 | nodes_to_include: list[
15 | M.FieldNode
16 | ], # TODO so far, not needed but may for better inheritence
17 | ) -> QueryBuilder:
18 | """takes in a dict of db typename and qb"""
19 | new_qb = QueryBuilder()
20 | # add dangling to each qb
21 | for node in nodes_to_include:
22 | for qb in qbs:
23 | if node.name == "__typename":
24 | qb.fields.add(f"{node.alias or node.name} := .__type__.name")
25 | # TODO other things here
26 | for qb in qbs:
27 | if not qb.typename:
28 | raise Exception("QB must have a typename if it is to be combined.")
29 | new_qb.children[qb.typename] = ChildEdge(
30 | db_expression=f"[is {qb.typename}]", qb=qb
31 | )
32 | return new_qb
33 |
34 |
35 | @dataclass
36 | class Property:
37 | db_name: str | None
38 | update_qb: T.Callable[[QueryBuilder], T.Awaitable[None] | None] = None
39 |
40 |
41 | @dataclass
42 | class Link:
43 | db_name: str | None
44 | return_cls_qb_config: (
45 | T.Union["QueryBuilderConfig", dict[str, "QueryBuilderConfig"]] | None
46 | ) = None
47 | path_to_return_cls: tuple[str, ...] | None = None
48 | update_qbs: T.Callable[[..., T.Any], None | T.Awaitable] = None
49 |
50 |
51 | @dataclass
52 | class QueryBuilderConfig:
53 | properties: dict[str, Property]
54 | links: dict[str, Link]
55 |
56 | def is_empty(self) -> bool:
57 | return not self.properties and not self.links
58 |
59 | async def from_info(
60 | self, info: Info, node: M.FieldNode | M.InlineFragmentNode
61 | ) -> QueryBuilder | None:
62 | if not node:
63 | return None
64 | qb = QueryBuilder()
65 | children_q = [*node.children]
66 | while len(children_q) > 0:
67 | child = children_q.pop(0)
68 | if isinstance(child, M.InlineFragmentNode):
69 | children_q.extend(child.children)
70 | else:
71 | if child.name in self.properties:
72 | property_config = self.properties[child.name]
73 | if db_name := property_config.db_name:
74 | if child.name != db_name:
75 | qb.fields.add(f"{child.name} := .{db_name}")
76 | else:
77 | qb.fields.add(db_name)
78 | if update_qb := property_config.update_qb:
79 | kwargs = {
80 | "qb": qb,
81 | "node": node,
82 | "child_node": child,
83 | "info": info,
84 | **{
85 | a.name: parse_value(
86 | variables=info.context.variables, v=a.value
87 | )
88 | for a in child.arguments
89 | },
90 | }
91 | kwargs = {
92 | k: v
93 | for k, v in kwargs.items()
94 | if k in inspect.signature(update_qb).parameters
95 | }
96 | _ = update_qb(**kwargs)
97 | if inspect.isawaitable(_):
98 | await _
99 | if child.name in self.links:
100 | method_config = self.links[child.name]
101 | original_child = child
102 | if method_config.path_to_return_cls:
103 | child = node_from_path(
104 | node=child, path=[*method_config.path_to_return_cls]
105 | )
106 | if config := method_config.return_cls_qb_config:
107 | if isinstance(config, dict):
108 | dangling_children: list[M.FieldNode] = []
109 | frag_qbs: list[QueryBuilder] = []
110 | for child_child in child.children:
111 | if isinstance(child_child, M.InlineFragmentNode):
112 | child_child_qb = await config[
113 | child_child.type_condition
114 | ].from_info(info=info, node=child_child)
115 | child_child_qb.typename = child_child.type_condition
116 | frag_qbs.append(child_child_qb)
117 | elif isinstance(child_child, M.FieldNode):
118 | dangling_children.append(child_child)
119 | else:
120 | raise Exception(
121 | f"Invalid node for config as dict: {child=}"
122 | )
123 | # now combine the dangling with the frags
124 | child_qb = combine_qbs(
125 | *frag_qbs, nodes_to_include=dangling_children
126 | )
127 | child_qb.fields.add("typename := .__type__.name")
128 | else:
129 | child_qb = await config.from_info(info=info, node=child)
130 | if db_name := method_config.db_name:
131 | name_to_use = child.alias or child.name
132 | db_expression = (
133 | None if name_to_use == db_name else f".{db_name}"
134 | )
135 | qb.children[name_to_use] = ChildEdge(
136 | db_expression=db_expression, qb=child_qb
137 | )
138 | if update_qbs := method_config.update_qbs:
139 | kwargs = {
140 | "qb": qb,
141 | "child_qb": child_qb,
142 | "node": node,
143 | "child_node": child,
144 | "info": info,
145 | **{
146 | a.name: parse_value(
147 | variables=info.context.variables, v=a.value
148 | )
149 | for a in original_child.arguments
150 | },
151 | }
152 | kwargs = {
153 | k: v
154 | for k, v in kwargs.items()
155 | if k in inspect.signature(update_qbs).parameters
156 | }
157 | _ = update_qbs(**kwargs)
158 | if inspect.isawaitable(_):
159 | await _
160 | return qb
161 |
--------------------------------------------------------------------------------
/fastgql/query_builders/edgedb/logic.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | import types
3 | import time
4 | import inspect
5 | import graphql
6 | from pydantic import BaseModel
7 | from devtools import debug
8 |
9 | from fastgql.execute.utils import get_root_type
10 | from fastgql.info import Info
11 | from .config import QueryBuilderConfig, Link, Property
12 | from .query_builder import QueryBuilder
13 |
14 |
15 | def get_qb_config_from_gql_field(
16 | gql_field: graphql.GraphQLField, path_to_return_cls: tuple[str, ...] = None
17 | ) -> QueryBuilderConfig:
18 | root = get_root_type(gql_field)
19 | if path_to_return_cls:
20 | path = [*path_to_return_cls]
21 | while path:
22 | p = path.pop(0)
23 | root = get_root_type(root.fields[p])
24 | if isinstance(root, list):
25 | child_qb_config = {cm.name: cm._pydantic_model.qb_config for cm in root}
26 | else:
27 | child_qb_config = root._pydantic_model.qb_config
28 | return child_qb_config
29 |
30 |
31 | def build_from_schema(schema: graphql.GraphQLSchema) -> None:
32 | start = time.time()
33 | print("starting to build gql")
34 | gql_models = [
35 | m
36 | for m in schema.type_map.values()
37 | if isinstance(m, graphql.GraphQLObjectType) and hasattr(m, "_pydantic_model")
38 | ]
39 | for gql_model in gql_models:
40 | gql_model._pydantic_model.qb_config = QueryBuilderConfig(
41 | properties={}, links={}
42 | )
43 | for gql_model in gql_models:
44 | pydantic_model = gql_model._pydantic_model
45 | config: QueryBuilderConfig = pydantic_model.qb_config
46 | # first do fields
47 | for field_name, field_info in pydantic_model.model_fields.items():
48 | meta_list = field_info.metadata
49 | for meta in meta_list:
50 | if isinstance(meta, Property):
51 | config.properties[field_name] = meta
52 | elif isinstance(meta, Link):
53 | # but then need to populated nested
54 | if not meta.return_cls_qb_config:
55 | meta.return_cls_qb_config = get_qb_config_from_gql_field(
56 | gql_model.fields[field_name]
57 | )
58 | config.links[field_name] = meta
59 | # now do functions
60 | for name, member in inspect.getmembers(pydantic_model):
61 | if inspect.isfunction(member):
62 | return_annotation = inspect.signature(member).return_annotation
63 | if isinstance(return_annotation, (T.Annotated, T._AnnotatedAlias)):
64 | for meta in return_annotation.__metadata__:
65 | if isinstance(meta, Link):
66 | if not meta.return_cls_qb_config:
67 | fields_by_og_name = {
68 | f._og_name: f for f in gql_model.fields.values()
69 | }
70 | meta.return_cls_qb_config = (
71 | get_qb_config_from_gql_field(
72 | fields_by_og_name[name],
73 | path_to_return_cls=meta.path_to_return_cls,
74 | )
75 | )
76 | config.links[name] = meta
77 | elif isinstance(meta, Property):
78 | config.properties[name] = meta
79 |
80 | # for gql_model in gql_models:
81 | # if gql_model.name == "EventUserPublic":
82 | # print(gql_model.name)
83 | # debug(gql_model._pydantic_model.qb_config)
84 | print(
85 | f"[EDGEDB QB CONFIG BUILDING] building the qb configs took: {(time.time() - start) * 1000} ms"
86 | )
87 |
88 |
89 | def root_type_s_from_annotation(
90 | a: T.Any,
91 | ) -> T.Type[BaseModel] | list[T.Type[BaseModel]]:
92 | if inspect.isclass(a):
93 | return a
94 | else:
95 | origin = T.get_origin(a)
96 | args = T.get_args(a)
97 | if origin is list or origin is types.UnionType or origin is T.Union:
98 | non_none_args = []
99 | for arg in args:
100 | if not (
101 | arg is None
102 | or (inspect.isclass(arg) and issubclass(arg, type(None)))
103 | ):
104 | non_none_args.append(arg)
105 | if len(non_none_args) == 1: # that means non was taken out?
106 | return root_type_s_from_annotation(non_none_args[0])
107 | else:
108 | return [root_type_s_from_annotation(arg) for arg in args]
109 |
110 |
111 | async def get_qb(info: Info) -> QueryBuilder:
112 | annotation = info.node.annotation
113 | root_type_s = root_type_s_from_annotation(annotation)
114 | if type(root_type_s) is list:
115 | existing_config = None
116 | for root_type in root_type_s:
117 | qb_config: QueryBuilderConfig = getattr(root_type, "qb_config", None)
118 | if qb_config and not qb_config.is_empty():
119 | if existing_config:
120 | debug(qb_config, existing_config)
121 | raise Exception("You cannot have conflicting qb_configs.")
122 | existing_config = qb_config
123 | if not existing_config:
124 | raise Exception("There is no return model with a qb_config.")
125 | return await existing_config.from_info(info=info, node=info.node)
126 | else:
127 | return await root_type_s.qb_config.from_info(info=info, node=info.node)
128 |
--------------------------------------------------------------------------------
/fastgql/query_builders/edgedb/models.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | from pydantic import BaseModel
3 | from fastgql.query_builders.edgedb.config import QueryBuilderConfig
4 |
5 |
6 | class QB(BaseModel):
7 | qb_config: T.ClassVar[QueryBuilderConfig]
8 |
--------------------------------------------------------------------------------
/fastgql/query_builders/edgedb/query_builder.py:
--------------------------------------------------------------------------------
1 | import typing as T
2 | from enum import Enum
3 | import random
4 | import string
5 | import re
6 | from pydantic import BaseModel, Field
7 |
8 |
9 | class FilterConnector(str, Enum):
10 | AND = "AND"
11 | OR = "OR"
12 |
13 |
14 | class QueryBuilderError(Exception):
15 | pass
16 |
17 |
18 | class ChildEdge(BaseModel):
19 | # for example, .artists
20 | db_expression: str | None
21 | qb: "QueryBuilder"
22 |
23 |
24 | class QueryBuilder(BaseModel):
25 | typename: str | None = None
26 | fields: set[str] = Field(default_factory=set)
27 | variables: dict[str, T.Any] = Field(default_factory=dict)
28 | children: dict[str, ChildEdge] = Field(default_factory=dict)
29 | filter: str | None = None
30 | order_by: str | None = None
31 | offset: str | None = None
32 | limit: str | None = None
33 |
34 | full_query_str: str | None = None
35 | pattern_to_replace: str | None = None
36 |
37 | @staticmethod
38 | def build_child_var_name(
39 | child_name: str, var_name: str, variables_to_use: dict[str, T.Any]
40 | ) -> str:
41 | child_name = re.sub(r"[^a-zA-Z0-9]+", "_", child_name)
42 | count = 0
43 | while var_name in variables_to_use:
44 | count_str = "" if not count else f"_{count}"
45 | var_name = f"_{child_name}{count_str}_{var_name}"
46 | return var_name
47 |
48 | def build(self) -> tuple[str, dict[str, T.Any]]:
49 | variables_to_use = self.variables.copy()
50 | child_strs: set[str] = set()
51 | for child_name, child_edge in self.children.items():
52 | child = child_edge.qb
53 | child_str, child_variables = child.build()
54 | for var_name, var_val in child_variables.items():
55 | if var_name in variables_to_use:
56 | if var_val is variables_to_use[var_name]:
57 | continue
58 | # must change the name for the child
59 | new_var_name = self.build_child_var_name(
60 | child_name=child_name,
61 | var_name=var_name,
62 | variables_to_use=variables_to_use,
63 | )
64 | variables_to_use[new_var_name] = var_val
65 | # now, must regex the str to find this and replace it
66 | regex = re.compile(r"\${}(?!\w)".format(var_name))
67 | child_str = regex.sub(f"${new_var_name}", child_str)
68 | else:
69 | variables_to_use[var_name] = var_val
70 | if not child_edge.db_expression:
71 | child_str = f"{child_name}: {child_str}"
72 | else:
73 | child_str = (
74 | f"{child_name} := (select {child_edge.db_expression} {child_str})"
75 | )
76 | child_strs.add(child_str)
77 |
78 | fields_str = ", ".join([*sorted(self.fields), *sorted(child_strs)])
79 | s_parts = ["" if not fields_str else f"{{ {fields_str} }}"]
80 | if self.filter:
81 | s_parts.append(f"FILTER {self.filter}")
82 | if self.order_by:
83 | s_parts.append(f"ORDER BY {self.order_by}")
84 | if self.offset is not None:
85 | s_parts.append(self.offset)
86 | if self.limit is not None:
87 | s_parts.append(self.limit)
88 | final_s = " ".join(s_parts)
89 | if self.full_query_str:
90 | final_s = self.full_query_str.replace(self.pattern_to_replace, final_s)
91 | return final_s, variables_to_use
92 |
93 | def add_variable(
94 | self, key: str, val: T.Any, replace: bool = False
95 | ) -> "QueryBuilder":
96 | if key in self.variables:
97 | if not replace and self.variables[key] != val:
98 | raise QueryBuilderError(
99 | f"Key {key} already exists in variables so you cannot add it. "
100 | f"If you'd like to replace it, pass replace."
101 | )
102 | self.variables[key] = val
103 | return self
104 |
105 | def add_variables(
106 | self, variables: dict[str, T.Any], replace: bool = False
107 | ) -> "QueryBuilder":
108 | """if there is an error, it does not save to the builder"""
109 | if not variables:
110 | return self
111 | if not replace:
112 | for k in variables.keys():
113 | if k in self.variables:
114 | raise QueryBuilderError(
115 | f"Key {k} already exists in variables so you cannot add it. "
116 | f"If you'd like to replace it, pass replace."
117 | )
118 | self.variables.update(variables)
119 | return self
120 |
121 | # ADD HELPER FUNCTIONS FOR LIMIT AND OFFSET -> like add_offset...
122 | def set_offset(self, offset: int | None, replace: bool = False) -> "QueryBuilder":
123 | if offset is None:
124 | return self
125 | if self.offset is not None:
126 | if not replace:
127 | raise QueryBuilderError(
128 | "An offset already exists. If you would like to replace it, pass in replace."
129 | )
130 | self.offset = "OFFSET Loading...
78 |
83 |
88 |
158 |
159 |
160 |
--------------------------------------------------------------------------------
/fastgql/utils.py:
--------------------------------------------------------------------------------
1 | import pathlib
2 | import json
3 | from fastgql.gql_ast import models as M
4 |
5 |
6 | def node_from_path(
7 | node: M.FieldNode, path: list[str], use_field_to_use: bool = False
8 | ) -> M.FieldNode | None:
9 | if not path:
10 | return node
11 | current_val = path.pop(0)
12 | children_q = [*node.children]
13 | while len(children_q) > 0:
14 | child = children_q.pop(0)
15 | if isinstance(child, M.FieldNode):
16 | name = (
17 | child.name
18 | if not use_field_to_use
19 | else child.alias or child.display_name
20 | )
21 | if name == current_val:
22 | return node_from_path(node=child, path=path)
23 | if isinstance(child, M.InlineFragmentNode):
24 | children_q.extend(child.children)
25 |
26 | return None
27 |
28 |
29 | def get_graphiql_html(
30 | subscription_enabled: bool = True, replace_variables: bool = True
31 | ) -> str:
32 | here = pathlib.Path(__file__).parent
33 | path = here / "static/graphiql.html"
34 |
35 | template = path.read_text(encoding="utf-8")
36 |
37 | if replace_variables:
38 | template = template.replace(
39 | "{{ SUBSCRIPTION_ENABLED }}", json.dumps(subscription_enabled)
40 | )
41 |
42 | return template
43 |
--------------------------------------------------------------------------------
/mypy.ini:
--------------------------------------------------------------------------------
1 | [mypy]
2 | plugins = pydantic.mypy
3 |
4 | follow_imports = silent
5 | warn_redundant_casts = True
6 | warn_unused_ignores = True
7 | disallow_any_generics = True
8 | check_untyped_defs = True
9 | no_implicit_reexport = True
10 |
11 | # for strict mypy: (this is the tricky one :-))
12 | disallow_untyped_defs = True
13 |
14 | [pydantic-mypy]
15 | init_forbid_extra = True
16 | init_typed = True
17 | warn_required_dynamic_aliases = True
18 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [tool.poetry]
2 | name = "fastgql"
3 | packages = [{ include = "fastgql" }]
4 | version = "0.24.4"
5 | description = "The easiest, fastest python GraphQL framework."
6 | authors = ["Jeremy Berman