@kronor/dtv 0.2.9

package/src/framework/runtime-reference.test.ts

@@ -0,0 +1,172 @@
+import { parseRuntimeReference, parseColumnDefinitionJson } from './view-parser';
+import { Runtime } from './runtime';
+
+describe('RuntimeReference', () => {
+    describe('parseRuntimeReference', () => {
+        it('should parse valid RuntimeReference object', () => {
+            const json = {
+                section: 'cellRenderers',
+                key: 'myRenderer'
+            };
+
+            const result = parseRuntimeReference(json);
+            expect(result).toEqual({
+                section: 'cellRenderers',
+                key: 'myRenderer'
+            });
+        });
+
+        it('should validate section values', () => {
+            const json = {
+                section: 'invalidSection',
+                key: 'myRenderer'
+            };
+
+            expect(() => {
+                parseRuntimeReference(json);
+            }).toThrow('Invalid RuntimeReference: "section" must be one of: cellRenderers, noRowsComponents, customFilterComponents, queryTransforms, initialValues');
+        });
+
+        it('should validate that section is a string', () => {
+            const json = {
+                section: 123,
+                key: 'myRenderer'
+            };
+
+            expect(() => {
+                parseRuntimeReference(json);
+            }).toThrow('Invalid RuntimeReference: "section" must be a string');
+        });
+
+        it('should validate that key is a string', () => {
+            const json = {
+                section: 'cellRenderers',
+                key: 123
+            };
+
+            expect(() => {
+                parseRuntimeReference(json);
+            }).toThrow('Invalid RuntimeReference: "key" must be a string');
+        });
+
+        it('should require section field', () => {
+            const json = {
+                key: 'myRenderer'
+            };
+
+            expect(() => {
+                parseRuntimeReference(json);
+            }).toThrow('Invalid RuntimeReference: "section" must be a string');
+        });
+
+        it('should require key field', () => {
+            const json = {
+                section: 'cellRenderers'
+            };
+
+            expect(() => {
+                parseRuntimeReference(json);
+            }).toThrow('Invalid RuntimeReference: "key" must be a string');
+        });
+    });
+
+    describe('ColumnDefinitionJson with RuntimeReference', () => {
+        const testRuntime: Runtime = {
+            cellRenderers: {
+                myRenderer: () => 'test',
+                otherRenderer: () => 'other'
+            },
+            queryTransforms: {},
+            noRowsComponents: {},
+            customFilterComponents: {},
+            initialValues: {}
+        };
+
+        it('should parse column with RuntimeReference format', () => {
+            const json = {
+                data: [{ type: 'field', path: 'test' }],
+                name: 'Test Column',
+                cellRenderer: {
+                    section: 'cellRenderers',
+                    key: 'myRenderer'
+                }
+            };
+
+            const result = parseColumnDefinitionJson(json, testRuntime, undefined);
+            expect(result.cellRenderer.section).toBe('cellRenderers');
+            expect(result.cellRenderer.key).toBe('myRenderer');
+        });
+
+        it('should require cellRenderer field', () => {
+            const json = {
+                data: [{ type: 'field', path: 'test' }],
+                name: 'Test Column'
+                // Missing cellRenderer
+            };
+
+            expect(() => {
+                parseColumnDefinitionJson(json, testRuntime, undefined);
+            }).toThrow('Invalid JSON: "cellRenderer" field is required');
+        });
+
+        it('should validate cellRenderer section is cellRenderers', () => {
+            const json = {
+                data: [{ type: 'field', path: 'test' }],
+                name: 'Test Column',
+                cellRenderer: {
+                    section: 'queryTransforms',
+                    key: 'myRenderer'
+                }
+            };
+
+            expect(() => {
+                parseColumnDefinitionJson(json, testRuntime, undefined);
+            }).toThrow('Invalid cellRenderer: section must be "cellRenderers"');
+        });
+
+        it('should validate cellRenderer reference key exists in runtime', () => {
+            const json = {
+                data: [{ type: 'field', path: 'test' }],
+                name: 'Test Column',
+                cellRenderer: {
+                    section: 'cellRenderers',
+                    key: 'nonExistentRenderer'
+                }
+            };
+
+            expect(() => {
+                parseColumnDefinitionJson(json, testRuntime, undefined);
+            }).toThrow('Invalid cellRenderer reference: "nonExistentRenderer". Valid keys are: myRenderer, otherRenderer');
+        });
+    });
+
+    describe('Custom Filter Component RuntimeReference', () => {
+        const testRuntime: Runtime = {
+            cellRenderers: {},
+            queryTransforms: {},
+            noRowsComponents: {},
+            customFilterComponents: {
+                phoneNumberFilter: () => 'PhoneNumberFilter',
+                emailFilter: () => 'EmailFilter'
+            },
+            initialValues: {}
+        };
+
+        it('should resolve custom filter component with RuntimeReference', () => {
+            // This would be tested as part of filter parsing, but we can test the concept
+            const runtimeRef = {
+                section: 'customFilterComponents' as const,
+                key: 'phoneNumberFilter'
+            };
+
+            const parsed = parseRuntimeReference(runtimeRef);
+            expect(parsed).toEqual({
+                section: 'customFilterComponents',
+                key: 'phoneNumberFilter'
+            });
+
+            // Verify the key exists in runtime
+            expect(testRuntime.customFilterComponents[parsed.key as keyof typeof testRuntime.customFilterComponents]).toBeDefined();
+        });
+    });
+});

package/src/framework/runtime.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { CellRenderer } from "./column-definition";
+import { NoRowsComponent } from "./view";
+import { TransformResult } from "./filters";
+
+// Runtime type definition for individual view runtimes
+export type Runtime = {
+    cellRenderers: Record<string, CellRenderer | React.ComponentType<any>>;
+    queryTransforms: Record<string, {
+        toQuery: (input: any) => TransformResult;
+    }>;
+    noRowsComponents: Record<string, NoRowsComponent | React.ComponentType<any>>;
+    customFilterComponents: Record<string, React.ComponentType<any>>;
+    initialValues: Record<string, any>;
+};

package/src/framework/saved-filters.test.ts

@@ -0,0 +1,422 @@
+/**
+ * @jest-environment jsdom
+ */
+import { createSavedFilterManager, SavedFilter, CURRENT_FORMAT_REVISION } from './saved-filters';
+import { FilterSchemasAndGroups } from './filters';
+
+// Mock crypto.randomUUID for consistent testing
+const mockUUID = jest.fn();
+Object.defineProperty(globalThis, 'crypto', {
+    value: { randomUUID: mockUUID },
+    writable: true
+});
+
+describe('SavedFilterManager', () => {
+    let manager: ReturnType<typeof createSavedFilterManager>;
+    let mockLocalStorage: { [key: string]: string };
+
+    // Basic test schema for simple tests
+    const basicSchema: FilterSchemasAndGroups = {
+        groups: [{ name: 'default', label: null }],
+        filters: [
+            {
+                id: 'email-filter',
+                label: 'Email Filter',
+                expression: {
+                    type: 'equals',
+                    field: 'email',
+                    value: { type: 'text' }
+                },
+                group: 'default',
+                aiGenerated: false
+            }
+        ]
+    };
+
+    beforeEach(() => {
+        // Reset UUID counter
+        let uuidCounter = 0;
+        mockUUID.mockImplementation(() => `test-uuid-${++uuidCounter}`);
+
+        // Mock localStorage
+        mockLocalStorage = {};
+        Object.defineProperty(window, 'localStorage', {
+            value: {
+                getItem: jest.fn((key: string) => mockLocalStorage[key] || null),
+                setItem: jest.fn((key: string, value: string) => {
+                    mockLocalStorage[key] = value;
+                }),
+                removeItem: jest.fn((key: string) => {
+                    delete mockLocalStorage[key];
+                })
+            },
+            writable: true
+        });
+
+        manager = createSavedFilterManager();
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('loadFilters', () => {
+        it('should return empty array when no filters are saved', () => {
+            const filters = manager.loadFilters('test-view', basicSchema);
+            expect(filters).toEqual([]);
+        });
+
+        it('should load saved filters from localStorage', () => {
+            const savedData = [
+                {
+                    id: 'filter-1',
+                    name: 'Test Filter',
+                    view: 'test-view',
+                    state: { 'email-filter': { type: 'leaf', field: 'email', value: 'test@example.com', control: { type: 'text' } } },
+                    createdAt: new Date().toISOString(),
+                    formatRevision: CURRENT_FORMAT_REVISION
+                }
+            ];
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify(savedData);
+
+            const filters = manager.loadFilters('test-view', basicSchema);
+            expect(filters).toHaveLength(1);
+            expect(filters[0].name).toBe('Test Filter');
+            expect(filters[0].state).toBeInstanceOf(Map);
+        });
+
+        it('should filter saved filters by view', () => {
+            const savedData = [
+                {
+                    id: 'filter-1',
+                    name: 'Filter for View A',
+                    view: 'view-a',
+                    state: {},
+                    createdAt: new Date().toISOString(),
+                    formatRevision: CURRENT_FORMAT_REVISION
+                },
+                {
+                    id: 'filter-2',
+                    name: 'Filter for View B',
+                    view: 'view-b',
+                    state: {},
+                    createdAt: new Date().toISOString(),
+                    formatRevision: CURRENT_FORMAT_REVISION
+                }
+            ];
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify(savedData);
+
+            const filtersForViewA = manager.loadFilters('view-a', basicSchema);
+            expect(filtersForViewA).toHaveLength(1);
+            expect(filtersForViewA[0].name).toBe('Filter for View A');
+        });
+
+        it('should handle invalid localStorage data gracefully', () => {
+            // Mock console.error to suppress expected error output in tests
+            const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+            mockLocalStorage['dtvSavedFilters'] = 'invalid json';
+            const filters = manager.loadFilters('test-view', basicSchema);
+            expect(filters).toEqual([]);
+
+            // Verify error was logged and restore console
+            expect(consoleSpy).toHaveBeenCalledWith('Failed to load saved filters from localStorage:', expect.any(Error));
+            consoleSpy.mockRestore();
+        });
+
+        it('should handle non-array localStorage data gracefully', () => {
+            // Mock console.error to suppress expected error output in tests
+            const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify({ not: 'an array' });
+            const filters = manager.loadFilters('test-view', basicSchema);
+            expect(filters).toEqual([]);
+
+            // Restore console
+            consoleSpy.mockRestore();
+        });
+
+        it('should migrate old array format filters and overwrite in localStorage', () => {
+            // Mock console.info to suppress expected info output in tests
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+
+            // Create old format data with OLD_ARRAY_FORMAT_REVISION
+            const oldFormatData = [
+                {
+                    id: 'old-filter',
+                    name: 'Old Format Filter',
+                    view: 'test-view',
+                    state: [
+                        {
+                            type: 'leaf',
+                            field: 'email',
+                            value: 'old@test.com',
+                            control: { type: 'text' },
+                            filterType: 'equals'
+                        }
+                    ],
+                    createdAt: new Date().toISOString(),
+                    formatRevision: '2025-09-04T00:00:00.000Z' // OLD_ARRAY_FORMAT_REVISION
+                }
+            ];
+
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify(oldFormatData);
+
+            // Load filters - should trigger migration
+            const filters = manager.loadFilters('test-view', basicSchema);
+
+            expect(filters).toHaveLength(1);
+            expect(filters[0].name).toBe('Old Format Filter');
+            expect(filters[0].state).toBeInstanceOf(Map);
+            expect(filters[0].formatRevision).toBe('2025-09-19T00:00:00.000Z'); // CURRENT_FORMAT_REVISION
+
+            // Check that localStorage was updated with migrated data
+            expect(localStorage.setItem).toHaveBeenCalledWith(
+                'dtvSavedFilters',
+                expect.stringContaining('"formatRevision":"2025-09-19T00:00:00.000Z"')
+            );
+
+            // Verify the migrated state is no longer an array
+            const savedData = JSON.parse(mockLocalStorage['dtvSavedFilters']);
+            expect(savedData[0].formatRevision).toBe('2025-09-19T00:00:00.000Z');
+            expect(Array.isArray(savedData[0].state)).toBe(false); // Should be object now
+
+            // Verify info was logged and restore console
+            expect(consoleSpy).toHaveBeenCalledWith('Migrated filters from old array format to new object format');
+            consoleSpy.mockRestore();
+        });
+
+        it('should migrate filters from legacy localStorage key', () => {
+            // Mock console.info to suppress expected info output in tests
+            const consoleSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+
+            // Create data in legacy key
+            const legacyData = [
+                {
+                    id: 'legacy-filter',
+                    name: 'Legacy Key Filter',
+                    view: 'test-view',
+                    state: [
+                        {
+                            type: 'leaf',
+                            field: 'email',
+                            value: 'legacy@test.com',
+                            control: { type: 'text' },
+                            filterType: 'equals'
+                        }
+                    ],
+                    createdAt: new Date().toISOString(),
+                    formatRevision: '2025-09-04T00:00:00.000Z' // OLD_ARRAY_FORMAT_REVISION
+                }
+            ];
+
+            // Put data only in legacy key
+            mockLocalStorage['savedFilters'] = JSON.stringify(legacyData);
+
+            // Load filters - should trigger migration from legacy key
+            const filters = manager.loadFilters('test-view', basicSchema);
+
+            expect(filters).toHaveLength(1);
+            expect(filters[0].name).toBe('Legacy Key Filter');
+            expect(filters[0].state).toBeInstanceOf(Map);
+            expect(filters[0].formatRevision).toBe('2025-09-19T00:00:00.000Z'); // CURRENT_FORMAT_REVISION
+
+            // Check that data was moved to new key
+            expect(mockLocalStorage['dtvSavedFilters']).toBeDefined();
+            expect(mockLocalStorage['savedFilters']).toBeUndefined(); // Should be removed
+
+            // Verify the migrated data
+            const savedData = JSON.parse(mockLocalStorage['dtvSavedFilters']);
+            expect(savedData[0].formatRevision).toBe('2025-09-19T00:00:00.000Z');
+            expect(Array.isArray(savedData[0].state)).toBe(false); // Should be object now
+
+            // Verify info messages were logged and restore console
+            expect(consoleSpy).toHaveBeenCalledWith('Found saved filters in legacy localStorage key, migrating...');
+            expect(consoleSpy).toHaveBeenCalledWith("Migrated 1 filters from legacy localStorage key 'savedFilters' to 'dtvSavedFilters'");
+            expect(consoleSpy).toHaveBeenCalledWith('Migrated filters from old array format to new object format');
+            consoleSpy.mockRestore();
+        });
+
+        it('should handle invalid state format during array conversion gracefully', () => {
+            // Mock console.warn and console.info to suppress expected output in tests
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+            const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+
+            // Create old format data with invalid state (not an array)
+            const invalidFormatData = [
+                {
+                    id: 'invalid-state-filter',
+                    name: 'Invalid State Filter',
+                    view: 'test-view',
+                    state: 'not-an-array', // This should trigger console.warn
+                    createdAt: new Date().toISOString(),
+                    formatRevision: '2025-09-04T00:00:00.000Z' // OLD_ARRAY_FORMAT_REVISION
+                }
+            ];
+
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify(invalidFormatData);
+
+            // Load filters - should trigger warning about invalid state format
+            const filters = manager.loadFilters('test-view', basicSchema);
+
+            // Should still return the filter; state now contains default leaf entries for schema-defined filters
+            expect(filters).toHaveLength(1);
+            expect(filters[0].name).toBe('Invalid State Filter');
+            expect(filters[0].state).toBeInstanceOf(Map);
+            // basicSchema has 1 filter (email-filter)
+            expect(filters[0].state.size).toBe(1);
+
+            // Verify warning was logged and restore console
+            expect(consoleWarnSpy).toHaveBeenCalledWith('Expected array for conversion but got:', 'string');
+            consoleWarnSpy.mockRestore();
+            consoleInfoSpy.mockRestore();
+        });
+    });
+
+    describe('saveFilter', () => {
+        it('should save filter to localStorage', () => {
+            const filterState = new Map([
+                ['email-filter', {
+                    type: 'leaf' as const,
+                    field: 'email',
+                    value: 'test@example.com',
+                    control: { type: 'text' as const },
+                    filterType: 'equals' as const
+                }]
+            ]);
+
+            const filterToSave = {
+                name: 'Test Filter',
+                view: 'test-view',
+                state: filterState
+            };
+
+            const savedFilter = manager.saveFilter(filterToSave);
+
+            expect(savedFilter.id).toBe('test-uuid-1');
+            expect(savedFilter.name).toBe('Test Filter');
+            expect(savedFilter.state).toBeInstanceOf(Map);
+            expect(savedFilter.createdAt).toBeInstanceOf(Date);
+            expect(savedFilter.formatRevision).toBe(CURRENT_FORMAT_REVISION);
+
+            // Check localStorage was called
+            expect(localStorage.setItem).toHaveBeenCalledWith(
+                'dtvSavedFilters',
+                expect.stringContaining('Test Filter')
+            );
+        });
+
+        it('should save multiple filters', () => {
+            const filterState = new Map([
+                ['email-filter', {
+                    type: 'leaf' as const,
+                    field: 'email',
+                    value: 'test@example.com',
+                    control: { type: 'text' as const },
+                    filterType: 'equals' as const
+                }]
+            ]);
+
+            const filter1 = { name: 'Filter 1', view: 'test-view', state: filterState };
+            const filter2 = { name: 'Filter 2', view: 'test-view', state: filterState };
+
+            manager.saveFilter(filter1);
+            manager.saveFilter(filter2);
+
+            const loadedFilters = manager.loadFilters('test-view', basicSchema);
+            expect(loadedFilters).toHaveLength(2);
+        });
+    });
+
+    describe('updateFilter', () => {
+        it('should update existing filter', () => {
+            const filterState = new Map([
+                ['email-filter', {
+                    type: 'leaf' as const,
+                    field: 'email',
+                    value: 'test@example.com',
+                    control: { type: 'text' as const },
+                    filterType: 'equals' as const
+                }]
+            ]);
+
+            const existingFilter: SavedFilter = {
+                id: 'existing-id',
+                name: 'Old Name',
+                view: 'test-view',
+                state: filterState,
+                createdAt: new Date(),
+                formatRevision: CURRENT_FORMAT_REVISION
+            };
+
+            // Manually add to localStorage to simulate existing filter
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify([{
+                id: 'existing-id',
+                name: 'Old Name',
+                view: 'test-view',
+                state: { 'email-filter': { type: 'leaf', field: 'email', value: 'test@example.com', control: { type: 'text' } } },
+                createdAt: new Date().toISOString(),
+                formatRevision: CURRENT_FORMAT_REVISION
+            }]);
+
+            const updates = { name: 'Updated Name' };
+            const updatedFilter = manager.updateFilter(existingFilter, updates);
+
+            expect(updatedFilter).not.toBeNull();
+            expect(updatedFilter!.name).toBe('Updated Name');
+            expect(updatedFilter!.id).toBe('existing-id');
+        });
+
+        it('should return null for non-existent filter', () => {
+            const filterState = new Map([
+                ['email-filter', {
+                    type: 'leaf' as const,
+                    field: 'email',
+                    value: 'test@example.com',
+                    control: { type: 'text' as const },
+                    filterType: 'equals' as const
+                }]
+            ]);
+
+            const nonExistentFilter: SavedFilter = {
+                id: 'non-existent',
+                name: 'Non-existent',
+                view: 'test-view',
+                state: filterState,
+                createdAt: new Date(),
+                formatRevision: CURRENT_FORMAT_REVISION
+            };
+
+            const result = manager.updateFilter(nonExistentFilter, { name: 'New Name' });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('deleteFilter', () => {
+        it('should delete existing filter', () => {
+            const savedData = [
+                {
+                    id: 'filter-to-delete',
+                    name: 'Filter to Delete',
+                    view: 'test-view',
+                    state: {},
+                    createdAt: new Date().toISOString(),
+                    formatRevision: CURRENT_FORMAT_REVISION
+                }
+            ];
+            mockLocalStorage['dtvSavedFilters'] = JSON.stringify(savedData);
+
+            const result = manager.deleteFilter('filter-to-delete');
+            expect(result).toBe(true);
+
+            // Verify the filter was removed
+            const remainingFilters = manager.loadFilters('test-view', basicSchema);
+            expect(remainingFilters).toHaveLength(0);
+        });
+
+        it('should return false for non-existent filter', () => {
+            const result = manager.deleteFilter('non-existent-id');
+            expect(result).toBe(false);
+        });
+    });
+});