Merge branch 'main' into add-interests-api

Author: GuY8528

.github/workflows/ci.yml

@@ -86,7 +86,7 @@ jobs:
       - uses: actions/setup-node@v3
       - uses: oven-sh/setup-bun@v2
       - run: make prepare-deploy-web
-      - run: test `ls web/out | wc -l` != 0
+      - run: test `ls web/.next | wc -l` != 0
 
   deploy-test-server:
     name: Deploy Test (server)

Makefile

@@ -16,7 +16,7 @@ setup-ci:
 	make generate-sql
 
 sync: sync-server sync-web sync-root sync-common
-	lefthook install || true
+	bunx lefthook install || true
 	@echo '----------------------------------------------------------------------------------------------------------'
 	@echo '| Most work is done. now running prisma-generate-sql (which might fail if .env.dev is not set configured)|'
 	@echo '----------------------------------------------------------------------------------------------------------'

common/zod/schemas.ts

@@ -133,8 +133,15 @@ export const SendMessageSchema = z.object({
   content: z.string().min(1, { message: "Content must not be empty." }),
 });
 
+export const MatchingStatusSchema = z.union([
+  z.literal("myRequest"),
+  z.literal("otherRequest"),
+  z.literal("matched"),
+]);
+
 export const DMOverviewSchema = z.object({
   isDM: z.literal(true),
+  matchingStatus: MatchingStatusSchema,
   friendId: UserIDSchema,
   name: NameSchema,
   thumbnail: z.string(),
@@ -163,6 +170,7 @@ export const DMRoomSchema = z.object({
 export const PersonalizedDMRoomSchema = z.object({
   name: NameSchema,
   thumbnail: z.string(),
+  matchingStatus: MatchingStatusSchema,
 });
 
 export const SharedRoomSchema = z.object({

flake.nix

@@ -27,13 +27,11 @@
             biome
             pkg-config
             openssl
-            lefthook
           ] ++ [
             rust-pkgs
           ];
           shellHook = ''
             export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${pkgs.stdenv.cc.cc.lib}/lib
-            lefthook install
           '' + prisma.shellHook;
         };
       });

server/src/database/chat.ts

@@ -14,24 +14,35 @@ import type {
 } from "common/types";
 import { prisma } from "./client";
 import { getRelation } from "./matches";
-import { getMatchedUser } from "./requests";
+import {
+  getMatchedUser,
+  getPendingRequestsFromUser,
+  getPendingRequestsToUser,
+} from "./requests";
 
-// ユーザーの参加しているすべての Room の概要 (Overview) の取得
 export async function getOverview(
   user: UserID,
 ): Promise<Result<RoomOverview[]>> {
   try {
     const matched = await getMatchedUser(user);
     if (!matched.ok) return Err(matched.error);
 
-    const dm = await Promise.all(
+    const senders = await getPendingRequestsToUser(user);
+    if (!senders.ok) return Err(senders.error);
+
+    const receivers = await getPendingRequestsFromUser(user);
+    if (!receivers.ok) return Err(receivers.error);
+
+    //マッチングしている人のオーバービュー
+    const matchingOverview = await Promise.all(
       matched.value.map(async (friend) => {
         const lastMessageResult = await getLastMessage(user, friend.id);
         const lastMessage = lastMessageResult.ok
           ? lastMessageResult.value
           : undefined;
         const overview: DMOverview = {
           isDM: true,
+          matchingStatus: "matched",
           friendId: friend.id,
           name: friend.name,
           thumbnail: friend.pictureUrl,
@@ -41,6 +52,44 @@ export async function getOverview(
       }),
     );
 
+    //自分にリクエストを送ってきた人のオーバービュー
+    const senderOverview = await Promise.all(
+      senders.value.map(async (sender) => {
+        const lastMessageResult = await getLastMessage(user, sender.id);
+        const lastMessage = lastMessageResult.ok
+          ? lastMessageResult.value
+          : undefined;
+        const overview: DMOverview = {
+          isDM: true,
+          matchingStatus: "otherRequest",
+          friendId: sender.id,
+          name: sender.name,
+          thumbnail: sender.pictureUrl,
+          lastMsg: lastMessage,
+        };
+        return overview;
+      }),
+    );
+
+    //自分がリクエストを送った人のオーバービュー
+    const receiverOverview = await Promise.all(
+      receivers.value.map(async (receiver) => {
+        const lastMessageResult = await getLastMessage(user, receiver.id);
+        const lastMessage = lastMessageResult.ok
+          ? lastMessageResult.value
+          : undefined;
+        const overview: DMOverview = {
+          isDM: true,
+          matchingStatus: "myRequest",
+          friendId: receiver.id,
+          name: receiver.name,
+          thumbnail: receiver.pictureUrl,
+          lastMsg: lastMessage,
+        };
+        return overview;
+      }),
+    );
+
     const sharedRooms: {
       id: number;
       name: string;
@@ -61,7 +110,21 @@ export async function getOverview(
       };
       return overview;
     });
-    return Ok([...shared, ...dm]);
+
+    const overview = [
+      ...matchingOverview,
+      ...senderOverview,
+      ...receiverOverview,
+      ...shared,
+    ];
+
+    const sortedOverviewByTime = overview.sort((a, b) => {
+      const dateA = a.lastMsg?.createdAt ? a.lastMsg.createdAt.getTime() : 0;
+      const dateB = b.lastMsg?.createdAt ? b.lastMsg.createdAt.getTime() : 0;
+      return dateB - dateA;
+    });
+
+    return Ok([...sortedOverviewByTime]);
   } catch (e) {
     return Err(e);
   }

server/src/database/requests.ts

@@ -276,3 +276,19 @@ export async function getMatchedUser(
     return Err(e);
   }
 }
+
+export async function matchWithMemo(userId: UserID) {
+  try {
+    const result = await prisma.relationship.create({
+      data: {
+        status: "MATCHED",
+        sendingUserId: userId,
+        receivingUserId: 0, //KeepメモのUserId
+      },
+    });
+
+    return result;
+  } catch (error) {
+    return Err(error);
+  }
+}

server/src/functions/chat.ts

@@ -42,8 +42,10 @@ export async function sendDM(
   send: SendMessage,
 ): Promise<http.Response<Message>> {
   const rel = await getRelation(from, to);
-  if (!rel.ok || rel.value.status !== "MATCHED")
-    return http.forbidden("cannot send to non-friend");
+  if (!rel.ok || rel.value.status === "REJECTED")
+    return http.forbidden(
+      "You cannot send a message because the friendship request was rejected.",
+    );
 
   // they are now MATCHED
   const msg: Omit<Message, "id"> = {
@@ -59,21 +61,28 @@ export async function sendDM(
 }
 
 export async function getDM(
-  requester: UserID,
-  _with: UserID,
+  user: UserID,
+  friend: UserID,
 ): Promise<http.Response<PersonalizedDMRoom & DMRoom>> {
-  if (!areMatched(requester, _with))
-    return http.forbidden("cannot DM with a non-friend");
+  const rel = await getRelation(user, friend);
+  if (!rel.ok || rel.value.status === "REJECTED")
+    return http.forbidden("cannot send to rejected-friend");
 
-  const room = await db.getDMbetween(requester, _with);
+  const room = await db.getDMbetween(user, friend);
   if (!room.ok) return http.internalError();
 
-  const friendData = await getUserByID(_with);
+  const friendData = await getUserByID(friend);
   if (!friendData.ok) return http.notFound("friend not found");
 
   const personalized: PersonalizedDMRoom & DMRoom = {
     name: friendData.value.name,
     thumbnail: friendData.value.pictureUrl,
+    matchingStatus:
+      rel.value.status === "MATCHED"
+        ? "matched"
+        : rel.value.sendingUserId === user //どっちが送ったリクエストなのかを判定
+          ? "myRequest"
+          : "otherRequest",
     ...room.value,
   };
 

server/src/index.ts

@@ -17,7 +17,7 @@ const app = express();
 // https://expressjs.com/ja/api.html#app.settings.table  の query parser を参照。
 app.set("query parser", "simple");
 
-const port = 3000;
+const port = process.env.PORT || 3000;
 const allowedOrigins = (
   process.env.CORS_ALLOW_ORIGINS || panic("env CORS_ALLOW_ORIGINS is missing")
 )

server/src/router/chat.ts

@@ -23,12 +23,12 @@ router.get("/overview", async (req, res) => {
   res.status(result.code).send(result.body);
 });
 
-// send DM to userid.
+// send DM to userId.
 router.post("/dm/to/:userid", async (req, res) => {
   const user = await safeGetUserId(req);
   if (!user.ok) return res.status(401).send("auth error");
   const friend = safeParseInt(req.params.userid);
-  if (!friend.ok) return res.status(400).send("bad param encoding: `userid`");
+  if (!friend.ok) return res.status(400).send("bad param encoding: `userId`");
 
   const send = SendMessageSchema.safeParse(req.body);
   if (!send.success) {
@@ -42,14 +42,14 @@ router.post("/dm/to/:userid", async (req, res) => {
   res.status(result.code).send(result.body);
 });
 
-// GET a DM Room with userid, CREATE one if not found.
+// GET a DM Room with userId, CREATE one if not found.
 router.get("/dm/with/:userid", async (req, res) => {
   const user = await safeGetUserId(req);
   if (!user.ok) return res.status(401).send("auth error");
 
   const friend = safeParseInt(req.params.userid);
   if (!friend.ok)
-    return res.status(400).send("invalid param `userid` formatting");
+    return res.status(400).send("invalid param `userId` formatting");
 
   const result = await core.getDM(user.value, friend.value);
 

server/src/router/users.ts

@@ -13,6 +13,7 @@ import express, { type Request, type Response } from "express";
 import {
   getPendingRequestsFromUser,
   getPendingRequestsToUser,
+  matchWithMemo,
 } from "../database/requests";
 import {
   createUser,
@@ -128,10 +129,20 @@ router.get("/id/:id", async (req: Request, res: Response) => {
 // INSERT INTO "User" VALUES (body...)
 router.post("/", async (req: Request, res: Response) => {
   const partialUser = InitUserSchema.safeParse(req.body);
-  if (!partialUser.success) return res.status(400).send("invalid format");
+  if (!partialUser.success)
+    return res.status(400).send({
+      error: "Invalid input format",
+      details: partialUser.error.errors,
+    });
 
   const user = await createUser(partialUser.data);
-  if (!user.ok) return res.status(500).send();
+  if (!user.ok) return res.status(500).send({ error: "Failed to create user" });
+
+  //ユーザー作成と同時にメモとマッチング
+  const result = await matchWithMemo(user.value.id);
+  if ("ok" in result && !result.ok) {
+    return res.status(500).send({ error: "Failed to match user with memo" });
+  }
   res.status(201).json(user.value);
 });