{"canonical_url":"https://engineer.company/sv/glossary/graphql/","content_markdown":"# GraphQL\n\n## Vad det är\n\nGraphQL är ett frågespråk för API:er tillsammans med den körmiljö som utför\nfrågorna på servern. Klienten skickar ett dokument som namnger exakt de fält den\nvill ha, och servern svarar med data i samma form. Specifikationen beskriver det\nsom ett språk och en exekveringsmotor för klient-server-program. Den anger att\nGraphQL skapades 2012, att arbetet med det som öppen standard inleddes 2015 och\natt det sedan 2019 är en leverans från GraphQL Specification Project under Joint\nDevelopment Foundation. Den senaste utgåvan är från september 2025.\n\nAllt utgår från det schema som en tjänst publicerar: en uppsättning typer, var\noch en med namngivna fält, och varje fält med en egen typ. De inbyggda\nskalärtyperna är `Int`, `Float`, `String`, `Boolean` och `ID`, och en tjänst kan\nlägga till egna skalärer, till exempel en för UUID:er. Varje typ får vara null\nom den inte är märkt med `!`, så en `String!` kan aldrig vara null, och listor\nskrivs inom hakparenteser: `[LineItem!]!` är en lista som alltid finns och\naldrig innehåller null. Även själva schemat går att ställa frågor till. Genom\nintrospektionsfälten `__schema` och `__type` kan en klient fråga en tjänst vad\nden erbjuder, och utvecklarverktyg och klientbibliotek bygger just på det.\n\nDet finns tre sorters operationer. En `query` är med specifikationens ord ”a\nread-only fetch”, alltså en hämtning som bara läser; en `mutation` är en\nskrivning följd av en hämtning; och en `subscription` är en långlivad förfrågan\nsom levererar data som svar på en följd av händelser över tid. På servern står\nen funktion bakom varje fält, oftast kallad en resolver, och den tar fram\nfältets värde. Tjänsten validerar först en operation mot schemat och anropar\nförst därefter resolverfunktionerna för de fält som operationen har valt.\nToppnivåfälten i en `mutation` körs ett i taget i stället för parallellt, så att\ntvå skrivningar i samma förfrågan inte kan krocka med varandra.\n\nSpecifikationen föreskriver varken transport eller serialiseringsformat. HTTP är\ndet vanligaste valet, och där ligger ett GraphQL-API på en enda URL, oftast med\nändelsen `/graphql`, och svarar i JSON, det vanligaste formatet. Klienten\nskickar en POST vars JSON-kropp innehåller `query`-texten och vid behov dess\n`variables`. En server får också ta emot GET för `query`-operationer, men en\n`mutation` måste alltid skickas som POST. Svaret har resultatet under `data` och\nallt som gick fel under `errors`. GraphQL Foundations vägledning om allt detta\nföljer en GraphQL-over-HTTP-specifikation som fortfarande är ett utkast.\n\n## Varför det spelar roll\n\nI de flesta HTTP-API:er är det servern som bestämmer vad varje slutpunkt\nreturnerar. En skärm som behöver en orders status och kundens namn får antingen\nhela ordern och hela kunden, alltså mer än den bad om, eller måste skicka en\nförfrågan per resurs och själv foga ihop svaren. Specifikationen kallar de två\nproblemen over-fetching och under-fetching. GraphQL vänder på det: klienten\nfrågar på nivån av enskilda fält och får exakt de fälten tillbaka, varken mer\neller mindre. En förfrågan kan också följa relationer, från en order till dess\norderrader och vidare till kunden, eftersom förfrågan har samma form som de data\nden får tillbaka.\n\nTypsystemet lönar sig två gånger. Varje operation valideras mot schemat innan\nnågon resolver körs, så ett felstavat fält eller ett argument av fel typ avvisas\ni sin helhet innan något alls har utförts, och verktyg kan fånga samma misstag\nmedan koden fortfarande skrivs. Och eftersom en klient bara får de fält den har\nvalt kostar ett nytt fält ingenting för befintliga klienter. Det gör det\npraktiskt att vidareutveckla ett API utan versionsnummer: ett nytt fält dyker\nupp bredvid det gamla, det gamla märks med `@deprecated` och en motivering, det\nförblir giltigt så att befintliga klienter inte går sönder, och det tas bort när\ningen klient använder det längre.\n\nKostnaderna är verkliga, och de flesta kommer av att man kliver utanför det\nmaskineri som HTTP själv har. Entiteter identifieras inte längre av URL:er, och\nallt går till en enda adress, oftast med POST, medan det är GET-förfrågningar\nsom i regel räknas som cachebara som standard. Den cachning som ett REST-API får\ngratis från mellanleden måste byggas upp igen med avsikt. Statuskoden berättar\ninte längre hela historien, för ett svar med både data och fel är fortfarande en\nframgång på HTTP-nivå. Klienten sätter nu ihop förfrågningar som servern aldrig\nhar sett, så en enda förfrågan kan begära mycket arbete, och att skydda servern\nmot det är tjänstens uppgift, inte något GraphQL gör åt den. Resolverfunktioner\nper fält är lätta att skriva, men skrivna naivt blir de mycket pratsamma mot\ndatabasen bakom dem.\n\n## Så ser det ut i praktiken\n\nEn liten del av ett schema för ordrar, var och en med orderrader och en kund:\n\n```graphql\ntype Query {\n  order(id: ID!): Order\n}\n\ntype Order {\n  id: ID!\n  status: String!\n  items: [LineItem!]!\n  customer: Customer\n}\n\ntype LineItem {\n  name: String!\n  quantity: Int!\n}\n\ntype Customer {\n  name: String!\n}\n```\n\nEn skärm som visar status, orderraderna och kundens namn skickar den här\noperationen till `/graphql` i kroppen på en POST, med `{\"id\": \"7421\"}` som\nvariabler:\n\n```graphql\nquery OrderSummary($id: ID!) {\n  order(id: $id) {\n    status\n    items {\n      name\n      quantity\n    }\n    customer {\n      name\n    }\n  }\n}\n```\n\nAnta att ordern och dess rader hämtas men att tjänsten bakom `customer` ligger\nnere. Svaret innehåller ändå allt som gick att ta fram. Fältet som misslyckades\nkommer tillbaka som null, och en post i `errors` talar om vad som gick fel, var\ni dokumentet det hände (rad 8, kolumn 5 är `customer`) och vilken sökväg i\nsvaret det gäller:\n\n```json\n{\n  \"data\": {\n    \"order\": {\n      \"status\": \"open\",\n      \"items\": [{ \"name\": \"notebook\", \"quantity\": 2 }],\n      \"customer\": null\n    }\n  },\n  \"errors\": [\n    {\n      \"message\": \"Customer service unavailable\",\n      \"locations\": [{ \"line\": 8, \"column\": 5 }],\n      \"path\": [\"order\", \"customer\"]\n    }\n  ]\n}\n```\n\nEftersom `customer` är deklarerat så att det får vara null stannar skadan vid\ndet fältet. Hade det varit `Customer!` hade felet fortplantat sig upp till\nföräldern, och hela ordern hade kommit tillbaka som null. Och eftersom `data`\ninte är null svarar servern med en 2xx-status trots att det finns ett fel: HTTP\nhar ingen statuskod för delvis framgång. En klient som bara tittar på\nstatuskoden kommer att behandla svaret som komplett.\n\nDen motsatta designen, där servern äger formen på varje svar, är den som ett\nprojekt i portföljen här på webbplatsen byggde: en\n[JSON-väg rakt från Postgres till API:et](/sv/portfolio/designed-a-json-passthrough-from-postgres-to-api/).\nDär sätter PostgreSQL-funktioner ihop hela svaret som JSON, och Go-handlern\nvidarebefordrar det orört, så när man ändrar vad en funktion returnerar ändras\nockså det klienten tar emot, utan att någon ändrar en enda rad handlerkod.\nFrontenden är där direkt beroende av den form som databasen ger den. I GraphQL\när det klienten som namnger fälten, och servern måste vara redo att leverera\nvilken kombination av dem som helst som schemat tillåter.\n\n## Var det går fel\n\n**Ett fält, tusen databasanrop.** Varje resolver är en liten funktion, en per\nfält, och en naiv tjänst anropar dem ett objekt i taget. En lista med ordrar och\nvarje orders kund kostar då ett databasanrop för listan och ett till för varje\norder i den. GraphQL Foundations vägledning kallar det N+1-problemet och pekar\npå batchning: de uppslag som begärs inom ett kort tidsfönster samlas ihop och\nskickas till databasen som en enda förfrågan, med ett verktyg som Facebooks\nDataLoader.\n\n**En förfrågan begär allt.** Eftersom det är klienten som skriver operationen\nkan ett dokument nästla vänners vänner många nivåer ner, upprepa ett dyrt fält\nunder hundra alias eller packa in många operationer i en enda förfrågan. Var och\nen är giltig GraphQL, och var och en kan binda upp servern. Försvaret ligger hos\ntjänsten: paginera listfält, avvisa operationer som överskrider ett största djup\neller en största bredd innan exekveringen börjar, sätt tak för alias och\nbatchstorlek, och ge för finare kontroll fälten vikter och avvisa varje\noperation vars uppskattade kostnad går över budget, en teknik som kallas query\ncomplexity analysis och som specifikationen själv inte ger några regler för. Ett\nAPI som bara betjänar sina egna klienter kan gå längre med trusted documents, så\natt bara operationer som har sparats i förväg och slås upp via hash får köras\növer huvud taget.\n\n**200 OK döljer felet.** Ett svar med fel kan ändå vara en 2xx, som i exemplet\novan. Med den äldre medietypen `application/json` går vägledningen längre: en\n2xx rekommenderas även när en giltig förfrågan inte kan utföras, och vissa äldre\nservrar returnerar 2xx även vid valideringsfel. En klient, och övervakningen\nrunt den, måste läsa `errors` och inte bara statuskoden. Den nyare medietypen\n`application/graphql-response+json` ger statuskoden mening igen, eftersom en\ngiltig förfrågan som inte kan utföras då får en 4xx eller 5xx, och klienter bör\nbe om den i sitt `Accept`-huvud.\n\n**Cachningen slutar fungera.** Varje operation är en POST till samma URL, så\ncacharna mellan klient och server, ett CDN inräknat, ser en enda adress och en\nmetod som de inte cachar som standard. Det hjälper att skicka\n`query`-operationer som GET, men ett långt dokument kan överskrida den URL-längd\nsom webbläsare och CDN:er accepterar. Persisted queries löser båda problemen:\nklienten skickar en hash, och servern slår upp hela dokumentet innan det\nvalideras och utförs. Överallt där svar cachas över HTTP måste känsliga svar\ncachas privat eller inte alls.\n\n**Ett fält försvinner.** Klienter väljer fält ett och ett, så om ett fält tas\nbort eller byter namn går varje klient som fortfarande väljer det sönder, och\ninte på något skonsamt sätt: en operation som nämner ett okänt fält underkänns i\nvalideringen i sin helhet och ger inga data alls. Specifikationen håller\nfält märkta för utfasning giltiga just för att befintliga klienter inte ska gå sönder. Lägg\ntill ersättningen först, märk det gamla fältet med `@deprecated` och en\nmotivering som pekar på det nya, och ta bort det gamla fältet först när\ningenting längre väljer det.\n\n## Läs mer\n\n- [GraphQL Specification Versions](https://spec.graphql.org/) — alla utgåvor av\n  specifikationen, från juli 2015 till utgåvan från september 2025, plus\n  arbetsutkastet: språket, typsystemet, validering, exekvering och fel.\n- [Serving over HTTP](https://graphql.org/learn/serving-over-http/) — den enda\n  slutpunkten, POST och GET, de två medietyperna för svar och reglerna för\n  statuskoder för var och en av dem.\n- [Performance](https://graphql.org/learn/performance/) — GET för\n  `query`-operationer, persisted queries, N+1-problemet och batchning.\n- [Security](https://graphql.org/learn/security/) — trusted documents, gränser\n  för djup, bredd och batcher, query complexity analysis samt introspektion och\n  feldetaljer i produktion.\n\n\u003chttps://engineer.company/sv/glossary/graphql/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur GraphQL låter klienten välja fälten den får tillbaka, vad en enda slutpunkt kostar i cachning och statuskoder, och fem sätt det går fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/graphql/index.gmi","gopher":"https://engineer.company/sv/glossary/graphql/gophermap","html":"https://engineer.company/sv/glossary/graphql/","json":"https://engineer.company/sv/glossary/graphql/index.json","markdown":"https://engineer.company/sv/glossary/graphql/index.md","pdf":"https://engineer.company/sv/glossary/graphql/index.pdf"},"kind":"page","language":"sv","title":"Vad är GraphQL?","url":"https://engineer.company/sv/glossary/graphql/","version":1}