umm

client/src/components/Chat/Chat.jsx

@@ -19,10 +19,10 @@ function Chat({ }) {
 
     const [messages, setMessages] = useState([]);
     const socket = useContext(SocketContext);
-    const {user} = useContext(UserContext);
+    const { user } = useContext(UserContext);
     const chatMainRef = useRef();
-    
-    
+
+
 
 
     // to get Messages of currently opened chat
@@ -36,8 +36,8 @@ function Chat({ }) {
             if (!socket) return;
             // console.log()
             socket.on("messages", (messages) => {
-                // console.log(messages);
-                setMessages(messages);
+                console.log("on-messages", messages);
+                setMessages(messages.reverse());
             });
 
             socket.emit("get_messages", currentChat.id);
@@ -54,25 +54,44 @@ function Chat({ }) {
     useEffect(() => {
         if (socket) {
             socket.on("receive_message", (message) => {
-                if (message.send_from == currentChat.id || message.send_from == user.id) {
+                console.log("receive_message:", message);
+
+
+                // if message is received in the current open chat 
+                if (message.sender_id == currentChat.id || message.sender_id == user.id) {
                     setMessages((prev) => [...prev, message]);
                 }
 
-                const ismessageOfContact = (contact) => (contact.id == message.send_to) || (contact.id == message.send_from);
-                var updatedContacts = contacts.map((contact) => (
-                    ismessageOfContact(contact) ?
-                        { ...contact, last_message: message } : contact
-                ));
 
-                updatedContacts.sort((a,b)=>b.last_message.send_at - a.last_message.send_at);
+                const isMsgOfOpenedChat = (contact) => (contact.id == message.receiver_id) || (contact.id == message.sender_id);
+                const updateUnseenCount = (contact) => {
+                    if (isMsgOfOpenedChat(contact)) {
+                        return contact.unseen_count;
+                    }
+                    else {
+                        return contact.unseen_count + 1;
+                    }
+                };
+                var updatedContacts = contacts.map((contact) => {
+                    var chat_data = { ...contact.chat_data };
+                    // console.log(contact);
+                    if (contact.id == message.receiver_id || contact.id == message.sender_id) {
+                        chat_data.last_message = message;
+                    }
+                    chat_data.unseen_count = updateUnseenCount(contact);
+
+                    return { ...contact, chat_data };
+                });
+
+                updatedContacts.sort((a, b) => Date.parse(b.chat_data.last_message.timestamp) - Date.parse(a.chat_data.last_message.timestamp));
                 // console.log(updatedContacts);
 
                 setContacts(updatedContacts);
-                
+
                 // if message from a new Contact
-                const contact = contacts.find(contact=>contact.id==message.send_from);
-                if(!contact && message.send_from !=user.id){
-                    socket.emit("get_contact",message.send_from);
+                const contact = contacts.find(contact => contact.id == message.sender_id);
+                if (!contact && message.sender_id != user.id) {
+                    socket.emit("get_contact", message.sender_id);
                 }
 
             });
@@ -95,7 +114,12 @@ function Chat({ }) {
         scrollToBottom();
     }, [messages]);
 
-
+    useEffect(() => {
+        if (messages.length === 0) return;
+        const unseen_messages = messages.filter(message => message.is_seen == 0);
+        console.log(unseen_messages);
+        socket.emit("mark_messages_seen", unseen_messages.map(msg => msg.id));
+    }, [messages]);
 
     // Until no chat is selected
     if (Object.keys(currentChat).length === 0) {
@@ -110,7 +134,7 @@ function Chat({ }) {
     // console.log("currentChat",currentChat);
     // console.log("currentChat",currentChat.id);
     // once a chat is selected
-    return ( 
+    return (
         <div className='chat'>
             <ChatHeader name={currentChat.username} />
             <ChatMain messages={messages} ref={chatMainRef} />

client/src/components/ChatFooter/ChatFooter.jsx

@@ -12,11 +12,6 @@ function ChatFooter({
 
 
 
-  useEffect(() => {
-    if (messageRef.current) {
-      messageRef.current.focus();
-    }
-  }) // risky this running all the time
 
   const sendMessage = (message) => {
 
@@ -24,8 +19,9 @@ function ChatFooter({
 
 
     const message_bundle = {
-      message,
-      send_to: currentChatId,
+      content:message,
+      receiver_id: currentChatId,
+      type:"text",
     }
 
     if (socket) {

client/src/components/ChatMain/ChatMain.jsx

@@ -10,13 +10,13 @@ const ChatMain = React.forwardRef(({
   const { user } = useContext(UserContext);
 
   const timeToReadable = (timestamp) => {
-    var d = new Date(timestamp * 1000);
+    var d = new Date(timestamp);
     return d.toLocaleTimeString();
     // return timestamp;
   }
 
   const isReceived = (message) => {
-    return user && message.send_to == user.id;
+    return user && message.sender_id != user.id;
   };
 
   return (
@@ -26,8 +26,8 @@ const ChatMain = React.forwardRef(({
         messages.map((message, idx) => (
           <Message
             key={idx}
-            message={message.message}
-            time={timeToReadable(message.send_at)}
+            message={message.content}
+            time={timeToReadable(message.timestamp)}
             isReceived={isReceived(message)}
           />
         ))

client/src/components/Contact/Contact.jsx

@@ -7,9 +7,13 @@ function Contact({
   lastmessage = "",
   onClick,
   isActive = false,
-  is_new = false,
+  unseen_count,
 }) {
 
+  var is_new=false;
+  if(unseen_count>0){
+    is_new=true;
+  }
 
   return (
     <div className={(isActive ? "active" : "") + ' contact'} onClick={onClick}>
@@ -20,6 +24,9 @@ function Contact({
           <p className={(is_new ? "new":"") + ' contact__lastmsg'}>{lastmessage}</p>
         }
       </div>
+      {unseen_count>0 && (
+        <span>{unseen_count}</span>
+      )}
     </div>
   )
 }

client/src/components/Contacts/Contacts.jsx

@@ -53,9 +53,9 @@ function Contacts({ }) {
                         key={contact.id}
                         onClick={() => { setCurrentChat(contact) }}
                         profile_pic={"logo512.png"}
-                        name={contact.username}
-                        lastmessage={contact.last_message.message}
-                        is_new={user.id == contact.last_message.send_to && contact.last_message.is_seen == 0}
+                        name={contact.id}
+                        lastmessage={contact.chat_data.last_message ? contact.chat_data.last_message.content:null}
+                        unseen_count={contact.chat_data.unseen_count ? contact.chat_data.unseen_count:null}
                         isActive={currentChat.id == contact.id}
                     />
                 ))

client/src/components/Search/Search.jsx

@@ -1,11 +1,14 @@
-import React from 'react';
+import React, { useContext } from 'react';
 import "./Search.css";
 import { MagnifyingGlassIcon } from '@heroicons/react/24/solid'
+import { ChatContext } from '../../contexts/ChatProvider';
 
 function Search() {
+    const { search, setSearch } = useContext(ChatContext);
+
     return (
         <div className='search'>
-            <input type="text" placeholder='Search' className='search__input'/>
+            <input type="text" placeholder='Search' className='search__input' value={search} onChange={e=>setSearch(e.target.value)} />
             <MagnifyingGlassIcon className='search__icon' color='black' />
         </div>
     )

client/src/components/SideBar/SideBar.jsx

@@ -11,8 +11,10 @@ function SideBar() {
     const socket = useContext(SocketContext);
 
     const {
+        contacts,
         setContacts,
         // setLastMessages,
+        search,
     } = useContext(ChatContext);
 
     useEffect(() => {
@@ -22,9 +24,9 @@ function SideBar() {
             if (!socket) return;
             socket.on("contacts", (contacts) => {
                 // console.log(contacts);
-                var newContacts = contacts; 
-                
-                newContacts.sort((a,b)=>b.last_message.send_at - a.last_message.send_at);
+                var newContacts = contacts;
+
+                newContacts.sort((a, b) => b.last_message.send_at - a.last_message.send_at);
 
                 setContacts(newContacts);  // set Contacts
                 // setLastMessages(contacts.map((contact) => contact.last_message)); // set Last messages
@@ -41,6 +43,24 @@ function SideBar() {
         }
     }, [socket]);
 
+    useEffect(() => {
+
+        if (!socket) return;
+
+        if (search.trim() == "") return;
+
+        socket.on("search_results",(contacts)=>{
+            setContacts(contacts);
+        })
+        socket.emit("search_contacts",search);
+
+        const cleanUp = () => {
+            socket.off("search_results");
+        }
+        return cleanUp;
+    }, [socket, search])
+
+
     return (
 
         <div className='side_bar'>

client/src/contexts/ChatProvider.jsx

@@ -6,12 +6,14 @@ export const ChatProvider = ({ children }) => {
     const [contacts, setContacts] = useState([]);
     const [currentChat, setCurrentChat] = useState({});
     const [lastMessages, setLastMessages] = useState([]);
+    const [search,setSearch] = useState("");
 
     return (
         <ChatContext.Provider value={{
             contacts, setContacts,
             currentChat, setCurrentChat,
             lastMessages, setLastMessages,
+            search,setSearch,
         }}>
             {children}
         </ChatContext.Provider>

server/index.ts

@@ -1,399 +0,0 @@
-import express from "express";
-import bodyParser from "body-parser";
-import { getDB } from "./db.js";
-import { lucia } from "./auth.js";
-import { generateId, verifyRequestOrigin } from "lucia";
-import { loginSchema, signUpSchema } from "./schemas.js";
-import bcrypt from "bcrypt";
-import dotenv from "dotenv";
-import cors from "cors";
-import mutler from "multer";
-import { Server, Socket } from "socket.io";
-import http from "http";
-import path from "path";
-
-dotenv.config();
-
-const __dirname = path.resolve();
-var db = getDB();
-
-
-var app = express();
-const server = http.createServer(app);
-
-const allowedOrigins = process.env.ALLOWED_ORIGINS || 'http://localhost:3001'
-const allowed_origins = allowedOrigins.split(",").map(item => item.trim());
-
-
-app.use(cors({
-  credentials: true,
-  // origin: true,
-  origin: allowed_origins,
-}));
-
-// parse application/json
-app.use(bodyParser.json());
-
-// parse application/x-www-form-urlencoded
-app.use(bodyParser.urlencoded({ extended: false }));
-
-// app.use(express.urlencoded());
-app.use(mutler().array(""));
-
-// The entire build/web directory is statically served.
-app.use(express.static(path.join(__dirname, "../client/build")));
-
-// middleware
-// app.use((req,res,next)=>{
-//   if(req.method==="GET"){
-//       return next();
-//   }
-
-//   const originHeader = req.headers.origin ?? null;
-//   const hostHeader = req.headers.host ?? null;
-//   if(!originHeader || !hostHeader || !verifyRequestOrigin(originHeader,[hostHeader])){
-//       return res.status(403).end();
-//   }
-//   return next();
-// })
-
-// middleware
-app.use(async (req, res, next) => {
-  const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
-  if (!sessionId) {
-    res.locals.user = null;
-    res.locals.session = null;
-    return next();
-  }
-  const { session, user } = await lucia.validateSession(sessionId);
-  if (session && session.fresh) {
-    res.appendHeader("Set-Cookie", lucia.createSessionCookie(session.id).serialize());
-  }
-  if (!session) {
-    res.appendHeader("Set-Cookie", lucia.createBlankSessionCookie().serialize());
-  }
-  res.locals.session = session;
-  res.locals.user = user;
-  // console.log(res.locals.session);
-  // console.log(res.locals.user);
-  return next();
-
-})
-
-
-const isAuthAPIMiddleware = async (req, res, next) => {
-  const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
-  // console.log(sessionId);
-
-  if (!sessionId) {
-
-    return res.status(403).send({ error: "unauthorized" });
-  }
-  const { session, user } = await lucia.validateSession(sessionId);
-  if (!session) {
-    return res.status(403).send({ error: "unauthorized" });
-  }
-  return next();
-};
-
-
-// app.get('/', (req, res) => {
-//   // res.cookie("msg","hmmmm");
-//   res.send('Hello World!');
-// })
-
-app.get("/session", (req, res) => {
-  if (!res.locals.user) {
-    return res.status(403).send();
-  }
-  return res.status(200).send(res.locals.user);
-})
-app.post("/signup", async (req, res) => {
-
-  // console.log(req.params);
-  // console.log(req.body);
-  const parsedData = signUpSchema.safeParse(req.body);
-  if (!parsedData.success) {
-    return res.status(403).json({ field_error: parsedData.error.flatten().fieldErrors }); // 403 is for validation error
-  }
-
-  var data = parsedData.data;
-  // check if password and confirm_password matchs
-  if (data.password != data.confirm_password) {
-    return res.status(403).json({
-      field_error: {
-        confirm_password: [
-          "password doesn't match"
-        ]
-      }
-    });
-  }
-
-  // check if username is already used
-  var row = db.prepare("select * from users where username=?").get(data.username);
-  if (row) {
-    return res.status(403).json({
-      field_error: {
-        username: [
-          "username already used."
-        ]
-      }
-    })
-  }
-
-  // save to data se
-  const userId = generateId(15);
-  const hashedPassword = await bcrypt.hash(data.password, 10);
-
-  await db.prepare("insert into users(id,name,username,password) values(?,?,?,?)").run(
-    userId,
-    data.name,
-    data.username,
-    hashedPassword
-  );
-
-  const session = await lucia.createSession(userId, {});
-  const sessionCookie = lucia.createSessionCookie(session.id);
-
-  res.cookie(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
-
-  res.json({
-    "status": "success",
-    "msg": "user created successfully",
-  });
-
-})
-
-app.post("/login", async (req, res) => {
-  console.log(req.body);
-
-  const parsedData = loginSchema.safeParse(req.body);
-
-  if (!parsedData.success) {
-    return res.status(403).json({
-      "field_error": parsedData.error.flatten().fieldErrors
-    })
-  }
-
-  // check if user exists 
-  const row = db.prepare("select * from users where username=?").get(parsedData.data.username);
-  // console.log(row);
-
-  if (!row) {
-    return res.status(403).json({
-      "error": "Incorrect username or password"
-    })
-  }
-
-  // check password
-  if (!await bcrypt.compare(parsedData.data.password, row.password)) {
-    return res.status(403).json({
-      "error": "Incorrect username or password"
-    })
-  }
-
-  // save session
-  const session = await lucia.createSession(row.id, {});
-  const sessionCookie = lucia.createSessionCookie(session.id);
-
-  // console.log(sessionCookie.attributes);
-  res.cookie(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
-
-  res.json({
-    "status": "success",
-    "msg": "logged in successfully",
-  });
-
-})
-
-
-
-// get all contacts route
-app.get("/contacts", isAuthAPIMiddleware, async (req, res) => {
-  const contacts = await db.prepare("select id,username from users where id!=?").all(res.locals.user.id);
-  // console.log(contacts);
-  res.json({ "contacts": contacts });
-})
-
-// get currentContact's messsages route
-app.get("/messages/:userid", isAuthAPIMiddleware, async (req, res) => {
-
-  // req.query.id
-
-  var messages = await db.prepare(`select * from messages
-   where (send_to=? and send_from=?) 
-   or
-   (send_to=? and send_from=?)`).all(
-    res.locals.user.id,
-    req.params.userid,
-
-    req.params.userid,
-    res.locals.user.id,
-  );
-  // const messages = await db.prepare("select * from messages").all();
-
-  res.json({ "messages": messages });
-})
-
-// Catch all. If we want to add pages later, then we should probably change this.
-app.get("*", (_req, res) => {
-  res.sendFile(path.join(__dirname + "/../client/build/index.html"));
-});
-
-
-const io = new Server(server, {
-  cors: {
-    origin: allowed_origins,
-    methods: ["GET", "POST"],
-    credentials: true,
-  }
-});
-
-const isAuth = async (req: Request, res: Response, next) => {
-  const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
-  // console.log(sessionId);
-
-  if (!sessionId) {
-
-    return next(new Error("error"));
-  }
-  const { session, user } = await lucia.validateSession(sessionId);
-  if (!session) {
-    // return res.end();
-    return next(new Error("error"));
-  }
-
-  return next();
-};
-
-io.engine.use(isAuth);
-
-async function getLastMessage({ user_id, contact_id }: { user_id: string, contact_id: string }) {
-
-  var last_message = await db.prepare(`select * from messages
-   where (send_to=? and send_from=?) 
-   or
-   (send_to=? and send_from=?)
-   ORDER BY send_at DESC
-   `).get(
-    user_id,
-    contact_id,
-
-    contact_id,
-    user_id,
-  );
-
-  // console.log(last_message);
-  if (last_message) {
-    return last_message;
-  }
-  else {
-    return {};
-  }
-
-}
-
-io.on("connection", async (socket) => {
-  console.log(`socket ${socket.id} connected`);
-
-  // add user and session to the socket.data object
-  const sessionId = lucia.readSessionCookie(socket.handshake.headers.cookie ?? "");
-  const { session, user } = await lucia.validateSession(sessionId as string);
-  socket.data.user = user;
-  socket.data.session = session;
-
-  socket.on("get_contacts", async () => {
-
-    // get all contacts to client
-    var contacts = await db.prepare("select id,username from users where id!=?").all(socket.data.user.id);
-    contacts = await Promise.all(contacts.map(async (contact: any) => {
-      return { ...contact, last_message: await getLastMessage({ user_id: socket.data.user.id, contact_id: contact.id }) }
-    }))
-
-    // console.log(contacts);
-    socket.emit("contacts", contacts);
-    // socket 
-  })
-
-
-
-  socket.on("get_messages", async (contact_id) => {
-    var messages = await db.prepare(`select * from messages
-    where (send_to=? and send_from=?) 
-    or
-    (send_to=? and send_from=?)
-    ORDER BY send_at ASC
-    `).all(
-      socket.data.user.id,
-      contact_id,
-
-      contact_id,
-      socket.data.user.id,
-    );
-
-    socket.emit("messages", messages);
-  });
-
-  socket.on("send_message", async (data) => {
-    // an event was received from the client
-
-    const msg_id = generateId(15);
-    const send_at = Math.floor(new Date().getTime() / 1000);
-
-    const stmt = db.prepare("insert into messages(id,message,send_to,send_from,send_at) values(?,?,?,?,?)");
-
-    await stmt.run(
-      msg_id,
-      data.message,
-      data.send_to,
-      socket.data.user.id,
-      send_at,
-    );
-
-    console.log("saved message:", data.message);
-
-    const sockets = await io.fetchSockets();
-    const message_bundle = {
-      ...data,
-      "id": msg_id,
-      "send_to": data.send_to,
-      "send_from": socket.data.user.id,
-      "send_at": send_at,
-      "is_seen": 0,
-    };
-
-    socket.emit("receive_message", message_bundle);
-    sockets.forEach((client) => {
-      if (client.data.user.id == data.send_to) {
-        // console.log("heyy");
-        return socket.to(client.id).emit("receive_message", message_bundle);
-      }
-    })
-
-  });
-
-  socket.on("get_contact", async contact_id => {
-    const contact = await db.prepare("select * from users where id = ?").get(contact_id);
-
-
-    socket.emit("contact", {
-      ...contact,
-      last_message: await getLastMessage({ user_id: socket.data.user.id, contact_id: contact_id }),
-    });
-  })
-
-  // upon disconnection
-  socket.on("disconnect", (reason) => {
-    console.log(`socket ${socket.id} disconnected due to ${reason}`);
-  });
-});
-
-
-
-
-
-const port = 3000;
-
-server.listen(port, () => {
-  console.log(`Running at port ${port}`);
-});

server/package.json

@@ -4,10 +4,10 @@
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "dev": "npx tsx watch index.ts",
-    "server": "npx tsx index.ts",
-    "dbinit": "npx tsx scripts/init_db.ts",
+    "dev": "npx tsx watch src/index.ts",
+    "server": "npx tsx src/index.ts",
+    "seed": "npx tsx src/seeder.ts",
+    "dbinit": "npx tsx src/scripts/init_db.ts",
     "both": "cd .. && cd client && npm run build && cd .. && cd server && npm run dev",
     "test": "echo \"Error: no test specified\" && exit 1"
   },

server/src/authHandler.ts

@@ -0,0 +1,163 @@
+import { lucia } from "./auth.js";
+import { generateId, Lucia } from "lucia";
+import { loginSchema, signUpSchema } from "./schemas.js";
+import bcrypt from "bcrypt";
+import { Database } from "better-sqlite3";
+import { Socket } from "socket.io";
+import { getDB } from "./db.js";
+
+var db: Database;
+db = getDB();
+
+// middleware
+export const authCookieMiddleware = (async (req: any, res: any, next: any) => {
+    const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
+    if (!sessionId) {
+        res.locals.user = null;
+        res.locals.session = null;
+        return next();
+    }
+    const { session, user } = await lucia.validateSession(sessionId);
+    if (session && session.fresh) {
+        res.appendHeader("Set-Cookie", lucia.createSessionCookie(session.id).serialize());
+    }
+    if (!session) {
+        res.appendHeader("Set-Cookie", lucia.createBlankSessionCookie().serialize());
+    }
+    res.locals.session = session;
+    res.locals.user = user;
+    // console.log(res.locals.session);
+    // console.log(res.locals.user);
+    return next();
+
+})
+
+export const isAuthAPIMiddleware = async (req: any, res: any, next: any) => {
+    const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
+    // console.log(sessionId);
+
+    if (!sessionId) {
+
+        return res.status(403).send({ error: "unauthorized" });
+    }
+    const { session, user } = await lucia.validateSession(sessionId);
+    if (!session) {
+        return res.status(403).send({ error: "unauthorized" });
+    }
+    return next();
+};
+
+export const isAuthSocketMiddleware = async (socket: Socket, next: any) => {
+    const sessionId = lucia.readSessionCookie(socket.handshake.headers.cookie ?? "");
+    console.log(sessionId);
+    if (!sessionId) return next(new Error("error"));
+
+    const { session, user } = await lucia.validateSession(sessionId);
+    if (!session) {
+        // return res.end();
+        return next(new Error("error"));
+    }
+
+    // add user and session to the socket.data object
+    socket.data.user = user;
+    socket.data.session = session;
+
+    return next();
+};
+
+
+export const signup_handler = async (req: any, res: any) => {
+
+    // console.log(req.params);
+    // console.log(req.body);
+    const parsedData = signUpSchema.safeParse(req.body);
+    if (!parsedData.success) {
+        return res.status(403).json({ field_error: parsedData.error.flatten().fieldErrors }); // 403 is for validation error
+    }
+
+    var data = parsedData.data;
+    // check if password and confirm_password matchs
+    if (data.password != data.confirm_password) {
+        return res.status(403).json({
+            field_error: {
+                confirm_password: [
+                    "password doesn't match"
+                ]
+            }
+        });
+    }
+
+    // check if username is already used
+    var row = db.prepare("select * from users where id=?").get(data.username);
+    if (row) {
+        return res.status(403).json({
+            field_error: {
+                username: [
+                    "username already used."
+                ]
+            }
+        })
+    }
+
+    // save to data se
+    const hashedPassword = await bcrypt.hash(data.password, 10);
+
+    await db.prepare("insert into users(id,name,password) values(?,?,?)").run(
+        data.username,
+        data.name,
+        hashedPassword
+    );
+
+    const session = await lucia.createSession(data.username, {});
+    const sessionCookie = lucia.createSessionCookie(session.id);
+
+    res.cookie(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
+
+    res.json({
+        "status": "success",
+        "msg": "user created successfully",
+    });
+
+};
+
+export const login_handler = (async (req: any, res: any) => {
+    // console.log(req.body);
+
+    const parsedData = loginSchema.safeParse(req.body);
+
+    if (!parsedData.success) {
+        return res.status(403).json({
+            "field_error": parsedData.error.flatten().fieldErrors
+        })
+    }
+
+    // check if user exists 
+    const row: any = db.prepare("select * from users where id=?").get(parsedData.data.username);
+    // console.log(row);
+
+    if (!row) {
+        return res.status(403).json({
+            "error": "Incorrect username or password"
+        })
+    }
+
+    // check password
+    if (!await bcrypt.compare(parsedData.data.password, row.password)) {
+        return res.status(403).json({
+            "error": "Incorrect username or password"
+        })
+    }
+
+    // save session
+    const session = await lucia.createSession(row.id, {});
+    const sessionCookie = lucia.createSessionCookie(session.id);
+
+    // console.log(sessionCookie.attributes);
+    res.cookie(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
+
+    res.json({
+        "status": "success",
+        "msg": "logged in successfully",
+    });
+
+})

server/src/chatHandler.ts

@@ -0,0 +1,175 @@
+import { lucia } from "./auth.js";
+import { generateId, Lucia } from "lucia";
+import bcrypt from "bcrypt";
+import { Database } from "better-sqlite3";
+import { getDB } from "./db.js";
+
+var db: Database;
+db = getDB();
+
+
+
+type MessageType = {
+    id: string,
+    content: string,
+    type: string,
+    timestamp: number,
+    sender_id: string,
+    receiver_id: string,
+    status: "sent" | "received" | "seen",
+};
+
+type ContactType = {
+    id: string,
+    name: string,
+    chat_data: {
+        last_message: MessageType,
+        unseen_count: number,
+    }
+};
+
+export function searchContacts(user_id: string, search_string: string) {
+    var contacts = db.prepare(`SELECT id,name FROM users WHERE id LIKE ? AND id!=?`)
+        .all("%" + search_string + "%",user_id);
+
+
+    // console.log(contacts);
+    contacts = contacts.map((contact: any) => {
+        var last_msg: any = getLastMessage(user_id, contact.id);
+
+        // console.log(user_id, contact.id, last_msg);
+        
+        var chat_data: any = {};
+        if (last_msg.id) {
+            chat_data.last_message = last_msg;
+            chat_data.unseen_count = getUnseenCount(user_id, contact.id);
+        }
+
+        return { ...contact, chat_data }
+    })
+
+    return contacts as ContactType[];
+}
+
+
+export function getContact(user_id: string, other_contact_id: string) {
+    var contact: any = {};
+    var user: any = db.prepare(`SELECT id,name from users
+        WHERE id=?
+        `).get(other_contact_id);
+
+    contact.id = user.id;
+    contact.name = user.name;
+    contact.chat_data = {
+        last_message: getLastMessage(user_id, other_contact_id),
+        unseen_count: getUnseenCount(user_id, other_contact_id),
+    }
+
+    return contact as ContactType;
+}
+
+export const getMyChats = (user_id: string) => {
+    // var contacts = db.prepare("SELECT send_to,send_from FROM messages WHERE send_to=? or send_from=?").all(user_id,user_id);
+
+    var chat_ids: any = db.prepare(`
+        SELECT Distinct(sender_id) as id FROM messages WHERE receiver_id=?
+        UNION
+        SELECT Distinct(receiver_id) as id FROM messages WHERE sender_id=?
+        `).all(user_id, user_id);
+
+    // get data of all   
+    var contacts: any = [];
+    for (var i = 0; i < chat_ids.length; i++) {
+        contacts.push(getContact(user_id, chat_ids[i].id));
+    }
+    return contacts as ContactType[];
+};
+
+
+export function getLastMessage(user_id: string, other_contact_id: string) {
+    const msg_stmt = db.prepare(`SELECT id,content,type,MAX(timestamp) as timestamp,sender_id,receiver_id,status 
+    FROM messages 
+    WHERE sender_id in (?,?) AND receiver_id in (?,?)`)
+
+    const last_message = msg_stmt.get(user_id, other_contact_id, user_id, other_contact_id);
+    return last_message as MessageType;
+}
+
+export function getUnseenCount(user_id: string, other_contact_id: string) {
+    const stmt = db.prepare(`SELECT COUNT(id) as unseen_count FROM messages
+        WHERE sender_id=? AND receiver_id=? AND status!='seen'
+    `)
+
+    const unseen_count: any = stmt.get(other_contact_id, user_id);
+    return unseen_count.unseen_count;
+}
+
+export function addMessage({
+    content,
+    type = "text",
+    sender_id,
+    receiver_id,
+}: {
+    content: string,
+    type: string,
+    sender_id: string,
+    receiver_id: string,
+
+}) {
+
+    type = type.toLowerCase();
+    const id = generateId(10);
+    const stmt = db.prepare(`INSERT INTO messages(id,content,type,sender_id,receiver_id) VALUES(?,?,?,?,?)`);
+
+    stmt.run(
+        id,
+        content,
+        type,
+        sender_id,
+        receiver_id
+    );
+
+    return db.prepare(`SELECT * FROM messages WHERE id=?`).get(id) as MessageType;
+}
+
+export function markMessageSeen(user_id: string, msg_id: string) {
+    const stmt = db.prepare(`UPDATE messages SET status='seen' WHERE sender_id!=? AND id=?`);
+    stmt.run(user_id, msg_id);
+}
+
+export function getAllMessages(user_id: string, other_contact_id: string) {
+    const stmt = db.prepare(`SELECT * from messages 
+    WHERE sender_id in (?,?) AND receiver_id in (?,?)
+    ORDER BY messages.timestamp DESC
+    `);
+
+    const msgs = stmt.all(user_id, other_contact_id, user_id, other_contact_id);
+    return msgs as MessageType[];
+}
+
+export function deleteChat(user_id: string, other_contact_id: string) {
+    db.prepare(`DELETE FROM message WHERE sender_id in (?,?) AND receiver_id in (?,?) `)
+        .run(user_id, other_contact_id, user_id, other_contact_id);
+    return true;
+}
+
+// console.log(searchContacts("user1","u"))
+// console.log(getMyChats("user1"))
+// console.log(getMyChats("user2"))
+// console.log(getMyChats("user3"))
+
+// console.log(getLastMessage("user1","user1"))
+// console.log(getUnseenCount("user1", "user2"))
+
+// // console.log(addMessage({
+// //         message: "new_msg",
+// //         type: "text",
+// //         send_from: "user3",
+// //     send_to: "wx6uv",
+// // }))
+
+// console.log(getUnseenCount("user1", "wx6uv"))
+// // markMessageSeen("user1", "33w87");
+// console.log(getAllMessages("user1", "wx6uv"))
+
+// console.log(deleteChat('user2',"sblua"))

server/src/index.ts

@@ -0,0 +1,176 @@
+import express from "express";
+import bodyParser from "body-parser";
+import { getDB } from "./db.js";
+import { lucia } from "./auth.js";
+import { generateId, verifyRequestOrigin } from "lucia";
+import { loginSchema, signUpSchema } from "./schemas.js";
+import bcrypt from "bcrypt";
+import dotenv from "dotenv";
+import cors from "cors";
+import mutler from "multer";
+import { Server, Socket } from "socket.io";
+import http from "http";
+import path from "path";
+import { authCookieMiddleware, isAuthAPIMiddleware, isAuthSocketMiddleware, login_handler, signup_handler } from "./authHandler.js";
+import {
+  getMyChats,
+  getLastMessage,
+  getUnseenCount,
+
+  searchContacts,
+
+  addMessage,
+  markMessageSeen,
+  getAllMessages,
+  getContact,
+} from "./chatHandler.js";
+
+dotenv.config();
+
+const __dirname = path.resolve();
+var db = getDB();
+
+
+var app = express();
+const server = http.createServer(app);
+
+const allowedOrigins = process.env.ALLOWED_ORIGINS || 'http://localhost:3001'
+const allowed_origins = allowedOrigins.split(",").map(item => item.trim());
+
+
+app.use(cors({
+  credentials: true,
+  // origin: true,
+  origin: allowed_origins,
+}));
+
+// parse application/json
+app.use(bodyParser.json());
+
+// parse application/x-www-form-urlencoded
+app.use(bodyParser.urlencoded({ extended: false }));
+
+// app.use(express.urlencoded());
+app.use(mutler().array(""));
+
+// The entire build/web directory is statically served.
+app.use(express.static(path.join(__dirname, "../client/build")));
+
+
+
+app.use(authCookieMiddleware);
+
+
+// http://localhost:3000/session
+app.get("/session", (req, res) => {
+  if (!res.locals.user) {
+    return res.status(403).send();
+  }
+  return res.status(200).send(res.locals.user);
+})
+
+app.post("/signup", signup_handler);
+app.post("/login", login_handler);
+
+app.get("/test", (req,res)=>{
+  console.log(req);
+  // console.log(res);
+  res.send("ok");
+});
+
+
+// Catch all. If we want to add pages later, then we should probably change this.
+app.get("*", (_req, res) => {
+  res.sendFile(path.join(__dirname + "/../client/build/index.html"));
+});
+
+// socket.io server
+const io = new Server(server, {
+  cors: {
+    origin: allowed_origins,
+    methods: ["GET", "POST"],
+    credentials: true,
+  }
+});
+
+io.use(isAuthSocketMiddleware);
+
+io.on("connection", async (socket) => {
+  console.log(`socket ${socket.id} connected`);
+  // client.emit("search_contacts","ankit")
+  socket.on("search_contacts",(search_string:string)=>{
+    const contacts = searchContacts(socket.data.user.id,search_string);
+    socket.emit("search_results",contacts);
+  })
+  
+  //Old chats 
+  socket.on("get_chats", async () => {
+
+    // get all chats of client
+    const chats = getMyChats(socket.data.user.id);
+    socket.emit("chats", chats);
+  })
+
+  socket.on("get_messages", async (chat_id) => {
+    var messages = getAllMessages(socket.data.user.id, chat_id);
+    // console.log(socket.data.user.id, chat_id);
+    // console.log(messages);
+    socket.emit("messages", messages);
+  });
+
+  socket.on("send_message", async (data) => {
+    // an event was received from the client
+
+    console.log(data);
+    const message = addMessage({
+      content: data.content,
+      type: data.type,
+      sender_id: socket.data.user.id,
+      receiver_id: data.receiver_id,
+    })
+
+    console.log("saved message:", message.content , "from:",message.sender_id);
+
+    
+
+    const sockets = await io.fetchSockets();
+    const receivers = sockets.filter((client)=>client.data.user.id==data.receiver_id);
+
+    receivers.forEach((client)=>{
+      client.emit("receive_message",message);
+    })
+    socket.emit("receive_message",message);
+
+  });
+
+  socket.on("mark_messages_seen", async (msg_ids: any) => {
+    // console.log(messages.length)
+
+    msg_ids.forEach((msg_id:any)=>{
+      markMessageSeen(socket.data.user.id,msg_id);
+    })
+
+  })
+
+  socket.on("get_contact", async contact_id => {
+    const contact: any = getContact(socket.data.user.id,contact_id);
+
+
+    socket.emit("contact", contact);
+  })
+
+  // upon disconnection
+  socket.on("disconnect", (reason) => {
+    console.log(`socket ${socket.id} disconnected due to ${reason}`);
+  });
+});
+
+
+
+
+
+const port = 3000;
+
+server.listen(port, () => {
+  console.log(`Running at port ${port}`);
+});

server/{scripts/init_db.ts → src/scripts/init_db.js}

@@ -1,21 +1,16 @@
 import database from "better-sqlite3";
 import dotenv from "dotenv";
 import fs from "fs";
-
 dotenv.config();
-
-const db_path = process.env.DB_NAME as string;
+const db_path = process.env.DB_NAME;
 console.log(db_path);
 fs.unlink(db_path, (err) => {
     if (err) {
         console.error(err);
     }
     else {
-        console.log(`deleted old database:\t${db_path}`)
-
-
+        console.log(`deleted old database:\t${db_path}`);
         const db = database(db_path);
-
         db.exec(`
             create table users(
                 id Text not null primary key,
@@ -24,7 +19,6 @@ fs.unlink(db_path, (err) => {
                 password varchar(20) NOT NULL
             );
         `);
-        
         db.exec(`
             create table sessions(
                 id Text not null primary key,
@@ -33,20 +27,24 @@ fs.unlink(db_path, (err) => {
                 FOREIGN KEY (user_id) REFERENCES users(id)
             );
         `);
-
+        db.exec(`
+            create table chats(
+                id Text not null primary key,
+                member_id TEXT NOT NULL,
+                FOREIGN KEY (member_id) REFERENCES users(id)
+            );
+        `);
         db.exec(`
             create table messages(
                 id Text not null primary key,
                 send_at INTEGER NOT NULL,
                 message Text not null,
-                send_to TEXT NOT NULL,
                 send_from TEXT NOT NULL,
+                chat_id TEXT NOT NULL,
                 is_seen TINYINT DEFAULT 0,
-                FOREIGN KEY (send_to) REFERENCES users(id),
-                FOREIGN KEY (send_from) REFERENCES users(id)
+                FOREIGN KEY (send_from) REFERENCES users(id),
+                FOREIGN KEY (chat_id) REFERENCES users(id)
             );
         `);
-        
-
     }
-})
+});

server/src/scripts/init_db.ts

@@ -0,0 +1,55 @@
+import database from "better-sqlite3";
+import dotenv from "dotenv";
+import fs from "fs";
+
+dotenv.config();
+
+const db_path = process.env.DB_NAME as string;
+console.log(db_path);
+fs.unlink(db_path, (err) => {
+    if (err) {
+        console.error(err);
+    }
+    else {
+        console.log(`deleted old database:\t${db_path}`)
+
+
+        const db = database(db_path);
+
+        db.exec(`
+            create table users(
+                id Text not null PRIMARY KEY,
+                name varchar(40) NOT NULL,
+                password varchar(20) NOT NULL
+            );
+        `);
+
+        db.exec(`
+            create table sessions(
+                id Text not null PRIMARY KEY,
+                expires_at INTEGER NOT NULL,
+                user_id TEXT NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+            );
+        `);
+
+
+        db.exec(`
+            create table messages(
+                id Text not null primary key,
+                content Text not null,
+                type Text NOT NULL DEFAULT "text",
+                sender_id TEXT NOT NULL,
+                receiver_id TEXT NOT NULL,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                status DEFAULT "sent", /* "sent", "received", "seen" */
+                FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE CASCADE,
+                FOREIGN KEY (receiver_id) REFERENCES users(id) ON DELETE CASCADE
+            );
+        `);
+
+
+
+
+    }
+})

server/src/seeder.ts

@@ -0,0 +1,69 @@
+import { getDB } from "./db.js";
+import bcrypt from "bcrypt";
+import { generateId, verifyRequestOrigin } from "lucia";
+
+
+import dotenv from "dotenv";
+dotenv.config();
+
+var db = getDB();
+
+const users = [
+    {
+        username: "user1",
+        password: await bcrypt.hash("123", 10),
+    },
+    {
+        username: "user2",
+        password: await bcrypt.hash("123", 10),
+    },
+    {
+        username: "user3",
+        password: await bcrypt.hash("123", 10),
+    },
+];
+
+
+
+function seedUsers() {
+
+    const stmt = db.prepare("INSERT INTO users(id,name,password) VALUES(?,?,?)");
+
+    users.forEach(user => {
+        stmt.run(user.username, user.username, user.password);
+    })
+
+}
+
+function seedMessages() {
+
+    const stmt = db.prepare(`INSERT INTO messages(id,content,type,sender_id,receiver_id) VALUES(?,?,?,?,?)`);
+
+    for (var i = 0; i < users.length; i++) {
+        for (var j = 0; j < users.length; j++) {
+            if(i==j) continue;
+            var message_id = generateId(5);
+            var content = "hi";
+            var type = "text";
+            var sender_id = users[i].username;
+            var receiver_id = users[j].username;
+            
+            stmt.run(
+                message_id,
+                content,
+                type,
+                sender_id,
+                receiver_id,
+            );
+
+        }    
+
+
+    }
+}
+
+
+db.prepare("delete from users").run();
+db.prepare("delete from messages").run();
+seedUsers()
+seedMessages()

server/tsconfig.json

@@ -27,7 +27,7 @@
     /* Modules */
     "module": "ESNext" /* Specify what module code is generated. */,
     "moduleResolution": "NodeNext",
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "rootDir": "./src/",                                  /* Specify the root folder within your source files. */
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */