feat: enhance User and Favorite Resolvers and Update Fixtures

- Update Favorite and User entities to improve data modeling
- Refactor Favorite and User resolvers to enhance query capabilities
- Add new resolvers.ts file to consolidate all resolvers
- Update GraphQL type definitions to reflect changes in resolvers
- Refactor server.ts to improve server setup and initialization
- Update book fixtures loading script to align with entity changes

This update enhances the functionality of the GraphQL API, improves the server setup process,
and ensures that the fixtures align with the updated entities.

Author: amalv

src/entity/Favorite.ts

@@ -1,12 +1,25 @@
-import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from "typeorm";
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  Unique,
+} from "typeorm";
 import { User } from "./User";
 import { Book } from "./Book";
 
 @Entity()
+@Unique(["userId", "bookId"])
 export class Favorite {
   @PrimaryGeneratedColumn()
   id: number;
 
+  @Column()
+  userId: number;
+
+  @Column()
+  bookId: number;
+
   @ManyToOne(() => User, (user) => user.favorites)
   user: User;
 

src/graphql/resolvers/Favorite.ts

@@ -5,22 +5,32 @@ import { Book } from "../../entity/Book";
 
 export const FavoriteResolvers = {
   Mutation: {
-    favoriteBook: async (_, { userId, bookId }, context) => {
+    favoriteBook: async (_, { bookId }, context) => {
       try {
-        console.log("User ID:", userId);
-        console.log("Book ID:", bookId);
-        if (!userId || !bookId) {
-          throw new Error("User ID or Book ID not provided");
+        const userId = context.userId;
+
+        if (!userId) {
+          throw new Error("User ID not provided");
+        }
+
+        if (!bookId) {
+          throw new Error("Book ID not provided");
         }
+
         const dataSourceInstance = await dataSource;
         const userRepository = dataSourceInstance.getRepository(User);
         const bookRepository = dataSourceInstance.getRepository(Book);
         const favoriteRepository = dataSourceInstance.getRepository(Favorite);
 
-        const user = await userRepository.findOne({ where: { id: userId } });
+        let user = await userRepository.findOne({ where: { id: userId } });
         const book = await bookRepository.findOne({ where: { id: bookId } });
-        if (!user || !book) {
-          throw new Error("User or Book not found");
+        if (!book) {
+          throw new Error("Book not found");
+        }
+
+        if (!user) {
+          user = userRepository.create({ auth0Id: userId });
+          await userRepository.save(user);
         }
 
         const favorite = new Favorite();

src/graphql/resolvers/User.ts

@@ -14,5 +14,30 @@ export const UserResolvers = {
         throw error;
       }
     },
+    user: async (_, __, context) => {
+      try {
+        const userId = context.userId;
+
+        if (!userId) {
+          throw new Error("User ID not provided");
+        }
+
+        const dataSourceInstance = await dataSource;
+        const userRepository = dataSourceInstance.getRepository(User);
+        const user = await userRepository.findOne({
+          where: { auth0Id: userId },
+          relations: ["favorites", "favorites.book"],
+        });
+
+        if (!user) {
+          throw new Error("User not found");
+        }
+
+        return user;
+      } catch (error) {
+        console.error("Error fetching user:", error);
+        throw error;
+      }
+    },
   },
 };

src/graphql/resolvers/resolvers.ts

@@ -0,0 +1,14 @@
+import { UserResolvers } from "./User";
+import { BookResolvers } from "./Book";
+import { FavoriteResolvers } from "./Favorite";
+
+export const resolvers = {
+  Query: {
+    ...UserResolvers.Query,
+    ...BookResolvers.Query,
+    ...FavoriteResolvers.Query,
+  },
+  Mutation: {
+    ...FavoriteResolvers.Mutation,
+  },
+};

src/graphql/types/index.ts

@@ -1,20 +1 @@
-import { UserType } from "./User";
-import { BookType } from "./Book";
-import { BooksPageType } from "./BooksPage";
-import { FavoriteType } from "./Favorite";
-
-export const typeDefs = `#graphql
-  ${UserType}
-  ${BookType}
-  ${BooksPageType}
-  ${FavoriteType}
-  type Query {
-    hello: String!
-    dbInfo: String!
-    users: [User!]!
-    books(author: String, title: String, cursor: String, limit: Int): BooksPage!
-    favoriteBooks(userId: ID!): [Favorite!]!
-  }
-  type Mutation {
-    favoriteBook(userId: ID!, bookId: ID!): Favorite
-  }`;
+export * from "./typeDefs";

src/graphql/types/typeDefs.ts

@@ -0,0 +1,21 @@
+import { UserType } from "./User";
+import { BookType } from "./Book";
+import { BooksPageType } from "./BooksPage";
+import { FavoriteType } from "./Favorite";
+
+export const typeDefs = `#graphql
+  ${UserType}
+  ${BookType}
+  ${BooksPageType}
+  ${FavoriteType}
+  type Query {
+    hello: String!
+    dbInfo: String!
+    user: User
+    users: [User!]!
+    books(author: String, title: String, cursor: String, limit: Int): BooksPage!
+    favoriteBooks(userId: ID!): [Favorite!]!
+  }
+  type Mutation {
+    favoriteBook(bookId: ID!): Favorite
+  }`;

src/scripts/loadBookFixtures.ts

@@ -2,33 +2,55 @@ import { faker } from "@faker-js/faker";
 import { AppDataSource } from "../data-source";
 import { User } from "../entity/User";
 import { Book } from "../entity/Book";
+import { Favorite } from "../entity/Favorite";
 import booksData from "../fixtures/raw/books.json";
 
 const initializeBooks = async (bookData) => {
+  if (isNaN(Date.parse(bookData.publicationDate))) {
+    console.log(
+      `Skipping book with invalid publication date: ${bookData.title}`
+    );
+    return;
+  }
   const book = new Book();
   book.title = bookData.title;
   book.author = bookData.author;
   book.publicationDate = new Date(bookData.publicationDate);
   book.image = bookData.image || faker.image.url({ width: 150, height: 150 });
   book.rating = bookData.rating;
   book.ratingsCount = bookData.ratingsCount;
-  await AppDataSource.manager.save(book);
-  console.log("Saved a new book with id: " + book.id);
+  return AppDataSource.manager.save(book);
 };
 
-const loadBooks = async () => {
-  const books = await AppDataSource.manager.find(Book);
+const initializeUsers = async () => {
+  const user = new User();
+  user.auth0Id = "1234567890";
+  return AppDataSource.manager.save(user);
+};
+
+const initializeFavorites = async (user, book) => {
+  const favorite = new Favorite();
+  favorite.userId = user.id;
+  favorite.bookId = book.id;
+  return AppDataSource.manager.save(favorite);
 };
 
 AppDataSource.initialize()
   .then(async () => {
-    console.log("Dropping and recreating the books table...");
+    console.log("Dropping and recreating the tables...");
+    await AppDataSource.manager.query('TRUNCATE "favorite" CASCADE');
+    await AppDataSource.manager.query('TRUNCATE "user", "book" CASCADE');
     await AppDataSource.synchronize(true);
 
     console.log("Inserting new books into the database...");
-    await Promise.all(booksData.map(initializeBooks));
+    const books = await Promise.all(booksData.map(initializeBooks));
+
+    console.log("Inserting new users into the database...");
+    const user = await initializeUsers();
 
-    console.log("Loading books from the database...");
-    await loadBooks();
+    console.log("Marking some books as favorites for the user...");
+    await Promise.all(
+      books.slice(0, 5).map((book) => initializeFavorites(user, book))
+    );
   })
   .catch((error) => console.log(error));

src/server.ts

@@ -8,6 +8,12 @@ import { typeDefs } from "./graphql/types";
 import winston from "winston";
 import jwt from "jsonwebtoken";
 
+interface GraphQLContext {
+  userId?: string;
+  lambdaEvent?: any;
+  lambdaContext?: any;
+}
+
 const logger = winston.createLogger({
   level: "info",
   format: winston.format.json(),
@@ -25,15 +31,21 @@ if (process.env.NODE_ENV !== "production") {
   );
 }
 
-interface MyContext {
-  userId?: string;
-  lambdaEvent?: any;
-  lambdaContext?: any;
-}
+const decodeToken = (token: string): string | undefined => {
+  if (token?.startsWith("Bearer ")) {
+    const jwtToken = token.slice(7, token.length).trimStart();
+    try {
+      const decoded = jwt.verify(jwtToken, process.env.JWT_SECRET);
+      return decoded.sub;
+    } catch (err) {
+      logger.error("Invalid token");
+    }
+  }
+};
 
 let server: ApolloServer | undefined;
 try {
-  server = new ApolloServer<MyContext>({
+  server = new ApolloServer<GraphQLContext>({
     typeDefs,
     resolvers,
     introspection: true,
@@ -49,16 +61,7 @@ const graphqlHandler = startServerAndCreateLambdaHandler(
   {
     context: async ({ event, context }) => {
       const token = event.headers.authorization || "";
-      let userId;
-      if (token && token.startsWith("Bearer ")) {
-        const jwtToken = token.slice(7, token.length).trimLeft();
-        try {
-          const decoded = jwt.verify(jwtToken, process.env.JWT_SECRET);
-          userId = decoded.sub;
-        } catch (err) {
-          logger.error("Invalid token");
-        }
-      }
+      const userId = decodeToken(token);
 
       return {
         userId,