✨ feat: add endpoint to fetch media by slug

src/modules/episode/services/http/getEpisodeDetails.service.ts

@@ -1,17 +1,14 @@
 import { AppError } from "../../../../helpers/error/instances/app";
 import { ErrorForwarder } from "../../../../helpers/error/instances/forwarder";
-import { getMediaIdFromSlugRepository } from "../../../media/repositories/GET/getMediaIdFromSlug.repository";
+import { selectMediaIdFromSlugRepository } from "../../../media/repositories/SELECT/selectMediaIdFromSlug.repository";
 import { GetEpisodeDetailsParams } from "../../controllers/getEpisodeDetails.controller";
 import { getEpisodeDetailsRepository } from "../../repositories/GET/getEpisodeDetails.repository";
 
-export const getEpisodeDetailsService = async (
+export const getEpisodeDetailsService = async (params: GetEpisodeDetailsParams) => {
-  params: GetEpisodeDetailsParams,
-) => {
   try {
-    if (!params.mediaSlug || !params.episode)
+    if (!params.mediaSlug || !params.episode) throw new AppError(400, "Media slug and episode are required.");
-      throw new AppError(400, "Media slug and episode are required.");
 
-    const mediaId = await getMediaIdFromSlugRepository(params.mediaSlug);
+    const mediaId = await selectMediaIdFromSlugRepository(params.mediaSlug);
     if (!mediaId?.id) throw new AppError(404, "Media not found.");
 
     const result = await getEpisodeDetailsRepository({

src/modules/internal/services/http/bulkInsertEpisode.service.ts

@@ -1,27 +1,20 @@
 import { ErrorForwarder } from "../../../../helpers/error/instances/forwarder";
 import { MediaEpisodeInfoResponse } from "../../types/mediaEpisodeInfo.type";
-import { getMediaByMalIdRepository } from "../../../media/repositories/GET/getMediaByMalId.repository";
 import { AppError } from "../../../../helpers/error/instances/app";
 import { SystemAccountId } from "../../../../config/account/system";
 import { bulkInsertEpisodesRepository } from "../../repositories/bulkInsertEpisodes.repository";
 import { getEpisodeReferenceAPI } from "../../../../config/apis/jikan/episode.reference";
+import { selectMediaByMalIdRepository } from "../../../media/repositories/SELECT/selectMediaByMalId.repository";
 
-export const bulkInsertEpisodeService = async (
+export const bulkInsertEpisodeService = async (mal_id: number, page: number = 1) => {
-  mal_id: number,
-  page: number = 1,
-) => {
   try {
     const episodeAPI = getEpisodeReferenceAPI(mal_id);
     const episodeData: MediaEpisodeInfoResponse = await fetch(
       `${episodeAPI.baseURL}${episodeAPI.getEpisodeList}?page=${page}`,
     ).then((res) => res.json());
 
-    const mediaData = await getMediaByMalIdRepository(mal_id);
+    const mediaData = await selectMediaByMalIdRepository(mal_id);
-    if (!mediaData)
+    if (!mediaData) throw new AppError(404, `Media with Mal ID ${mal_id} not found in database`);
-      throw new AppError(
-        404,
-        `Media with Mal ID ${mal_id} not found in database`,
-      );
 
     const insertedEpisodeData = [];
     episodeData.data.forEach(async (episode) => {

src/modules/media/controllers/getMediaBySlug.controller.ts

@@ -0,0 +1,18 @@
+import { Context, Static } from "elysia";
+import { mainErrorHandler } from "../../../helpers/error/handler";
+import { getMediaBySlugSchema } from "../schemas/getMediaBySlug.schema";
+
+export const getMediaBySlugController = async (ctx: {
+  set: Context["set"];
+  params: Static<typeof getMediaBySlugSchema.params>;
+}) => {
+  try {
+    return {
+      success: true,
+      status: 200,
+      message: `Media with slug '${ctx.params.slug}' fetched successfully`,
+    };
+  } catch (error) {
+    return mainErrorHandler(ctx.set, error);
+  }
+};

src/modules/media/index.ts

@@ -1,7 +1,8 @@
 import Elysia from "elysia";
 import { getAllMediaController } from "./controllers/getAllMedia.controller";
+import { getMediaBySlugController } from "./controllers/getMediaBySlug.controller";
+import { getMediaBySlugSchema } from "./schemas/getMediaBySlug.schema";
 
-export const mediaModule = new Elysia({ prefix: "/media" }).get(
+export const mediaModule = new Elysia({ prefix: "/media" })
-  "/",
+  .get("/", getAllMediaController)
-  getAllMediaController,
+  .get("/:slug", getMediaBySlugController, getMediaBySlugSchema);
-);

src/modules/media/repositories/SELECT/selectAllMedia.repository.ts

@@ -1,7 +1,7 @@
 import { AppError } from "../../../../helpers/error/instances/app";
 import { mediaModel } from "../../model";
 
-export const getAllMediaRepository = async (page: number) => {
+export const selectAllMediaRepository = async (page: number) => {
   try {
     const limit = 10;
     return await mediaModel.findMany({

src/modules/media/repositories/SELECT/selectMediaByMalId.repository.ts

@@ -1,7 +1,7 @@
 import { AppError } from "../../../../helpers/error/instances/app";
 import { mediaModel } from "../../model";
 
-export const getMediaByMalIdRepository = async (mal_id: number) => {
+export const selectMediaByMalIdRepository = async (mal_id: number) => {
   try {
     return await mediaModel.findUnique({
       where: { malId: mal_id },

src/modules/media/repositories/SELECT/selectMediaIdFromSlug.repository.ts

@@ -1,7 +1,7 @@
 import { AppError } from "../../../../helpers/error/instances/app";
 import { mediaModel } from "../../model";
 
-export const getMediaIdFromSlugRepository = async (slug: string) => {
+export const selectMediaIdFromSlugRepository = async (slug: string) => {
   try {
     return await mediaModel.findUnique({
       where: { slug },

src/modules/media/schemas/getMediaBySlug.schema.ts

@@ -0,0 +1,29 @@
+import { t } from "elysia";
+import { AppRouteSchema } from "../../../helpers/types/AppRouteSchema";
+
+export const getMediaBySlugSchema = {
+  params: t.Object({
+    slug: t.String({ description: "The slug of the media to fetch" }),
+  }),
+  detail: {
+    summary: "Fetch a media item by its slug",
+    description: "Fetch the specified media item using its slug. This endpoint returns the media details if found.",
+    responses: {
+      200: {
+        description: "Media item fetched successfully",
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                success: { type: "boolean", example: true },
+                status: { type: "number", example: 200 },
+                message: { type: "string", example: "Media fetched successfully" },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+} satisfies AppRouteSchema;

src/modules/media/services/http/getAllMedia.service.ts

@@ -1,14 +1,11 @@
 import { ErrorForwarder } from "../../../../helpers/error/instances/forwarder";
-import { getAllMediaRepository } from "../../repositories/GET/getAllMedia.repository";
+import { selectAllMediaRepository } from "../../repositories/SELECT/selectAllMedia.repository";
 
 export const getAllMediaService = async (pagination: string) => {
   try {
-    const page =
+    const page = /^\d+$/.test(pagination) && Number(pagination) > 0 ? Number(pagination) : 1;
-      /^\d+$/.test(pagination) && Number(pagination) > 0
-        ? Number(pagination)
-        : 1;
 
-    return getAllMediaRepository(page);
+    return selectAllMediaRepository(page);
   } catch (error) {
     ErrorForwarder(error);
   }