ForHosting KIT · Outils pour développeurs

Extraire les noms et types de variables GraphQL

Cet extracteur lit un document GraphQL exécutable, contrôle sa syntaxe et répertorie les variables déclarées par chaque requête, mutation ou souscription.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Le résultat conserve la nature et le nom éventuel de l’opération, ainsi que le nom et la notation exacte du type de chaque variable, listes et marqueurs non nuls compris. Il facilite la création de formulaires, la revue des opérations clientes, la documentation d’une intégration et le contrôle préalable des requêtes.

Distinguez les déclarations des utilisations

Une variable GraphQL apparaît dans une déclaration telle que <code>$id: ID!</code> près du nom d’opération, puis dans des utilisations telles que <code>user(id: $id)</code> au sein de la sélection. Cette capacité ne restitue que les déclarations. Elle les rattache à leur requête, mutation ou souscription, si bien que deux opérations peuvent déclarer le même nom sans fusion. La notation utile est préservée : <code>String</code>, <code>ID!</code> ou <code>[ID!]!</code>. Les valeurs par défaut et directives sont analysées afin de vérifier la syntaxe, mais ne figurent pas dans la réponse. Les fragments sont également contrôlés, sans produire d’entrée puisqu’ils ne déclarent aucune variable d’opération. Une requête anonyme abrégée est indiquée sans nom et avec une liste vide.

Contrôlez la syntaxe de manière déterministe

Une expression régulière devient fragile face aux commentaires, chaînes, blocs de texte, listes imbriquées, objets par défaut, directives, fragments, alias et opérations multiples. Cet analyseur lexicalise le document complet et respecte la grammaire exécutable de GraphQL. Il refuse notamment les chaînes non terminées, nombres incorrects, caractères inattendus, sélections vides et définitions incomplètes. La réponse convient donc à un contrôle anticipé dans une chaîne de compilation. Aucun réseau ni schéma n’est consulté. L’outil ne peut donc pas déterminer si un champ existe sur votre serveur, si un type correspond à un argument ou si les règles liées au schéma sont satisfaites. Employez-le pour la syntaxe et l’inventaire, puis réalisez séparément la validation du schéma.

Intégrez un résultat structuré

La réponse fournit le tableau <code>operations</code> dans l’ordre du document et le total <code>variable_count</code>. Chaque opération précise sa nature, son nom lorsqu’il est présent, et un tableau <code>variables</code> composé de fiches <code>name</code> et <code>type</code>. Cette structure stable permet de générer des éditeurs, comparer des opérations versionnées, créer des tableaux documentaires ou détecter une nouvelle entrée obligatoire. La séparation des opérations évite les faux conflits entre noms répétés. L’entrée est limitée à 200,000 caractères afin de borner l’analyse. Aucune requête n’est exécutée et aucun schéma, en-tête, identifiant ou valeur n’est demandé. Collez le document dans le navigateur ou appelez l’API pour $0.002 par élément. Une erreur indique la position approximative du problème.

Cas d’usage

Créer un formulaire de variables

Lisez les déclarations et créez les champs appropriés avant de recueillir les valeurs d’exécution.

Réviser les requêtes persistées

Comparez les noms et types GraphQL exacts après la modification d’une opération versionnée.

Documenter les opérations clientes

Transformez un document multi-opération en inventaire classé par nature.

Questions fréquentes

La requête GraphQL est-elle exécutée ?

Non. Le document est analysé localement sans jamais contacter de point d’accès GraphQL.

Les utilisations de variables sont-elles incluses ?

Non. Seules les déclarations sont rendues ; les références ne constituent pas de nouvelles déclarations.

Les marqueurs de liste et non nuls sont-ils conservés ?

Oui. ID!, [String!] et [ID!]! conservent leur notation GraphQL complète.

Les champs sont-ils validés avec mon schéma ?

Non. La syntaxe est vérifiée sans schéma ; l’existence et la compatibilité nécessitent une autre étape.

Plusieurs opérations et fragments sont-ils admis ?

Oui. Les opérations restent ordonnées ; les fragments sont contrôlés sans ajouter de déclarations.

Quel est le coût d’un appel API ?

Chaque élément coûte $0.002. La version web exécute localement le même analyseur.

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/dev/graphql-query-variables-extract

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/dev/graphql-query-variables-extract \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"}'

const res = await fetch("https://api.kit.forhosting.com/dev/graphql-query-variables-extract", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "query": "query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/graphql-query-variables-extract",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "query": "query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/graphql-query-variables-extract", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"query":"query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"query":"query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/graphql-query-variables-extract", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "query": "query FindUser($id: ID!, $withPosts: Boolean = false) { user(id: $id) { name posts @include(if: $withPosts) { title } } }"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.graphql_query_variables_extract",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_chars 200000

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Consulter la documentation complète du KIT →