serene-core-server 0.1.1

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

@@ -0,0 +1,211 @@
+"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.ChatParticipantModel = void 0;
+const errors_1 = require("../../types/errors");
+const service_1 = require("../../services/users/service");
+class ChatParticipantModel {
+    constructor() {
+        // Consts
+        this.clName = 'ChatParticipantModel';
+        // Services
+        this.usersService = new service_1.UsersService();
+    }
+    // Code
+    create(prisma, id, chatSessionId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Validate
+            if (userProfileId == null) {
+                console.error(`${fnName}: userProfileId not specified`);
+                throw `Validation error`;
+            }
+            // Create record
+            try {
+                return yield prisma.chatParticipant.create({
+                    data: {
+                        id: id,
+                        chatSessionId: chatSessionId,
+                        userProfileId: userProfileId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteByChatSessionId(prisma, chatSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByChatSessionId()`;
+            // Delete records
+            try {
+                yield prisma.chatParticipant.deleteMany({
+                    where: {
+                        chatSessionId: chatSessionId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query record
+            var chatParticipant = undefined;
+            try {
+                chatParticipant = yield 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;
+        });
+    }
+    getByChatSessionId(prisma, chatSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByChatSessionId()`;
+            // Get by chatSessionId
+            // Query records
+            try {
+                return yield prisma.chatParticipant.findMany({
+                    where: {
+                        chatSessionId: chatSessionId
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    getByChatSessionIdAndOwnerType(prisma, chatSessionId, ownerType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByChatSessionId()`;
+            // Query record
+            try {
+                return yield prisma.chatParticipant.findFirst({
+                    where: {
+                        chatSessionId: chatSessionId,
+                        userProfile: {
+                            ownerType: ownerType
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    getByChatSessionIdAndUserProfileId(prisma, chatSessionId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByChatSessionId()`;
+            // Query record
+            try {
+                return yield prisma.chatParticipant.findFirst({
+                    where: {
+                        chatSessionId: chatSessionId,
+                        userProfileId: userProfileId
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    getParticipantTypeByUserProfileId(prisma, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getParticipantTypeByUserProfileId()`;
+            // Query record
+            const userProfile = yield this.usersService.getById(prisma, userProfileId);
+            // Validate
+            if (userProfile == null) {
+                throw new errors_1.CustomError(`${fnName}: userProfile == null`);
+            }
+            // Return OK
+            return userProfile.ownerType;
+        });
+    }
+    update(prisma, id, chatSessionId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Create record
+            try {
+                return yield prisma.chatParticipant.update({
+                    data: {
+                        chatSessionId: chatSessionId,
+                        userProfileId: userProfileId
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, chatSessionId, userProfileId) {
+        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 chatParticipant = yield this.getById(prisma, id);
+                if (chatParticipant != null) {
+                    id = chatParticipant.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                return yield this.create(prisma, id, chatSessionId, userProfileId);
+            }
+            else {
+                return yield this.update(prisma, id, chatSessionId, userProfileId);
+            }
+        });
+    }
+}
+exports.ChatParticipantModel = ChatParticipantModel;

package/dist/models/chat/chat-session-model.d.ts

@@ -0,0 +1,92 @@
+import { PrismaClient } from '@prisma/client';
+export declare class ChatSessionModel {
+    clName: string;
+    create(prisma: PrismaClient, id: string | undefined, chatSettingsId: string, instanceId: string | null, status: string, isEncryptedAtRest: boolean, name: string | null, externalIntegration: string | null, externalId: string | null, createdById: string): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }>;
+    deleteById(prisma: PrismaClient, id: string): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }>;
+    deleteByIdCascade(prisma: PrismaClient, id: string): Promise<void>;
+    deleteByInstanceId(prisma: PrismaClient, instanceId: string): Promise<void>;
+    filter(prisma: PrismaClient, instanceId: string | null | undefined, status: string | undefined, isEncryptedAtRest: boolean | undefined, externalIntegration: string | null | undefined, createdById: string | undefined): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }[] | undefined>;
+    getByDaysAgo(prisma: PrismaClient, daysAgo: number, status?: string | undefined): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }[] | undefined>;
+    getByExternalIntegrationAndExternalId(prisma: PrismaClient, externalIntegration: string, externalId: string, includeChatSettings?: boolean): Promise<any>;
+    getById(prisma: PrismaClient, id: string, includeChatSettings?: boolean): Promise<any>;
+    update(prisma: PrismaClient, id: string, chatSettingsId: string | undefined, instanceId: string | null | undefined, status: string | undefined, isEncryptedAtRest: boolean | undefined, name: string | null | undefined, externalIntegration: string | null | undefined, externalId: string | null | undefined, createdById: string | undefined): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }>;
+    upsert(prisma: PrismaClient, id: string, chatSettingsId: string | undefined, instanceId: string | null | undefined, status: string | undefined, isEncryptedAtRest: boolean | undefined, name: string | null | undefined, externalIntegration: string | null | undefined, externalId: string | null | undefined, createdById: string): Promise<{
+        name: string | null;
+        id: string;
+        status: string;
+        token: string;
+        externalIntegration: string | null;
+        created: Date;
+        updated: Date;
+        externalId: string | null;
+        instanceId: string | null;
+        chatSettingsId: string;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+    }>;
+}

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

@@ -0,0 +1,301 @@
+"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.ChatSessionModel = void 0;
+const { v4: uuidv4 } = require('uuid');
+const errors_1 = require("../../types/errors");
+const chat_participant_model_1 = require("./chat-participant-model");
+// Models
+const chatParticipantModel = new chat_participant_model_1.ChatParticipantModel();
+// Class
+class ChatSessionModel {
+    constructor() {
+        // Consts
+        this.clName = 'ChatSessionModel';
+    }
+    // Code
+    create(prisma, id, chatSettingsId, instanceId, status, isEncryptedAtRest, name, externalIntegration, externalId, createdById) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Generate a token
+            const token = uuidv4();
+            // Create record
+            try {
+                return yield prisma.chatSession.create({
+                    data: {
+                        id: id,
+                        chatSettingsId: chatSettingsId,
+                        instanceId: instanceId,
+                        status: status,
+                        isEncryptedAtRest: isEncryptedAtRest,
+                        token: token,
+                        name: name,
+                        externalIntegration: externalIntegration,
+                        externalId: externalId,
+                        createdById: createdById
+                    }
+                });
+            }
+            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 chat session
+            try {
+                return yield prisma.chatSession.delete({
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteByIdCascade(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByIdCascade()`;
+            // Delete chat messages (code copied directly from chat-message-model.ts
+            // to avoid setting the encryption key via the constructor).
+            try {
+                yield prisma.chatMessage.deleteMany({
+                    where: {
+                        chatSessionId: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Delete chat participants
+            yield chatParticipantModel.deleteByChatSessionId(prisma, id);
+            // Delete chat session
+            yield this.deleteById(prisma, id);
+        });
+    }
+    deleteByInstanceId(prisma, instanceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByInstanceId()`;
+            // Get records for the instanceId
+            const chatSessions = yield this.filter(prisma, instanceId, undefined, undefined, undefined, undefined);
+            // Validate
+            if (chatSessions == null) {
+                throw new errors_1.CustomError(`${fnName}: chatSessions == null`);
+            }
+            // Delete cascade each chat session
+            for (const chatSession of chatSessions) {
+                yield this.deleteByIdCascade(prisma, chatSession.id);
+            }
+        });
+    }
+    filter(prisma, instanceId, status, isEncryptedAtRest, externalIntegration, createdById) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.filter()`;
+            // Query records
+            try {
+                return yield prisma.chatSession.findMany({
+                    where: {
+                        instanceId: instanceId,
+                        status: status,
+                        isEncryptedAtRest: isEncryptedAtRest,
+                        externalIntegration: externalIntegration,
+                        createdById: createdById
+                    },
+                    orderBy: [
+                        {
+                            created: 'desc'
+                        }
+                    ]
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    getByDaysAgo(prisma_1, daysAgo_1) {
+        return __awaiter(this, arguments, void 0, function* (prisma, daysAgo, status = undefined) {
+            // Debug
+            const fnName = `${this.clName}.getByDaysAgo()`;
+            // Days ago
+            const day = 1000 * 60 * 60 * 24;
+            const daysAgoTime = day * daysAgo;
+            const daysAgoDate = new Date(new Date().getTime() - daysAgoTime);
+            // Query records
+            try {
+                return yield prisma.chatSession.findMany({
+                    where: {
+                        status: status,
+                        created: {
+                            lt: daysAgoDate
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    getByExternalIntegrationAndExternalId(prisma_1, externalIntegration_1, externalId_1) {
+        return __awaiter(this, arguments, void 0, function* (prisma, externalIntegration, externalId, includeChatSettings = false) {
+            // Debug
+            const fnName = `${this.clName}.getByExternalIntegrationAndExternalId()`;
+            // Query record
+            var chatSession = undefined;
+            try {
+                chatSession = yield prisma.chatSession.findFirst({
+                    include: {
+                        chatSettings: includeChatSettings
+                    },
+                    where: {
+                        externalIntegration: externalIntegration,
+                        externalId: externalId
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+            // Return OK
+            return chatSession;
+        });
+    }
+    getById(prisma_1, id_1) {
+        return __awaiter(this, arguments, void 0, function* (prisma, id, includeChatSettings = false) {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query record
+            var chatSession = undefined;
+            try {
+                chatSession = yield prisma.chatSession.findUnique({
+                    include: {
+                        chatSettings: includeChatSettings
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+            // Return OK
+            return chatSession;
+        });
+    }
+    update(prisma, id, chatSettingsId, instanceId, status, isEncryptedAtRest, name, externalIntegration, externalId, createdById) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Update record
+            try {
+                return yield prisma.chatSession.update({
+                    data: {
+                        chatSettingsId: chatSettingsId,
+                        instanceId: instanceId,
+                        status: status,
+                        isEncryptedAtRest: isEncryptedAtRest,
+                        name: name,
+                        externalIntegration: externalIntegration,
+                        externalId: externalId,
+                        createdById: createdById
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, chatSettingsId, instanceId, status, isEncryptedAtRest, name, externalIntegration, externalId, createdById) {
+        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 chatSession = yield this.getById(prisma, id);
+                if (chatSession != null) {
+                    id = chatSession.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                // Validate for create (mainly for type validation of the create call)
+                if (chatSettingsId == null) {
+                    console.error(`${fnName}: id is null and chatSettingsId is null`);
+                    throw 'Prisma error';
+                }
+                if (instanceId === undefined) {
+                    console.error(`${fnName}: id is null and instanceId is undefined`);
+                    throw 'Prisma error';
+                }
+                if (status == null) {
+                    console.error(`${fnName}: id is null and status is null`);
+                    throw 'Prisma error';
+                }
+                if (name === undefined) {
+                    console.error(`${fnName}: id is null and name is undefined`);
+                    throw 'Prisma error';
+                }
+                if (externalIntegration === undefined) {
+                    console.error(`${fnName}: id is null and externalIntegration is undefined`);
+                    throw 'Prisma error';
+                }
+                if (externalId === undefined) {
+                    console.error(`${fnName}: id is null and externalId is undefined`);
+                    throw 'Prisma error';
+                }
+                if (isEncryptedAtRest == null) {
+                    console.error(`${fnName}: id is null and isEncryptedAtRest is null`);
+                    throw 'Prisma error';
+                }
+                // Create
+                return yield this.create(prisma, undefined, // id
+                chatSettingsId, instanceId, status, isEncryptedAtRest, name, externalIntegration, externalId, createdById);
+            }
+            else {
+                // Update
+                return yield this.update(prisma, id, chatSettingsId, instanceId, status, isEncryptedAtRest, name, externalIntegration, externalId, createdById);
+            }
+        });
+    }
+}
+exports.ChatSessionModel = ChatSessionModel;

package/dist/models/chat/chat-settings-model.d.ts

@@ -0,0 +1,87 @@
+import { PrismaClient } from '@prisma/client';
+export declare class ChatSettingsModel {
+    clName: string;
+    create(prisma: PrismaClient, baseChatSettingsId: string | null, status: string, isEncryptedAtRest: boolean, isJsonMode: boolean, isPinned: boolean, name: string | null, agentUserId: string, prompt: string | null, appCustom: any | null, createdById: string): Promise<{
+        name: string | null;
+        id: string;
+        prompt: string | null;
+        status: string;
+        created: Date;
+        updated: Date;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+        baseChatSettingsId: string | null;
+        isJsonMode: boolean;
+        isPinned: boolean;
+        agentUserId: string;
+        agentRole: string | null;
+        appCustom: import("@prisma/client/runtime/library").JsonValue | null;
+    }>;
+    deleteById(prisma: PrismaClient, id: string): Promise<void>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByName(prisma: PrismaClient, name: string): Promise<any>;
+    getByBaseChatSettingsId(prisma: PrismaClient, baseChatSettingsId: string | null | undefined): Promise<{
+        name: string | null;
+        id: string;
+        prompt: string | null;
+        status: string;
+        created: Date;
+        updated: Date;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+        baseChatSettingsId: string | null;
+        isJsonMode: boolean;
+        isPinned: boolean;
+        agentUserId: string;
+        agentRole: string | null;
+        appCustom: import("@prisma/client/runtime/library").JsonValue | null;
+    }[]>;
+    getUnused(prisma: PrismaClient): Promise<{
+        name: string | null;
+        id: string;
+        prompt: string | null;
+        status: string;
+        created: Date;
+        updated: Date;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+        baseChatSettingsId: string | null;
+        isJsonMode: boolean;
+        isPinned: boolean;
+        agentUserId: string;
+        agentRole: string | null;
+        appCustom: import("@prisma/client/runtime/library").JsonValue | null;
+    }[]>;
+    update(prisma: PrismaClient, id: string, baseChatSettingsId: string | null | undefined, status: string | undefined, isEncryptedAtRest: boolean | undefined, isJsonMode: boolean | undefined, isPinned: boolean | undefined, name: string | null | undefined, agentUserId: string | undefined, prompt: string | null | undefined, appCustom: any | null | undefined, createdById: string | undefined): Promise<{
+        name: string | null;
+        id: string;
+        prompt: string | null;
+        status: string;
+        created: Date;
+        updated: Date;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+        baseChatSettingsId: string | null;
+        isJsonMode: boolean;
+        isPinned: boolean;
+        agentUserId: string;
+        agentRole: string | null;
+        appCustom: import("@prisma/client/runtime/library").JsonValue | null;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, baseChatSettingsId: string | null | undefined, status: string | undefined, isEncryptedAtRest: boolean | undefined, isJsonMode: boolean | undefined, isPinned: boolean | undefined, name: string | null | undefined, agentUserId: string | undefined, prompt: string | null | undefined, appCustom: any | null | undefined, createdById: string | undefined): Promise<{
+        name: string | null;
+        id: string;
+        prompt: string | null;
+        status: string;
+        created: Date;
+        updated: Date;
+        isEncryptedAtRest: boolean;
+        createdById: string;
+        baseChatSettingsId: string | null;
+        isJsonMode: boolean;
+        isPinned: boolean;
+        agentUserId: string;
+        agentRole: string | null;
+        appCustom: import("@prisma/client/runtime/library").JsonValue | null;
+    }>;
+}