GraphQL to TypeScript Resolvers
GraphQL Fullstack Engineering & Resolver Typing Suite

GraphQL SDL to TypeScript Resolver Types Generator

Generate strongly-typed TypeScript resolver interfaces, query/mutation arguments, and parent context types from GraphQL SDL.

Zero Server Transmission
Presets:
Resolver Generator Options
GraphQL Schema Definition (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)
Type Defs Parsed15 TypesObject, interface, union, and enum definitions recognized from SDL AST
Resolver Fields9 FieldsStrongly-typed resolver functions and argument signatures generated
Zero Dependencies100% Client-SidePure client-side in-memory compilation with zero server roundtrips

Full GraphQL Specification Compliance

Parses queries, mutations, subscriptions, input types, interfaces, unions, custom directives, and scalar definitions with high-fidelity AST analysis.

Zero-Latency Client-Side Type Synthesis

All tokenizer and code generation routines execute purely within the browser's JavaScript engine. Your schema secrets never touch remote servers.

Production-Ready Fullstack Typing

Generates Apollo Server, GraphQL Yoga, and Mercurius-compatible root resolvers, type resolver functions, parent mappers, and argument interfaces.

Technical Reference & Architecture Guide

GraphQL SDL to TypeScript Resolver Types Generator Developer Guide — Reference Guide

Generate strongly-typed TypeScript resolver interfaces, query/mutation arguments, and parent context types from GraphQL SDL.

Key Parameters & Controls

Context Type Namestring

The identifier for the shared context object passed as the third parameter to all resolver functions.

Default: GraphQLContext
Resolver Return WrapperEnum (PromiseOrValue | PromiseOnly | DirectValue)

Type wrapping strategy for resolver execution outcomes (e.g., T | Promise<T> versus Promise<T>).

Default: PromiseOrValue
Root Parent TypingEnum (unknown | undefined | empty_object)

Typing strategy applied to the initial parent/source parameter for root Query and Mutation fields.

Default: unknown
Custom Scalar MappingRecord<string, string>

Custom TypeScript type bindings for custom GraphQL SDL scalars like DateTime, JSON, and UUID.

Default: {"DateTime": "string | Date", "JSON": "Record<string, unknown>"}

Pro Tips & Best Practices

Combine with DataLoader for N+1 Query Prevention

Type your context object with strongly-typed DataLoader instances so nested field resolvers receive fully typed batch loading methods.

Leverage Parent Typing for Nested Resolvers

Nested field resolvers automatically infer the parent object's resolved shape (e.g., UserParent), ensuring access only to valid domain properties.

Zero-Overhead String Literals for Union Types

Configure GraphQL union types and enums as string literal unions to eliminate runtime JavaScript overhead and maximize tree-shaking.

Common Gotchas & Troubleshooting

Type mismatch between resolver return type and GraphQL schema field definition

Verify that the resolver returns either the exact field type or a Promise resolving to it, matching strict nullability and array wrapping constraints.

Unmapped custom scalar types default to 'any' or cause compilation errors

Add explicit type mappings for all custom schema scalars (e.g., DateTime -> string | Date) in the scalar configuration settings.

Frequently Asked Questions

What is the difference between client-side GraphQL types and backend resolver types?▼

Client-side types represent operation response data shapes, whereas resolver types define backend execution functions with signatures like (parent, args, context, info) => T.

Can I use generated resolver types with Apollo Server, GraphQL Yoga, and Mercurius?▼

Yes. The generated ResolverMap and type definitions conform to standard GraphQL-JS execution signatures and plug directly into makeExecutableSchema, Apollo Server, and Yoga.

How does the generator handle nullable and optional GraphQL fields?▼

Fields marked with '!' generate required return types, while unadorned fields are typed as T | null | undefined with optional argument properties.

Is my proprietary GraphQL SDL schema sent to an external server?▼

No. All SDL parsing, AST validation, and TypeScript code generation occur 100% locally in your browser with zero network requests or telemetry.

Related Tools & Utilities

All Tools →
cURL to C# Converter (.NET HttpClient, RestSharp & Flurl)developer

Translate command-line cURL requests into idiomatic C# code using .NET HttpClient, RestSharp, or Flurl.Http.

Open tool→
cURL to Java Converter (Java 11+ HttpClient, OkHttp & Spring WebClient)developer

Convert cURL commands into production-grade Java HTTP requests with native java.net.http.HttpClient, OkHttp3, or Spring WebClient.

Open tool→
JSON to XML Schema (XSD) Definition Generatordeveloper

Infer XML Schema Definition (XSD) type structures, complex elements, attributes, and minOccurs/maxOccurs rules from sample JSON.

Open tool→
Interactive .gitignore File Generator (Node, Python, Go, Rust, Java)developer

Generate comprehensive .gitignore templates by combining rules for operating systems, IDEs, and 50+ programming languages.

Open tool→
Cron Expression Parser & Schedule Explainerdeveloper

Translate cryptic 5-part and 6-part cron expressions into plain English explanations and predict the next 10 upcoming run dates.

Open tool→
Interactive JavaScript Regular Expression (RegEx) Tester & Matcherdeveloper

Test, debug, and benchmark regular expressions in real-time with capture group extraction, replacement previews, regex flag toggles, and syntax explanations.

Open tool→