add methods to add a conversation and a new message

Author: AlexNi245

packages/backend/src/persistance/getDatabase.ts

@@ -17,6 +17,11 @@ import Session from './session';
 import Storage from './storage';
 import Otp from './otp';
 import { syncAcknowledge } from './messages/syncAcknowledge';
+import { PrismaClient } from '@prisma/client';
+import { addConversation } from './storage/postgres/addConversation';
+import { getConversationList } from './storage/postgres/getConversationList';
+import { addMessage } from './storage/postgres/addMessage';
+import { getMessages } from './storage/postgres/getMessages';
 
 export enum RedisPrefix {
     Conversation = 'conversation:',
@@ -59,8 +64,16 @@ export async function getRedisClient() {
     return client;
 }
 
-export async function getDatabase(_redis?: Redis): Promise<IDatabase> {
+export async function getPrismaClient() {
+    return new PrismaClient();
+}
+
+export async function getDatabase(
+    _redis?: Redis,
+    _prisma?: PrismaClient,
+): Promise<IDatabase> {
     const redis = _redis ?? (await getRedisClient());
+    const prisma = _prisma ?? (await getPrismaClient());
 
     return {
         //Messages
@@ -104,6 +117,12 @@ export async function getDatabase(_redis?: Redis): Promise<IDatabase> {
         setOtp: Otp.setOtp(redis),
         getOtp: Otp.getOtp(redis),
         resetOtp: Otp.resetOtp(redis),
+        //Storage AddConversation
+        storage_addConversation: addConversation(prisma),
+        storage_getConversationList: getConversationList(prisma),
+        //Storage Add Messages
+        storage_addMessage: addMessage(prisma),
+        storage_getMessages: getMessages(prisma),
     };
 }
 
@@ -194,6 +213,23 @@ export interface IDatabase {
         ensName: string,
         channelType: NotificationChannelType,
     ) => Promise<void>;
+
+    storage_addConversation: (
+        ensName: string,
+        encryptedContactName: string,
+    ) => Promise<boolean>;
+    storage_getConversationList: (ensName: string) => Promise<string[]>;
+    storage_addMessage: (
+        ensName: string,
+        encryptedContactName: string,
+        messageId: string,
+        encryptedEnvelopContainer: string,
+    ) => Promise<boolean>;
+    storage_getMessages: (
+        ensName: string,
+        encryptedContactName: string,
+        page: number,
+    ) => Promise<string[]>;
 }
 
 export type Redis = Awaited<ReturnType<typeof getRedisClient>>;

packages/backend/src/persistance/storage/postgres/addConversation.ts

@@ -1,9 +1,41 @@
 import { PrismaClient } from '@prisma/client';
 export const addConversation =
-    (db: PrismaClient) => async (contactName: string) => {
-        await db.conversation.create({
-            data: {
-                id: contactName,
-            },
-        });
+    (db: PrismaClient) => async (ensName: string, contactName: string) => {
+        try {
+            let account = await db.account.findFirst({
+                where: {
+                    id: ensName,
+                },
+            });
+
+            if (!account) {
+                //Create account
+                account = await db.account.create({
+                    data: {
+                        id: ensName,
+                    },
+                });
+            }
+
+            const conversationAlreadyExists = await db.conversation.findFirst({
+                where: {
+                    accountId: ensName,
+                    encryptedId: contactName,
+                },
+            });
+
+            if (!conversationAlreadyExists) {
+                await db.conversation.create({
+                    data: {
+                        encryptedId: contactName,
+                        accountId: ensName,
+                    },
+                });
+            }
+
+            return true;
+        } catch (e) {
+            console.log('addConversation error ', e);
+            return false;
+        }
     };

packages/backend/src/persistance/storage/postgres/addMessage.ts

@@ -0,0 +1,57 @@
+import { PrismaClient } from '@prisma/client';
+
+export const addMessage =
+    (db: PrismaClient) =>
+    async (
+        ensName: string,
+        contactName: string,
+        messageId: string,
+        encryptedEnvelopContainer: string,
+    ) => {
+        try {
+            let account = await db.account.findFirst({
+                where: {
+                    id: ensName,
+                },
+            });
+
+            if (!account) {
+                //Create account
+                account = await db.account.create({
+                    data: {
+                        id: ensName,
+                    },
+                });
+            }
+
+            let conversation = await db.conversation.findFirst({
+                where: {
+                    accountId: ensName,
+                    encryptedId: contactName,
+                },
+            });
+
+            if (!conversation) {
+                conversation = await db.conversation.create({
+                    data: {
+                        encryptedId: contactName,
+                        accountId: ensName,
+                    },
+                });
+            }
+            console.log('conversation', conversation);
+
+            await db.encryptedMessage.create({
+                data: {
+                    id: messageId,
+                    conversationId: conversation.encryptedId,
+                    encryptedEnvelopContainer,
+                },
+            });
+
+            return true;
+        } catch (e) {
+            console.log('addMessage error ', e);
+            return false;
+        }
+    };

packages/backend/src/persistance/storage/postgres/getConversationList.ts

@@ -0,0 +1,20 @@
+import { PrismaClient } from '@prisma/client';
+export const getConversationList =
+    (db: PrismaClient) => async (ensName: string) => {
+        const account = await db.account.findFirst({
+            where: {
+                id: ensName,
+            },
+        });
+        if (!account) {
+            return [];
+        }
+        console.log('get conversations for ', ensName);
+        const conversations = await db.conversation.findMany({
+            where: {
+                accountId: ensName,
+            },
+        });
+        console.log('get conversations ', conversations);
+        return conversations.map((c) => c.encryptedId);
+    };

packages/backend/src/persistance/storage/postgres/getMessages.ts

@@ -0,0 +1,28 @@
+import { PrismaClient } from '@prisma/client';
+
+const PAGE_SIZE = 100;
+
+export const getMessages =
+    (db: PrismaClient) =>
+    async (ensName: string, contactName: string, page: number) => {
+        const conversation = await db.conversation.findFirst({
+            where: {
+                accountId: ensName,
+                encryptedId: contactName,
+            },
+        });
+
+        if (!conversation) {
+            return [];
+        }
+
+        const messages = await db.encryptedMessage.findMany({
+            skip: page * PAGE_SIZE,
+            take: PAGE_SIZE,
+            where: {
+                conversationId: conversation.encryptedId,
+            },
+        });
+
+        return messages.map((m) => m.encryptedEnvelopContainer);
+    };