Wip refactor streamhandler

.gitignore

@@ -3,6 +3,8 @@ server/dist
 server/node_modules
 server/logs
 
+*.temp.*
+
 #FRONTEND
 
 # dependencies

libs/types/index.d.ts

@@ -1,28 +1,31 @@
 import { IUser } from "../../server/src/models/types";
 
-interface IEvent {
+export interface IEvent {
   eventDate: Date;
   eventName: string;
 }
 
-interface IEventAndIUser extends IEvent, IUser {}
-interface ServerToClientEvents {
+export interface IEventAndIUser extends IEvent, IUser {}
+export interface ServerToClientEvents {
   noArg: () => void;
   withAck: (d: string, callback: (e: number) => void) => void;
   messageServer: (date: Date, username: string, message: string) => void;
   userJoinTwitchChat: (eventDate: IEvent, user: IUser) => void;
   onRedemption: (data: ISoundData) => void;
 }
 
-interface ClientToServerEvents {
+export interface ClientToServerEvents {
   messageClient: (message: string) => void;
+  saveConfigs: () => void;
+  refreshTriggers: () => void;
+  refreshCommands: () => void;
 }
 
-interface InterServerEvents {
+export interface InterServerEvents {
   ping: () => void;
 }
 
-interface ISoundData {
+export interface ISoundData {
   rewardId: string;
   userId: string;
   userName: string;
@@ -33,12 +36,4 @@ interface ISoundData {
   rewardImage: string;
 }
 
-interface SocketData {}
-
-export {
-  ClientToServerEvents,
-  SocketData,
-  InterServerEvents,
-  ServerToClientEvents,
-  IEventAndIUser,
-};
+export interface SocketData {}

server/package.json

@@ -49,6 +49,7 @@
     "@middlewares": "dist/middlewares",
     "@utils": "dist/utils",
     "@services": "dist/services",
+    "@defaults": "dist/defaults",
     "@types": "@types"
   }
 }

server/src/defaults/configsDefaults.ts

@@ -0,0 +1,22 @@
+import { IConfigDefaults } from "./types";
+
+export const configDefaults: IConfigDefaults = {
+  commandsPrefix: "--",
+  timersIntervalDelay: 20,
+  activeUserTimeDelay: 150,
+  chatGamesIntervalDelay: 20,
+  minActiveUsersThreshold: 3,
+  intervalCheckChatters: 300,
+  pointsIncrement: {
+    message: 1,
+    watch: 10,
+    watchMultipler: 2.0,
+  },
+  intervalCheckViewersPeek: 600,
+  permissionLevels: {
+    broadcaster: 10,
+    mod: 8,
+    vip: 4,
+    all: 0,
+  },
+};

server/src/defaults/types/index.d.ts

@@ -0,0 +1,4 @@
+import { IConfig } from "@models/types";
+
+export interface IConfigDefaults
+  extends Omit<IConfig, "_id" | "createdAt" | "updatedAt"> {}

server/src/models/chatCommandModel.ts

@@ -4,7 +4,6 @@ import { IChatCommandDocument } from "./types";
 const ChatCommandSchema: Schema<IChatCommandDocument> = new Schema(
   {
     name: { type: String, required: true },
-    // createdAt: { type: Date, required: true, default: Date.now },
     description: { type: String },
     enabled: { type: Boolean, default: true },
     aliases: [String],
@@ -15,7 +14,7 @@ const ChatCommandSchema: Schema<IChatCommandDocument> = new Schema(
       min: 0,
       max: 10,
     },
-    useCount: {
+    uses: {
       type: Number,
       default: 0,
     },

server/src/models/configModel.ts

@@ -1,25 +1,61 @@
 import { Model, model, Schema } from "mongoose";
 import { IConfigDocument } from "./types";
+import { configDefaults } from "../defaults/configsDefaults";
+const {
+  commandsPrefix,
+  timersIntervalDelay,
+  activeUserTimeDelay,
+  chatGamesIntervalDelay,
+  minActiveUsersThreshold,
+  pointsIncrement,
+  intervalCheckChatters,
+  intervalCheckViewersPeek,
+  permissionLevels,
+} = configDefaults;
 
 const ConfigSchema: Schema<IConfigDocument> = new Schema(
   {
-    commandsPrefix: { type: String, required: true, default: "--" },
-    timersIntervalDelay: { type: Number, required: true, default: 20 },
-    activeUserTimeDelay: { type: Number, required: true, default: 150 },
-    chatGamesIntervalDelay: { type: Number, required: true, default: 20 },
-    minActiveUsersThreshold: { type: Number, required: true, default: 3 },
-    intervalCheckChatters: { type: Number, required: true, default: 150 },
+    commandsPrefix: { type: String, required: true, default: commandsPrefix },
+    timersIntervalDelay: {
+      type: Number,
+      required: true,
+      default: timersIntervalDelay,
+    },
+    activeUserTimeDelay: {
+      type: Number,
+      required: true,
+      default: activeUserTimeDelay,
+    },
+    chatGamesIntervalDelay: {
+      type: Number,
+      required: true,
+      default: chatGamesIntervalDelay,
+    },
+    minActiveUsersThreshold: {
+      type: Number,
+      required: true,
+      default: minActiveUsersThreshold,
+    },
+    intervalCheckChatters: {
+      type: Number,
+      required: true,
+      default: intervalCheckChatters,
+    },
     pointsIncrement: {
-      message: { type: Number, default: 1 },
-      watch: { type: Number, default: 10 },
-      watchMultipler: { type: Number, default: 2.0 },
+      message: { type: Number, default: pointsIncrement.message },
+      watch: { type: Number, default: pointsIncrement.watch },
+      watchMultipler: { type: Number, default: pointsIncrement.watchMultipler },
+    },
+    intervalCheckViewersPeek: {
+      type: Number,
+      required: true,
+      default: intervalCheckViewersPeek,
     },
-    intervalCheckViewersPeek: { type: Number, required: true, default: 600 },
     permissionLevels: {
-      broadcaster: { type: Number, default: 10 },
-      mod: { type: Number, default: 8 },
-      vip: { type: Number, default: 4 },
-      all: { type: Number, default: 0 },
+      broadcaster: { type: Number, default: permissionLevels.broadcaster },
+      mod: { type: Number, default: permissionLevels.mod },
+      vip: { type: Number, default: permissionLevels.vip },
+      all: { type: Number, default: permissionLevels.all },
     },
   },
   {

server/src/models/streamSessionModel.ts

@@ -2,27 +2,32 @@ import { Model, model, Schema } from "mongoose";
 import { IStreamSessionDocument } from "./types";
 
 const StreamSessionSchema: Schema<IStreamSessionDocument> = new Schema({
-  sessionStart: { type: Date, required: true, default: new Date() },
+  sessionStart: { type: Date, required: true, default: Date.now },
   sessionEnd: { type: Date },
   sessionTitles: {
     type: Map,
     of: String,
+    default: new Map(),
   },
   categories: {
     type: Map,
     of: String,
+    default: new Map(),
   },
   tags: {
     type: Map,
     of: String,
+    default: new Map(),
   },
   viewers: {
     type: Map,
     of: Number,
+    default: new Map(),
   },
   watchers: {
     type: Map,
     of: Number,
+    default: new Map(),
   },
 });
 

server/src/models/triggerModel.ts

@@ -1,16 +1,16 @@
 import { Model, model, Schema } from "mongoose";
 import { ITriggerDocument } from "./types";
-
 const TriggerSchema: Schema<ITriggerDocument> = new Schema(
   {
     name: { type: String, required: true },
     enabled: { type: Boolean, default: true },
     chance: { type: Number, default: 50 },
     delay: { type: Number, default: 360 },
     onDelay: { type: Boolean, default: false },
-    // createdAt: { type: Date, required: true, default: Date.now },
+    uses: { type: Number, default: 0 },
     words: [String],
     messages: [String],
+    mode: { type: String, default: "WHOLE-WORD" },
   },
   { timestamps: true }
 );

server/src/models/types/index.d.ts

@@ -57,17 +57,21 @@ export interface IStreamSession {
 
 export type IStreamSessionDocument = IStreamSession & Document;
 
+export type TTriggerMode = "WHOLE-WORD" | "STARTS-WITH" | "ALL";
+
 export interface ITrigger {
   _id: string;
   name: string;
   enabled: boolean;
   chance: number;
   delay: number;
   onDelay: boolean;
+  uses: number;
   words: string[];
   messages: string[];
   createdAt: Date;
   updatedAt: Date;
+  mode: TTriggerMode;
 }
 
 export type ITriggerDocument = ITrigger & Document;
@@ -108,7 +112,7 @@ export interface IChatCommand {
   aliases: string[];
   messages: string[];
   privilege: number;
-  useCount: number;
+  uses: number;
 }
 
 export type IChatCommandDocument = IChatCommand & Document;

server/src/services/chatCommands/chatCommandsService.ts

@@ -174,3 +174,65 @@ export const deleteChatCommandById = async (id: string) => {
     handleAppError(err);
   }
 };
+
+export const getChatCommandsAliases = async (): Promise<
+  string[] | undefined
+> => {
+  try {
+    const commandsAliases = await ChatCommand.aggregate([
+      {
+        $group: {
+          _id: null,
+          aliases: { $push: "$aliases" },
+        },
+      },
+      {
+        $project: {
+          aliases: {
+            $reduce: {
+              input: "$aliases",
+              initialValue: [],
+              in: { $concatArrays: ["$$value", "$$this"] },
+            },
+          },
+          _id: 0,
+        },
+      },
+      {
+        $unwind: "$aliases",
+      },
+      {
+        $addFields: {
+          aliasesLower: { $toLower: "$aliases" },
+        },
+      },
+      {
+        $sort: {
+          aliasesLower: 1,
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          aliases: { $push: "$aliasesLower" },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          aliases: 1,
+        },
+      },
+    ]);
+
+    if (commandsAliases.length > 0) {
+      return commandsAliases[0].aliases;
+    }
+    return [];
+  } catch (err) {
+    logger.error(
+      `Error occured while aggregating chat commands for all aliases words: ${err}`
+    );
+    handleAppError(err);
+  }
+};