@servicetitan/titan-chatbot-api 3.0.0

package/src/stores/__tests__/chatbot-ui.store.test.ts

@@ -0,0 +1,196 @@
+import { expect } from '@jest/globals';
+import { ChatError, ChatUiEvent } from '@servicetitan/titan-chat-ui-common';
+import { Models, ModelsMocks } from '../../api-client';
+import { initTestContainer } from '../../utils/test-utils';
+import { ChatbotUiEvent, ChatbotUiStore } from '../chatbot-ui.store';
+import { FilterStore } from '../filter.store';
+
+const mockEventEmitter = {
+    on: jest.fn(),
+    off: jest.fn(),
+    emit: jest.fn(),
+    listeners: jest.fn(),
+    listenerCount: jest.fn(),
+};
+jest.mock('events', () => ({
+    EventEmitter: class {
+        on = mockEventEmitter.on;
+        off = mockEventEmitter.off;
+        emit = mockEventEmitter.emit;
+        listeners = mockEventEmitter.listeners;
+        listenerCount = mockEventEmitter.listenerCount;
+    },
+}));
+
+const initContainer = initTestContainer(ChatbotUiStore, () => {});
+
+describe('[ChatbotUiStore]', () => {
+    let store: ChatbotUiStore;
+
+    beforeEach(() => {
+        const container = initContainer();
+        store = container.get(ChatbotUiStore);
+        jest.useFakeTimers();
+        jest.setSystemTime(Date.parse('2021-01-01T00:00:00.000Z'));
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+        jest.clearAllMocks();
+        mockEventEmitter.on.mockClear();
+        mockEventEmitter.off.mockClear();
+        mockEventEmitter.emit.mockClear();
+        mockEventEmitter.listeners.mockClear();
+        mockEventEmitter.listenerCount.mockClear();
+    });
+
+    test('should have default state', () => {
+        expect(store.filterStore).toBeInstanceOf(FilterStore);
+    });
+
+    test('should setFilters', () => {
+        const frontendModel = ModelsMocks.mockFrontendModel();
+        store.setFilters(frontendModel);
+
+        expect(store.filterStore.filters.length).toEqual(1);
+        expect(store.filterStore.filters[0].key).toEqual('Sources');
+    });
+
+    describe('with chat events', () => {
+        test('should sendSessionFeedback', async () => {
+            mockEmit();
+            const feedback = new Models.Feedback({
+                sessionId: 1,
+                rating: Models.FeedbackRatings.ThumbsDown,
+                description: 'description',
+            });
+            await store.sendSessionFeedback(feedback);
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatbotUiEvent.eventChatbotSessionFeedback,
+                expect.any(Function),
+                expect.any(Function),
+                feedback
+            );
+        });
+
+        test('should sendMessageFeedback', async () => {
+            mockEmit();
+            const feedback = new Models.Feedback({
+                sessionId: 1,
+                messageId: 1,
+                linkUrl: 'https://example.com/feedback',
+                options: [Models.FeedbackOptions.Unclear],
+                rating: Models.FeedbackRatings.ThumbsUp,
+                description: 'description',
+            });
+            const message: Models.IBotMessage = {
+                id: 1,
+                sessionId: 1,
+                answer: 'message text',
+                guardFlag: 'N',
+                isGuardrailed: false,
+            };
+            await store.sendMessageFeedback(message, feedback);
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatbotUiEvent.eventChatbotMessageFeedback,
+                expect.any(Function),
+                expect.any(Function),
+                feedback
+            );
+            expect(feedback.messageId).toBe(message.id);
+        });
+
+        test('should recover', async () => {
+            mockEmit();
+            const spyRecoverCustomization = jest.fn().mockResolvedValue(undefined);
+            store.customizations.error = {
+                recover: spyRecoverCustomization,
+            };
+            store.setError('Test error');
+
+            await store.recover();
+
+            expect(spyRecoverCustomization).toHaveBeenCalledWith(store.error);
+            expect(mockEventEmitter.emit).not.toHaveBeenCalled();
+            await checkScrollTriggered();
+        });
+
+        test('should recover without customizations', async () => {
+            mockEmit();
+            const spyRecoverCustomization = jest.fn().mockResolvedValue(undefined);
+            store.setError('Test error');
+
+            await store.recover();
+
+            expect(spyRecoverCustomization).not.toHaveBeenCalled();
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatUiEvent.eventRecover,
+                expect.any(Function),
+                expect.any(Function),
+                new ChatError('Test error')
+            );
+            await checkScrollTriggered();
+        });
+
+        test('should sendMessageText without message', async () => {
+            mockEmit();
+            await store.sendMessageText('');
+            expect(mockEventEmitter.emit).not.toHaveBeenCalledWith(
+                ChatUiEvent.eventMessageSend,
+                expect.any(Function),
+                expect.any(Function),
+                expect.objectContaining({
+                    type: 'message',
+                    message: '',
+                }),
+                store.filterStore.export()
+            );
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatUiEvent.eventTimerRestart,
+                expect.any(Function),
+                expect.any(Function)
+            );
+            await checkScrollTriggered(false);
+        });
+
+        test('should sendMessageText', async () => {
+            mockEmit();
+            const messageText = 'Hello, world!';
+            await store.sendMessageText(messageText);
+
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatUiEvent.eventMessageSend,
+                expect.any(Function),
+                expect.any(Function),
+                expect.objectContaining({
+                    type: 'message',
+                    message: messageText,
+                }),
+                store.filterStore.export()
+            );
+            expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+                ChatUiEvent.eventTimerRestart,
+                expect.any(Function),
+                expect.any(Function)
+            );
+            await checkScrollTriggered();
+        });
+
+        function mockEmit() {
+            mockEventEmitter.listeners.mockImplementation(() => ['1']);
+            mockEventEmitter.listenerCount.mockReturnValue(1);
+            mockEventEmitter.emit.mockImplementation(
+                async (eventName: string, resolve: () => void) => {
+                    await Promise.resolve();
+                    resolve();
+                }
+            );
+        }
+
+        async function checkScrollTriggered(triggered = true) {
+            const counter = store.scrollCounter;
+            await jest.runOnlyPendingTimersAsync();
+            expect(counter < store.scrollCounter).toBe(triggered);
+        }
+    });
+});

package/src/stores/__tests__/filter.store.test.ts

@@ -0,0 +1,363 @@
+import { expect } from '@jest/globals';
+import { Models, ModelsMocks } from '../../api-client';
+import { FilterStore } from '../filter.store';
+
+describe('[FilterStore]', () => {
+    let store: FilterStore;
+
+    const validateFilters = (key: string, subOptionsLength: number) => {
+        const filter = store.filters.find(f => f.key === key);
+        expect(filter?.subOptions?.length ?? 0).toEqual(subOptionsLength);
+    };
+
+    const validateSelected = (key: string, expected?: string[]) => {
+        if (!expected) {
+            expect(store.selectedOptions[key]).toBeUndefined();
+        }
+        expect(store.selectedOptions[key]).toEqual(expected);
+    };
+
+    beforeEach(() => {
+        store = new FilterStore();
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('should validate defaults', () => {
+        expect(Object.keys(store.filters).length).toEqual(0);
+        expect(Object.keys(store.selectedOptions).length).toEqual(0);
+    });
+
+    test('Should initialize properly', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        // We initialized 1 root filter (Sources) with 2 subgroups
+        expect(store.filters.length).toEqual(1);
+        expect(store.filters[0].key).toEqual('Sources');
+        expect(store.filters[0].displayName).toEqual('Sources');
+        expect(store.filters[0].type).toEqual(Models.OptionType.Group);
+        expect(store.filters[0].subOptions!.length).toEqual(2);
+
+        const sourceKb = store.filters[0].subOptions![0];
+        expect(sourceKb.key).toEqual('KnowledgeBase');
+        expect(sourceKb.displayName).toEqual('Knowledge Base');
+        expect(sourceKb.type).toEqual(Models.OptionType.Selectable);
+        expect(sourceKb.subOptions!.length).toEqual(2);
+
+        const contentTypes = sourceKb.subOptions![0];
+        expect(contentTypes.key).toEqual('ContentTypes');
+        expect(contentTypes.displayName).toEqual('Content Types');
+        expect(contentTypes.type).toEqual(Models.OptionType.Group);
+        expect(contentTypes.subOptions!.length).toEqual(3);
+
+        const productAreas = sourceKb.subOptions![1];
+        expect(productAreas.key).toEqual('ProductAreas');
+        expect(productAreas.displayName).toEqual('Product Areas');
+        expect(productAreas.type).toEqual(Models.OptionType.Group);
+        expect(productAreas.subOptions!.length).toEqual(3);
+    });
+
+    test('Should fail when selecting option from non-existing filter', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        expect(() => store.selectOption('non-existing', 'subFilter1')).toThrow(
+            'Filter with key "non-existing" does not exist.'
+        );
+    });
+
+    test('Should fail when selecting non-existing option from existing filter', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        expect(() => store.selectOption('Sources', 'non-existing-option')).toThrow(
+            'Option "non-existing-option" does not exist in the filter "Sources".'
+        );
+    });
+
+    test('Should select value', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+
+        expect(store.filters.length).toEqual(1);
+
+        // Source filter: select Jarvis option: 1 filter + 1 subfilter
+        store.selectOption('Sources', 'Jarvis');
+        validateSelected('Sources', ['Jarvis']);
+        expect(store.filters.length).toEqual(2);
+        expect(store.filters[0].key).toEqual('Sources');
+        expect(store.filters[1].key).toEqual('ContentTypes');
+        expect(store.filters[1].subOptions!.length).toEqual(3);
+
+        // Source filter: select knowledgeBase option (options with the same key are merged)
+        store.selectOption('Sources', 'KnowledgeBase');
+        validateSelected('Sources', ['Jarvis', 'KnowledgeBase']);
+        expect(store.filters.length).toEqual(3);
+        expect(store.filters[0].key).toEqual('Sources');
+        expect(store.filters[1].key).toEqual('ContentTypes');
+        expect(store.filters[1].subOptions!.map(o => o.key)).toEqual([
+            'kbReleaseNotes',
+            'kbFaq',
+            'kbHowTo',
+            'xxx',
+            'yyy',
+        ]);
+
+        store.selectOption('ContentTypes', 'kbReleaseNotes');
+        expect(store.filters.length).toEqual(3);
+        validateSelected('Sources', ['Jarvis', 'KnowledgeBase']);
+        validateSelected('ContentTypes', ['kbReleaseNotes']);
+        validateSelected('ProductAreas');
+
+        store.selectOption('ProductAreas', 'Call Booking');
+        expect(store.filters.length).toEqual(3);
+        validateSelected('Sources', ['Jarvis', 'KnowledgeBase']);
+        validateSelected('ContentTypes', ['kbReleaseNotes']);
+        validateSelected('ProductAreas', ['Call Booking']);
+    });
+
+    test('Should deselect value', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectOption('Sources', 'KnowledgeBase');
+        store.selectOption('Sources', 'Jarvis');
+        store.selectOption('ContentTypes', 'kbReleaseNotes');
+        store.selectOption('ContentTypes', 'yyy');
+        store.selectOption('ContentTypes', 'kbHowTo');
+        store.selectOption('ProductAreas', 'Marketing');
+        store.selectOption('ProductAreas', 'Marketing Pro');
+
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
+        validateSelected('Sources', ['KnowledgeBase', 'Jarvis']);
+        validateSelected('ContentTypes', ['kbReleaseNotes', 'yyy', 'kbHowTo']);
+        validateSelected('ProductAreas', ['Marketing', 'Marketing Pro']);
+
+        store.deselectOption('Sources', 'Jarvis');
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 3);
+        validateSelected('Sources', ['KnowledgeBase']);
+        validateSelected('ContentTypes', ['kbReleaseNotes', 'kbHowTo']);
+        validateSelected('ProductAreas', ['Marketing', 'Marketing Pro']);
+
+        store.deselectOption('ContentTypes', 'kbHowTo');
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 3);
+        validateSelected('Sources', ['KnowledgeBase']);
+        validateSelected('ContentTypes', ['kbReleaseNotes']);
+        validateSelected('ProductAreas', ['Marketing', 'Marketing Pro']);
+
+        store.deselectOption('ContentTypes', 'kbReleaseNotes');
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 3);
+        validateSelected('Sources', ['KnowledgeBase']);
+        validateSelected('ContentTypes', []);
+        validateSelected('ProductAreas', ['Marketing', 'Marketing Pro']);
+
+        store.deselectOption('ProductAreas', 'Marketing Pro');
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 3);
+        validateSelected('Sources', ['KnowledgeBase']);
+        validateSelected('ContentTypes', []);
+        validateSelected('ProductAreas', ['Marketing']);
+
+        store.deselectOption('Sources', 'KnowledgeBase');
+        expect(store.filters.length).toEqual(1);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 0);
+        validateFilters('ProductAreas', 0);
+        validateSelected('Sources', []);
+        validateSelected('ContentTypes', []);
+        validateSelected('ProductAreas', []);
+    });
+
+    test('Should deselect value 2', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+
+        store.selectOption('Sources', 'KnowledgeBase');
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 3);
+
+        store.selectOption('Sources', 'Jarvis');
+        expect(store.filters.length).toEqual(3);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
+
+        store.deselectOption('Sources', 'KnowledgeBase');
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 3);
+        validateFilters('ProductAreas', 0);
+
+        store.selectOption('Sources', 'KnowledgeBase');
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
+    });
+
+    test('Should select all', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectAll('Sources');
+        store.selectAll('ProductAreas');
+        store.selectAll('ContentTypes');
+
+        validateSelected('Sources', ['KnowledgeBase', 'Jarvis']);
+        validateSelected('ContentTypes', ['kbReleaseNotes', 'kbFaq', 'kbHowTo', 'xxx', 'yyy']);
+        validateSelected('ProductAreas', ['Call Booking', 'Marketing', 'Marketing Pro']);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
+    });
+
+    test('Should deselect all', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectAll('Sources');
+        store.selectAll('ContentTypes');
+        store.selectAll('ProductAreas');
+
+        store.deselectAll('ContentTypes');
+        store.deselectAll('ProductAreas');
+        store.deselectAll('Sources');
+
+        validateSelected('Sources', []);
+        validateSelected('ContentTypes', []);
+        validateSelected('ProductAreas', []);
+        validateFilters('Sources', 2);
+        validateFilters('ContentTypes', 0);
+        validateFilters('ProductAreas', 0);
+    });
+
+    test('should getFilterLabel', () => {
+        const filterKey = 'contentTypes';
+        const label = store.getFilterLabel(filterKey);
+        expect(label).toEqual('Content Types');
+    });
+
+    test('should export', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectOption('Sources', 'KnowledgeBase');
+        store.selectOption('Sources', 'Jarvis');
+        store.selectOption('ContentTypes', 'kbReleaseNotes');
+        store.selectOption('ContentTypes', 'yyy');
+        store.selectOption('ContentTypes', 'kbHowTo');
+        store.selectOption('ProductAreas', 'Marketing');
+        store.selectOption('ProductAreas', 'Marketing Pro');
+
+        const exported = store.export();
+        expect(exported).toEqual({
+            subOptions: {
+                Sources: {
+                    subOptions: {
+                        KnowledgeBase: {
+                            subOptions: {
+                                ContentTypes: {
+                                    values: ['kbReleaseNotes', 'kbHowTo'],
+                                },
+                                ProductAreas: {
+                                    values: ['Marketing', 'Marketing Pro'],
+                                },
+                            },
+                        },
+                        Jarvis: {
+                            subOptions: {
+                                ContentTypes: {
+                                    values: ['kbReleaseNotes', 'yyy'],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+    });
+
+    test('should export 2', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        const exported = store.export();
+        expect(exported).toBeUndefined();
+    });
+
+    test('should export 3', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectOption('Sources', 'KnowledgeBase');
+        const exported = store.export();
+        expect(exported).toEqual({
+            subOptions: {
+                Sources: {
+                    subOptions: {
+                        KnowledgeBase: {
+                            subOptions: {},
+                        },
+                    },
+                },
+            },
+        });
+    });
+
+    test('should export 4', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectOption('Sources', 'KnowledgeBase');
+        store.selectOption('ProductAreas', 'Marketing');
+        store.deselectOption('ProductAreas', 'Marketing');
+        store.selectOption('ProductAreas', 'Marketing');
+
+        const exported = store.export();
+        expect(exported).toEqual({
+            subOptions: {
+                Sources: {
+                    subOptions: {
+                        KnowledgeBase: {
+                            subOptions: {
+                                ProductAreas: {
+                                    values: ['Marketing'],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+    });
+
+    test('should export 5', () => {
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        store.selectOption('Sources', 'KnowledgeBase');
+        store.selectOption('Sources', 'Jarvis');
+        store.selectOption('ContentTypes', 'kbReleaseNotes');
+
+        const exported = store.export();
+        expect(exported).toEqual({
+            subOptions: {
+                Sources: {
+                    subOptions: {
+                        KnowledgeBase: {
+                            subOptions: {
+                                ContentTypes: {
+                                    values: ['kbReleaseNotes'],
+                                },
+                            },
+                        },
+                        Jarvis: {
+                            subOptions: {
+                                ContentTypes: {
+                                    values: ['kbReleaseNotes'],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+    });
+
+    test('should export 6', () => {
+        const exported = store.export();
+        expect(exported).toBeUndefined();
+    });
+});

package/src/stores/__tests__/initialize.store.test.ts

@@ -0,0 +1,73 @@
+import { expect } from '@jest/globals';
+import { Container } from '@servicetitan/react-ioc';
+import { initTestContainer } from '../../utils/test-utils';
+import { InitializeStore, InitializeStoreStatus } from '../initialize.store';
+
+const initContainer = initTestContainer(InitializeStore, () => {});
+
+describe('[InitializeStore]', () => {
+    let store: InitializeStore;
+    let container: Container;
+
+    beforeEach(() => {
+        container = initContainer();
+        store = container.get(InitializeStore);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('should have correct default values', () => {
+        expect(store.isInitialized).toBe(false);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.None);
+    });
+
+    test('should initialize correctly', async () => {
+        const initializePromise = store.initialize();
+        expect(store.isInitialized).toBe(false);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Pending);
+
+        await initializePromise;
+
+        expect(store.isInitialized).toBe(true);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Success);
+    });
+
+    test('should create only one promise', async () => {
+        const spy = jest.spyOn(store as any, 'initializeInternal');
+
+        const initializePromise = store.initialize();
+        const initializePromise2 = store.initialize();
+
+        await initializePromise;
+        await initializePromise2;
+
+        expect(store.isInitialized).toBe(true);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Success);
+        expect(spy).toHaveBeenCalledTimes(1); // Should be called once
+    });
+
+    test('should initialize correctly with force', async () => {
+        const spy = jest.spyOn(store as any, 'initializeInternal');
+        const initializePromise = store.initialize();
+        expect(store.isInitialized).toBe(false);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Pending);
+
+        await initializePromise;
+
+        expect(store.isInitialized).toBe(true);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Success);
+
+        const initializePromise2 = store.initialize(true);
+        expect(store.isInitialized).toBe(false);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Pending);
+
+        await initializePromise2;
+
+        expect(store.isInitialized).toBe(true);
+        expect(store.initializeStatus).toBe(InitializeStoreStatus.Success);
+
+        expect(spy).toHaveBeenCalledTimes(2); // Should be called twice because of reset
+    });
+});