Standalone

import { ApolloServer } from 'apollo-server';

import { schema } from './schema';
import { injectorContext } from './app';

await new ApolloServer({
  schema,
  context: () => {
    const gqlInjectorContext = injectorContext.createChildScope('graphql');
    // You can do whatever you want with the GraphQL injector context here
    return {
      injectorContext: gqlInjectorContext,
    };
  },
}).listen();

import * as user from './user/types';

export const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: () => ({
      user: user.queries,
    }),
  }),
  mutation: new GraphQLObjectType({
    name: 'Mutation',
    fields: () => ({
      user: user.mutations,
    }),
  }),
});

import { App } from '@deepkit/app';
import { GraphQLModule, Resolvers, TypesBuilder } from '@deepkit-graphql/core';

import { UserModule } from './user/user.module';

const gqlModule = new GraphQLModule();

export const app = new App({
  imports: [gqlModule, new UserModule()],
});

export const injectorContext = app.serviceContainer.getInjectorContext();

export const builder = new TypesBuilder(gqlModule.resolvers);

import { createModule } from '@deepkit/app';

import { UserResolver } from './user.resolver';

export class UserModule extends createModule({
  controllers: [UserResolver],
}) {}

import { graphql } from '@deepkit-graphql/core';

export interface User {
  // ...
}

@graphql.resolver<User>()
export class UserResolver {
  @graphql.query()
  get(): Promise<User> {
    // ...
  }

  @graphql.mutation()
  create(): Promise<User> {
    // ...
  }
}

import { GraphQLObjectType } from 'graphql';

import { builder } from '../app';
import { UserResolver } from './user.resolver';

export const queries = {
  type: new GraphQLObjectType({
    name: 'UserQueries',
    fields: () =>
      builder.generateQueryResolverFields({
        controller: UserResolver,
      }),
  }),
};

export const mutations = {
  type: new GraphQLObjectType({
    name: 'UserMutations',
    fields: () =>
      builder.generateMutationResolverFields({
        controller: UserResolver,
      }),
  }),
};