Add data-loaders

Author: hirsch88

src/api/models/Pet.ts

@@ -1,4 +1,4 @@
-import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn } from 'typeorm';
 import { IsNotEmpty } from 'class-validator';
 import { User } from './User';
 
@@ -17,7 +17,11 @@ export class Pet {
     @Column()
     public age: number;
 
+    @Column()
+    public userId: number;
+
     @ManyToOne(type => User, user => user.pets)
+    @JoinColumn({ name: 'userId' })
     public user: User;
 
     public toString(): string {

src/api/queries/GetPetsQuery.ts

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

src/api/repositories/PetRepository.ts

@@ -2,6 +2,16 @@ import { Repository, EntityRepository } from 'typeorm';
 import { Pet } from '../models/Pet';
 
 @EntityRepository(Pet)
-export class PetRepository extends Repository<Pet>  {
+export class PetRepository extends Repository<Pet> {
+
+    /**
+     * Find by userId is used for our data-loader to get all needed pets in one query.
+     */
+    public findByUserIds(ids: string[]): Promise<Pet[]> {
+        return this.createQueryBuilder()
+            .select()
+            .where(`pet.userId IN (${ids.map(id => `'${id}'`).join(', ')})`)
+            .getMany();
+    }
 
 }

src/api/types/PetType.ts

@@ -3,23 +3,43 @@ import {
     GraphQLString,
     GraphQLInt,
     GraphQLObjectType,
+    GraphQLFieldConfigMap,
 } from 'graphql';
+import { merge } from 'lodash';
+import { OwnerType } from './UserType';
+import { Pet } from '../models/Pet';
+import { GraphQLContext } from '../../lib/graphql';
+
+const PetFields: GraphQLFieldConfigMap = {
+    id: {
+        type: GraphQLID,
+        description: 'The ID',
+    },
+    name: {
+        type: GraphQLString,
+        description: 'The name of the pet.',
+    },
+    age: {
+        type: GraphQLInt,
+        description: 'The age of the pet in years.',
+    },
+};
+
+export const PetOfUserType = new GraphQLObjectType({
+    name: 'PetOfUser',
+    description: 'A users pet',
+    fields: () => merge<GraphQLFieldConfigMap, GraphQLFieldConfigMap>(PetFields, {}),
+});
 
 export const PetType = new GraphQLObjectType({
     name: 'Pet',
     description: 'A single pet.',
-    fields: {
-        id: {
-            type: GraphQLID,
-            description: 'The ID',
-        },
-        name: {
-            type: GraphQLString,
-            description: 'The name of the pet.',
+    fields: () => merge<GraphQLFieldConfigMap, GraphQLFieldConfigMap>(PetFields, {
+        owner: {
+            type: OwnerType,
+            description: 'The owner of the pet',
+            resolve: (pet: Pet, args: any, context: GraphQLContext<any, any>) =>
+                context.dataLoaders.users.load(pet.userId),
         },
-        age: {
-            type: GraphQLInt,
-            description: 'The age of the pet in years.',
-        },
-    },
+    }),
 });

src/api/types/UserType.ts

@@ -1,39 +1,52 @@
-import { PetService } from './../services/PetService';
 import {
     GraphQLID,
     GraphQLString,
     GraphQLObjectType,
+    GraphQLFieldConfigMap,
     GraphQLList,
 } from 'graphql';
-import { PetType } from './PetType';
-import { User } from '../models/User';
+import { merge } from 'lodash';
 import { GraphQLContext } from '../../lib/graphql';
+import { PetOfUserType } from './PetType';
+import { User } from '../models/User';
+
+const UserFields: GraphQLFieldConfigMap = {
+    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.',
+    },
+};
 
 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.',
-        },
+    fields: () => merge<GraphQLFieldConfigMap, GraphQLFieldConfigMap>(UserFields, {
         pets: {
-            type: new GraphQLList(PetType),
+            type: new GraphQLList(PetOfUserType),
             description: 'The pets of a user',
-            resolve: (user: User, args: any, context: GraphQLContext<any, any>) =>
-                context.container.get<PetService>(PetService).findByUser(user),
+            resolve: async (user: User, args: any, context: GraphQLContext<any, any>) =>
+                // We use data-loaders to save db queries
+                context.dataLoaders.petByUserIds.loadMany([user.id]),
+                // This would be the case with a normal service, but not very fast
+                // context.container.get<PetService>(PetService).findByUser(user),
         },
-    },
+    }),
+});
+
+export const OwnerType = new GraphQLObjectType({
+    name: 'Owner',
+    description: 'The owner of a pet',
+    fields: () => merge<GraphQLFieldConfigMap, GraphQLFieldConfigMap>(UserFields, {}),
 });

src/lib/graphql/GraphQLContext.ts

@@ -1,10 +1,16 @@
 import * as express from 'express';
+import * as DataLoader from 'dataloader';
 import { Container } from 'typedi';
 
 export interface GraphQLContext<TData, TResolveArgs> {
     container: typeof Container;
     request: express.Request;
     response: express.Response;
+    dataLoaders: GraphQLContextDataLoader;
     resolveArgs?: TResolveArgs;
     data?: TData;
 }
+
+export interface GraphQLContextDataLoader {
+    [key: string]: DataLoader<number | string, any>;
+}

src/lib/graphql/dataloader.ts

@@ -0,0 +1,21 @@
+export interface Identifiable {
+    id?: number | number;
+}
+
+export function ensureInputOrder<T extends Identifiable>(ids: number[] | string[], result: T[], key: string): T[] {
+    // For the dataloader batching to work, the results must be in the same order and of the
+    // same length as the ids. See: https://github.com/facebook/dataloader#batch-function
+    const orderedResult: T[] = [];
+    for (const id of ids) {
+        const item = result.find(t => t[key] === id);
+        if (item) {
+            orderedResult.push(item);
+        } else {
+            /* tslint:disable */
+            // @ts-ignore
+            orderedResult.push(null);
+            /* tslint:enable */
+        }
+    }
+    return orderedResult;
+}

src/lib/graphql/index.ts

@@ -1,12 +1,15 @@
 import * as express from 'express';
 import * as GraphQLHTTP from 'express-graphql';
+import * as DataLoader from 'dataloader';
 import { GraphQLSchema, GraphQLObjectType } from 'graphql';
-import { Container as container } from 'typedi';
+import { Container as container, ObjectType } from 'typedi';
 
-import { GraphQLContext } from './GraphQLContext';
+import { GraphQLContext, GraphQLContextDataLoader } from './GraphQLContext';
 import { MetadataArgsStorage } from './MetadataArgsStorage';
 import { importClassesFromDirectories } from './importClassesFromDirectories';
 import { handlingErrors, getErrorCode, getErrorMessage } from './graphql-error-handling';
+import { ensureInputOrder } from './dataloader';
+import { Repository, getCustomRepository, getRepository } from 'typeorm';
 
 // -------------------------------------------------------------------------
 // Main exports
@@ -24,13 +27,41 @@ export * from './graphql-error-handling';
 // Main Functions
 // -------------------------------------------------------------------------
 
+/**
+ * Creates a new dataloader wiht the typorm repository
+ */
+export function createDataLoader<T>(obj: ObjectType<T>, method?: string, key?: string): DataLoader<any, any> {
+    let repository;
+    try {
+        repository = getCustomRepository<Repository<any>>(obj);
+    } catch (errorRepo) {
+        try {
+            repository = getRepository(obj);
+        } catch (errorModel) {
+            throw new Error('Could not create a dataloader, because obj is nether model or repository!');
+        }
+    }
+
+    return new DataLoader(async (ids: number[]) => {
+        let items = [];
+        if (method) {
+            items = await repository[method](ids);
+        } else {
+            items = await repository.findByIds(ids);
+        }
+
+        return ensureInputOrder(ids, items, key || 'id');
+    });
+}
+
 /**
  * Defines the options to create a GraphQLServer
  */
 export interface GraphQLServerOptions<TData> {
     queries: string[];
     mutations: string[];
     route?: string;
+    dataLoaders?: GraphQLContextDataLoader;
     editorEnabled?: boolean;
     contextData?: TData;
 }
@@ -56,6 +87,7 @@ export function createGraphQLServer<TData>(expressApp: express.Application, opti
             container,
             request,
             response,
+            dataLoaders: options.dataLoaders || {},
             resolveArgs: {},
             data: options.contextData,
         };

src/loaders/graphqlLoader.ts

@@ -1,6 +1,9 @@
 import { MicroframeworkSettings, MicroframeworkLoader } from 'microframework';
-import { createGraphQLServer } from '../lib/graphql';
+import { createGraphQLServer, createDataLoader } from '../lib/graphql';
 import { env } from '../core/env';
+import { PetRepository } from './../api/repositories/PetRepository';
+import { Pet } from './../api/models/Pet';
+import { UserRepository } from './../api/repositories/UserRepository';
 
 
 export const graphqlLoader: MicroframeworkLoader = (settings: MicroframeworkSettings | undefined) => {
@@ -12,6 +15,11 @@ export const graphqlLoader: MicroframeworkLoader = (settings: MicroframeworkSett
             editorEnabled: env.graphql.enabled,
             queries: env.app.dirs.queries,
             mutations: env.app.dirs.queries,
+            dataLoaders: {
+                users: createDataLoader(UserRepository),
+                pets: createDataLoader(Pet),
+                petByUserIds: createDataLoader(PetRepository, 'findByUserIds', 'userId'),
+            },
         });
 
     }