Add graphql lib and examples

Author: hirsch88

.env.example

@@ -30,6 +30,12 @@ DB_DATABASE="my_database"
 DB_SYNCHRONIZE=false
 DB_LOGGING=false
 
+#
+# GraphQL
+#
+GRAPHQL_ENABLED=true
+GRAPHQL_ROUTE="/graphql"
+
 #
 # Swagger
 #

.env.test

@@ -30,6 +30,12 @@ DB_DATABASE="my_database"
 DB_SYNCHRONIZE=false
 DB_LOGGING=false
 
+#
+# GraphQL
+#
+GRAPHQL_ENABLED=true
+GRAPHQL_ROUTE="/graphql"
+
 #
 # Swagger
 #

package.json

@@ -59,14 +59,17 @@
     "compression": "^1.7.1",
     "copyfiles": "^1.2.0",
     "cors": "^2.8.4",
+    "dataloader": "^1.3.0",
     "dotenv": "^4.0.0",
     "event-dispatch": "^0.4.1",
     "express": "^4.16.2",
     "express-basic-auth": "^1.1.3",
+    "express-graphql": "^0.6.11",
     "express-status-monitor": "^1.0.1",
     "faker": "^4.1.0",
     "figlet": "^1.2.0",
     "glob": "^7.1.2",
+    "graphql": "^0.11.7",
     "helmet": "^3.9.0",
     "jsonfile": "^4.0.0",
     "lodash": "^4.17.4",

src/api/queries/GetUsersQuery.ts

@@ -0,0 +1,22 @@
+import { GraphQLFieldConfig, GraphQLList } from 'graphql';
+import { Query, AbstractQuery, GraphQLContext } from './../../lib/graphql';
+import { UserService } from '../services/UserService';
+import { UserType } from './../types/UserType';
+import { User } from '../models/User';
+import { Logger } from '../../core/Logger';
+
+@Query()
+export class GetUsersQuery extends AbstractQuery<GraphQLContext<any, any>, User[], any> implements GraphQLFieldConfig {
+    public type = new GraphQLList(UserType);
+    public allow = [];
+    public args = {};
+
+    private log = new Logger(__filename);
+
+    public async run(root: any, args: any, context: GraphQLContext<any, any>): Promise<User[]> {
+        const users = await context.container.get<UserService>(UserService).find();
+        this.log.info(`Found ${users.length} users`);
+        return users;
+    }
+
+}

src/api/types/UserType.ts

@@ -0,0 +1,32 @@
+import {
+    GraphQLID,
+    GraphQLString,
+    GraphQLObjectType,
+} from 'graphql';
+
+export const UserType = new GraphQLObjectType({
+    name: 'User',
+    description: 'A single user.',
+    fields: {
+        id: {
+            type: GraphQLID,
+            description: 'The ID',
+        },
+        firstName: {
+            type: GraphQLString,
+            description: 'The first name of the user.',
+        },
+        lastName: {
+            type: GraphQLString,
+            description: 'The last name of the user.',
+        },
+        email: {
+            type: GraphQLString,
+            description: 'The email of this user.',
+        },
+        // pets: {
+        //     type: GraphQLString,
+        //     description: 'The personal number of this user.‚',
+        // },
+    },
+});

src/app.ts

@@ -20,6 +20,7 @@ import { monitorLoader } from './loaders/monitorLoader';
 import { homeLoader } from './loaders/homeLoader';
 import { publicLoader } from './loaders/publicLoader';
 import { iocLoader } from './loaders/iocLoader';
+import { graphqlLoader } from './loaders/graphqlLoader';
 import { eventDispatchLoader } from './loaders/eventDispatchLoader';
 
 
@@ -38,6 +39,7 @@ bootstrapMicroframework({
         monitorLoader,
         homeLoader,
         publicLoader,
+        graphqlLoader,
     ],
 })
     .then(() => banner(log))

src/core/banner.ts

@@ -13,6 +13,9 @@ export function banner(log: Logger): void {
         log.info(`Version      : ${env.app.version}`);
         log.info(``);
         log.info(`API Info     : ${env.app.route}${env.app.routePrefix}`);
+        if (env.graphql.enabled) {
+            log.info(`GraphQL      : ${env.app.route}${env.graphql.route}`);
+        }
         if (env.swagger.enabled) {
             log.info(`Swagger      : ${env.app.route}${env.swagger.route}`);
         }

src/core/env.ts

@@ -13,6 +13,8 @@ dotenv.config({ path: path.join(process.cwd(), `.env${((process.env.NODE_ENV ===
 export const env = {
     node: process.env.NODE_ENV || 'development',
     isProduction: process.env.NODE_ENV === 'production',
+    isTest: process.env.NODE_ENV === 'test',
+    isDevelopment: process.env.NODE_ENV === 'development',
     app: {
         name: getOsEnv('APP_NAME'),
         version: (pkg as any).version,
@@ -29,6 +31,8 @@ export const env = {
             controllers: [path.join(__dirname, '..', 'api/**/*Controller{.js,.ts}')],
             middlewares: [path.join(__dirname, '..', 'api/**/*Middleware{.js,.ts}')],
             interceptors: [path.join(__dirname, '..', 'api/**/*Interceptor{.js,.ts}')],
+            queries: [path.join(__dirname, '..', 'api/**/*Query{.js,.ts}')],
+            mutations: [path.join(__dirname, '..', 'api/**/*Mutation{.js,.ts}')],
         },
     },
     log: {
@@ -49,6 +53,10 @@ export const env = {
         synchronize: toBool(getOsEnv('DB_SYNCHRONIZE')),
         logging: toBool(getOsEnv('DB_LOGGING')),
     },
+    graphql: {
+        enabled: toBool(getOsEnv('GRAPHQL_ENABLED')),
+        route: getOsEnv('GRAPHQL_ROUTE'),
+    },
     swagger: {
         enabled: toBool(getOsEnv('SWAGGER_ENABLED')),
         route: getOsEnv('SWAGGER_ROUTE'),

src/lib/graphql/AbstractGraphQLHooks.ts

@@ -0,0 +1,35 @@
+import { UserError } from './graphql-error-handling';
+
+// export interface GraphQLHooks {
+//     before<C, A, S>(context: C, args: A, source?: S): Promise<A> | A;
+//     after<R, C, A, S>(result: R, context: C, args: A, source?: S): Promise<R> | R;
+//     run<S, A, C, R>(rootOrSource: S, args: A, context: C): Promise<R> | Promise<undefined> | R | undefined;
+// }implements GraphQLHooks
+
+export abstract class AbstractGraphQLHooks<TContext, TResult, TArgs>  {
+
+    /**
+     * This is our before hook. Here you are able
+     * to alter the args object before the actual resolver(execute)
+     * will be called.
+     */
+    public before<S>(context: TContext, args: TArgs, source?: S): Promise<TArgs> | TArgs {
+        return args;
+    }
+
+    /**
+     * This our after hook. It will be called ater the actual resolver(execute).
+     * There you are able to alter the result before it is send to the client.
+     */
+    public after<S>(result: TResult, context: TContext, args?: TArgs, source?: S): Promise<TResult> | TResult {
+        return result;
+    }
+
+    /**
+     * This our resolver, which should gather the needed data;
+     */
+    public run<S>(rootOrSource: S, args: TArgs, context: TContext): Promise<TResult> | TResult {
+        throw new UserError('Query not implemented!');
+    }
+
+}

src/lib/graphql/AbstractGraphQLQuery.ts

@@ -0,0 +1,20 @@
+import { AbstractGraphQLHooks } from './AbstractGraphQLHooks';
+
+
+export abstract class AbstractQuery<TContext, TResult, TArgs> extends AbstractGraphQLHooks<TContext, TResult, TArgs> {
+
+    /**
+     * This will be called by graphQL and they need to have it not as a
+     * member function of this class. We use this hook to add some more logic
+     * to it, like permission checking and before and after hooks to alter some data.
+     */
+    public resolve = async <S>(root: S, args: TArgs, context: TContext): Promise<TResult> => {
+        // We need to store the query arguments in the context so they can be accessed by subsequent resolvers
+        (context as any).resolveArgs = args;
+        args = await this.before(context, args);
+        let result = await this.run<S>(root, args, context);
+        result = await this.after(result, context, args);
+        return (result as TResult);
+    }
+
+}