గ్రాఫ్‌క్యూల్ అనేది API ల కోసం ప్రశ్న భాష మరియు రన్‌టైమ్ పరిష్కరిణి, ఇది సంక్లిష్ట డేటాతో పనిచేసే సేవలకు మరింత నిర్మాణాన్ని అందించడానికి ఉపయోగించబడుతుంది. గ్రాఫ్‌క్యూల్‌తో, క్లయింట్లు తమకు అవసరమైన డేటాను మాత్రమే అభ్యర్థించవచ్చు మరియు మరేమీ లేదు.

తేడా ఏమిటంటే ఎవరు నమూనాను సెట్ చేస్తారు

సాంప్రదాయ REST API లలో API సర్వర్ ఉంటుంది, ఇది నిర్మాణాత్మక డేటాతో అభ్యర్థనలకు ప్రతిస్పందిస్తుంది, సాధారణంగా JSON రూపంలో ఉంటుంది. మీరు GET అభ్యర్థన చేస్తే a api.com/users/, మీరు ఈ క్రింది విధంగా ప్రతిస్పందనగా ఏదైనా స్వీకరించాలని ఆశిస్తారు:

{
  users: [
    {
      name: 'Anthony',
      friends: [...]
    }
  ]
}

మీ అనువర్తనం భిన్నంగా కనిపిస్తుంది, కానీ పాయింట్ ఏమిటంటే స్కీమా REST ఎండ్ పాయింట్ ద్వారా నిర్వచించబడుతుంది. మీరు ఇప్పుడే ఒక అభ్యర్థన చేసారు /users/, కానీ మీరు ఈ డేటా మొత్తాన్ని తిరిగి పొందారు.

ఏది ఏమైనప్పటికీ, మీరు ఏ డేటాను తిరిగి పొందుతారో మీకు తెలిస్తే మరియు వెబ్‌లోని చాలా సేవలకు ఇది ప్రామాణికం. అయితే, మీరు PUT అభ్యర్ధనలను చేస్తుంటే, అది పని చేయడానికి మీరు API ని సరైన పారామితులతో అందించాలి, లేకపోతే మీరు లోపాలకు లోనవుతారు. వాస్తవానికి, మీరు API కి విలువలను తిరిగి పొందటానికి URL పారామితులను ఉపయోగించవచ్చు, తిరిగి పొందటానికి వినియోగదారు ID వంటివి, మీరు API ని మరింత డైనమిక్ చేయడానికి ఉపయోగించవచ్చు.

గ్రాఫ్‌క్యూల్ API లు కొద్దిగా భిన్నంగా పనులు చేస్తాయి. వేర్వేరు ఎండ్ పాయింట్లకు వ్యక్తిగత అభ్యర్ధనలను చేయడానికి బదులుగా, ఇవన్నీ వేర్వేరు డేటాను సూచిస్తాయి, గ్రాఫ్క్యూల్ అప్లికేషన్ ఒకే మూలానికి ఒక అభ్యర్థనను పంపుతుంది. అభ్యర్థన బాడీ స్కీమాను కలిగి ఉంది మరియు ఏ డేటాను తిరిగి ఇవ్వాలో API కి చెబుతుంది. ఈ విధంగా, మీరు ఒక అభ్యర్థనలో సంక్లిష్ట డేటాను అభ్యర్థించవచ్చు మరియు API చెప్పినదానికంటే ఎక్కువ పంపదు, పెద్ద ప్రతిస్పందన పరిమాణాన్ని తగ్గిస్తుంది.

ఉదాహరణకు, మీరు నిర్దిష్ట వినియోగదారు యొక్క ఇమెయిల్ చిరునామాను అభ్యర్థించాలనుకుంటే, మీరు గ్రాఫ్క్యూల్ అభ్యర్థనను పంపవచ్చు api.com ఎండ్ పాయింట్, కింది ప్రశ్నతో:

{
  users(name: "Anthony") {
    email
  }
}

“వినియోగదారు” వస్తువు ఇతర సమాచారం కోసం ఫీల్డ్‌లను కలిగి ఉన్నా ఫర్వాలేదు; మీరు ఇమెయిల్‌ను మాత్రమే అభ్యర్థించినందున, మీరు ఇమెయిల్‌ను మాత్రమే స్వీకరిస్తారు. వాస్తవానికి, మీరు ఇప్పటికీ JSON ఆబ్జెక్ట్‌ను REST గా పంపుతున్నారు మరియు ఇప్పటికీ అదే విధంగా కమ్యూనికేట్ చేస్తున్నారు, కానీ అభ్యర్థనలు మరింత సమాచారంగా ఉన్నాయి.

సంక్లిష్టమైన స్కీమా ఉన్న అనువర్తనాల కోసం, సంస్థాగత కారణాల వల్ల ఈ రకమైన API చాలా ఉపయోగపడుతుంది. గ్రాఫిక్‌క్యూల్‌తో, API ని కాన్ఫిగర్ చేసేటప్పుడు మీరు మీ స్కీమాను ఖచ్చితంగా నిర్వచించవలసి వస్తుంది, స్టాటిక్ టైపింగ్ మిమ్మల్ని నిర్మాణాలు మరియు రకాలను పాటించమని బలవంతం చేస్తుంది. డేటా నిర్మాణం సులభంగా గుర్తించదగినది మరియు సవరించదగినది. ప్రామాణిక REST API లతో మీరు అదే ప్రభావాన్ని సులభంగా సాధించవచ్చు, కానీ గ్రాఫ్‌క్యూల్ దీన్ని వర్తిస్తుంది.

అలాగే, గ్రాఫ్‌క్యూల్ ప్రశ్నలు మరింత సమర్థవంతంగా పనిచేస్తాయి. ఉదాహరణకు, ఒక సాధారణ సమస్య “స్నేహితుల స్నేహితులు” అనే ప్రశ్న. REST API లో, మీరు సందేహాస్పదమైన వినియోగదారు కోసం ఒక అభ్యర్థనను పంపవలసి ఉంటుంది, ఆపై, వారి స్నేహితుల ID లను స్వీకరించిన తర్వాత, ప్రతి స్నేహితుడి సమాచారం కోసం వ్యక్తిగత అభ్యర్థనలను పంపండి, ఆపై మీకు కావలసిన ప్రతిదాన్ని ఫిల్టర్ చేయండి. వాస్తవానికి ఈ ప్రశ్నను డేటాబేస్ వైపు అమలు చేయడానికి మీరు కొత్త ఎండ్ పాయింట్‌ను అమలు చేయవచ్చు (కాని తప్పక), కానీ ఇది నిజమైన సమస్యపై ఒక పాచ్.

గ్రాఫ్‌క్యూల్‌తో, ఈ ప్రశ్న చాలా సులభం. ప్రతి స్నేహితుడికి మీరు పేరు కావాలని మీరు పేర్కొనాలి మరియు (బ్యాకెండ్ సరిగ్గా నిర్వహించడానికి కాన్ఫిగర్ చేయబడిందని అనుకుందాం) API ఈ పరస్పర చర్యను సహజంగా నిర్వహిస్తుంది, ప్రతి అభ్యర్థనకు ప్రత్యేక కాన్ఫిగరేషన్ లేకుండా.

{
  users(name: "Anthony") {
    friends {
      name
    }
  }
}

వాస్తవానికి, గ్రాఫ్క్యూల్ దాని లోపాలు లేకుండా లేదు. సాధారణ అనువర్తనాల కోసం, ప్రాథమిక REST ఎండ్ పాయింట్‌ను మార్చడం చాలా క్లిష్టంగా ఉంటుంది. అదనంగా, సాంప్రదాయ REST API తో, మీరు విభిన్న మార్గాలను విభజించగలిగే ప్రయోజనాన్ని పొందుతారు. ఉదాహరణకి, /users ఉంది /posts వాటిని ప్రత్యేక సర్వర్‌లెస్ లాంబ్డా ఫంక్షన్ల ద్వారా నిర్వహించవచ్చు మరియు ఒకదానికొకటి స్వతంత్రంగా ప్రాసెస్ చేయవచ్చు మరియు నవీకరించవచ్చు – ఈ భావనను మైక్రోసర్వీస్ బ్యాకెండ్ అని పిలుస్తారు. గ్రాఫ్‌క్యూల్ కోసం, దానిని ప్రత్యేక బ్లాక్‌లుగా విభజించడం చాలా కేంద్రీకృతమై మరియు చాలా కష్టం (అసాధ్యం కాకపోయినా).

మీరు ఎలా ప్రారంభిస్తారు?

గ్రాఫ్క్యూల్ వివిధ భాషల కోసం చాలా సర్వర్ లైబ్రరీలను కలిగి ఉంది, కానీ సాధారణంగా జావాస్క్రిప్ట్ మరియు నోడ్జెఎస్ లతో ఉపయోగిస్తారు.

గ్రాఫ్‌క్యూల్ ప్రశ్నకు రెండు విషయాలు అవసరం: నిర్మాణం మరియు డేటా రకాలను నిర్వచించే స్కీమా, మరియు ఒక ఇన్పుట్ తీసుకొని స్కీమాతో అనుబంధించబడిన విలువను తిరిగి ఇచ్చే పరిష్కరిణి. పరిష్కారంలో, డేటాబేస్ అభ్యర్థనలను పొందడం, డేటాను సవరించడం మరియు మీకు అవసరమైన ఏవైనా చర్యలను మీరు చేయవచ్చు, ఇవన్నీ స్కీమాకు చివరిలో సరిపోయే రిటర్న్ విలువలో ప్యాక్ చేసినంత వరకు.

సంక్లిష్టమైన అనువర్తనాల కోసం, స్కీమా మరియు దాని పరిష్కరిణి నిర్మాణం ఆధారంగా స్వయంచాలకంగా ఉత్పత్తి చేయబడతాయి, కాని చివరికి స్కీమా కేవలం ఒక రకం నిర్వచనం మరియు పరిష్కరిణి కేవలం స్కీమాలోని విభిన్న కీలను పరిష్కరించే ఫంక్షన్లతో కూడిన వస్తువు.

var { graphql, buildSchema } = require('graphql');


var schema = buildSchema(`
  type Query {
    hello: String
  }
`);


var root = {
  hello: () => {
    return 'Hello world!';
  },
};


graphql(schema, '{ hello }', root).then((response) => {
  console.log(response);
});

పూర్తి గ్రాఫ్‌క్యూల్ సర్వర్‌ను ఎలా సెటప్ చేయాలో మరింత సమాచారం కోసం, మీరు ఎక్స్‌ప్రెస్‌తో ఇన్‌స్టాల్ చేసి ఉపయోగించడంపై గ్రాఫ్‌క్యూల్ యొక్క గైడ్‌ను చదవవచ్చు.

Source link