Implemented Reply functionality for DirectChat and GroupChat

schema.graphql

@@ -1144,7 +1144,7 @@ type Mutation {
   revokeRefreshTokenForUser: Boolean!
   saveFcmToken(token: String): Boolean!
   sendMembershipRequest(organizationId: ID!): MembershipRequest!
-  sendMessageToDirectChat(chatId: ID!, messageContent: String!): DirectChatMessage!
+  sendMessageToDirectChat(chatId: ID!, messageContent: String!, replyTo: ID): DirectChatMessage!
   sendMessageToGroupChat(chatId: ID!, messageContent: String!): GroupChatMessage!
   signUp(data: UserInput!, file: String): AuthData!
   togglePostPin(id: ID!, title: String): Post!

src/constants.ts

@@ -57,6 +57,13 @@ export const CHAT_NOT_FOUND_ERROR = Object.freeze({
   PARAM: "chat",
 });
 
+export const MESSAGE_NOT_FOUND_ERROR = Object.freeze({
+  DESC: "Message not found",
+  CODE: "message.notFound",
+  MESSAGE: "message.notFound",
+  PARAM: "message",
+});
+
 export const VENUE_ALREADY_EXISTS_ERROR = Object.freeze({
   DESC: "Venue already exists",
   CODE: "venue.alreadyExists",

src/models/DirectChatMessage.ts

@@ -12,6 +12,7 @@ export interface InterfaceDirectChatMessage {
   directChatMessageBelongsTo: PopulatedDoc<InterfaceDirectChat & Document>;
   sender: PopulatedDoc<InterfaceUser & Document>;
   receiver: PopulatedDoc<InterfaceUser & Document>;
+  replyTo: PopulatedDoc<InterfaceDirectChatMessage & Document>;
   messageContent: string;
   status: string;
   createdAt: Date;
@@ -45,6 +46,11 @@ const directChatMessageSchema = new Schema(
       ref: "User",
       required: true,
     },
+    replyTo: {
+      type: Schema.Types.ObjectId,
+      ref: "DirectChatMessage",
+      required: false,
+    },
     messageContent: {
       type: String,
       required: true,

src/models/GroupChatMessage.ts

@@ -13,6 +13,7 @@ export interface InterfaceGroupChatMessage {
   sender: PopulatedDoc<InterfaceUser & Document>;
   createdAt: Date;
   updatedAt: Date;
+  replyTo: PopulatedDoc<InterfaceGroupChatMessage & Document>;
   messageContent: string;
   status: string;
 }
@@ -39,6 +40,11 @@ const groupChatMessageSchema = new Schema(
       ref: "User",
       required: true,
     },
+    replyTo: {
+      type: Schema.Types.ObjectId,
+      ref: "GroupChatMessage",
+      required: false,
+    },
     messageContent: {
       type: String,
       required: true,

src/resolvers/DirectChatMessage/index.ts

@@ -1,10 +1,12 @@
 import type { DirectChatMessageResolvers } from "../../types/generatedGraphQLTypes";
 import { directChatMessageBelongsTo } from "./directChatMessageBelongsTo";
 import { receiver } from "./receiver";
+import { replyTo } from "./replyTo";
 import { sender } from "./sender";
 
 export const DirectChatMessage: DirectChatMessageResolvers = {
   directChatMessageBelongsTo,
   receiver,
   sender,
+  replyTo,
 };

src/resolvers/DirectChatMessage/replyTo.ts

@@ -0,0 +1,31 @@
+import type { DirectChatMessageResolvers } from "../../types/generatedGraphQLTypes";
+import { DirectChatMessage } from "../../models";
+import { MESSAGE_NOT_FOUND_ERROR } from "../../constants";
+import { errors, requestContext } from "../../libraries";
+/**
+ * This resolver function will fetch and return the receiver(user) of the Direct chat from the database.
+ * @param parent - An object that is the return value of the resolver for this field's parent.
+ * @returns An `object` that contains User's data.
+ */
+export const replyTo: DirectChatMessageResolvers["replyTo"] = async (
+  parent,
+) => {
+  console.log("PARENT ", parent);
+  if (parent.replyTo) {
+    const result = await DirectChatMessage.findOne({
+      _id: parent.replyTo,
+    }).lean();
+
+    if (result) {
+      return result;
+    } else {
+      throw new errors.NotFoundError(
+        requestContext.translate(MESSAGE_NOT_FOUND_ERROR.MESSAGE),
+        MESSAGE_NOT_FOUND_ERROR.CODE,
+        MESSAGE_NOT_FOUND_ERROR.PARAM,
+      );
+    }
+  } else {
+    return null;
+  }
+};

src/resolvers/GroupChatMessage/index.ts

@@ -1,8 +1,10 @@
 import type { GroupChatMessageResolvers } from "../../types/generatedGraphQLTypes";
 import { groupChatMessageBelongsTo } from "./groupChatMessageBelongsTo";
+import { replyTo } from "./replyTo";
 import { sender } from "./sender";
 
 export const GroupChatMessage: GroupChatMessageResolvers = {
   groupChatMessageBelongsTo,
   sender,
+  replyTo,
 };

src/resolvers/GroupChatMessage/replyTo.ts

@@ -0,0 +1,29 @@
+import type { GroupChatMessageResolvers } from "../../types/generatedGraphQLTypes";
+import { GroupChatMessage } from "../../models";
+import { MESSAGE_NOT_FOUND_ERROR } from "../../constants";
+import { errors, requestContext } from "../../libraries";
+/**
+ * This resolver function will fetch and return the receiver(user) of the Direct chat from the database.
+ * @param parent - An object that is the return value of the resolver for this field's parent.
+ * @returns An `object` that contains User's data.
+ */
+export const replyTo: GroupChatMessageResolvers["replyTo"] = async (parent) => {
+  console.log("PARENT ", parent);
+  if (parent.replyTo) {
+    const result = await GroupChatMessage.findOne({
+      _id: parent.replyTo,
+    }).lean();
+
+    if (result) {
+      return result;
+    } else {
+      throw new errors.NotFoundError(
+        requestContext.translate(MESSAGE_NOT_FOUND_ERROR.MESSAGE),
+        MESSAGE_NOT_FOUND_ERROR.CODE,
+        MESSAGE_NOT_FOUND_ERROR.PARAM,
+      );
+    }
+  } else {
+    return null;
+  }
+};

src/resolvers/Mutation/sendMessageToDirectChat.ts

@@ -48,6 +48,7 @@ export const sendMessageToDirectChat: MutationResolvers["sendMessageToDirectChat
       sender: context.userId,
       receiver: directChat.users[receiverIndex],
       messageContent: args.messageContent,
+      replyTo: args.replyTo,
     });
 
     // add createdDirectChatMessage to directChat

src/resolvers/Mutation/sendMessageToGroupChat.ts

@@ -64,6 +64,7 @@ export const sendMessageToGroupChat: MutationResolvers["sendMessageToGroupChat"]
       sender: context.userId,
       createdAt: new Date(),
       messageContent: args.messageContent,
+      replyTo: args.replyTo,
     });
 
     // add createdGroupChatMessage to groupChat

src/typeDefs/mutations.ts

@@ -250,11 +250,13 @@ export const mutations = gql`
     sendMessageToDirectChat(
       chatId: ID!
       messageContent: String!
+      replyTo: ID
     ): DirectChatMessage! @auth
 
     sendMessageToGroupChat(
       chatId: ID!
       messageContent: String!
+      replyTo: ID
     ): GroupChatMessage! @auth
 
     signUp(data: UserInput!, file: String): AuthData!

src/typeDefs/types.ts

@@ -191,6 +191,7 @@ export const types = gql`
     directChatMessageBelongsTo: DirectChat!
     sender: User!
     receiver: User!
+    replyTo: DirectChatMessage
     createdAt: DateTime!
     updatedAt: DateTime!
     messageContent: String!
@@ -385,6 +386,7 @@ export const types = gql`
     _id: ID!
     groupChatMessageBelongsTo: GroupChat!
     sender: User!
+    replyTo: GroupChatMessage
     createdAt: DateTime!
     updatedAt: DateTime!
     messageContent: String!

src/types/generatedGraphQLTypes.ts

@@ -628,6 +628,7 @@ export type DirectChatMessage = {
   directChatMessageBelongsTo: DirectChat;
   messageContent: Scalars['String']['output'];
   receiver: User;
+  replyTo?: Maybe<DirectChatMessage>;
   sender: User;
   updatedAt: Scalars['DateTime']['output'];
 };
@@ -1012,6 +1013,7 @@ export type GroupChatMessage = {
   createdAt: Scalars['DateTime']['output'];
   groupChatMessageBelongsTo: GroupChat;
   messageContent: Scalars['String']['output'];
+  replyTo?: Maybe<GroupChatMessage>;
   sender: User;
   updatedAt: Scalars['DateTime']['output'];
 };
@@ -1751,12 +1753,14 @@ export type MutationSendMembershipRequestArgs = {
 export type MutationSendMessageToDirectChatArgs = {
   chatId: Scalars['ID']['input'];
   messageContent: Scalars['String']['input'];
+  replyTo?: InputMaybe<Scalars['ID']['input']>;
 };
 
 
 export type MutationSendMessageToGroupChatArgs = {
   chatId: Scalars['ID']['input'];
   messageContent: Scalars['String']['input'];
+  replyTo?: InputMaybe<Scalars['ID']['input']>;
 };
 
 
@@ -3952,6 +3956,7 @@ export type DirectChatMessageResolvers<ContextType = any, ParentType extends Res
   directChatMessageBelongsTo?: Resolver<ResolversTypes['DirectChat'], ParentType, ContextType>;
   messageContent?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   receiver?: Resolver<ResolversTypes['User'], ParentType, ContextType>;
+  replyTo?: Resolver<Maybe<ResolversTypes['DirectChatMessage']>, ParentType, ContextType>;
   sender?: Resolver<ResolversTypes['User'], ParentType, ContextType>;
   updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
@@ -4144,6 +4149,7 @@ export type GroupChatMessageResolvers<ContextType = any, ParentType extends Reso
   createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
   groupChatMessageBelongsTo?: Resolver<ResolversTypes['GroupChat'], ParentType, ContextType>;
   messageContent?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  replyTo?: Resolver<Maybe<ResolversTypes['GroupChatMessage']>, ParentType, ContextType>;
   sender?: Resolver<ResolversTypes['User'], ParentType, ContextType>;
   updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;

tests/helpers/directChat.ts

@@ -9,7 +9,7 @@
 import type { Document } from "mongoose";
 
 export type TestDirectChatType =
   | (InterfaceDirectChat & Document<any, any, InterfaceDirectChat>)
   | null;
 
 export type TestDirectChatMessageType =
@@ -45,11 +45,18 @@
   const [testUser, testOrganization, testDirectChat] =
     await createTestDirectChat();
 
+  const directChatMessage = await createDirectChatMessage(
+    testUser?._id,
+    testUser?._id,
+    testDirectChat?._id,
+  );
+
   if (testDirectChat && testUser) {
     const testDirectChatMessage = await DirectChatMessage.create({
       directChatMessageBelongsTo: testDirectChat._id,
       sender: testUser._id,
       receiver: testUser._id,
+      replyTo: directChatMessage?._id,
       messageContent: `msgContent${nanoid().toLowerCase()}`,
     });
     return [testUser, testOrganization, testDirectChat, testDirectChatMessage];

tests/helpers/groupChat.ts

@@ -9,7 +9,7 @@
 import type { Document } from "mongoose";
 
 export type TestGroupChatType =
   | (InterfaceGroupChat & Document<any, any, InterfaceGroupChat>)
   | null;
 
 export type TestGroupChatMessageType =
@@ -46,16 +46,36 @@
   const [testUser, testOrganization, testGroupChat] =
     await createTestGroupChat();
 
+  const message = await createGroupChatMessage(
+    testUser?._id,
+    testGroupChat?._id,
+  );
+
   if (testGroupChat && testUser) {
     const testGroupChatMessage = await GroupChatMessage.create({
       groupChatMessageBelongsTo: testGroupChat._id,
       sender: testUser._id,
       createdAt: new Date(),
       messageContent: `messageContent${nanoid().toLowerCase()}`,
+      replyTo: message?._id,
     });
 
     return [testUser, testOrganization, testGroupChat, testGroupChatMessage];
   } else {
     return [testUser, testOrganization, testGroupChat, null];
   }
 };
+
+export const createGroupChatMessage = async (
+  senderId: string,
+  groupChatId: string,
+): Promise<TestGroupChatMessageType> => {
+  const directChatMessage = await GroupChatMessage.create({
+    groupChatMessageBelongsTo: groupChatId,
+    sender: senderId,
+    createdAt: new Date(),
+    messageContent: `messageContent${nanoid().toLowerCase()}`,
+  });
+
+  return directChatMessage;
+};

tests/resolvers/DirectChatMessage/replyTo.spec.ts

@@ -0,0 +1,72 @@
+import "dotenv/config";
+import { replyTo as replyToResolver } from "../../../src/resolvers/DirectChatMessage/replyTo";
+import { connect, disconnect } from "../../helpers/db";
+import type mongoose from "mongoose";
+import { DirectChatMessage } from "../../../src/models";
+import { beforeAll, afterAll, describe, it, expect, vi } from "vitest";
+import type { TestDirectChatMessageType } from "../../helpers/directChat";
+import { createTestDirectChatMessage } from "../../helpers/directChat";
+import { Types } from "mongoose";
+import { MESSAGE_NOT_FOUND_ERROR } from "../../../src/constants";
+
+let testDirectChatMessage: TestDirectChatMessageType;
+let MONGOOSE_INSTANCE: typeof mongoose;
+
+beforeAll(async () => {
+  MONGOOSE_INSTANCE = await connect();
+  const temp = await createTestDirectChatMessage();
+  testDirectChatMessage = temp[3];
+});
+
+afterAll(async () => {
+  await disconnect(MONGOOSE_INSTANCE);
+});
+
+describe("resolvers -> DirectChatMessage -> directChatMessageBelongsTo", () => {
+  it(`returns directChat object for parent.directChatMessageBelongsTo`, async () => {
+    const parent = testDirectChatMessage?.toObject();
+
+    if (!parent) {
+      throw new Error("Parent object is undefined.");
+    }
+
+    if (typeof replyToResolver !== "function") {
+      throw new Error("replyToResolver is not a function.");
+    }
+
+    const replyToPayload = await replyToResolver(parent, {}, {});
+
+    const replyTo = await DirectChatMessage.findOne({
+      _id: testDirectChatMessage?.replyTo,
+    }).lean();
+
+    expect(replyToPayload).toEqual(replyTo);
+  });
+  it(`throws NotFoundError if no directChat exists`, async () => {
+    const { requestContext } = await import("../../../src/libraries");
+    const spy = vi
+      .spyOn(requestContext, "translate")
+      .mockImplementationOnce((message) => message);
+
+    const parent = {
+      ...testDirectChatMessage?.toObject(),
+      replyTo: new Types.ObjectId(), // Set to a non-existing ObjectId
+    };
+
+    if (!parent) {
+      throw new Error("Parent object is undefined.");
+    }
+
+    if (typeof replyToResolver !== "function") {
+      throw new Error("replyToResolver is not a function.");
+    }
+
+    try {
+      // @ts-expect-error - Testing for error
+      await replyToResolver(parent, {}, {});
+    } catch (error: unknown) {
+      expect(spy).toBeCalledWith(MESSAGE_NOT_FOUND_ERROR.MESSAGE);
+      expect((error as Error).message).toEqual(MESSAGE_NOT_FOUND_ERROR.MESSAGE);
+    }
+  });
+});