or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

configuration.md index.md plugin-function.md visitor.md

tile.json

tessl/npm-graphql-codegen--typescript-resolvers

GraphQL Code Generator plugin for generating TypeScript types for resolvers signature

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:npm/@graphql-codegen/typescript-resolvers@4.5.x

To install, run

npx @tessl/cli install tessl/npm-graphql-codegen--typescript-resolvers@4.5.0

GraphQL Code Generator TypeScript Resolvers Plugin

GraphQL Code Generator plugin that generates TypeScript signatures for GraphQL resolver functions, providing type safety and consistency between GraphQL schema definitions and their corresponding TypeScript implementations. It analyzes GraphQL schemas and generates strongly-typed resolver interfaces that include proper typing for arguments, context, return types, and GraphQL resolve info.

Package Information

Package Name: @graphql-codegen/typescript-resolvers
Package Type: npm
Language: TypeScript
Installation: npm install @graphql-codegen/typescript-resolvers
Peer Dependencies: graphql, @graphql-codegen/cli
Optional Peer Dependencies: graphql-sock (for semantic non-null custom directives)

Core Imports

import { plugin } from "@graphql-codegen/typescript-resolvers";

For CommonJS:

const { plugin } = require("@graphql-codegen/typescript-resolvers");

For configuration types and visitor class:

import { 
  TypeScriptResolversPluginConfig,
  TypeScriptResolversVisitor 
} from "@graphql-codegen/typescript-resolvers";

Basic Usage

This plugin is used as part of GraphQL Code Generator configuration to generate TypeScript resolver signatures:

import type { CodegenConfig } from '@graphql-codegen/cli';

const config: CodegenConfig = {
  schema: 'path/to/schema.graphql',
  generates: {
    'src/generated/resolvers-types.ts': {
      plugins: ['typescript', 'typescript-resolvers'],
      config: {
        contextType: './context#Context',
        mappers: {
          User: './models#UserModel'
        }
      }
    }
  }
};

export default config;

Architecture

The plugin consists of several key components:

Plugin Function: Main entry point that processes GraphQL schemas and generates resolver types
Configuration System: Extensive configuration options for customizing output and behavior
Visitor Pattern: AST visitor that traverses GraphQL schema definitions and generates TypeScript code
Type Generation: Creates resolver signatures, subscription handlers, and enum resolvers
Federation Support: Built-in support for Apollo Federation reference resolvers
Schema Stitching: Optional support for GraphQL schema stitching patterns

Capabilities

Core Plugin Function

Main plugin function that generates TypeScript resolver signatures from GraphQL schemas.

function plugin(
  schema: GraphQLSchema,
  documents: Types.DocumentFile[],
  config: TypeScriptResolversPluginConfig
): Promise<Types.ComplexPluginOutput<{
  generatedResolverTypes: RootResolver['generatedResolverTypes'];
}>>;

Plugin Function

Plugin Configuration

Comprehensive configuration options for customizing resolver generation behavior, including type mappings, custom resolvers, and output formatting.

interface TypeScriptResolversPluginConfig extends RawResolversConfig {
  useIndexSignature?: boolean;
  noSchemaStitching?: boolean;
  wrapFieldDefinitions?: boolean;
  customResolveInfo?: string;
  customResolverFn?: string;
  directiveResolverMappings?: Record<string, string>;
  allowParentTypeOverride?: boolean;
  optionalInfoArgument?: boolean;
  makeResolverTypeCallable?: boolean;
}

Configuration Options

Type Generation Visitor

Advanced visitor class that handles AST traversal and generates TypeScript code with proper type safety and customization.

class TypeScriptResolversVisitor extends BaseResolversVisitor<
  TypeScriptResolversPluginConfig,
  ParsedTypeScriptResolversConfig
> {
  constructor(pluginConfig: TypeScriptResolversPluginConfig, schema: GraphQLSchema);
  
  transformParentGenericType(parentType: string): string;
  formatRootResolver(schemaTypeName: string, resolverType: string, declarationKind: DeclarationKind): string;
  ListType(node: ListTypeNode): string;
  NamedType(node: NamedTypeNode): string;
  NonNullType(node: NonNullTypeNode): string;
  buildEnumResolverContentBlock(node: EnumTypeDefinitionNode, mappedEnumType: string): string;
}

Visitor Implementation

Generated Types

The plugin generates comprehensive TypeScript type definitions for resolvers:

Core Resolver Types

// Basic resolver function signature
type ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => Promise<TResult> | TResult;

// Resolver type (union of all resolver variants)
type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = 
  | ResolverFn<TResult, TParent, TContext, TArgs>
  | ResolverWithResolve<TResult, TParent, TContext, TArgs>;

// Root resolvers object
type Resolvers<ContextType = any> = ResolversObject<{
  Query?: QueryResolvers<ContextType>;
  Mutation?: MutationResolvers<ContextType>;
  Subscription?: SubscriptionResolvers<ContextType>;
  // ... generated types for each GraphQL type
}>;

Subscription Types

type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;

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

interface 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>;
}

Advanced Types

// Type resolver for unions/interfaces
type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
  parent: TParent,
  context: TContext,
  info: GraphQLResolveInfo
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

// Type guard function
type IsTypeOfResolverFn<T = {}, TContext = {}> = (
  obj: T, 
  context: TContext, 
  info: GraphQLResolveInfo
) => boolean | Promise<boolean>;

// Directive resolver function
type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
  next: NextResolverFn<TResult>,
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

// Enum resolver signature
type EnumResolverSignature<T, AllowedValues = any> = { 
  [key in keyof T]?: AllowedValues 
};