Invoer

Uitvoer

Wat is de GraphQL Minifier?

Wanneer je een GraphQL-schema meestuurt als deel van een deploy-artefact, een Lambda-bundle of een via CDN geleverde SDL-string, lopen beschrijvingen en `#`-commentaar snel op. Een echt productieschema kan makkelijk voor 40-60 % uit documentatie bestaan in bytes — handig wanneer mensen het lezen, dood gewicht zodra het over de lijn gaat om een client op te starten. De GraphQL-specificatie definieert commentaar, block-string-beschrijvingen en de meeste witruimte als genegeerde tokens, wat betekent dat elke fatsoenlijke parser ze toch al negeert. Deze minifier haalt dat allemaal weg en geeft een SDL op één regel terug die byte voor byte gelijk is aan het origineel vanuit het oogpunt van de parser.

De minifier is met de hand geschreven — er wordt geen graphql-npm-package in de pagina geladen, dus de eerste paint blijft klein. Hij tokeniseert het SDL, gooit elk commentaar- en block-string-token weg en zendt de structurele tokens opnieuw uit met de absolute minimumwitruimte die nodig is om aangrenzende name-tokens uit elkaar te houden (de enige plek waar spec-conform SDL echt een spatie nodig heeft). De uitvoer wordt geverifieerd met dezelfde lichte parser die in de formatter zit, dus de round-trip via graphql-js of Apollo Server bij het opstarten gedraagt zich identiek aan het origineel.

Alles draait in je browser. Geen upload, geen schema dat ergens wordt opgeslagen. Plakken, minifyen, kopiëren.

Hoe gebruik je de GraphQL Minifier

Drie snelle stappen. De knoppen die hieronder beschreven worden, zijn de daadwerkelijke knoppen op deze pagina — er is geen Minify-knop omdat minifyen automatisch gebeurt.

Plakken, uploaden of een voorbeeld laden

Plak een GraphQL-schema in het linker Invoer-paneel — minifyen gebeurt automatisch een fractie van een seconde nadat je stopt met typen, dus er is geen Convert-knop om te zoeken. Klik op Uploaden voor een .graphql-, .graphqls- of .gql-bestand, of druk op Voorbeeld om een realistisch e-commerce-bestelschema te laden met commentaar en block-string-beschrijvingen die je kunt zien verdwijnen. Een typische invoer ziet er zo uit:

"""An order placed by a customer."""
type Order {
  # The unique order identifier
  id: ID!
  placedAt: DateTime!
  customer: Customer!
  items: [OrderItem!]!
  status: OrderStatus!
}

Zowel server-stijl-schemas (met extend type Query) als losse typedefinities werken. De geaccepteerde vormen komen overeen met wat de GraphQL Schema Definition Language ondersteunt.

Lees de geminifyde uitvoer

Het rechter Uitvoer-paneel toont het geminifyde SDL op één regel, met de pill van bespaarde bytes in de paneelheader zodat je in één oogopslag ziet hoeveel je hebt bespaard. Commentaar (# ...) en block-string-beschrijvingen ("""...""") worden volledig verwijderd — ze hebben volgens de Relay GraphQL-specificatie geen semantische betekenis, en elk introspectie-gebaseerd tooling pakt beschrijvingen toch op vanuit je resolver-laag. Heeft het SDL niet-uitgebalanceerde haakjes of een andere parse-fout, dan toont de minifier een vriendelijke inline-melding — hij gooit nooit een exception en crasht niet.

Kopiëren of downloaden

Druk op Kopiëren om het geminifyde schema te grijpen voor inline gebruik in een deploy-script, een Lambda-env-var of een configbestand. Druk op Downloaden om op te slaan als .graphql. De wis-knop op het invoerpaneel zet je terug naar een lege staat. Minifyen gebeurt volledig client-side — je schema verlaat de pagina nooit.

Wanneer dit echt nuttig is

Kleinere deploy-artefacten

Bundel je je schema in een serverless-functie of een Docker-laag? Beschrijvingen en commentaar verwijderen halveert doorgaans het aantal bytes. Vermenigvuldig dat met elke cold start en elke laag-download en de besparing duikt op je rekening op. De runtime-parser maalt er niet om — beschrijvingen zijn alleen introspectie-metadata, en de meeste productiedeploys zetten introspectie sowieso uit volgens de productie-richtlijn van Apollo Router.

Schemas via CDN geleverd

Als je gateway het SDL bij het opstarten van een CDN haalt (Federation supergraph-compositie, schema-registry-pulls), kost elke byte latency op het koude pad. Geminifyd SDL parsed identiek en scheelt een flinke hap in de wire-size — vaak meer dan gzip zou doen, want gzip kan niet comprimeren wat al weg is.

Schemas in de broncode opnemen

Soms moet je een schema-string opnemen in een configbestand, een omgevingsvariabele of een zelfgebouwd tool. Een geminifyde één-regel-versie past schoon in een TypeScript-template-literal of een YAML-scalar zonder dat je elke newline hoeft te escapen.

Diff-ruis verminderen

Als twee revisies van een schema alleen verschillen in beschrijvingen of commentaar, ligt het echte structurele diff begraven onder doc-string-wijzigingen. Beide kanten minifyen voordat je een diff trekt isoleert de echte schema-delta, wat handig is voor change-management en het detecteren van breaking changes.

Veelgestelde vragen

Is het geminifyde schema nog steeds geldig GraphQL?

Ja — elke token die de spec als negeerbaar definieert (commentaar, beschrijvingen, overbodige witruimte, komma's) wordt verwijderd, maar elke naam, leesteken, string-literal en getal blijft bewaard. De uitvoer parseert naar exact dezelfde AST als de invoer. Je kunt dat verifiëren door beide door graphql-js te halen en de resulterende documenten te vergelijken.

Verlies ik mijn schemadocumentatie?

Ja — dat is het hele idee. Beschrijvingen en `#`-commentaar worden verwijderd. Houd je niet-geminifyde bron in versiebeheer en minify pas wanneer je het artefact gaat verschepen. Documentatie die je echt aan clients wilt tonen, leeft in je introspectie-respons, die wordt gegenereerd uit je runtime-resolver-metadata, niet uit de gedeployde SDL-string.

Wordt mijn schema naar een server gestuurd?

Nee. Minifyen gebeurt volledig in je browser. Niets wordt geüpload, niets wordt gelogd. Veilig om interne of nog niet uitgebrachte schemas in te plakken.

Hoeveel kan ik verwachten te besparen?

Hangt af van hoe sterk je schema gedocumenteerd is. Een kale SDL zonder beschrijvingen bespaart 10-15 % (alleen witruimte). Een goed gedocumenteerd schema met block-string-beschrijvingen op elk type en veld bespaart doorgaans 40-60 %. De bespaarde-bytes-pill in de uitvoerpaneelheader vertelt je het exacte getal voor jouw invoer.

Werkt het met directives, custom scalars en federation?

Ja. @deprecated, @key, @external, scalar DateTime en elke aangepaste directive of scalar blijven behouden. De minifier verwijdert alleen negeerbare tokens — alles wat semantisch is, blijft. Federation-directives gaan schoon door de round-trip.

Hoe groot mag het schema zijn?

Alles wat je browser comfortabel rendert. Schemas met een paar honderd types zijn geen probleem. Boven de 5 MB begint de Ace-editor zelf te traagheid — die is de bottleneck, niet de minifier.

Andere GraphQL-tools

Minifyen is één onderdeel van werken met GraphQL. Deze tools dekken de rest af: