serene-core-server 0.1.1

package/dist/src/models/chat/chat-message-model.js

@@ -0,0 +1,484 @@
+import { Encrypter } from '../../services/access/encrypt-service';
+import { CustomError } from '../../types/errors';
+export class ChatMessageModel {
+    // Consts
+    clName = 'ChatMessageModel';
+    msPerMinute = 60000;
+    // Services
+    encrypter;
+    // Code
+    constructor(encryptionKey) {
+        this.encrypter = new Encrypter(encryptionKey);
+    }
+    async countMessages(prisma, userProfileId, startDate, sentByAi) {
+        // Debug
+        const fnName = `${this.clName}.countMessages()`;
+        // Query
+        const count = await prisma.chatMessage.count({
+            where: {
+                sentByAi: sentByAi,
+                chatSession: {
+                    createdById: userProfileId,
+                },
+                created: {
+                    gte: startDate,
+                },
+            },
+        });
+        // Return
+        return count;
+    }
+    async create(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Encrypt the message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            message = this.encrypter.encrypt(message);
+        }
+        // Create record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.create({
+                data: {
+                    id: id,
+                    chatSessionId: chatSession.id,
+                    replyToId: replyToId,
+                    fromChatParticipantId: fromChatParticipantId,
+                    toChatParticipantId: toChatParticipantId,
+                    externalId: externalId,
+                    sentByAi: sentByAi,
+                    message: message
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return chatMessage;
+    }
+    async deleteByChatSessionId(prisma, chatSessionId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByChatSessionId()`;
+        // Delete records
+        try {
+            await prisma.chatMessage.deleteMany({
+                where: {
+                    chatSessionId: chatSessionId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.deleteById()`;
+        // Delete record
+        try {
+            await prisma.chatMessage.delete({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id, chatSession) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Query record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypt message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+        }
+        // Return OK
+        return chatMessage;
+    }
+    async getByChatSessionId(prisma, chatSession, maxPrevMessages) {
+        // Debug
+        const fnName = `${this.clName}.getByChatSessionId()`;
+        // Validate
+        if (chatSession == null) {
+            console.error(`${fnName}: chatSessionId == null`);
+            throw 'Prisma error';
+        }
+        if (chatSession.id == null) {
+            console.error(`${fnName}: chatSession.id == null`);
+            throw 'Prisma error';
+        }
+        // Query records
+        var chatMessages = [];
+        if (maxPrevMessages == null) {
+            // No max prev messages; get all messages
+            try {
+                chatMessages = await prisma.chatMessage.findMany({
+                    where: {
+                        chatSessionId: chatSession.id
+                    },
+                    orderBy: [
+                        {
+                            created: 'asc'
+                        }
+                    ]
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        else {
+            // Limit by max prev messages
+            try {
+                chatMessages = await prisma.chatMessage.findMany({
+                    take: maxPrevMessages,
+                    where: {
+                        chatSessionId: chatSession.id
+                    },
+                    orderBy: [
+                        {
+                            created: 'desc'
+                        }
+                    ]
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            chatMessages.reverse();
+        }
+        // Decrypts message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            for (const chatMessage of chatMessages) {
+                chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+            }
+        }
+        // Return
+        return chatMessages;
+    }
+    async getByChatSessionAndExternalId(prisma, chatSession, externalId) {
+        // Debug
+        const fnName = `${this.clName}.getByChatSessionIdAndExternalId()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatSessionId == null`);
+        }
+        if (externalId == null) {
+            throw new CustomError(`${fnName}: externalId == null`);
+        }
+        // Query record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.findFirst({
+                where: {
+                    chatSessionId: chatSession.id,
+                    externalId: externalId
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypt message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+        }
+        // Return OK
+        return chatMessage;
+    }
+    async getByLastMessageId(prisma, chatSession, lastMessageId) {
+        // Debug
+        const fnName = `${this.clName}.getByLastMessageId()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Get the last message if specified
+        var lastMessageCreated = new Date();
+        if (lastMessageId != null) {
+            const lastMessage = await this.getById(prisma, lastMessageId, chatSession);
+            if (lastMessage != null) {
+                lastMessageCreated = lastMessage.created;
+            }
+        }
+        // Query records
+        var chatMessages = [];
+        try {
+            chatMessages = await prisma.chatMessage.findMany({
+                where: {
+                    chatSessionId: chatSession.id,
+                    created: {
+                        gt: lastMessageCreated
+                    }
+                },
+                orderBy: [
+                    {
+                        created: 'asc'
+                    }
+                ]
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypts message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            for (const chatMessage of chatMessages) {
+                chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+            }
+        }
+        // Return
+        return chatMessages;
+    }
+    async getEarliestUnread(prisma, chatSession) {
+        // Debug
+        const fnName = `${this.clName}.getEarliestUnread()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Query record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.findFirst({
+                where: {
+                    chatSessionId: chatSession.id,
+                    sentByAi: true
+                },
+                orderBy: [
+                    {
+                        created: 'desc'
+                    }
+                ]
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypt message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+        }
+        // Return OK
+        return chatMessage;
+    }
+    async getFirst(prisma, chatSession) {
+        // Debug
+        const fnName = `${this.clName}.getFirst()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Query record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.findFirst({
+                where: {
+                    chatSessionId: chatSession.id
+                },
+                orderBy: [
+                    {
+                        created: 'asc'
+                    }
+                ]
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypt message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+        }
+        // Return OK
+        return chatMessage;
+    }
+    async getLast(prisma, chatSession) {
+        // Debug
+        const fnName = `${this.clName}.getLast()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Query record
+        var chatMessage = undefined;
+        try {
+            chatMessage = await prisma.chatMessage.findFirst({
+                where: {
+                    chatSessionId: chatSession.id
+                },
+                orderBy: [
+                    {
+                        created: 'desc'
+                    }
+                ]
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Decrypt message if required
+        if (chatSession.isEncryptedAtRest === true) {
+            chatMessage.message = this.encrypter.decrypt(chatMessage.message);
+        }
+        // Return OK
+        return chatMessage;
+    }
+    async setExternalId(prisma, id, externalId) {
+        // Debug
+        const fnName = `${this.clName}.setExternalId()`;
+        // Validate
+        if (id == null) {
+            throw new CustomError(`${fnName}: id == null`);
+        }
+        if (externalId === undefined) {
+            throw new CustomError(`${fnName}: externalId == null`);
+        }
+        // Update record
+        try {
+            return await prisma.chatMessage.update({
+                data: {
+                    externalId: externalId
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            // Don't fail, this can happen due to a unique constraint violation in
+            // some valid scenarios.
+            // Trying to handle the specific Prisma error code didn't work
+            console.warn(`${fnName}: warning: ` + JSON.stringify(error));
+            return null;
+        }
+    }
+    async update(prisma, id, chatSession, replyToId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Validate
+        if (chatSession == null) {
+            throw new CustomError(`${fnName}: chatMessage == null`);
+        }
+        // Encrypt the message if required
+        if (message != null &&
+            chatSession.isEncryptedAtRest === true) {
+            message = this.encrypter.encrypt(message);
+        }
+        // Update record
+        try {
+            return await prisma.chatMessage.update({
+                data: {
+                    chatSessionId: chatSession.id,
+                    replyToId: replyToId,
+                    fromChatParticipantId: fromChatParticipantId,
+                    toChatParticipantId: toChatParticipantId,
+                    externalId: externalId,
+                    sentByAi: sentByAi,
+                    message: message
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If the id is specified, try to get it
+        if (id != null) {
+            const chatMessage = await this.getById(prisma, id, chatSession);
+            if (chatMessage != null) {
+                id = chatMessage.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (replyToId === undefined) {
+                console.error(`${fnName}: id is null and replyToId is undefined`);
+                throw 'Prisma error';
+            }
+            if (fromUserProfileId == null) {
+                console.error(`${fnName}: id is null and fromUserProfileId is null`);
+                throw 'Prisma error';
+            }
+            if (fromChatParticipantId === undefined) {
+                console.error(`${fnName}: id is null and fromChatParticipantId is undefined`);
+                throw 'Prisma error';
+            }
+            if (toChatParticipantId === undefined) {
+                console.error(`${fnName}: id is null and toChatParticipantId is undefined`);
+                throw 'Prisma error';
+            }
+            if (externalId === undefined) {
+                console.error(`${fnName}: id is null and externalId is undefined`);
+                throw 'Prisma error';
+            }
+            if (sentByAi === undefined) {
+                console.error(`${fnName}: id is null and sentByAi is undefined`);
+                throw 'Prisma error';
+            }
+            if (message === undefined) {
+                console.error(`${fnName}: id is null and message is undefined`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, chatSession, replyToId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message);
+        }
+    }
+}

package/dist/src/models/chat/chat-participant-model.d.ts

@@ -0,0 +1,39 @@
+import { PrismaClient } from '@/prisma/client';
+import { UsersService } from '../../services/users/service';
+export declare class ChatParticipantModel {
+    clName: string;
+    usersService: UsersService;
+    create(prisma: PrismaClient, id: string | undefined, chatSessionId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    }>;
+    deleteByChatSessionId(prisma: PrismaClient, chatSessionId: string): Promise<void>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByChatSessionId(prisma: PrismaClient, chatSessionId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    }[] | undefined>;
+    getByChatSessionIdAndOwnerType(prisma: PrismaClient, chatSessionId: string, ownerType: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    } | null | undefined>;
+    getByChatSessionIdAndUserProfileId(prisma: PrismaClient, chatSessionId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    } | null | undefined>;
+    getParticipantTypeByUserProfileId(prisma: PrismaClient, userProfileId: string): Promise<string | null>;
+    update(prisma: PrismaClient, id: string, chatSessionId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, chatSessionId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        chatSessionId: string;
+    }>;
+}

package/dist/src/models/chat/chat-participant-model.js

@@ -0,0 +1,178 @@
+import { CustomError } from '../../types/errors';
+import { UsersService } from '../../services/users/service';
+export class ChatParticipantModel {
+    // Consts
+    clName = 'ChatParticipantModel';
+    // Services
+    usersService = new UsersService();
+    // Code
+    async create(prisma, id, chatSessionId, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Validate
+        if (userProfileId == null) {
+            console.error(`${fnName}: userProfileId not specified`);
+            throw `Validation error`;
+        }
+        // Create record
+        try {
+            return await prisma.chatParticipant.create({
+                data: {
+                    id: id,
+                    chatSessionId: chatSessionId,
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteByChatSessionId(prisma, chatSessionId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByChatSessionId()`;
+        // Delete records
+        try {
+            await prisma.chatParticipant.deleteMany({
+                where: {
+                    chatSessionId: chatSessionId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query record
+        var chatParticipant = undefined;
+        try {
+            chatParticipant = await prisma.chatParticipant.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return OK
+        return chatParticipant;
+    }
+    async getByChatSessionId(prisma, chatSessionId) {
+        // Debug
+        const fnName = `${this.clName}.getByChatSessionId()`;
+        // Get by chatSessionId
+        // Query records
+        try {
+            return await prisma.chatParticipant.findMany({
+                where: {
+                    chatSessionId: chatSessionId
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async getByChatSessionIdAndOwnerType(prisma, chatSessionId, ownerType) {
+        // Debug
+        const fnName = `${this.clName}.getByChatSessionId()`;
+        // Query record
+        try {
+            return await prisma.chatParticipant.findFirst({
+                where: {
+                    chatSessionId: chatSessionId,
+                    userProfile: {
+                        ownerType: ownerType
+                    }
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async getByChatSessionIdAndUserProfileId(prisma, chatSessionId, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.getByChatSessionId()`;
+        // Query record
+        try {
+            return await prisma.chatParticipant.findFirst({
+                where: {
+                    chatSessionId: chatSessionId,
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async getParticipantTypeByUserProfileId(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.getParticipantTypeByUserProfileId()`;
+        // Query record
+        const userProfile = await this.usersService.getById(prisma, userProfileId);
+        // Validate
+        if (userProfile == null) {
+            throw new CustomError(`${fnName}: userProfile == null`);
+        }
+        // Return OK
+        return userProfile.ownerType;
+    }
+    async update(prisma, id, chatSessionId, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Create record
+        try {
+            return await prisma.chatParticipant.update({
+                data: {
+                    chatSessionId: chatSessionId,
+                    userProfileId: userProfileId
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, chatSessionId, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If the id is specified, try to get it
+        if (id != null) {
+            const chatParticipant = await this.getById(prisma, id);
+            if (chatParticipant != null) {
+                id = chatParticipant.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            return await this.create(prisma, id, chatSessionId, userProfileId);
+        }
+        else {
+            return await this.update(prisma, id, chatSessionId, userProfileId);
+        }
+    }
+}