Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ինչ պետք է իմանալ GraphQL-ի մասին 2024 թվականին

Մի քանի տարի GraphQL-ի հետ աշխատելուց հետո հեղինակը ցանկանում է կիսվել այս տեխնոլոգիայի վերաբերյալ իր դիտարկումներով և փորձով։

14 րոպե
ՃարտարապետությունԾրագրային ապահովման մշակումAPIGraphQL

GraphQL-ը տարիների ընթացքում դարձել է բավականին մեծ երևույթ։ Շատ մշակողներ ոգևորվեցին այս տեխնոլոգիայով, այդ թվում՝ ես։

Մի քանի տարի այս տեխնոլոգիայի հետ աշխատելուց հետո ցանկանում եմ կիսվել GraphQL-ի վերաբերյալ իմ դիտարկումներով և փորձով։

Սկսենք հիմնական սահմանումից. ի՞նչ է GraphQL-ը։

GraphQL-ը հարցումների լեզու է, որը թույլ է տալիս նշել, թե ինչ տվյալներ եք ստանալու հարցման պատասխանում։ Այն նաև տրամադրում է runtime, որը լուծում է այդ հարցումները ձեր առկա տվյալների դեմ։ Այդ տվյալները կարող եք պատկերացնել որպես գրաֆի հանգույցներ։ Օբյեկտները կարող են կապված լինել այլ օբյեկտների հետ, բայց ձեզ կարող է հետաքրքրել այդ հանգույցների միայն փոքր մասը։

Բավականին հեշտ է, այնպես չէ՞։ Հիանալի, եկեք խորանանք։

Ազատություն

GraphQL-ը թույլ է տալիս սերվիսի հաճախորդներին ազատորեն ընտրել, թե ինչ ստանան սերվերից։ Յուրաքանչյուր հարցման համար՝ լինի դա query, mutation թե subscription, դուք որոշում եք, թե ինչ տեղեկատվություն ստանալ և որ դաշտերը ձեզ պետք չեն։ Սրանք հարցումների միակ 3 տեսակներն են։ Query գործողությունները նախատեսված են տվյալներ կարդալու համար, Mutation գործողությունները՝ դրանք փոխելու, իսկ Subscription գործողությունները տրամադրում են իրական ժամանակի թարմացումներ, երբ հայտնվում են նոր տվյալներ։

Որպես հաճախորդ՝ դուք կարող եք մեկ query-ով խնդրել ձեզ անհրաժեշտ բոլոր տվյալները։ Եթե ձեզ հետաքրքրում են տվյալների միայն որոշ մասեր, կարող եք խնդրել հենց դրանք։ Ձեր համակարգի/UI-ի տարբեր մասերը կարող են ընտրել տարբեր տվյալներ։

Սա նշանակում է, որ API-ի մատակարարը կարիք չունի կանխատեսելու տվյալների օգտագործման յուրաքանչյուր եզրային դեպք։ Դա իսկապես լավ է աշխատում, երբ ձեր հանրային API-ն ունի շատ հաճախորդներ, քանի որ նրանք կարող են օգտագործել ձեր տվյալները բազմաթիվ տարբեր ձևերով։

Այս գաղափարը զգալի ազդեցություն ունի մեր մշակման գործընթացի վրա։ Թիմերը կամ թիմերի մասերը, օրինակ՝ backend-ը և frontend-ը, կարող են շփվել ավելի ասինխրոն։ Պատճառն այն է, որ մատակարարի և սպառողի միջև կա պայմանագիր՝ սխեմա (schema), որի մասին կխոսենք ավելի ուշ։

Իր բնույթով GraphQL-ը կապում է տվյալների օբյեկտները միմյանց հետ։ Այսպիսով, երբ օբյեկտին ավելացնում ենք դաշտ, այդ օբյեկտի տեսակը վերադարձնող յուրաքանչյուր query պատասխան այժմ կարող է ներառել լրացուցիչ դաշտ։ Կարիք չկա backend թիմին խնդրել ամեն endpoint-ում ավելացնել մեկ դաշտ։

Սխեմային նոր դաշտ ավելացնելը չի պահանջում տեղեկացնել սխեմայի բոլոր հաճախորդներին, քանի որ նրանք չեն օգտագործի այդ տվյալները։ Թեև, գուցե պետք է տեղեկացնեք, եթե միասին աշխատում եք որպես Թիմ։

Նշանակո՞ւմ է արդյոք սա, որ backend մշակողը կստեղծի հսկայական սխեմա և մնացածը կթողնի հաճախորդներին։ Բնավ ոչ։ Շատ դեպքեր կան, երբ որոշ հարցումներ պետք է օպտիմիզացվեն՝ ավելի շատ տվյալներ բերելու կամ դրանք ֆիլտրելու համար։

Ընտրության այս ազատությունը կարող է նաև զգալիորեն փոքրացնել ձեր payload-ը։ Օրինակ՝ Migrating to GraphQL: A Practical Assessment աշխատանքում, որտեղ հեղինակները GitHub API-ն REST-ից տեղափոխեցին GraphQL, payload-ը GraphQL-ին անցնելուց հետո նվազեց 93,5 դաշտից (մեդիանային արժեքներ) մինչև ընդամենը 5,5։ Արդյունքում պատասխանի չափը GraphQL-ին անցնելուց հետո իջավ 9,8 ՄԲ-ից (մեդիանային արժեքներ) մինչև ընդամենը 86 ԿԲ։ Սա հիանալի լուր է մոբայլ հավելվածների համար, որոնք API են կիսում վեբ հավելվածների հետ։

Հենց դրա համար էլ GraphQL-ը ստեղծվել է առաջին հերթին։ Ահա Facebook-ի ամենավաղ հոդվածը դրա մասին։

Սխեմա

Ես արդեն նշեցի սխեման։ Ինչ-որ իմաստով դա այն տեղն է, որտեղ մշակողները կարող են համաձայնության գալ, թե ինչպիսին կլինեն query-ները/subscription-ները և mutation-ները։ Ինձ համար դա GraphQL-ի ամենամեծ առանձնահատկություններից մեկն է։ Դրա ստեղծումը անխուսափելի է։ Եվ նույնիսկ եթե այդպես չլիներ, չպետք է բաց թողնեիք այն, քանի որ այն ձեզ վերահսկողություն է տալիս մշակման գործընթացի նկատմամբ և սահմանում է պայմանագիր API-ի մատակարարի և նրա հաճախորդների միջև՝ լինի դա front-end թիմակից, մեկ այլ մայրցամաքի թիմ, թե նույնիսկ արտաքին ընկերություն։

GraphQL սխեման խիստ տիպավորված է, ուստի գործիքները կարող են օգնել մեզ ստուգել, թե արդյոք հարցումը համապատասխանում է սխեմային։ GraphQL սերվերը նույնպես վավերացնում է հարցումները։ Մատակարարները հենվում են սխեմայի վրա՝ սերվիս ճիշտ մուտքակետեր կառուցելու համար։

Սխեման ունի հիերարխիկ կառուցվածք, ինչը նշանակում է, որ որոշ դաշտեր կարող են ներդրված լինել (custom տեսակներ)։ Սա թույլ է տալիս խուսափել սերվիսին բազմաթիվ հարցումներից, հատկապես երբ տվյալները բերվում են մեկ հանգույցի/aggregate-ի շուրջ։ Այդուհանդերձ, միշտ չէ, որ հնարավոր կլինի անցնել գրաֆով և հավաքել ամեն ինչ։ Որոշ հանգույցներ GraphQL սխեմայում կապված չեն։ Այդպիսի դեպքերում կարող ենք լուծել՝ մեկ հարցման մեջ մեկից ավելի գործողություն կատարելով։

Սխեման հաճախորդներին տրամադրելու մի քանի եղանակ կա։ Կարող եք նրանց ուղարկել ֆայլ, կամ հաճախորդը կարող է սխեման բերել introspection query-ով։ Լավ պրակտիկա է անջատել introspection query-ները ձեր production սերվիսում։

Այս հոդվածը բացատրում է, թե ինչու և ինչպես դա անել։

Սխեման հաճախ թեթևացնում է մեր բեռը, երբ այլապես կմտածեինք What endpoint should I query for this use case? Սա այլևս իմ հոգսը չէ. GraphQL-ը ինձ տալիս է սխեմա, և եթե տեղեկատվությունը դրա մեջ է, ես կարող եմ այն բերել։

Կոդի գեներացիա

Քանի որ GraphQL-ը մեզ տալիս է սխեմա՝ աշխատելու համար, գործիքները կարող են գեներացնել կոդում օգտագործվող կառուցվածքներ ինչպես Backend-ում, այնպես էլ Frontend-ում։ Այս պարզ հնարավորությունը փրկում է ձեզ դասերի ձանձրալի ստեղծումից/խմբագրումից ամեն անգամ, երբ սխեման փոխվում է։ Օրինակ՝ Java-ում կարող եք օգտագործել graphql-java-codegen։ Սա կարող է հատկապես օգտակար լինել ավելի մեծ նախագծերում, որտեղ մենք չգիտենք սխեմայի յուրաքանչյուր փոփոխության մասին։ Մենք պարզապես քաշում ենք սխեմայի վերջին տարբերակը, վերակառուցում ենք կոդը, և ամեն ինչ արդիական է։ Այն նաև պաշտպանում է մեզ չնչին սխալներից, ինչպիսիք են դաշտերի անուններում տառասխալները։ Կոդի գեներացիան, ամենայն հավանականությամբ, ձեզ ժամանակ կխնայի։

Էվոլյուցիա

GraphQL-ը նկարագրվում է որպես version free, ինչը նշանակում է, որ եթե ամեն ինչ ճիշտ անեք, ձեր սխեման տարբերակավորելու կարիք չկա։

Facebook-ի կողմից երեք տարվա ընթացքում թողարկված հավելվածները դեռ աջակցվում են մեր GraphQL API-ի մեկ և նույն տարբերակի վրա։
GraphQL – a data query language

Ինչպե՞ս դա կարող է աշխատել։

Նոր դաշտ ավելացնելը ոչ մի պայմանագիր չի խախտում. հաճախորդը նույնիսկ չի էլ իմանում, որ այդ նոր դաշտերը կամ query-ները գոյություն ունեն, չէ՞։

Լավ, իսկ ֆունկցիաների հեռացո՞ւմը։ Հենց այստեղ է @Deprecated դիրեկտիվը փրկում վիճակը։

Նախ բացատրենք, թե ինչ է դիրեկտիվը**։**

Որքան հնարավոր է պարզ ասած՝ դա լրացուցիչ տեղեկատվության կտոր է, որը կարող եք ներառել սխեմայում։ Դիրեկտիվների շուրջ կարող եք նաև տրամաբանություն կառուցել, ինչը նրանց դարձնում է բավականին հզոր։

Հիմա վերադառնանք @Deprecated-ին։

@Deprecated դիրեկտիվի օգտագործումը

Այն հաճախորդներին ազդարարում է, որ սխեմայի այս հատվածն այլևս չպետք է օգտագործվի։ Սակայն դաշտը մնում է մեր սխեմայում նույնիսկ @Deprecated նշվելուց հետո, և տարիների ընթացքում կարող ենք կուտակել դրանցից բավականին շատ։ Ահա թե ինչու պետք է հետևենք, թե ինչպես է օգտագործվում մեր սխեման։ Երբ համոզվեք, որ ոչ ոք այլևս չի օգտագործում դաշտը, կարող եք այն հեռացնել։

Observability-ն արժանի է առանձին բլոգ գրառման, բայց գուցե ցանկանաք ծանոթանալ Apollo Studio-ին, որը թույլ է տալիս դիտել վիճակագրություն ձեր սխեմայի, հարցումների, խափանումների մակարդակի և շատ այլ բաների մասին՝ օգնելով գնահատել, թե արդյոք դաշտը կարելի է հեռացնել։

GraphQL սխեմայի էվոլյուցիան աստիճանական գործընթաց է, այլ ոչ թե մեծ պայթյունավոր փոփոխություն։

Բնականաբար, եթե փոքր թիմում եք կամ լավ եք շփվում ձեր հաճախորդների հետ, կարող եք հեռացնել դաշտը, երբ երկու կողմերը պատրաստ են, առանց երկարակյաց @Deprecated դաշտեր պահելու։ Ինչպես միշտ, ամեն ինչ կախված է հանգամանքներից։

Անարդյունավետ հարցումներ

GraphQL-ը մեզ տալիս է շատ ազատություն և հնարավորություններ, բայց, ինչպես միշտ, ոչինչ անվճար չի լինում։ Մեր սխեմայի օբյեկտների մեծ մասը կապված է, ինչը կարող է հանգեցնել նրան, որ որոշ մշակողներ ցանկանան բերել բոլոր տվյալները։ Դրան գումարվում է, որ որոշ տվյալներ կարող են ներդրված լինել, և մենք կարող ենք բերել նաև դրանք։

Այսպիսով, ո՞րն է խնդիրը։ Տվյալները սխեմայում են, ուրեմն ինչո՞ւ չեմ կարող պարզապես քաշել դրանք։

GraphQL-ի տեսանկյունից յուրաքանչյուր դաշտ ֆունկցիա է։ Հաճախ այս resolver մեթոդը շատ պարզ է՝ պարզապես օբյեկտի getter։ Backend գործիքները հաճախ դա թաքցնում են մեզանից, քանի որ մենք գործ ունենք միայն օբյեկտների հետ։ Սակայն որոշ դաշտեր տարբեր են. դրանք պահանջում են ինչ-որ բան հաշվարկել կամ լրացուցիչ հարցում ուղարկել մեկ այլ սերվիս՝ պարզապես այն պատճառով, որ այդ տվյալները գտնվում են այլ տեղում։ Դժվար է ասել, թե որ դաշտերն են «թանկ»։

Օրինակ՝

User հանգույցի օրինակ

Կարո՞ղ ենք հեշտությամբ ասել, թե այս դաշտերից որոնք են լրացուցիչ հարցումներ պահանջում։ Հավանաբար accountNumber-ը, այնպես չէ՞։ Բայց գուցե name և lastName դաշտերը անվտանգության նկատառումներով ինչ-որ ծածկագրում (obfuscation) են պահանջում։ Կամ գուցե ընդհանրապես լրացուցիչ հարցումներ կամ հաշվարկներ չլինեն։ Մենք երբեք չենք կարող վստահ լինել, թե ինչ է տեղի ունենում մեր կանչից հետո։ Այս օրինակը շատ պարզ է՝ ընդամենը չորս դաշտով։ Իսկ ի՞նչ, եթե ունենայինք 20 դաշտ custom ներդրված տեսակներով։ Դա շատ ավելի դժվար կլիներ։

Ի՞նչ է բխում դրանից։

N+1 խնդիր

Հնարավոր N+1 խնդրի օրինակ

Մենք կարող ենք մեր User-ին ավելացնել նոր դաշտ, որը պարունակում է տվյալ User-ի բոլոր վարկային քարտերը։ Ամեն անգամ, երբ բերում ենք User, կարող ենք բերել նաև օգտատիրոջ քարտերը։ Այստեղ սերվերը կցանկանա այդ հավաքածուի յուրաքանչյուր տարրը բերել առանձին, ինչը կարող է հանգեցնել N+1 խնդրի։

Նման խնդիրները կարելի է լուծել data loader-ներով։ Դա լրացուցիչ բերման մեխանիզմ է, որը թույլ է տալիս ձեր սերվերին խմբավորել հանգույցները և խնդրել դրանք բոլորը միանգամից։

Կախվածությունների դժոխք

Մեկ այլ հնարավոր խնդիր այն է, որ ամբողջական օբյեկտների բերումը կարող է առաջացնել բազմաթիվ հարցումներ բազմաթիվ սերվիսների նկատմամբ՝ ընդամենը մեկ GraphQL օբյեկտ ստանալու համար։ Բայց արդյո՞ք հաճախորդն է մեղավոր, որ ցանկանում է այնպիսի դաշտ, ինչպիսին հաշվեհամարն է։ Իհարկե ոչ։ Ուրեմն ինչպե՞ս լուծել սա։

Ես տեսել եմ մշակողների, ովքեր հակվում են դեպի «աստվածային» տեսակներ սխեմաներում։ Մշակման ընթացքում, օրինակ, մեր User տեսակը կարող է վերածվել այսպիսի հրեշի՝

Հսկայական հանգույցի օրինակ

Ամբողջական User օբյեկտի բերումը ցավոտ կլինի, չէ՞։ Այս դաշտերից շատերը բավականին բարդ են և կարող են լրացուցիչ query պահանջել որևէ սերվիսի նկատմամբ։ Երբեմն որոշ դաշտեր ստանալը կարող է նույնիսկ նշանակել հարցում ուղարկել արտաքին ճշմարտության աղբյուրին (օրինակ՝ պետական սերվերներին)։

Հավանաբար ոչ մի view-ին այս ամբողջ տեղեկատվությունը պետք չէ։ Ուրեմն ի՞նչ կարող ենք փոխել։ Կարող ենք փոխել ներքևի տվյալների կառուցվածքը (տվյալների բազա կամ սերվիսներ) կամ վերևի սխեման։

Հնարավորության դեպքում խուսափեք տվյալների բազայի սխեման փոխելուց։ API-ի և տվյալների բազայի խիստ կապվածությունը այն է, ինչից պետք է խուսափել։ Մի տարբերակ է տվյալները մի սերվիսից տեղափոխել մյուսը։ Դա կարող է աշխատել, բայց հիշեք, որ սերվիսները տվյալներ հավաքելուց բացի ունեն նաև այլ պատասխանատվություններ՝ նրանք զբաղվում են մասշտաբավորմամբ, բիզնես տրամաբանությամբ, bounded context-ներով և այլն։

Մեկ այլ տարբերակ է կառուցել read model այս կոնկրետ տեսակի համար։ Դա կարող է լավ աշխատել, թեև կարող եք բախվել eventual consistency խնդիրների՝ կարդալիս։

Վերջին միջոցը GraphQL սխեմայի փոփոխությունն է։

Ձեր սխեման UI-ի վրա հիմնելը լավ գաղափար չէ։ Փոխարենը կարող ենք վերցնել domain-driven design-ի հասկացություններ, հատկապես ubiquitous language-ը։ Սահմանմամբ դա բիզնեսի և մշակման թիմերի ընդհանուր եզրույթների հավաքածու է, որը երկուսն էլ պետք է հասկանան նույն կերպ։

Այսպիսով՝ փորձենք մեր User-ը բաժանել մի քանի առանձին հասկացությունների։

(Եթե աշխատում եք բանկային ոլորտում, հավանաբար իմ անվանումները ձեզ ծիծաղելի կթվան. ներողություն դրա համար :) )

Այս բաժանումը հետևում է մի քանի տարբեր համատեքստերի, որոնք կարող են հանգեցնել առանձին հավելվածների կամ view-ների՝ տարբեր տեսակի օգտատերերի համար։ Մարդիկ, ովքեր ձեզ հիփոթեք են տրամադրում, հավանաբար նույն մարդիկ չեն, ովքեր կապվում են ձեզ հետ վարկային քարտերի հարցով։

Բացի այդ, յուրաքանչյուր տեսակի տեղեկատվություն կարող է գալ տարբեր տեղից։ Օրինակ՝ SecurityInformation-ը պարունակում է տեղեկատվություն այն մասին, թե արդյոք հաճախորդները կոտրվել են։ Այդպիսի տվյալները չեն պատկանում debt ոլորտին, չէ՞։

Այս պահին այս տեսակներից շատերը կապված չեն։ Եթե բաժանումը լավ է արված, դա լավ բան է։ Յուրաքանչյուր query այժմ պարզապես տեղեկատվություն կբերի մեկ տեղից (սերվիս/read-model) հնարավորինս արագ։

Կարո՞ղ է դա իրագործվել production-ում։ Հավանաբար ոչ. դուք, ամենայն հավանականությամբ, դեռ կունենաք կապեր տեսակների միջև, ինչպես MortgageInfromation-ում։ Սակայն ձեր նպատակը պետք է լինի նվազեցնել դրանց քանակը։

Արդյո՞ք տվյալների աղբյուրը սխեմայի օբյեկտները բաժանելու լավագույն և միակ չափանիշն է։ Այն լավ չափանիշ է, բայց պետք է նկատի ունենալ նաև կարդալու իրավունքները։

Ի՞նչ եմ ես տեսնում

Ամեն անգամ, երբ մշակում ենք օգտատիրոջ հարցում, պետք է ստուգենք, թե ով է այդ օգտատերը և արդյոք նա ունի համապատասխան թույլտվություններ՝ որոշակի տվյալներ բերելու համար։ Դիտարկենք մեր Account տեսակը հիմա։

Ենթադրենք՝ loans դաշտը կարող են բերել միայն օգտատերերի մի քանի տեսակներ։ Ի՞նչ պետք է պատահի, երբ ամբողջ օբյեկտը բերող օգտատերը այդ դաշտի հասանելիություն չունի։ Արդյո՞ք պետք է բացառություն նետել։ Դա ճիշտ է թվում, քանի որ սերվերի կողմում ինչ-որ բան սխալ է գնացել։ Կա նաև մեկ այլ մոտեցում՝ վերադարձնել մասնակի օբյեկտ։ Այդ դեպքում բոլոր դաշտերը հասանելի կլինեն, բայց ի՞նչ արժեք կունենա loans դաշտը։ Կարող ենք վերադարձնել null, բայց սխեմայի «!»-ը ասում է, որ դաշտը երբեք null չի լինի։ Գուցե ուրեմն պետք է վերադարձնել դատարկ ցուցակ։

Սա փոքր, բայց նշանակալի որոշում է, քանի որ կարող է անհամապատասխանություն մտցնել մեր հավելվածում։ Որոշ հաճախորդներ այժմ կարող են ստանալ վարկերի դատարկ ցուցակ, թեև վարկեր գոյություն ունեն։ Ձեր օգտատերը կարող է բիզնես որոշում կայացնել այդ տվյալների հիման վրա։ Այնքան էլ լավ չէ, չէ՞։

Գուցե եթե ես Account տեսակի հասանելիություն ունեմ, պետք է կարողանամ բերել յուրաքանչյուր դաշտ։ Այդ դեպքում թույլտվությունները կգտնվեն query-ի արմատային տեսակի վրա։ Դա հետաքրքիր մոտեցում է, որը պարզեցնում է հեղինակման խնդիրը։

Բնականաբար, դրա գինը կա. դա անելը կարող է API-ի նախագծումը զգալիորեն սահմանափակել։ Երբ տիրույթը փոխվի, մենք դեռ կարող ենք նույն իրավիճակում հայտնվել։ Custom դիրեկտիվը կարող է օգնել ձեր API սպառողներին։ Մենք քննարկեցինք @Deprecated դիրեկտիվը, բայց կարող եք գրել նաև ձեր սեփականը։ Օրինակ՝ կարող եք ստեղծել @hasRole անունով դիրեկտիվ, որը վերցնում է պահանջվող դերը և ապա runtime-ում ստուգում է, թե արդյոք օգտատերն այն ունի։

Custom դիրեկտիվի օրինակ

Անվտանգություն

Արդյո՞ք GraphQL-ն անվտանգ է։ Ինչպես միշտ, պատասխանը պետք է լինի «Կախված է»։ Բայց գրազ կգամ՝ հոգնել եք դա լսելուց։ Ուրեմն վերաձևակերպեմ հարցը. «Արդյո՞ք իմ հավելվածը անվտանգ կլինի, եթե պարզապես ավելացնեմ GraphQL ստեկին»։ Այդ դեպքում պատասխանը ոչ է։ Ինչպես հաճախ լինում է, երբ օգտատերերին շատ ազատություն ենք տալիս, նրանք կարող են այն օգտագործել ձեզ վնասելու համար։ Հաճախակի սխալ է production-ում introspection query-ն միացված թողնելը, ինչը մեր արտադրանքի օգտատերերին թույլ է տալիս բերել query-ներ և տվյալներ, որոնք նրանք երբեք չպետք է տեսնեն։ Նման սցենարում custom դիրեկտիվները, ինչպիսին @hasRole-ն է, շատ բան են բացահայտում պոտենցիալ հարձակվողներին։

Սա կարևոր թեմա է, որը պետք է խորությամբ ուսումնասիրել, և այն արժանի է առանձին հոդվածի։ Մի անտեսեք այն, քանի որ այն կարող է մեծ վնաս հասցնել ձեր production-ին։

Այդուհանդերձ, եթե ցանկանում եք GraphQL-ի խոցելիությունների մասին սովորել անվտանգ միջավայրում, խորհուրդ եմ տալիս Damn Vulnerable GraphQL Application նախագիծը։ Դա hack me հավելված է, լի խոցելիություններով, որոնք կարելի է շահագործել։ Հաճելի ժամանց :)

GraphQL իրականացումներ

Հիշեք, որ GraphQL սերվերի ոչ բոլոր իրականացումներն են անպայման աջակցում բոլոր հնարավորություններին։

Ինչո՞ւ։ GraphQL-ի սպեցիֆիկացիան գրվել է 2015 թվականին, և դրա վերջին պաշտոնական թարմացումը եղել է 2021 թվականին։ Մեր ոլորտը անընդհատ զարգանում է, ուստի որոշ որոշումներ պետք է կայացվեին։

Վերցնենք, օրինակ, այն հարցը, թե ինչ HTTP պատասխանի կարգավիճակ վերադարձնել։ Կարող եք ենթադրել 200, և իսկապես 200 OK-ն «ընդհանուր պրակտիկա» է, բայց GraphQL spec-ը ոչ մի տեղ չի ասում, թե սերվերը ինչ կոդ պետք է վերադարձնի։ Հետևաբար որոշ գործիքներ սխալների համար օգտագործում են տարբեր կոդեր։

Graphlq-helix-ը կամ Netlix-dgs-ը դրան այլ մոտեցում են ցուցաբերում։

Որոշ մշակողներ սա խնդրահարույց են համարում, ուստի գրել են RFC (դեռ նախագիծ), որը նկարագրում է, թե ինչպես պետք է GraphQL-ը սպասարկվի և սպառվի HTTP-ի վրայով։

Տարբերությունները չեն սահմանափակվում կարգավիճակի կոդերով։ Որոշ իրականացումներ անվտանգությունը մշակում են այլ կերպ կամ նույնիսկ ավելացնում են լրացուցիչ տեսակներ։ Արժե դա նկատի ունենալ։

Ամփոփում

GraphQL-ը հիանալի տեխնոլոգիա է, որն արժե ուսումնասիրել։ Խորհուրդ եմ տալիս փորձարկել այն կամ պարզապես ծանոթանալ Apollo-ի անվճար ուսուցողական նյութերին։ Այն կարող է ձեզ նոր հայացք տալ API-ների և մշակման գործընթացի վերաբերյալ։

Հիշեք, որ նույնիսկ երբ ինչ-որ բան դրսից զարմանալի է թվում, production-ում օգտագործելուց առաջ պետք է ավելի մանրակրկիտ ուսումնասիրեք դրա հնարավոր գինը։ Հաջողություն։