{"canonical_url":"https://engineer.company/da/glossary/graphql/","content_markdown":"# GraphQL\n\n## Hvad det er\n\nGraphQL er et forespørgselssprog til API'er sammen med den runtime, der udfører\nforespørgslerne på serveren. Klienten sender et dokument, der nævner præcis de\nfelter, den vil have, og serveren svarer med data i samme form. Specifikationen\nbeskriver det som et forespørgselssprog og en eksekveringsmotor til\nklient-server-applikationer. Den fortæller, at GraphQL blev skabt i 2012, at\narbejdet med det som åben standard begyndte i 2015, og at det siden 2019 har\nværet en leverance fra GraphQL Specification Project under Joint Development\nFoundation. Den seneste udgave er fra september 2025.\n\nAlt udgår fra det skema, en tjeneste offentliggør: et sæt typer, hver med\nnavngivne felter, og hvert felt med sin egen type. De indbyggede skalartyper er\n`Int`, `Float`, `String`, `Boolean` og `ID`, og en tjeneste kan tilføje sine\negne skalarer, for eksempel én til UUID'er. Enhver type kan være null, medmindre\nden er markeret med `!`, så en `String!` kan aldrig være null, og lister skrives\ni firkantede parenteser: `[LineItem!]!` er en liste, der altid er til stede og\naldrig indeholder null. Skemaet kan også selv forespørges. Gennem\nintrospektionsfelterne `__schema` og `__type` kan en klient spørge en tjeneste,\nhvad den tilbyder, og udviklerværktøjer og klientbiblioteker bygger netop på\ndet.\n\nDer findes tre slags operationer. En `query` er med specifikationens ord »a\nread-only fetch«, altså en hentning, der kun læser; en `mutation` er en\nskrivning efterfulgt af en hentning; og en `subscription` er en langvarig\nforespørgsel, der leverer data som svar på en række hændelser over tid. På\nserveren står en funktion bag hvert felt, som regel kaldet en resolver, og den\nleverer feltets værdi. Tjenesten validerer først en operation mod skemaet og\nkalder først derefter resolverne for de felter, operationen har valgt.\nTopniveaufelterne i en mutation køres ét ad gangen i stedet for parallelt, så to\nskrivninger i samme forespørgsel ikke kan overhale hinanden.\n\nSpecifikationen foreskriver hverken en transport eller et serialiseringsformat.\nHTTP er det mest almindelige valg, og dér ligger et GraphQL-API på én enkelt\nURL, som regel med endelsen `/graphql`, og svarer i JSON, det mest almindelige\nformat. Klienten sender en POST, hvis brødtekst er JSON med `query`-teksten og\nom nødvendigt dens `variables`. En server kan også tage imod GET til queries,\nmen en mutation skal altid sendes som POST. Svaret har resultatet under `data`\nog alt, hvad der gik galt, under `errors`. GraphQL Foundations vejledning om alt\ndette følger en GraphQL-over-HTTP-specifikation, der stadig er et udkast.\n\n## Hvorfor det betyder noget\n\nI de fleste HTTP-API'er er det serveren, der bestemmer, hvad hvert endpoint\nreturnerer. En skærm, der skal bruge en ordres status og kundens navn, får enten\nhele ordren og hele kunden, altså mere, end den bad om, eller må sende én\nforespørgsel pr. ressource og selv sætte svarene sammen. Specifikationen kalder\nde to problemer over-fetching og under-fetching. GraphQL vender det om: klienten\nspørger på niveau med de enkelte felter og får præcis de felter tilbage, hverken\nmere eller mindre. Én forespørgsel kan også følge relationer, fra en ordre til\ndens ordrelinjer og videre til kunden, fordi forespørgslen har samme form som de\ndata, den får tilbage.\n\nTypesystemet betaler sig to gange. Hver operation valideres mod skemaet, før\nnogen resolver kører, så et felt med en stavefejl eller et argument af forkert\ntype afvises samlet, før noget overhovedet er udført, og værktøjer kan fange de\nsamme fejl, mens koden stadig bliver skrevet. Og da en klient kun får de felter,\nden har valgt, koster et nyt felt ingenting for de eksisterende klienter. Det\ngør det praktisk at videreudvikle et API uden versionsnumre: et nyt felt kommer\ntil ved siden af det gamle, det gamle markeres med `@deprecated` og en\nbegrundelse, det forbliver gyldigt, så eksisterende klienter ikke går i stykker,\nog det fjernes, når ingen klient bruger det længere.\n\nOmkostningerne er reelle, og de fleste kommer af, at man træder uden for HTTP's\neget maskineri. Entiteter identificeres ikke længere af URL'er, og alt går til\nén adresse, som regel med POST, mens det er GET-forespørgsler, der typisk regnes\nfor cachebare som standard. Den caching, et REST-API får forærende fra\nmellemleddene, skal bygges op igen med vilje. Statuskoden fortæller ikke længere\nhele historien, for et svar med både data og fejl er stadig en succes på\nHTTP-niveau. Klienten sammensætter nu forespørgsler, serveren aldrig har set, så\nen enkelt forespørgsel kan bede om meget arbejde, og at beskytte serveren mod\ndet er tjenestens opgave, ikke noget, GraphQL gør for den. Resolvere pr. felt er\nlette at skrive, men skrevet naivt bliver de meget snakkesalige over for\ndatabasen bag dem.\n\n## Sådan ser det ud i praksis\n\nEn lille del af et skema for ordrer, hver med ordrelinjer og en kunde:\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, der viser status, ordrelinjerne og kundens navn, sender denne\noperation til `/graphql` i brødteksten af 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\nAntag, at ordren og dens linjer bliver hentet, men at tjenesten bag `customer`\ner nede. Svaret indeholder stadig alt, hvad der kunne leveres. Det fejlede felt\nkommer tilbage som null, og en post i `errors` fortæller, hvad der gik galt,\nhvor i dokumentet det skete (linje 8, kolonne 5 er `customer`), og hvilken sti i\nsvaret det berører:\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\nFordi `customer` er erklæret, så det kan være null, standser skaden ved det\nfelt. Havde det været `Customer!`, var fejlen forplantet op til forælderen, og\nhele ordren var kommet tilbage som null. Og fordi `data` ikke er null, svarer\nserveren med en 2xx-status, selv om der er en fejl: HTTP har ingen statuskode\nfor delvis succes. En klient, der kun ser på statuskoden, vil behandle svaret\nsom komplet.\n\nDet modsatte design, hvor serveren ejer formen på hvert svar, er det, et projekt\ni sitets portefølje byggede. I dets\n[JSON-passthrough-arkitektur fra Postgres til API'et](/da/portfolio/designed-a-json-passthrough-from-postgres-to-api/)\nsamler PostgreSQL-funktioner hele svaret som JSON, og Go-handleren sender det\nvidere uændret, så når man ændrer, hvad en funktion returnerer, ændrer man også,\nhvad klienten modtager, uden at nogen retter en linje handler-kode. Dér bygger\nfrontenden direkte på den form, databasen giver den. I GraphQL er det klienten,\nder nævner felterne, og serveren skal være klar til at levere enhver kombination\naf dem, som skemaet tillader.\n\n## Hvor det går galt\n\n**Ét felt, tusind databasekald.** Resolvere er små funktioner, én pr. felt, og\nen naiv tjeneste kalder dem ét objekt ad gangen. En liste over ordrer med hver\nordres kunde koster så ét databasekald til listen og ét mere for hver ordre i\nden. GraphQL Foundations vejledning kalder det N+1-problemet og peger på\nbatching: de opslag, der bliver bedt om inden for et kort tidsrum, samles og\nsendes til databasen som én forespørgsel, med et værktøj som Facebooks\nDataLoader.\n\n**Én forespørgsel beder om alt.** Fordi det er klienten, der skriver\noperationen, kan ét dokument indlejre venners venner mange niveauer ned, gentage\net dyrt felt under hundrede aliasser eller pakke mange operationer ind i én\nforespørgsel. Hver af dem er gyldig GraphQL, og hver af dem kan lægge beslag på\nserveren. Forsvaret ligger hos tjenesten: paginér listefelter, afvis\noperationer, der overskrider en maksimal dybde eller bredde, før udførelsen\nbegynder, sæt loft over aliasser og batchstørrelse, og giv for finere kontrol\nfelterne en vægt og afvis enhver operation, hvis anslåede pris overstiger\nbudgettet, en teknik kendt som query complexity analysis, som specifikationen\nselv ikke giver nogen regler for. Et API, der kun betjener sine egne klienter,\nkan gå videre med trusted documents, så kun operationer, der er gemt på forhånd\nog slås op efter hash, overhovedet må køre.\n\n**200 OK skjuler fejlen.** Et svar med fejl kan stadig være en 2xx, som i\neksemplet ovenfor. Med den ældre medietype `application/json` går vejledningen\nvidere: en 2xx anbefales, selv når en gyldig forespørgsel ikke kan udføres, og\nnogle ældre servere returnerer også 2xx ved valideringsfejl. En klient, og\novervågningen omkring den, må læse `errors` og ikke kun statuskoden. Den nyere\nmedietype `application/graphql-response+json` giver statuskoden mening igen, da\nen gyldig forespørgsel, hvis udførelse mislykkes, så får en 4xx eller 5xx, og\nklienter bør bede om den i deres `Accept`-header.\n\n**Cachingen holder op med at virke.** Hver operation er en POST til den samme\nURL, så de caches, der sidder mellem klient og server, et CDN medregnet, ser én\nadresse og en metode, de som standard ikke cacher. Det hjælper at sende queries\nsom GET, men et langt dokument kan overskride den URL-længde, som browsere og\nCDN'er accepterer. Persisted queries løser begge problemer: klienten sender en\nhash, og serveren slår det fulde dokument op, før det valideres og udføres.\nOveralt, hvor svar caches over HTTP, skal følsomme svar caches privat eller slet\nikke.\n\n**Et felt forsvinder.** Klienter vælger felter ét for ét, så hvis et felt\nfjernes eller omdøbes, går enhver klient, der stadig vælger det, i stykker, og\nikke stille og roligt: en operation, der nævner et ukendt felt, fejler\nvalideringen som helhed og giver slet ingen data. Specifikationen holder\nforældede felter gyldige netop for, at eksisterende klienter ikke skal gå i\nstykker. Tilføj erstatningen først, markér det gamle felt med `@deprecated` og\nen begrundelse, der peger på det nye, og fjern først det gamle felt, når intet\nlængere vælger det.\n\n## Læs mere\n\n- [GraphQL Specification Versions](https://spec.graphql.org/) — alle udgaver af\n  specifikationen, fra juli 2015 til udgaven fra september 2025, plus\n  arbejdsudkastet: sproget, typesystemet, validering, udførelse og fejl.\n- [Serving over HTTP](https://graphql.org/learn/serving-over-http/) — det ene\n  endpoint, POST og GET, de to medietyper for svar og reglerne for statuskoder\n  for hver af dem.\n- [Performance](https://graphql.org/learn/performance/) — GET til queries,\n  persisted queries, N+1-problemet og batching.\n- [Security](https://graphql.org/learn/security/) — trusted documents, grænser\n  for dybde, bredde og batches, query complexity analysis samt introspektion og\n  fejldetaljer i produktion.\n\n\u003chttps://engineer.company/da/glossary/graphql/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Hvordan GraphQL lader klienten vælge de felter, den får tilbage, hvad ét endpoint koster i caching og statuskoder, og fem måder, det går galt på.","formats":{"gemtext":"https://engineer.company/da/glossary/graphql/index.gmi","gopher":"https://engineer.company/da/glossary/graphql/gophermap","html":"https://engineer.company/da/glossary/graphql/","json":"https://engineer.company/da/glossary/graphql/index.json","markdown":"https://engineer.company/da/glossary/graphql/index.md","pdf":"https://engineer.company/da/glossary/graphql/index.pdf"},"kind":"page","language":"da","title":"Hvad er GraphQL?","url":"https://engineer.company/da/glossary/graphql/","version":1}