or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

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

tile.json

Plugin Function

The main plugin function is the core entry point for the GraphQL Code Generator typescript-resolvers plugin. It processes GraphQL schemas and generates TypeScript resolver signatures.

Capabilities

Main Plugin Function

Processes a GraphQL schema and generates TypeScript resolver type definitions.

/**
 * Main GraphQL Code Generator plugin function for generating TypeScript resolver signatures
 * @param schema - The GraphQL schema to process
 * @param documents - GraphQL documents (queries, mutations, subscriptions) - typically empty for this plugin
 * @param config - Configuration options for the plugin
 * @returns Plugin output containing generated TypeScript code and metadata
 */
function plugin(
  schema: GraphQLSchema,
  documents: Types.DocumentFile[],
  config: TypeScriptResolversPluginConfig
): Promise<Types.ComplexPluginOutput<{
  generatedResolverTypes: RootResolver['generatedResolverTypes'];
}>>;

Usage Example:

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

const schema = buildSchema(`
  type Query {
    users: [User!]!
    user(id: ID!): User
  }
  
  type User {
    id: ID!
    name: String!
    email: String!
  }
`);

const result = await plugin(schema, [], {
  contextType: './context#Context',
  mappers: {
    User: './models#UserModel'
  }
});

// result.content contains the generated TypeScript code
// result.prepend contains import statements
// result.meta contains metadata about generated types

Plugin Output Type

The plugin returns a complex output object containing generated code and metadata.

interface Types.ComplexPluginOutput<TMeta = {}> {
  /** The main generated content */
  content: string;
  /** Import statements and other code to prepend */
  prepend: string[];
  /** Additional metadata about the generation */
  meta: TMeta;
}

Generated Resolver Types Metadata

The plugin provides metadata about the generated resolver types.

interface RootResolver {
  generatedResolverTypes: Record<string, string>;
}

Example Generated Output:

// Example of what the plugin generates
export type ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => Promise<TResult> | TResult;

export type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
  users?: Resolver<Array<UserModel>, ParentType, ContextType>;
  user?: Resolver<Maybe<UserModel>, ParentType, ContextType, RequireFields<QueryUserArgs, 'id'>>;
};

export type UserResolvers<ContextType = Context, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']> = {
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  email?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
};

export type Resolvers<ContextType = Context> = {
  Query?: QueryResolvers<ContextType>;
  User?: UserResolvers<ContextType>;
};

Internal Processing Steps

The plugin performs several key processing steps:

Schema Analysis: Analyzes the GraphQL schema structure and types
Configuration Processing: Processes plugin configuration options and applies defaults
Import Generation: Generates necessary import statements based on configuration
Type Mapping: Applies custom type mappers and directive resolver mappings
Visitor Execution: Uses the TypeScriptResolversVisitor to traverse the schema AST
Code Generation: Generates resolver signatures, subscription types, and enum resolvers
Federation Support: Adds Federation-specific types if federation is enabled
Output Assembly: Combines all generated code into the final output

Advanced Usage with Federation:

const result = await plugin(schema, [], {
  federation: true,
  contextType: './context#Context',
  mappers: {
    User: './models#UserModel'
  }
});

// Generates additional Federation-specific types like ReferenceResolver

Advanced Usage with Custom Resolver Function:

const result = await plugin(schema, [], {
  customResolverFn: './types#CustomResolver',
  contextType: './context#Context'
});

// Uses custom resolver function signature instead of default ResolverFn