feat: add event channels and messages (#41)

* feat!: add EventChannel, refactors event

* refactor: channels with single table inheritance

* feat: Message entity

* feat: add further properties to Message entity

* feat: message creation

* feat: get message from API

* feat: get messages of channel

* feat: deleting a message

* feat: validate messages

* refactor(MessageService): require time for creation

* test: createEvent

* test: getMessage

* test: deleteMessage

* test!: getMessages

* test: 100% coverage for MessageService

* docs: add disclaimer to message fixtures

* test: controller createMessage

* test: fix typos in message service tests

* test: getMessage controller

* test: getMessages controller

* test: 100% coverage for message controller tests

* refactor: use glob pattern for entities, simplify messages pagination

* style: remove unused imports, fix lint errors

* refactor: use HttpCode enum

Author: amishshah

package-lock.json

@@ -32,6 +32,7 @@
   "@types/jest": "^26.0.4",
   "@types/node": "^14.0.22",
   "@types/supertest": "^2.0.10",
+  "@types/uuid": "^8.0.0",
   "@typescript-eslint/eslint-plugin": "^3.6.0",
   "@typescript-eslint/parser": "^3.6.0",
   "@unicsmcr/eslint-config": "0.0.2",
@@ -40,7 +41,8 @@
   "supertest": "^4.0.2",
   "ts-jest": "^26.1.1",
   "ts-mockito": "^2.6.1",
-  "typescript": "^3.9.6"
+  "typescript": "^3.9.6",
+  "uuid": "^8.3.0"
  },
  "eslintConfig": {
   "extends": "@unicsmcr",

package.json

@@ -0,0 +1,59 @@
+import { NextFunction, Request } from 'express';
+import { inject, injectable } from 'tsyringe';
+import { AuthenticatedResponse } from '../routes/middleware/getUser';
+import MessageService from '../services/MessageService';
+import { AccountType } from '../entities/User';
+import { HttpCode } from '../util/errors';
+
+@injectable()
+export class MessageController {
+	private readonly messageService: MessageService;
+
+	public constructor(@inject(MessageService) messageService: MessageService) {
+		this.messageService = messageService;
+	}
+
+	public async createMessage(req: Request & { params: { channelID: string } }, res: AuthenticatedResponse, next: NextFunction): Promise<void> {
+		try {
+			const message = await this.messageService.createMessage({ ...req.body, channelID: req.params.channelID, authorID: res.locals.user.id });
+			res.json({ message });
+		} catch (error) {
+			next(error);
+		}
+	}
+
+	public async getMessage(req: Request & { params: { channelID: string; messageID: string } }, res: AuthenticatedResponse, next: NextFunction): Promise<void> {
+		try {
+			const message = await this.messageService.getMessage({ id: req.params.messageID, channelID: req.params.channelID });
+			res.json({ message });
+		} catch (error) {
+			next(error);
+		}
+	}
+
+	public async getMessages(req: Request & { params: { channelID: string; page: number } }, res: AuthenticatedResponse, next: NextFunction): Promise<void> {
+		try {
+			const messages = await this.messageService.getMessages({
+				channelID: req.params.channelID,
+				page: Number(req.query.page),
+				count: 50
+			});
+			res.json({ messages });
+		} catch (error) {
+			next(error);
+		}
+	}
+
+	public async deleteMessage(req: Request & { params: { channelID: string; messageID: string } }, res: AuthenticatedResponse, next: NextFunction): Promise<void> {
+		try {
+			await this.messageService.deleteMessage({
+				id: req.params.messageID,
+				channelID: req.params.channelID,
+				authorID: res.locals.user.accountType === AccountType.Admin ? undefined : res.locals.user.id
+			});
+			res.status(HttpCode.NoContent).end();
+		} catch (error) {
+			next(error);
+		}
+	}
+}

src/controllers/MessageController.ts

@@ -0,0 +1,15 @@
+import { PrimaryGeneratedColumn, OneToOne, Entity, TableInheritance, ChildEntity } from 'typeorm';
+import { Event } from './Event';
+
+@Entity()
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export class Channel {
+	@PrimaryGeneratedColumn('uuid')
+	public id!: string;
+}
+
+@ChildEntity()
+export class EventChannel extends Channel {
+	@OneToOne(() => Event, event => event.channel)
+	public event!: Event;
+}

src/entities/Channel.ts

@@ -1,5 +1,16 @@
-import { PrimaryGeneratedColumn, Entity, Column } from 'typeorm';
-import { MaxLength, IsString } from 'class-validator';
+import { PrimaryGeneratedColumn, Entity, Column, OneToOne, JoinColumn } from 'typeorm';
+import { MaxLength, IsString, IsDate } from 'class-validator';
+import { EventChannel } from './Channel';
+
+export interface APIEvent {
+	id: string;
+	title: string;
+	startTime: string;
+	endTime: string;
+	description: string;
+	external: string;
+	channelID: string;
+}
 
 @Entity()
 export class Event {
@@ -12,9 +23,11 @@ export class Event {
 	public title!: string;
 
 	@Column('timestamp')
+	@IsDate()
 	public startTime!: Date;
 
 	@Column('timestamp')
+	@IsDate()
 	public endTime!: Date;
 
 	@Column()
@@ -25,4 +38,21 @@ export class Event {
 	@Column()
 	@IsString()
 	public external!: string;
+
+	@OneToOne(() => EventChannel, channel => channel.event, { nullable: true, eager: true, cascade: true })
+	@JoinColumn()
+	public channel!: EventChannel;
+
+	public toJSON(): APIEvent {
+		const { id, title, startTime, endTime, description, external, channel } = this;
+		return {
+			id,
+			title,
+			startTime: startTime.toISOString(),
+			endTime: endTime.toISOString(),
+			description,
+			external,
+			channelID: channel.id
+		};
+	}
 }

src/entities/Event.ts

@@ -0,0 +1,44 @@
+import { Entity, PrimaryGeneratedColumn, ManyToOne, Column } from 'typeorm';
+import { Channel } from './Channel';
+import { User } from './User';
+import { IsDate, IsString, MaxLength, MinLength } from 'class-validator';
+
+export interface APIMessage {
+	id: string;
+	channelID: string;
+	authorID: string;
+	content: string;
+	time: string;
+}
+
+@Entity()
+export default class Message {
+	@PrimaryGeneratedColumn('uuid')
+	public id!: string;
+
+	@ManyToOne(() => Channel, { eager: true })
+	public channel!: Channel;
+
+	@ManyToOne(() => User, { eager: true })
+	public author!: User;
+
+	@Column()
+	@IsString()
+	@MinLength(1, { message: 'A message must be at least 1 character long' })
+	@MaxLength(400, { message: 'A message can be 400 characters at most' })
+	public content!: string;
+
+	@Column('timestamp')
+	@IsDate()
+	public time!: Date;
+
+	public toJSON(): APIMessage {
+		return {
+			id: this.id,
+			channelID: this.channel.id,
+			authorID: this.author.id,
+			content: this.content,
+			time: this.time.toISOString()
+		};
+	}
+}

src/entities/Message.ts

@@ -8,18 +8,15 @@ import express, { Router, Response, Request, NextFunction } from 'express';
 
 import { createConnection } from 'typeorm';
 import { getConfig } from './util/config';
-import { User } from './entities/User';
 import { UserRoutes } from './routes/UserRoutes';
-import { EmailConfirmation } from './entities/EmailConfirmation';
 import { container } from 'tsyringe';
-import Profile from './entities/Profile';
 import EmailService from './services/email/EmailService';
 import MockEmailService from './services/email/MockEmailService';
 import { APIError, HttpCode } from './util/errors';
 import { Server as WebSocketServer } from 'ws';
 import GatewayController from './controllers/GatewayController';
-import { Event } from './entities/Event';
 import { EventRoutes } from './routes/EventRoutes';
+import { MessageRoutes } from './routes/MessageRoutes';
 
 export function createExpress() {
 	const app = express();
@@ -38,6 +35,7 @@ export function createExpress() {
 
 	container.resolve(UserRoutes).routes(router);
 	container.resolve(EventRoutes).routes(router);
+	container.resolve(MessageRoutes).routes(router);
 
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	app.use((err: any, req: Request, res: Response, next: NextFunction) => {
@@ -64,7 +62,7 @@ export async function createDBConnection() {
 		type: 'postgres',
 		...getConfig().db, // username, password, host, port, database
 		entities: [
-			User, EmailConfirmation, Profile, Event
+			`${__dirname}/entities/**/*{.js,.ts}`
 		],
 		synchronize: true,
 		logging: false

src/index.ts

@@ -0,0 +1,20 @@
+import { Router } from 'express';
+import { inject, injectable } from 'tsyringe';
+import { getUser, isVerified } from './middleware';
+import { MessageController } from '../controllers/MessageController';
+
+@injectable()
+export class MessageRoutes {
+	private readonly messageController: MessageController;
+
+	public constructor(@inject(MessageController) messageController: MessageController) {
+		this.messageController = messageController;
+	}
+
+	public routes(router: Router): void {
+		router.post('/channels/:channelID/messages', getUser, isVerified, this.messageController.createMessage.bind(this.messageController));
+		router.get('/channels/:channelID/messages', getUser, isVerified, this.messageController.getMessages.bind(this.messageController));
+		router.get('/channels/:channelID/messages/:messageID', getUser, isVerified, this.messageController.getMessage.bind(this.messageController));
+		router.delete('/channels/:channelID/messages/:messageID', getUser, isVerified, this.messageController.deleteMessage.bind(this.messageController));
+	}
+}

src/routes/MessageRoutes.ts

@@ -1,10 +1,11 @@
 import { singleton } from 'tsyringe';
-import { Event } from '../entities/Event';
+import { Event, APIEvent } from '../entities/Event';
 import { getRepository, getConnection } from 'typeorm';
 import { validateOrReject } from 'class-validator';
+import { EventChannel } from '../entities/Channel';
 import { formatValidationErrors, APIError, HttpCode } from '../util/errors';
 
-type EventCreationData = Omit<Event, 'id'>;
+type EventCreationData = Omit<APIEvent, 'id' | 'channelID'>;
 
 enum PatchEventError {
 	IdMissing = 'Event ID missing',
@@ -13,25 +14,28 @@ enum PatchEventError {
 
 @singleton()
 export default class EventService {
-	public async createEvent(data: EventCreationData): Promise<Event> {
+	public async createEvent(data: EventCreationData): Promise<APIEvent> {
 		const event = new Event();
 		const { title, description, startTime, endTime, external } = data;
-		Object.assign(event, { title, description, startTime, endTime, external });
+		Object.assign(event, { title, description, startTime: new Date(startTime), endTime: new Date(endTime), external });
 		await validateOrReject(event).catch(e => Promise.reject(formatValidationErrors(e)));
-		return getRepository(Event).save(event);
+		const channel = new EventChannel();
+		channel.event = event;
+		event.channel = channel;
+		return (await getRepository(Event).save(event)).toJSON();
 	}
 
-	public findAll(): Promise<Event[]> {
-		return getRepository(Event).find();
+	public async findAll(): Promise<APIEvent[]> {
+		return (await getRepository(Event).find()).map(event => event.toJSON());
 	}
 
-	public async editEvent(data: Pick<Event, 'id'> & Partial<Event>): Promise<Event> {
+	public async editEvent(data: Pick<Event, 'id'> & Partial<Event>): Promise<APIEvent> {
 		return getConnection().transaction(async entityManager => {
 			if (!data.id) throw new APIError(HttpCode.BadRequest, PatchEventError.IdMissing);
 			const event = await entityManager.findOneOrFail(Event, data.id).catch(() => Promise.reject(new APIError(HttpCode.BadRequest, PatchEventError.EventNotFound)));
-			Object.assign(event, data);
+			Object.assign(event, { ...data, channel: event.channel });
 			await validateOrReject(event).catch(e => Promise.reject(formatValidationErrors(e)));
-			return entityManager.save(event);
+			return (await entityManager.save(event)).toJSON();
 		});
 	}
 }