Merge branch 'develop' of Software_Engineering_I/greenvironment-server into master

.gitignore

@@ -5,3 +5,4 @@ npm-debug.log
 test/*.log
 dist
 .idea
+config.yaml

CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Connection to Postgres Database
+- Graphql Schema
+- default-config file and generation of config file on startup
+- DTOs
+- Home Route

Dockerfile

@@ -0,0 +1,12 @@
+FROM node:current-alpine
+
+COPY . /home/node/green
+WORKDIR /home/node/green
+RUN npm install -g gulp
+RUN npm install --save-dev
+RUN npm rebuild node-sass
+RUN gulp
+COPY . .
+EXPOSE 8080
+EXPOSE 5432
+CMD ["npm" , "run"]

README.md

@@ -1 +1,11 @@
-greenvironment-server
+# greenvironment-server
+
+Server of the greenvironment social network.
+
+## Install
+
+You need to install a nodejs runtime to run the greenvironment server. 
+Then you need to install all requirements. To do so, open a terminal in the
+greenvironment project folder and execute "npm i". You can build the project by
+executing "gulp" in the terminal. To run the server you need
+to execute "node ./dist".

docker-compose.yml

@@ -0,0 +1,15 @@
+version: "3"
+services:
+  greenvironment:
+    build:
+      context: .
+      dockerfile: ./Dockerfile
+    user: "node"
+    working_dir: /home/node/green
+    environment:
+      - NODE_ENV=production
+    volumes:
+      - ./:/home/node/green
+    ports:
+      - "8080:8080"
+    command: "npm start"

gulpfile.js

@@ -3,7 +3,7 @@ const sass = require('gulp-sass');
 const ts = require('gulp-typescript');
 const minify = require('gulp-minify');
 const del = require('delete');
-
+const gulp = require('gulp');
 
 function clearDist(cb) {
     del('dist/*', cb);
@@ -34,7 +34,12 @@ function compileSass() {
         .pipe(dest('dist/public/stylesheets'));
 }
 
-task('default', series(clearDist, compileTypescript, minifyJs, compileSass));
+function moveRemaining() {
+    return src(['src/**/*', '!src/**/*.ts', '!src/**/*.sass', '!src/**/*.js'])
+        .pipe(dest('dist'));
+}
+
+task('default', series(clearDist, compileTypescript, minifyJs, compileSass, moveRemaining));
 task('watch', () => {
     watch('src/public/stylesheets/sass/**/*.sass', compileSass);
     watch('**/*.js', minifyJs);

package.json

@@ -0,0 +1,70 @@
+{
+  "name": "greenvironment-server",
+  "version": "0.1.0",
+  "description": "Server for greenvironment network",
+  "main": "./dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "gulp",
+    "start": "node ./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.trivernis.net/Software_Engineering_I/greenvironment-server.git"
+  },
+  "keywords": [
+    "server",
+    "nodejs",
+    "express"
+  ],
+  "author": "SoftEngI",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/compression": "^1.0.1",
+    "@types/connect-pg-simple": "^4.2.0",
+    "@types/cookie-parser": "^1.4.2",
+    "@types/express": "^4.17.1",
+    "@types/express-graphql": "^0.8.0",
+    "@types/express-session": "^1.15.14",
+    "@types/express-socket.io-session": "^1.3.2",
+    "@types/fs-extra": "^8.0.0",
+    "@types/graphql": "^14.2.3",
+    "@types/http-status": "^0.2.30",
+    "@types/js-yaml": "^3.12.1",
+    "@types/markdown-it": "0.0.9",
+    "@types/node": "^12.7.8",
+    "@types/pg": "^7.11.0",
+    "@types/socket.io": "^2.1.2",
+    "@types/winston": "^2.4.4",
+    "delete": "^1.1.0",
+    "gulp": "^4.0.2",
+    "gulp-minify": "^3.1.0",
+    "gulp-sass": "^4.0.2",
+    "gulp-typescript": "^5.0.1",
+    "ts-lint": "^4.5.1",
+    "tsc": "^1.20150623.0",
+    "tslint": "^5.19.0",
+    "typescript": "^3.5.3"
+  },
+  "dependencies": {
+    "compression": "^1.7.4",
+    "connect-pg-simple": "^6.0.1",
+    "cookie-parser": "^1.4.4",
+    "express": "^4.17.1",
+    "express-graphql": "^0.9.0",
+    "express-session": "^1.16.2",
+    "express-socket.io-session": "^1.3.5",
+    "fs-extra": "^8.1.0",
+    "g": "^2.0.1",
+    "graphql": "^14.4.2",
+    "graphql-import": "^0.7.1",
+    "http-status": "^1.3.2",
+    "js-yaml": "^3.13.1",
+    "markdown-it": "^10.0.0",
+    "markdown-it-emoji": "^1.4.0",
+    "pg": "^7.12.1",
+    "pug": "^2.0.4",
+    "socket.io": "^2.2.0",
+    "winston": "^3.2.1"
+  }
+}

src/app.ts

@@ -0,0 +1,97 @@
+import * as compression from "compression";
+import connectPgSimple = require("connect-pg-simple");
+import * as cookieParser from "cookie-parser";
+import * as express from "express";
+import * as graphqlHTTP from "express-graphql";
+import * as session from "express-session";
+import sharedsession = require("express-socket.io-session");
+import {buildSchema} from "graphql";
+import {importSchema} from "graphql-import";
+import * as http from "http";
+import * as path from "path";
+import * as socketIo from "socket.io";
+import {resolver} from "./graphql/resolvers";
+import dataaccess, {queryHelper} from "./lib/dataaccess";
+import globals from "./lib/globals";
+import routes from "./routes";
+
+const logger = globals.logger;
+
+const PgSession = connectPgSimple(session);
+
+class App {
+    public app: express.Application;
+    public io: socketIo.Server;
+    public server: http.Server;
+
+    constructor() {
+        this.app = express();
+        this.server = new http.Server(this.app);
+        this.io = socketIo(this.server);
+    }
+
+    /**
+     * initializes everything that needs to be initialized asynchronous.
+     */
+    public async init() {
+        await dataaccess.init();
+        await routes.ioListeners(this.io);
+
+        const appSession = session({
+            cookie: {
+                maxAge: Number(globals.config.session.cookieMaxAge) || 604800000,
+                secure: "auto",
+            },
+            resave: false,
+            saveUninitialized: false,
+            secret: globals.config.session.secret,
+            store: new PgSession({
+                pool: dataaccess.pool,
+                tableName: "user_sessions",
+            }),
+        });
+
+        this.io.use(sharedsession(appSession, {autoSave: true}));
+
+        this.app.set("views", path.join(__dirname, "views"));
+        this.app.set("view engine", "pug");
+        this.app.set("trust proxy", 1);
+
+        this.app.use(compression());
+        this.app.use(express.json());
+        this.app.use(express.urlencoded({extended: false}));
+        this.app.use(express.static(path.join(__dirname, "public")));
+        this.app.use(cookieParser());
+        this.app.use(appSession);
+        this.app.use((req, res, next) => {
+            logger.verbose(`${req.method} ${req.url}`);
+            next();
+        });
+        this.app.use(routes.router);
+        this.app.use("/graphql",  graphqlHTTP((request, response) => {
+            return {
+                // @ts-ignore all
+                context: {session: request.session},
+                graphiql: true,
+                rootValue: resolver(request, response),
+                schema: buildSchema(importSchema(path.join(__dirname, "./graphql/schema.graphql"))),
+            };
+        }));
+    }
+
+    /**
+     * Starts the web server.
+     */
+    public start() {
+        if (globals.config.server.port) {
+            logger.info(`Starting server...`);
+            this.app.listen(globals.config.server.port);
+            logger.info(`Server running on port ${globals.config.server.port}`);
+        } else {
+            logger.error("No port specified in the config." +
+                "Please configure a port in the config.yaml.");
+        }
+    }
+}
+
+export default App;

src/default-config.yaml

@@ -0,0 +1,22 @@
+# database connection info
+database:
+  host:
+  port:
+  user:
+  password:
+  database:
+
+# http server configuration
+server:
+  port: 8080
+
+session:
+  secret: REPLACE WITH SAFE RANDOM GENERATED SECRET
+  cookieMaxAge: 604800000‬ # 7 days
+
+markdown:
+  plugins:
+    - 'markdown-it-emoji'
+
+logging:
+  level: info

src/graphql/resolvers.ts

@@ -0,0 +1,227 @@
+import {GraphQLError} from "graphql";
+import * as status from "http-status";
+import dataaccess from "../lib/dataaccess";
+import {Chatroom} from "../lib/dataaccess/Chatroom";
+import {Post} from "../lib/dataaccess/Post";
+import {Profile} from "../lib/dataaccess/Profile";
+import {User} from "../lib/dataaccess/User";
+import {NotLoggedInGqlError} from "../lib/errors/graphqlErrors";
+import globals from "../lib/globals";
+import {InternalEvents} from "../lib/InternalEvents";
+import {is} from "../lib/regex";
+
+/**
+ * Returns the resolvers for the graphql api.
+ * @param req - the request object
+ * @param res - the response object
+ */
+export function resolver(req: any, res: any): any {
+    return {
+        getSelf() {
+            if (req.session.userId) {
+                return new Profile(req.session.userId);
+            } else {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+        },
+        async getUser({userId, handle}: { userId: number, handle: string }) {
+            if (handle) {
+                return await dataaccess.getUserByHandle(handle);
+            } else if (userId) {
+                return new User(userId);
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No userId or handle provided.");
+            }
+        },
+        async getPost({postId}: { postId: number }) {
+            if (postId) {
+                return await dataaccess.getPost(postId);
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No postId given.");
+            }
+        },
+        async getChat({chatId}: { chatId: number }) {
+            if (chatId) {
+                return new Chatroom(chatId);
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No chatId given.");
+            }
+        },
+        acceptCookies() {
+            req.session.cookiesAccepted = true;
+            return true;
+        },
+        async login({email, passwordHash}: { email: string, passwordHash: string }) {
+            if (email && passwordHash) {
+                try {
+                    const user = await dataaccess.getUserByLogin(email, passwordHash);
+                    req.session.userId = user.id;
+                    return user;
+                } catch (err) {
+                    globals.logger.warn(err.message);
+                    globals.logger.debug(err.stack);
+                    res.status(status.BAD_REQUEST);
+                    return err.graphqlError || err.message;
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No email or password given.");
+            }
+        },
+        logout() {
+            if (req.session.user) {
+                delete req.session.user;
+                return true;
+            } else {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+        },
+        async register({username, email, passwordHash}: { username: string, email: string, passwordHash: string }) {
+            if (username && email && passwordHash) {
+                if (!is.email(email)) {
+                    res.status(status.BAD_REQUEST);
+                    return new GraphQLError(`'${email}' is not a valid email address!`);
+                }
+                try {
+                    const user = await dataaccess.registerUser(username, email, passwordHash);
+                    req.session.userId = user.id;
+                    return user;
+                } catch (err) {
+                    globals.logger.warn(err.message);
+                    globals.logger.debug(err.stack);
+                    res.status(status.BAD_REQUEST);
+                    return err.graphqlError || err.message;
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No username, email or password given.");
+            }
+        },
+        async vote({postId, type}: { postId: number, type: dataaccess.VoteType }) {
+            if (postId && type) {
+                if (req.session.userId) {
+                    return await (new Post(postId)).vote(req.session.userId, type);
+                } else {
+                    res.status(status.UNAUTHORIZED);
+                    return new NotLoggedInGqlError();
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No postId or type given.");
+            }
+        },
+        async createPost({content}: { content: string }) {
+            if (content) {
+                if (req.session.userId) {
+                    const post = await dataaccess.createPost(content, req.session.userId);
+                    globals.internalEmitter.emit(InternalEvents.GQLPOSTCREATE, post);
+                    return post;
+                } else {
+                    res.status(status.UNAUTHORIZED);
+                    return new NotLoggedInGqlError();
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("Can't create empty post.");
+            }
+        },
+        async deletePost({postId}: { postId: number }) {
+            if (postId) {
+                const post = new Post(postId);
+                if ((await post.author()).id === req.session.userId) {
+                    return await dataaccess.deletePost(post.id);
+                } else {
+                    res.status(status.FORBIDDEN);
+                    return new GraphQLError("User is not author of the post.");
+                }
+            } else {
+                return new GraphQLError("No postId given.");
+            }
+        },
+        async createChat({members}: { members: number[] }) {
+            if (req.session.userId) {
+                const chatMembers = [req.session.userId];
+                if (members) {
+                    chatMembers.push(...members);
+                }
+                return await dataaccess.createChat(...chatMembers);
+            } else {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+        },
+        async sendMessage({chatId, content}: { chatId: number, content: string }) {
+            if (!req.session.userId) {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+            if (chatId && content) {
+                try {
+                    const message = await dataaccess.sendChatMessage(req.session.userId, chatId, content);
+                    globals.internalEmitter.emit(InternalEvents.GQLCHATMESSAGE, message);
+                    return message;
+                } catch (err) {
+                    globals.logger.warn(err.message);
+                    globals.logger.debug(err.stack);
+                    res.status(status.BAD_REQUEST);
+                    return err.graphqlError || err.message;
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No chatId or content given.");
+            }
+        },
+        async sendRequest({receiver, type}: { receiver: number, type: dataaccess.RequestType }) {
+            if (!req.session.userId) {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+            if (receiver && type) {
+                return await dataaccess.createRequest(req.session.userId, receiver, type);
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No receiver or type given.");
+            }
+        },
+        async denyRequest({sender, type}: { sender: number, type: dataaccess.RequestType }) {
+            if (!req.session.userId) {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+            if (sender && type) {
+                const profile = new Profile(req.session.userId);
+                await profile.denyRequest(sender, type);
+                return true;
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No sender or type given.");
+            }
+        },
+        async acceptRequest({sender, type}: { sender: number, type: dataaccess.RequestType }) {
+            if (!req.session.userId) {
+                res.status(status.UNAUTHORIZED);
+                return new NotLoggedInGqlError();
+            }
+            if (sender && type) {
+                try {
+                    const profile = new Profile(req.session.userId);
+                    await profile.acceptRequest(sender, type);
+                    return true;
+                } catch (err) {
+                    globals.logger.warn(err.message);
+                    globals.logger.debug(err.stack);
+                    res.status(status.BAD_REQUEST);
+                    return err.graphqlError || err.message;
+                }
+            } else {
+                res.status(status.BAD_REQUEST);
+                return new GraphQLError("No sender or type given.");
+            }
+        },
+    };
+}

src/graphql/schema.graphql

@@ -0,0 +1,236 @@
+type Query {
+    "returns the user object for a given user id or a handle (only one required)"
+    getUser(userId: ID, handle: String): User
+
+    "returns the logged in user"
+    getSelf: Profile
+
+    "returns the post object for a post id"
+    getPost(postId: ID!): Post
+
+    "returns the chat object for a chat id"
+    getChat(chatId: ID!): ChatRoom
+
+    "find a post by the posted date or content"
+    findPost(first: Int, offset: Int, text: String!, postedDate: String): [Post]
+
+    "find a user by user name or handle"
+    findUser(first: Int, offset: Int, name: String!, handle: String!): [User]
+}
+
+type Mutation {
+    "Accepts the usage of cookies."
+    acceptCookies: Boolean
+
+    "Login of the user. The passwordHash should be a sha512 hash of the password."
+    login(email: String, passwordHash: String): Profile
+
+    "Registers the user."
+    register(username: String, email: String, passwordHash: String): Profile
+
+    "Logout of the user."
+    logout: Boolean
+
+    "Upvote/downvote a Post"
+    vote(postId: ID!, type: VoteType!): VoteType
+
+    "Report the post"
+    report(postId: ID!): Boolean
+
+   "send a request"
+    sendRequest(receiver: ID!, type: RequestType): Request
+
+    "lets you accept a request for a given request id"
+    acceptRequest(sender: ID!, type: RequestType): Boolean
+
+    "lets you deny a request for a given request id"
+    denyRequest(requestId: ID!): Boolean
+
+    "send a message in a Chatroom"
+    sendMessage(chatId: ID!, content: String!): ChatMessage
+
+    "create the post"
+    createPost(content: String!): Post
+
+    "delete the post for a given post id"
+    deletePost(postId: ID!): Boolean
+
+    "Creates a chat between the user (and optional an other user)"
+    createChat(members: [ID!]): ChatRoom
+}
+
+interface UserData {
+    "url for the Profile picture of the User"
+    profilePicture: String
+
+    "name of the User"
+    name: String!
+
+    "unique identifier name from the User"
+    handle: String!
+
+    "Id of the User"
+    id: ID!
+
+    "the total number of posts the user posted"
+    numberOfPosts: Int
+
+    "returns a given number of posts of a user"
+    posts(first: Int=10, offset: Int): [Post]
+
+    "creation date of the user account"
+    joinedAt: String!
+
+    "all friends of the user"
+    friends: [User]
+}
+
+"represents a single user account"
+type User implements UserData{
+    "url for the Profile picture of the User"
+    profilePicture: String
+
+    "name of the User"
+    name: String!
+
+    "unique identifier name from the User"
+    handle: String!
+
+    "Id of the User"
+    id: ID!
+
+    "the total number of posts the user posted"
+    numberOfPosts: Int
+
+    "returns a given number of posts of a user"
+    posts(first: Int=10, offset: Int): [Post]
+
+    "creation date of the user account"
+    joinedAt: String!
+
+    "all friends of the user"
+    friends: [User]
+}
+
+type Profile implements UserData {
+    "url for the Profile picture of the User"
+    profilePicture: String
+
+    "name of the User"
+    name: String!
+
+    "returns the chatrooms the user joined."
+    chats(first: Int=10, offset: Int): [ChatRoom]
+
+    "unique identifier name from the User"
+    handle: String!
+
+    "Id of the User"
+    id: ID!
+
+    "the total number of posts the user posted"
+    numberOfPosts: Int
+
+    "returns a given number of posts of a user"
+    posts(first: Int=10, offset: Int): [Post]
+
+    "creation date of the user account"
+    joinedAt: String!
+
+    "all friends of the user"
+    friends: [User]
+
+    "all sent request for groupChats/friends/events"
+    sentRequests: [Request]
+
+    "all received request for groupChats/friends/events"
+    receivedRequests: [Request]
+}
+
+"represents a single user post"
+type Post {
+
+    "The id of the post."
+    id: ID!
+
+    "the text of the post"
+    content: String
+
+    "the content of the post rendered by markdown-it"
+    htmlContent: String
+
+    "upvotes of the Post"
+    upvotes: Int!
+
+    "downvotes of the Post"
+    downvotes: Int!
+
+    "the user that is the author of the Post"
+    author: User!
+
+    "date the post was created"
+    createdAt: String!
+
+    "the type of vote the user performed on the post"
+    userVote: VoteType
+}
+
+"represents a request of any type"
+type Request {
+    "Id of the user who sended the request"
+    sender: User!
+
+    "Id of the user who received the request"
+    receiver: User!
+
+    "type of the request"
+    type: RequestType!
+}
+
+"represents a chatroom"
+type ChatRoom {
+    "the socket.io namespace for the chatroom"
+    namespace: String
+
+    "the members of the chatroom"
+    members: [User!]
+
+    "return a specfic range of messages posted in the chat"
+    messages(first: Int = 10, offset: Int, containing: String): [ChatMessage]!
+
+    "id of the chat"
+    id: ID!
+}
+
+type ChatMessage {
+    "The author of the chat message."
+    author: User!
+
+    "The chatroom the message was posted in"
+    chat: ChatRoom!
+
+    "The timestamp when the message was posted (epoch)."
+    createdAt: String!
+
+    "The content of the message."
+    content: String!
+
+    "The content of the message rendered by markdown-it."
+    htmlContent: String
+}
+
+"represents the type of vote performed on a post"
+enum VoteType {
+    UPVOTE
+    DOWNVOTE
+}
+
+"""
+represents the type of request that the user has received
+Currently on Friend Requests are implemented.
+"""
+enum RequestType {
+    FRIENDREQUEST
+    GROUPINVITE
+    EVENTINVITE
+}

src/index.ts

@@ -0,0 +1,11 @@
+import App from "./app";
+
+/**
+ * async main function wrapper.
+ */
+(async () => {
+    const app = new App();
+    await app.init();
+    app.start();
+})();
+

src/lib/InternalEvents.ts

@@ -0,0 +1,8 @@
+export enum InternalEvents {
+    CHATCREATE = "chatCreate",
+    CHATMESSAGE = "chatMessage",
+    GQLCHATMESSAGE = "graphqlChatMessage",
+    REQUESTCREATE = "requestCreate",
+    POSTCREATE = "postCreate",
+    GQLPOSTCREATE = "graphqlPostCreate",
+}

src/lib/MemoryCache.ts

@@ -0,0 +1,73 @@
+import * as crypto from "crypto";
+import {EventEmitter} from "events";
+
+export class MemoryCache extends EventEmitter {
+    private cacheItems: any = {};
+    private cacheExpires: any = {};
+    private expireCheck: NodeJS.Timeout;
+
+    /**
+     * Creates interval function.
+     * @param ttl
+     */
+    constructor(private ttl: number = 500) {
+        super();
+        this.expireCheck = setInterval(() => this.checkExpires(), ttl / 2);
+    }
+
+    /**
+     * Creates a md5 hash of the given key.
+     * @param key
+     */
+    public hashKey(key: string): string {
+        const hash = crypto.createHash("sha1");
+        const data = hash.update(key, "utf8");
+        return data.digest("hex");
+    }
+
+    /**
+     * Sets an entry.
+     * @param key
+     * @param value
+     */
+    public set(key: string, value: any) {
+        this.cacheItems[key] = value;
+        this.cacheExpires[key] = Date.now() + this.ttl;
+        this.emit("set", key, value);
+    }
+
+    /**
+     * Returns the entry stored with the given key.
+     * @param key
+     */
+    public get(key: string) {
+        if (this.cacheItems.hasOwnProperty(key)) {
+            this.emit("hit", key, this.cacheItems[key]);
+            return this.cacheItems[key];
+        } else {
+            this.emit("miss", key);
+        }
+    }
+
+    /**
+     * Deletes a cache item.
+     * @param key
+     */
+    public delete(key: string) {
+        this.emit("delete", key);
+        delete this.cacheItems[key];
+    }
+
+    /**
+     * Checks expires and clears items that are over the expire value.
+     */
+    private checkExpires() {
+        for (const [key, value] of Object.entries(this.cacheExpires)) {
+            if (value < Date.now()) {
+                this.emit("delete", key);
+                delete this.cacheItems[key];
+                delete this.cacheExpires[key];
+            }
+        }
+    }
+}

src/lib/QueryHelper.ts

@@ -0,0 +1,212 @@
+/**
+ * @author Trivernis
+ * @remarks
+ *
+ * Taken from {@link https://github.com/Trivernis/whooshy}
+ */
+
+import * as fsx from "fs-extra";
+import {Pool, PoolClient, QueryConfig, QueryResult} from "pg";
+import globals from "./globals";
+
+const logger = globals.logger;
+
+export interface IAdvancedQueryConfig extends QueryConfig {
+    cache?: boolean;
+}
+
+/**
+ * Transaction class to wrap SQL transactions.
+ */
+export class SqlTransaction {
+    /**
+     * Constructor.
+     * @param client
+     */
+    constructor(private client: PoolClient) {
+    }
+
+    /**
+     * Begins the transaction.
+     */
+    public async begin() {
+        return await this.client.query("BEGIN");
+    }
+
+    /**
+     * Commits the transaction
+     */
+    public async commit() {
+        return await this.client.query("COMMIT");
+    }
+
+    /**
+     * Rolls back the transaction
+     */
+    public async rollback() {
+        return await this.client.query("ROLLBACK");
+    }
+
+    /**
+     * Executes a query inside the transaction.
+     * @param query
+     */
+    public async query(query: QueryConfig) {
+        return await this.client.query(query);
+    }
+
+    /**
+     * Releases the client back to the pool.
+     */
+    public release() {
+        this.client.release();
+    }
+}
+
+/**
+ * Query helper for easyer fetching of a specific row count.
+ */
+export class QueryHelper {
+    private pool: Pool;
+
+    /**
+     * Constructor.
+     * @param pgPool
+     * @param [tableCreationFile]
+     * @param [tableUpdateFile]
+     */
+    constructor(pgPool: Pool, private tableCreationFile?: string, private tableUpdateFile?: string) {
+        this.pool = pgPool;
+    }
+
+    /**
+     * Async init function
+     */
+    public async init() {
+        await this.pool.connect();
+        await this.createTables();
+        await this.updateTableDefinitions();
+    }
+
+    /**
+     * creates all tables needed if a filepath was given with the constructor
+     */
+    public async createTables() {
+        if (this.tableCreationFile) {
+            logger.info("Creating nonexistent tables...");
+            const tableSql = await fsx.readFile(this.tableCreationFile, "utf-8");
+            const trans = await this.createTransaction();
+            await trans.begin();
+            try {
+                await trans.query({text: tableSql});
+                await trans.commit();
+            } catch (err) {
+                globals.logger.error(`Error on table creation ${err.message}`);
+                globals.logger.debug(err.stack);
+                await trans.rollback();
+            } finally {
+                trans.release();
+            }
+        }
+    }
+
+    /**
+     * Updates the definition of the tables if the table update file was passed in the constructor
+     */
+    public async updateTableDefinitions() {
+        if (this.tableUpdateFile) {
+            logger.info("Updating table definitions...");
+            const tableSql = await fsx.readFile(this.tableUpdateFile, "utf-8");
+            const trans = await this.createTransaction();
+            await trans.begin();
+            try {
+                await trans.query({text: tableSql});
+                await trans.commit();
+            } catch (err) {
+                globals.logger.error(`Error on table update ${err.message}`);
+                globals.logger.debug(err.stack);
+                await trans.rollback();
+            } finally {
+                trans.release();
+            }
+        }
+    }
+
+    /**
+     * executes the sql query with values and returns all results.
+     * @param query
+     */
+    public async all(query: IAdvancedQueryConfig): Promise<any[]> {
+        const result = await this.query(query);
+        return result.rows;
+    }
+
+    /**
+     * executes the sql query with values and returns the first result.
+     * @param query
+     */
+    public async first(query: IAdvancedQueryConfig): Promise<any> {
+        const result = await this.query(query);
+        if (result.rows && result.rows.length > 0) {
+            return result.rows[0];
+        }
+    }
+
+    /**
+     * Creates a new Transaction to be uses with error handling.
+     */
+    public async createTransaction() {
+        const client: PoolClient = await this.pool.connect();
+        return new SqlTransaction(client);
+    }
+
+    /**
+     * Queries the database with error handling.
+     * @param query - the sql and values to execute
+     */
+    private async query(query: IAdvancedQueryConfig): Promise<QueryResult|{rows: any}> {
+        try {
+            query.text = query.text.replace(/[\r\n]/g, " ");
+            globals.logger.silly(`Executing sql '${JSON.stringify(query)}'`);
+
+            if (query.cache) {
+                const key = globals.cache.hashKey(JSON.stringify(query));
+                const cacheResult = globals.cache.get(key);
+                if (cacheResult) {
+                    return cacheResult;
+                } else {
+                    const result = await this.pool.query(query);
+                    globals.cache.set(key, result);
+                    return result;
+                }
+            } else {
+                return await this.pool.query(query);
+            }
+        } catch (err) {
+            logger.debug(`Error on query "${JSON.stringify(query)}".`);
+            logger.error(`Sql query failed: ${err}`);
+            logger.verbose(err.stack);
+            return {
+                rows: null,
+            };
+        }
+    }
+}
+
+/**
+ * Returns the parameterized value sql for inserting
+ * @param columnCount
+ * @param rowCount
+ * @param [offset]
+ */
+export function buildSqlParameters(columnCount: number, rowCount: number, offset?: number): string {
+    let sql = "";
+    for (let i = 0; i < rowCount; i++) {
+        sql += "(";
+        for (let j = 0; j < columnCount; j++) {
+            sql += `$${(i * columnCount) + j + 1 + offset},`;
+        }
+        sql = sql.replace(/,$/, "") + "),";
+    }
+    return sql.replace(/,$/, "");
+}

src/lib/Route.ts

@@ -0,0 +1,26 @@
+/**
+ * @author Trivernis
+ * @remarks
+ *
+ * Taken from {@link https://github.com/Trivernis/whooshy}
+ */
+
+import {Router} from "express";
+import {Namespace, Server} from "socket.io";
+
+/**
+ * Abstract Route class to be implemented by each route.
+ * This class contains the socket-io Server, router and resolver
+ * for each route.
+ */
+abstract class Route {
+
+    public router?: Router;
+    protected io?: Server;
+    protected ions?: Namespace;
+
+    public abstract async init(...params: any): Promise<any>;
+    public abstract async destroy(...params: any): Promise<any>;
+}
+
+export default Route;

src/lib/dataaccess/ChatMessage.ts

@@ -0,0 +1,31 @@
+import markdown from "../markdown";
+import {Chatroom} from "./Chatroom";
+import {User} from "./User";
+
+export class ChatMessage {
+    constructor(
+        public readonly author: User,
+        public readonly chat: Chatroom,
+        public readonly createdAt: number,
+        public readonly content: string) {}
+
+    /**
+     * The content rendered by markdown-it.
+     */
+    public htmlContent(): string {
+        return markdown.renderInline(this.content);
+    }
+
+    /**
+     * Returns resolved and rendered content of the chat message.
+     */
+    public resolvedContent() {
+        return {
+            author: this.author.id,
+            chat: this.chat.id,
+            content: this.content,
+            createdAt: this.createdAt,
+            htmlContent: this.htmlContent(),
+        };
+    }
+}

src/lib/dataaccess/Chatroom.ts

@@ -0,0 +1,76 @@
+import globals from "../globals";
+import {ChatMessage} from "./ChatMessage";
+import {queryHelper} from "./index";
+import {User} from "./User";
+
+export class Chatroom {
+
+    public namespace: string;
+    constructor(public readonly id: number) {
+        this.id = Number(id);
+        this.namespace = `/chat/${id}`;
+    }
+
+    /**
+     * Returns if the chat exists.
+     */
+    public async exists(): Promise<boolean> {
+        const result = await queryHelper.first({
+            text: "SELECT id FROM chats WHERE id = $1",
+            values: [this.id],
+        });
+        return !!result.id;
+    }
+
+    /**
+     * Returns all members of a chatroom.
+     */
+    public async members(): Promise<User[]> {
+        const result = await queryHelper.all({
+            cache: true,
+            text:  `SELECT * FROM chat_members
+                    JOIN users ON (chat_members.member = users.id)
+                    WHERE chat_members.chat = $1;`,
+            values: [this.id],
+        });
+        const chatMembers = [];
+        for (const row of result) {
+            const user = new User(row.id, row);
+            chatMembers.push(user);
+        }
+        return chatMembers;
+    }
+
+    /**
+     * Returns messages of the chat
+     * @param limit - the limit of messages to return
+     * @param offset - the offset of messages to return
+     * @param containing - filter by containing
+     */
+    public async messages({first, offset, containing}: {first?: number, offset?: number, containing?: string}) {
+        const lim = first || 16;
+        const offs = offset || 0;
+
+        const result = await queryHelper.all({
+            cache: true,
+            text: "SELECT * FROM chat_messages WHERE chat = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
+            values: [this.id, lim, offs],
+        });
+
+        const messages = [];
+        const users: any = {};
+        for (const row of result) {
+            if (!users[row.author]) {
+                const user = new User(row.author);
+                await user.exists();
+                users[row.author] = user;
+            }
+            messages.push(new ChatMessage(users[row.author], this, row.created_at, row.content));
+        }
+        if (containing) {
+            return messages.filter((x) => x.content.includes(containing));
+        } else {
+            return messages;
+        }
+    }
+}

src/lib/dataaccess/DataObject.ts

@@ -0,0 +1,40 @@
+/**
+ * abstact DataObject class
+ */
+import {EventEmitter} from "events";
+
+export abstract class DataObject extends EventEmitter {
+    protected dataLoaded: boolean = false;
+    private loadingData: boolean = false;
+
+    constructor(public id: number, protected row?: any) {
+        super();
+        this.id = Number(id);
+    }
+
+    /**
+     * Returns if the object extists by trying to load data.
+     */
+    public async exists() {
+        await this.loadDataIfNotExists();
+        return this.dataLoaded;
+    }
+
+    protected abstract loadData(): Promise<void>;
+
+    /**
+     * Loads data from the database if data has not been loaded
+     */
+    protected async loadDataIfNotExists() {
+        if (!this.dataLoaded && !this.loadingData) {
+            this.loadingData = true;
+            await this.loadData();
+            this.loadingData = false;
+            this.emit("loaded");
+        } else if (this.loadingData) {
+            return new Promise((res) => {
+                this.on("loaded", () => res());
+            });
+        }
+    }
+}

src/lib/dataaccess/Post.ts

@@ -0,0 +1,159 @@
+import markdown from "../markdown";
+import {DataObject} from "./DataObject";
+import {queryHelper} from "./index";
+import dataaccess from "./index";
+import {User} from "./User";
+
+export class Post extends DataObject {
+    public readonly id: number;
+    private $createdAt: string;
+    private $content: string;
+    private $author: number;
+    private $type: string;
+
+    /**
+     * Returns the resolved data of the post.
+     */
+    public async resolvedData() {
+        await this.loadDataIfNotExists();
+        return {
+            authorId: this.$author,
+            content: this.$content,
+            createdAt: this.$createdAt,
+            id: this.id,
+            type: this.$type,
+        };
+    }
+    /**
+     * Returns the upvotes of a post.
+     */
+    public async upvotes(): Promise<number> {
+        const result = await queryHelper.first({
+            cache: true,
+            text: "SELECT COUNT(*) count FROM votes WHERE item_id = $1 AND vote_type = 'UPVOTE'",
+            values: [this.id],
+        });
+        return result.count;
+    }
+
+    /**
+     * Returns the downvotes of the post
+     */
+    public async downvotes(): Promise<number> {
+        const result = await queryHelper.first({
+            cache: true,
+            text: "SELECT COUNT(*) count FROM votes WHERE item_id = $1 AND vote_type = 'DOWNVOTE'",
+            values: [this.id],
+        });
+        return result.count;
+    }
+
+    /**
+     * The content of the post (markdown)
+     */
+    public async content(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return this.$content;
+    }
+
+    /**
+     * the content rendered by markdown-it.
+     */
+    public async htmlContent(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return markdown.render(this.$content);
+    }
+
+    /**
+     * The date the post was created at.
+     */
+    public async createdAt(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return this.$createdAt;
+    }
+
+    /**
+     * The autor of the post.
+     */
+    public async author(): Promise<User> {
+        await this.loadDataIfNotExists();
+        return new User(this.$author);
+    }
+
+    /**
+     * Deletes the post.
+     */
+    public async delete(): Promise<void> {
+        const query = await queryHelper.first({
+            text: "DELETE FROM posts WHERE id = $1",
+            values: [this.id],
+        });
+    }
+
+    /**
+     * The type of vote the user performed on the post.
+     */
+    public async userVote(userId: number): Promise<dataaccess.VoteType> {
+        const result = await queryHelper.first({
+            cache: true,
+            text: "SELECT vote_type FROM votes WHERE user_id = $1 AND item_id = $2",
+            values: [userId, this.id],
+        });
+        if (result) {
+            return result.vote_type;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Performs a vote on a post.
+     * @param userId
+     * @param type
+     */
+    public async vote(userId: number, type: dataaccess.VoteType): Promise<dataaccess.VoteType> {
+        const uVote = await this.userVote(userId);
+        if (uVote === type) {
+            await queryHelper.first({
+                text: "DELETE FROM votes WHERE item_id = $1 AND user_id = $2",
+                values: [this.id, userId],
+            });
+        } else {
+            if (uVote) {
+                await queryHelper.first({
+                    text: "UPDATE votes SET vote_type = $1 WHERE user_id = $2 AND item_id = $3",
+                    values: [type, userId, this.id],
+                });
+            } else {
+                await queryHelper.first({
+                    text: "INSERT INTO votes (user_id, item_id, vote_type) values ($1, $2, $3)",
+                    values: [userId, this.id, type],
+                });
+            }
+            return type;
+        }
+    }
+
+    /**
+     * Loads the data from the database if needed.
+     */
+    protected async loadData(): Promise<void> {
+        let result: any;
+        if (this.row) {
+            result = this.row;
+        } else {
+            result = await queryHelper.first({
+                cache: true,
+                text: "SELECT * FROM posts WHERE posts.id = $1",
+                values: [this.id],
+            });
+        }
+        if (result) {
+            this.$author = result.author;
+            this.$content = result.content;
+            this.$createdAt = result.created_at;
+            this.$type = result.type;
+            this.dataLoaded = true;
+        }
+    }
+}

src/lib/dataaccess/Profile.ts

@@ -0,0 +1,163 @@
+import {RequestNotFoundError} from "../errors/RequestNotFoundError";
+import {Chatroom} from "./Chatroom";
+import dataaccess, {queryHelper} from "./index";
+import {User} from "./User";
+import {Request} from "./Request";
+
+export class Profile extends User {
+
+    /**
+     * Returns all chatrooms (with pagination).
+     * Skips the query if the user doesn't exist.
+     * @param first
+     * @param offset
+     */
+    public async chats({first, offset}: {first: number, offset?: number}): Promise<Chatroom[]> {
+        if (!(await this.exists())) {
+            return [];
+        }
+        first = first || 10;
+        offset = offset || 0;
+
+        const result = await queryHelper.all({
+            text: "SELECT chat FROM chat_members WHERE member = $1 LIMIT $2 OFFSET $3",
+            values: [this.id, first, offset],
+        });
+        if (result) {
+            return result.map((row) => new Chatroom(row.chat));
+        } else {
+            return [];
+        }
+    }
+
+    /**
+     * Returns all open requests the user has send.
+     */
+    public async sentRequests() {
+        const result = await queryHelper.all({
+            cache: true,
+            text: "SELECT * FROM requests WHERE sender = $1",
+            values: [this.id],
+        });
+        return this.getRequests(result);
+    }
+
+    /**
+     * Returns all received requests of the user.
+     */
+    public async receivedRequests() {
+        const result = await queryHelper.all({
+            cache: true,
+            text: "SELECT * FROM requests WHERE receiver = $1",
+            values: [this.id],
+        });
+        return this.getRequests(result);
+    }
+
+    /**
+     * Sets the greenpoints of a user.
+     * @param points
+     */
+    public async setGreenpoints(points: number): Promise<number> {
+        const result = await queryHelper.first({
+            text: "UPDATE users SET greenpoints = $1 WHERE id = $2 RETURNING greenpoints",
+            values: [points, this.id],
+        });
+        return result.greenpoints;
+    }
+
+    /**
+     * Sets the email of the user
+     * @param email
+     */
+    public async setEmail(email: string): Promise<string> {
+        const result = await queryHelper.first({
+            text: "UPDATE users SET email = $1 WHERE users.id = $2 RETURNING email",
+            values: [email, this.id],
+        });
+        return result.email;
+    }
+
+    /**
+     * Updates the handle of the user
+     */
+    public async setHandle(handle: string): Promise<string> {
+        const result = await queryHelper.first({
+            text: "UPDATE users SET handle = $1 WHERE id = $2",
+            values: [handle, this.id],
+        });
+        return result.handle;
+    }
+
+    /**
+     * Sets the username of the user
+     * @param name
+     */
+    public async setName(name: string): Promise<string> {
+        const result = await queryHelper.first({
+            text: "UPDATE users SET name = $1 WHERE id = $2",
+            values: [name, this.id],
+        });
+        return result.name;
+    }
+
+    /**
+     * Denys a request.
+     * @param sender
+     * @param type
+     */
+    public async denyRequest(sender: number, type: dataaccess.RequestType) {
+        await queryHelper.first({
+            text: "DELETE FROM requests WHERE receiver = $1 AND sender = $2 AND type = $3",
+            values: [this.id, sender, type],
+        });
+    }
+
+    /**
+     * Accepts a request.
+     * @param sender
+     * @param type
+     */
+    public async acceptRequest(sender: number, type: dataaccess.RequestType) {
+        const exists = await queryHelper.first({
+            cache: true,
+            text: "SELECT 1 FROM requests WHERE receiver = $1 AND sender = $2 AND type = $3",
+            values: [this.id, sender, type],
+        });
+        if (exists) {
+            if (type === dataaccess.RequestType.FRIENDREQUEST) {
+                await queryHelper.first({
+                    text: "INSERT INTO user_friends (user_id, friend_id) VALUES ($1, $2)",
+                    values: [this.id, sender],
+                });
+            }
+        } else {
+            throw new RequestNotFoundError(sender, this.id, type);
+        }
+    }
+
+    /**
+     * Returns request wrapper for a row database request result.
+     * @param rows
+     */
+    private getRequests(rows: any) {
+        const requests = [];
+        const requestUsers: any = {};
+
+        for (const row of rows) {
+            let sender = requestUsers[row.sender];
+
+            if (!sender) {
+                sender = new User(row.sender);
+                requestUsers[row.sender] = sender;
+            }
+            let receiver = requestUsers[row.receiver];
+            if (!receiver) {
+                receiver = new User(row.receiver);
+                requestUsers[row.receiver] = receiver;
+            }
+            requests.push(new Request(sender, receiver, row.type));
+        }
+        return requests;
+    }
+}

src/lib/dataaccess/Request.ts

@@ -0,0 +1,24 @@
+import dataaccess from "./index";
+import {User} from "./User";
+
+/**
+ * Represents a request to a user.
+ */
+export class Request {
+    constructor(
+        public readonly sender: User,
+        public readonly receiver: User,
+        public readonly type: dataaccess.RequestType) {
+    }
+
+    /**
+     * Returns the resolved request data.
+     */
+    public resolvedData() {
+        return {
+            receiverId: this.receiver.id,
+            senderId: this.sender.id,
+            type: this.type,
+        };
+    }
+}

src/lib/dataaccess/User.ts

@@ -0,0 +1,128 @@
+import globals from "../globals";
+import {DataObject} from "./DataObject";
+import {queryHelper} from "./index";
+import {Post} from "./Post";
+
+export class User extends DataObject {
+    private $name: string;
+    private $handle: string;
+    private $email: string;
+    private $greenpoints: number;
+    private $joinedAt: string;
+    private $exists: boolean;
+
+    /**
+     * The name of the user
+     */
+    public async name(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return this.$name;
+    }
+
+    /**
+     * The unique handle of the user.
+     */
+    public async handle(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return this.$handle;
+    }
+
+    /**
+     * The email of the user
+     */
+    public async email(): Promise<string> {
+        await this.loadDataIfNotExists();
+        return this.$email;
+    }
+
+    /**
+     * The number of greenpoints of the user
+     */
+    public async greenpoints(): Promise<number> {
+        await this.loadDataIfNotExists();
+        return this.$greenpoints;
+    }
+
+    /**
+     * Returns the number of posts the user created
+     */
+    public async numberOfPosts(): Promise<number> {
+        const result = await queryHelper.first({
+            cache: true,
+            text: "SELECT COUNT(*) count FROM posts WHERE author = $1",
+            values: [this.id],
+        });
+        return result.count;
+    }
+
+    /**
+     * The date the user joined the platform
+     */
+    public async joinedAt(): Promise<Date> {
+        await this.loadDataIfNotExists();
+        return new Date(this.$joinedAt);
+    }
+
+    /**
+     * Returns all friends of the user.
+     */
+    public async friends(): Promise<User[]> {
+        const result = await queryHelper.all({
+            cache: true,
+            text: "SELECT * FROM user_friends WHERE user_id = $1 OR friend_id = $1",
+            values: [this.id],
+        });
+        const userFriends = [];
+        for (const row of result) {
+            if (row.user_id === this.id) {
+                userFriends.push(new User(row.friend_id));
+            } else {
+                userFriends.push(new User(row.user_id));
+            }
+        }
+        return userFriends;
+    }
+
+    /**
+     * Returns all posts for a user.
+     */
+    public async posts({first, offset}: {first: number, offset: number}): Promise<Post[]> {
+        first = first || 10;
+        offset = offset || 0;
+        const result = await queryHelper.all({
+            cache: true,
+            text: "SELECT * FROM posts WHERE author = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
+            values: [this.id, first, offset],
+        });
+        const posts = [];
+
+        for (const row of result) {
+            posts.push(new Post(row.id, row));
+        }
+        return posts;
+    }
+
+    /**
+     * Fetches the data for the user.
+     */
+    protected async loadData(): Promise<void> {
+        let result: any;
+        if (this.row) {
+            result = this.row;
+        } else {
+            result = await queryHelper.first({
+                cache: true,
+                text: "SELECT * FROM users WHERE users.id = $1",
+                values: [this.id],
+            });
+        }
+        if (result) {
+            this.$name = result.name;
+            this.$handle = result.handle;
+            this.$email = result.email;
+            this.$greenpoints = result.greenpoints;
+            this.$joinedAt = result.joined_at;
+            this.dataLoaded = true;
+        }
+    }
+}

src/lib/dataaccess/index.ts

@@ -0,0 +1,258 @@
+import {Pool} from "pg";
+import {ChatNotFoundError} from "../errors/ChatNotFoundError";
+import {EmailAlreadyRegisteredError} from "../errors/EmailAlreadyRegisteredError";
+import {UserNotFoundError} from "../errors/UserNotFoundError";
+import globals from "../globals";
+import {InternalEvents} from "../InternalEvents";
+import {QueryHelper} from "../QueryHelper";
+import {ChatMessage} from "./ChatMessage";
+import {Chatroom} from "./Chatroom";
+import {Post} from "./Post";
+import {Profile} from "./Profile";
+import {Request} from "./Request";
+import {User} from "./User";
+
+const config = globals.config;
+const tableCreationFile = __dirname + "/../../sql/create-tables.sql";
+const tableUpdateFile = __dirname + "/../../sql/update-tables.sql";
+
+const dbClient: Pool = new Pool({
+    database: config.database.database,
+    host: config.database.host,
+    password: config.database.password,
+    port: config.database.port,
+    user: config.database.user,
+});
+export const queryHelper = new QueryHelper(dbClient, tableCreationFile, tableUpdateFile);
+
+/**
+ * Generates a new handle from the username and a base64 string of the current time.
+ * @param username
+ */
+function generateHandle(username: string) {
+    return `${username}.${Buffer.from(Date.now().toString()).toString("base64")}`;
+}
+
+/**
+ * Namespace with functions to fetch initial data for wrapping.
+ */
+namespace dataaccess {
+
+    export const pool: Pool = dbClient;
+
+    /**
+     * Initializes everything that needs to be initialized asynchronous.
+     */
+    export async function init() {
+        try {
+            await queryHelper.init();
+        } catch (err) {
+            globals.logger.error(err.message);
+            globals.logger.debug(err.stack);
+        }
+    }
+
+    /**
+     * Returns the user by handle.
+     * @param userHandle
+     */
+    export async function getUserByHandle(userHandle: string): Promise<User> {
+        const result = await queryHelper.first({
+            text: "SELECT * FROM users WHERE users.handle = $1",
+            values: [userHandle],
+        });
+        if (result) {
+            return new User(result.id, result);
+        } else {
+            throw new UserNotFoundError(userHandle);
+        }
+    }
+
+    /**
+     * Returns the user by email and password
+     * @param email
+     * @param password
+     */
+    export async function getUserByLogin(email: string, password: string): Promise<Profile> {
+        const result = await queryHelper.first({
+            text: "SELECT * FROM users WHERE email = $1 AND password = $2",
+            values: [email, password],
+        });
+        if (result) {
+            return new Profile(result.id, result);
+        } else {
+            throw new UserNotFoundError(email);
+        }
+    }
+
+    /**
+     * Registers a user with a username and password returning a user
+     * @param username
+     * @param email
+     * @param password
+     */
+    export async function registerUser(username: string, email: string, password: string) {
+        const existResult = await queryHelper.first({
+            text: "SELECT email FROM users WHERE email = $1;",
+            values: [email],
+        });
+        if (!existResult || !existResult.email) {
+            const result = await queryHelper.first({
+                text: "INSERT INTO users (name, handle, password, email) VALUES ($1, $2, $3, $4) RETURNING *",
+                values: [username, generateHandle(username), password, email],
+            });
+            return new Profile(result.id, result);
+        } else {
+            throw new EmailAlreadyRegisteredError(email);
+        }
+    }
+
+    /**
+     * Returns a post for a given postId.s
+     * @param postId
+     */
+    export async function getPost(postId: number): Promise<Post> {
+        const result = await queryHelper.first({
+            text: "SELECT * FROM posts WHERE id = $1",
+            values: [postId],
+        });
+        if (result) {
+            return new Post(result.id, result);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Creates a post
+     * @param content
+     * @param authorId
+     * @param type
+     */
+    export async function createPost(content: string, authorId: number, type?: string): Promise<Post> {
+        type = type || "MISC";
+        const result = await queryHelper.first({
+            text: "INSERT INTO posts (content, author, type) VALUES ($1, $2, $3) RETURNING *",
+            values: [content, authorId, type],
+        });
+        const post = new Post(result.id, result);
+        globals.internalEmitter.emit(InternalEvents.POSTCREATE, post);
+        return post;
+    }
+
+    /**
+     * Deletes a post
+     * @param postId
+     */
+    export async function deletePost(postId: number): Promise<boolean> {
+        const result = await queryHelper.first({
+            text: "DELETE FROM posts WHERE posts.id = $1",
+            values: [postId],
+        });
+        return true;
+    }
+
+    /**
+     * Creates a chatroom containing two users
+     * @param members
+     */
+    export async function createChat(...members: number[]): Promise<Chatroom> {
+        const idResult = await queryHelper.first({
+            text: "INSERT INTO chats (id) values (default) RETURNING *;",
+        });
+        const id = idResult.id;
+        const transaction = await queryHelper.createTransaction();
+        try {
+            await transaction.begin();
+            for (const member of members) {
+                await transaction.query({
+                    name: "chat-member-insert",
+                    text: "INSERT INTO chat_members (chat, member) VALUES ($1, $2);",
+                    values: [id, member],
+                });
+            }
+            await transaction.commit();
+        } catch (err) {
+            globals.logger.warn(`Failed to insert chatmember into database: ${err.message}`);
+            globals.logger.debug(err.stack);
+            await transaction.rollback();
+        } finally {
+            transaction.release();
+        }
+        const chat = new Chatroom(id);
+        globals.internalEmitter.emit(InternalEvents.CHATCREATE, chat);
+        return chat;
+    }
+
+    /**
+     * Sends a message into a chat.
+     * @param authorId
+     * @param chatId
+     * @param content
+     */
+    export async function sendChatMessage(authorId: number, chatId: number, content: string) {
+        const chat = new Chatroom(chatId);
+        if ((await chat.exists())) {
+            const result = await queryHelper.first({
+                text: "INSERT INTO chat_messages (chat, author, content) values ($1, $2, $3) RETURNING *",
+                values: [chatId, authorId, content],
+            });
+            const message = new ChatMessage(new User(result.author), chat, result.created_at, result.content);
+            globals.internalEmitter.emit(InternalEvents.CHATMESSAGE, message);
+            return message;
+        } else {
+            throw new ChatNotFoundError(chatId);
+        }
+    }
+
+    /**
+     * Returns all chats.
+     */
+    export async function getAllChats(): Promise<Chatroom[]> {
+        const result = await queryHelper.all({
+            text: "SELECT id FROM chats;",
+        });
+        const chats = [];
+        for (const row of result) {
+            chats.push(new Chatroom(row.id));
+        }
+        return chats;
+    }
+
+    /**
+     * Sends a request to a user.
+     * @param sender
+     * @param receiver
+     * @param type
+     */
+    export async function createRequest(sender: number, receiver: number, type?: RequestType) {
+        type = type || RequestType.FRIENDREQUEST;
+
+        const result = await queryHelper.first({
+            text: "INSERT INTO requests (sender, receiver, type) VALUES ($1, $2, $3) RETURNING *",
+            values: [sender, receiver, type],
+        });
+        const request = new Request(new User(result.sender), new User(result.receiver), result.type);
+        globals.internalEmitter.emit(InternalEvents.REQUESTCREATE, Request);
+        return request;
+    }
+
+    /**
+     * Enum representing the types of votes that can be performed on a post.
+     */
+    export enum VoteType {
+        UPVOTE = "UPVOTE",
+        DOWNVOTE = "DOWNVOTE",
+    }
+
+    /**
+     * Enum representing the types of request that can be created.
+     */
+    export enum RequestType {
+        FRIENDREQUEST = "FRIENDREQUEST",
+        GROUPINVITE = "GROUPINVITE",
+        EVENTINVITE = "EVENTINVITE",
+    }
+}
+
+export default dataaccess;

src/lib/errors/BaseError.ts

@@ -0,0 +1,13 @@
+import {GraphQLError} from "graphql";
+
+/**
+ * Base error class.
+ */
+export class BaseError extends Error {
+    public readonly graphqlError: GraphQLError;
+
+    constructor(message?: string, friendlyMessage?: string) {
+        super(message);
+        this.graphqlError = new GraphQLError(friendlyMessage || message);
+    }
+}

src/lib/errors/ChatNotFoundError.ts

@@ -0,0 +1,7 @@
+import {BaseError} from "./BaseError";
+
+export class ChatNotFoundError extends BaseError {
+    constructor(chatId: number) {
+        super(`Chat with id ${chatId} not found.`);
+    }
+}

src/lib/errors/EmailAlreadyRegisteredError.ts

@@ -0,0 +1,8 @@
+import {BaseError} from "./BaseError";
+
+export class EmailAlreadyRegisteredError extends BaseError {
+    constructor(email: string) {
+        super(`A user for '${email}' does already exist.`);
+    }
+
+}

src/lib/errors/RequestNotFoundError.ts

@@ -0,0 +1,9 @@
+import dataaccess from "../dataaccess";
+import {BaseError} from "./BaseError";
+
+export class RequestNotFoundError extends BaseError {
+    constructor(sender: number, receiver: number, type: dataaccess.RequestType) {
+        super(`Request with sender '${sender}' and receiver '${receiver}' of type '${type}' not found.`);
+    }
+
+}

src/lib/errors/UserNotFoundError.ts

@@ -0,0 +1,7 @@
+import {BaseError} from "./BaseError";
+
+export class UserNotFoundError extends BaseError {
+    constructor(username: string) {
+        super(`User ${username} not found!`);
+    }
+}

src/lib/errors/graphqlErrors.ts

@@ -0,0 +1,9 @@
+import {GraphQLError} from "graphql";
+import {BaseError} from "./BaseError";
+
+export class NotLoggedInGqlError extends GraphQLError {
+
+    constructor() {
+        super("Not logged in");
+    }
+}

src/lib/globals.ts

@@ -0,0 +1,52 @@
+/**
+ * @author Trivernis
+ * @remarks
+ *
+ * Partly taken from {@link https://github.com/Trivernis/whooshy}
+ */
+
+import {EventEmitter} from "events";
+import * as fsx from "fs-extra";
+import * as yaml from "js-yaml";
+import * as winston from "winston";
+import {MemoryCache} from "./MemoryCache";
+
+const configPath = "config.yaml";
+const defaultConfig = __dirname + "/../default-config.yaml";
+
+// ensure that the config exists by copying the default config.
+if (!(fsx.pathExistsSync(configPath))) {
+    fsx.copySync(defaultConfig, configPath);
+} else {
+    const conf = yaml.safeLoad(fsx.readFileSync(configPath, "utf-8"));
+    const defConf = yaml.safeLoad(fsx.readFileSync(defaultConfig, "utf-8"));
+    fsx.writeFileSync(configPath, yaml.safeDump(Object.assign(defConf, conf)));
+}
+
+/**
+ * Defines global variables to be used.
+ */
+namespace globals {
+    export const config = yaml.safeLoad(fsx.readFileSync("config.yaml", "utf-8"));
+    export const cache = new MemoryCache(1200);
+    export const logger = winston.createLogger({
+        transports: [
+            new winston.transports.Console({
+                format: winston.format.combine(
+                    winston.format.timestamp(),
+                    winston.format.colorize(),
+                    winston.format.printf(({ level, message, timestamp }) => {
+                        return `${timestamp} ${level}: ${message}`;
+                    }),
+                ),
+                level: config.logging.level,
+            }),
+        ],
+    });
+    export const internalEmitter = new EventEmitter();
+    cache.on("set", (key) => logger.debug(`Caching '${key}'.`));
+    cache.on("miss", (key) => logger.debug(`Cache miss for '${key}'`));
+    cache.on("hit", (key) => logger.debug(`Cache hit for '${key}'`));
+}
+
+export default globals;

src/lib/markdown.ts

@@ -0,0 +1,36 @@
+import * as MarkdownIt from "markdown-it/lib";
+import globals from "./globals";
+
+namespace markdown {
+
+    const md = new MarkdownIt();
+
+    for (const pluginName of globals.config.markdown.plugins) {
+        try {
+            const plugin = require(pluginName);
+            if (plugin) {
+                md.use(plugin);
+            }
+        } catch (err) {
+            globals.logger.warn(`Markdown-it plugin '${pluginName}' not found!`);
+        }
+    }
+
+    /**
+     * Renders the markdown string inline (without blocks).
+     * @param markdownString
+     */
+    export function renderInline(markdownString: string) {
+        return md.renderInline(markdownString);
+    }
+
+    /**
+     * Renders the markdown string.
+     * @param markdownString
+     */
+    export function render(markdownString: string) {
+        return md.render(markdownString);
+    }
+}
+
+export default markdown;

src/lib/regex.ts

@@ -0,0 +1,11 @@
+export namespace is {
+    const emailRegex = /\S+?@\S+?(\.\S+?)?\.\w{2,3}(.\w{2-3})?/g;
+
+    /**
+     * Tests if a string is a valid email.
+     * @param testString
+     */
+    export function email(testString: string) {
+        return emailRegex.test(testString);
+    }
+}

src/public/stylesheets/sass/mixins.sass

@@ -0,0 +1,5 @@
+@mixin gridPosition($rowStart, $rowEnd, $columnStart, $columnEnd)
+  grid-row-start: $rowStart
+  grid-row-end: $rowEnd
+  grid-column-start: $columnStart
+  grid-column-end: $columnEnd

src/public/stylesheets/sass/style.sass

@@ -0,0 +1,108 @@
+@import "vars"
+@import "mixins"
+
+body
+  font-family: Arial, serif
+
+button
+  border: 2px solid $cPrimary
+  margin-top: 0.125em
+  padding: 0.125em
+  background-color: $cPrimary
+  color: $cPrimarySurface
+  font-weight: bold
+  transition-duration: 0.25s
+
+button:hover
+  background-color: lighten($cPrimary, 10%)
+  cursor: pointer
+
+button:active
+  background-color: darken($cPrimary, 5%)
+  box-shadow: inset 0.25em 0.25em 0.1em rgba(0, 0, 0, 0.25)
+
+.stylebar
+  @include gridPosition(1, 2, 1, 4)
+  display: grid
+  grid-template: 100% /25% 50% 25%
+  background-color: $cPrimary
+  color: $cPrimarySurface
+
+  h1
+    @include gridPosition(1, 2, 1, 2)
+    text-align: center
+    margin: auto
+
+#content
+  grid-template: 7.5% 92.5% / 25% 50% 25%
+  display: grid
+  width: 100%
+  height: 100%
+
+#friendscontainer
+  @include gridPosition(2, 3, 1, 2)
+  background-color: $cPrimaryBackground
+
+#input-login
+  margin-top: 1em
+  @include gridPosition(2,3,2,3)
+  grid-template: 7.5% 7.5% 7.5% 7.5% 72%/ 100%
+  display: grid
+  background-color: $cPrimaryBackground
+
+  input
+    margin: 0.25em
+
+  .loginButton
+    margin: 0.25em
+
+#input-register
+  margin-top: 1em
+  @include gridPosition(2,3,2,3)
+  grid-template: 7.5% 7.5% 7.5% 7.5% 7.5% 7.5% 58%/ 100%
+  display: grid
+  background-color: $cPrimaryBackground
+
+  input
+    margin: 0.25em
+
+  .registerButton
+    margin: 0.25em
+
+#feedcontainer
+  @include gridPosition(2, 3, 2, 3)
+  background-color: $cSecondaryBackground
+  .postinput
+    margin: 0.5em
+    input
+      width: 100%
+      border-radius: 0.25em
+      border: 1px solid $cPrimary
+      padding: 0.125em
+      height: 2em
+    button.submitbutton
+      border-radius: 0.25em
+      height: 2em
+
+  .feeditem
+    background-color: $cPrimaryBackground
+    min-height: 2em
+    margin: 0.5em
+    padding: 0.25em
+    border-radius: 0.25em
+    .itemhead
+      align-items: flex-start
+
+      .title, .handle, .date
+        margin: 0.125em
+      .title
+        font-weight: bold
+
+      .handle, .date
+        color: $cInactiveText
+      .handle a
+        text-decoration: none
+        color: $cInactiveText
+        font-style: normal
+      .handle a:hover
+        text-decoration: underline

src/public/stylesheets/sass/vars.sass

@@ -0,0 +1,5 @@
+$cPrimaryBackground: #fff
+$cSecondaryBackground: #ddd
+$cInactiveText: #555
+$cPrimary: #0d6b14
+$cPrimarySurface: #fff

src/routes/home.ts

@@ -0,0 +1,101 @@
+import {Router} from "express";
+import {Namespace, Server} from "socket.io";
+import dataaccess from "../lib/dataaccess";
+import {ChatMessage} from "../lib/dataaccess/ChatMessage";
+import {Chatroom} from "../lib/dataaccess/Chatroom";
+import {Post} from "../lib/dataaccess/Post";
+import {Request} from "../lib/dataaccess/Request";
+import globals from "../lib/globals";
+import {InternalEvents} from "../lib/InternalEvents";
+import Route from "../lib/Route";
+
+/**
+ * list of chatroom socket namespaces.
+ */
+const chatRooms: Namespace[] = [];
+
+/**
+ * Class for the home route.
+ */
+class HomeRoute extends Route {
+    /**
+     * Constructor, creates new router.
+     */
+    constructor() {
+        super();
+        this.router = Router();
+    }
+
+    /**
+     * Asynchronous init for socket.io.
+     * @param io - the io instance
+     */
+    public async init(io: Server) {
+        this.io = io;
+
+        io.on("connection", (socket) => {
+            socket.on("postCreate", async (content) => {
+                if (socket.handshake.session.userId) {
+                    const post = await dataaccess.createPost(content, socket.handshake.session.userId);
+                    io.emit("post", await post.resolvedData());
+                } else {
+                    socket.emit("error", "Not logged in!");
+                }
+            });
+            globals.internalEmitter.on(InternalEvents.REQUESTCREATE, (request: Request) => {
+                if (request.receiver.id === socket.handshake.session.userId) {
+                    socket.emit("request", request.resolvedData());
+                }
+            });
+            globals.internalEmitter.on(InternalEvents.GQLPOSTCREATE, async (post: Post) => {
+                socket.emit("post", await post.resolvedData());
+            });
+        });
+
+        const chats = await dataaccess.getAllChats();
+        for (const chat of chats) {
+            chatRooms[chat.id] = this.getChatSocketNamespace(chat.id);
+        }
+        globals.internalEmitter.on(InternalEvents.CHATCREATE, (chat: Chatroom) => {
+            chatRooms[chat.id] = this.getChatSocketNamespace(chat.id);
+        });
+    }
+
+    /**
+     * Destroys the instance by dereferencing the router and resolver.
+     */
+    public async destroy(): Promise<void> {
+        this.router = null;
+    }
+
+    /**
+     * Returns the namespace socket for a chat socket.
+     * @param chatId
+     */
+    private getChatSocketNamespace(chatId: number) {
+        if (chatRooms[chatId]) {
+            return chatRooms[chatId];
+        }
+        const chatNs = this.io.of(`/chat/${chatId}`);
+        chatNs.on("connection", (socket) => {
+            socket.on("chatMessage", async (content) => {
+                if (socket.handshake.session.userId) {
+                    const userId = socket.handshake.session.userId;
+                    const message = await dataaccess.sendChatMessage(userId, chatId, content);
+                    socket.broadcast.emit("chatMessage", message.resolvedContent());
+                    socket.emit("chatMessageSent", message.resolvedContent());
+                } else {
+                    socket.emit("error", "Not logged in!");
+                }
+            });
+            globals.internalEmitter.on(InternalEvents.GQLCHATMESSAGE, (message: ChatMessage) => {
+                if (message.chat.id === chatId) {
+                    socket.emit("chatMessage", message.resolvedContent());
+                }
+            });
+        });
+        return chatNs;
+    }
+}
+
+export default HomeRoute;

src/routes/index.ts

@@ -0,0 +1,34 @@
+/**
+ * @author Trivernis
+ * @remarks
+ *
+ * Taken from {@link https://github.com/Trivernis/whooshy}
+ */
+
+import {Router} from "express";
+import {Server} from "socket.io";
+
+import HomeRoute from "./home";
+
+const homeRoute = new HomeRoute();
+
+/**
+ * Namespace to manage the routes of the server.
+ * Allows easier assignments of graphql endpoints, socket.io connections and routers when
+ * used with {@link Route}.
+ */
+namespace routes {
+    export const router = Router();
+
+    router.use("/", homeRoute.router);
+
+    /**
+     * Assigns the io listeners or namespaces to the routes
+     * @param io
+     */
+    export const ioListeners = async (io: Server) => {
+        await homeRoute.init(io);
+    };
+}
+
+export default routes;

src/sql/create-tables.sql

@@ -0,0 +1,137 @@
+--create functions
+DO $$BEGIN
+
+    IF NOT EXISTS(SELECT 1 from pg_proc WHERE proname = 'function_exists') THEN
+        CREATE FUNCTION function_exists(text) RETURNS boolean LANGUAGE plpgsql AS $BODY$
+        BEGIN
+            RETURN EXISTS(SELECT 1 from pg_proc WHERE proname = $1);
+        END $BODY$;
+    END IF;
+
+    IF NOT function_exists('type_exists') THEN
+        CREATE FUNCTION type_exists(text) RETURNS boolean LANGUAGE plpgsql AS $BODY$
+        BEGIN
+            RETURN EXISTS (SELECT 1 FROM pg_type WHERE typname = $1);
+        END $BODY$;
+    END IF;
+
+END$$;
+
+--create types
+DO $$ BEGIN
+
+    IF NOT type_exists('votetype') THEN
+        CREATE TYPE votetype AS enum ('DOWNVOTE', 'UPVOTE');
+    END IF;
+
+    IF NOT type_exists('posttype') THEN
+        CREATE TYPE posttype AS enum ('MISC', 'ACTION', 'IMAGE', 'TEXT');
+    END IF;
+
+    IF NOT type_exists('requesttype') THEN
+        CREATE TYPE requesttype AS enum ('FRIENDREQUEST');
+    END IF;
+
+END$$;
+
+-- create functions relying on types
+
+DO $$ BEGIN
+
+    IF NOT function_exists('cast_to_votetype') THEN
+        CREATE FUNCTION cast_to_votetype(text) RETURNS votetype LANGUAGE plpgsql AS $BODY$
+        BEGIN
+            RETURN CASE WHEN $1::votetype IS NULL THEN 'UPVOTE' ELSE $1::votetype END;
+        END $BODY$;
+    END IF;
+
+    IF NOT function_exists('cast_to_posttype') THEN
+        CREATE FUNCTION cast_to_posttype(text) RETURNS posttype LANGUAGE plpgsql AS $BODY$
+        BEGIN
+            RETURN CASE WHEN $1::posttype IS NULL THEN 'MISC' ELSE $1::posttype END;
+        END $BODY$;
+    END IF;
+
+END$$;
+
+-- create tables
+DO $$ BEGIN
+
+    CREATE TABLE IF NOT EXISTS "user_sessions" (
+        "sid" varchar NOT NULL,
+        "sess" json NOT NULL,
+        "expire" timestamp(6) NOT NULL,
+        PRIMARY KEY ("sid") NOT DEFERRABLE INITIALLY IMMEDIATE
+    ) WITH (OIDS=FALSE);
+
+    CREATE TABLE IF NOT EXISTS users (
+        id SERIAL PRIMARY KEY,
+        name varchar(128) NOT NULL,
+        handle varchar(128) UNIQUE NOT NULL,
+        password varchar(1024) NOT NULL,
+        email varchar(128) UNIQUE NOT NULL,
+        greenpoints INTEGER DEFAULT 0,
+        joined_at TIMESTAMP DEFAULT now()
+    );
+
+    CREATE TABLE IF NOT EXISTS posts (
+        id BIGSERIAL PRIMARY KEY,
+        upvotes INTEGER DEFAULT 0,
+        downvotes INTEGER DEFAULT 0,
+        created_at TIMESTAMP DEFAULT now(),
+        content text,
+        author SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        type posttype NOT NULL DEFAULT 'MISC'
+    );
+
+    CREATE TABLE IF NOT EXISTS votes (
+        user_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        item_id BIGSERIAL REFERENCES posts (id) ON DELETE CASCADE,
+        vote_type votetype DEFAULT 'DOWNVOTE',
+        PRIMARY KEY (user_id, item_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+        id BIGSERIAL PRIMARY KEY,
+        time TIMESTAMP,
+        owner SERIAL REFERENCES users (id)
+    );
+
+    CREATE TABLE IF NOT EXISTS event_members (
+        event BIGSERIAL REFERENCES events (id),
+        member SERIAL REFERENCES users (id),
+        PRIMARY KEY (event, member)
+    );
+
+    CREATE TABLE IF NOT EXISTS chats (
+        id BIGSERIAL PRIMARY KEY
+    );
+
+    CREATE TABLE IF NOT EXISTS chat_messages (
+        chat BIGSERIAL REFERENCES chats (id) ON DELETE CASCADE,
+        author SERIAL REFERENCES users (id) ON DELETE SET NULL,
+        content VARCHAR(1024) NOT NULL,
+        created_at TIMESTAMP DEFAULT now(),
+        PRIMARY KEY (chat, author, created_at)
+    );
+
+    CREATE TABLE IF NOT EXISTS chat_members (
+        chat BIGSERIAL REFERENCES chats (id) ON DELETE CASCADE,
+        member SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        PRIMARY KEY (chat, member)
+    );
+
+    CREATE TABLE IF NOT EXISTS user_friends (
+        user_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        friend_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        PRIMARY KEY (user_id, friend_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS requests (
+        sender SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        receiver SERIAL REFERENCES users (id) ON DELETE CASCADE,
+        type requesttype DEFAULT 'FRIENDREQUEST',
+        PRIMARY KEY (sender, receiver, type)
+    );
+
+END $$;

src/sql/update-tables.sql

@@ -0,0 +1,19 @@
+DO $$ BEGIN
+
+    ALTER TABLE IF EXISTS votes
+        ADD COLUMN IF NOT EXISTS vote_type votetype DEFAULT 'UPVOTE',
+        ALTER COLUMN vote_type TYPE votetype USING cast_to_votetype(vote_type::text),
+        ALTER COLUMN vote_type DROP DEFAULT,
+        ALTER COLUMN vote_type SET DEFAULT 'UPVOTE';
+
+    ALTER TABLE IF EXISTS posts
+        ALTER COLUMN type TYPE posttype USING cast_to_posttype(type::text),
+        ALTER COLUMN type DROP DEFAULT,
+        ALTER COLUMN type SET DEFAULT 'MISC',
+        DROP COLUMN IF EXISTS upvotes,
+        DROP COLUMN IF EXISTS downvotes;
+
+    ALTER TABLE requests
+        ADD COLUMN IF NOT EXISTS type requesttype DEFAULT 'FRIENDREQUEST';
+
+END $$;

tslint.json

@@ -0,0 +1,31 @@
+{
+  "extends": "tslint:recommended",
+  "rulesDirectory": [],
+  "rules": {
+    "max-line-length": {
+      "options": [120]
+    },
+    "new-parens": true,
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-conditional-assignment": true,
+    "no-consecutive-blank-lines": false,
+    "cyclomatic-complexity": true,
+    "brace-style": "1tbs",
+    "semicolon": true,
+    "indent": [true, "spaces", 4],
+    "no-shadowed-variable": true,
+    "no-console": {
+      "severity": "warning",
+      "options": ["debug", "info", "log", "time", "timeEnd", "trace"]
+    },
+    "no-namespace": false,
+    "no-internal-module": false,
+    "max-classes-per-file": false
+  },
+  "jsRules": {
+    "max-line-length": {
+      "options": [120]
+    }
+  }
+}