GraphQL, API sorgulama dilidir ve veri tabanından sadece gerekli bilgilerin getirilmesini sağlayarak ağ yükünü azaltır Query sorguları ise veri sorgulamak için kullanılır ve içinde parametreler bulunur Bu parametrelerle sıralama, sayfalama ve filtreleme işlemleri yapılabilir Bu sayede veri yönetimi kolaylaşır ve process'in verimliliği artar Query dışında mutation ve subscription gibi farklı sorgu türleri de vardır GraphQL'ın kullanımı oldukça esnektir ve projelerde ihtiyaca göre farklı Query'ler yazılabilir

GraphQL, bir API sorgulama dilidir ve sorgular dahilinde gelen verilerin yönetimini kolaylaştırır. Query, GraphQL içinde kullanılan ve özellikle veri sorgusu yapmak için kullanılan bir sorgu türüdür. Query sorguları sayesinde veri tabanından sadece gerekli olan bilgiler getirilebildiği için ağ yükü azaltılmış ve öğelerin gereksiz bilgileri yüklemesine engel olunmuştur.

Query içindeki parametreler belirli bir şema ve tip ile eşleştirilir. Bu nedenle kullanılan verilerin doğru tipte, doğru formatta ve istenilen sınırlama ile geldiği kontrol edilir. Bunun yanı sıra, Query sorguları için mutation gibi yeni bir sorgu oluşturmak yerine, mevcut Query'leri değiştirerek ve parametreler ekleyerek değişiklik yapılabilir.

Query içinde kullanılan parametreler arasında 'limit' ve 'offset' sayfalama işlemleri için, 'orderBy' sıralama işlemleri için, 'where', 'In' ve 'notIn' ise filtreleme işlemleri için kullanılır. Bunların yanı sıra, Query'ler içinde fragment adı verilen, birden fazla Query için aynı kodları kullanma imkanı sağlayan yapılar da vardır.

GraphQL Query yapısı, veri alışverişi sürecinde önemli bir rol oynar ve veri yönetimini kolaylaştırarak process'in verimliliğini arttırır. Query yapısının yanı sıra, mutation ve subscription gibi sorgular da mevcuttur ve farklı amaçlar için kullanılır.

Query Parametreleri

GraphQL Query'leri, API taleplerinde CRUD (create, read, update, delete) operasyonlarının yanı sıra belirtilen alanların, kaynakların, ilişkilerin ve birçok yönlü veri sorgulamalarının gerçekleştirilmesini sağlar. Bir Query yaparken kullanacağımız parametreler ise şunlardır:

• query: Sorgunun adı ve body'si
• variable: Bir değişken adı kapsülenerek kullanılan veri
• operationName: Query'ye özel bir çalıştırma adı
• directives: Query'ye özel direktiflerin kullanımı

Yukarıda saydığımız parametrelerin hepsi, GraphQL sistemini kullanırken sıkça karşılaştığınız ve kullanacağınız yapılar arasındadır. GraphQL Query'leri sorgulamalara olanak tanırken, bu parametreleri kullanarak verileri filtreleyebilir, sıralayabilir, varyasyonları oluşturabilir ve esnek bir şekilde veri taleplerinizi ayarlayabilirsiniz. Tüm bunlar, veri sorgulama işlemi sırasında büyük bir kontrol sahibi olmanızı sağlar.

Ayrıca, GraphQL Query'lerinde değişken kullanımı da oldukça yaygındır. Bunlar, Query içinde belirlenemeyen değişkenlerin kullanılması, gerektiğinde bir Query içinde birden fazla değişkenlerin kullanılabilmesi gibi durumlar için tasarlanmıştır. Bu sayede, herhangi bir Query'nin dinamik ve esnek bir şekilde çalışması ve farklı veri setlerini filtreleyerek işleme konulması mümkün kılınmıştır.

Query Örnekleri

GraphQL Query örnekleri, kullanım amaçlarına göre farklılık gösterir. İlk örneğimizde, tüm kitapların adını, yazar adını ve yayın tarihini getirmek isteyebiliriz. Bunun için şu şekilde bir kod kullanabiliriz:

query {  books {    title    author    publishedDate  }}

Bir diğer örnekte, yalnızca belirli bir kategorideki kitapları getirmek isteyebiliriz. Bunun için şu şekilde bir kod kullanabiliriz:

query {  books(category: "Roman") {    title    author    publishedDate  }}

Başka bir örnekte, belirli bir kitabın detaylarını getirmek isteyebiliriz. Bunun için şu şekilde bir kod kullanabiliriz:

query {  book(id: 123) {    title    author    publishedDate    description  }}

Gördüğünüz gibi, GraphQL Query örnekleri oldukça esnek ve kullanıcılara kolaylık sağlayacak şekilde tasarlanmıştır. Bu örneklerden hareketle, kendi projelerinizde de ihtiyacınıza uygun Query'ler tasarlayabilirsiniz.

Basit Bir Query Örneği

query { hello}

Query Variable'ları

Query Variable'ları, GraphQL Query'leri içinde kullanılan değişkenlerdir. Bu değişkenler, GraphQL Query'inin tekrar kullanılabilirliğini ve esnekliğini artırır. Query içinde değişkenleri kullanmak için, şu şekilde tanımlanır:

query getUser($id: ID!) { user(id: $id) { name email }}

Bu örnekte, "getUser" Query'si oluşturulurken "id" adında bir değişken tanımlanır. Bu değişken, "ID" tipinde bir veri almak zorundadır. Query'in geri kalanında, değişken kullanımı "$" işareti ile belirtilir. Örneğin, bu Query'de "$id" değişkeni, kullanıcının "id" değeriyle eşleşir.

Query Variable'ları manipülasyon sırasında farklı bir veriye göre kullanılabilir. Örneğin, birden fazla kullanıcının verisine erişmek için aynı Query'i kullanabilirsiniz, ancak değişkenleri farklılaştırarak. Bu, Query'in yalnızca birkaç değişkenle sınırlı kalmasını önler ve genel olarak daha işlevsel bir Query yaratır.

Ayrıca, Query Variable'ları kullanarak hata ayıklama yapabilirsiniz. GraphQL Query'inizde bir hata olduğunda, değişkenlerin değerlerini değiştirerek hata ayıklama sürecini kolaylaştıracak ve hatanın nedenini bulmak için zaman kazanacaksınız.

Genel olarak, Query Variable'ları, GraphQL Query'inin genel kullanılabilirliğini ve esnekliğini artıran çok önemli bir araçtır.

Query Dönen Veriler

GraphQL Query ile yaptığımız işlemler sonrası geri dönen verileri nasıl işleyebiliriz? Bu işlemi kolaylaştırmak için GraphQL, kullanıcıların sadece ihtiyaç duydukları verileri alabilmelerini sağlar.

Query sonrası dönen verilerin işlenmesi için, isteğe bağlı olarak fragment adı verilen yapıları kullanabilirsiniz. Fragments, bir Query içinde birden fazla kez kullanılan field yapısının tekrar tekrar yazılmamasını sağlar. Bu sayede, daha temiz ve anlaşılır kod yazabilirsiniz. Fragments kullanarak birden fazla Query sonucunun tek bir yerde kullanılabilmesi de mümkündür.

Ayrıca, Query sonucu dönen verileri filtrelemek de mümkündür. GraphQL, sunduğu filtreleme özellikleri sayesinde, sadece gerekli olan verileri geri döndürerek gereksiz veri trafiğini önler ve veri alışverişi hızını artırır.

Örneğin, bir kitap mağazası uygulamasında kullanıcıların yalnızca yazar adı ve kitap adı gibi belirli verileri alması için bir Query yapabilirsiniz. Bu sayede, gereksiz verilerin inmesini engelleyerek uygulamanın daha hızlı çalışmasını sağlayabilirsiniz.

GraphQL Query sonrası dönen verilerin diğer bir yöntemi ise, gelen verileri bir tablo şeklinde düzenleyebilirsiniz. Bu, verilerin daha anlaşılır olmasını sağlarken, elde etmek istediğiniz sonuçlara daha hızlı erişmenizi sağlar. Tablolarda sütun başlıklarını belirleyebilir, boş verileri görmezden gelebilir veya verileri filtreleyebilirsiniz.

GraphQL Query sonrası dönen verilerin işlenmesi konusunda daha fazla bilgi almak için, GraphQL dokümanlarını ve örneklere bakabilirsiniz.

GraphQL Fragments

GraphQL Query yaptığımızda, sonuç olarak kullanılan veriler birden fazla alan ve obje içerebilir. Bu nedenle, sonucun nasıl görüneceğini önceden bilemeyiz ve sadece gereksinimlerimizi tanımlayabiliriz. Bununla birlikte, her seferinde aynı alanları istemek yerine, daha sonradan kullanacakları sorgulayıcılar için tekrar kullanılabilir kod parçaları oluşturmak ihtiyacı doğar. İşte burada GraphQL Fragments devreye girer.

GraphQL Fragments basitçe, birden fazla sorguda yeniden kullanılabilen bir sorgu parçasıdır. Bu nedenle, sorgunun sonucunda dönen verileri filtrelemek için kullanılır.

Fragmentler, herhangi bir sorgu için bir "parça" olarak düşünülebilir. Sadece bayrak adı verilen bir anahtar ile tanımlanırlar. Query içindeki herhangi bir objeyi seçebilirler ve mesajın türüne bağlı olarak değişebilirler.

Aşağıdaki örnekte, "UserFragment" adlı bir fragment tanımlandı. Bu fragment, "User" objesi için kullanılır ve sonuçta ad, soyad ve e-posta adresi getirir. Bu fragment'in içeriği şöyle olabilir:

```fragment UserFragment on User { firstName lastName email}```

Bu fragment daha sonra Query içinde kullanılabilir ve sadece kullanılacak alanları seçmek için tekrar tekrar yazılması gerekmez:

```query { User(id: "123") { ...UserFragment }}```

Bu sayede, Query sonucunda dönen verilerin ya da fragmentlerin daha kolay anlaşılır, daha düzenli ve okunaklı hale getirilmesi sağlanır.

Query Sonucunu Filtrelemek

GraphQL Query yapılarında, Query sonrası dönen verileri işlemek için filtreleme yapmak oldukça sık kullanılan bir yöntemdir. Filtreleme yapılabilmesi için, Query içinde kullanılan parametrelerin değeri değiştirilerek sonuçların kontrol edilebilmesi mümkündür.

Örneğin, bir uygulamada kullanıcıların adlarına ve yaşlarına göre listeleme yapılmak istendiğinde, Query parametrelerinde bu bilgiler kullanılabilir. Bu şekilde, örneğin yaş parametresi 30 olarak değerlendirildiğinde, sadece 30 yaşındaki kullanıcılar listelenebilir.

Query sonrası dönen verileri işlemek için kullanılan bazı filtreleme yöntemleri aşağıda sıralanmıştır:

• Limit: Sadece belirli bir sayıda sonucun gösterilmesi sağlanır.
• Offset: Gösterimin başlangıç noktasının belirlenmesini sağlar.
• Distinct: Tekrarlanan sonuçların tek bir kez gösterilmesini sağlar.
• Order By: Sonuçların belli bir özelliğe göre sıralanmasını sağlar.
• Where: Verilerin belirli koşullara göre filtrelenmesine olanak tanır.

Bu yöntemlerden herhangi biri ya da birkaçı kullanılarak, Query sonrası dönen verilerin istenilen şekilde filtrelenmesi mümkündür. Böylelikle, uygulama performansı artırılabilir ve kullanıcılara daha iyi bir deneyim sunulabilir.

Özetle, GraphQL ile yapılan Query işlemlerinde sonuçların filtrelenmesi oldukça önemlidir. Query parametreleri üzerinde değişiklik yaparak farklı sonuçlar elde edilebilir ve kullanıcıların ihtiyaçlarına uygun veriler gösterilebilir. Bu da uygulamanın daha kullanıcı dostu ve performanslı hale gelmesine yardımcı olur.

GraphQL, sadece sorgu (query) oluşturmakla kalmaz, aynı zamanda veri manipülasyonu için de kullanılabilir. Bu noktada devreye mutation'lar girer.

Mutation'lar, API üzerinden bir kaynak üzerinde değişiklik yapılmasını sağlayan sorgu türleridir. Bu işlemler CREATE, UPDATE veya DELETE işlemlerini içerebilir.

• CREATE: Yeni bir kaynak oluşturma işlemi
• UPDATE: Var olan bir kaynağın güncellenmesi işlemi
• DELETE: Var olan bir kaynağın silinmesi işlemi

GraphQL Mutation'lar, query'ler gibi parametreler alır. Bu parametreler, işlem yapılacak kaynağı veya verileri belirlemek için kullanılır.

İşlem sonrasında, mutation sorgusu sonucu veri değiştirilir veya etkilenen kaynakların bilgileri alınır. Bu bilgiler, mutation sorgusunun sonucunda dönen verilerler şeklinde alınır.

GraphQL mutation'ları da query'lerle benzer şekilde örneklerle inceleyelim.

Mutation Parametreleri

Mutationlar, var olan veriyi değiştirme veya yeni veri oluşturma işlemlerinde kullanılır. Bu nedenle, mutation parametreleri, değiştirilecek veya oluşturulacak verinin özelliklerini belirtir. Mutation parametreleri, bir input object type olarak tanımlanır ve mutation içinde kullanılır.

Input object type yapısı, birbirleriyle ilgili birden fazla parametrenin saklanmasını sağlayan bir yapıdır. Bu yapı ile birlikte, mutation işlemlerinde birden fazla parametre belirtilerek, bu parametrelerin bir arada veri oluşumunu etkilemesi sağlanır. Örneğin, yeni bir kullanıcı oluşturmak için, kullanıcının adı, soyadı, e-posta adresi ve şifre gibi parametrelerin bir arada kullanılması gerekir. input object type yapısı sayesinde, bu parametreler bir arada kullanılır ve yeni bir kullanıcı oluşturulur.

Mutation parametreleri, veri tipi, isim ve nullability gibi özelliklere de sahiptir. Veri tipi, belirtilen parametrenin ne tür bir veri oluşturacağını belirler; isim, parametrenin nasıl adlandırılacağını belirler; nullability ise parametrenin zorunlu olup olmadığını belirler.

Aşağıdaki örnek, bir kullanıcının adını veya soyadını güncelleyen bir mutation kodudur. Bu örnek, “updateUser” isimli bir mutation, “UserInput” isimli bir input object type kullanır ve “name” ve “surname” isimli iki adet parametreye sahiptir.

```graphqlmutation updateUser($id: ID!, $input: UserInput!) { updateUser(id: $id, input: $input) { id name surname }}

input UserInput { name: String surname: String}```

Yukarıdaki örnekte, “UserInput” isimli bir input object type tanımlanmıştır. Bu input object type, “name” ve “surname” isimli iki adet parametreye sahiptir ve her ikisi de string veri tipindedir. “updateUser” isimli mutation, “id” ve “input” adlı iki adet parametre alır. “id” parametresi, güncellenecek kullanıcının kimliği, “input” parametresi ise, güncellenecek verileri içeren “UserInput” tipinde bir input object type’dır.

Mutation Örnekleri

GraphQL'nin olmazsa olmazlarından Mutation'ları kullanarak, verileri aynı şekilde güncelleme yapılabilir. İşte size GraphQL Mutation örnekleri.

Bu örnekte, basit bir Post türü oluşturarak başlayalım. Bunun için öncelikle şu kodları yazalım:

```type Post { id: ID! title: String! body: String!}```

Ardından, Post türünü ekleme işlemi için aşağıdaki kodları da yazmamız gerekiyor:

```type Mutation { createPost( title: String! body: String! ): Post}```

Eğer Mutation başarılı olursa, örnek bir dönüş değeri olarak Post türünden bir nesne döndürecektir. Şimdi, Mutation'u test etmek için aşağıdaki GraphQL isteğini gönderelim:

```mutation { createPost( title: "GraphQL Nedir?" body: "GraphQL, veri sorgulama dilidir." ) { id title body }}```

Ve sonuç olarak,```{ "data": { "createPost": { "id": "abc123", "title": "GraphQL Nedir?", "body": "GraphQL, veri sorgulama dilidir." } }}```

şeklinde bir yanıt almış oluruz.

Bu örnekte, bir Input Object Type kullanarak bir Post oluşturacağız. Input Object Types, Mutation'larda daha fazla parametre kullanmanıza olanak tanır. Bu örnekte kullanacağımız kodları aşağıda görebilirsiniz:

```input PostInput { title: String! body: String!}

type Mutation { createPost( post: PostInput! ): Post}```

Ve test etmek için kullanacağımız GraphQL isteği:

```mutation { createPost( post: { title: "GraphQL Nedir?" body: "GraphQL, veri sorgulama dilidir." } ) { id title body }}```

Sonuç olarak, yine bir Post türünden nesne almış oluruz.

Bu örnekler sayesinde, GraphQL Mutation kullanımını anlamış olduk. Geliştirmeler yaparak, isteklerimizi daha karmaşık hale getirebiliriz.

Basit Bir Mutation Örneği

GraphQL'de Mutation, verileri değiştirmek için kullanılan bir işlemdir. Bu işlem, sorgulara benzer bir yapıya sahiptir ancak sorgulardan farklı olarak verileri değiştirir. Bir Mutation işlemi, sunucu tarafında işlenerek değişikliklere neden olur.

Basit bir Mutation işlemi örneği aşağıdaki gibidir:

mutation { addProductToCart(productId: "123", quantity: 2) { cartTotal } }

Burada, addProductToCart isimli bir Mutation işlemi yapılıyor. Bu işlem, productId ve quantity parametrelerini alarak, sepete ürün ekliyor. Sonrasında, cartTotal verisi, işlem sonucunda dönen veriler arasında yer alıyor.

Bu örnekte, "mutation" anahtar sözcüğü kullanılarak Mutation işlemi başlatılır. İçinde "addProductToCart" gibi bir isim verilerek işlem tanımlanır. Sonrasında, işlemin alacağı parametreler girilir. Bu örnekte, ürünün "productId" ve eklenen ürün sayısının "quantity" parametreleri gösterilmiştir. Son olarak, işlem sonrasında dönen verileri belirlemek için cartTotal değeri kullanılır.

Bu örnek, en temel Mutation işlemlerinden biridir. Daha karmaşık işlemler için, Query işlemlerinde olduğu gibi, farklı parametreler, değişkenler ve daha fazla dönen değer kullanılabilir.

Input Object Types

Mutation'lar içinde kullanılan Input Object Types, içinde birden çok parametre barındıran bir veri yapısıdır. Her parametrenin türü ve adı tanımlanarak oluşturulur. Bu yapının kullanımı, birden fazla argümanın kullanılması gereken durumlarda oldukça kullanışlıdır. İnput Object Types, birden fazla parametrenin tek bir adreste toplanmasına izin verir ve çoğu zaman çok daha okunaklı bir kod yazımını sağlar.

Input Object Types, ayrıca GraphQL arayüzlerinde girilen verileri doğrudan nesnelere dönüştürmek için de kullanılabilir. Genellikle bir kullanıcının girdiği bilgileri bir arka uç API'sine aktarmak için kullanılır. Bu yapı, bir sınıf tanımlamasına benzer ve birçok kullanışlı özellik içerir.

Input Object Types yapısını oluştururken, her bir parametrenin türü ve adı belirtilmelidir. Örneğin, eğer bir kullanıcı sayfası oluşturma Mutation'ı varsa, Input Object Types içinde "ad", "soyad" ve "yaş" gibi parametreler tanımlanabilir. Bu sayede, bu üç parametrenin herbiri ayrı ayrı belirtilmek yerine tek bir nesnede toplanabilir.

Aşağıda, Input Object Types yapısının örnek bir kod bloğu verilmiştir:

input KullanıcıInput {  ad: String  soyad: String  yaş: Int}

Bu kod bloğunda "KullanıcıInput" adında bir Input Object Type tanımlanmıştır. Bu nesne, "ad", "soyad" ve "yaş" adında üç ayrı parametre alır. Bu parametrelerin türleri String ve Int olarak belirtilmiştir.

Input Object Types yapısı, GraphQL Query ve Mutation'larınızı daha da fonksiyonel hale getirirken aynı zamanda kod yazımınızı da daha okunaklı hale getirir. Kullanıcının girdiği verileri toplayan ve doğru formata dönüştüren Input Object Types, GraphQL arayüzlerinin güçlü bir özelliğidir.

Mutation Sonucu Dönen Veriler

GraphQL Mutation'ları ile yapılan işlemler sonucunda dönen veriler, Query'lerde olduğu gibi işlenmesi gereken verilerdir. Mutation sonucu dönen verilerin işlenmesi, birçok yöntemle gerçekleştirilebilir.

Öncelikle, Mutation sonucu dönen verilerin içeriğine bakılmalıdır. Bu verilerin istenilen formatta olup olmadığı kontrol edilmelidir. Eğer sorunsuz bir şekilde işlenmesi mümkün değilse, veri yapısı düzenlenmelidir.

Mutation sonrası dönen veriler, Query sonrası dönen verilerden farklı işlevlere sahip olabilir. Bundan dolayı, Mutation sonrası dönen verilerin nasıl işleneceği, işlevlerine göre değişebilir. Örneğin, bir Mutation sonucunda yeni bir kullanıcı oluşturulduğunu düşünelim. Bu durumda, yeni kullanıcının oluşturulduğuna dair bir onay mesajı veya kullanıcının ID'si gibi bilgiler dönebilir. Bu veriler, kullanıcıya gösterilmek üzere uygun bir şekilde formatlanmalı ve ekrana basılmalıdır.

GraphQL Mutation'ları kullanılırken, dönüş verilerinde fragmentlar ve alias'lar kullanılabilmektedir. Fragmentlar, Query'lere benzer şekilde kullanılabilir ve kod tekrarını azaltmak için oldukça faydalıdır. Alias'lar ise, aynı Mutation'da birden fazla parametre kullandığımızda, farklı dönüşler için ayrı bir sorgu yazmamıza gerek kalmadan, kolayca aynı Mutation'ı kullanmamıza olanak tanır.

Sonuç olarak, Mutation sonucu dönen verilerin işlenmesi, kullanım amaçlarına göre değişebilir. Ancak, verilerin istenilen formatta olduğundan emin olmak ve uygun bir şekilde formatlanmaları, her durumda önemlidir. Fragmentlar ve alias'lar gibi GraphQL yapılarının kullanımı, kod tekrarını azaltarak daha temiz ve okunaklı kod yazmamıza olanak tanır.

Optimistic Mutation

Optimistic Mutation, birçok durumda kullanıcılara daha hızlı bir geri dönüş sağlayarak performansı artırmak için kullanılır. Bu yöntemle, kullanıcı herhangi bir bekleme süresi olmadan değişikliklerini hemen görebilir.

Bu proses, optimizasyon için oldukça etkili bir yoldur. Optimistic Mutation kullanan uygulamalar, kullanıcıya öncelikle bir bekleme ekranı olmaksızın hızlı bir şekilde veri sunar ve ardından verilerinizin onaylanıp onaylanmadığını kullanıcıya bildirir.

Örneğin, bir kullanıcının tweetlerini güncellediği bir sosyal ağ sitesine bakalım. Bir çağrı yapıldığında, uygulama güncelleme işlemini gerçekleştirmeden önce değişikliklerin onaylanması için bir bekleme süresi sunar. Bu durumun Optimistic Mutation ile değiştirilmesi, kullanıcılara daha hızlı bir deneyim sunmaktadır. Öncelikle uygulama, değişiklikleri hemen gösterir ve onay alınana kadar yanıtı değiştirir.

Bu yöntem yaygın bir kullanıcı deneyimi tasarımı yöntemidir. Optimistic Mutation kullanarak, kullanıcıların hissettiği gecikme süresini en alt düzeye indirebilirsiniz. Hem kullanıcı memnuniyeti hem de verimlilik açısından önemlidir.

GraphQL Subscription

GraphQL Subscription, bir bağlantı noktası oluşturmak suretiyle gerçek zamanlı veri alışverişine izin verir. Subscription, sunucu tarafında yapılan herhangi bir değişikliği anında takip etmenizi sağlar. Örneğin, bir kullanıcının bir mesaj gönderdiği bir sohbet uygulamasını ele alalım. Bu mesaj tüm kullanıcılara gönderilebilir. Bu durumda Subscription, eklenen yeni mesajın gerçek zamanlı olarak tüm kullanıcılara gösterilmesini sağlar.

Subscription'ı çalıştırmak için GraphQL entegrasyonunun belirli bir parametresini kullanırız. Bu parametre, 'subscription' olarak da bilinir. Subscription iletimi yapısında yine tıpkı Query yapısında olduğu gibi alanlar belirlememiz gerekiyor. Subscription yapısı bize geri döndürülecek veri türlerinin de belirlenmesini içerir.

Örneğin, bir sohbet uygulaması tasarlıyorsanız, müşterinin sadece isim vererek belirli bir sohbet odasına katılmasını isteyebilirsiniz. Subscription yapısında, müşterilerin bu sohbet odasına katıldıklarında, sunucudan gerçek zamanlı haberleşme ile birlikte sohbet yapısı sağlanacaktır. Böylece, müşteriler ve sohbet odası arasındaki sohbet başarılı bir şekilde sağlanmış olacaktır.

Aynı zamanda Subscription yapısında kullanılan filtreleme yöntemleri tıpkı Query tarzında olduğu gibi kullanılabilir. Abone sayesinde veriler canlı olarak yayınlanırken, filtreleme özellikleri sayesinde sadece istenen verilere odaklanabilirsiniz.

GraphQL Subscription'ı, sunucu ve istemci tarafındaki bağlantı konusunda son derece etkili hale getirir. Veri alışverişine yönelik en uygun yöntemdir ve tüm güncellemeleri anlık olarak sunmak için en uygun seçenektir. Özellikle bir sohbet uygulaması gibi gerçek zamanlı veri alışverişi gerektiren uygulamalar için ideal bir çözümdür.