Merge pull request #419 from Hexastack/418-issue-add-retro-compatibility-for-find-and-findandpopulate-methods

fix: add retro compatibility for find and findAndPopulate methods

api/src/attachment/controllers/attachment.controller.ts

@@ -94,7 +94,7 @@ export class AttachmentController extends BaseController<Attachment> {
     )
     filters: TFilterQuery<Attachment>,
   ) {
-    return await this.attachmentService.findPage(filters, pageQuery);
+    return await this.attachmentService.find(filters, pageQuery);
   }
 
   /**

api/src/chat/controllers/message.controller.ts

@@ -55,7 +55,7 @@ import { SubscriberService } from '../services/subscriber.service';
 @UseInterceptors(CsrfInterceptor)
 @Controller('message')
 export class MessageController extends BaseController<
-  Message,
+  AnyMessage,
   MessageStub,
   MessagePopulate,
   MessageFull

api/src/chat/repositories/message.repository.ts

@@ -72,7 +72,7 @@ export class MessageRepository extends BaseRepository<
     until = new Date(),
     limit: number = 30,
   ) {
-    return await this.findPage(
+    return await this.find(
       {
         $or: [{ recipient: subscriber.id }, { sender: subscriber.id }],
         createdAt: { $lt: until },
@@ -96,7 +96,7 @@ export class MessageRepository extends BaseRepository<
     since = new Date(),
     limit: number = 30,
   ) {
-    return await this.findPage(
+    return await this.find(
       {
         $or: [{ recipient: subscriber.id }, { sender: subscriber.id }],
         createdAt: { $gt: since },

api/src/chat/repositories/subscriber.repository.ts

@@ -106,7 +106,7 @@ export class SubscriberRepository extends BaseRepository<
    * @returns The constructed query object.
    */
   findByForeignIdQuery(id: string) {
-    return this.findPageQuery(
+    return this.findQuery(
       { foreign_id: id },
       { skip: 0, limit: 1, sort: ['lastvisit', 'desc'] },
     );

api/src/chat/services/message.service.ts

@@ -126,7 +126,7 @@ export class MessageService extends BaseService<
    * @returns The message history since the specified date.
    */
   async findLastMessages(subscriber: Subscriber, limit: number = 5) {
-    const lastMessages = await this.findPage(
+    const lastMessages = await this.find(
       {
         $or: [{ sender: subscriber.id }, { recipient: subscriber.id }],
       },

api/src/cms/controllers/content.controller.ts

@@ -283,10 +283,7 @@ export class ContentController extends BaseController<
       );
       throw new NotFoundException(`ContentType of id ${contentType} not found`);
     }
-    return await this.contentService.findPage(
-      { entity: contentType },
-      pageQuery,
-    );
+    return await this.contentService.find({ entity: contentType }, pageQuery);
   }
 
   /**

api/src/cms/services/content.service.ts

@@ -170,7 +170,7 @@ export class ContentService extends BaseService<
       }
 
       try {
-        const contents = await this.findPage(query, {
+        const contents = await this.find(query, {
           skip,
           limit,
           sort: ['createdAt', 'desc'],

api/src/utils/generics/base-repository.ts

@@ -22,6 +22,7 @@ import {
   SortOrder,
   UpdateQuery,
   UpdateWithAggregationPipeline,
+  UpdateWriteOpResult,
 } from 'mongoose';
 
 import { TFilterQuery } from '@/utils/types/filter.types';
@@ -70,7 +71,7 @@ export abstract class BaseRepository<
     this.registerLifeCycleHooks();
   }
 
-  getPopulate() {
+  getPopulate(): P[] {
     return this.populate;
   }
 
@@ -79,7 +80,7 @@ export abstract class BaseRepository<
     return `hook:${entity}:${suffix}` as `hook:${IHookEntities}:${TNormalizedEvents}`;
   }
 
-  private registerLifeCycleHooks() {
+  private registerLifeCycleHooks(): void {
     const repository = this;
     const hooks = LifecycleHookManager.getHooks(this.cls.name);
 
@@ -202,7 +203,7 @@ export abstract class BaseRepository<
   protected async execute<R extends Omit<T, P>>(
     query: Query<T[], T>,
     cls: new () => R,
-  ) {
+  ): Promise<R[]> {
     const resultSet = await query.lean(this.leanOpts).exec();
     return resultSet.map((doc) => plainToClass(cls, doc, this.transformOpts));
   }
@@ -211,7 +212,7 @@ export abstract class BaseRepository<
     query: Query<T, T>,
     cls: new () => R,
     options?: ClassTransformOptions,
-  ) {
+  ): Promise<R> {
     const doc = await query.lean(this.leanOpts).exec();
     return plainToClass(cls, doc, options ?? this.transformOpts);
   }
@@ -219,7 +220,7 @@ export abstract class BaseRepository<
   protected findOneQuery(
     criteria: string | TFilterQuery<T>,
     projection?: ProjectionType<T>,
-  ) {
+  ): Query<T, T, object, T, 'findOne', object> {
     if (!criteria) {
       // An empty criteria would return the first document that it finds
       throw new Error('findOneQuery() should not have an empty criteria');
@@ -247,7 +248,7 @@ export abstract class BaseRepository<
   async findOneAndPopulate(
     criteria: string | TFilterQuery<T>,
     projection?: ProjectionType<T>,
-  ) {
+  ): Promise<TFull> {
     this.ensureCanPopulate();
     const query = this.findOneQuery(criteria, projection).populate(
       this.populate,
@@ -259,8 +260,32 @@ export abstract class BaseRepository<
     filter: TFilterQuery<T>,
     pageQuery?: PageQueryDto<T>,
     projection?: ProjectionType<T>,
-  ) {
-    const { skip = 0, limit, sort = ['createdAt', 'asc'] } = pageQuery || {};
+  ): Query<T[], T, object, T, 'find', object>;
+
+  /**
+   * @deprecated
+   */
+  protected findQuery(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T>,
+    projection?: ProjectionType<T>,
+  ): Query<T[], T, object, T, 'find', object>;
+
+  protected findQuery(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T> | PageQueryDto<T>,
+    projection?: ProjectionType<T>,
+  ): Query<T[], T, object, T, 'find', object> {
+    if (Array.isArray(pageQuery)) {
+      const query = this.model.find<T>(filter, projection);
+      return query.sort([pageQuery] as [string, SortOrder][]);
+    }
+
+    const {
+      skip = 0,
+      limit = 0,
+      sort = ['createdAt', 'asc'],
+    } = pageQuery || {};
     const query = this.model.find<T>(filter, projection);
     return query
       .skip(skip)
@@ -272,12 +297,32 @@ export abstract class BaseRepository<
     filter: TFilterQuery<T>,
     pageQuery?: PageQueryDto<T>,
     projection?: ProjectionType<T>,
-  ) {
+  ): Promise<T[]>;
+
+  /**
+   * @deprecated
+   */
+  async find(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<T[]>;
+
+  async find(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T> | PageQueryDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<T[]> {
+    if (Array.isArray(pageQuery)) {
+      const query = this.findQuery(filter, pageQuery, projection);
+      return await this.execute(query, this.cls);
+    }
+
     const query = this.findQuery(filter, pageQuery, projection);
     return await this.execute(query, this.cls);
   }
 
-  private ensureCanPopulate() {
+  private ensureCanPopulate(): void {
     if (!this.populate || !this.clsPopulate) {
       throw new Error('Cannot populate query');
     }
@@ -287,23 +332,47 @@ export abstract class BaseRepository<
     filters: TFilterQuery<T>,
     pageQuery?: PageQueryDto<T>,
     projection?: ProjectionType<T>,
-  ) {
+  ): Promise<TFull[]>;
+
+  /**
+   * @deprecated
+   */
+  async findAndPopulate(
+    filters: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<TFull[]>;
+
+  async findAndPopulate(
+    filters: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T> | PageQueryDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<TFull[]> {
     this.ensureCanPopulate();
+    if (Array.isArray(pageQuery)) {
+      const query = this.findQuery(filters, pageQuery, projection).populate(
+        this.populate,
+      );
+      return await this.execute(query, this.clsPopulate);
+    }
+
     const query = this.findQuery(filters, pageQuery, projection).populate(
       this.populate,
     );
     return await this.execute(query, this.clsPopulate);
   }
 
-  protected findAllQuery(sort?: QuerySortDto<T>) {
-    return this.findQuery({}, { limit: undefined, skip: undefined, sort });
+  protected findAllQuery(
+    sort?: QuerySortDto<T>,
+  ): Query<T[], T, object, T, 'find', object> {
+    return this.findQuery({}, { limit: 0, skip: 0, sort });
   }
 
-  async findAll(sort?: QuerySortDto<T>) {
-    return await this.find({}, { limit: undefined, skip: undefined, sort });
+  async findAll(sort?: QuerySortDto<T>): Promise<T[]> {
+    return await this.find({}, { limit: 0, skip: 0, sort });
   }
 
-  async findAllAndPopulate(sort?: QuerySortDto<T>) {
+  async findAllAndPopulate(sort?: QuerySortDto<T>): Promise<TFull[]> {
     this.ensureCanPopulate();
     const query = this.findAllQuery(sort).populate(this.populate);
     return await this.execute(query, this.clsPopulate);
@@ -315,7 +384,7 @@ export abstract class BaseRepository<
   protected findPageQuery(
     filters: TFilterQuery<T>,
     { skip, limit, sort }: PageQueryDto<T>,
-  ) {
+  ): Query<T[], T, object, T, 'find', object> {
     return this.findQuery(filters)
       .skip(skip)
       .limit(limit)
@@ -339,7 +408,7 @@ export abstract class BaseRepository<
   async findPageAndPopulate(
     filters: TFilterQuery<T>,
     pageQuery: PageQueryDto<T>,
-  ) {
+  ): Promise<TFull[]> {
     this.ensureCanPopulate();
     const query = this.findPageQuery(filters, pageQuery).populate(
       this.populate,
@@ -365,7 +434,7 @@ export abstract class BaseRepository<
     );
   }
 
-  async createMany(dtoArray: U[]) {
+  async createMany(dtoArray: U[]): Promise<T[]> {
     const docs = await this.model.create(dtoArray);
 
     return docs.map((doc) =>
@@ -394,7 +463,7 @@ export abstract class BaseRepository<
   async updateMany<D extends Partial<U>>(
     filter: TFilterQuery<T>,
     dto: UpdateQuery<D>,
-  ) {
+  ): Promise<UpdateWriteOpResult> {
     return await this.model.updateMany<T>(filter, {
       $set: dto,
     });
@@ -410,19 +479,19 @@ export abstract class BaseRepository<
     return await this.model.deleteMany(criteria);
   }
 
-  async preValidate(_doc: HydratedDocument<T>) {
+  async preValidate(_doc: HydratedDocument<T>): Promise<void> {
     // Nothing ...
   }
 
-  async postValidate(_validated: HydratedDocument<T>) {
+  async postValidate(_validated: HydratedDocument<T>): Promise<void> {
     // Nothing ...
   }
 
-  async preCreate(_doc: HydratedDocument<T>) {
+  async preCreate(_doc: HydratedDocument<T>): Promise<void> {
     // Nothing ...
   }
 
-  async postCreate(_created: HydratedDocument<T>) {
+  async postCreate(_created: HydratedDocument<T>): Promise<void> {
     // Nothing ...
   }
 
@@ -430,7 +499,7 @@ export abstract class BaseRepository<
     _query: Query<D, D, unknown, T, 'findOneAndUpdate'>,
     _criteria: TFilterQuery<T>,
     _updates: UpdateWithAggregationPipeline | UpdateQuery<D>,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 
@@ -438,35 +507,35 @@ export abstract class BaseRepository<
     _query: Query<D, D, unknown, T, 'updateMany'>,
     _criteria: TFilterQuery<T>,
     _updates: UpdateWithAggregationPipeline | UpdateQuery<D>,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 
   async postUpdateMany(
     _query: Query<D, D, unknown, T, 'updateMany'>,
     _updated: any,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 
   async postUpdate(
     _query: Query<D, D, unknown, T, 'findOneAndUpdate'>,
     _updated: T,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 
   async preDelete(
     _query: Query<DeleteResult, D, unknown, T, 'deleteOne' | 'deleteMany'>,
     _criteria: TFilterQuery<T>,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 
   async postDelete(
     _query: Query<DeleteResult, D, unknown, T, 'deleteOne' | 'deleteMany'>,
     _result: DeleteResult,
-  ) {
+  ): Promise<void> {
     // Nothing ...
   }
 }

api/src/utils/generics/base-service.ts

@@ -48,7 +48,25 @@ export abstract class BaseService<
     filter: TFilterQuery<T>,
     pageQuery?: PageQueryDto<T>,
     projection?: ProjectionType<T>,
+  ): Promise<T[]>;
+
+  /**
+   * @deprecated
+   */
+  async find(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<T[]>;
+
+  async find(
+    filter: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T> | PageQueryDto<T>,
+    projection?: ProjectionType<T>,
   ): Promise<T[]> {
+    if (Array.isArray(pageQuery))
+      return await this.repository.find(filter, pageQuery, projection);
+
     return await this.repository.find(filter, pageQuery, projection);
   }
 
@@ -56,7 +74,29 @@ export abstract class BaseService<
     filters: TFilterQuery<T>,
     pageQuery?: PageQueryDto<T>,
     projection?: ProjectionType<T>,
-  ) {
+  ): Promise<TFull[]>;
+
+  /**
+   * @deprecated
+   */
+  async findAndPopulate(
+    filters: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<TFull[]>;
+
+  async findAndPopulate(
+    filters: TFilterQuery<T>,
+    pageQuery?: QuerySortDto<T> | PageQueryDto<T>,
+    projection?: ProjectionType<T>,
+  ): Promise<TFull[]> {
+    if (Array.isArray(pageQuery))
+      return await this.repository.findAndPopulate(
+        filters,
+        pageQuery,
+        projection,
+      );
+
     return await this.repository.findAndPopulate(
       filters,
       pageQuery,