fix broken filters

Author: Alfagun74

src/modules/games/games.controller.spec.ts

@@ -1,3 +1,5 @@
+import * as nestjsPaginate from "nestjs-paginate";
+import * as nestjsPaginateFilter from "nestjs-paginate/lib/filter";
 import { Repository } from "typeorm";
 import { OtpService } from "../otp/otp.service";
 import { Progress } from "../progresses/progress.entity";
@@ -9,6 +11,22 @@ import { GamesController } from "./games.controller";
 import { GamesService } from "./games.service";
 import { GamevaultGame } from "./gamevault-game.entity";
 
+jest.mock("nestjs-paginate", () => {
+  const actual = jest.requireActual("nestjs-paginate");
+  return {
+    ...actual,
+    paginate: jest.fn(),
+  };
+});
+
+jest.mock("nestjs-paginate/lib/filter", () => {
+  const actual = jest.requireActual("nestjs-paginate/lib/filter");
+  return {
+    ...actual,
+    addFilter: jest.fn(),
+  };
+});
+
 describe("GamesController", () => {
   let controller: GamesController;
   let gamesService: jest.Mocked<GamesService>;
@@ -57,6 +75,9 @@ describe("GamesController", () => {
     gamesRepository = {
       find: jest.fn(),
       createQueryBuilder: jest.fn(),
+      manager: {
+        getRepository: jest.fn(),
+      },
     } as any;
 
     progressRepository = {
@@ -79,6 +100,67 @@ describe("GamesController", () => {
       usersService,
       otpService,
     );
+
+    jest.clearAllMocks();
+  });
+
+  describe("findGames", () => {
+    it("should resolve metadata tag filters to game ids before paginate", async () => {
+      const metadataQueryBuilder = {
+        select: jest.fn().mockReturnThis(),
+        distinct: jest.fn().mockReturnThis(),
+        innerJoin: jest.fn().mockReturnThis(),
+        getRawMany: jest.fn().mockResolvedValue([{ id: 7 }, { id: "9" }]),
+      };
+
+      const metadataRepository = {
+        createQueryBuilder: jest.fn().mockReturnValue(metadataQueryBuilder),
+      };
+
+      (gamesRepository.manager.getRepository as jest.Mock).mockReturnValue(
+        metadataRepository,
+      );
+
+      (nestjsPaginateFilter.addFilter as jest.Mock).mockImplementation(() => {
+        return {};
+      });
+
+      (nestjsPaginate.paginate as jest.Mock).mockResolvedValue({
+        data: [],
+        meta: {} as any,
+        links: {} as any,
+      });
+
+      await controller.findGames({ user: createMockUser() }, {
+        filter: {
+          "metadata.tags.name": "$in:Action",
+        },
+        sortBy: [],
+        path: "api/games",
+      } as any);
+
+      expect(gamesRepository.manager.getRepository).toHaveBeenCalled();
+      expect(nestjsPaginateFilter.addFilter).toHaveBeenCalledWith(
+        metadataQueryBuilder,
+        {
+          filter: {
+            "tags.name": "$in:Action",
+          },
+        },
+        {
+          "tags.name": true,
+        },
+      );
+      expect(nestjsPaginate.paginate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filter: {
+            id: "$in:7,9",
+          },
+        }),
+        gamesRepository,
+        expect.any(Object),
+      );
+    });
   });
 
   describe("putFilesReindex", () => {

src/modules/games/games.controller.ts

@@ -41,12 +41,13 @@ import { In, Not, Repository } from "typeorm";
 import { FileInterceptor } from "@nestjs/platform-express";
 import bytes from "bytes";
 import { isArray } from "lodash";
-import { FilterSuffix } from "nestjs-paginate/lib/filter";
+import { FilterSuffix, addFilter } from "nestjs-paginate/lib/filter";
 import configuration from "../../configuration";
 import { DisableApiIf } from "../../decorators/disable-api-if.decorator";
 import { MinimumRole } from "../../decorators/minimum-role.decorator";
 import { PaginateQueryOptions } from "../../decorators/pagination.decorator";
 import { ApiOkResponsePaginated, toFindOptionsRelations } from "../../globals";
+import { GameMetadata } from "../metadata/games/game.metadata.entity";
 import { OtpService } from "../otp/otp.service";
 import { State } from "../progresses/models/state.enum";
 import { Progress } from "../progresses/progress.entity";
@@ -59,6 +60,15 @@ import { GamevaultGame } from "./gamevault-game.entity";
 import { GameIdDto } from "./models/game-id.dto";
 import { UpdateGameDto } from "./models/update-game.dto";
 
+const metadataRelationNameFilters = {
+  "metadata.genres.name": "genres.name",
+  "metadata.tags.name": "tags.name",
+  "metadata.developers.name": "developers.name",
+  "metadata.publishers.name": "publishers.name",
+} as const;
+
+type MetadataRelationNameFilterKey = keyof typeof metadataRelationNameFilters;
+
 @ApiBearerAuth()
 @ApiTags("game")
 @Controller("games")
@@ -224,6 +234,14 @@ export class GamesController {
       }
     }
 
+    const relationFilteredGameIds =
+      await this.resolveMetadataRelationNameFilterGameIds(query);
+
+    if (relationFilteredGameIds) {
+      this.removeMetadataRelationNameFilters(query);
+      this.applyResolvedGameIdFilter(query, relationFilteredGameIds);
+    }
+
     if (
       configuration.PARENTAL.AGE_RESTRICTION_ENABLED &&
       request.user.role !== Role.ADMIN
@@ -483,4 +501,93 @@ export class GamesController {
 
     return query;
   }
+
+  private async resolveMetadataRelationNameFilterGameIds(
+    query: PaginateQuery,
+  ): Promise<number[] | undefined> {
+    const activeFilters = Object.entries(metadataRelationNameFilters).filter(
+      ([filterKey]) => query.filter?.[filterKey] != null,
+    ) as Array<
+      [
+        MetadataRelationNameFilterKey,
+        (typeof metadataRelationNameFilters)[MetadataRelationNameFilterKey],
+      ]
+    >;
+
+    if (activeFilters.length === 0) {
+      return undefined;
+    }
+
+    let matchingIds: number[] | undefined;
+
+    for (const [queryFilterKey, metadataFilterKey] of activeFilters) {
+      const filterValue = query.filter?.[queryFilterKey];
+
+      if (filterValue == null) {
+        continue;
+      }
+
+      const metadataQuery = {
+        filter: {
+          [metadataFilterKey]: filterValue,
+        },
+      } as PaginateQuery;
+
+      const queryBuilder = this.gamesRepository.manager
+        .getRepository(GameMetadata)
+        .createQueryBuilder("metadata")
+        .select("game.id", "id")
+        .distinct(true)
+        .innerJoin(GamevaultGame, "game", "game.metadata_id = metadata.id");
+
+      addFilter(queryBuilder, metadataQuery, {
+        [metadataFilterKey]: true,
+      });
+
+      const resolvedIds = (
+        await queryBuilder.getRawMany<{ id: number | string }>()
+      )
+        .map(({ id }) => Number(id))
+        .filter((id) => Number.isInteger(id));
+
+      if (matchingIds == null) {
+        matchingIds = resolvedIds;
+      } else {
+        const resolvedIdSet = new Set(resolvedIds);
+        matchingIds = matchingIds.filter((id) => resolvedIdSet.has(id));
+      }
+
+      if (matchingIds.length === 0) {
+        break;
+      }
+    }
+
+    return matchingIds;
+  }
+
+  private removeMetadataRelationNameFilters(query: PaginateQuery) {
+    for (const filterKey of Object.keys(metadataRelationNameFilters)) {
+      delete query.filter?.[filterKey];
+    }
+  }
+
+  private applyResolvedGameIdFilter(query: PaginateQuery, gameIds: number[]) {
+    query.filter ??= {};
+
+    const resolvedIdFilter =
+      gameIds.length > 0 ? `$in:${gameIds.join(",")}` : "$eq:-1";
+    const existingIdFilter = query.filter.id;
+
+    if (existingIdFilter == null) {
+      query.filter.id = resolvedIdFilter;
+      return;
+    }
+
+    if (isArray(existingIdFilter)) {
+      query.filter.id = [...existingIdFilter, resolvedIdFilter];
+      return;
+    }
+
+    query.filter.id = [existingIdFilter, resolvedIdFilter];
+  }
 }