chore: remove mixup of filter and fields in v3 publish

Author: minottic

src/published-data/pipes/registered.pipe.ts

@@ -1,50 +1,53 @@
 import { Inject, Injectable, PipeTransform, Scope } from "@nestjs/common";
 import { REQUEST } from "@nestjs/core";
 import { Request } from "express";
-import { omit } from "lodash";
+import { IPublishedDataFilters } from "../interfaces/published-data.interface";
 
 function addRegisteredStatusToJson(
-  json: Record<string, string>,
+  filter: IPublishedDataFilters,
   isAuthenticated = false,
 ) {
-  if (isAuthenticated) return json;
-  return { ...json, status: "registered" };
+  if (isAuthenticated) return filter;
+  filter.where = {
+    ...filter.where,
+    status: "registered",
+  };
+  return filter;
 }
 
 @Injectable({ scope: Scope.REQUEST })
 export class RegisteredFilterPipe implements PipeTransform<
-  { filter?: string; fields?: string; limits?: string },
-  { filter?: string; fields?: string; limits?: string }
+  { filter?: IPublishedDataFilters },
+  { filter?: IPublishedDataFilters }
 > {
   constructor(@Inject(REQUEST) private readonly request: Request) {}
 
-  transform(value: { filter?: string; fields?: string; limits?: string }) {
-    const jsonFields = JSON.parse(value?.fields || "{}");
+  transform(value: { filter?: IPublishedDataFilters }) {
     const withRegistered = addRegisteredStatusToJson(
-      jsonFields,
+      value?.filter ?? {},
       this.request.isAuthenticated(),
     );
-    return { ...value, fields: JSON.stringify(withRegistered) };
+    return { filter: withRegistered };
   }
 }
 
 @Injectable({ scope: Scope.REQUEST })
 export class RegisteredPipe implements PipeTransform<
-  Record<string, string>,
-  Record<string, string>
+  IPublishedDataFilters,
+  IPublishedDataFilters
 > {
   constructor(@Inject(REQUEST) private readonly request: Request) {}
 
-  transform(value: Record<string, string>) {
+  transform(value: IPublishedDataFilters) {
     return addRegisteredStatusToJson(value, this.request.isAuthenticated());
   }
 }
 
 export class IdToDoiPipe implements PipeTransform<
   { id: string },
-  { doi: string }
+  { where: { doi: string } }
 > {
   transform(value: { id: string }) {
-    return { ...omit(value, "id"), doi: value.id };
+    return { where: { doi: value.id } };
   }
 }

src/published-data/pipes/v3-filter.pipe.ts

@@ -1,9 +1,7 @@
 import { FilterPipe } from "src/common/pipes/filter.pipe";
 import { PublishedData } from "../schemas/published-data.schema";
 import { publishedDataV3toV4FieldMap } from "../dto/published-data.obsolete.dto";
-import { JsonToStringPipe } from "src/common/pipes/json-to-string.pipe";
 
 export const V3_FILTER_TO_V4_PIPE = [
   new FilterPipe<PublishedData>({ apiToDBMap: publishedDataV3toV4FieldMap }),
-  new JsonToStringPipe("fields"),
 ];

src/published-data/published-data.controller.ts

@@ -29,7 +29,7 @@ import {
   ApiTags,
 } from "@nestjs/swagger";
 import { plainToInstance } from "class-transformer";
-import { FilterQuery, QueryOptions } from "mongoose";
+import { QueryOptions } from "mongoose";
 import { firstValueFrom } from "rxjs";
 import { AttachmentsService } from "src/attachments/attachments.service";
 import { AllowAny } from "src/auth/decorators/allow-any.decorator";
@@ -65,10 +65,7 @@ import {
   RegisteredPipe,
 } from "./pipes/registered.pipe";
 import { PublishedDataService } from "./published-data.service";
-import {
-  PublishedData,
-  PublishedDataDocument,
-} from "./schemas/published-data.schema";
+import { PublishedData } from "./schemas/published-data.schema";
 import { V3_FILTER_TO_V4_PIPE } from "./pipes/v3-filter.pipe";
 
 @ApiBearerAuth()
@@ -272,16 +269,6 @@ export class PublishedDataController {
     description: "Database filters to apply when retrieve all published data",
     required: false,
   })
-  @ApiQuery({
-    name: "limits",
-    description: "Database limits to apply when retrieve all published data",
-    required: false,
-  })
-  @ApiQuery({
-    name: "fields",
-    description: "Database fields to apply apply filters on",
-    required: false,
-  })
   @ApiResponse({
     status: HttpStatus.OK,
     type: PublishedDataObsoleteDto,
@@ -296,25 +283,9 @@ export class PublishedDataController {
     @Query(...V3_FILTER_TO_V4_PIPE, RegisteredFilterPipe)
     filter?: {
       filter: IPublishedDataFilters;
-      fields: string;
-      limits: string;
     },
   ): Promise<PublishedDataObsoleteDto[]> {
     const publishedDataFilters: IPublishedDataFilters = filter?.filter ?? {};
-    const publishedDataLimits: {
-      skip: number;
-      limit: number;
-      order: string;
-    } = JSON.parse(filter?.limits ?? "{}");
-    const publishedDataFields = JSON.parse(filter?.fields ?? "{}");
-
-    if (!publishedDataFilters.limits) {
-      publishedDataFilters.limits = publishedDataLimits;
-    }
-    if (!publishedDataFilters.fields) {
-      publishedDataFilters.fields = publishedDataFields;
-    }
-
     const fetchedData =
       await this.publishedDataService.findAll(publishedDataFilters);
 
@@ -344,23 +315,12 @@ export class PublishedDataController {
     @Query(...V3_FILTER_TO_V4_PIPE, RegisteredFilterPipe)
     filter?: {
       filter: IPublishedDataFilters;
-      fields: string;
-      limits: string;
     },
   ) {
-    const jsonFilters: IPublishedDataFilters = filter?.filter ?? {};
-    const jsonFields: FilterQuery<PublishedDataDocument> = filter?.fields
-      ? JSON.parse(filter.fields)
-      : {};
-
-    const filters: FilterQuery<PublishedDataDocument> = {
-      where: jsonFilters,
-      fields: jsonFields,
-    };
-
+    const filters: IPublishedDataFilters = filter?.filter ?? {};
     const options: QueryOptions = {
-      limit: jsonFilters?.limits?.limit,
-      skip: jsonFilters?.limits?.skip,
+      limit: filters?.limits?.limit,
+      skip: filters?.limits?.skip,
     };
 
     return this.publishedDataService.countDocuments(filters, options);
@@ -454,11 +414,14 @@ export class PublishedDataController {
   })
   async findOne(
     @Param(new IdToDoiPipe(), RegisteredPipe)
-    idFilter: {
-      doi: string;
-      registered?: string;
+    filter: {
+      where: {
+        doi: string;
+        registered?: string;
+      };
     },
   ): Promise<PublishedDataObsoleteDto> {
+    const idFilter = filter.where;
     const publishedData = await this.publishedDataService.findOne(idFilter);
     if (!publishedData) {
       throw new NotFoundException(

src/published-data/published-data.service.ts

@@ -17,7 +17,6 @@ import { firstValueFrom } from "rxjs";
 import { JWTUser } from "src/auth/interfaces/jwt-user.interface";
 import {
   addCreatedByFields,
-  createFullqueryFilter,
   handleAxiosRequestError,
   parseLimitFilters,
 } from "src/common/utils";
@@ -79,47 +78,22 @@ export class PublishedDataService {
   }
 
   async findAll(filter: IPublishedDataFilters): Promise<PublishedData[]> {
-    const whereFilter: FilterQuery<PublishedDataDocument> = filter.where ?? {};
-    const fields = filter.fields ?? {};
-    const filterQuery: FilterQuery<PublishedDataDocument> =
-      createFullqueryFilter<PublishedDataDocument>(
-        this.publishedDataModel,
-        "doi",
-        fields,
-      );
-    const whereClause: FilterQuery<PublishedDataDocument> = {
-      ...filterQuery,
-      ...whereFilter,
-    };
     const { limit, skip, sort } = parseLimitFilters(filter.limits);
-
     return this.publishedDataModel
-      .find(whereClause)
+      .find(filter.where ?? {})
       .limit(limit)
       .skip(skip)
       .sort(sort)
+      .select(filter.fields ?? {})
       .exec();
   }
 
   async countDocuments(
     filter: FilterQuery<PublishedDataDocument>,
     options?: object,
   ): Promise<ICount> {
-    const whereFilter: FilterQuery<PublishedDataDocument> = filter.where ?? {};
-    const fields = filter.fields ?? {};
-    const filterQuery: FilterQuery<PublishedDataDocument> =
-      createFullqueryFilter<PublishedDataDocument>(
-        this.publishedDataModel,
-        "doi",
-        fields,
-      );
-    const whereClause: FilterQuery<PublishedDataDocument> = {
-      ...filterQuery,
-      ...whereFilter,
-    };
-
     const count = await this.publishedDataModel
-      .countDocuments(whereClause, options)
+      .countDocuments(filter.where ?? {}, options)
       .exec();
     return { count };
   }