Graphql example

package.json

@@ -16,6 +16,8 @@
     "awilix": "^4.3.4",
     "dotenv": "^10.0.0",
     "express": "^4.17.1",
+    "express-graphql": "^0.12.0",
+    "graphql": "^15.6.1",
     "joi": "^17.4.1",
     "lodash.template": "^4.5.0",
     "mongodb": "^4.0.0",

src/_boot/graphql.ts

@@ -0,0 +1,47 @@
+import { asValue } from 'awilix';
+import { graphqlHTTP } from 'express-graphql';
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
+
+import { makeSchemaStorage, RegisterSchema } from '@/_lib/graphql/schema';
+import { makeModule } from '@/context';
+import { config } from '@/config';
+
+const graphql = makeModule('graphql', async ({ app: { onBooted }, container: { build, register, cradle } }) => {
+  const { getSchemaData, registerSchema } = build(makeSchemaStorage);
+
+  onBooted(async () => {
+    const { queries } = getSchemaData();
+
+    build(({ server }) => {
+      server.use(
+        '/graphql',
+        graphqlHTTP({
+          schema: new GraphQLSchema({
+            query: new GraphQLObjectType({
+              name: 'Query',
+              description: 'The root of all queries',
+              fields: () => ({
+                ...queries,
+              }),
+            }),
+          }),
+          graphiql: config.environment !== 'production',
+          context: {
+            container: cradle,
+          },
+        })
+      );
+    });
+  }, 'prepend');
+
+  register({
+    registerSchema: asValue(registerSchema),
+  });
+});
+
+type GraphQLRegistry = {
+  registerSchema: RegisterSchema;
+};
+
+export { graphql };
+export type { GraphQLRegistry };

src/_boot/index.ts

@@ -9,6 +9,7 @@ import { Logger } from 'pino';
 import { pubSub } from '@/_boot/pubSub';
 import { MessageBundle } from '@/messages';
 import { swagger } from '@/_boot/swagger';
+import { graphql } from '@/_boot/graphql';
 
 const main = withContext(async ({ app, container, config, bootstrap, logger, messageBundle }) => {
   container.register({
@@ -19,7 +20,7 @@ const main = withContext(async ({ app, container, config, bootstrap, logger, mes
     config: asValue(config),
   });
 
-  await bootstrap(database, server, swagger, pubSub, repl, ...appModules);
+  await bootstrap(database, server, graphql, swagger, pubSub, repl, ...appModules);
 });
 
 type MainRegistry = {

src/_lib/graphql/Graphql.d.ts

@@ -0,0 +1,32 @@
+import { Registry } from '@/container';
+import { GraphQLFieldConfig, GraphQLFieldResolver } from 'graphql';
+
+type GraphQLContext = {
+  container: Registry;
+};
+
+type Sort = Readonly<{
+  field: string;
+  direction: 'asc' | 'desc';
+}>;
+
+type Pagination = Readonly<{
+  page: number;
+  pageSize: number;
+}>;
+
+type Filter = Record<string, any>;
+
+type Args = {
+  pagination: Pagination;
+  filter: Filter;
+  sort: Sort[];
+}
+
+type GraphQLResolver = GraphQLFieldResolver<any, GraphQLContext, Args>
+
+type GraphQLQueryMap<TSource, TContext> = {
+  [key: string]: GraphQLFieldConfig<TSource, TContext, Args>;
+} 
+
+export { GraphQLContext, GraphQLQueryMap, GraphQLResolver };

src/_lib/graphql/schema.ts

@@ -0,0 +1,37 @@
+type SchemaData = {
+  queries: any;
+  mutations: any;
+};
+
+type RegisterSchema = (schemaData: SchemaData) => void 
+type GetSchemaData = () => SchemaData;
+
+type MakeSchemaStorage = {
+  getSchemaData: GetSchemaData;
+  registerSchema: RegisterSchema;
+}
+
+const makeSchemaStorage = (): MakeSchemaStorage => {
+  let queries = {};
+  let mutations = {};
+
+  return {
+    getSchemaData: () => ({ queries, mutations }),
+    registerSchema: (schemaData: SchemaData): void => {
+      queries = { ...queries, ...schemaData.queries };
+      mutations = { ...mutations, ...schemaData.mutations };
+    },
+  };
+};
+
+type Dependencies = {
+  registerSchema: RegisterSchema;
+};
+
+const withSchemaRegister =
+  (schemaData: SchemaData) =>
+  ({ registerSchema }: Dependencies): void =>
+    registerSchema(schemaData);
+
+export { makeSchemaStorage, withSchemaRegister };
+export type { RegisterSchema }

src/_sharedKernel/interface/graphql/TypeDefs.ts

@@ -0,0 +1,41 @@
+import { 
+  GraphQLEnumType, 
+  GraphQLInputObjectType, 
+  GraphQLInt, 
+  GraphQLList, 
+  GraphQLString,
+} from "graphql";
+
+const PaginationType = new GraphQLInputObjectType({
+  name: 'Pagination',
+  fields: () => ({
+    page: {
+      type: GraphQLInt,
+      defaultValue: 1
+    },
+    pageSize: {
+      type: GraphQLInt,
+      defaultValue: 10
+    }
+  })
+})
+
+const SortType = GraphQLList(new GraphQLInputObjectType({
+  name: 'Sort',
+  fields: () => ({
+    field: {
+      type: GraphQLString,
+    },
+    direction: {
+      type: new GraphQLEnumType({
+        name: 'Direction',
+        values: {
+          asc: { value: 'asc' },
+          desc: { value: 'desc' },
+        }
+      })
+    }
+  })
+}))
+
+export { PaginationType, SortType }

src/article/__tests__/integration/interface/graphql/ArticleResolver.spec.ts

@@ -0,0 +1,72 @@
+import { randomBytes } from 'crypto';
+import { makeTestControls, TestControls } from '@/__tests__/TestControls';
+
+describe('ArticleResolver', () => {
+  let controls: TestControls;
+
+  beforeAll(async () => {
+    controls = await makeTestControls();
+  });
+
+  // beforeEach(async () => {
+  //   const { clearDatabase } = controls;
+
+  //   await clearDatabase();
+  // });
+
+  // afterAll(async () => {
+  //   const { cleanUp } = controls;
+
+  //   await cleanUp();
+  // });
+
+  describe('QUERY Articles', () => {
+    it('gets the first page of articles', async () => {
+      const { request } = controls;
+
+      const title = randomBytes(20).toString('hex');
+      const content = 'New Article content';
+      const getArticlesQuery = `
+          query Articles($filter: ArticleFilter, $sort: [Sort], $pagination: Pagination) {
+            articles(filter: $filter, sort: $sort, pagination: $pagination) {
+              id
+              title
+              comments {
+                id
+                body
+                createdAt
+              }
+            }
+          }
+        `;
+      const variables = {
+        pagination: {
+          page: 1,
+          pageSize: 10,
+        },
+      };
+
+      const response = await request().post('/api/articles').send({
+        title,
+        content,
+      });
+
+      await request().patch(`/api/articles/${response.body.id}/publish`);
+
+      return request()
+        .post('/graphql')
+        .send({
+          operationName: 'Articles',
+          query: getArticlesQuery,
+          variables,
+        })
+        .expect(async (res) => {
+          console.log(res);
+          expect(res.status).toBe(200);
+          const { data } = res.body;
+          expect(data).toHaveProperty('articles');
+          expect(data.articles).toHaveLength(1);
+        });
+    });
+  });
+});

src/article/index.ts

@@ -13,6 +13,8 @@ import { makeMongoFindArticles } from '@/article/query/impl/MongoFindArticles';
 import { makeModule } from '@/context';
 import { makeArticleCreatedEmailListener } from '@/article/interface/email/ArticleCreatedEmailListener';
 import { articleMessages } from '@/article/messages';
+import { withSchemaRegister } from '@/_lib/graphql/schema';
+import { articleQueries } from './interface/graphql';
 
 const articleModule = makeModule(
   'article',
@@ -34,6 +36,13 @@ const articleModule = makeModule(
       findArticles: asFunction(makeMongoFindArticles),
     });
 
+    build(
+      withSchemaRegister({
+        queries: articleQueries,
+        mutations: {},
+      })
+    );
+
     build(makeArticleController);
     build(makeArticleCreatedEmailListener);
   }

src/article/interface/graphql/ArticleResolver.ts

@@ -0,0 +1,12 @@
+import { GraphQLResolver } from '@/_lib/graphql/Graphql';
+
+const articleResolver:  GraphQLResolver = async (_, args, context) => {
+  const { findArticles } = context.container;
+  const { filter, pagination, sort } = args;
+
+  const { data: articles } = await findArticles({ filter, pagination, sort });
+
+  return articles;
+};
+
+export { articleResolver };

src/article/interface/graphql/ArticleTypeDef.ts

@@ -0,0 +1,69 @@
+import {
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLObjectTypeConfig,
+  GraphQLString,
+} from 'graphql';
+
+import { GraphQLContext } from '@/_lib/graphql/Graphql';
+import { ArticleListItemDTO } from '@/article/query/FindArticles';
+
+type ArticlesConfigType = GraphQLObjectTypeConfig<ArticleListItemDTO, GraphQLContext>;
+
+const CommentType  = new GraphQLObjectType({
+  name: 'Comment',
+  fields: () => ({
+    id: {
+      type: GraphQLString,
+      description: 'The comment Id',
+      resolve: comment => comment.id,
+    }, 
+    body: {
+      type: GraphQLString,
+      description: 'The comment body',
+      resolve: comment => comment.body,
+    },
+    createdAt: {
+      type: GraphQLString,
+      description: 'The date the comment was wrote',
+      resolve: comment => comment.createAt
+    },
+  })
+})
+
+const ArticleTypeConfig: ArticlesConfigType = {
+  name: 'Article',
+  description: 'A blog post article',
+  fields: () => ({
+    id: {
+      type: GraphQLNonNull(GraphQLString),
+      description: 'The page Id',
+      resolve: article => article.id,
+    },
+    title: {
+      type: GraphQLString,
+      description: 'The article title',
+      resolve: article => article.title,
+    },
+    content: {
+      type: GraphQLString,
+      description: 'The article content',
+      resolve: article => article.content,
+    },
+    publishedAt: {
+      type: GraphQLString,
+      description: 'The date the article was published',
+      resolve: article => article.publishedAt
+    },
+    comments: {
+      type: GraphQLList(CommentType),
+      description: 'The article comments',
+      resolve: article => article.comments,
+    },
+  }),
+};
+
+const ArticleType = GraphQLList(new GraphQLObjectType(ArticleTypeConfig));
+
+export { ArticleType };