Write mutations to: create a community and join a community

.eslintrc.js

@@ -62,9 +62,12 @@ module.exports = {
     'relay/unused-fields': 'off',
   },
   settings: {
+    react: {
+      version: 'detect',
+    },
     'import/resolver': {
       typescript: {
-        directory: ['packages/*/tsconfig.json'],
+        project: ['packages/*/tsconfig.json'],
       },
     },
   },

packages/server/.gitignore

@@ -1 +1 @@
-graphql/
+/graphql

packages/server/package.json

@@ -14,15 +14,15 @@
   },
   "dependencies": {
     "@koa/cors": "^3.1.0",
+    "@koa/router": "^10.1.1",
     "bcryptjs": "^2.4.3",
     "dotenv": "^10.0.0",
     "graphql": "^15.6.1",
     "graphql-relay": "^0.9.0",
     "jsonwebtoken": "^8.5.1",
     "koa": "^2.13.3",
     "koa-bodyparser": "^4.3.0",
-    "koa-graphql": "^0.9.0",
-    "koa-router": "^10.1.1",
+    "koa-graphql": "^0.12.0",
     "mongoose": "^6.0.10"
   },
   "devDependencies": {
@@ -32,8 +32,8 @@
     "@types/koa": "^2.13.4",
     "@types/koa-bodyparser": "^4.3.3",
     "@types/koa-graphql": "^0.8.5",
-    "@types/koa-router": "^7.4.4",
     "@types/koa__cors": "^3.0.3",
+    "@types/koa__router": "^8.0.11",
     "babel-loader": "^8.2.3",
     "mongodb-memory-server-global": "^8.0.0",
     "webpack": "^5.64.0",

packages/server/src/app.ts

@@ -1,36 +1,49 @@
-import Koa from 'koa';
-import Router from 'koa-router';
+import Koa, { Request } from 'koa';
+import Router from '@koa/router';
 import bodyparser from 'koa-bodyparser';
-import GraphQLHTTP from 'koa-graphql';
+import { graphqlHTTP, OptionsData } from 'koa-graphql';
 import cors from '@koa/cors';
 
 import { schema } from './schema';
 import { config } from './environment';
+import { getUser } from './auth';
 
 const app = new Koa();
 const router = new Router();
 
-const graphQlSettingsPerReq = async (): Promise<GraphQLHTTP.OptionsData> => ({
-  graphiql: config.NODE_ENV !== 'production',
-  schema,
-  pretty: true,
-  formatError: ({ message, locations, stack }) => {
-    /* eslint-disable no-console */
-    console.log(message);
-    console.log(locations);
-    console.log(stack);
-    /* eslint-enable no-console */
-
-    return {
-      message,
-      locations,
-      stack,
-    };
-  },
-});
-
-const graphQlServer = GraphQLHTTP(graphQlSettingsPerReq);
-
+const graphQlSettingsPerReq = async (req: Request): Promise<OptionsData> => {
+  const user = await getUser(req.header.authorization);
+
+  return {
+    graphiql:
+      config.NODE_ENV !== 'production'
+        ? {
+            headerEditorEnabled: true,
+            shouldPersistHeaders: true,
+          }
+        : false,
+    schema,
+    pretty: true,
+    context: {
+      user,
+    },
+    customFormatErrorFn: ({ message, locations, stack }) => {
+      /* eslint-disable no-console */
+      console.log(message);
+      console.log(locations);
+      console.log(stack);
+      /* eslint-enable no-console */
+
+      return {
+        message,
+        locations,
+        stack,
+      };
+    },
+  };
+};
+
+const graphQlServer = graphqlHTTP(graphQlSettingsPerReq);
 router.all('/graphql', graphQlServer);
 
 app.use(cors());

packages/server/src/auth.ts

@@ -1,6 +1,26 @@
 import jwt from 'jsonwebtoken';
 
+import { Maybe } from '@fakeddit/types';
+
+import { UserModel, UserDocument } from './modules/user/UserModel';
 import { config } from './environment';
 
+export const getUser = async (
+  token: Maybe<string>,
+): Promise<Maybe<UserDocument>> => {
+  if (!token) return null;
+
+  // TODO: Maybe it should be a crime
+  [, token] = token.split('JWT ');
+
+  const decodedToken = jwt.verify(token, config.JWT_SECRET) as { id: string };
+
+  const user = await UserModel.findOne({ _id: decodedToken.id });
+
+  if (!user) return null;
+
+  return user;
+};
+
 export const generateJwtToken = (userId: string) =>
   `JWT ${jwt.sign({ id: userId }, config.JWT_SECRET)}`;

packages/server/src/modules/community/CommunityModel.ts

@@ -0,0 +1,47 @@
+import mongoose, { Schema, Types } from 'mongoose';
+
+export interface Community {
+  name: string;
+  displayName: string;
+  admin: Types.ObjectId;
+  members: Types.ObjectId[];
+  mods: Types.ObjectId[];
+}
+
+const CommunitySchema = new Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      unique: true,
+      maxlength: 21,
+    },
+    admin: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+    },
+    displayName: {
+      type: String,
+      required: true,
+    },
+    mods: {
+      type: [Schema.Types.ObjectId],
+      ref: 'User',
+      default: [],
+    },
+    members: {
+      type: [Schema.Types.ObjectId],
+      ref: 'User',
+      required: true,
+    },
+  },
+  {
+    timestamps: {
+      createdAt: true,
+      updatedAt: true,
+    },
+  },
+);
+
+export const CommunityModel = mongoose.model('Community', CommunitySchema);

packages/server/src/modules/community/CommunityType.ts

@@ -0,0 +1,42 @@
+import {
+  GraphQLObjectType,
+  GraphQLString,
+  GraphQLList,
+  GraphQLID,
+  GraphQLNonNull,
+} from 'graphql';
+import { globalIdField } from 'graphql-relay';
+
+import { Community } from './CommunityModel';
+
+export const CommunityType = new GraphQLObjectType<Community>({
+  name: 'Community',
+  fields: {
+    id: globalIdField('Community'),
+    name: {
+      type: new GraphQLNonNull(GraphQLString),
+      resolve: community => community.name,
+      description: 'The slugged name of the community - this is unique',
+    },
+    displayName: {
+      type: new GraphQLNonNull(GraphQLString),
+      resolve: community => community.displayName,
+      description:
+        "Some custom name that doens't necessary be the name of the community",
+    },
+    admin: {
+      type: new GraphQLNonNull(GraphQLID),
+    },
+    mods: {
+      type: new GraphQLNonNull(new GraphQLList(GraphQLID)),
+      resolve: community => community.mods,
+    },
+    members: {
+      // TODO: Turn it a list of ObjectIDs
+      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLID))),
+      resolve: community => community.members,
+      description:
+        'A list containing the IDs of all users that is member of this community',
+    },
+  },
+});

packages/server/src/modules/community/__tests__/communityCreate.test.ts

@@ -0,0 +1,133 @@
+import { graphql } from 'graphql';
+
+import {
+  clearDatabaseAndRestartCounters,
+  connectWithMongoose,
+  disconnectWithMongoose,
+} from '../../../../test';
+import { schema } from '../../../schema';
+
+import { createUser } from '../../user/fixtures/createUser';
+
+beforeAll(connectWithMongoose);
+beforeEach(clearDatabaseAndRestartCounters);
+afterAll(disconnectWithMongoose);
+
+it('should create a new community', async () => {
+  const user = await createUser();
+
+  const mutation = `
+    mutation M($displayName: String!, $communityId: String!) {
+      communityCreate(
+        input: { displayName: $displayName, communityId: $communityId }
+      ) {
+        community {
+          id
+          name
+          displayName
+          members
+        }
+      }
+    }
+  `;
+
+  const rootValue = {};
+
+  const variables = {
+    displayName: 'A community to lovers of tests',
+    communityId: 'WeLoveTests',
+  };
+
+  const result = await graphql(
+    schema,
+    mutation,
+    rootValue,
+    { user },
+    variables,
+  );
+
+  expect(result.errors).toBeUndefined();
+
+  const { community } = result?.data?.communityCreate;
+
+  expect(community.id).toBeDefined();
+  expect(community.name).toBe(variables.communityId);
+  expect(community.displayName).toBe(variables.displayName);
+  expect(community.members).toHaveLength(1);
+  expect(community.members).toContain(user._id.toString());
+});
+
+it("should not allow create a community if doesn't have authorization header", async () => {
+  const mutation = `
+    mutation M($displayName: String!, $communityId: String!) {
+      communityCreate(
+        input: { displayName: $displayName, communityId: $communityId }
+      ) {
+        community {
+          id
+          name
+          displayName
+          members
+        }
+      }
+    }
+  `;
+
+  const rootValue = {};
+
+  const variables = {
+    displayName: 'A community to lovers of tests',
+    communityId: 'WeLoveTests',
+  };
+
+  const result = await graphql(schema, mutation, rootValue, {}, variables);
+
+  expect(result?.data?.communityCreate).toBeNull();
+
+  expect(result?.errors).toBeDefined();
+  expect(result.errors && result.errors[0]?.message).toBe(
+    'You are not logged in. Please, try again!',
+  );
+});
+
+it('should not create a duplicate community', async () => {
+  const user = await createUser();
+
+  const mutation = `
+    mutation M($displayName: String!, $communityId: String!) {
+      communityCreate(
+        input: { displayName: $displayName, communityId: $communityId }
+      ) {
+        community {
+          id
+          name
+          displayName
+          members
+        }
+      }
+    }
+  `;
+
+  const rootValue = {};
+
+  const variables = {
+    displayName: 'A community to lovers of tests',
+    communityId: 'WeLoveTests',
+  };
+
+  await graphql(schema, mutation, rootValue, { user }, variables);
+  const result = await graphql(
+    schema,
+    mutation,
+    rootValue,
+    { user },
+    variables,
+  );
+
+  expect(result?.data?.communityCreate).toBeNull();
+
+  expect(result?.errors).toBeDefined();
+  expect(result.errors && result.errors[0].message).toBe(
+    'A community with this name has already been created. Please, try again!',
+  );
+});