app.js

const express = require('express')
const app = express()
app.use(express.json())
const sqlite3 = require('sqlite3')
const {open} = require('sqlite')
const bcrypt = require('bcrypt')
const jwt = require('jsonwebtoken')

let db = null
const path = require('path')
const dbpath = path.join(__dirname, 'twitterClone.db')

const dbInitializer = async () => {
  db = await open({
    filename: dbpath,
    driver: sqlite3.Database,
  })
  app.listen(3000)
  console.log('Server is running on http://localhost:3000')
}

//Register API

app.post('/register/', async (request, response) => {
  const {username, password, name, gender} = request.body
  const hashedPassword = await bcrypt.hash(password, 10)
  const selectQuery = `Select * from user where username='${username}'`
  const dbResponse = await db.get(selectQuery)
  if (dbResponse === undefined) {
    if (password.length < 6) {
      response.status(400)
      response.send('Password is too short')
      return
    } else {
      const insertQuery = `insert into user(username,password,name,gender) values('${username}','${hashedPassword}','${name}','${gender}');`
      const dbResponse = await db.run(insertQuery)
      response.send('User created successfully')
    }
  } else {
    response.status(400)
    response.send('User already exists')
  }
})

app.post('/login/', async (request, response) => {
  const {username, password} = request.body
  const selectQuery = `Select * from user where username='${username}';`
  const dbResponse = await db.get(selectQuery)
  if (dbResponse === undefined) {
    // User Doesn't Exist
    response.status(400)
    response.send('Invalid user')
  } else {
    // User Exists

    const isPassMatched = await bcrypt.compare(password, dbResponse.password)
    if (isPassMatched === true) {
      // Password is matched
      const userId = dbResponse.user_id
      const payload = {
        username: username,
        userId: userId,
      }
      //console.log(dbResponse)
      //console.log(payload)
      const jwtToken = await jwt.sign(payload, 'SECREt_TOKEN')
      response.send({jwtToken})
    } else {
      // Password is not matched
      response.status(400)
      response.send('Invalid password')
    }
  }
})

const authenticate = (request, response, next) => {
  const authHeader = request.headers['authorization']
  if (authHeader === undefined) {
    response.status(401).send('Invalid JWT Token')
    return
  }

  const jwtToken = authHeader.split(' ')[1]
  if (jwtToken === undefined) {
    response.status(401).send('Invalid JWT Token')
    return
  }

  jwt.verify(jwtToken, 'SECREt_TOKEN', (error, payload) => {
    if (error) {
      response.status(401).send('Invalid JWT Token')
    } else {
      //console.log('Decoded JWT payload:', payload)
      request.userId = payload.userId
      request.username = payload.username
      next()
    }
  })
}

app.get('/user/tweets/feed/', authenticate, async (request, response) => {
  const userId = request.userId
  const selectQuery = `SELECT
      u.username,
      t.tweet,
      t.date_time AS dateTime
    FROM
      follower f
      INNER JOIN tweet t ON f.following_user_id = t.user_id
      INNER JOIN user u ON t.user_id = u.user_id
    WHERE
      f.follower_user_id = ${userId}
    ORDER BY
      t.date_time DESC
    LIMIT 4;
    `
  const tweets = await db.all(selectQuery)
  //console.log(tweets)
  response.send(tweets)
})

app.get('/user/following/', authenticate, async (request, response) => {
  const userId = request.userId
  const selectQuery = `Select 
    distinct(u.name) 
  from 
    follower f
    inner join user u on f.following_user_id=u.user_id
  where f.follower_user_id=${userId}
  `
  const dbResponse = await db.all(selectQuery)
  response.send(dbResponse)
})

app.get('/user/followers/', authenticate, async (request, response) => {
  const userId = request.userId
  const selectQuery = `Select
    u.name as name
  from follower f
  inner join user u
    on u.user_id=f.follower_user_id
  where 
    f.following_user_id=${userId};`
  const dbResponse = await db.all(selectQuery)
  response.send(dbResponse)
})

app.get('/tweets/:tweetId/', authenticate, async (request, response) => {
  try {
    const {tweetId} = request.params
    const userId = request.userId

    // Step 1: Check if the tweet is posted by someone the user follows
    const accessQuery = `
      SELECT tweet.tweet, tweet.date_time AS dateTime
      FROM tweet
      INNER JOIN follower ON tweet.user_id = follower.following_user_id
      WHERE follower.follower_user_id = ? AND tweet.tweet_id = ?;
    `
    const tweetContent = await db.get(accessQuery, [userId, tweetId])

    if (tweetContent === undefined) {
      response.status(401).send('Invalid Request')
      return
    }

    // Step 2: Get likes count
    const likesQuery = `SELECT COUNT(*) AS likes FROM like WHERE tweet_id = ?;`
    const {likes} = await db.get(likesQuery, [tweetId])

    // Step 3: Get replies count
    const repliesQuery = `SELECT COUNT(*) AS replies FROM reply WHERE tweet_id = ?;`
    const {replies} = await db.get(repliesQuery, [tweetId])

    // Step 4: Send final response
    response.send({
      tweet: tweetContent.tweet,
      likes,
      replies,
      dateTime: tweetContent.dateTime,
    })
  } catch (error) {
    response.status(500).send('Server Error')
  }
})

app.get('/tweets/:tweetId/likes/', authenticate, async (request, response) => {
  const {tweetId} = request.params
  const userId = request.userId
  const selectQuery = `Select 
    t.tweet,
    t.date_time as dateTime
  from tweet t
  inner join follower f on f.following_user_id=t.user_id
  where f.follower_user_id=${userId} and t.tweet_id=${tweetId}
  `
  const tweetContent = await db.get(selectQuery)
  if (tweetContent === undefined) {
    response.status(401)
    response.send('Invalid Request')
  } else {
    const likedUsersQuery = `Select 
      u.username
    from
      user u
      inner join like l on l.user_id=u.user_id
      where l.tweet_id=${tweetId}  
    `
    const likedUsers = await db.all(likedUsersQuery)
    const likes = {
      likes: likedUsers.map(user => user.username),
    }
    response.send(likes)
  }
})

app.get(
  '/tweets/:tweetId/replies/',
  authenticate,
  async (request, response) => {
    const {tweetId} = request.params
    const userId = request.userId
    const selectQuery = `Select 
    t.tweet,
    t.date_time as dateTime
  from tweet t
  inner join follower f on f.following_user_id=t.user_id
  where f.follower_user_id=${userId} and t.tweet_id=${tweetId}
  `
    const tweetContent = await db.get(selectQuery)
    if (tweetContent === undefined) {
      response.status(401)
      response.send('Invalid Request')
    } else {
      const likedUsersQuery = `Select 
      u.name,
      l.reply
    from
      user u
      inner join reply l on l.user_id=u.user_id
      where l.tweet_id=${tweetId}  
    `
      const repliedUsers = await db.all(likedUsersQuery)
      response.send({replies: repliedUsers})
    }
  },
)

app.get('/user/tweets/', authenticate, async (request, response) => {
  const userId = request.userId
  const selectQuery = `Select 
  t.tweet,
  (select count(*) from like where tweet_id=t.tweet_id) as likes,
  (select count(*) from reply where tweet_id=t.tweet_id) as replies,
  t.date_time as dateTime
  from tweet t
  where t.user_id=${userId}
  `
  const dbResponse = await db.all(selectQuery)
  response.send(dbResponse)
})

app.post('/user/tweets/', authenticate, async (request, response) => {
  const userId = request.userId
  const tweet = request.tweet
  const insertQuery = `insert into tweet (tweet,user_id) values('${tweet}','${userId}')`
  await db.run(insertQuery)
  response.send('Created a Tweet')
})

app.delete('/tweets/:tweetId/', authenticate, async (request, response) => {
  const {tweetId} = request.params
  const userId = request.userId

  const selectQuery = `Select user_id from tweet where tweet_id=${tweetId}`
  const dbuser = await db.get(selectQuery)
  if (dbuser.user_id === userId) {
    const deleteQuery = `delete from tweet where tweet_id=${tweetId}`
    await db.run(deleteQuery)
    response.send('Tweet Removed')
  } else {
    response.status(401)
    response.send('Invalid Request')
  }
})

dbInitializer()

module.exports = app