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

GraphQL Code Generator plugin for generating TypeScript types for resolvers signature

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Plugin Function

Name: tessl/npm-graphql-codegen--typescript-resolvers
Author: tessl

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