@servicetitan/titan-chatbot-api 4.3.3 → 4.4.0

package/src/api-client/models/__mocks__/models.mock.ts

@@ -127,14 +127,18 @@ export const mockFeedback = (overrides?: Partial<Models.IFeedback>): Models.Feed
         ...overrides,
     });
 
-export const mockSelections = (overrides?: Models.Selections): Models.Selections | undefined =>
-    new Models.Selections({
-        ...ModelsUtils.createSelectionsModel([mockFrontendModel().options], {
-            Sources: ['KnowledgeBase', 'Jarvis'],
-            ContentTypes: ['kbReleaseNotes', 'kbFaq', 'xxx'],
-        }),
+export const mockSelections = (overrides?: Models.Selections): Models.Selections | undefined => {
+    return new Models.Selections({
+        ...ModelsUtils.createSelectionsModel(
+            [mockFrontendModel().options],
+            new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes', 'kbFaq', 'xxx']],
+            ])
+        ),
         ...overrides,
     });
+};
 
 export const mockUserMessage = (overrides?: Partial<Models.IUserMessage>): Models.UserMessage =>
     new Models.UserMessage({

package/src/api-client/utils/model-utils.ts

@@ -6,7 +6,7 @@ export function createNewSessionModel(data?: Models.ISession): Models.Session {
 
 export function createSelectionsModel(
     filters: Models.IOption[],
-    selected: Record<string, string[]>
+    selected: Map<string, string[]>
 ): Models.Selections | undefined {
     const process = (filters: Models.IOption[]): Models.Selections | undefined => {
         let result: Models.Selections | undefined;
@@ -29,7 +29,7 @@ export function createSelectionsModel(
                 // Leaf filter: just collect selected values
                 const values = filter.subOptions
                     ?.map(o => o.key)
-                    .filter(o => selected[filter.key]?.includes(o));
+                    .filter(o => selected.get(filter.key)?.includes(o));
                 if (values?.length) {
                     ensureResult();
                     result!.subOptions![filter.key] = new Models.Selections({ values });
@@ -40,7 +40,7 @@ export function createSelectionsModel(
                     x =>
                         x.type === Models.OptionType.Selectable &&
                         Boolean(x.subOptions?.length) &&
-                        selected[filter.key]?.includes(x.key!)
+                        selected.get(filter.key)?.includes(x.key!)
                 );
                 if (!filterSelectables.length) {
                     continue;

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

@@ -52,7 +52,7 @@ describe('[ChatbotUiStore]', () => {
         const frontendModel = ModelsMocks.mockFrontendModel();
         store.setFilters(frontendModel);
 
-        expect(store.filterStore.filters.length).toEqual(1);
+        expect(store.filterStore.filters.length).toEqual(3);
         expect(store.filterStore.filters[0].key).toEqual('Sources');
     });
 

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

@@ -1,9 +1,9 @@
 import { expect } from '@jest/globals';
 import { Models, ModelsMocks } from '../../api-client';
-import { FilterStore } from '../filter.store';
+import { FilterStore, IFilterStore } from '../filter.store';
 
 describe('[FilterStore]', () => {
-    let store: FilterStore;
+    let store: IFilterStore;
 
     const validateFilters = (key: string, subOptionsLength: number) => {
         const filter = store.filters.find(f => f.key === key);
@@ -12,9 +12,9 @@ describe('[FilterStore]', () => {
 
     const validateSelected = (key: string, expected?: string[]) => {
         if (!expected) {
-            expect(store.selectedOptions[key]).toBeUndefined();
+            expect(store.selected.get(key)).toBeUndefined();
         }
-        expect(store.selectedOptions[key]).toEqual(expected);
+        expect(store.selected.get(key)).toEqual(expected);
     };
 
     beforeEach(() => {
@@ -27,35 +27,35 @@ describe('[FilterStore]', () => {
 
     test('should validate defaults', () => {
         expect(Object.keys(store.filters).length).toEqual(0);
-        expect(Object.keys(store.selectedOptions).length).toEqual(0);
+        expect(store.selected.size).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);
+        expect(store.filters.length).toEqual(3);
+
+        const checkFilter = (
+            idx: number,
+            key: string,
+            type: Models.OptionType,
+            subOptionsLength: number
+        ) => {
+            expect(store.filters[idx].key).toEqual(key);
+            expect(store.filters[idx].type).toEqual(type);
+            expect(store.filters[idx].subOptions!.length).toEqual(subOptionsLength);
+        };
+
+        // Check filters flattened
+        checkFilter(0, 'Sources', Models.OptionType.Group, 2);
+        checkFilter(1, 'ContentTypes', Models.OptionType.Group, 5);
+        checkFilter(2, 'ProductAreas', Models.OptionType.Group, 3);
+
+        // Check options and that they don't have sub-options (because of flattening)
+        const optionKnowledgeBase = store.filters[0].subOptions![0];
+        expect(optionKnowledgeBase.key).toEqual('KnowledgeBase');
+        expect(optionKnowledgeBase.displayName).toEqual('Knowledge Base');
+        expect(optionKnowledgeBase.type).toEqual(Models.OptionType.Selectable);
+        expect(optionKnowledgeBase.subOptions!.length).toEqual(0);
     });
 
     test('Should fail when selecting option from non-existing filter', () => {
@@ -68,22 +68,22 @@ describe('[FilterStore]', () => {
     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".'
+            'Option with key \"non-existing-option\" does not exist in filter \"Sources\".'
         );
     });
 
     test('Should select value', () => {
         store.initFilters(ModelsMocks.mockFrontendModel());
 
-        expect(store.filters.length).toEqual(1);
+        expect(store.filters.length).toEqual(3);
 
         // 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.length).toEqual(3);
         expect(store.filters[0].key).toEqual('Sources');
         expect(store.filters[1].key).toEqual('ContentTypes');
-        expect(store.filters[1].subOptions!.length).toEqual(3);
+        expect(store.filters[2].key).toEqual('ProductAreas');
 
         // Source filter: select knowledgeBase option (options with the same key are merged)
         store.selectOption('Sources', 'KnowledgeBase');
@@ -134,7 +134,7 @@ describe('[FilterStore]', () => {
         store.deselectOption('Sources', 'Jarvis');
         expect(store.filters.length).toEqual(3);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
+        validateFilters('ContentTypes', 5);
         validateFilters('ProductAreas', 3);
         validateSelected('Sources', ['KnowledgeBase']);
         validateSelected('ContentTypes', ['kbReleaseNotes', 'kbHowTo']);
@@ -143,7 +143,7 @@ describe('[FilterStore]', () => {
         store.deselectOption('ContentTypes', 'kbHowTo');
         expect(store.filters.length).toEqual(3);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
+        validateFilters('ContentTypes', 5);
         validateFilters('ProductAreas', 3);
         validateSelected('Sources', ['KnowledgeBase']);
         validateSelected('ContentTypes', ['kbReleaseNotes']);
@@ -152,7 +152,7 @@ describe('[FilterStore]', () => {
         store.deselectOption('ContentTypes', 'kbReleaseNotes');
         expect(store.filters.length).toEqual(3);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
+        validateFilters('ContentTypes', 5);
         validateFilters('ProductAreas', 3);
         validateSelected('Sources', ['KnowledgeBase']);
         validateSelected('ContentTypes', []);
@@ -161,17 +161,17 @@ describe('[FilterStore]', () => {
         store.deselectOption('ProductAreas', 'Marketing Pro');
         expect(store.filters.length).toEqual(3);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
+        validateFilters('ContentTypes', 5);
         validateFilters('ProductAreas', 3);
         validateSelected('Sources', ['KnowledgeBase']);
         validateSelected('ContentTypes', []);
         validateSelected('ProductAreas', ['Marketing']);
 
         store.deselectOption('Sources', 'KnowledgeBase');
-        expect(store.filters.length).toEqual(1);
+        expect(store.filters.length).toEqual(3);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 0);
-        validateFilters('ProductAreas', 0);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
         validateSelected('Sources', []);
         validateSelected('ContentTypes', []);
         validateSelected('ProductAreas', []);
@@ -182,7 +182,7 @@ describe('[FilterStore]', () => {
 
         store.selectOption('Sources', 'KnowledgeBase');
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
+        validateFilters('ContentTypes', 5);
         validateFilters('ProductAreas', 3);
 
         store.selectOption('Sources', 'Jarvis');
@@ -193,8 +193,8 @@ describe('[FilterStore]', () => {
 
         store.deselectOption('Sources', 'KnowledgeBase');
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 3);
-        validateFilters('ProductAreas', 0);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
 
         store.selectOption('Sources', 'KnowledgeBase');
         validateFilters('Sources', 2);
@@ -251,8 +251,8 @@ describe('[FilterStore]', () => {
         validateSelected('ContentTypes', []);
         validateSelected('ProductAreas', []);
         validateFilters('Sources', 2);
-        validateFilters('ContentTypes', 0);
-        validateFilters('ProductAreas', 0);
+        validateFilters('ContentTypes', 5);
+        validateFilters('ProductAreas', 3);
     });
 
     test('should getFilterLabel', () => {
@@ -384,4 +384,22 @@ describe('[FilterStore]', () => {
         const exported = store.export();
         expect(exported).toBeUndefined();
     });
+
+    test('should detect disabled options', () => {
+        const checkDisabled = (disabledArray: boolean[]) => {
+            const keys = ['kbFaq', 'kbReleaseNotes', 'kbHowTo', 'xxx', 'yyy'];
+            keys.forEach((key, index) => {
+                expect(store.isOptionDisabled('ContentTypes', key)).toBe(disabledArray[index]);
+            });
+        };
+
+        store.initFilters(ModelsMocks.mockFrontendModel());
+        checkDisabled([true, true, true, true, true]);
+
+        store.selectOption('Sources', 'KnowledgeBase');
+        checkDisabled([false, false, false, true, true]);
+
+        store.selectOption('Sources', 'Jarvis');
+        checkDisabled([false, false, false, false, false]);
+    });
 });

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

@@ -3,7 +3,7 @@ import { ChatUiEvent, ChatUiStore, IChatUiStore } from '@servicetitan/titan-chat
 import { action, makeObservable } from 'mobx';
 import { Models } from '../api-client';
 import { ChatbotCustomizations } from '../models';
-import { FilterStore } from './filter.store';
+import { FilterStore, IFilterStore } from './filter.store';
 
 export const CHATBOT_UI_STORE_TOKEN = symbolToken<IChatbotUiStore>('CHATBOT_UI_STORE_TOKEN');
 
@@ -14,7 +14,7 @@ export enum ChatbotUiEvent {
 }
 
 export interface IChatbotUiStore extends IChatUiStore<ChatbotCustomizations> {
-    filterStore: FilterStore;
+    filterStore: IFilterStore;
     settings?: Models.IFrontendModel;
     setFilters: (filterOptions: Models.IFrontendModel) => void;
     startSession: (
@@ -32,7 +32,7 @@ export interface IChatbotUiStore extends IChatUiStore<ChatbotCustomizations> {
 
 @injectable()
 export class ChatbotUiStore extends ChatUiStore<ChatbotCustomizations> implements IChatbotUiStore {
-    filterStore = new FilterStore();
+    filterStore: IFilterStore = new FilterStore();
 
     constructor() {
         super();