serene-core-server 0.1.1

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

@@ -0,0 +1,523 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatMessageModel = void 0;
+const encrypt_service_1 = require("../../services/access/encrypt-service");
+const errors_1 = require("../../types/errors");
+class ChatMessageModel {
+    // Code
+    constructor(encryptionKey) {
+        // Consts
+        this.clName = 'ChatMessageModel';
+        this.msPerMinute = 60000;
+        this.encrypter = new encrypt_service_1.Encrypter(encryptionKey);
+    }
+    countMessages(prisma, userProfileId, startDate, sentByAi) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.countMessages()`;
+            // Query
+            const count = yield prisma.chatMessage.count({
+                where: {
+                    sentByAi: sentByAi,
+                    chatSession: {
+                        createdById: userProfileId,
+                    },
+                    created: {
+                        gte: startDate,
+                    },
+                },
+            });
+            // Return
+            return count;
+        });
+    }
+    create(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.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 = yield 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;
+        });
+    }
+    deleteByChatSessionId(prisma, chatSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByChatSessionId()`;
+            // Delete records
+            try {
+                yield prisma.chatMessage.deleteMany({
+                    where: {
+                        chatSessionId: chatSessionId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteById()`;
+            // Delete record
+            try {
+                yield prisma.chatMessage.delete({
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma, id, chatSession) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Query record
+            var chatMessage = undefined;
+            try {
+                chatMessage = yield 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;
+        });
+    }
+    getByChatSessionId(prisma, chatSession, maxPrevMessages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 = yield 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 = yield 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;
+        });
+    }
+    getByChatSessionAndExternalId(prisma, chatSession, externalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByChatSessionIdAndExternalId()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatSessionId == null`);
+            }
+            if (externalId == null) {
+                throw new errors_1.CustomError(`${fnName}: externalId == null`);
+            }
+            // Query record
+            var chatMessage = undefined;
+            try {
+                chatMessage = yield 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;
+        });
+    }
+    getByLastMessageId(prisma, chatSession, lastMessageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByLastMessageId()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Get the last message if specified
+            var lastMessageCreated = new Date();
+            if (lastMessageId != null) {
+                const lastMessage = yield this.getById(prisma, lastMessageId, chatSession);
+                if (lastMessage != null) {
+                    lastMessageCreated = lastMessage.created;
+                }
+            }
+            // Query records
+            var chatMessages = [];
+            try {
+                chatMessages = yield 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;
+        });
+    }
+    getEarliestUnread(prisma, chatSession) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getEarliestUnread()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Query record
+            var chatMessage = undefined;
+            try {
+                chatMessage = yield 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;
+        });
+    }
+    getFirst(prisma, chatSession) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getFirst()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Query record
+            var chatMessage = undefined;
+            try {
+                chatMessage = yield 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;
+        });
+    }
+    getLast(prisma, chatSession) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getLast()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Query record
+            var chatMessage = undefined;
+            try {
+                chatMessage = yield 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;
+        });
+    }
+    setExternalId(prisma, id, externalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.setExternalId()`;
+            // Validate
+            if (id == null) {
+                throw new errors_1.CustomError(`${fnName}: id == null`);
+            }
+            if (externalId === undefined) {
+                throw new errors_1.CustomError(`${fnName}: externalId == null`);
+            }
+            // Update record
+            try {
+                return yield 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;
+            }
+        });
+    }
+    update(prisma, id, chatSession, replyToId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Validate
+            if (chatSession == null) {
+                throw new errors_1.CustomError(`${fnName}: chatMessage == null`);
+            }
+            // Encrypt the message if required
+            if (message != null &&
+                chatSession.isEncryptedAtRest === true) {
+                message = this.encrypter.encrypt(message);
+            }
+            // Update record
+            try {
+                return yield 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';
+            }
+        });
+    }
+    upsert(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.upsert()`;
+            // If the id is specified, try to get it
+            if (id != null) {
+                const chatMessage = yield 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 yield this.create(prisma, id, chatSession, replyToId, fromUserProfileId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message);
+            }
+            else {
+                // Update
+                return yield this.update(prisma, id, chatSession, replyToId, fromChatParticipantId, toChatParticipantId, externalId, sentByAi, message);
+            }
+        });
+    }
+}
+exports.ChatMessageModel = ChatMessageModel;

package/dist/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;
+    }>;
+}