GraphQL to TypeScript Resolvers
GraphQL Fullstack Engineering & Resolver Typing Suite

Guide Développeur : Générateur de Types de Résolveurs TypeScript depuis GraphQL SDL

Générez des interfaces de résolveurs TypeScript strictement typées, des arguments de requêtes/mutations et des types de contexte depuis vos schémas GraphQL SDL.

Zero Server Transmission
Presets:
Options du Générateur
Définition de Schéma GraphQL (SDL)
114 lines•1901 chars•1901 B
Valid GraphQL AST
/* =============================================================================
 * AUTOMATICALLY GENERATED GRAPHQL RESOLVER TYPES
 * Engine: ToolsAA GraphQL-to-TypeScript Resolvers V3
 * Mode: APOLLO / Pure Client-Side Type Synthesis
 * ============================================================================= */

Maybe<T> = T | null | undefined;
Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };

ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: any
) => Promise<TResult> | TResult;

Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
  | ResolverFn<TResult, TParent, TContext, TArgs>
  | { resolve: ResolverFn<TResult, TParent, TContext, TArgs> };

SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: any
) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;

SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: any
) => TResult | Promise<TResult>;

SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
}

SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
  | ((...args: any[]) => SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>)
  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>;

TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
  parent: TParent,
  context: TContext,
  info: any
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

IsTypeOfResolverFn<T = {}, TContext = {}> = (
  obj: T,
  context: TContext,
  info: any
) => boolean | Promise<boolean>;

/** All built-in and configured custom scalar mapping */
Scalars = {
  ID: { input: string; output: string };
  String: { input: string; output: string };
  Boolean: { input: boolean; output: boolean };
  Int: { input: number; output: number };
  Float: { input: number; output: number };
  DateTime: { input: Date | string; output: Date | string };
  Date: { input: Date | string; output: Date | string };
  Time: { input: string; output: string };
  JSON: { input: any; output: any };
  JSONObject: { input: Record<string, any>; output: Record<string, any> };
  Decimal: { input: string | number; output: string | number };
  UUID: { input: string; output: string };
  Upload: { input: File | Blob; output: File | Blob };

};

/* ==================== ENUMS ==================== */

UserRole {
  ADMIN = 'ADMIN',
  CUSTOMER = 'CUSTOMER',
  FULFILLMENT = 'FULFILLMENT',
}

OrderStatus {
  PENDING = 'PENDING',
  PROCESSING = 'PROCESSING',
  SHIPPED = 'SHIPPED',
  DELIVERED = 'DELIVERED',
  CANCELLED = 'CANCELLED',
}

/* ==================== TYPE MAPPERS ==================== */

/** Mapping of GraphQL types to internal resolver return types */
ResolversTypes = {
  ID: Scalars['ID']['output'];
  String: Scalars['String']['output'];
  Boolean: Scalars['Boolean']['output'];
  Int: Scalars['Int']['output'];
  Float: Scalars['Float']['output'];
  DateTime: Scalars['DateTime']['output'];
  Date: Scalars['Date']['output'];
  Time: Scalars['Time']['output'];
  JSON: Scalars['JSON']['output'];
  JSONObject: Scalars['JSONObject']['output'];
  Decimal: Scalars['Decimal']['output'];
  UUID: Scalars['UUID']['output'];
  Upload: Scalars['Upload']['output'];
  UserRole: UserRole;
  OrderStatus: OrderStatus;
  SearchResult: ResolversTypes['Product'] | ResolversTypes['User'] | ResolversTypes['Order'];
  Node: ResolversTypes['User'] | ResolversTypes['Product'] | ResolversTypes['Order'];
  Timestamps: ResolversTypes['User'] | ResolversTypes['Product'] | ResolversTypes['Order'];
  User: UserModel;
  Product: ProductModel;
  Order: OrderModel;
  OrderItem: OrderItemModel;
  Address: AddressModel;
  Query: {};
  Mutation: {};
};

/** Mapping of GraphQL types to parent/root argument types passed to field resolvers */
ResolversParentTypes = {
  ID: Scalars['ID']['output'];
  String: Scalars['String']['output'];
  Boolean: Scalars['Boolean']['output'];
  Int: Scalars['Int']['output'];
  Float: Scalars['Float']['output'];
  DateTime: Scalars['DateTime']['output'];
  Date: Scalars['Date']['output'];
  Time: Scalars['Time']['output'];
  JSON: Scalars['JSON']['output'];
  JSONObject: Scalars['JSONObject']['output'];
  Decimal: Scalars['Decimal']['output'];
  UUID: Scalars['UUID']['output'];
  Upload: Scalars['Upload']['output'];
  UserRole: UserRole;
  OrderStatus: OrderStatus;
  SearchResult: ResolversParentTypes['Product'] | ResolversParentTypes['User'] | ResolversParentTypes['Order'];
  Node: ResolversParentTypes['User'] | ResolversParentTypes['Product'] | ResolversParentTypes['Order'];
  Timestamps: ResolversParentTypes['User'] | ResolversParentTypes['Product'] | ResolversParentTypes['Order'];
  User: UserModel;
  Product: ProductModel;
  Order: OrderModel;
  OrderItem: OrderItemModel;
  Address: AddressModel;
  Query: {};
  Mutation: {};
};

/* ==================== ENTITY MODEL INTERFACES ==================== */

/** Represents a customer or admin account in the storefront. */
UserModel {
  id: Scalars['ID']['output'];
  email: Scalars['String']['output'];
  displayName: Scalars['String']['output'];
  role: UserRole;
  orders: Array<ResolversTypes['Order']>;
  defaultAddress?: Maybe<ResolversTypes['Address']>;
  createdAt: Scalars['DateTime']['output'];
  updatedAt?: Maybe<Scalars['DateTime']['output']>;
}

ProductModel {
  id: Scalars['ID']['output'];
  sku: Scalars['String']['output'];
  title: Scalars['String']['output'];
  price: Scalars['Float']['output'];
  inventoryCount: Scalars['Int']['output'];
  tags: Array<Scalars['String']['output']>;
  createdAt: Scalars['DateTime']['output'];
  updatedAt?: Maybe<Scalars['DateTime']['output']>;
}

OrderModel {
  id: Scalars['ID']['output'];
  orderNumber: Scalars['String']['output'];
  customer: ResolversTypes['User'];
  status: OrderStatus;
  items: Array<ResolversTypes['OrderItem']>;
  totalAmount: Scalars['Float']['output'];
  shippingAddress: ResolversTypes['Address'];
  createdAt: Scalars['DateTime']['output'];
  updatedAt?: Maybe<Scalars['DateTime']['output']>;
}

OrderItemModel {
  id: Scalars['ID']['output'];
  product: ResolversTypes['Product'];
  quantity: Scalars['Int']['output'];
  unitPrice: Scalars['Float']['output'];
}

AddressModel {
  street: Scalars['String']['output'];
  city: Scalars['String']['output'];
  postalCode: Scalars['String']['output'];
  country: Scalars['String']['output'];
}

/* ==================== RESOLVERS INTERFACES ==================== */

/** Represents a customer or admin account in the storefront. */
UserResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']> {
  id?: Resolver<Scalars['ID']['output'], ParentType, ContextType, {}>;
  email?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  displayName?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  role?: Resolver<UserRole, ParentType, ContextType, {}>;
  orders?: Resolver<Array<ResolversTypes['Order']>, ParentType, ContextType, UserOrdersArgs>;
  defaultAddress?: Resolver<Maybe<ResolversTypes['Address']>, ParentType, ContextType, {}>;
  createdAt?: Resolver<Scalars['DateTime']['output'], ParentType, ContextType, {}>;
  updatedAt?: Resolver<Maybe<Scalars['DateTime']['output']>, ParentType, ContextType, {}>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}

ProductResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Product'] = ResolversParentTypes['Product']> {
  id?: Resolver<Scalars['ID']['output'], ParentType, ContextType, {}>;
  sku?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  title?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  price?: Resolver<Scalars['Float']['output'], ParentType, ContextType, {}>;
  inventoryCount?: Resolver<Scalars['Int']['output'], ParentType, ContextType, {}>;
  tags?: Resolver<Array<Scalars['String']['output']>, ParentType, ContextType, {}>;
  createdAt?: Resolver<Scalars['DateTime']['output'], ParentType, ContextType, {}>;
  updatedAt?: Resolver<Maybe<Scalars['DateTime']['output']>, ParentType, ContextType, {}>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}

OrderResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Order'] = ResolversParentTypes['Order']> {
  id?: Resolver<Scalars['ID']['output'], ParentType, ContextType, {}>;
  orderNumber?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  customer?: Resolver<ResolversTypes['User'], ParentType, ContextType, {}>;
  status?: Resolver<OrderStatus, ParentType, ContextType, {}>;
  items?: Resolver<Array<ResolversTypes['OrderItem']>, ParentType, ContextType, {}>;
  totalAmount?: Resolver<Scalars['Float']['output'], ParentType, ContextType, {}>;
  shippingAddress?: Resolver<ResolversTypes['Address'], ParentType, ContextType, {}>;
  createdAt?: Resolver<Scalars['DateTime']['output'], ParentType, ContextType, {}>;
  updatedAt?: Resolver<Maybe<Scalars['DateTime']['output']>, ParentType, ContextType, {}>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}

OrderItemResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['OrderItem'] = ResolversParentTypes['OrderItem']> {
  id?: Resolver<Scalars['ID']['output'], ParentType, ContextType, {}>;
  product?: Resolver<ResolversTypes['Product'], ParentType, ContextType, {}>;
  quantity?: Resolver<Scalars['Int']['output'], ParentType, ContextType, {}>;
  unitPrice?: Resolver<Scalars['Float']['output'], ParentType, ContextType, {}>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}

AddressResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Address'] = ResolversParentTypes['Address']> {
  street?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  city?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  postalCode?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  country?: Resolver<Scalars['String']['output'], ParentType, ContextType, {}>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}

QueryResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> {
  me?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType, {}>;
  user?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType, RequireFields<QueryUserArgs, 'id'>>;
  product?: Resolver<Maybe<ResolversTypes['Product']>, ParentType, ContextType, RequireFields<QueryProductArgs, 'id'>>;
  products?: Resolver<Array<ResolversTypes['Product']>, ParentType, ContextType, QueryProductsArgs>;
  search?: Resolver<Array<ResolversTypes['SearchResult']>, ParentType, ContextType, RequireFields<QuerySearchArgs, 'query'>>;
}

MutationResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> {
  createProduct?: Resolver<ResolversTypes['Product'], ParentType, ContextType, RequireFields<MutationCreateProductArgs, 'input'>>;
  checkoutCart?: Resolver<ResolversTypes['Order'], ParentType, ContextType, RequireFields<MutationCheckoutCartArgs, 'input'>>;
  cancelOrder?: Resolver<ResolversTypes['Order'], ParentType, ContextType, RequireFields<MutationCancelOrderArgs, 'orderId'>>;
}

SearchResultResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['SearchResult'] = ResolversParentTypes['SearchResult']> {
  __resolveType: TypeResolveFn<'Product' | 'User' | 'Order', ParentType, ContextType>;
}

NodeResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Node'] = ResolversParentTypes['Node']> {
  __resolveType: TypeResolveFn<'User' | 'Product' | 'Order', ParentType, ContextType>;
}

TimestampsResolvers<ContextType = AppContext, ParentType extends ResolversParentTypes['Timestamps'] = ResolversParentTypes['Timestamps']> {
  __resolveType: TypeResolveFn<'User' | 'Product' | 'Order', ParentType, ContextType>;
}

/** Top-level combined resolvers map passed to your GraphQL server setup */
Resolvers<ContextType = AppContext> {
  User?: UserResolvers<ContextType>;
  Product?: ProductResolvers<ContextType>;
  Order?: OrderResolvers<ContextType>;
  OrderItem?: OrderItemResolvers<ContextType>;
  Address?: AddressResolvers<ContextType>;
  Query?: QueryResolvers<ContextType>;
  Mutation?: MutationResolvers<ContextType>;
  SearchResult?: SearchResultResolvers<ContextType>;
  Node?: NodeResolvers<ContextType>;
  Timestamps?: TimestampsResolvers<ContextType>;
}
299 lines•13141 chars•13141 B
Parsed in 1ms (Pure Browser)
Définitions Analysées15 TypesTypes d'objets, interfaces, unions et énumérations identifiés dans l'AST
Champs de Résolveurs9 FieldsSignatures de résolveurs et interfaces d'arguments typées générées
Zéro Dépendance100% Client-SideTraitement ultra-rapide en mémoire dans le navigateur sans transit de données

Conformité Totale aux Spécifications GraphQL

Analyse fidèlement les queries, mutations, subscriptions, inputs, interfaces, unions et directives personnalisées.

Synthèse de Types Locale sans Latence

L'analyse lexicale et la génération TypeScript s'exécutent entièrement dans le navigateur.

Intégration Prête pour la Production

Prend en charge Apollo Server, GraphQL Yoga et Mercurius avec mappers de parents et typage d'arguments.

Référence technique et guide d'architecture

Guide Développeur : Générateur de Types de Résolveurs TypeScript depuis GraphQL SDL — Guide de référence

Générez des interfaces de résolveurs TypeScript strictement typées, des arguments de requêtes/mutations et des types de contexte depuis vos schémas GraphQL SDL.

Paramètres clés et contrôles

Nom du Type de Contexte (Context Type Name)string

Identifiant du type ou de l'interface de contexte partagé passé en troisième argument à chaque fonction résolveur.

Par défaut : GraphQLContext
Encapsulation du Retour du Résolveur (Resolver Return Wrapper)Enum (PromiseOrValue | PromiseOnly | DirectValue)

Stratégie de typage du résultat d'exécution des résolveurs (ex. T | Promise<T> ou Promise<T> uniquement).

Par défaut : PromiseOrValue
Typage du Parent Racine (Root Parent Typing)Enum (unknown | undefined | empty_object)

Typage appliqué au premier paramètre (parent/source) pour les champs racine de Query et Mutation.

Par défaut : unknown
Mappage des Scalaires Personnalisés (Custom Scalar Mapping)Record<string, string>

Liaison des types TypeScript pour les scalaires GraphQL personnalisés comme DateTime, JSON ou UUID.

Par défaut : {"DateTime": "string | Date", "JSON": "Record<string, unknown>"}

Conseils de pro et bonnes practices

Association avec DataLoader pour Éliminer les Requêtes N+1

Typez votre objet de contexte avec des instances DataLoader strictement typées afin que les résolveurs imbriqués disposent de méthodes de chargement par lot fiables.

Exploitation du Typage Parent pour les Résolveurs Imbriqués

Les résolveurs de champs imbriqués déduisent automatiquement la structure du parent résolu (ex. UserParent), évitant tout accès à des propriétés inexistantes.

Unions de Littéraux de Chaînes pour des Enums sans Surcharge

Privilégiez les unions de littéraux ('ADMIN' | 'USER') aux enums TypeScript traditionnels pour supprimer le code JavaScript résiduel et optimiser le tree-shaking.

Pièges courants et dépannage

Incompatibilité de type entre la valeur retournée par le résolveur et le schéma GraphQL

Vérifiez que la fonction résolveur retourne le type exact ou une Promise correspondante, en respectant la nullabilité et les tableaux définis dans le SDL.

Les scalaires personnalisés non mappés génèrent des types 'any' ou des erreurs

Déclarez des correspondances explicites dans le panneau de configuration des scalaires (ex. DateTime -> string | Date).

Foire aux questions (FAQ)

Quelle est la différence entre les types GraphQL côté client et les types de résolveurs backend ?▼

Les types client modélisent les réponses aux requêtes, tandis que les types de résolveurs définissent la signature des fonctions d'exécution côté serveur : (parent, args, context, info) => T.

Est-ce compatible avec Apollo Server, GraphQL Yoga et Mercurius ?▼

Oui. L'interface de résolveurs générée respecte les spécifications de GraphQL-JS et se branche directement sur makeExecutableSchema, Apollo Server ou createYoga.

Comment sont gérés les champs non nuls (!) et les champs optionnels ?▼

Les champs marqués d'un '!' exigent un type de retour obligatoire, tandis que les champs non marqués acceptent T | null | undefined avec des arguments optionnels.

Mon schéma GraphQL SDL propriétaire est-il envoyé à un serveur externe ?▼

Non. Le parsing du schéma, la validation de l'AST et la génération TypeScript s'exécutent à 100 % localement dans votre navigateur sans aucune fuite de données.

Outils et utilitaires connexes

Tous les outils →
Guide de développement : Convertisseur cURL vers C# (.NET HttpClient, RestSharp et Flurl)developer

Convertissez vos requêtes cURL en code C# idiomatique pour .NET HttpClient, RestSharp ou Flurl.Http avec les meilleures pratiques de programmation asynchrone et de pool de connexions.

Ouvrir l'outil→
Guide développeur du convertisseur cURL vers Java (Java 11+ HttpClient, OkHttp & Spring WebClient)developer

Convertissez vos commandes cURL en requêtes HTTP Java prêtes pour la production avec java.net.http.HttpClient natif, OkHttp3 ou Spring WebClient.

Ouvrir l'outil→
Guide Développeur : Générateur de Définition JSON vers XML Schema (XSD)developer

Inférence de schémas XML (XSD), structures de types complexes, attributs et règles de cardinalité minOccurs/maxOccurs à partir d'échantillons JSON.

Ouvrir l'outil→
Générateur Interactif de Fichier .gitignore (Node, Python, Go, Rust, Java) Guide Développeurdeveloper

Générez des modèles .gitignore complets en combinant les règles pour systèmes d'exploitation, éditeurs et plus de 50 langages de programmation.

Ouvrir l'outil→
Syntaxe Crontab & Expressions Quartz Cheat Sheetdeveloper

Référence exhaustive de la syntaxe cron POSIX à 5 champs et Quartz à 6 champs. Raccourcis macros, calcul des cycles et prévention des chevauchements de tâches.

Ouvrir l'outil→
Guide Pratique des Expressions Régulières (RegEx) JavaScriptdeveloper

Manuel technique des expressions régulières ECMAScript, groupes de capture, remplacements et drapeaux de configuration.

Ouvrir l'outil→