PricingLoginStart free
Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

Mentakrifkan Jenis, Pertanyaan dan Mutasi

Bina skema GraphQL bertip dengan Strawberry dan pasangkannya pada aplikasi FastAPI dengan kebergantungan dikongsi.

Pelajaran 1 daripada 413 langkah

Mentakrifkan Jenis, Pertanyaan dan Mutasi ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Mengapa Strawberry untuk GraphQL pada FastAPI

Strawberry ialah pustaka GraphQL berasaskan kod untuk Python yang menggunakan dataclass dan petunjuk jenis untuk mentakrifkan skema anda. Daripada menulis SDL GraphQL secara manual, anda menulis kelas Python biasa dan Strawberry menjana skema daripadanya.

  • Berasaskan kod: jenis Python ialah sumber kebenaran — SDL dijana.
  • Selamat jenis: petunjuk jenis standard (int, str, list[str], Optional) dipetakan terus kepada jenis GraphQL.
  • Asli ASGI: disertakan dengan penghala yang dipasang dengan kemas pada aplikasi FastAPI, sambil berkongsi gelung peristiwa dan sistem kebergantungannya.

Dalam pelajaran ini, kita membina skema berjenis (jenis, Query dan Mutation) lalu memasangnya pada FastAPI dengan kebergantungan yang dikongsi.

Mentakrifkan Jenis Objek

Jenis objek GraphQL hanyalah kelas yang dihiasi dengan @strawberry.type. Setiap atribut beranotasi menjadi medan. Petunjuk jenis menentukan jenis medan GraphQL: int menjadi Int, str menjadi String, dan medan bukan pilihan menjadi bukan nol (!).

  • Gunakan strawberry.ID untuk medan pengecam — ia disiri sebagai rentetan tetapi menandakan semantik identiti.
  • Optional[...] (atau X | None) menjadikan medan boleh bernilai nol.
import strawberry
from typing import Optional


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str
    pages: int
    summary: Optional[str] = None

Jenis Akar Query

Setiap skema GraphQL memerlukan akar Query — titik masuk untuk bacaan. Anda mengisytiharkannya sebagai @strawberry.type yang medannya diselesaikan oleh kaedah yang dihiasi dengan @strawberry.field.

  • Anotasi pemulangan kaedah menentukan jenis GraphQL medan tersebut.
  • Parameter kaedah (selain self) menjadi argumen GraphQL.
  • Memulangkan list[Book] menghasilkan senarai bukan nol yang mengandungi buku bukan nol: [Book!]!.
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return [
            Book(id="1", title="Dune", author="Herbert", pages=412),
            Book(id="2", title="1984", author="Orwell", pages=328),
        ]

    @strawberry.field
    def book(self, id: strawberry.ID) -> Book | None:
        for b in self.books():
            if b.id == id:
                return b
        return None

Membina Skema

strawberry.Schema menghubungkan jenis akar. Sekurang-kurangnya anda perlu memberikan query=Query; kemudian anda boleh menambah mutation=Mutation. Pembinaan skema mengesahkan jenis anda dan membolehkan anda mencetak SDL yang dijana — pemeriksaan kewajaran yang sangat baik.

Berikut ialah contoh yang sepenuhnya kendiri: takrifkan jenis, query, bina skema, dan laksanakan query secara segerak dengan schema.execute_sync. Tiada pelayan atau rangka kerja diperlukan.

import strawberry


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return [Book(id="1", title="Dune", author="Herbert")]


schema = strawberry.Schema(query=Query)

result = schema.execute_sync("{ books { id title author } }")
print(result.errors)
print(result.data)

Argumen Medan dan Nilai Lalai

Argumen GraphQL datang terus daripada parameter penyelesai. Parameter dengan nilai lalai menjadi argumen pilihan; tanpa nilai lalai, ia diperlukan.

  • Gunakan typing.Optional + nilai lalai untuk menyatakan argumen pilihan yang boleh bernilai nol.
  • Strawberry menukarkan nilai argumen yang diterima kepada jenis Python beranotasi secara automatik.

Di bawah, limit lalai kepada 10 dan genre ialah penapis pilihan.

import strawberry
from typing import Optional


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    genre: str


LIBRARY = [
    Book(id="1", title="Dune", genre="scifi"),
    Book(id="2", title="It", genre="horror"),
]


@strawberry.type
class Query:
    @strawberry.field
    def books(self, limit: int = 10, genre: Optional[str] = None) -> list[Book]:
        items = LIBRARY if genre is None else [b for b in LIBRARY if b.genre == genre]
        return items[:limit]


schema = strawberry.Schema(query=Query)
print(schema.execute_sync('{ books(genre: "scifi") { title } }').data)

Jenis Input untuk Mutasi

Mutasi yang menerima data berstruktur hendaklah menggunakan jenis input: kelas yang dihiasi dengan @strawberry.input. Jenis input ialah setara GraphQL bagi isi permintaan — ia memastikan tandatangan mutasi kemas dan menerangkan dirinya sendiri.

  • Medan tanpa nilai lalai ialah medan input yang diperlukan.
  • Gunakan semula input yang sama merentasi aliran penciptaan/pengemaskinian dengan menjadikan medan pilihan apabila sesuai.
import strawberry
from typing import Optional


@strawberry.input
class AddBookInput:
    title: str
    author: str
    pages: Optional[int] = None

Jenis Akar Mutation

Akar Mutation mencerminkan Query tetapi menyatakan operasi tulis. Setiap kaedah ialah @strawberry.mutation. Konvensyen: terima jenis input, lakukan kesan sampingan, dan pulangkan objek yang dicipta atau dikemas kini supaya klien boleh membaca medan terkini dalam satu perjalanan pergi balik.

Contoh ini mengekalkan stor dalam memori dan memulangkan Book baharu. Contoh ini sepenuhnya kendiri dan boleh dijalankan.

import strawberry

_DB: list["Book"] = []


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str


@strawberry.input
class AddBookInput:
    title: str
    author: str


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return _DB


@strawberry.type
class Mutation:
    @strawberry.mutation
    def add_book(self, data: AddBookInput) -> Book:
        book = Book(id=str(len(_DB) + 1), title=data.title, author=data.author)
        _DB.append(book)
        return book


schema = strawberry.Schema(query=Query, mutation=Mutation)
q = 'mutation { addBook(data: {title: "Dune", author: "Herbert"}) { id title } }'
print(schema.execute_sync(q).data)

Penyelesai Tak Segerak

Oleh sebab Strawberry berjalan pada ASGI, penyelesai boleh menjadi async. Ini penting pada FastAPI: penyelesai anda akan menggunakan await untuk panggilan pangkalan data, klien HTTP atau carian cache tanpa menyekat gelung peristiwa.

  • Hanya isytiharkan async def — Strawberry akan menunggunya untuk anda.
  • Campurkan penyelesai segerak dan tak segerak secara bebas dalam skema yang sama.
  • Gunakan penyelesai tak segerak untuk sebarang I/O supaya satu permintaan GraphQL dengan banyak medan kekal tidak menyekat.
import strawberry
import asyncio


@strawberry.type
class Stats:
    total_books: int


async def fetch_count() -> int:
    await asyncio.sleep(0)  # stand-in for an async DB call
    return 42


@strawberry.type
class Query:
    @strawberry.field
    async def stats(self) -> Stats:
        return Stats(total_books=await fetch_count())


schema = strawberry.Schema(query=Query)
print(asyncio.run(schema.execute("{ stats { totalBooks } }")).data)

Memasang pada FastAPI dengan GraphQLRouter

Strawberry menyediakan strawberry.fastapi.GraphQLRouter, iaitu APIRouter yang anda pasang dengan app.include_router. Ia menyediakan titik akhir GraphQL dan IDE dalam pelayar (GraphiQL) pada laluan yang sama.

  • Berikan schema yang telah dibina kepada penghala.
  • Pasangkannya di bawah laluan seperti /graphql.
  • Penghala menggunakan gelung peristiwa FastAPI, jadi penyelesai tak segerak dan peristiwa permulaan/penutupan FastAPI berfungsi bersama.

Ini ialah kod rangka kerja, jadi ia tidak boleh dijalankan pada penghakim kosong.

import strawberry
from fastapi import FastAPI
from strawberry.fastapi import GraphQLRouter


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


schema = strawberry.Schema(query=Query)
graphql_app = GraphQLRouter(schema)

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

Berkongsi Kebergantungan melalui Konteks

Manfaat utama memasang pada FastAPI ialah kebergantungan yang dikongsi. Berikan context_getter kepada GraphQLRouter — ia ialah boleh panggil kebergantungan FastAPI, jadi ia sendiri boleh menggunakan Depends pada sesi DB, pengguna semasa atau objek tetapan.

Apa sahaja yang dipulangkan oleh pengambil konteks didedahkan kepada penyelesai melalui strawberry.Info pada info.context. Inilah cara pengesahan dan sesi pangkalan data mengalir daripada FastAPI ke penyelesai GraphQL anda.

from fastapi import Depends
from strawberry.fastapi import GraphQLRouter


async def get_db():
    # yield a real async session in production
    yield {"connection": "db-session"}


async def get_context(db=Depends(get_db)):
    return {"db": db, "role": "reader"}


graphql_app = GraphQLRouter(schema, context_getter=get_context)

Membaca Konteks dalam Penyelesai

Untuk menggunakan konteks yang dikongsi, tambahkan parameter info: strawberry.Info pada penyelesai. Strawberry menyuntikkannya secara automatik dan ia tidak pernah muncul sebagai argumen GraphQL. Akses kebergantungan anda melalui info.context.

  • info.context["db"] — sesi yang disediakan oleh context_getter.
  • Gunakannya untuk memberi kuasa: baca pengguna semasa dan jana ralat jika kebenaran tiada.
  • Objek konteks yang sama dikongsi merentasi setiap penyelesai dalam satu permintaan.
import strawberry


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

    @strawberry.field
    def secret(self, info: strawberry.Info) -> str:
        if info.context["role"] != "admin":
            raise Exception("forbidden")
        return "top-secret"

Semakan Pantas: Berkongsi Sesi DB

Anda telah memasang skema Strawberry pada FastAPI dan memerlukan setiap penyelesai GraphQL menggunakan sesi pangkalan data yang sama bagi setiap permintaan seperti yang diperoleh oleh titik akhir REST anda daripada kebergantungan FastAPI. Apakah cara idiomatik Strawberry + FastAPI untuk menyambungkannya?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah membina skema GraphQL berjenis dengan Strawberry dan memasangnya pada FastAPI:

  • Jenis: kelas @strawberry.type dengan medan berpetunjuk jenis; strawberry.ID untuk pengecam dan Optional untuk medan yang boleh bernilai nol.
  • Query: akar bacaan, dengan penyelesai @strawberry.field yang parameternya menjadi argumen GraphQL.
  • Mutasi: kaedah @strawberry.mutation yang menerima jenis @strawberry.input dan memulangkan objek yang terjejas.
  • Skema: strawberry.Schema(query=Query, mutation=Mutation), yang boleh disahkan dengan execute_sync.
  • Integrasi FastAPI: pasang dengan GraphQLRouter, dan kongsi sesi DB serta pengesahan melalui context_getter + info.context, dengan menggunakan semula suntikan kebergantungan FastAPI.

Pendekatan berasaskan kod dan selamat jenis ini memastikan API GraphQL serta aplikasi FastAPI anda menggunakan bahasa yang sama — petunjuk jenis Python.

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
21
Pelajaran
84
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mentakrifkan Jenis, Pertanyaan dan Mutasi” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Mentakrifkan Jenis, Pertanyaan dan Mutasi”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mentakrifkan Jenis, Pertanyaan dan Mutasi”?

Bina skema GraphQL bertip dengan Strawberry dan pasangkannya pada aplikasi FastAPI dengan kebergantungan dikongsi. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Mentakrifkan Jenis, Pertanyaan dan Mutasi” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Mentakrifkan Jenis, Pertanyaan dan Mutasi
  2. Menyelesaikan Pertanyaan N+1 dengan DataLoaders
  3. Langganan GraphQL Masa Nyata
  4. Analisis Kos Pertanyaan dan Had Kedalaman
← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI