GraphQL to TypeScript Resolvers
GraphQL Fullstack Engineering & Resolver Typing Suite

Guia do Desenvolvedor: Gerador de Tipos de Resolver TypeScript a partir de GraphQL SDL

Gere interfaces de resolver TypeScript fortemente tipadas, argumentos de query/mutation e tipos de contexto a partir de esquemas GraphQL SDL.

Zero Server Transmission
Presets:
Opções de Geração
Definição de Esquema 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)
Tipos Analisados15 TypesTipos de objetos, interfaces, uniões e enums reconhecidos na AST do SDL
Campos de Resolver9 FieldsAssinaturas de funções resolver e interfaces de argumentos geradas
Zero Dependências100% Client-SideCompilação instantânea na memória do navegador sem envio a servidores remotos

Conformidade Total com Especificação GraphQL

Processa queries, mutations, subscriptions, inputs, interfaces e diretivas com alta fidelidade sintática.

Síntese de Tipos sem Latência no Navegador

Tokenização e geração de código 100% no cliente. Seus esquemas e segredos permanecem protegidos localmente.

Pronto para Ambientes de Produção

Compatível com Apollo Server, GraphQL Yoga e Mercurius com mapeamentos avançados de contexto e modelos pai.

Referência técnica e guia de arquitetura

Guia do Desenvolvedor: Gerador de Tipos de Resolver TypeScript a partir de GraphQL SDL — Guia de referência

Gere interfaces de resolver TypeScript fortemente tipadas, argumentos de query/mutation e tipos de contexto a partir de esquemas GraphQL SDL.

Parâmetros principais e controles

Nome do Tipo de Contexto (Context Type Name)string

O identificador da interface de contexto injetada como terceiro parâmetro em todas as funções resolver.

Padrão: GraphQLContext
Encapsulamento de Retorno do Resolver (Resolver Return Wrapper)Enum (PromiseOrValue | PromiseOnly | DirectValue)

Estratégia de tipagem para o retorno dos resolvers (ex.: T | Promise<T> versus apenas Promise<T>).

Padrão: PromiseOrValue
Tipagem do Pai Raiz (Root Parent Typing)Enum (unknown | undefined | empty_object)

Estratégia de tipagem para o parâmetro inicial (parent/source) nos campos raiz de Query e Mutation.

Padrão: unknown
Mapeamento de Escalares Customizados (Custom Scalar Mapping)Record<string, string>

Vinculação de tipos TypeScript para escalares personalizados do GraphQL, como DateTime, JSON e UUID.

Padrão: {"DateTime": "string | Date", "JSON": "Record<string, unknown>"}

Dicas profissionais e melhores práticas

Combinação com DataLoader para Eliminar Problemas N+1

Defina seu tipo de contexto com instâncias tipadas do DataLoader para que resolvers aninhados executem carregamento em lote com total segurança.

Tipagem Estrita de Pais em Resolvers Aninhados

Resolvers de campos aninhados inferem automaticamente o formato resolvido do objeto pai (ex.: UserParent), prevenindo referências a propriedades inválidas.

União de Literais de String para Enums sem Overhead

Prefira uniões de literais de string em vez de enums numéricos do TypeScript para evitar código extra no runtime e maximizar o tree-shaking.

Problemas comuns e solução de problemas

Erro de incompatibilidade de tipos entre o retorno do resolver e o campo do esquema

Verifique se a função resolver retorna o tipo exato ou uma Promise compatível, respeitando as regras de nulidade e coleções do SDL.

Escalares customizados não mapeados resultam no tipo 'any' ou falhas de compilação

Adicione mapeamentos explícitos no painel de escalares para cada escalar do SDL (ex.: DateTime -> string | Date).

Perguntas frequentes (FAQ)

Qual a diferença entre tipos GraphQL do cliente e tipos de resolver do backend?▼

Os tipos de cliente representam os dados de resposta das operações, enquanto os tipos de resolver tipificam as funções de resolução no servidor: (parent, args, context, info) => T.

O código gerado é compatível com Apollo Server, GraphQL Yoga e Mercurius?▼

Sim. A interface de resolvers gerada segue os padrões do GraphQL-JS e integra-se diretamente ao makeExecutableSchema e aos principais frameworks.

Como os campos anuláveis e não nulos (!) são tratados?▼

Campos com '!' geram tipos de retorno obrigatórios, enquanto campos comuns são tipados estritamente como T | null | undefined.

Meu esquema GraphQL SDL é transmitido para algum servidor externo?▼

Não. A análise sintática do SDL, a validação de AST e a geração do código TypeScript ocorrem 100% no seu navegador com total privacidade.

Ferramentas e utilitários relacionados

Todas as ferramentas →
Guia do Desenvolvedor: Conversor de cURL para C# (.NET HttpClient, RestSharp e Flurl)developer

Converta comandos cURL em código C# idiomático para .NET HttpClient, RestSharp ou Flurl.Http com padrões assíncronos e melhores práticas de pool de conexões.

Abrir ferramenta→
Guia do Desenvolvedor: Conversor de cURL para Java (Java 11+ HttpClient, OkHttp e Spring WebClient)developer

Converta comandos cURL em requisições HTTP Java prontas para produção com java.net.http.HttpClient nativo, OkHttp3 ou Spring WebClient.

Abrir ferramenta→
Guia do Desenvolvedor: Gerador de Definições JSON para XML Schema (XSD)developer

Infira esquemas XML (XSD), estruturas de tipos complexos, atributos e regras de ocorrência minOccurs/maxOccurs a partir de dados JSON.

Abrir ferramenta→
Gerador Interativo de Arquivos .gitignore (Node, Python, Go, Rust, Java) Guia do Desenvolvedordeveloper

Gere modelos .gitignore abrangentes combinando regras para sistemas operacionais, IDEs e mais de 50 linguagens de programação.

Abrir ferramenta→
Sintaxe Crontab e Expressões Quartz Cheat Sheetdeveloper

Manual completo da sintaxe cron POSIX de 5 campos e Quartz de 6 campos. Macros, intervalos de execução e controle de sobreposição de tarefas.

Abrir ferramenta→
Guia de Expressões Regulares (RegEx) e Validação de Sintaxedeveloper

Folha de referência para sintaxe ECMAScript RegExp, grupos de captura nomeados, asserções lookaround e sinalizadores de execução.

Abrir ferramenta→