Add get beatmap by filename

server/src/controllers/api/index.ts

@@ -52,6 +52,48 @@ export default (app: App) => {
         tags: ["v2"],
       },
     )
+    .get(
+      "v2/filename/:filename",
+      async ({
+        BeatmapsManagerInstance,
+        params: { filename },
+        query: { full },
+        set,
+      }) => {
+        const beatmap = await BeatmapsManagerInstance.getBeatmap({
+          beatmapFilename: filename,
+          allowMissingNonBeatmapValues: full,
+        });
+
+        if (beatmap.source) {
+          set.headers["X-Data-Source"] = beatmap.source;
+        }
+
+        const { source: _, ...responseBeatmap } = beatmap;
+        if (!full || !beatmap.data)
+          return responseBeatmap?.data ?? responseBeatmap;
+
+        const beatmapset = await BeatmapsManagerInstance.getBeatmapSet({
+          beatmapSetId: beatmap.data.beatmapset_id,
+        });
+
+        if (beatmapset.source) {
+          set.headers["X-Data-Source"] = beatmapset.source;
+        }
+
+        const { source: __, ...responseBeatmapset } = beatmapset;
+        return responseBeatmapset?.data ?? responseBeatmapset;
+      },
+      {
+        params: t.Object({
+          filename: t.String(),
+        }),
+        query: t.Object({
+          full: t.Optional(t.BooleanString()),
+        }),
+        tags: ["v2"],
+      },
+    )
     .get(
       "v2/md5/:hash",
       async ({

server/src/core/abstracts/client/base-client.types.ts

@@ -41,6 +41,7 @@ export type DownloadOsuBeatmap = {
 export type GetBeatmapOptions = {
   beatmapId?: number;
   beatmapHash?: string;
+  beatmapFilename?: string;
   allowMissingNonBeatmapValues?: boolean;
 };
 
@@ -61,6 +62,7 @@ export enum ClientAbilities {
   GetBeatmapsetsByBeatmapIds = 1 << 11, // 2048
   GetBeatmapByIdWithSomeNonBeatmapValues = 1 << 12, // 4096
   GetBeatmapByHashWithSomeNonBeatmapValues = 1 << 13, // 8192
+  GetBeatmapByFilename = 1 << 14, // 16384
 }
 
 export type MirrorClient<T extends BaseClient = BaseClient> = {

server/src/core/domains/osu.ppy.sh/bancho.client.ts

@@ -32,6 +32,7 @@ export class BanchoClient extends BaseClient {
         abilities: [
           ClientAbilities.GetBeatmapById,
           ClientAbilities.GetBeatmapByHash,
+          ClientAbilities.GetBeatmapByFilename,
           ClientAbilities.GetBeatmapSetById,
           ClientAbilities.GetBeatmaps,
           ClientAbilities.DownloadOsuBeatmap,
@@ -49,6 +50,7 @@ export class BanchoClient extends BaseClient {
             abilities: [
               ClientAbilities.GetBeatmapById,
               ClientAbilities.GetBeatmapByHash,
+              ClientAbilities.GetBeatmapByFilename,
               ClientAbilities.GetBeatmapSetById,
               ClientAbilities.GetBeatmaps,
               ClientAbilities.DownloadOsuBeatmap,
@@ -85,6 +87,9 @@ export class BanchoClient extends BaseClient {
     else if (ctx.beatmapHash) {
       return await this.getBeatmapByHash(ctx.beatmapHash);
     }
+    else if (ctx.beatmapFilename) {
+      return await this.getBeatmapByFilename(ctx.beatmapFilename);
+    }
 
     throw new Error("Invalid arguments");
   }
@@ -293,6 +298,30 @@ export class BanchoClient extends BaseClient {
     };
   }
 
+  private async getBeatmapByFilename(
+    beatmapHash: string,
+  ): Promise<ResultWithStatus<Beatmap>> {
+    const result = await this.api.get<BanchoBeatmap>(`api/v2/beatmaps/lookup`, {
+      config: {
+        headers: {
+          Authorization: `Bearer ${await this.osuApiKey}`,
+        },
+        params: {
+          filename: beatmapHash,
+        },
+      },
+    });
+
+    if (!result || result.status !== 200 || !result.data) {
+      return { result: null, status: result?.status ?? 500 };
+    }
+
+    return {
+      result: this.convertService.convertBeatmap(result.data),
+      status: result.status,
+    };
+  }
+
   private get osuApiKey() {
     return this.banchoService.getBanchoClientToken();
   }

server/src/core/managers/mirrors/mirrors.manager.ts

@@ -125,8 +125,8 @@ export class MirrorsManager {
   async getBeatmap(
     ctx: GetBeatmapOptions,
   ): Promise<ResultWithStatus<Beatmap>> {
-    if (!ctx.beatmapId && !ctx.beatmapHash) {
-      throw new Error("Either beatmapId or beatmapHash is required");
+    if (!ctx.beatmapId && !ctx.beatmapHash && !ctx.beatmapFilename) {
+      throw new Error("Either beatmapId, beatmapHash or beatmapFilename is required");
     }
 
     let criteria: ClientAbilities;
@@ -135,11 +135,14 @@ export class MirrorsManager {
         ? ClientAbilities.GetBeatmapByIdWithSomeNonBeatmapValues
         : ClientAbilities.GetBeatmapById;
     }
-    else {
+    else if (ctx.beatmapHash) {
       criteria = ctx.allowMissingNonBeatmapValues
         ? ClientAbilities.GetBeatmapByHashWithSomeNonBeatmapValues
         : ClientAbilities.GetBeatmapByHash;
     }
+    else {
+      criteria = ClientAbilities.GetBeatmapByFilename;
+    }
 
     return await this.useMirror<Beatmap>(ctx, criteria, "getBeatmap");
   }

server/src/core/managers/storage/storage-cache.service.ts

@@ -23,11 +23,28 @@ export class StorageCacheService {
   async getBeatmap(
     ctx: GetBeatmapOptions,
   ): Promise<Beatmap | null | undefined> {
+    if (!ctx.beatmapId && !ctx.beatmapHash && !ctx.beatmapFilename) {
+      throw new Error("Either beatmapId, beatmapHash or beatmapFilename is required");
+    }
+
     let { beatmapId } = ctx;
 
     if (ctx.beatmapHash) {
       const cachedId = await this.redis.get(
-                `${RedisKeys.BEATMAP_ID_BY_HASH}${ctx.beatmapHash}`,
+        `${RedisKeys.BEATMAP_ID_BY_HASH}${ctx.beatmapHash}`,
+      );
+
+      if (!cachedId)
+        return undefined;
+      if (cachedId === "null")
+        return null;
+
+      beatmapId = Number(cachedId);
+    }
+
+    if (ctx.beatmapFilename) {
+      const cachedId = await this.redis.get(
+        `${RedisKeys.BEATMAP_ID_BY_FILENAME}${ctx.beatmapFilename}`,
       );
 
       if (!cachedId)
@@ -46,9 +63,18 @@ export class StorageCacheService {
   }
 
   async insertEmptyBeatmap(ctx: GetBeatmapOptions) {
-    const key = ctx?.beatmapId
-      ? `${RedisKeys.BEATMAP_BY_ID}${ctx?.beatmapId}`
-      : `${RedisKeys.BEATMAP_ID_BY_HASH}${ctx?.beatmapHash}`;
+    let key = "";
+
+    if (ctx?.beatmapId) {
+      key = `${RedisKeys.BEATMAP_BY_ID}${ctx?.beatmapId}`;
+    }
+    else if (ctx?.beatmapHash) {
+      key = `${RedisKeys.BEATMAP_ID_BY_HASH}${ctx?.beatmapHash}`;
+    }
+    else if (ctx?.beatmapFilename) {
+      key = `${RedisKeys.BEATMAP_ID_BY_FILENAME}${ctx?.beatmapFilename}`;
+    }
+
     await this.redis.set(
       key,
       "null",
@@ -73,6 +99,15 @@ export class StorageCacheService {
     );
   }
 
+  async insertBeatmapByFilename(beatmap: Beatmap, filename: string) {
+    await this.redis.set(
+      `${RedisKeys.BEATMAP_ID_BY_FILENAME}${filename}`,
+      beatmap.id,
+      "PX",
+      this.getRedisTTLBasedOnStatus(beatmap.status),
+    );
+  }
+
   async insertEmptyBeatmapset(ctx: GetBeatmapSetOptions) {
     const key = `${RedisKeys.BEATMAPSET_BY_ID}${ctx?.beatmapSetId}`;
     await this.redis.set(

server/src/core/managers/storage/storage.manager.ts

@@ -49,6 +49,10 @@ export class StorageManager {
   async getBeatmap(
     ctx: GetBeatmapOptions,
   ): Promise<Beatmap | null | undefined> {
+    if (!ctx.beatmapId && !ctx.beatmapHash && !ctx.beatmapFilename) {
+      throw new Error("Either beatmapId, beatmapHash or beatmapFilename is required");
+    }
+
     let entity = await this.cacheService.getBeatmap(ctx);
 
     if (entity !== undefined) {
@@ -61,6 +65,9 @@ export class StorageManager {
     else if (ctx.beatmapHash) {
       entity = await getBeatmapByHash(ctx.beatmapHash);
     }
+    else if (ctx.beatmapFilename) {
+      // We don't store filenames in database, skip
+    }
 
     if (entity) {
       this.cacheService.insertBeatmap(entity);
@@ -145,6 +152,10 @@ export class StorageManager {
     if (beatmap) {
       await createBeatmap(beatmap);
       await this.cacheService.insertBeatmap(beatmap);
+
+      if (ctx.beatmapFilename) {
+        await this.cacheService.insertBeatmapByFilename(beatmap, ctx.beatmapFilename);
+      }
     }
     else {
       await this.cacheService.insertEmptyBeatmap(ctx);

server/src/types/redis.ts

@@ -1,6 +1,7 @@
 export enum RedisKeys {
   BEATMAP_BY_ID = "BEATMAP:ID:",
   BEATMAP_ID_BY_HASH = "BEATMAP_ID:HASH:",
+  BEATMAP_ID_BY_FILENAME = "BEATMAP_ID:FILENAME:",
   BEATMAPSET_BY_ID = "BEATMAPSET:ID:",
   BEATMAPSET_FILE_BY_ID = "BEATMAPSET_FILE:ID:",
   BEATMAP_OSU_FILE = "BEATMAP_OSU_FILE:ID:",