feat(leaderboards): add a guild option to /leaderboard

apps/api/src/dtos/guild-search.dto.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Statsify
+ *
+ * This source code is licensed under the GNU GPL v3 license found in the
+ * LICENSE file in the root directory of this source tree.
+ * https://github.com/Statsify/statsify/blob/main/LICENSE
+ */
+
+import { ApiProperty } from "@nestjs/swagger";
+import { IsOptional, IsString, MaxLength } from "class-validator";
+
+export class GuildSearchDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(32)
+  @ApiProperty({ required: false })
+  public query?: string;
+}

apps/api/src/dtos/index.ts

@@ -10,6 +10,7 @@ export * from "./cache.dto.js";
 export * from "./cached-player.dto.js";
 export * from "./guild-leaderboard.dto.js";
 export * from "./guild-rankings.dto.js";
+export * from "./guild-search.dto.js";
 export * from "./guild.dto.js";
 export * from "./head.dto.js";
 export * from "./user.dto.js";

apps/api/src/dtos/player-leaderboard.dto.ts

@@ -7,7 +7,7 @@
  */
 
 import { ApiProperty, PartialType } from "@nestjs/swagger";
-import { IsEnum, IsInt, IsOptional, Min } from "class-validator";
+import { IsEnum, IsInt, IsOptional, IsString, MaxLength, Min, MinLength } from "class-validator";
 import { Player, getLeaderboardFields } from "@statsify/schemas";
 import { PlayerDto } from "./player.dto.js";
 import { Transform } from "class-transformer";
@@ -19,6 +19,13 @@ export class PlayerLeaderboardDto extends PartialType(PlayerDto) {
   @ApiProperty({ enum: fields })
   public field: string;
 
+  @IsOptional()
+  @IsString()
+  @MinLength(3)
+  @MaxLength(32)
+  @ApiProperty({ required: false })
+  public guild?: string;
+
   @Transform((params) => +params.value)
   @IsInt()
   @Min(0)

apps/api/src/guild/guild.module.ts

@@ -10,6 +10,8 @@ import { Guild, Player } from "@statsify/schemas";
 import { GuildController } from "./guild.controller.js";
 import { GuildLeaderboardController } from "./leaderboards/guild-leaderboard.controller.js";
 import { GuildLeaderboardService } from "./leaderboards/guild-leaderboard.service.js";
+import { GuildSearchController } from "./search/guild-search.controller.js";
+import { GuildSearchService } from "./search/guild-search.service.js";
 import { GuildService } from "./guild.service.js";
 import { HypixelModule } from "#hypixel";
 import { Module } from "@nestjs/common";
@@ -18,7 +20,7 @@ import { TypegooseModule } from "@m8a/nestjs-typegoose";
 
 @Module({
   imports: [HypixelModule, PlayerModule, TypegooseModule.forFeature([Guild, Player])],
-  controllers: [GuildController, GuildLeaderboardController],
-  providers: [GuildService, GuildLeaderboardService],
+  controllers: [GuildController, GuildLeaderboardController, GuildSearchController],
+  providers: [GuildService, GuildLeaderboardService, GuildSearchService],
 })
 export class GuildModule {}

apps/api/src/guild/guild.service.ts

@@ -14,6 +14,7 @@ import {
 } from "@statsify/api-client";
 import { Guild, GuildMember, Player, deserialize, serialize } from "@statsify/schemas";
 import { GuildLeaderboardService } from "./leaderboards/guild-leaderboard.service.js";
+import { GuildSearchService } from "./search/guild-search.service.js";
 import { HypixelService } from "#hypixel";
 import { InjectModel } from "@m8a/nestjs-typegoose";
 import { Injectable } from "@nestjs/common";
@@ -30,6 +31,7 @@ export class GuildService {
     private readonly hypixelService: HypixelService,
     private readonly playerService: PlayerService,
     private readonly guildLeaderboardService: GuildLeaderboardService,
+    private readonly guildSearchService: GuildSearchService,
     @InjectModel(Guild) private readonly guildModel: ReturnModelType<typeof Guild>,
     @InjectModel(Player) private readonly playerModel: ReturnModelType<typeof Player>
   ) {}
@@ -140,12 +142,14 @@ export class GuildService {
     const flatGuild = flatten(guild);
     const serializedGuild = serialize(Guild, flatGuild);
 
-    await this.guildModel
-      .replaceOne({ id: guild.id }, serializedGuild, { upsert: true })
-      .lean()
-      .exec();
-
-    await this.guildLeaderboardService.addLeaderboards(Guild, serializedGuild, "id");
+    await Promise.all([
+      this.guildModel
+        .replaceOne({ id: guild.id }, serializedGuild, { upsert: true })
+        .lean()
+        .exec(),
+      this.guildLeaderboardService.addLeaderboards(Guild, serializedGuild, "id"),
+      this.guildSearchService.add(guild.name),
+    ]);
 
     return deserialize(Guild, flatGuild);
   }

apps/api/src/guild/search/guild-search.controller.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Statsify
+ *
+ * This source code is licensed under the GNU GPL v3 license found in the
+ * LICENSE file in the root directory of this source tree.
+ * https://github.com/Statsify/statsify/blob/main/LICENSE
+ */
+
+import { ApiOkResponse, ApiOperation, ApiTags } from "@nestjs/swagger";
+import { Auth } from "#auth";
+import { Controller, Get, Query } from "@nestjs/common";
+import { GetGuildSearchResponse } from "@statsify/api-client";
+import { GuildSearchDto } from "#dtos";
+import { GuildSearchService } from "./guild-search.service.js";
+
+@Controller("/guild/search")
+@ApiTags("Guild")
+export class GuildSearchController {
+  public constructor(private readonly guildSearchService: GuildSearchService) {}
+
+  @ApiOperation({ summary: "Get a Fuzzy Searched List of Guilds" })
+  @ApiOkResponse({ type: GetGuildSearchResponse })
+  @Auth({ weight: 0 })
+  @Get()
+  public async getGuilds(@Query() { query = "" }: GuildSearchDto) {
+    const guilds = await this.guildSearchService.get(query);
+
+    return {
+      success: true,
+      guilds,
+    };
+  }
+}

apps/api/src/guild/search/guild-search.service.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) Statsify
+ *
+ * This source code is licensed under the GNU GPL v3 license found in the
+ * LICENSE file in the root directory of this source tree.
+ * https://github.com/Statsify/statsify/blob/main/LICENSE
+ */
+
+import { Guild } from "@statsify/schemas";
+import { InjectModel } from "@m8a/nestjs-typegoose";
+import { InjectRedis } from "#redis";
+import { Injectable } from "@nestjs/common";
+import { Logger } from "@statsify/logger";
+import { Redis } from "ioredis";
+import type { ReturnModelType } from "@typegoose/typegoose";
+
+const REDI_SEARCH_NOT_INSTALLED =
+  "This error was most likely caused because RediSearch is not installed.";
+const GUILD_AUTOCOMPLETE_KEY = "guild:autocomplete";
+
+@Injectable()
+export class GuildSearchService {
+  private logger = new Logger("GuildSearchService");
+
+  public constructor(
+    @InjectRedis() private readonly redis: Redis,
+    @InjectModel(Guild) private readonly guildModel: ReturnModelType<typeof Guild>
+  ) {}
+
+  public async get(query: string): Promise<string[]> {
+    query = query.trim().toLowerCase();
+
+    if (!query) return [];
+
+    const searchOptions = query.length >= 3 ? ["FUZZY", "MAX", "25"] : ["MAX", "25"];
+
+    const redisResults = await (
+      this.redis.call(
+        "FT.SUGGET",
+        GUILD_AUTOCOMPLETE_KEY,
+        query,
+        ...searchOptions
+      ) as Promise<string[]>
+    ).catch((e) => {
+      this.handleRedisError(e);
+
+      return [];
+    });
+
+    if (redisResults.length > 0) return redisResults;
+
+    return this.getCachedGuilds(query);
+  }
+
+  public async add(name: string) {
+    if (name.length < 3 || name.length > 32) return;
+
+    await this.redis
+      .call("FT.SUGADD", GUILD_AUTOCOMPLETE_KEY, name, "1", "INCR")
+      .catch((e) => this.handleRedisError(e));
+  }
+
+  private async getCachedGuilds(query: string) {
+    const guilds = await this.guildModel
+      .find({ nameToLower: { $regex: `^${this.escapeRegex(query)}` } })
+      .select({ name: true, _id: false })
+      .sort({ exp: -1 })
+      .limit(25)
+      .lean()
+      .exec();
+
+    return guilds.map(({ name }) => name);
+  }
+
+  private escapeRegex(input: string) {
+    return input.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  }
+
+  private handleRedisError(error: unknown) {
+    this.logger.error(error);
+    this.logger.error(REDI_SEARCH_NOT_INSTALLED);
+  }
+}

apps/api/src/leaderboards/leaderboard.service.ts

@@ -80,18 +80,7 @@ export abstract class LeaderboardService {
   ) {
     const PAGE_SIZE = 10;
 
-    const {
-      fieldName,
-      additionalFields = [],
-      extraDisplay,
-      formatter,
-      sort,
-      name,
-      hidden,
-    } = getLeaderboardField(
-      constructor,
-      field
-    ) as LeaderboardEnabledMetadata;
+    const { sort } = getLeaderboardField(constructor, field);
 
     let top: number;
     let bottom: number;
@@ -127,6 +116,31 @@ export abstract class LeaderboardService {
       sort
     );
 
+    return this.formatLeaderboard(
+      constructor,
+      field,
+      leaderboard,
+      top / PAGE_SIZE,
+      highlight
+    );
+  }
+
+  protected async formatLeaderboard<T>(
+    constructor: Constructor<T>,
+    field: string,
+    leaderboard: { id: string; score: number; index: number }[],
+    page: number,
+    highlight?: number
+  ) {
+    const {
+      fieldName,
+      additionalFields = [],
+      extraDisplay,
+      formatter,
+      name,
+      hidden,
+    } = getLeaderboardField(constructor, field);
+
     const additionalFieldMetadata = additionalFields.map((k) =>
       getLeaderboardField(constructor, k, false)
     );
@@ -185,7 +199,7 @@ export abstract class LeaderboardService {
       name,
       fields,
       data,
-      page: top / PAGE_SIZE,
+      page,
     };
   }
 

apps/api/src/player/leaderboards/player-leaderboard.controller.ts

@@ -37,7 +37,7 @@ export class PlayerLeaderboardsController {
   @ApiBadRequestResponse({ type: ErrorResponse })
   @Auth({ weight: 3 })
   public getPlayerLeaderboard(
-    @Body() { field, page, player, position }: PlayerLeaderboardDto
+    @Body() { field, guild, page, player, position }: PlayerLeaderboardDto
   ) {
     let input: number | string;
     let type: LeaderboardQuery;
@@ -53,6 +53,14 @@ export class PlayerLeaderboardsController {
       type = LeaderboardQuery.PAGE;
     }
 
+    if (guild)
+      return this.playerLeaderboardService.getGuildScopedLeaderboard(
+        guild,
+        field,
+        input,
+        type
+      );
+
     return this.playerLeaderboardService.getLeaderboard(Player, field, input, type);
   }