Indata

Utdata

Vad är GraphQL-minifieraren?

När du skickar ett GraphQL-schema som del av en deploy-artefakt, en Lambda-bundle eller en SDL-sträng som levereras via CDN, växer beskrivningar och `#`-kommentarer snabbt. Ett riktigt produktionsschema kan lätt vara 40-60 % dokumentation räknat i bytes — användbart när människor läser det, dödvikt när det går över tråden för att starta upp en klient. GraphQL-specifikationen definierar kommentarer, blocksträngsbeskrivningar och de flesta blanksteg som ignorerade tokens, vilket betyder att varje rimlig parser ändå ignorerar dem. Den här minifieraren tar bort allt detta och returnerar en SDL på en rad som är byte-för-byte ekvivalent med originalet ur parserns synvinkel.

Minifieraren är handskriven — inget graphql-npm-paket laddas in på sidan, så första paint förblir lätt. Den tokeniserar SDL, kastar varje kommentar- och blocksträngs-token och sänder ut de strukturella tokens igen med det absoluta minimum av blanksteg som krävs för att hålla intilliggande name-tokens åtskilda (det enda stället där spec-konform SDL faktiskt behöver ett mellanslag). Utdata verifieras av samma lättviktsparser som används i formattern, så ronden genom graphql-js eller Apollo Server vid uppstart beter sig precis som med originalet.

Allt körs i din webbläsare. Ingen uppladdning, inget schema som lagras någonstans. Klistra in, minifiera, kopiera.

Hur du använder GraphQL-minifieraren

Tre snabba steg. Knapparna som beskrivs nedan är de faktiska knapparna på den här sidan — det finns ingen Minify-knapp eftersom minifieringen sker automatiskt.

Klistra in, ladda upp eller hämta ett exempel

Klistra in ett GraphQL-schema i den vänstra Indata-panelen — minifieringen sker automatiskt en bråkdel av en sekund efter att du slutat skriva, så det finns ingen Convert-knapp att leta efter. Klicka på Ladda upp för en .graphql-, .graphqls- eller .gql-fil, eller tryck på Exempel för att hämta ett realistiskt e-handelsorderschema med kommentarer och blocksträngsbeskrivningar du kan se försvinna. En typisk indata ser ut så här:

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

Både scheman i serverstil (med extend type Query) och fristående typdefinitioner fungerar. De former som accepteras matchar vad GraphQL Schema Definition Language stöder.

Läs den minifierade utdatan

Den högra Utdata-panelen visar den minifierade SDL på en enda rad, med pillen för sparade bytes i panelhuvudet så du ser med en blick hur mycket du sparade. Kommentarer (# ...) och blocksträngsbeskrivningar ("""...""") tas bort helt — de har enligt Relays GraphQL-specifikation noll semantisk betydelse, och varje introspektionsbaserat verktyg plockar ändå upp beskrivningar från ditt resolverlager. Om SDL har obalanserade klamrar eller något annat parsningsfel visar minifieraren ett vänligt inline-meddelande — den kastar aldrig undantag eller kraschar.

Kopiera eller ladda ner

Tryck på Kopiera för att ta tag i det minifierade schemat och inlina det i ett deploy-skript, en Lambda-miljövariabel eller en konfigurationsfil. Tryck på Ladda ner för att spara som .graphql. Rensa-knappen i indatapanelen återställer dig till ett tomt läge. Minifiering sker helt på klientsidan — ditt schema lämnar aldrig sidan.

När det här faktiskt är användbart

Mindre deploy-artefakter

Buntar du ditt schema i en serverless-funktion eller ett Docker-lager? Att ta bort beskrivningar och kommentarer halverar oftast bytestorleken. Multiplicera det med varje cold start och varje lager-nedladdning så syns besparingen på fakturan. Runtime-parsern bryr sig inte — beskrivningar är metadata enbart för introspektion, och de flesta produktionsdeployer stänger ändå av introspektion enligt Apollo Routers produktionsvägledning.

Scheman som levereras via CDN

Om din gateway hämtar SDL från en CDN vid uppstart (Federation supergraph-komposition, schema-registerhämtningar) kostar varje byte latens på den kalla vägen. Minifierad SDL parsas identiskt och kapar en rejäl bit av wire-storleken — ofta mer än vad gzip skulle göra, eftersom gzip inte kan komprimera det som redan tagits bort.

Inlina scheman i källkod

Ibland behöver du inlina en schema-sträng i en konfigurationsfil, en miljövariabel eller ett egenbyggt verktyg. En minifierad enradsversion landar rent i en TypeScript template literal eller en YAML-skalär utan att du behöver escapa varje radbrytning.

Minska brus i diffar

När två revisioner av ett schema bara skiljer sig i beskrivningar eller kommentarer, ligger den verkliga strukturella diffen begravd under doc-string-ändringar. Att minifiera båda sidorna innan du diffar isolerar den verkliga schema-deltan, vilket är användbart för ändringshantering och upptäckt av breaking changes.

Vanliga frågor

Är det minifierade schemat fortfarande giltigt GraphQL?

Ja — varje token som specifikationen definierar som ignorerbar (kommentarer, beskrivningar, redundanta blanksteg, kommatecken) tas bort, men varje namn, skiljetecken, stränglitteral och tal behålls. Utdata parsas till exakt samma AST som indatan. Du kan verifiera det genom att köra båda genom graphql-js och jämföra de resulterande dokumenten.

Förlorar jag min schemadokumentation?

Ja — det är hela poängen. Beschriftningar och `#`-kommentarer tas bort. Behåll din ominifierade källa i versionskontroll och minifiera bara när du står i begrepp att skicka iväg artefakten. Dokumentation som du faktiskt vill exponera mot klienter lever i ditt introspektionssvar, vilket genereras från dina runtime-resolvermetadata, inte från den utrullade SDL-strängen.

Skickas mitt schema till en server?

Nej. Minifieringen körs helt i din webbläsare. Inget laddas upp, inget loggas. Säkert att klistra in interna eller opublicerade scheman.

Hur mycket kan jag förvänta mig att spara?

Det beror på hur tungt dokumenterat ditt schema är. En naken SDL utan beskrivningar sparar 10-15 % (bara blanksteg). Ett väldokumenterat schema med blocksträngsbeskrivningar på varje typ och fält sparar oftast 40-60 %. Pillen för sparade bytes i utdatapanelens header berättar exakta siffran för din indata.

Hanterar den direktiv, custom scalars och federation?

Ja. @deprecated, @key, @external, scalar DateTime och alla anpassade direktiv eller scalars behålls. Minifieraren tar bara bort ignorerbara tokens — allt semantiskt stannar. Federation-direktiv går genom round-trip rent.

Hur stort schema kan jag minifiera?

Allt som din webbläsare renderar bekvämt. Scheman med några hundra typer är inga problem. Bortom cirka 5 MB börjar Ace-editorn själv bli långsam — det är flaskhalsen, inte minifieraren.

Andra GraphQL-verktyg

Att minifiera är en del av att jobba med GraphQL. De här verktygen sköter resten: