Jenis GraphQL

Kueri sangat mirip dengan GET operasi karena mereka melakukan pengambilan baca-saja untuk mendapatkan data dari sumber Anda. Di GraphQL, men Query definisikan semua titik masuk untuk klien yang membuat permintaan terhadap server Anda. Akan selalu ada Query dalam implementasi GraphQL Anda.

Berikut adalah jenis objek Query dan modifikasi yang kami gunakan dalam contoh skema sebelumnya:

type Person { 
  id: ID!
  name: String
  age: Int
  occupation: Occupation
}
type Occupation {
  title: String
}
type Query {                                   
  people: [Person]
}

Kami Query berisi bidang people yang disebut yang mengembalikan daftar Person instance dari sumber data. Katakanlah kita perlu mengubah perilaku aplikasi kita, dan sekarang kita perlu mengembalikan daftar hanya Occupation contoh untuk beberapa tujuan terpisah. Kita cukup menambahkannya ke kueri:

type Query {                                   
  people: [Person]
  occupations: [Occupation]
}

Di GraphQL, kita dapat memperlakukan kueri kita sebagai sumber tunggal permintaan. Seperti yang Anda lihat, ini berpotensi jauh lebih sederhana daripada implementasi RESTful yang mungkin menggunakan titik akhir yang berbeda untuk mencapai hal yang sama (.../api/1/peopledan). .../api/1/occupations

Dengan asumsi kita memiliki implementasi resolver untuk kueri ini, kita sekarang dapat melakukan kueri yang sebenarnya. Sementara ti Query penya ada, kita harus secara eksplisit memanggilnya agar dapat berjalan dalam kode aplikasi. Ini dapat dilakukan dengan menggunakan query kata kunci:

query getItems {
   people {
      name
   }
   occupations {
      title
   }
}

Seperti yang Anda lihat, kueri ini dipanggil getItems dan mengembalikan people (daftar Person objek) dan occupations (daftar Occupation objek). Dipeople, kami hanya mengembalikan name bidang masing-masingPerson, sementara kami mengembalikan title bidang masing-masingOccupation. Tanggapannya mungkin terlihat seperti ini:

{
  "data": {
    "people": [
      {
        "name": "John Smith"
      },
      {
        "name": "Andrew Miller"
      },
      .
      .
      .
    ],
    "occupations": [
      {
        "title": "Firefighter"
      },
      {
        "title": "Bookkeeper"
      },
      .
      .
      .
    ]
  }
}

Contoh respons menunjukkan bagaimana data mengikuti bentuk kueri. Setiap entri yang diambil terdaftar dalam lingkup bidang. peopledan occupations mengembalikan hal-hal sebagai daftar terpisah. Meskipun berguna, mungkin lebih mudah untuk memodifikasi kueri untuk mengembalikan daftar nama dan pekerjaan orang:

query getItems {
   people {
      name   
      occupation {
        title
      }
}

Ini adalah modifikasi hukum karena Person tipe kami berisi occupation bidang tipeOccupation. Ketika terdaftar dalam lingkuppeople, kami mengembalikan masing-masing Person name bersama dengan yang terkait Occupationtitle. Tanggapannya mungkin terlihat seperti ini:

}
  "data": {
    "people": [
      {
        "name": "John Smith",
        "occupation": {
          "title": "Firefighter"
        }
      },
      {
        "name": "Andrew Miller",
        "occupation": {
          "title": "Bookkeeper"
        }
      },
      .
      .
      .
    ]
  }
}

Mutasi mirip dengan operasi pengubah keadaan seperti PUT atauPOST. Mereka melakukan operasi tulis untuk memodifikasi data di sumber, lalu mengambil respons. Mereka menentukan titik masuk Anda untuk permintaan modifikasi data. Tidak seperti kueri, mutasi mungkin atau mungkin tidak dimasukkan dalam skema tergantung pada kebutuhan proyek. Berikut mutasi dari contoh skema:

type Mutation {
  addPerson(id: ID!, name: String, age: Int): Person
}

Bid addPerson ang mewakili satu titik masuk yang menambahkan Person a ke sumber data. addPersonadalah nama bidang;id,name, dan age merupakan parameter; dan Person merupakan tipe pengembalian. Melihat kembali jen Person isnya:

type Person { 
  id: ID!
  name: String
  age: Int
  occupation: Occupation
}

Kami menambahkan occupation bidang. Namun, kita tidak dapat mengatur bidang ini secara Occupation langsung karena objek tidak dapat diteruskan sebagai argumen; mereka benar-benar tipe keluaran. Sebagai gantinya, kita harus meneruskan input dengan bidang yang sama sebagai argumen:

input occupationInput {
  title: String
}

Kami juga dapat dengan mudah memperbarui kami addPerson untuk memasukkan ini sebagai parameter saat membuat Person instance baru:

type Mutation {
  addPerson(id: ID!, name: String, age: Int, occupation: occupationInput): Person
}

Berikut skema yang diperbarui:

type Person { 
  id: ID!
  name: String
  age: Int
  occupation: Occupation
}

type Occupation {
  title: String
}

input occupationInput {
  title: String
}

type Mutation {
  addPerson(id: ID!, name: String, age: Int, occupation: occupationInput): Person
}

Perhatikan bahwa occupation akan melewati title bidang dari occupationInput untuk menyelesaikan pembuatan al Person ih-alih Occupation objek asli. Dengan asumsi kita memiliki implementasi resolver untukaddPerson, kita sekarang dapat melakukan mutasi yang sebenarnya. Sementara ti Mutation penya ada, kita harus secara eksplisit memanggilnya agar dapat berjalan dalam kode aplikasi. Ini dapat dilakukan dengan menggunakan mutation kata kunci:

mutation createPerson {
  addPerson(id: ID!, name: String, age: Int, occupation: occupationInput) {
    name
    age
    occupation {
      title
    }
  }
}

Mutasi ini disebutcreatePerson, dan addPerson merupakan operasi. Untuk membuat yang baruPerson, kita bisa memasukkan argumen untukid,name,age, danoccupation. Dalam lingkupaddPerson, kita juga dapat melihat bidang lain sepertiname,age, dll. Ini adalah tanggapan Anda; ini adalah bidang yang akan dikembalikan setelah addPerson operasi selesai. Berikut adalah bagian terakhir dari contoh:

mutation createPerson {
  addPerson(id: "1", name: "Steve Powers", age: "50", occupation: "Miner") {
    id
    name
    age
    occupation {
      title
    }
  }
}

Menggunakan mutasi ini, hasilnya mungkin terlihat seperti ini:

{
  "data": {
    "addPerson": {
      "id": "1",
      "name": "Steve Powers",
      "age": "50",
      "occupation": {
        "title": "Miner"
      }
    }
  }
}

Seperti yang Anda lihat, respons mengembalikan nilai yang kami minta dalam format yang sama yang ditentukan dalam mutasi kami. Ini adalah praktik yang baik untuk mengembalikan semua nilai yang dimodifikasi untuk mengurangi kebingungan dan kebutuhan akan lebih banyak kueri di masa mendatang. Mutasi memungkinkan Anda untuk memasukkan beberapa operasi dalam ruang lingkupnya. Mereka akan dijalankan secara berurutan dalam urutan yang tercantum dalam mutasi. Misalnya, jika kita membuat operasi lain addOccupation yang disebut yang menambahkan judul pekerjaan ke sumber data, kita dapat memanggil ini dalam mutasi setelahnyaaddPerson. addPersonakan ditangani terlebih dahulu diikuti olehaddOccupation.

Langganan digunakan WebSockets untuk membuka koneksi dua arah yang langgeng antara server dan kliennya. Biasanya, klien akan berlangganan, atau mendengarkan, ke server. Setiap kali server membuat perubahan sisi server atau melakukan acara, klien yang berlangganan akan menerima pembaruan. Jenis protokol ini berguna ketika beberapa klien berlangganan dan perlu diberitahu tentang perubahan yang terjadi di server atau klien lain. Misalnya, langganan dapat digunakan untuk memperbarui umpan media sosial. Mungkin ada dua pengguna, Pengguna A dan Pengguna B, yang keduanya berlangganan pembaruan pemberitahuan otomatis setiap kali mereka menerima pesan langsung. Pengguna A pada Klien A dapat mengirim pesan langsung ke Pengguna B pada Klien B. Klien Pengguna A akan mengirim pesan langsung, yang akan diproses oleh server. Server kemudian akan mengirim pesan langsung ke akun Pengguna B sambil mengirim pemberitahuan otomatis ke Klien B.

Berikut adalah contoh Subscription yang dapat kita tambahkan ke contoh skema:

type Subscription {                                   
  personAdded: Person
}

Bid personAdded ang akan mengirim pesan ke klien berlangganan setiap kali yang baru Person ditambahkan ke sumber data. Dengan asumsi kita memiliki implementasi resolver untukpersonAdded, kita sekarang dapat menggunakan langganan. Sementara ti Subscription penya ada, kita harus secara eksplisit memanggilnya agar dapat berjalan dalam kode aplikasi. Ini dapat dilakukan dengan menggunakan subscription kata kunci:

subscription personAddedOperation {
  personAdded {
    id
    name
  }
}

Langganan dipanggilpersonAddedOperation, dan operasinyapersonAdded. personAddedakan mengembalikan name bidang id dan Person instance baru. Melihat contoh mutasi, kami menambahkan Person menggunakan operasi ini:

addPerson(id: "1", name: "Steve Powers", age: "50", occupation: "Miner")

Jika klien kami berlangganan pembaruan untuk yang baru ditambahkanPerson, mereka mungkin melihat ini setelah di addPerson jalankan:

{
  "data": {
    "personAdded": {
      "id": "1",
      "name": "Steve Powers"
    }
  }
}

Di bawah ini adalah ringkasan dari apa yang ditawarkan langganan:

Langganan adalah saluran dua arah yang memungkinkan klien dan server menerima pembaruan yang cepat, tetapi stabil. Mereka biasanya menggunakan WebSocket protokol, yang menciptakan koneksi standar dan aman.

Langganan gesit karena mengurangi overhead pengaturan koneksi. Setelah berlangganan, klien dapat terus menjalankan langganan itu untuk jangka waktu yang lama. Mereka umumnya menggunakan sumber daya komputasi secara efisien dengan memungkinkan pengembang untuk menyesuaikan masa pakai langganan dan untuk mengkonfigurasi informasi apa yang akan diminta.

Secara umum, langganan memungkinkan klien untuk membuat beberapa langganan sekaligus. Dalam hal ini AWS AppSync, langganan hanya digunakan untuk menerima pembaruan real-time dari AWS AppSync layanan. Mereka tidak dapat digunakan untuk melakukan kueri atau mutasi.

Alternatif utama untuk langganan adalah polling, yang mengirimkan kueri pada interval yang ditentukan untuk meminta data. Proses ini biasanya kurang efisien daripada langganan dan menempatkan banyak tekanan pada klien dan backend.

schema {
  query: Query
  mutation: Mutation
  subscription: Subscription
}

.
.
.

type Query {                                   
  # code goes here
}
type Mutation {                                   
  # code goes here
}
type Subscription {                                   
  # code goes here
}