Strawberry

https://github.com/strawberry-graphql/strawberry
Admin
Strawberry GraphQL is a Python library that allows you to build GraphQL APIs using Python...
Tokens:130,843
Snippets:1,512
Trust Score:9.3
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup development environment

Source: https://github.com/strawberry-graphql/strawberry/blob/main/AGENTS.md

Use these commands to synchronize dependencies and install pre-commit hooks for local development.

```shell
$ uv sync
$ uv run pre-commit install
```

--------------------------------

### Start the Strawberry Development Server

Source: https://github.com/strawberry-graphql/strawberry/wiki/Getting-started

Command to start the development server for a given application file.

```sh
strawberry server app
```

--------------------------------

### Install Uvicorn

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/dataloaders.md

Command to install the uvicorn ASGI server.

```shell
pip install uvicorn
```

--------------------------------

### Install Pre-commit Hook

Source: https://github.com/strawberry-graphql/strawberry/blob/main/README.md

Install the pre-commit configuration for the project.

```shell
pre-commit install
```

--------------------------------

### Install Strawberry and CLI

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/index.md

Activate the virtual environment and install the strawberry-graphql package with CLI support.

```shell
source virtualenv/bin/activate
pip install 'strawberry-graphql[cli]'
```

--------------------------------

### Install Strawberry CLI

Source: https://github.com/strawberry-graphql/strawberry/blob/main/README.md

Install the library with CLI support using pip.

```shell
pip install "strawberry-graphql[cli]"
```

--------------------------------

### Start the reviews service

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation.md

Run the reviews service on port 3000.

```shell
cd reviews
strawberry dev --port 3000 app
```

--------------------------------

### Install ddtrace

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/datadog.md

Install the required ddtrace package before using the Datadog extension.

```shell
pip install ddtrace
```

--------------------------------

### Install FastAPI dependencies

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/fastapi.md

Install the necessary dependencies for using Strawberry with FastAPI.

```shell
pip install 'strawberry-graphql[fastapi]'
```

--------------------------------

### Initialize schema and start server

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/index.md

Create the schema instance and run the development server.

```python
schema = strawberry.Schema(query=Query)
```

```shell
strawberry dev schema
```

--------------------------------

### Start the local server

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/chalice.md

Run the local development server to test the GraphQL API.

```shell
chalice local
```

--------------------------------

### Install ASGI dependencies

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/asgi.md

Install the required dependencies for Strawberry's ASGI support.

```shell
pip install 'strawberry-graphql[asgi]'
```

--------------------------------

### Install Strawberry GraphQL

Source: https://github.com/strawberry-graphql/strawberry/wiki/Getting-started

Command to install the strawberry-graphql package via pip.

```bash
pip install strawberry-graphql
```

--------------------------------

### Setup Development Environment

Source: https://github.com/strawberry-graphql/strawberry/blob/main/README.md

Commands to clone the repository and set up the development environment using uv.

```shell
git clone https://github.com/strawberry-graphql/strawberry
cd strawberry
uv sync
uv run pytest
```

--------------------------------

### Run Development Server

Source: https://github.com/strawberry-graphql/strawberry/blob/main/README.md

Start the development server to test the API via GraphiQL.

```shell
strawberry dev app
```

--------------------------------

### Install OpenTelemetry extension

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/opentelemetry.md

Install the required dependencies for OpenTelemetry support in Strawberry.

```shell
pip install 'strawberry-graphql[opentelemetry]'
```

--------------------------------

### GraphQL SDL Customer Interface Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/interfaces.md

An example of a Customer interface and its implementing types Company and Individual in GraphQL SDL.

```graphql
interface Customer {
  name: String!
}

type Company implements Customer {
  employees: [Individual!]!
  name: String!
}

type Individual implements Customer {
  employed_by: Company
  name: String!
}

type Query {
  customers: [Customer!]!
}
```

--------------------------------

### Run Strawberry development server

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/offset-based.md

Start the development server using the strawberry CLI.

```shell
strawberry dev example:schema
```

--------------------------------

### Start Docker Compose

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/operations/tracing.md

Command to start the OpenTelemetry collector services using docker-compose.

```shell
docker-compose up --force-recreate --build
```

--------------------------------

### Install Apollo Federation dependencies

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/apollo-federation-tracing.md

Install the required package to use the Apollo Federation tracing extension.

```shell
pip install 'strawberry-graphql[apollo-federation]'
```

--------------------------------

### Start the books service

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation.md

Run the books service on port 3500.

```shell
cd books
strawberry dev --port 3500 app
```

--------------------------------

### Start FastAPI Server

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/query-batching.md

Command to run the FastAPI application using uvicorn.

```bash
uvicorn app:app --reload
```

--------------------------------

### Start the Apollo Router

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation.md

Launch the router using the generated supergraph schema.

```shell
./router --supergraph supergraph-schema.graphql
```

--------------------------------

### Install Strawberry Channels dependencies

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/channels.md

Install the required dependencies for Strawberry Channels support using pip.

```shell
pip install 'strawberry-graphql[channels]'
```

--------------------------------

### Install dependencies and run checks

Source: https://github.com/strawberry-graphql/strawberry/blob/main/CONTRIBUTING.md

Commands to synchronize dependencies and execute the test suite and type checker.

```shell
$ uv sync
$ uv run pytest
$ uv run mypy
```

--------------------------------

### Serve GraphQL schema with AIOHTTP

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/aiohttp.md

Example of setting up a basic AIOHTTP application with a GraphQLView, including a query and a subscription.

```python
import strawberry
import asyncio
from aiohttp import web
from strawberry.aiohttp.views import GraphQLView
from typing import AsyncGenerator


@strawberry.type
class Query:
    @strawberry.field
    def hello(self, name: str = "World") -> str:
        return f"Hello, {name}!"


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def count(self, to: int = 100) -> AsyncGenerator[int, None]:
        for i in range(to):
            yield i
            await asyncio.sleep(1)


schema = strawberry.Schema(query=Query, subscription=Subscription)

app = web.Application()
app.router.add_route("*", "/graphql", GraphQLView(schema=schema))

web.run_app(app)
```

--------------------------------

### Serve GraphQL schema with Quart

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/quart.md

This example demonstrates how to initialize a Quart application and register the GraphQLView to handle both standard requests and WebSocket connections at the /graphql endpoint.

```python
from quart import Quart
from strawberry.quart.views import GraphQLView
from api.schema import schema

view = GraphQLView.as_view("graphql_view", schema=schema)

app = Quart(__name__)
app.add_url_rule("/graphql", view_func=view)
app.add_url_rule("/graphql", view_func=view, methods=["GET"], websocket=True)

if __name__ == "__main__":
    app.run()
```

--------------------------------

### Integrate Strawberry with Litestar

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/litestar.md

Example showing how to define a schema and mount it using make_graphql_controller in a Litestar application.

```python
import strawberry
from litestar import Litestar
from strawberry.litestar import make_graphql_controller


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello World"


schema = strawberry.Schema(Query)

GraphQLController = make_graphql_controller(
    schema,
    path="/graphql",
)

app = Litestar(route_handlers=[GraphQLController])
```

--------------------------------

### Using tracer_provider

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/opentelemetry.md

Example of providing a custom tracer provider to the OpenTelemetry extension.

```python
import strawberry
from opentelemetry.trace import TracerProvider
from strawberry.extensions.tracing import OpenTelemetryExtension


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


class MyTracerProvider(TracerProvider):
    def get_tracer(self, name, version=None, schema_url=None):
        return super().get_tracer(name, version, schema_url)


schema = strawberry.Schema(
    Query,
    extensions=[
        OpenTelemetryExtension(
            tracer_provider=MyTracerProvider(),
        ),
    ],
)
```

--------------------------------

### Using an_argument with ExtensionName

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/_template.md

Example showing how to initialize ExtensionName with the an_argument parameter.

```python
import strawberry
from strawberry.extensions import ValidationCache

schema = strawberry.Schema(
    Query,
    extensions=[
        ExtensionName(an_argument="something"),
    ],
)
```

--------------------------------

### Example GraphQL query

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/connections.md

A sample GraphQL query to fetch paginated users using connections.

```graphql
query getUsers {
  getUsers(first: 2) {
    edges {
      node {
        id
        name
        occupation
        age
      }
      cursor
    }
    pageInfo {
      endCursor
      hasNextPage
    }
  }
}
```

--------------------------------

### Configuring ParserCache maxsize

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/parser-cache.md

Example of initializing ParserCache with a custom maxsize of 100 entries.

```python
import strawberry
from strawberry.extensions import ParserCache


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        ParserCache(maxsize=100),
    ],
)
```

--------------------------------

### Using maxsize with ValidationCache

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/validation-cache.md

Example demonstrating how to configure the cache size limit using the maxsize parameter.

```python
import strawberry
from strawberry.extensions import ValidationCache


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        ValidationCache(maxsize=100),
    ],
)
```

--------------------------------

### Example RELEASE.md file

Source: https://github.com/strawberry-graphql/strawberry/blob/main/AGENTS.md

Template for creating a release note file, including frontmatter for release type and social media messages.

```markdown
---
release type: patch
social_messages:
  x: >-
    {project_name} {version} is out! This release fixes schema printing for
    nullable input defaults. 🍓 https://strawberry.rocks/release/{version}
  linkedin: >-
    {project_name} {version} is out. This release fixes schema printing for
    nullable input defaults, so generated SDL keeps explicit null values.
---

This release fixes schema printing for nullable input defaults.

Strawberry now preserves explicit `None` values in printed nested input
defaults.
```

--------------------------------

### Run Codegen with Multiple Plugins

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/codegen/query-codegen.md

Example of passing multiple plugins to the codegen tool using the -p flag.

```shell
strawberry codegen --schema schema --output-dir ./output -p python -p typescript query.graphql
```

--------------------------------

### Migrate from UNSET - Before

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/maybe.md

Example of using strawberry.UNSET to differentiate between absent and null values.

```python
import strawberry


@strawberry.input
class UpdateUserInput:
    name: str | None = strawberry.UNSET
    phone: str | None = strawberry.UNSET


@strawberry.type
class Mutation:
    @strawberry.mutation
    def update_user(self, input: UpdateUserInput) -> User:
        if input.name is not strawberry.UNSET:
            user.name = input.name  # Could be a string or None
        if input.phone is not strawberry.UNSET:
            user.phone = input.phone
        return user
```

--------------------------------

### Install OpenTelemetry Dependencies

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/operations/tracing.md

Required pip packages for OpenTelemetry API, SDK, and OTLP exporter.

```shell
pip install opentelemetry-api
pip install opentelemetry-sdk
pip install opentelemetry-exporter-otlp
```

--------------------------------

### Migrate from UNSET - After

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/maybe.md

Example of using strawberry.Maybe to handle field states with explicit type safety.

```python
import strawberry


@strawberry.input
class UpdateUserInput:
    name: strawberry.Maybe[str | None]
    phone: strawberry.Maybe[str | None]


@strawberry.type
class Mutation:
    @strawberry.mutation
    def update_user(self, input: UpdateUserInput) -> User:
        if input.name is not None:
            user.name = input.name.value  # Access via .value
        if input.phone is not None:
            user.phone = input.phone.value
        return user
```

--------------------------------

### Example of missing return annotation

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/missing-return-annotation.md

This code triggers the missing return annotation error because the 'example' resolver lacks a return type hint.

```python
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def example(self):
        return "this is an example"


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Usage example of PyInstrument extension

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/pyinstrument.md

Demonstrates how to integrate the PyInstrument extension into a Strawberry schema by adding it to the extensions list.

```python
import strawberry
from strawberry.extensions import pyinstrument


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        pyinstrument.PyInstrument(report_path="pyinstrument.html"),
    ],
)
```

--------------------------------

### Example Federated GraphQL Query

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation-v1.md

A sample query demonstrating how a gateway joins data from the books service and the reviews service.

```graphql
{
  # query defined in the books service
  books {
    title
    # field defined in the reviews service
    reviews {
      body
    }
  }
}
```

--------------------------------

### Integrate FastAPI with Strawberry

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/fastapi.md

Basic setup for a FastAPI application using the GraphQLRouter to serve a Strawberry schema.

```python
import strawberry

from fastapi import FastAPI
from strawberry.fastapi import GraphQLRouter


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello World"


schema = strawberry.Schema(Query)

graphql_app = GraphQLRouter(schema)

app = FastAPI()
app.include_router(graphql_app, prefix="/graphql")
```

--------------------------------

### Execute an addBook mutation

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/general/mutations.md

Example GraphQL document to execute the addBook mutation with title and author arguments.

```graphql
mutation {
  addBook(title: "The Little Prince", author: "Antoine de Saint-Exupéry") {
    title
  }
}
```

--------------------------------

### Run ASGI App with Uvicorn

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/dataloaders.md

Command to start the ASGI application using uvicorn, assuming the file is named schema.py.

```shell
uvicorn schema:app
```

--------------------------------

### Defining a Query class with a user field

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/accessing-parent-data.md

Example of a Query class that returns a User instance.

```python
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def user(self) -> User:
        return User(first_name="Albert", last_name="Heijn")
```

--------------------------------

### Define a basic Strawberry Schema

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/schema.md

Example of defining a schema with a mandatory Query type.

```python
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello World"


schema = strawberry.Schema(Query)
```

--------------------------------

### Configure Apollo Gateway

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation-v1.md

Initializes an ApolloGateway with a list of federated services and starts an ApolloServer to serve the combined schema.

```js
const { ApolloServer } = require("apollo-server");
const { ApolloGateway } = require("@apollo/gateway");

const gateway = new ApolloGateway({
  serviceList: [
    { name: "books", url: "http://localhost:8000" },
    { name: "reviews", url: "http://localhost:8080" },
  ],
});

const server = new ApolloServer({ gateway });

server.listen().then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});
```

--------------------------------

### Usage example of MaxTokensLimiter

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/max-tokens-limiter.md

Demonstrates how to integrate the MaxTokensLimiter extension into a Strawberry GraphQL schema by adding it to the extensions list.

```python
import strawberry
from strawberry.extensions import MaxTokensLimiter


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        MaxTokensLimiter(max_token_count=1000),
    ],
)
```

--------------------------------

### Run development server with strawberry dev

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/server.md

Starts a development server using the specified schema symbol and module. The schema symbol defaults to 'schema' if not provided.

```shell
strawberry dev package.module:schema
```

--------------------------------

### Django manage.py Instrumentation

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/operations/tracing.md

Setup code for OpenTelemetry TracerProvider and Django instrumentation within manage.py.

```python
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.django import DjangoInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

resource = Resource(attributes={"service.name": "yourservicename"})
trace.set_tracer_provider(TracerProvider(resource=resource))
tracer = trace.get_tracer(__name__)
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

...


def main():
    DjangoInstrumentor().instrument()
    ...
```

--------------------------------

### Server startup confirmation

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/offset-based.md

The expected output message upon successful server startup.

```text
Running strawberry on http://0.0.0.0:8000/graphql 🍓
```

--------------------------------

### Define resolvers for Book, Author, and Query types

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/general/schema-basics.md

This example demonstrates defining resolver functions for Book, Author, and Query types to provide static data to fields.

```python
def get_author_for_book(root) -> "Author":
    return Author(name="Michael Crichton")


@strawberry.type
class Book:
    title: str
    author: "Author" = strawberry.field(resolver=get_author_for_book)


def get_books_for_author(root) -> typing.List[Book]:
    return [Book(title="Jurassic Park")]


@strawberry.type
class Author:
    name: str
    books: typing.List[Book] = strawberry.field(resolver=get_books_for_author)


def get_authors(root) -> typing.List[Author]:
    return [Author(name="Michael Crichton")]


@strawberry.type
class Query:
    authors: typing.List[Author] = strawberry.field(resolver=get_authors)
    books: typing.List[Book] = strawberry.field(resolver=get_books_for_author)
```

--------------------------------

### Create virtual environment

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/index.md

Set up a Python virtual environment for the project.

```shell
python -m venv virtualenv
```

--------------------------------

### Initialize project directory

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/index.md

Create a new directory for the Strawberry project.

```shell
mkdir strawberry-demo
cd strawberry-demo
```

--------------------------------

### Define GraphQL types and resolvers with type hints

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/concepts/typings.md

A complete example demonstrating the use of type hints for GraphQL types, fields, and resolvers, including the use of Optional for nullable fields.

```python
import datetime
import decimal
from typing import List, Optional

import strawberry

BOOKS_LOOKUP = {
    "Frank Herbert": [
        {
            "title": "Dune",
            "date_published": "1965-08-01",
            "price": "5.99",
            "isbn": 9780801950773,
        }
    ],
}


@strawberry.type
class Book:
    title: str
    author: "Author"
    date_published: datetime.date
    price: decimal.Decimal
    isbn: str


def get_books_by_author(root: "Author") -> List["Book"]:
    stored_books = BOOKS_LOOKUP[root.name]

    return [
        Book(
            title=book.get("title"),
            author=root,
            date_published=book.get("date_published"),
            price=book.get("price"),
            isbn=book.get("isbn"),
        )
        for book in stored_books
    ]


@strawberry.type
class Author:
    name: str
    books: List[Book] = strawberry.field(resolver=get_books_by_author)


@strawberry.type
class Group:
    name: Optional[str]  # groups of authors don't necessarily have names
    authors: List[Author]

    @strawberry.field
    def books(self) -> List[Book]:
        books = []

        for author in self.authors:
            books += get_books_by_author(author)

        return books
```

--------------------------------

### create_type usage example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/tools.md

Demonstrates creating a Query type dynamically using fields and the resulting GraphQL schema definition.

```python
import strawberry
from strawberry.tools import create_type


@strawberry.field
def hello(info) -> str:
    return "World"


def get_name(info) -> str:
    return info.context.user.name


my_name = strawberry.field(name="myName", resolver=get_name)

Query = create_type("Query", [hello, my_name])

schema = strawberry.Schema(query=Query)
```

```graphql
type Query {
  hello: String!
  myName: String!
}
```

--------------------------------

### Offset-based pagination with metadata

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/overview.md

Example of including metadata like total count in the pagination response.

```json
{
  "users": [
    ...
  ]
  "metadata": {
    "count": 25
  }
}
```

--------------------------------

### GraphQL validation error example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/errors.md

An example of an invalid GraphQL query and the resulting error response containing a message, location, and path.

```graphql
{
  hi
}
```

```json
{
  "data": null,
  "errors": [
    {
      "message": "Cannot query field 'hi' on type 'Query'.",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": null
    }
  ]
}
```

--------------------------------

### Create a new Chalice project

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/chalice.md

Use the Chalice CLI to initialize a new project directory.

```shell
chalice new-project badger-project
cd badger-project
```

--------------------------------

### Invalid strawberry.field() nesting example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/invalid-strawberry-field-annotation.md

This example demonstrates the incorrect usage where strawberry.field() is nested inside a list item annotation, which is not supported.

```python
from typing import Annotated

import strawberry


@strawberry.type
class Query:
    names: list[Annotated[str, strawberry.field(description="A name")]]
```

--------------------------------

### GraphQL SDL schema definition

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/codegen/schema-codegen.md

An example SDL file defining a Query type and a User type.

```graphql
type Query {
  user: User
}

type User {
  id: ID!
  name: String!
}
```

--------------------------------

### Triggering Some Error

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/_template.md

This example demonstrates code that will throw the Some Error error due to an undefined Query type.

```python
import strawberry

schema = strawberry.Schema(query=Query)
```

--------------------------------

### Conflicting Arguments Error Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/conflicting-arguments.md

This example demonstrates a resolver that triggers the Conflicting Arguments error by defining 'self', 'root', and 'parent' simultaneously.

```python
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def hello(
        self, root, parent: strawberry.Parent[str]
    ) -> str:  #  <-- self, root, and parent all identify the same input
        return f"hello world"
```

--------------------------------

### Define Schema with Cursor Pagination

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/cursor-based.md

This example defines the User, PageMeta, and Query types, along with helper functions to encode and decode cursors for pagination.

```python
from base64 import b64encode, b64decode
from typing import List, Optional, Dict, Any, cast

import strawberry

user_data = [
    {
        "id": 1,
        "name": "Norman Osborn",
        "occupation": "Founder, Oscorp Industries",
        "age": 42,
    },
    {
        "id": 2,
        "name": "Peter Parker",
        "occupation": "Freelance Photographer, The Daily Bugle",
        "age": 20,
    },
    {
        "id": 3,
        "name": "Harold Osborn",
        "occupation": "President, Oscorp Industries",
        "age": 19,
    },
    {
        "id": 4,
        "name": "Eddie Brock",
        "occupation": "Journalist, The Eddie Brock Report",
        "age": 20,
    },
]


def encode_user_cursor(id: int) -> str:
    """
    Encodes the given user ID into a cursor.

    :param id: The user ID to encode.

    :return: The encoded cursor.
    """
    return b64encode(f"user:{id}".encode("ascii")).decode("ascii")


def decode_user_cursor(cursor: str) -> int:
    """
    Decodes the user ID from the given cursor.

    :param cursor: The cursor to decode.

    :return: The decoded user ID.
    """
    cursor_data = b64decode(cursor.encode("ascii")).decode("ascii")
    return int(cursor_data.split(":")[1])


@strawberry.type
class User:
    id: str = strawberry.field(description="ID of the user.")
    name: str = strawberry.field(description="The name of the user.")
    occupation: str = strawberry.field(description="The occupation of the user.")
    age: int = strawberry.field(description="The age of the user.")

    @staticmethod
    def from_row(row: Dict[str, Any]) -> "User":
        return User(
            id=row["id"], name=row["name"], occupation=row["occupation"], age=row["age"]
        )


@strawberry.type
class PageMeta:
    next_cursor: Optional[str] = strawberry.field(
        description="The next cursor to continue with."
    )


@strawberry.type
class UserResponse:
    users: List[User] = strawberry.field(description="The list of users.")
    page_meta: PageMeta = strawberry.field(description="Metadata to aid in pagination.")


@strawberry.type
class Query:
    @strawberry.field(description="Get a list of users.")
    def get_users(self, limit: int, cursor: Optional[str] = None) -> UserResponse:
        if cursor is not None:
            # decode the user ID from the given cursor.
            user_id = decode_user_cursor(cursor=cursor)
        else:
            # no cursor was given (this happens usually when the
            # client sends a query for the first time).
            user_id = 0

        # filter the user data, going through the next set of results.
        filtered_data = [user for user in user_data if user["id"] >= user_id]

        # slice the relevant user data (Here, we also slice an
        # additional user instance, to prepare the next cursor).
        sliced_users = filtered_data[: limit + 1]

        if len(sliced_users) > limit:
            # calculate the client's next cursor.
            last_user = sliced_users.pop(-1)
            next_cursor = encode_user_cursor(id=last_user["id"])
        else:
            # We have reached the last page, and
            # don't have the next cursor.
            next_cursor = None

        sliced_users = [User.from_row(x) for x in sliced_users]

        return UserResponse(
            users=sliced_users, page_meta=PageMeta(next_cursor=next_cursor)
        )


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Override get_context for custom context

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/sanic.md

Override get_context to provide a custom context object for resolvers. The example returns a dictionary containing an 'example' key.

```python
import strawberry
from strawberry.sanic.views import GraphQLView
from strawberry.http.temporal_response import TemporalResponse
from sanic.request import Request


class MyGraphQLView(GraphQLView):
    async def get_context(self, request: Request, response: TemporalResponse):
        return {"example": 1}


@strawberry.type
class Query:
    @strawberry.field
    def example(self, info: strawberry.Info) -> str:
        return str(info.context["example"])
```

--------------------------------

### Customizing on_ws_connect in Litestar

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/litestar.md

This example demonstrates how to override on_ws_connect to handle authentication by inspecting connection parameters. It shows how to accept connections with custom payloads or reject them using ConnectionRejectionError.

```python
import strawberry
from typing import Dict
from strawberry.exceptions import ConnectionRejectionError
from strawberry.litestar import make_graphql_controller


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "world"


schema = strawberry.Schema(Query)

GraphQLController = make_graphql_controller(
    schema,
    path="/graphql",
)


class MyGraphQLController(GraphQLController):
    async def on_ws_connect(self, context: Dict[str, object]):
        connection_params = context["connection_params"]

        if not isinstance(connection_params, dict):
            # Reject without a custom graphql-ws error payload
            raise ConnectionRejectionError()

        if connection_params.get("password") != "secret":
            # Reject with a custom graphql-ws error payload
            raise ConnectionRejectionError({"reason": "Invalid password"})

        if username := connection_params.get("username"):
            # Accept with a custom acknowledgment payload
            return {"message": f"Hello, {username}!"}

        # Accept without a acknowledgment payload
        return await super().on_ws_connect(context)
```

--------------------------------

### Returning a database model in a resolver

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/accessing-parent-data.md

Example of a resolver returning a database model instead of a Strawberry type instance.

```python
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def user(self) -> User:
        # let's assume UserModel fetches data from the db and it
        # also has `first_name` and `last_name`
        user = UserModel.objects.first()

        return user
```

--------------------------------

### Invalid Input Type Inheritance Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/invalid-superclass-interface.md

This example demonstrates the invalid configuration where a class marked as an input type inherits from an interface, which is not supported in GraphQL.

```python
import strawberry


@strawberry.interface
class SomeInterface:
    some_field: str


@strawberry.input
class SomeInput(SomeInterface):
    another_field: int
```

--------------------------------

### Define types using Schema Definition Language (SDL)

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/general/schema-basics.md

An example of a GraphQL schema using SDL to define Book and Author types and their relationships.

```graphql
type Book {
  title: String!
  author: Author!
}

type Author {
  name: String!
  books: [Book!]!
}
```

--------------------------------

### Streaming Subscription Results with AsyncGenerator

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/general/subscriptions.md

This example demonstrates a subscription that executes a subprocess and streams its output using an AsyncGenerator. It includes a defensive wait_for_call helper to handle potential stream reading timeouts.

```python
import strawberry
import asyncio
import asyncio.subprocess as subprocess
from asyncio import streams
from typing import Any, AsyncGenerator, AsyncIterator, Coroutine, Optional


async def wait_for_call(coro: Coroutine[Any, Any, bytes]) -> Optional[bytes]:
    """
    wait_for_call calls the supplied coroutine in a wait_for block.

    This mitigates cases where the coroutine doesn't yield until it has
    completed its task. In this case, reading a line from a StreamReader; if
    there are no `\n` line chars in the stream the function will never exit
    """
    try:
        return await asyncio.wait_for(coro(), timeout=0.1)
    except asyncio.TimeoutError:
        pass


async def lines(stream: streams.StreamReader) -> AsyncIterator[str]:
    """
    lines reads all lines from the provided stream, decoding them as UTF-8
    strings.
    """
    while True:
        b = await wait_for_call(stream.readline)
        if b:
            yield b.decode("UTF-8").rstrip()
        else:
            break


async def exec_proc(target: int) -> subprocess.Process:
    """
    exec_proc starts a sub process and returns the handle to it.
    """
    return await asyncio.create_subprocess_exec(
        "/bin/bash",
        "-c",
        f"for ((i = 0 ; i < {target} ; i++)); do echo $i; sleep 0.2; done",
        stdout=subprocess.PIPE,
    )


async def tail(proc: subprocess.Process) -> AsyncGenerator[str, None]:
    """
    tail reads from stdout until the process finishes
    """
    # Note: race conditions are possible here since we're in a subprocess. In
    # this case the process can finish between the loop predicate and the call
    # to read a line from stdout. This is a good example of why you need to
    # be defensive by using asyncio.wait_for in wait_for_call().
    while proc.returncode is None:
        async for l in lines(proc.stdout):
            yield l
    else:
        # read anything left on the pipe after the process has finished
        async for l in lines(proc.stdout):
            yield l


@strawberry.type
class Query:
    @strawberry.field
    def hello() -> str:
        return "world"


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def run_command(self, target: int = 100) -> AsyncGenerator[str, None]:
        proc = await exec_proc(target)
        return tail(proc)


schema = strawberry.Schema(query=Query, subscription=Subscription)
```

--------------------------------

### Unresolved Field Type Error Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/unresolved-field-type.md

This example demonstrates the error occurring when a forward reference to an undefined 'User' type is used within a 'Query' class.

```python
import strawberry


@strawberry.type
class Query:
    user: "User"


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Create ASGI application

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/asgi.md

Initialize the GraphQL ASGI application using your schema.

```python
# server.py
from strawberry.asgi import GraphQL

from api.schema import schema

app = GraphQL(schema)
```

--------------------------------

### Invalid Union Argument Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/invalid-argument-type.md

This example demonstrates code that triggers an Invalid Argument Type error by attempting to use a union type as a field argument.

```python
import strawberry

from typing import Union, Annotated


@strawberry.type
class TypeA:
    id: strawberry.ID


ExampleUnion = Annotated[Union[TypeA], strawberry.union("ExampleUnion")]


@strawberry.type
class Query:
    @strawberry.field
    def example(self, data: Example) -> str:
        return "this is an example"


schema = strawberry.Schema(query=Query)
```

--------------------------------

### GraphQL query for federated fields

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/federation.md

Example query demonstrating how to fetch fields defined in different services, such as title from the books service and reviews from the reviews service.

```graphql
{
  # query defined in the books service
  allBooks {
    title
    # field defined in the reviews service
    reviews {
      body
    }
  }
}
```

--------------------------------

### Schema initialization

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/connections.md

Initializing a Strawberry schema with a query.

```python
schema = strawberry.Schema(query=Query)
```

--------------------------------

### FieldWithResolverAndDefaultFactoryError Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/exceptions.md

Raised when a field defines both a resolver and a default_factory.

```python
@strawberry.type
class Query:
    @strawberry.field(default_factory=lambda: "Example C")
    def c(self) -> str:
        return "I'm a resolver"


# Throws 'Field "c" on type "Query" cannot define a default_factory and a resolver.'
```

--------------------------------

### Define File Upload Mutations and Inputs

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/file-upload.md

Example showing how to define mutations and input types that accept single or multiple Upload objects in an asynchronous Strawberry GraphQL resolver.

```python
import typing
import strawberry
from strawberry.file_uploads import Upload


@strawberry.input
class FolderInput:
    files: typing.List[Upload]


@strawberry.type
class Mutation:
    @strawberry.mutation
    async def read_file(self, file: Upload) -> str:
        return (await file.read()).decode("utf-8")

    @strawberry.mutation
    async def read_files(self, files: typing.List[Upload]) -> typing.List[str]:
        contents = []
        for file in files:
            content = (await file.read()).decode("utf-8")
            contents.append(content)
        return contents

    @strawberry.mutation
    async def read_folder(self, folder: FolderInput) -> typing.List[str]:
        contents = []
        for file in folder.files:
            content = (await file.read()).decode("utf-8")
            contents.append(content)
        return contents
```

--------------------------------

### Import AsyncGraphQLView

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/flask.md

Use AsyncGraphQLView for asynchronous support, which is recommended when utilizing dataloaders.

```python
from strawberry.flask.views import AsyncGraphQLView
```

--------------------------------

### WrongReturnTypeForUnion Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/exceptions.md

Raised when a Union type cannot be resolved because it is not wrapped in a strawberry.field.

```python
@strawberry.type
class A:
    a: int


@strawberry.type
class B:
    b: int


@strawberry.type
class Query:
    ab: Union[A, B] = "ciao"  # missing `strawberry.field` !


query = """{    ab {
        __typename,

        ... on A {
            a
        }
    }
}"""

result = schema.execute_sync(query, root_value=Query())

# result will look like:
# ExecutionResult(
#     data=None,
#     errors=[
#         GraphQLError(
#             'The type "<class \'str\'>" cannot be resolved for the field "ab" , are you using a strawberry.field?',
#             locations=[SourceLocation(line=2, column=9)],
#             path=["ab"],
#         )
#     ],
#     extensions={},
# )
```

--------------------------------

### FieldWithResolverAndDefaultValueError Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/exceptions.md

Raised when a field defines both a resolver and a default value.

```python
def test_resolver() -> str:
    return "I'm a resolver"


@strawberry.type
class Query:
    c: str = strawberry.field(default="Example C", resolver=test_resolver)


# Throws 'Field "c" on type "Query" cannot define a default value and a resolver.'
```

--------------------------------

### Usage example of MaxAliasesLimiter

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/max-aliases-limiter.md

Demonstrates how to integrate the MaxAliasesLimiter extension into a Strawberry schema by adding it to the extensions list with a specified max_alias_count.

```python
import strawberry
from strawberry.extensions import MaxAliasesLimiter


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        MaxAliasesLimiter(max_alias_count=15),
    ],
)
```

--------------------------------

### Define a DataLoader with a GraphQL Query

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/dataloaders.md

Example showing the definition of a DataLoader and its usage within a Strawberry GraphQL query resolver.

```python
from typing import List

from strawberry.dataloader import DataLoader
import strawberry


@strawberry.type
class User:
    id: strawberry.ID


async def load_users(keys) -> List[User]:
    return [User(id=key) for key in keys]


loader = DataLoader(load_fn=load_users)


@strawberry.type
class Query:
    @strawberry.field
    async def get_user(self, id: strawberry.ID) -> User:
        return await loader.load(id)


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Adding NoSchemaIntrospectionCustomRule

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/add-validation-rules.md

Example of adding the built-in NoSchemaIntrospectionCustomRule from graphql-core to a schema.

```python
import strawberry
from strawberry.extensions import AddValidationRules
from graphql.validation import NoSchemaIntrospectionCustomRule


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        AddValidationRules([NoSchemaIntrospectionCustomRule]),
    ],
)
```

--------------------------------

### Adding NoDeprecatedCustomRule

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/add-validation-rules.md

Example of adding the built-in NoDeprecatedCustomRule from graphql-core to a schema.

```python
import strawberry
from strawberry.extensions import AddValidationRules
from graphql.validation import NoDeprecatedCustomRule


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Hello, world!"


schema = strawberry.Schema(
    Query,
    extensions=[
        AddValidationRules([NoDeprecatedCustomRule]),
    ],
)
```

--------------------------------

### Fixing Multiple Strawberry Fields Error

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/errors/multiple-strawberry-fields.md

This example demonstrates the correct approach by combining all field configuration options into a single strawberry.field() call.

```python
from typing import Annotated

import strawberry


@strawberry.type
class Query:
    name: Annotated[
        str,
        strawberry.field(
            description="The name",
            deprecation_reason="Use fullName instead",
        ),
    ]


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Execute Enum query

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/enums.md

Example query using the defined Enum field.

```graphql
query {
  bestFlavour
}
```

--------------------------------

### Define an async resolver with strawberry.field

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/concepts/async.md

An example of an asynchronous resolver using asyncio.sleep to simulate a delay, integrated into a Strawberry Query type.

```python
import asyncio
import strawberry


async def resolve_hello(root) -> str:
    await asyncio.sleep(1)

    return "Hello world"


@strawberry.type
class Query:
    hello: str = strawberry.field(resolver=resolve_hello)


schema = strawberry.Schema(Query)
```

--------------------------------

### Defining Custom Context Types

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/litestar.md

Example of defining custom Info types for queries, mutations, and subscriptions using BaseContext, HTTPContextType, and WebSocketContextType.

```python
import strawberry
from typing import Any
from litestar import Request, Litestar
from litestar.datastructures import State
from strawberry.litestar import (
    make_graphql_controller,
    BaseContext,
    HTTPContextType,
    WebSocketContextType,
)
from strawberry.types.info import Info
from sqlalchemy.ext.asyncio import AsyncSession
from app.models import User
from sqlalchemy import select


class CustomContext(BaseContext, kw_only=True):
    user: User
    session: AsyncSession


class CustomHTTPContextType(HTTPContextType, CustomContext):
    request: Request[User, Any, State]


class CustomWSContextType(WebSocketContextType, CustomContext):
    socket: WebSocket[User, Token, State]


async def custom_context_getter(
    request: Request, db_session: AsyncSession
) -> CustomContext:
    return CustomContext(user=request.user, session=db_session)


@strawberry.type
class Query:
    @strawberry.field
    async def hello(self, info: strawberry.Info[CustomHTTPContextType, None]) -> str:
        session: AsyncSession = info.context.session
        user: User = info.context.user

        query = select(User).where(User.id == user.id)
        user = (await session.execute((query))).scalar_one()
        return f"Hello {user.first_name}"


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def count(
        self, info: strawberry.Info[CustomWSContextType, None], target: int = 100
    ) -> AsyncGenerator[int, None]:
        import devtools

        devtools.debug(info.context)
        devtools.debug(info.context.socket)
        for i in range(target):
            yield i
            await asyncio.sleep(0.5)


schema = strawberry.Schema(Query, subscription=Subscription)

GraphQLController = make_graphql_controller(
    schema,
    path="/graphql",
    context_getter=custom_context_getter,
)

app = Litestar(route_handlers=[GraphQLController])
```

--------------------------------

### MultipleStrawberryArgumentsError Example

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/exceptions.md

Raised when multiple strawberry.argument annotations are applied to a single argument.

```python
import strawberry
from typing_extensions import Annotated


@strawberry.field
def name(
    argument: Annotated[
        str,
        strawberry.argument(description="This is a description"),
        strawberry.argument(description="Another description"),
    ],
) -> str:
    return "Name"


# Throws 'Annotation for argument `argument` on field `name` cannot have multiple `strawberry.argument`s'
```

--------------------------------

### Run project commands

Source: https://github.com/strawberry-graphql/strawberry/blob/main/AGENTS.md

Common CLI commands for testing, linting, and formatting the codebase.

```shell
uv run pytest
uv run pytest path/to/test.py -q
uv run mypy --config-file mypy.ini
uv run ruff check .
uv run ruff format .
uv run ruff format --check .
uv run pre-commit run --all-files
uv run nox -t tests -l
```

--------------------------------

### PyInstrument(report_path: Path)

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/extensions/pyinstrument.md

Initializes the PyInstrument extension to profile schema execution and save the results to a specified file path.

```APIDOC
## PyInstrument

### Description
Initializes the PyInstrument extension for a Strawberry schema to enable performance profiling and call stack inspection.

### Constructor
`PyInstrument(report_path: Path = Path("pyinstrument.html"))`

### Parameters
- **report_path** (Path) - Optional - The file system path where the generated HTML profiling report will be saved. Defaults to "pyinstrument.html".
```

--------------------------------

### GraphQL Subscription: SubscribeToChatRooms

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/channels.md

Start a subscription to specific chat rooms on the GraphQL client.

```graphql
subscription SubscribeToChatRooms {
  joinChatRooms(
    rooms: [{ roomName: "room1" }, { roomName: "room2" }]
    user: "foo"
  ) {
    roomName
    message
    currentUser
  }
}
```

--------------------------------

### Define User Data and Cursor Utilities

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/pagination/cursor-based.md

This snippet sets up the mock user dataset and provides helper functions to encode and decode user IDs into base64 cursors.

```python
# example.py

from base64 import b64encode, b64decode
from typing import List, Optional, Dict, Any, cast

import strawberry

user_data = [
    {
        "id": 1,
        "name": "Norman Osborn",
        "occupation": "Founder, Oscorp Industries",
        "age": 42,
    },
    {
        "id": 2,
        "name": "Peter Parker",
        "occupation": "Freelance Photographer, The Daily Bugle",
        "age": 20,
    },
    {
        "id": 3,
        "name": "Harold Osborn",
        "occupation": "President, Oscorp Industries",
        "age": 19,
    },
    {
        "id": 4,
        "name": "Eddie Brock",
        "occupation": "Journalist, The Eddie Brock Report",
        "age": 20,
    },
]


def encode_user_cursor(id: int) -> str:
    """
    Encodes the given user ID into a cursor.

    :param id: The user ID to encode.

    :return: The encoded cursor.
    """
    return b64encode(f"user:{id}".encode("ascii")).decode("ascii")


def decode_user_cursor(cursor: str) -> int:
    """
    Decodes the user ID from the given cursor.

    :param cursor: The cursor to decode.

    :return: The decoded user ID.
    """
    cursor_data = b64decode(cursor.encode("ascii")).decode("ascii")
    return int(cursor_data.split(":")[1])


@strawberry.type
class User:
    id: str = strawberry.field(description="ID of the user.")
    name: str = strawberry.field(description="The name of the user.")
    occupation: str = strawberry.field(description="The occupation of the user.")
    age: int = strawberry.field(description="The age of the user.")

    @staticmethod
    def from_row(row: Dict[str, Any]) -> "User":
        return User(
            id=row["id"], name=row["name"], occupation=row["occupation"], age=row["age"]
        )


@strawberry.type
class PageMeta:
    next_cursor: Optional[str] = strawberry.field(
        description="The next cursor to continue with."
    )


@strawberry.type
class UserResponse:
    users: List[User] = strawberry.field(description="The list of users.")
    page_meta: PageMeta = strawberry.field(description="Metadata to aid in pagination.")


@strawberry.type
class Query:
    @strawberry.field(description="Get a list of users.")
    def get_users(self) -> UserResponse: ...


schema = strawberry.Schema(query=Query)
```

--------------------------------

### Python: Subscription confirmation with yield None

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/integrations/channels.md

Adapt the subscription to send a null value to the client upon successful connection, confirming the Channels layer subscription has started.

```python
# mysite/gqlchat/subscription.py


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def join_chat_rooms(
        self,
        info: strawberry.Info,
        rooms: List[ChatRoom],
        user: str,
    ) -> AsyncGenerator[ChatRoomMessage | None, None]:
        ...
        async with ws.listen_to_channel("chat.message", groups=room_ids) as cm:
            yield None
            async for message in cm:
                if message["room_id"] in room_ids:
                    yield ChatRoomMessage(
                        room_name=message["room_id"],
                        message=message["message"],
                        current_user=user,
                    )
```

--------------------------------

### Initialize and Use DataLoader

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/guides/dataloaders.md

Initialize a DataLoader with the loading function and perform a single load.

```python
from strawberry.dataloader import DataLoader

loader = DataLoader(load_fn=load_users)

user = await loader.load(1)
```

--------------------------------

### GraphQL SDL Union definition

Source: https://github.com/strawberry-graphql/strawberry/blob/main/docs/types/union.md

Example of a union type defined in GraphQL Schema Definition Language.

```graphql
union MediaItem = Audio | Video | Image
```
Tokens:
Raw