@servicetitan/titan-chatbot-api 4.3.3 → 4.4.1

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

@@ -73,6 +73,29 @@ export const mockFrontendModelFlat = (): Models.FrontendModel => {
     });
 };
 
+export const mockFrontendModelMixed = (): Models.FrontendModel => {
+    const sources = mockOptionSimple('Sources', 'Sources', Models.OptionType.Group, [
+        mockOptionSimple('KnowledgeBase', 'Knowledge Base', Models.OptionType.Selectable, [
+            mockOptionSimple('ContentTypes', 'Content Types', Models.OptionType.Group, [
+                mockOptionSimple('kbReleaseNotes', 'Release Notes', Models.OptionType.Selectable),
+                mockOptionSimple('kbFaq', 'FAQ', Models.OptionType.Selectable),
+                mockOptionSimple('kbHowTo', 'How To', Models.OptionType.Selectable),
+            ]),
+            mockOptionSimple('ProductAreas', 'Product Areas', Models.OptionType.Group, [
+                mockOptionSimple('Call Booking', 'Call Booking', Models.OptionType.Selectable),
+                mockOptionSimple('Marketing', 'Marketing', Models.OptionType.Selectable),
+                mockOptionSimple('Marketing Pro', 'Marketing Pro', Models.OptionType.Selectable),
+            ]),
+        ]),
+        mockOptionSimple('Jarvis', 'Jarvis', Models.OptionType.Selectable),
+    ]);
+    return new Models.FrontendModel({
+        options: mockOptionSimple('customer-knowledge', undefined, Models.OptionType.Group, [
+            sources,
+        ]),
+    });
+};
+
 export const mockFrontendModel = (): Models.FrontendModel => {
     const sources = mockOptionSimple('Sources', 'Sources', Models.OptionType.Group, [
         mockOptionSimple('KnowledgeBase', 'Knowledge Base', Models.OptionType.Selectable, [
@@ -127,14 +150,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/__tests__/model-utils.test.ts

@@ -0,0 +1,388 @@
+import { expect } from '@jest/globals';
+import { Models, ModelsMocks } from '../..';
+import { createSelectionsModel } from '../model-utils';
+
+describe('[model-utils] createSelectionsModel', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('with no selections', () => {
+        test('should return undefined when no selections are made', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = [frontendModel.options];
+            const selected = new Map<string, string[]>();
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeUndefined();
+        });
+
+        test('should return undefined when selected map is empty', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = [frontendModel.options];
+            const selected = new Map<string, string[]>();
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeUndefined();
+        });
+
+        test('should handle empty selection arrays', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = [frontendModel.options];
+            const selected = new Map<string, string[]>([
+                ['Sources', []],
+                ['ContentTypes', []],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe('with flat filter structure (leaf filters only)', () => {
+        test('should handle single leaf filter selection', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['ContentTypes', ['kbReleaseNotes']]]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions).toBeDefined();
+            expect(result?.subOptions!.ContentTypes).toBeDefined();
+            expect(result?.subOptions!.ContentTypes.values).toEqual(['kbReleaseNotes']);
+        });
+
+        test('should handle multiple values in single leaf filter', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['ContentTypes', ['kbReleaseNotes', 'kbFaq', 'kbHowTo']],
+            ]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions!.ContentTypes.values).toEqual([
+                'kbReleaseNotes',
+                'kbFaq',
+                'kbHowTo',
+            ]);
+        });
+
+        test('should handle multiple different leaf filters', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['ContentTypes', ['kbReleaseNotes', 'kbFaq']],
+                ['ProductAreas', ['Marketing']],
+            ]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions!.ContentTypes.values).toEqual(['kbReleaseNotes', 'kbFaq']);
+            expect(result?.subOptions!.ProductAreas.values).toEqual(['Marketing']);
+        });
+
+        test('should filter out non-matching selections', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['ContentTypes', ['kbReleaseNotes', 'nonExistentOption']],
+            ]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+
+            expect(result).toBeDefined();
+            // Only kbReleaseNotes should be included, nonExistentOption should be filtered out
+            expect(result?.subOptions!.ContentTypes.values).toEqual(['kbReleaseNotes']);
+        });
+
+        test('should return undefined when all selected options are invalid', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['ContentTypes', ['nonExistent1', 'nonExistent2']],
+            ]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe('with mixed filter structure', () => {
+        test('should handle selections in mixed structure (1st level option without nested filters)', () => {
+            const frontendModel = ModelsMocks.mockFrontendModelMixed();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['Sources', ['Jarvis']]]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources).toBeDefined();
+            expect(result?.subOptions!.Sources.values).toEqual(['Jarvis']);
+        });
+
+        test('should handle selections in mixed structure (1st level option with nested filters)', () => {
+            const frontendModel = ModelsMocks.mockFrontendModelMixed();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['Sources', ['KnowledgeBase', 'Jarvis']]]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources).toBeDefined();
+            expect(result?.subOptions!.Sources.values).toEqual(['Jarvis']);
+            expect(result?.subOptions!.Sources.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.KnowledgeBase).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions).toEqual({});
+        });
+    });
+
+    describe('with nested filter structure', () => {
+        test('should handle single source selection without sub-filters', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['Sources', ['KnowledgeBase']]]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.KnowledgeBase).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions).toEqual({});
+        });
+
+        test('should handle source with content type selection', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase']],
+                ['ContentTypes', ['kbReleaseNotes']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            const kbSubOptions = result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions;
+            expect(kbSubOptions).toBeDefined();
+            expect(kbSubOptions!.ContentTypes).toBeDefined();
+            expect(kbSubOptions!.ContentTypes.values).toEqual(['kbReleaseNotes']);
+        });
+
+        test('should handle multiple sources with same content type selection', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.KnowledgeBase).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions!.Jarvis).toBeDefined();
+
+            // Both sources should have the ContentTypes selection (filtered by available options)
+            expect(
+                result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions!.ContentTypes
+                    .values
+            ).toEqual(['kbReleaseNotes']);
+            expect(
+                result?.subOptions!.Sources.subOptions!.Jarvis.subOptions!.ContentTypes.values
+            ).toEqual(['kbReleaseNotes']);
+        });
+
+        test('should filter content types based on each sources available options', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes', 'kbFaq', 'xxx']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+
+            // KnowledgeBase has [kbReleaseNotes, kbFaq, kbHowTo], so it should have [kbReleaseNotes, kbFaq]
+            const kbContentTypes =
+                result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions!.ContentTypes
+                    .values;
+            expect(kbContentTypes).toEqual(['kbReleaseNotes', 'kbFaq']);
+
+            // Jarvis has [kbReleaseNotes, xxx, yyy], so it should have [kbReleaseNotes, xxx]
+            const jarvisContentTypes =
+                result?.subOptions!.Sources.subOptions!.Jarvis.subOptions!.ContentTypes.values;
+            expect(jarvisContentTypes).toEqual(['kbReleaseNotes', 'xxx']);
+        });
+
+        test('should handle product areas with nested structure', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase']],
+                ['ProductAreas', ['Marketing', 'Marketing Pro']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            const kbSubOptions = result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions;
+            expect(kbSubOptions!.ProductAreas).toBeDefined();
+            expect(kbSubOptions!.ProductAreas.values).toEqual(['Marketing', 'Marketing Pro']);
+        });
+
+        test('should handle both content types and product areas', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase']],
+                ['ContentTypes', ['kbReleaseNotes', 'kbHowTo']],
+                ['ProductAreas', ['Marketing']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            const kbSubOptions = result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions;
+
+            expect(kbSubOptions!.ContentTypes.values).toEqual(['kbReleaseNotes', 'kbHowTo']);
+            expect(kbSubOptions!.ProductAreas.values).toEqual(['Marketing']);
+        });
+
+        test('should handle complex scenario with multiple sources and filters', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes', 'yyy', 'kbHowTo']],
+                ['ProductAreas', ['Marketing', 'Marketing Pro']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeDefined();
+            expect(result?.subOptions!.Sources.subOptions).toBeDefined();
+
+            // Verify KnowledgeBase selections
+            const kbSubOptions = result?.subOptions!.Sources.subOptions!.KnowledgeBase.subOptions;
+            // KB has kbReleaseNotes, kbFaq, kbHowTo - matches kbReleaseNotes and kbHowTo
+            expect(kbSubOptions!.ContentTypes.values).toEqual(['kbReleaseNotes', 'kbHowTo']);
+            expect(kbSubOptions!.ProductAreas.values).toEqual(['Marketing', 'Marketing Pro']);
+
+            // Verify Jarvis selections
+            const jarvisSubOptions = result?.subOptions!.Sources.subOptions!.Jarvis.subOptions;
+            // Jarvis has kbReleaseNotes, xxx, yyy - matches kbReleaseNotes and yyy
+            expect(jarvisSubOptions!.ContentTypes.values).toEqual(['kbReleaseNotes', 'yyy']);
+            // Jarvis doesn't have ProductAreas, so it shouldn't be present
+            expect(jarvisSubOptions!.ProductAreas).toBeUndefined();
+        });
+
+        test('should match the FilterStore export test case', () => {
+            // This test matches the scenario from filter.store.test.ts line 266
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes', 'yyy', 'kbHowTo']],
+                ['ProductAreas', ['Marketing', 'Marketing Pro']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            // Should match the expected output from filter.store.test.ts
+            expect(result).toEqual({
+                subOptions: {
+                    Sources: {
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes', 'kbHowTo'],
+                                    },
+                                    ProductAreas: {
+                                        values: ['Marketing', 'Marketing Pro'],
+                                    },
+                                },
+                            },
+                            Jarvis: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes', 'yyy'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+    });
+
+    describe('edge cases', () => {
+        test('should ignore non-Group type filters', () => {
+            const customFilters: Models.IOption[] = [
+                new Models.Option({
+                    key: 'NotAGroup',
+                    displayName: 'Not A Group',
+                    type: Models.OptionType.Selectable,
+                    subOptions: [
+                        new Models.Option({
+                            key: 'option1',
+                            displayName: 'Option 1',
+                            type: Models.OptionType.Selectable,
+                        }),
+                    ],
+                }),
+            ];
+            const selected = new Map<string, string[]>([['NotAGroup', ['option1']]]);
+
+            const result = createSelectionsModel(customFilters, selected);
+
+            expect(result).toBeUndefined();
+        });
+
+        test('should handle filters with no subOptions', () => {
+            const customFilters: Models.IOption[] = [
+                new Models.Option({
+                    key: 'EmptyFilter',
+                    displayName: 'Empty Filter',
+                    type: Models.OptionType.Group,
+                    subOptions: [],
+                }),
+            ];
+            const selected = new Map<string, string[]>([['EmptyFilter', ['anything']]]);
+
+            const result = createSelectionsModel(customFilters, selected);
+
+            expect(result).toBeUndefined();
+        });
+
+        test('should create proper Selections model structure', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase']],
+                ['ContentTypes', ['kbReleaseNotes']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+
+            expect(result).toBeInstanceOf(Models.Selections);
+            expect(result?.subOptions).toBeDefined();
+            expect(typeof result?.subOptions).toBe('object');
+        });
+    });
+});

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;
@@ -22,44 +22,48 @@ export function createSelectionsModel(
             x => x.type === Models.OptionType.Group && Boolean(x.subOptions?.length)
         );
         for (const filter of filterList) {
-            const hasSubFilters = Boolean(
-                filter.subOptions?.some(x => Boolean(x.subOptions?.length))
+            const selectedLeafOptions = filter.subOptions!.filter(
+                x =>
+                    x.type === Models.OptionType.Selectable &&
+                    selected.get(filter.key)?.includes(x.key!) &&
+                    !x.subOptions?.length
             );
-            if (!hasSubFilters) {
+            let values: string[] | undefined;
+            if (selectedLeafOptions.length) {
                 // Leaf filter: just collect selected values
-                const values = filter.subOptions
+                values = selectedLeafOptions
                     ?.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 });
                 }
-            } else {
-                // Non-leaf filter: add selected options as selectables and process sub-filters
-                const filterSelectables = filter.subOptions!.filter(
-                    x =>
-                        x.type === Models.OptionType.Selectable &&
-                        Boolean(x.subOptions?.length) &&
-                        selected[filter.key]?.includes(x.key!)
-                );
-                if (!filterSelectables.length) {
-                    continue;
-                }
-                ensureResult();
-                const filterResult = new Models.Selections({
-                    subOptions: {},
-                });
-                result!.subOptions![filter.key] = filterResult;
-                for (const filterSelectable of filterSelectables) {
-                    // Process sub-filters: if any sub-filters selected, add them to the result
-                    const subFilters = filterSelectable.subOptions!;
-                    const resultSubFilters = process(subFilters);
-                    filterResult.subOptions![filterSelectable.key] =
-                        resultSubFilters ??
-                        new Models.Selections({
-                            subOptions: {},
-                        });
-                }
+            }
+            // Non-leaf filter: add selected options as selectables and process sub-filters
+            const selectedNonLeafOptions = filter.subOptions!.filter(
+                x =>
+                    x.type === Models.OptionType.Selectable &&
+                    selected.get(filter.key)?.includes(x.key!) &&
+                    Boolean(x.subOptions?.length)
+            );
+            if (!selectedNonLeafOptions.length) {
+                continue;
+            }
+            ensureResult();
+            const filterResult = new Models.Selections({
+                values,
+                subOptions: {},
+            });
+            result!.subOptions![filter.key] = filterResult;
+            for (const noneLeafOption of selectedNonLeafOptions) {
+                // Process sub-filters: if any sub-filters selected, add them to the result
+                const subFilters = noneLeafOption.subOptions!;
+                const resultSubFilters = process(subFilters);
+                filterResult.subOptions![noneLeafOption.key] =
+                    resultSubFilters ??
+                    new Models.Selections({
+                        subOptions: {},
+                    });
             }
         }
         return result;

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');
     });