cloudservices/src/class/Client.ts

import { Client as DiscordClient, Intents } from 'discord.js';
import Redis from 'ioredis';
import mongoose from 'mongoose';
import signale from 'signale';
import fs from 'fs-extra';
import config from '../config.json';
import { Account, AccountInterface, Moderation, ModerationInterface, Domain, DomainInterface, Tier, TierInterface } from '../models';
import { emojis } from '../stores';
import { Command, CSCLI, Util, Collection, Server, Event } from '.';

export default class Client extends DiscordClient {
  public config: { 'token': string; 'cloudflare': string; 'prefix': string; 'emailPass': string; 'mongoURL': string; 'port': number; 'keyPair': { 'publicKey': string; 'privateKey': string; }; vendorKey: string; internalKey: string; };

  public util: Util;

  public commands: Collection<Command>;

  public events: Collection<Event>;

  public db: { Account: mongoose.Model<AccountInterface>; Domain: mongoose.Model<DomainInterface>; Moderation: mongoose.Model<ModerationInterface>; Tier: mongoose.Model<TierInterface>; };

  public redis: Redis.Redis;

  public stores: { emojis: { success: string, loading: string, error: string }; };

  public functions: Collection<Function>;

  public signale: signale.Signale;

  public server: Server;

  public updating: boolean;

  public buildError: boolean

  constructor() {
    super({
      shards: 'auto',
      intents: [
        Intents.FLAGS.GUILDS,
        Intents.FLAGS.GUILD_MEMBERS,
        Intents.FLAGS.GUILD_BANS,
        Intents.FLAGS.GUILD_EMOJIS_AND_STICKERS,
        Intents.FLAGS.GUILD_INTEGRATIONS,
        Intents.FLAGS.GUILD_WEBHOOKS,
        Intents.FLAGS.GUILD_INVITES,
        Intents.FLAGS.GUILD_VOICE_STATES,
        Intents.FLAGS.GUILD_PRESENCES,
        Intents.FLAGS.GUILD_MESSAGES,
        Intents.FLAGS.GUILD_MESSAGE_REACTIONS,
        Intents.FLAGS.GUILD_MESSAGE_TYPING,
        Intents.FLAGS.DIRECT_MESSAGES,
        Intents.FLAGS.DIRECT_MESSAGE_REACTIONS,
        Intents.FLAGS.DIRECT_MESSAGE_TYPING,
      ],
      partials: [
        'USER',
        'CHANNEL',
        'GUILD_MEMBER',
        'MESSAGE',
        'REACTION',
      ],
      allowedMentions: {
        parse: [
          'users',
          'roles',
        ],
        repliedUser: false,
      },
    });

    process.title = 'cloudservices';
    this.config = config;
    this.util = new Util(this);
    this.commands = new Collection<Command>();
    this.events = new Collection<Event>();
    this.functions = new Collection<Function>();
    this.db = { Account, Domain, Moderation, Tier };
    this.redis = new Redis();
    this.stores = { emojis };
    this.signale = signale;
    this.signale.config({
      displayDate: true,
      displayTimestamp: true,
      displayFilename: true,
    });
    this.updating = false;
    this.buildError = false;
    this.errorEvents();
  }

  public async errorEvents() {
    process.on('unhandledRejection', (error: Error) => {
      this.util.handleError(error);
    });
    this.on('error', (error) => {
      this.util.handleError(error);
    });
  }

  public async loadFunctions() {
    const functions = await fs.readdir(`${__dirname}/../functions`);
    functions.forEach(async (func) => {
      if (func === 'index.ts' || func === 'index.js') return;
      try {
        const funcRequire: Function = require(`${__dirname}/../functions/${func}`).default;
        this.functions.set(func.split('.')[0], funcRequire);
      } catch (error) {
        this.signale.error(`Error occurred loading ${func}`);
        await this.util.handleError(error);
      }
    });
  }

  public loadCommand(CommandFile: any) {
    // eslint-disable-next-line no-useless-catch
    try {
      const command: Command = new CommandFile(this);
      if (command.subcmds.length) {
        command.subcmds.forEach((C) => {
          const cmd: Command = new C(this);
          command.subcommands.add(cmd.name, cmd);
        });
      }
      delete command.subcmds;
      this.commands.add(command.name, command);
      this.signale.complete(`Loaded command ${command.name}`);
    } catch (err) { throw err; }
  }

  public async loadEvents(eventFiles: { [s: string]: typeof Event; } | ArrayLike<typeof Event>) {
    const evtFiles = Object.entries<typeof Event>(eventFiles);
    for (const [name, Ev] of evtFiles) {
      const event = new Ev(this);
      this.events.add(event.event, event);
      this.on(event.event, event.run);
      this.signale.success(`Successfully loaded event: ${name}`);
      delete require.cache[require.resolve(`${__dirname}/../events/${name}`)];
    }
  }

  public async loadCommands(commandFiles: { [s: string]: typeof Command; } | ArrayLike<typeof Command>) {
    const cmdFiles = Object.values<typeof Command>(commandFiles);
    for (const Cmd of cmdFiles) {
      const command = new Cmd(this);
      if (command.subcmds.length) {
        command.subcmds.forEach((C) => {
          const cmd: Command = new C(this);
          command.subcommands.add(cmd.name, cmd);
        });
      }
      delete command.subcmds;
      this.commands.add(command.name, command);
      this.signale.success(`Successfully loaded command: ${command.name}`);
    }
  }

  public async init() {
    await mongoose.connect(config.mongoURL, { useNewUrlParser: true, useUnifiedTopology: true });
    await this.login(config.token);
    this.on('ready', () => {
      this.signale.info(`Connected to Discord as ${this.user.username}#${this.user.discriminator}`);
    });
    const intervals = await fs.readdir(`${__dirname}/../intervals`);
    intervals.forEach((interval) => {
      if (interval === 'index.js') {
        return;
      }
      require(`${__dirname}/../intervals/${interval}`).default(this);
      this.signale.complete(`Loaded interval ${interval.split('.')[0]}`);
    });
    this.server = new Server(this, { port: this.config.port });

    const corepath = '/opt/CloudServices/dist';
    const cmdFiles = await fs.readdir('/opt/CloudServices/dist/commands');
    cmdFiles.forEach((f) => delete require.cache[`${corepath}/${f}`]);
    delete require.cache[`${corepath}/config.json`];
    delete require.cache[`${corepath}/class/Util`];
  }
}