My Favorites List

The My Favorites Feature

Clicking the My Favorites link in the main navigation will take you to page which contains a list of Movies that you can revisit later.

When a logged in user hovers their mouse cursor over a Movie on the website, a bookmark icon appears in the top right hand corner. Clicking this icon will either add or remove the Movie from the user’s Favorites list.

When adding a Movie to the list, a POST request it sent to the /api/favorites/{id} endpoint. When this happens, the following chain of events will occur:

Likewise, when it is clicked for a Movie that has already been favorited, a DELETE request is sent to the same URL, and the Movie is removed from the list.

Adding a Movie to My Favorites

For the first part of this challenge, modify the add() method to open a new database session, run the Cypher statement to create the :HAS_FAVORITE relationship, close the session and return the movie details along with an additional favorite property.

// Open a new session
const session = this.driver.session()

MATCH (u:User {userId: $userId})
MATCH (m:Movie {tmdbId: $movieId})

MERGE (u)-[r:HAS_FAVORITE]->(m)
ON CREATE SET r.createdAt = datetime()

RETURN m {
    .*,
    favorite: true
} AS movie

// Create HAS_FAVORITE relationship within a Write Transaction
const res = await session.executeWrite(
  tx => tx.run(
    `
      MATCH (u:User {userId: $userId})
      MATCH (m:Movie {tmdbId: $movieId})
      MERGE (u)-[r:HAS_FAVORITE]->(m)
      ON CREATE SET u.createdAt = datetime()
      RETURN m {
        .*,
        favorite: true
      } AS movie
    `,
    { userId, movieId, }
  )
)

// Throw an error if the user or movie could not be found
if ( res.records.length === 0 ) {
  throw new NotFoundError(
    `Could not create favorite relationship between User ${userId} and Movie ${movieId}`
  )
}

// Close the session
await session.close()

// Return movie details and `favorite` property
const [ first ] = res.records
const movie = first.get('movie')

return toNativeTypes(movie)

async add(userId, movieId) {
  // Open a new Session
  const session = this.driver.session()

  // Create HAS_FAVORITE relationship within a Write Transaction
  const res = await session.executeWrite(
    tx => tx.run(
      `
        MATCH (u:User {userId: $userId})
        MATCH (m:Movie {tmdbId: $movieId})
        MERGE (u)-[r:HAS_FAVORITE]->(m)
        ON CREATE SET u.createdAt = datetime()
        RETURN m {
          .*,
          favorite: true
        } AS movie
      `,
      { userId, movieId, }
    )
  )

  // Throw an error if the user or movie could not be found
  if ( res.records.length === 0 ) {
    throw new NotFoundError(
      `Could not create favorite relationship between User ${userId} and Movie ${movieId}`
    )
  }

  // Close the session
  await session.close()

  // Return movie details and `favorite` property
  const [ first ] = res.records
  const movie = first.get('movie')

  return toNativeTypes(movie)
}

Removing a Movie from My Favorites

The second part of this challenge is to write the code to remove a movie from the My Favorites list.

The code for deleting the :HAS_FAVORITE relationship will be similar, only the Cypher statement will change.

Instead of two separate MATCH clauses, we can instead attempt to find the pattern within a single clause. If the relationship (with an alias of r) exists, we will delete it and then return the movie information with favorite set to false.

MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie {tmdbId: $movieId})
DELETE r

RETURN m {
    .*,
    favorite: false
} AS movie

Use the code from the add() method above to implement the remove() function. If you get stuck, you can reveal the completed method below.

  async remove(userId, movieId) {
    // Open a new Session
    const session = this.driver.session()

    // Create HAS_FAVORITE relationship within a Write Transaction
    const res = await session.executeWrite(
      tx => tx.run(
        `
          MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie {tmdbId: $movieId})
          DELETE r
          RETURN m {
            .*,
            favorite: false
          } AS movie
        `,
        { userId, movieId, }
      )
    )

    // Throw an error if the user or movie could not be found
    if ( res.records.length === 0 ) {
      throw new NotFoundError(
        `Could not remove favorite relationship between User ${userId} and Movie ${movieId}`
      )
    }

    // Close the session
    await session.close()

    // Return movie details and `favorite` property
    const [ first ] = res.records
    const movie = first.get('movie')

    return toNativeTypes(movie)
  }

Listing My Favorites

Finally, the all() method in the FavoriteService currently returns a hardcoded list of Movies.

  async all(userId, sort = 'title', order = 'ASC', limit = 6, skip = 0) {
    // TODO: Open a new session
    // TODO: Retrieve a list of movies favorited by the user
    // TODO: Close session

    return popular
  }

Update this method to return a paginated list of movies that the user has added to their My Favorites list.

MATCH (:User {userId: $userId})-[:HAS_FAVORITE]->(m)

RETURN m {
    .*,
    favorite: true
} AS movie

You have already written similar code a few times, so try to implement this one on your own. If you get stuck, you can view the full solution below.

Remember to also import the int() function from neo4j-driver. This is required to convert the skip and limit values to Neo4j integers.

async all(userId, sort = 'title', order = 'ASC', limit = 6, skip = 0) {
  // Open a new session
  const session = await this.driver.session()

  // Retrieve a list of movies favorited by the user
  const res = await session.executeRead(
    tx => tx.run(
      `
        MATCH (u:User {userId: $userId})-[:HAS_FAVORITE]->(m:Movie)
        RETURN m {
          .*,
          favorite: true
        } AS movie
        ORDER BY m.\`${sort}\` ${order}
        SKIP $skip
        LIMIT $limit
      `,
      { userId, skip: int(skip), limit: int(limit) }
    )
  )

  // Close session
  await session.close()

  return res.records.map(row => toNativeTypes(row.get('movie')))
}

Testing

To test that this functionality has been correctly implemented, run the following code in a new terminal session:

npm run test 07

The test file is located at test/challenges/07-favorites-list.spec.js.

git checkout 07-favorites-list