feat: complete day 11

day11/resolvers/custom/actorResolvers.js

@@ -0,0 +1,63 @@
+const db = require("../../models");
+
+const ActorResolvers = {
+  Query: {
+    async getActor(_, { id }) {
+      try {
+        const actor = await db.actor.findByPk(id, {
+          include: [
+            { model: db.movie, as: "movies", through: { attributes: [] } },
+          ],
+        });
+        if (!actor) return { success: false, error: "Actor not found" };
+        return { success: true, data: actor };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async getAllActors() {
+      try {
+        const actors = await db.actor.findAll({
+          include: [
+            { model: db.movie, as: "movies", through: { attributes: [] } },
+          ],
+        });
+        return { success: true, data: actors };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+  Mutation: {
+    async createActor(_, args) {
+      try {
+        const actor = await db.actor.create(args);
+        return { success: true, data: actor };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async updateActor(_, { id, ...args }) {
+      try {
+        const actor = await db.actor.findByPk(id);
+        if (!actor) return { success: false, error: "Actor not found" };
+        await actor.update(args);
+        return { success: true, data: actor };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async deleteActor(_, { id }) {
+      try {
+        const actor = await db.actor.findByPk(id);
+        if (!actor) return { success: false, error: "Actor not found" };
+        await actor.destroy();
+        return { success: true, data: actor };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+};
+
+module.exports = ActorResolvers;

day11/resolvers/custom/directorResolvers.js

@@ -0,0 +1,59 @@
+const db = require("../../models");
+
+const DirectorResolvers = {
+  Query: {
+    async getDirector(_, { id }) {
+      try {
+        const director = await db.director.findByPk(id, {
+          include: [{ model: db.movie, as: "movies" }],
+        });
+        if (!director) return { success: false, error: "Director not found" };
+        return { success: true, data: director };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async getAllDirectors() {
+      try {
+        const directors = await db.director.findAll({
+          include: [{ model: db.movie, as: "movies" }],
+        });
+        return { success: true, data: directors };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+  Mutation: {
+    async createDirector(_, args) {
+      try {
+        const director = await db.director.create(args);
+        return { success: true, data: director };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async updateDirector(_, { id, ...args }) {
+      try {
+        const director = await db.director.findByPk(id);
+        if (!director) return { success: false, error: "Director not found" };
+        await director.update(args);
+        return { success: true, data: director };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async deleteDirector(_, { id }) {
+      try {
+        const director = await db.director.findByPk(id);
+        if (!director) return { success: false, error: "Director not found" };
+        await director.destroy();
+        return { success: true, data: director };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+};
+
+module.exports = DirectorResolvers;

day11/resolvers/custom/movieResolvers.js

@@ -0,0 +1,121 @@
+const { fn, col } = require("sequelize");
+const db = require("../../models");
+
+const MovieResolvers = {
+  Query: {
+    async getMovie(_, { id }) {
+      try {
+        const movie = await db.movie.findByPk(id, {
+          include: [
+            { model: db.director, as: "director" },
+            { model: db.review, as: "reviews" },
+            { model: db.actor, as: "actors", through: { attributes: [] } },
+            { model: db.genre, as: "genres", through: { attributes: [] } },
+          ],
+        });
+        if (!movie) return { success: false, error: "Movie not found" };
+        return { success: true, data: movie };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async getAllMovies() {
+      try {
+        const movies = await db.movie.findAll({
+          include: [
+            { model: db.director, as: "director" },
+            { model: db.review, as: "reviews" },
+            { model: db.actor, as: "actors", through: { attributes: [] } },
+            { model: db.genre, as: "genres", through: { attributes: [] } },
+          ],
+        });
+        return { success: true, data: movies };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async getMoviesWithReviewCount(_, { minReviews }) {
+      try {
+        const movies = await db.movie.findAll({
+          // attributes: {
+          //   include: [[fn("COUNT", col("reviews.id")), "reviewCount"]],
+          // },
+          include: [
+            { model: db.review, as: "reviews" },
+            { model: db.director, as: "director" },
+            { model: db.actor, as: "actors", through: { attributes: [] } },
+            { model: db.genre, as: "genres", through: { attributes: [] } },
+          ],
+          // having: literal(`COUNT(reviews.id) > ${minReviews}`),
+        });
+        const filtered = movies.filter(
+          (m) => (m.reviews ? m.reviews.length : 0) > minReviews
+        );
+        return { success: true, data: filtered };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+  Mutation: {
+    async createMovie(_, args) {
+      try {
+        const movie = await db.movie.create(args);
+        return { success: true, data: movie };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async updateMovie(_, { id, ...args }) {
+      try {
+        const movie = await db.movie.findByPk(id);
+        if (!movie) return { success: false, error: "Movie not found" };
+        await movie.update(args);
+        return { success: true, data: movie };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async deleteMovie(_, { id }) {
+      try {
+        const movie = await db.movie.findByPk(id);
+        if (!movie) return { success: false, error: "Movie not found" };
+        await movie.destroy();
+        return { success: true, data: movie };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async addActorToMoviesByGenre(_, { actor_id, genre_id }) {
+      try {
+        // Find all movies for the given genre
+        const genre = await db.genre.findByPk(genre_id, {
+          include: [{ model: db.movie, as: "movies" }],
+        });
+        if (!genre) return { success: false, error: "Genre not found" };
+        const movies = genre.movies;
+        for (const movie of movies) {
+          await db.movie_actor.findOrCreate({
+            where: { movie_id: movie.id, actor_id },
+            defaults: { movie_id: movie.id, actor_id },
+          });
+        }
+        // Return updated movies
+        const updatedMovies = await db.movie.findAll({
+          where: { id: movies.map((m) => m.id) },
+          include: [
+            { model: db.director, as: "director" },
+            { model: db.review, as: "reviews" },
+            { model: db.actor, as: "actors", through: { attributes: [] } },
+            { model: db.genre, as: "genres", through: { attributes: [] } },
+          ],
+        });
+        return { success: true, data: updatedMovies };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+};
+
+module.exports = MovieResolvers;

day11/resolvers/custom/reviewResolvers.js

@@ -0,0 +1,59 @@
+const db = require("../../models");
+
+const ReviewResolvers = {
+  Query: {
+    async getReview(_, { id }) {
+      try {
+        const review = await db.review.findByPk(id, {
+          include: [{ model: db.movie, as: "movie" }],
+        });
+        if (!review) return { success: false, error: "Review not found" };
+        return { success: true, data: review };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async getAllReviews() {
+      try {
+        const reviews = await db.review.findAll({
+          include: [{ model: db.movie, as: "movie" }],
+        });
+        return { success: true, data: reviews };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+  Mutation: {
+    async createReview(_, args) {
+      try {
+        const review = await db.review.create(args);
+        return { success: true, data: review };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async updateReview(_, { id, ...args }) {
+      try {
+        const review = await db.review.findByPk(id);
+        if (!review) return { success: false, error: "Review not found" };
+        await review.update(args);
+        return { success: true, data: review };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    async deleteReview(_, { id }) {
+      try {
+        const review = await db.review.findByPk(id);
+        if (!review) return { success: false, error: "Review not found" };
+        await review.destroy();
+        return { success: true, data: review };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+  },
+};
+
+module.exports = ReviewResolvers;

day11/resolvers/index.js

@@ -7,47 +7,58 @@
  * @author Ryan Wong
  *
  */
-const { GraphQLUpload } = require('graphql-upload');
+const { GraphQLUpload } = require("graphql-upload");
 
-const updateUserResolver = require('./update/updateUser');
-const singleUserResolver = require('./single/singleUser');
-const typeUserResolver = require('./type/typeUser');
+const updateUserResolver = require("./update/updateUser");
+const singleUserResolver = require("./single/singleUser");
+const typeUserResolver = require("./type/typeUser");
 
-const createLinkResolver = require('./create/createLink');
-const typeLinkResolver = require('./type/typeLink');
-const singleLinkResolver = require('./single/singleLink');
-const deactivateAllLinksResolver = require('./delete/deactivateAllLinks');
+const createLinkResolver = require("./create/createLink");
+const typeLinkResolver = require("./type/typeLink");
+const singleLinkResolver = require("./single/singleLink");
+const deactivateAllLinksResolver = require("./delete/deactivateAllLinks");
 
-const calendarResolver = require('./custom/calendar');
-const noteResolver = require('./custom/note');
-const customImageResolver = require('./custom/image');
-const uploadFileMutationResolver = require('./custom/uploadFile');
-
-const connectionStepsResolver = require('./custom/connectionSteps');
+// const calendarResolver = require("./custom/calendar");
+// const noteResolver = require("./custom/note");
+// const customImageResolver = require("./custom/image");
+// const uploadFileMutationResolver = require("./custom/uploadFile");
 
+// const connectionStepsResolver = require("./custom/connectionSteps");
+const movieResolvers = require("./custom/movieResolvers");
+const reviewResolvers = require("./custom/reviewResolvers");
+const directorResolvers = require("./custom/directorResolvers");
+const actorResolvers = require("./custom/actorResolvers");
 
 module.exports = {
   Upload: GraphQLUpload,
   Query: {
     user: singleUserResolver,
     link: singleLinkResolver,
-    ...calendarResolver.Query,
-    ...customImageResolver.Query,
-    ...noteResolver.Query,
-    ...connectionStepsResolver.Query
+    // ...calendarResolver.Query,
+    // ...customImageResolver.Query,
+    // ...noteResolver.Query,
+    // ...connectionStepsResolver.Query,
+    ...movieResolvers.Query,
+    ...reviewResolvers.Query,
+    ...directorResolvers.Query,
+    ...actorResolvers.Query,
   },
   Mutation: {
     updateUser: updateUserResolver,
     createLink: createLinkResolver,
     deactivateAllLinks: deactivateAllLinksResolver,
-    uploadFile: uploadFileMutationResolver,
-    ...calendarResolver.Mutation,
-    ...customImageResolver.Mutation,
-    ...noteResolver.Mutation,
+    // uploadFile: uploadFileMutationResolver,
+    // ...calendarResolver.Mutation,
+    // ...customImageResolver.Mutation,
+    // ...noteResolver.Mutation,
+    ...movieResolvers.Mutation,
+    ...reviewResolvers.Mutation,
+    ...directorResolvers.Mutation,
+    ...actorResolvers.Mutation,
   },
 
-  ...calendarResolver.Type,
-  ...noteResolver.Type,
+  // ...calendarResolver.Type,
+  // ...noteResolver.Type,
 
   User: typeUserResolver,
   Link: typeLinkResolver,