Switch to TypeORM's DataSource API (#299)

- Switch to TypeORM's DataSource API, rather than using the now deprecated ormconfig.json
- This will fix stage deployment not knowing how to deploy the database migrations

#297

> **NOTE:** This change requires the deployment scripts to be updated, please update them on the server before merging

Co-authored-by: Ethan Lane <ethan@vylpes.com>
Reviewed-on: https://gitea.vylpes.xyz/RabbitLabs/vylbot-app/pulls/299

src/database/dataSources/appDataSource.ts

@@ -0,0 +1,26 @@
+import { DataSource } from "typeorm";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+const AppDataSource = new DataSource({
+    type: "mysql",
+    host: process.env.DB_HOST,
+    port: Number(process.env.DB_PORT),
+    username: process.env.DB_AUTH_USER,
+    password: process.env.DB_AUTH_PASS,
+    database: process.env.DB_NAME,
+    synchronize: process.env.DB_SYNC == "true",
+    logging: process.env.DB_LOGGING == "true",
+    entities: [
+        "dist/database/entities/**/*.js",
+    ],
+    migrations: [
+        "dist/database/migrations/**/*.js",
+    ],
+    subscribers: [
+        "dist/database/subscribers/**/*.js",
+    ],
+});
+
+export default AppDataSource;

src/database/entities/501231711271780357/Lobby.ts

@@ -0,0 +1,44 @@
+import { Column, Entity } from "typeorm";
+import BaseEntity from "../../../contracts/BaseEntity";
+import AppDataSource from "../../dataSources/appDataSource";
+
+@Entity()
+export default class Lobby extends BaseEntity {
+    constructor(channelId: string, roleId: string, cooldown: number, name: string) {
+        super();
+
+        this.ChannelId = channelId;
+        this.RoleId = roleId;
+        this.Cooldown = cooldown;
+        this.Name = name;
+
+        this.LastUsed = new Date(0);
+    }
+
+    @Column()
+    public ChannelId: string;
+
+    @Column()
+    public RoleId: string;
+
+    @Column()
+    public Cooldown: number;
+
+    @Column()
+    public LastUsed: Date;
+
+    @Column()
+    public Name: string;
+
+    public MarkAsUsed() {
+        this.LastUsed = new Date();
+    }
+
+    public static async FetchOneByChannelId(channelId: string, relations?: string[]): Promise<Lobby | null> {
+        const repository = AppDataSource.getRepository(Lobby);
+
+        const single = await repository.findOne({ where: { ChannelId: channelId }, relations: relations || [] });
+
+        return single;
+    }
+}

src/database/entities/Audit.ts

@@ -0,0 +1,53 @@
+import { Column, Entity } from "typeorm";
+import { AuditType } from "../../constants/AuditType";
+import BaseEntity from "../../contracts/BaseEntity";
+import StringTools from "../../helpers/StringTools";
+import AppDataSource from "../dataSources/appDataSource";
+
+@Entity()
+export default class Audit extends BaseEntity {
+    constructor(userId: string, auditType: AuditType, reason: string, moderatorId: string, serverId: string) {
+        super();
+
+        this.AuditId = StringTools.RandomString(5).toUpperCase();
+        this.UserId = userId;
+        this.AuditType = auditType;
+        this.Reason = reason;
+        this.ModeratorId = moderatorId;
+        this.ServerId = serverId;
+    }
+
+    @Column()
+    AuditId: string;
+
+    @Column()
+    UserId: string;
+
+    @Column()
+    AuditType: AuditType;
+
+    @Column()
+    Reason: string;
+
+    @Column()
+    ModeratorId: string;
+
+    @Column()
+    ServerId: string;
+
+    public static async FetchAuditsByUserId(userId: string, serverId: string): Promise<Audit[] | null> {
+        const repository = AppDataSource.getRepository(Audit);
+
+        const all = await repository.find({ where: { UserId: userId, ServerId: serverId } });
+
+        return all;
+    }
+
+    public static async FetchAuditByAuditId(auditId: string, serverId: string): Promise<Audit | null> {
+        const repository = AppDataSource.getRepository(Audit);
+
+        const single = await repository.findOne({ where: { AuditId: auditId, ServerId: serverId } });
+
+        return single;
+    }
+}

src/database/entities/IgnoredChannel.ts

@@ -0,0 +1,20 @@
+import { Entity } from "typeorm";
+import BaseEntity from "../../contracts/BaseEntity";
+import AppDataSource from "../dataSources/appDataSource";
+
+@Entity()
+export default class IgnoredChannel extends BaseEntity {
+    constructor(channelId: string) {
+        super();
+
+        this.Id = channelId;
+    }
+
+    public static async IsChannelIgnored(channelId: string): Promise<boolean> {
+        const repository = AppDataSource.getRepository(IgnoredChannel);
+
+        const single = await repository.findOne({ where: { Id: channelId } });
+
+        return single != undefined;
+    }
+}

src/database/entities/Role.ts

@@ -0,0 +1,45 @@
+import { Column, Entity, ManyToOne } from "typeorm";
+import BaseEntity from "../../contracts/BaseEntity"
+import Server from "./Server";
+import AppDataSource from "../dataSources/appDataSource";
+
+@Entity()
+export default class Role extends BaseEntity {
+    constructor(roleId: string) {
+        super();
+
+        this.RoleId = roleId;
+    }
+
+    @Column()
+    RoleId: string;
+
+    @ManyToOne(() => Server, x => x.Roles)
+    Server: Server;
+
+    public SetServer(server: Server) {
+        this.Server = server;
+    }
+
+    public static async FetchOneByRoleId(roleId: string, relations?: string[]): Promise<Role | null> {
+        const repository = AppDataSource.getRepository(Role);
+
+        const single = await repository.findOne({ where: { RoleId: roleId }, relations: relations || []});
+
+        return single;
+    }
+
+    public static async FetchAllByServerId(serverId: string): Promise<Role[]> {
+        const repository = AppDataSource.getRepository(Server);
+
+        const all = await repository.findOne({ where: { Id: serverId }, relations: [
+            "Roles",
+        ] });
+
+        if (!all) {
+            return [];
+        }
+
+        return all.Roles;
+    }
+}

src/database/entities/Server.ts

@@ -0,0 +1,27 @@
+import { Entity, OneToMany } from "typeorm";
+import BaseEntity from "../../contracts/BaseEntity";
+import Role from "./Role";
+import Setting from "./Setting";
+
+@Entity()
+export default class Server extends BaseEntity {
+    constructor(serverId: string) {
+        super();
+
+        this.Id = serverId;
+    }
+
+    @OneToMany(() => Setting, x => x.Server)
+    Settings: Setting[];
+
+    @OneToMany(() => Role, x => x.Server)
+    Roles: Role[];
+
+    public AddSettingToServer(setting: Setting) {
+        this.Settings.push(setting);
+    }
+
+    public AddRoleToServer(role: Role) {
+        this.Roles.push(role);
+    }
+}

src/database/entities/Setting.ts

@@ -0,0 +1,36 @@
+import { Column, Entity, ManyToOne } from "typeorm";
+import BaseEntity from "../../contracts/BaseEntity";
+import Server from "./Server";
+import AppDataSource from "../dataSources/appDataSource";
+
+@Entity()
+export default class Setting extends BaseEntity {
+    constructor(key: string, value: string) {
+        super();
+
+        this.Key = key;
+        this.Value = value;
+    }
+
+    @Column()
+    Key: string;
+
+    @Column()
+    Value: string;
+
+    @ManyToOne(() => Server, x => x.Settings)
+    Server: Server;
+
+    public UpdateBasicDetails(key: string, value: string) {
+        this.Key = key;
+        this.Value = value;
+    }
+
+    public static async FetchOneByKey(key: string, relations?: string[]): Promise<Setting | null> {
+        const repository = AppDataSource.getRepository(Setting);
+
+        const single = await repository.findOne({ where: { Key: key }, relations: relations || {} });
+
+        return single;
+    }
+}

src/database/migrations/3.1/1662399171315-CreateBase.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from "typeorm"
+import MigrationHelper from "../../../helpers/MigrationHelper"
+
+export class vylbot1662399171315 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        MigrationHelper.Up('1662399171315-CreateBase', '3.1', [
+            "01-table/Audit",
+            "01-table/IgnoredChannel",
+            "01-table/Lobby",
+            "01-table/Role",
+            "01-table/Server",
+            "01-table/Setting",
+
+            "02-key/Audit",
+            "02-key/IgnoredChannel",
+            "02-key/Lobby",
+            "02-key/Role",
+            "02-key/Server",
+            "02-key/Setting",
+
+            "03-constraint/Role",
+            "03-constraint/Setting",
+        ], queryRunner);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+    }
+
+}