feat: Include new queue service class.

This class will handle all queueing and checking if users are in queues via redis.

Author: PhlexPlexico

config/development.json.template

@@ -11,7 +11,8 @@
     "uploadDemos": false,
     "localLoginEnabled": true,
     "redisUrl": "redis://:super_secure@localhost:6379",
-    "redisTTL": 86400
+    "redisTTL": 86400,
+    "queueTTL": 3600
   },
   "development": {
     "driver": "mysql",

config/production.json.template

@@ -11,7 +11,8 @@
     "uploadDemos": $UPLOADDEMOS,
     "localLoginEnabled": $LOCALLOGINS,
     "redisUrl": "$REDISURL",
-    "redisTTL": $REDISTTL
+    "redisTTL": $REDISTTL,
+    "queueTTL": $QUEUETTL
   },
   "production": {
     "driver": "mysql",

config/test.json.template

@@ -11,7 +11,8 @@
     "uploadDemos": false,
     "localLoginEnabled": true,
     "redisUrl": "redis://:super_secure@localhost:6379",
-    "redisTTL": 86400
+    "redisTTL": 86400,
+    "queueTTL": 3600
   },
   "test": {
     "driver": "mysql",

src/services/queue.ts

@@ -0,0 +1,189 @@
+import config from "config";
+import Utils from "../utility/utils.js";
+import { QueueDescriptor } from "../types/queues/QueueDescriptor.js"
+import { QueueItem } from "../types/queues/QueueItem.js";
+import { createClient } from "redis";
+
+const redis = createClient({ url: config.get("server.redisUrl"), });
+const DEFAULT_TTL_SECONDS: number = config.get("server.queueTTL") == 0 ? 3600 : config.get("server.queueTTL");
+
+export class QueueService {
+  async createQueue(ttlSeconds = DEFAULT_TTL_SECONDS, ownerId?: string, maxPlayers: number = 10): Promise<QueueDescriptor> {
+    let slug: string;
+    let key: string;
+    let attempts: number = 0;
+
+    do {
+      slug = Utils.generateSlug();
+      key = `queue:${slug}`;
+      const exists = await redis.exists(key);
+      if (!exists) break;
+      attempts++;
+    } while (attempts < 5);
+
+    if (attempts === 5) {
+      throw new Error('Failed to generate a unique queue slug after 5 attempts.');
+    }
+
+    const createdAt = Date.now();
+    const expiresAt = createdAt + ttlSeconds * 1000;
+
+    const descriptor: QueueDescriptor = {
+      name: slug,
+      slug,
+      createdAt,
+      expiresAt,
+      ownerId,
+      maxSize: maxPlayers,
+      isPrivate: false
+    };
+
+    await redis.sAdd('queues', slug);
+    await redis.expire(key, ttlSeconds);
+    await redis.set(`queue-meta:${slug}`, JSON.stringify(descriptor), { EX: ttlSeconds });
+
+    return descriptor;
+  }
+
+  async deleteQueue(
+    slug: string,
+    requesterSteamId: string,
+    role: 'user' | 'admin' | 'super_admin'
+  ): Promise<void> {
+    const key = `queue:${slug}`;
+    const metaKey = `queue-meta:${slug}`;
+    const meta = await getQueueMetaOrThrow(slug);
+
+    // Permission check
+    const isOwner = meta.ownerId === requesterSteamId;
+    const isAdmin = role === 'admin' || role === 'super_admin';
+
+    if (!isOwner && !isAdmin) {
+      throw new Error('You do not have permission to delete this queue.');
+    }
+
+    // Delete queue data
+    await redis.del(key);        // Remove queue list
+    await redis.del(metaKey);    // Remove metadata
+    await redis.sRem('queues', slug); // Remove from global queue list
+  }
+
+  async addUserToQueue(
+    slug: string,
+    steamId: string,
+    requesterSteamId: string,
+    role: 'user' | 'admin' | 'super_admin'
+  ): Promise<void> {
+    const key = `queue:${slug}`;
+    const meta = await getQueueMetaOrThrow(slug);
+
+    // Permission check
+    if (
+      role === 'user' &&
+      steamId !== requesterSteamId &&
+      meta.ownerId !== requesterSteamId
+    ) {
+      throw new Error('You do not have permission to add other users to this queue.');
+    }
+
+    const currentUsers = await redis.lRange(key, 0, -1);
+    const alreadyInQueue = currentUsers.some((item: string) => {
+      const parsed = JSON.parse(item);
+      return parsed.steamId === steamId;
+    });
+    if (alreadyInQueue) {
+      throw new Error(`Steam ID ${steamId} is already in the queue.`);
+    }
+
+    if (meta.maxSize && currentUsers.length >= meta.maxSize) {
+      throw new Error(`Queue ${slug} is full.`);
+    }
+
+    const hltvRating = await Utils.getRatingFromSteamId(steamId);
+
+    const item: QueueItem = {
+      steamId,
+      timestamp: Date.now(),
+      hltvRating: hltvRating ?? undefined
+    };
+
+    await redis.rPush(key, JSON.stringify(item));
+  }
+
+  async removeUserFromQueue(
+    slug: string,
+    steamId: string,
+    requesterSteamId: string,
+    role: 'user' | 'admin' | 'super_admin'
+  ): Promise<boolean> {
+    const key = `queue:${slug}`;
+    const meta = await getQueueMetaOrThrow(slug);
+
+    // Permission check
+    if (
+      role === 'user' &&
+      steamId !== requesterSteamId &&
+      meta.ownerId !== requesterSteamId
+    ) {
+      throw new Error('You do not have permission to remove other users from this queue.');
+    }
+
+    const currentUsers = await redis.lRange(key, 0, -1);
+    for (const item of currentUsers) {
+      const parsed = JSON.parse(item);
+      if (parsed.steamId === steamId) {
+        await redis.lRem(key, 1, item);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async listUsersInQueue(slug: string): Promise<QueueItem[]> {
+    const key = `queue:${slug}`;
+    const exists = await redis.exists(key);
+    if (!exists) throw new Error(`Queue ${slug} does not exist or has expired.`);
+
+    const rawItems = await redis.lRange(key, 0, -1);
+    return rawItems.map((item: string) => JSON.parse(item));
+  }
+
+  async listQueues(requesterSteamId: string, role: 'user' | 'admin' | 'super_admin'): Promise<QueueDescriptor[]> {
+    const slugs = await redis.sMembers('queues');
+    const descriptors: QueueDescriptor[] = [];
+
+    for (const slug of slugs) {
+      const metaRaw = await redis.get(`queue-meta:${slug}`);
+      if (!metaRaw) continue;
+
+      const meta: QueueDescriptor = JSON.parse(metaRaw);
+
+      if (role === 'admin' || role === 'super_admin' || meta.ownerId === requesterSteamId) {
+        descriptors.push(meta);
+      }
+    }
+
+    return descriptors;
+  }
+
+}
+
+async function getQueueMetaOrThrow(slug: string): Promise<QueueDescriptor> {
+  const key = `queue:${slug}`;
+  const metaKey = `queue-meta:${slug}`;
+
+  const exists = await redis.exists(key);
+  if (!exists) {
+    throw new Error(`Queue ${slug} does not exist or has expired.`);
+  }
+
+  const metaRaw = await redis.get(metaKey);
+  if (!metaRaw) {
+    throw new Error(`Queue metadata missing for ${slug}.`);
+  }
+
+  return JSON.parse(metaRaw);
+}
+
+export default QueueService;

src/types/queues/QueueDescriptor.ts

@@ -0,0 +1,9 @@
+export interface QueueDescriptor {
+  name: string;           // Human-readable name
+  slug: string;           // Unique identifier
+  createdAt: number;      // Timestamp (ms) when queue was created
+  expiresAt: number;      // Timestamp (ms) when queue will expire
+  ownerId?: string;       // Optional user ID of the queue creator
+  maxSize?: number;       // Optional max number of users allowed
+  isPrivate?: boolean;    // Optional flag for visibility
+}

src/types/queues/QueueItem.ts

@@ -0,0 +1,5 @@
+export interface QueueItem {
+  steamId: string;
+  timestamp: number;
+  hltvRating?: number;
+}

src/utility/utils.ts

@@ -81,6 +81,43 @@ class Utils {
     }
   }
 
+/**
+ * Fetches HLTV rating for a user by Steam ID.
+ * @param steamId - The user's Steam ID
+ * @returns HLTV rating or null if not found
+ */
+static async getRatingFromSteamId(steamId: string): Promise<number | null> {
+  let playerStatSql =
+    `SELECT  steam_id, name, sum(kills) as kills,
+    sum(deaths) as deaths, sum(assists) as assists, sum(k1) as k1,
+    sum(k2) as k2, sum(k3) as k3,
+    sum(k4) as k4, sum(k5) as k5, sum(v1) as v1,
+    sum(v2) as v2, sum(v3) as v3, sum(v4) as v4,
+    sum(v5) as v5, sum(roundsplayed) as trp, sum(flashbang_assists) as fba,
+    sum(damage) as dmg, sum(headshot_kills) as hsk, count(id) as totalMaps,
+    sum(knife_kills) as knifekills, sum(friendlies_flashed) as fflash,
+    sum(enemies_flashed) as eflash, sum(util_damage) as utildmg
+    FROM    player_stats
+    WHERE steam_id = ? 
+      AND match_id IN (
+        SELECT  id
+        FROM    \`match\`
+        WHERE   cancelled = 0)`;
+  const user: RowDataPacket[] = await db.query(playerStatSql, [steamId]);;
+
+  if (!user.length) return null;
+
+  return this.getRating(parseFloat(user[0].kills),
+    parseFloat(user[0].trp),
+    parseFloat(user[0].deaths),
+    parseFloat(user[0].k1),
+    parseFloat(user[0].k2),
+    parseFloat(user[0].k3),
+    parseFloat(user[0].k4),
+    parseFloat(user[0].k5));
+}
+
+
   /** Inner function - Supports encryption and decryption for the database keys to get server RCON passwords.
    * @name decrypt
    * @function
@@ -591,6 +628,40 @@ class Utils {
     }
   }
 
+  /**
+   * Generates a Counter-Strike-style slug using themed adjectives and nouns,
+   * including weapon skins and knife types.
+   * Example: "clutch-karambit" or "dusty-dragonlore"
+   */
+  public static generateSlug(): string {
+    const adjectives = [
+      'dusty', 'silent', 'brutal', 'clutch', 'smoky', 'tactical', 'deadly', 'stealthy',
+      'eco', 'forceful', 'aggressive', 'defensive', 'sneaky', 'explosive', 'fraggy', 'nasty',
+      'quick', 'slow', 'noisy', 'clean', 'dirty', 'sharp', 'blind', 'lucky',
+      'fiery', 'cold', 'ghostly', 'venomous', 'royal'
+    ];
+
+    const nouns = [
+      // Weapons & gameplay
+      'ak47', 'deagle', 'bombsite', 'flashbang', 'knife', 'smoke', 'molotov', 'awp',
+      'nade', 'scout', 'pistol', 'rifle', 'mid', 'long', 'short', 'connector',
+      'ramp', 'hegrenade', 'tunnel', 'palace', 'apps', 'boost', 'peek', 'spray',
+
+      // Skins
+      'dragonlore', 'fireserpent', 'hyperbeast', 'fade', 'casehardened', 'redline',
+      'vulcan', 'asiimov', 'howl', 'bloodsport', 'phantomdisruptor', 'neonrider',
+
+      // Knives
+      'karambit', 'bayonet', 'butterfly', 'gutknife', 'falchion', 'shadowdaggers',
+      'huntsman', 'talon', 'ursus', 'paracord', 'nomad'
+    ];
+
+    const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+    const noun = nouns[Math.floor(Math.random() * nouns.length)];
+
+    return `${adj}-${noun}`;
+  }
+
   public static addChallongeTeamAuthsToArray: (teamId: number, custom_field_response: { key: string; value: string; }) => Promise<void> = async (teamId: number, custom_field_response: { key: string, value: string }) => {
     let teamAuthArray: Array<Array<any>> = [];
     let key: keyof typeof custom_field_response;
@@ -608,6 +679,7 @@ class Utils {
       await db.query(sqlString, [teamAuthArray]);
     }
   }
+
 }
 
 

yarn.lock

@@ -4945,9 +4945,9 @@ v8-to-istanbul@^9.0.1:
     convert-source-map "^2.0.0"
 
 validator@^13.7.0:
-  version "13.15.15"
-  resolved "https://registry.yarnpkg.com/validator/-/validator-13.15.15.tgz#246594be5671dc09daa35caec5689fcd18c6e7e4"
-  integrity sha512-BgWVbCI72aIQy937xbawcs+hrVaN/CZ2UwutgaJ36hGqRrLNM+f5LUT/YPRbo8IV/ASeFzXszezV+y2+rq3l8A==
+  version "13.15.20"
+  resolved "https://registry.yarnpkg.com/validator/-/validator-13.15.20.tgz#054e9238109538a1bf46ae3e1290845a64fa2186"
+  integrity sha512-KxPOq3V2LmfQPP4eqf3Mq/zrT0Dqp2Vmx2Bn285LwVahLc+CsxOM0crBHczm8ijlcjZ0Q5Xd6LW3z3odTPnlrw==
 
 vary@^1, vary@~1.1.2:
   version "1.1.2"