feat: student favourited courses list

apps/api/src/studentFavouritedCourses/api/studentFavouritedCourses.controller.ts

@@ -1,12 +1,24 @@
-import { Body, Controller, Delete, Post, Query } from "@nestjs/common";
+import { Body, Controller, Delete, Get, Post, Query } from "@nestjs/common";
 import { Validate } from "nestjs-typebox";
-import { BaseResponse, nullResponse, UUIDSchema } from "src/common";
+import {
+  BaseResponse,
+  nullResponse,
+  paginatedResponse,
+  PaginatedResponse,
+  UUIDSchema,
+} from "src/common";
 import { CurrentUser } from "src/common/decorators/user.decorator";
 import { StudentFavouritedCoursesService } from "../studentFavouritedCourses.service";
 import {
   createFavouritedCourseSchema,
   CreateFavouritedCourseSchema,
 } from "../schemas/createFavouritedCourse.schema";
+import { Type } from "@sinclair/typebox";
+import {
+  sortCourseFieldsOptions,
+  SortCourseFieldsOptions,
+} from "src/courses/schemas/courseQuery";
+import { allCoursesSchema, AllCoursesResponse } from "../schemas/course.schema";
 
 @Controller("studentFavouritedCourses")
 export class StudentFavouritedCoursesController {
@@ -32,6 +44,32 @@ export class StudentFavouritedCoursesController {
     });
   }
 
+  @Get()
+  @Validate({
+    response: paginatedResponse(allCoursesSchema),
+    request: [
+      { type: "query", name: "page", schema: Type.Number({ minimum: 1 }) },
+      { type: "query", name: "perPage", schema: Type.Number() },
+      { type: "query", name: "sort", schema: sortCourseFieldsOptions },
+    ],
+  })
+  async getAllCategories(
+    @Query("page") page: number,
+    @Query("perPage") perPage: number,
+    @Query("sort") sort: SortCourseFieldsOptions,
+    @CurrentUser() currentUser: { userId: string },
+  ): Promise<PaginatedResponse<AllCoursesResponse>> {
+    const query = { page, perPage, sort };
+
+    const data =
+      await this.studentFavouritedCoursesService.getCoursesForStudents(
+        query,
+        currentUser.userId,
+      );
+
+    return new PaginatedResponse(data);
+  }
+
   @Delete()
   @Validate({
     response: nullResponse(),

apps/api/src/studentFavouritedCourses/studentFavouritedCourses.service.ts

@@ -4,10 +4,25 @@ import {
   Injectable,
   NotFoundException,
 } from "@nestjs/common";
-import { and, eq } from "drizzle-orm";
-import { DatabasePg } from "src/common";
-import { courses, studentFavouritedCourses } from "src/storage/schema";
+import { and, count, eq, sql } from "drizzle-orm";
+import { DatabasePg, Pagination } from "src/common";
+import { DEFAULT_PAGE_SIZE, addPagination } from "src/common/pagination";
+import { CoursesQuery } from "src/courses/api/courses.types";
+import { getSortOptions } from "src/common/helpers/getSortOptions";
+import {
+  CourseSortField,
+  CourseSortFields,
+} from "src/courses/schemas/courseQuery";
+import {
+  categories,
+  courseLessons,
+  courses,
+  studentCourses,
+  studentFavouritedCourses,
+  users,
+} from "src/storage/schema";
 import { Status } from "src/storage/schema/utils";
+import { AllCoursesResponse } from "./schemas/course.schema";
 
 @Injectable()
 export class StudentFavouritedCoursesService {
@@ -43,6 +58,83 @@ export class StudentFavouritedCoursesService {
       .returning();
   }
 
+  async getCoursesForStudents(
+    query: CoursesQuery,
+    userId: string,
+  ): Promise<{ data: AllCoursesResponse; pagination: Pagination }> {
+    const {
+      sort = CourseSortFields.title,
+      perPage = DEFAULT_PAGE_SIZE,
+      page = 1,
+    } = query;
+
+    const { sortOrder, sortedField } = getSortOptions(sort);
+
+    const selectedColumns = {
+      id: courses.id,
+      creationDate: courses.createdAt,
+      title: courses.title,
+      imageUrl: courses.imageUrl,
+      author: sql<string>`CONCAT(${users.firstName} || ' ' || ${users.lastName})`,
+      category: categories.title,
+      courseLessonCount: sql<number>`(SELECT COUNT(*) FROM ${courseLessons} WHERE ${courseLessons.courseId} = ${courses.id})::INTEGER`,
+      enrolledParticipantCount: count(studentCourses.courseId),
+    };
+
+    return this.db.transaction(async (tx) => {
+      const queryDB = tx
+        .select(selectedColumns)
+        .from(studentFavouritedCourses)
+        .innerJoin(courses, eq(studentFavouritedCourses.courseId, courses.id))
+        .innerJoin(categories, eq(courses.categoryId, categories.id))
+        .leftJoin(users, eq(courses.authorId, users.id))
+        .leftJoin(studentCourses, eq(courses.id, studentCourses.courseId))
+        .leftJoin(courseLessons, eq(courses.id, courseLessons.courseId))
+        .where(and(eq(studentFavouritedCourses.studentId, userId)))
+        .orderBy(
+          sortOrder(this.getColumnToSortBy(sortedField as CourseSortField)),
+        )
+        .groupBy(
+          courses.id,
+          courses.title,
+          courses.imageUrl,
+          users.firstName,
+          users.lastName,
+          categories.title,
+        );
+
+      const dynamicQuery = queryDB.$dynamic();
+      const paginatedQuery = addPagination(dynamicQuery, page, perPage);
+      const data = await paginatedQuery;
+      const [totalItems] = await tx
+        .select({ count: count() })
+        .from(studentFavouritedCourses)
+        .innerJoin(courses, eq(studentFavouritedCourses.courseId, courses.id))
+        .innerJoin(categories, eq(courses.categoryId, categories.id))
+        .leftJoin(users, eq(courses.authorId, users.id))
+        .leftJoin(studentCourses, eq(courses.id, studentCourses.courseId))
+        .leftJoin(courseLessons, eq(courses.id, courseLessons.courseId))
+        .where(and(eq(studentFavouritedCourses.studentId, userId)))
+        .groupBy(
+          courses.id,
+          courses.title,
+          courses.imageUrl,
+          users.firstName,
+          users.lastName,
+          categories.title,
+        );
+
+      return {
+        data: data,
+        pagination: {
+          totalItems: totalItems?.count || 0,
+          page,
+          perPage,
+        },
+      };
+    });
+  }
+
   async deleteFavouritedCourseForUser(id: string, userId: string) {
     const [deletedFavouritedCourse] = await this.db
       .delete(studentFavouritedCourses)
@@ -58,4 +150,21 @@ export class StudentFavouritedCoursesService {
       throw new NotFoundException("Favourite course not found");
     }
   }
+
+  private getColumnToSortBy(sort: CourseSortField) {
+    switch (sort) {
+      case CourseSortFields.author:
+        return sql<string>`CONCAT(${users.firstName} || ' ' || ${users.lastName})`;
+      case CourseSortFields.category:
+        return categories.title;
+      case CourseSortFields.creationDate:
+        return courses.createdAt;
+      case CourseSortFields.lessonsCount:
+        return count(studentCourses.courseId);
+      case CourseSortFields.enrolledParticipantsCount:
+        return count(studentCourses.courseId);
+      default:
+        return courses.title;
+    }
+  }
 }

apps/api/src/swagger/api-schema.json

@@ -857,6 +857,96 @@
           }
         }
       },
+      "get": {
+        "operationId": "StudentFavouritedCoursesController_getAllCategories",
+        "parameters": [
+          {
+            "name": "page",
+            "required": false,
+            "in": "query",
+            "schema": {
+              "minimum": 1,
+              "type": "number"
+            }
+          },
+          {
+            "name": "perPage",
+            "required": false,
+            "in": "query",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "sort",
+            "required": false,
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "const": "title",
+                  "type": "string"
+                },
+                {
+                  "const": "category",
+                  "type": "string"
+                },
+                {
+                  "const": "creationDate",
+                  "type": "string"
+                },
+                {
+                  "const": "author",
+                  "type": "string"
+                },
+                {
+                  "const": "lessonsCount",
+                  "type": "string"
+                },
+                {
+                  "const": "enrolledParticipantsCount",
+                  "type": "string"
+                },
+                {
+                  "const": "-title",
+                  "type": "string"
+                },
+                {
+                  "const": "-category",
+                  "type": "string"
+                },
+                {
+                  "const": "-creationDate",
+                  "type": "string"
+                },
+                {
+                  "const": "-author",
+                  "type": "string"
+                },
+                {
+                  "const": "-lessonsCount",
+                  "type": "string"
+                },
+                {
+                  "const": "-enrolledParticipantsCount",
+                  "type": "string"
+                }
+              ]
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetAllCategoriesResponse"
+                }
+              }
+            }
+          }
+        }
+      },
       "delete": {
         "operationId": "StudentFavouritedCoursesController_deleteFavouritedCourseForUser",
         "parameters": [
@@ -1334,17 +1424,7 @@
                 "title": {
                   "type": "string"
                 },
-                "archived": {
-                  "anyOf": [
-                    {
-                      "type": "boolean"
-                    },
-                    {
-                      "type": "null"
-                    }
-                  ]
-                },
-                "createdAt": {
+                "imageUrl": {
                   "anyOf": [
                     {
                       "type": "string"
@@ -1353,13 +1433,28 @@
                       "type": "null"
                     }
                   ]
+                },
+                "author": {
+                  "type": "string"
+                },
+                "category": {
+                  "type": "string"
+                },
+                "courseLessonCount": {
+                  "type": "number"
+                },
+                "enrolledParticipantCount": {
+                  "type": "number"
                 }
               },
               "required": [
                 "id",
                 "title",
-                "archived",
-                "createdAt"
+                "imageUrl",
+                "author",
+                "category",
+                "courseLessonCount",
+                "enrolledParticipantCount"
               ]
             }
           },