This project is inspired by Apollo-codegen. Currently apollo-codegen only generate TypeScripts for GraphQL Client. The shape of the generated type is based on the client's query strings.
This module aim to do the Server counterpart: from a Schema Definition, generate the types to make it type-safed when developing GraphQL server (mainly resolvers)
Support Typescript string enum with fallback to string union (fallback not tested yet)
import { generateTypeScriptTypes } from 'graphql-schema-typescript';
generateTypeScriptTypes(schema, outputPath, options)
.then(() => {
console.log('DONE');
process.exit(0);
})
.catch(err =>{
console.error(err);
process.exit(1);
});
You can then bootstrap this script on your dev server, or use something like ts-node to execute it directly
schema
: your graphql schemaoutputPath
: where the types is generatedoptions
: see GenerateTypescriptOptions
- You can also use CLIs to generate your TypeScript instead of writing code
- Instead of providing a schema, you need to provide a folder that contains your type definitions, written in .gql or .graphql extensions
- Use
graphql-schema-typescript generate-ts --help
for more details
The file generated will have some types that can make it type-safed when writing resolver:
- Args type in your resolve function is now type-safed
- Parent type and resolve result is still
any
, but could be overwritten in your code
For example, if you schema is like this:
schema {
query: RootQuery
}
type RootQuery {
Users(input: UserFilter): [User!]!
# ... some more fields here
}
input UserFilter {
username: [String]
}
type User {
firstName: String!
# ... some more fields here
}
Then the tools will generate TypeScripts like this:
/**
* This interface define the shape of your resolver
* Note that this type is designed to be compatible with graphql-tools resolvers
* However, you can still use other generated interfaces to make your resolver type-safed
*/
export interface GQLResolver {
RootQuery?: GQLRootQueryTypeResolver;
User?: GQLUserTypeResolver;
}
export interface GQLRootQueryTypeResolver {
Users?: RootQueryToUsersResolver;
}
export interface RootQueryToUsersArgs {
Users?: GQLUserFilter;
}
export interface RootQueryToUsersResolver<TParent = any, TResult = any> {
(parent: TParent, args: RootQueryToUsersArgs, context: any, info: GraphQLResolveInfo): TResult;
}
In this example, if you are not using graphql-tools,
you can still use RootQueryToUsersResolver
type to make your args type safed.
- More detailed API Documentation
- Integrate with Travis CI
-
v1.2.1:
- Added strict nulls option for compatibility with apollo-codegen
-
v1.2.0:
- Field resolvers under subscriptions are being generated with resolve and subscribe method
-
v1.1.0:
- Add CLIs support
-
v1.0.6:
- Generate TypeScript for resolvers. See Type Resolvers
-
v1.0.4:
- If types is generated under global scope, use string union instead of string enum
-
v1.0.2:
- Change default prefix from
GQL_
toGQL
- Add config options: allow to generate types under a global or namespace declaration
- Change default prefix from