@roadmanjs/chat 0.0.63 → 0.0.65

package/src/chat/methods/ChatConvo.methods.ts

@@ -0,0 +1,340 @@
+import ChatConvoModel, {
+    ChatConvo,
+    ChatConvoModelName,
+    ChatConvoType,
+    chatConvoSelectors,
+} from '../models/ChatConvo.model';
+import {ChatMessage, ChatMessageModel} from '../models';
+import {connectionOptions, createUpdate} from '@roadmanjs/couchset';
+import {publishMessageToTopic, sendPushNotification} from '../../shared/pubsub.utils';
+
+import {ContextType} from '../../shared/ContextType';
+import {awaitTo} from '@stoqey/client-graphql';
+import compact from 'lodash/compact';
+import isEmpty from 'lodash/isEmpty';
+import {log} from '@roadmanjs/logs';
+
+export const createAConvoAndReturnIt = async (newConvo: ChatConvoType): Promise<ChatConvoType> => {
+    const {members = [], group = false, owner, ...others} = newConvo;
+
+    const [errorCreatingConvo, createdChatConvo = []] = await awaitTo(
+        createChatConvoType({
+            ...others,
+            members,
+            group,
+            owner,
+        })
+    );
+
+    if (errorCreatingConvo) {
+        throw errorCreatingConvo;
+    }
+
+    let convo = createdChatConvo[0];
+    if (owner) {
+        const selected = createdChatConvo.find((chat) => chat.owner === owner);
+        if (selected) {
+            convo = selected;
+        }
+    }
+
+    return convo;
+};
+
+export const createChatConvoType = async (
+    props: Partial<ChatConvoType>
+): Promise<ChatConvoType[]> => {
+    const {members = [], group = false, ...others} = props;
+
+    if (isEmpty(members)) {
+        throw new Error('members have to be more than one');
+    }
+
+    const defaultConvo: ChatConvoType = {
+        ...others,
+        members,
+        group,
+        owner: 'system',
+    };
+
+    const isPublicChat = defaultConvo.public;
+
+    if (isPublicChat) {
+        const existingPublicChat = await ChatConvoModel.pagination({
+            where: {convoId: defaultConvo.convoId},
+        });
+
+        if (existingPublicChat && existingPublicChat.length) {
+            return existingPublicChat;
+        }
+    }
+
+    const [errorSystemConvo, createdSystemConvo] = await awaitTo(
+        createUpdate<ChatConvoType>({
+            model: ChatConvoModel,
+            data: defaultConvo,
+            ...defaultConvo,
+        })
+    );
+
+    if (errorSystemConvo) {
+        throw errorSystemConvo;
+    }
+
+    if (isPublicChat) {
+        return [createdSystemConvo];
+    }
+
+    // create a convo for each member
+    const [errorConvos, convos] = await awaitTo(
+        Promise.all(
+            members.map((member) =>
+                createUpdate<ChatConvoType>({
+                    model: ChatConvoModel,
+                    data: {
+                        ...defaultConvo,
+                        owner: member,
+                        convoId: createdSystemConvo?.id,
+                    },
+                    ...defaultConvo,
+                    owner: member,
+                })
+            )
+        )
+    );
+
+    if (errorConvos) {
+        throw errorConvos;
+    }
+
+    return convos as ChatConvoType[];
+};
+
+export const getChatConvoById = async (id: string, owner: string): Promise<ChatConvo | null> => {
+    try {
+        const bucket = connectionOptions.bucketName;
+
+        const query = `
+            SELECT *
+            FROM \`${bucket}\` convo
+            JOIN \`${bucket}\` owner
+            ON KEYS convo.owner
+            NEST \`${bucket}\` members
+            ON KEYS convo.members
+            LEFT JOIN \`${bucket}\` lastMessage
+            ON KEYS convo.lastMessage
+            LEFT JOIN \`${bucket}\` source
+            ON KEYS convo.sourceId
+                
+            WHERE convo._type = "${ChatConvoModelName}"
+            AND (convo.id = "${id}" OR convo.convoId = "${id}")
+            AND convo.owner = "${owner}"
+            LIMIT 1;
+            `;
+
+        const [errorFetching, data = []] = await awaitTo(
+            ChatConvoModel.customQuery<any>({
+                limit: 1,
+                query,
+                params: {limit: 1, id},
+            })
+        );
+
+        if (errorFetching) {
+            throw errorFetching;
+        }
+
+        const [rows = []] = data;
+
+        const dataToSend = rows.map((d) => {
+            const {convo, lastMessage = {}, members, owner} = d;
+            const source = d.source || {};
+            const lastMessageParsed = ChatMessageModel.parse(lastMessage);
+            const chatConvoItem = ChatConvoModel.parse({
+                ...convo,
+                source,
+                members,
+                owner,
+            });
+            chatConvoItem.lastMessage = lastMessageParsed;
+            return chatConvoItem;
+        });
+
+        return dataToSend[0];
+    } catch (error) {
+        log('error getting chat messages', error);
+        return null;
+    }
+};
+
+interface UpdateConvoLastMessage {
+    sender: string;
+    convoId: string;
+    lastMessageId: string;
+}
+
+export const updateConvoLastMessage = async (args: UpdateConvoLastMessage): Promise<boolean> => {
+    const {sender, convoId, lastMessageId} = args;
+    try {
+        // find all convo by convoId
+        // add update them all with the new lastMessageId
+
+        const convos: ChatConvoType[] = await ChatConvoModel.pagination({
+            select: chatConvoSelectors,
+            where: {convoId: {$eq: convoId}},
+        });
+
+        if (!isEmpty(convos)) {
+            // update convo objects
+            const [errorConvos, updatedConvos] = await awaitTo(
+                Promise.all(
+                    convos.map((convo) => {
+                        const update = {
+                            ...convo,
+                            lastMessage: lastMessageId,
+                        };
+
+                        if (convo.owner !== sender) {
+                            // if this is not creator, update unread
+                            update.unread = (convo.unread || 0) + 1;
+                        }
+
+                        return createUpdate<ChatConvoType>({
+                            model: ChatConvoModel,
+                            data: update,
+                            ...convo,
+                        });
+                    })
+                )
+            );
+            if (errorConvos) {
+                throw errorConvos;
+            }
+
+            log(
+                `updated convos with lastMessage=${lastMessageId}`,
+                updatedConvos.map((uc) => uc.id)
+            );
+        }
+
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+interface UpdateConvoSubscriptions {
+    context: ContextType;
+    sender: string;
+    convoId: string;
+    data: any;
+}
+
+/**
+ * Send data to convo expect the sender
+ * @param args
+ * @returns
+ */
+export const updateConvoSubscriptions = async (
+    args: UpdateConvoSubscriptions
+): Promise<boolean> => {
+    const {context, sender, convoId, data} = args;
+
+    const getSubscriptionData = () => {
+        if (data.id) {
+            // contains message payload
+            return {message: data.id};
+        }
+        return data;
+    };
+
+    const subscriptionData = getSubscriptionData();
+
+    const publishToMessageTopic = async () => {
+        return publishMessageToTopic(context, [ChatMessage.name], {
+            convoId,
+            owner: sender,
+            ...subscriptionData,
+        });
+    };
+
+    try {
+        // send to message topic
+        await publishToMessageTopic();
+
+        // send to convo topics
+        const membersConvos: ChatConvoType[] = await ChatConvoModel.pagination({
+            select: chatConvoSelectors,
+            where: {convoId: {$eq: convoId}, owner: {$neq: sender}},
+        });
+
+        if (!isEmpty(membersConvos)) {
+            const isPublicChat = compact(membersConvos.map((c) => c.public));
+
+            if (!isEmpty(isPublicChat)) {
+                log(`updated subscriptions isPublicChat`);
+                return;
+            }
+
+            // push notification here
+
+            // update sockets, no need for results
+            await awaitTo(
+                Promise.all(
+                    membersConvos.map((convo) => {
+                        const pushmessage = {
+                            ...data,
+                            convoId,
+                            owner: convo.owner,
+                        };
+
+                        // unhandled promises
+                        if (!subscriptionData.typing) {
+                            sendPushNotification(sender, pushmessage);
+                        }
+
+                        // Send subscriptions to owners
+                        return publishMessageToTopic(context, [ChatConvo.name], {
+                            convoId,
+                            owner: convo.owner,
+                            ...subscriptionData,
+                        }); // update sockets
+                    })
+                )
+            );
+
+            log(
+                `updated subscriptions from=${sender} with data=${data}`,
+                membersConvos.map((uc) => uc.id)
+            );
+
+            // update sockets
+        }
+
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+export const removeUnreadCount = async (owner: string, convoId: string): Promise<any> => {
+    try {
+        const convos: ChatConvoType[] = await ChatConvoModel.pagination({
+            select: chatConvoSelectors,
+            where: {convoId: {$eq: convoId}, owner: {$eq: owner}},
+        });
+
+        if (!isEmpty(convos)) {
+            const convo = convos[0];
+            if (convo.unread > 0) {
+                convo.unread = 0; // remove the unread
+                await ChatConvoModel.updateById(convo.id, convo, {silent: true}); // do not updatedAt
+            }
+        }
+
+        return true;
+    } catch (err) {
+        log(err);
+        return false;
+    }
+};

package/src/chat/methods/ChatConvo.test.ts

@@ -0,0 +1,122 @@
+import 'reflect-metadata';
+import 'mocha';
+
+import {expect} from 'chai';
+import { getChatConvoById } from './ChatConvo.methods';
+import {startCouchbase} from '@roadmanjs/couchset';
+
+before((done) => {
+    startCouchbase().then(() => done());
+});
+
+describe('ChatConvo', () => {
+    // it('it should send a push notification to a user', async () => {
+    //     const senderId = '1c01d85f-b811-44b1-8a4f-bef8030bf265';
+    //     const convoId = 'b613b7c5-5f73-4331-8703-3a1176728a31';
+
+    //     const owner = '99bc43ba-02ab-4394-b48b-49a39a95443c';
+
+    //     const sendMessage = await sendPushNotification(senderId, {
+    //         owner,
+    //         convoId,
+    //         message: 'some message',
+    //     });
+    //     expect(sendMessage).to.not.be.empty;
+    // });
+    // it('it should create an new convo and return it', async () => {
+    //     const newConvo: ChatConvoType = {
+    //         owner: '1c01d85f-b811-44b1-8a4f-bef8030bf265',
+    //         members: [
+    //             '1c01d85f-b811-44b1-8a4f-bef8030bf265',
+    //             '0ac710ce-4530-4ea9-8f70-9d19383c95d4',
+    //         ],
+    //         group: true,
+    //     };
+
+    //     const newConvoCreated = await startConvo(newConvo);
+
+    //     console.log('new convo create', newConvoCreated);
+    //     console.log('new convo create members', newConvoCreated.data.members);
+
+    //     expect(newConvoCreated).to.be.not.empty;
+    // });
+
+    it("it should return chat convo with joins", async () => {
+        const convo = await getChatConvoById("d2bb6ba6-1bc5-480a-a3ae-c28bec3708bf", "1c01d85f-b811-44b1-8a4f-bef8030bf265");
+
+        console.log('convo with joins', convo);
+        expect(convo.members[0].id).to.be.not.empty;
+    })
+
+    // it("Create convo", async () => {
+    //   const owner = "1c01d85f-b811-44b1-8a4f-bef8030bf265";
+    //   const otherUser = "99bc43ba-02ab-4394-b48b-49a39a95443c";
+    //   const members = [owner, otherUser];
+
+    //   const chatConvo = {
+    //       members,
+    //       group: false,
+
+    //   };
+
+    //   const createdConvo = await createChatConvoType(chatConvo);
+
+    //   console.log("Created", createdConvo);
+    //   expect(createdConvo).to.not.be.empty;
+    // });
+
+    // it("Remove read count", async () => {
+    //   const owner = "1c01d85f-b811-44b1-8a4f-bef8030bf265";
+    //   const convoId = "b613b7c5-5f73-4331-8703-3a1176728a31";
+
+    //   const hasUpdateCount = await removeUnreadCount(owner, convoId);
+
+    //   console.log("Created", hasUpdateCount);
+    //   expect(hasUpdateCount).to.be.true;
+    // });
+
+    // it('Start public ChatConvo', async () => {
+    //     const id = 'rtv-1';
+
+    //     const publicConvo = await startPublicConvo(id);
+
+    //     console.log('Created', publicConvo);
+
+    //     expect(publicConvo.public).to.be.true;
+    // });
+
+    // it('GetConvoOwnerNAuth public convo', async () => {
+    //     const convoId = 'e8e15949-311e-4954-8701-3fe46cc21b98';
+    //     const mockContext = {
+    //         req: {
+    //             headers: {
+    //                 authorization: '',
+    //             },
+    //         },
+    //     };
+
+    //     const publicMessages = await getConvoOwnerNAuth(convoId, mockContext);
+
+    //     console.log('publicMessages', publicMessages);
+
+    //     expect(publicMessages).not.to.be.empty;
+    // });
+
+    // it('GetConvoOwnerNAuth private convo', async () => {
+    //     const convoId = 'e9992706-e854-4aef-bb5f-5e09d4224bf4';
+    //     const mockContext = {
+    //         req: {
+    //             headers: {
+    //                 authorization:
+    //                     'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiI5OWJjNDNiYS0wMmFiLTQzOTQtYjQ4Yi00OWEzOWE5NTQ0M2MiLCJpYXQiOjE2NjMyMTc2MjMsImV4cCI6MTY2MzQ3NjgyM30.zvCJo95goSCemwhvSEXF5nd3jIDhMZTfVrn9jUeo1OA',
+    //             },
+    //         },
+    //     };
+
+    //     const publicMessages = await getConvoOwnerNAuth(convoId, mockContext);
+
+    //     console.log('publicMessages', publicMessages);
+
+    //     expect(publicMessages).not.to.be.empty;
+    // });
+});