@servicetitan/titan-chatbot-api 4.4.0 → 4.4.2

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

@@ -0,0 +1,453 @@
+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('top level, single filter, single value', () => {
+            const flatModel = ModelsMocks.mockFrontendModelFlat();
+            const flatFilters = flatModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['ContentTypes', ['kbReleaseNotes']]]);
+
+            const result = createSelectionsModel(flatFilters, selected);
+            expect(result).toEqual({
+                subOptions: {
+                    ContentTypes: {
+                        values: ['kbReleaseNotes'],
+                    },
+                },
+            });
+        });
+
+        test('top level, single filter, multiple values', () => {
+            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).toEqual({
+                subOptions: {
+                    ContentTypes: {
+                        values: ['kbReleaseNotes', 'kbFaq', 'kbHowTo'],
+                    },
+                },
+            });
+        });
+
+        test('top level, multiple filter, multiple values', () => {
+            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).toEqual({
+                subOptions: {
+                    ContentTypes: {
+                        values: ['kbReleaseNotes', 'kbFaq'],
+                    },
+                    ProductAreas: {
+                        values: ['Marketing'],
+                    },
+                },
+            });
+        });
+
+        test('non-existing filter', () => {
+            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).toEqual({
+                subOptions: {
+                    ContentTypes: {
+                        values: ['kbReleaseNotes'],
+                    },
+                },
+            });
+        });
+
+        test('no valid filters', () => {
+            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('top level, single filter, single value', () => {
+            const frontendModel = ModelsMocks.mockFrontendModelMixed();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['Sources', ['Jarvis']]]);
+
+            const result = createSelectionsModel(filters, selected);
+            expect(result).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['Jarvis'],
+                    },
+                },
+            });
+        });
+
+        test('top level, multiple filters, single value', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase', 'Jarvis'],
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values', () => {
+            const frontendModel = ModelsMocks.mockFrontendModelMixed();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([
+                ['Sources', ['KnowledgeBase', 'Jarvis']],
+                ['ContentTypes', ['kbReleaseNotes']],
+                ['ProductAreas', ['Marketing']],
+            ]);
+
+            const result = createSelectionsModel(filters, selected);
+            expect(result).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase', 'Jarvis'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes'],
+                                    },
+                                    ProductAreas: {
+                                        values: ['Marketing'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+    });
+
+    describe('with nested filter structure', () => {
+        test('top level, single filter, single value', () => {
+            const frontendModel = ModelsMocks.mockFrontendModel();
+            const filters = frontendModel.options.subOptions ?? [];
+            const selected = new Map<string, string[]>([['Sources', ['KnowledgeBase']]]);
+
+            const result = createSelectionsModel(filters, selected);
+            expect(result).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase'],
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, single value', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values (with shared sub option)', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase', 'Jarvis'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes'],
+                                    },
+                                },
+                            },
+                            Jarvis: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values (with mixed sub 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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase', 'Jarvis'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes', 'kbFaq'],
+                                    },
+                                },
+                            },
+                            Jarvis: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes', 'xxx'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ProductAreas: {
+                                        values: ['Marketing', 'Marketing Pro'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values (more values)', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase'],
+                        subOptions: {
+                            KnowledgeBase: {
+                                subOptions: {
+                                    ContentTypes: {
+                                        values: ['kbReleaseNotes', 'kbHowTo'],
+                                    },
+                                    ProductAreas: {
+                                        values: ['Marketing'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+
+        test('all levels, multiple filters, multiple values (more values2)', () => {
+            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).toEqual({
+                subOptions: {
+                    Sources: {
+                        values: ['KnowledgeBase', 'Jarvis'],
+                        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

@@ -16,49 +16,68 @@ export function createSelectionsModel(
                     subOptions: {},
                 });
             }
+            return result.subOptions!;
         };
 
         const filterList = filters.filter(
             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!)
             );
-            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.get(filter.key)?.includes(o));
                 if (values?.length) {
-                    ensureResult();
-                    result!.subOptions![filter.key] = new Models.Selections({ values });
+                    const subOptions = ensureResult();
+                    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.get(filter.key)?.includes(x.key!)
-                );
-                if (!filterSelectables.length) {
+            }
+            if (!selectedLeafOptions.length) {
+                continue;
+            }
+
+            // 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;
+            }
+
+            // We have some sub-filters to process: collect their results
+            const subFilterResults = new Map<string, Models.Selections>();
+            for (const nonLeafOption of selectedNonLeafOptions) {
+                const subFilters = nonLeafOption.subOptions!;
+                const resultSubFilters = process(subFilters);
+                if (!resultSubFilters) {
                     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: {},
-                        });
+                subFilterResults.set(nonLeafOption.key!, resultSubFilters);
+            }
+
+            // If any sub-filters selected, ensure result and add them to the current subOptions
+            if (subFilterResults.size) {
+                const subOptions = ensureResult();
+                for (const [key, value] of subFilterResults) {
+                    let subFilterSelection = subOptions[filter.key];
+                    if (!subFilterSelection) {
+                        subFilterSelection = new Models.Selections({});
+                        subOptions[filter.key] = subFilterSelection;
+                    }
+                    if (!subFilterSelection.subOptions) {
+                        subFilterSelection.subOptions = {};
+                    }
+                    subFilterSelection.subOptions![key] = value;
                 }
             }
         }

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

@@ -277,6 +277,7 @@ describe('[FilterStore]', () => {
         expect(exported).toEqual({
             subOptions: {
                 Sources: {
+                    values: ['KnowledgeBase', 'Jarvis'],
                     subOptions: {
                         KnowledgeBase: {
                             subOptions: {
@@ -314,11 +315,7 @@ describe('[FilterStore]', () => {
         expect(exported).toEqual({
             subOptions: {
                 Sources: {
-                    subOptions: {
-                        KnowledgeBase: {
-                            subOptions: {},
-                        },
-                    },
+                    values: ['KnowledgeBase'],
                 },
             },
         });
@@ -335,6 +332,7 @@ describe('[FilterStore]', () => {
         expect(exported).toEqual({
             subOptions: {
                 Sources: {
+                    values: ['KnowledgeBase'],
                     subOptions: {
                         KnowledgeBase: {
                             subOptions: {
@@ -359,6 +357,7 @@ describe('[FilterStore]', () => {
         expect(exported).toEqual({
             subOptions: {
                 Sources: {
+                    values: ['KnowledgeBase', 'Jarvis'],
                     subOptions: {
                         KnowledgeBase: {
                             subOptions: {