@devrev/ts-adaas 1.19.4-beta.0 → 1.19.5

package/dist/state/state.test.js

@@ -41,7 +41,7 @@ describe(state_1.State.name, () => {
         expect(postStateSpy).not.toHaveBeenCalled();
         expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails for event type %s', async (eventType) => {
         // Arrange
         const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
             payload: { event_type: eventType },
@@ -50,7 +50,6 @@ describe(state_1.State.name, () => {
             isAxiosError: true,
             response: { status: 500 },
         });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
         await expect((0, state_1.createAdapterState)({
             event,
@@ -59,13 +58,12 @@ describe(state_1.State.name, () => {
         })).rejects.toThrow('process.exit called');
         expect(processExitSpy).toHaveBeenCalledWith(1);
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails for event type %s', async (eventType) => {
         // Arrange
         const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
             payload: { event_type: eventType },
         });
         fetchStateSpy.mockResolvedValue({ state: 'invalid-json' });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
         await expect((0, state_1.createAdapterState)({
             event,
@@ -74,13 +72,12 @@ describe(state_1.State.name, () => {
         })).rejects.toThrow('process.exit called');
         expect(processExitSpy).toHaveBeenCalledWith(1);
     });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response', async (eventType) => {
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response for event type %s', async (eventType) => {
         // Arrange
         const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
             payload: { event_type: eventType },
         });
         fetchStateSpy.mockResolvedValue({ state: null });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
         await expect((0, state_1.createAdapterState)({
             event,
@@ -110,7 +107,6 @@ describe(state_1.State.name, () => {
         postStateSpy.mockResolvedValue({
             success: true,
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
         await (0, state_1.createAdapterState)({
             event,
@@ -141,7 +137,6 @@ describe(state_1.State.name, () => {
         postStateSpy.mockResolvedValue({
             success: true,
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
         await (0, state_1.createAdapterState)({
             event,
@@ -165,8 +160,6 @@ describe(state_1.State.name, () => {
                 test: 'test',
             }),
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
         // Act & Assert
         await expect((0, state_1.createAdapterState)({
             event,
@@ -188,7 +181,6 @@ describe(state_1.State.name, () => {
             snapInVersionId: '1.0.0',
         });
         fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act & Assert
         await (0, state_1.createAdapterState)({
             event,
@@ -214,7 +206,6 @@ describe(state_1.State.name, () => {
         installInitialDomainMappingSpy.mockResolvedValue({
             success: true,
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
         await (0, state_1.createAdapterState)({
             event,
@@ -224,498 +215,6 @@ describe(state_1.State.name, () => {
         // Assert
         expect(installInitialDomainMappingSpy).toHaveBeenCalled();
     });
-    describe('Enhanced Control Protocol - TimeValue resolution failures', () => {
-        it('should exit the process if extraction_start_time resolution fails', async () => {
-            // Arrange: WORKERS_NEWEST type but state has no workersNewest
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.WORKERS_NEWEST,
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-                workers_oldest: '',
-                workers_newest: '',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            jest.spyOn(console, 'error').mockImplementation(() => { });
-            // Act & Assert
-            await expect((0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should exit the process if extraction_end_time resolution fails', async () => {
-            // Arrange: WORKERS_NEWEST type but state has no workersNewest
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.UNBOUNDED,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.WORKERS_NEWEST,
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-                workers_oldest: '',
-                workers_newest: '',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            jest.spyOn(console, 'error').mockImplementation(() => { });
-            // Act & Assert
-            await expect((0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-    });
-    describe('Backwards compatibility - missing TimeValue type', () => {
-        it('should skip resolution when extraction_start_time has no type', async () => {
-            // Arrange: platform sends extraction_start_time without a type field (old platform version)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {},
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            const state = await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: should not crash, extract_from is not set, extract_to is resolved
-            expect(processExitSpy).not.toHaveBeenCalled();
-            expect(event.payload.event_context.extract_from).toBeUndefined();
-            expect(event.payload.event_context.extract_to).toBe('2025-06-01T00:00:00.000Z');
-            expect(state.state.pendingWorkersNewest).toBe('2025-06-01T00:00:00.000Z');
-        });
-        it('should skip resolution when extraction_end_time has no type', async () => {
-            // Arrange: platform sends extraction_end_time without a type field
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                        extraction_end_time: {},
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: should not crash, extract_to is not set, extract_from is resolved
-            expect(processExitSpy).not.toHaveBeenCalled();
-            expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00.000Z');
-            expect(event.payload.event_context.extract_to).toBeUndefined();
-        });
-        it('should skip resolution when both extraction times have no type', async () => {
-            // Arrange: platform sends both time values without type fields
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            value: 'some-value',
-                        },
-                        extraction_end_time: {
-                            value: 'some-value',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: should not crash, neither extraction time is resolved
-            expect(processExitSpy).not.toHaveBeenCalled();
-            expect(event.payload.event_context.extract_from).toBeUndefined();
-            expect(event.payload.event_context.extract_to).toBeUndefined();
-        });
-    });
-    describe('Enhanced Control Protocol - extraction window validation', () => {
-        it('should exit the process if extract_from >= extract_to', async () => {
-            // Arrange: start is after end (inverted window)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            jest.spyOn(console, 'error').mockImplementation(() => { });
-            // Act & Assert
-            await expect((0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should exit the process if extract_from equals extract_to', async () => {
-            // Arrange: start equals end (zero-width window)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-06-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            jest.spyOn(console, 'error').mockImplementation(() => { });
-            // Act & Assert
-            await expect((0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should not exit when extract_from < extract_to', async () => {
-            // Arrange: valid window
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-        it('should not validate when only extract_from is set', async () => {
-            // Arrange: only start, no end
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-        it('should not exit when extract_from is UNBOUNDED and extract_to is a real timestamp', async () => {
-            // Arrange: UNBOUNDED start (epoch) with a real ABSOLUTE end timestamp
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.UNBOUNDED,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-    });
-    describe('Pending extraction boundaries (pendingWorkersOldest/pendingWorkersNewest)', () => {
-        const FIXED_NOW = '2026-03-26T10:00:00.000Z';
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.setSystemTime(new Date(FIXED_NOW));
-        });
-        afterEach(() => {
-            jest.useRealTimers();
-        });
-        it('should store resolved values in pendingWorkersOldest/pendingWorkersNewest on StartExtractingMetadata', async () => {
-            // Arrange
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: '',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.UNBOUNDED,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.CURRENT_TIME,
-                        },
-                    },
-                },
-            });
-            fetchStateSpy.mockRejectedValue({
-                isAxiosError: true,
-                response: { status: 404 },
-            });
-            installInitialDomainMappingSpy.mockResolvedValue({ success: true });
-            postStateSpy.mockResolvedValue({ success: true });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            const state = await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert
-            expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
-            expect(state.state.pendingWorkersNewest).toBe(FIXED_NOW);
-            expect(event.payload.event_context.extract_from).toBe('1970-01-01T00:00:00.000Z');
-            expect(event.payload.event_context.extract_to).toBe(FIXED_NOW);
-        });
-        it('should overwrite pending values on a retry (new StartExtractingMetadata after failure)', async () => {
-            // Arrange: state has stale pending values from a previous failed attempt
-            const staleOldest = '2026-03-25T08:00:00.000Z';
-            const staleNewest = '2026-03-25T09:00:00.000Z';
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.UNBOUNDED,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.CURRENT_TIME,
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-                pendingWorkersOldest: staleOldest,
-                pendingWorkersNewest: staleNewest,
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            const state = await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: pending values are overwritten with fresh resolution, not stale values
-            expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
-            expect(state.state.pendingWorkersNewest).toBe(FIXED_NOW);
-            expect(state.state.pendingWorkersNewest).not.toBe(staleNewest);
-        });
-        it('should reuse pending values from state on ContinueExtractingData instead of re-resolving', async () => {
-            // Arrange: state has pending values from a prior StartExtractingMetadata phase
-            const pendingOldest = '1970-01-01T00:00:00.000Z';
-            const pendingNewest = '2026-03-26T08:00:00.000Z'; // Earlier than FIXED_NOW
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: {
-                    event_type: extraction_1.EventType.ContinueExtractingData,
-                    event_context: {
-                        // Platform still sends TimeValue objects, but they should be ignored
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.CURRENT_TIME,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.CURRENT_TIME,
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-                pendingWorkersOldest: pendingOldest,
-                pendingWorkersNewest: pendingNewest,
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            const state = await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: uses cached pending values, NOT new Date() resolution
-            expect(event.payload.event_context.extract_from).toBe(pendingOldest);
-            expect(event.payload.event_context.extract_to).toBe(pendingNewest);
-            // Pending values in state remain unchanged
-            expect(state.state.pendingWorkersOldest).toBe(pendingOldest);
-            expect(state.state.pendingWorkersNewest).toBe(pendingNewest);
-        });
-        it('should not set extract_from/extract_to on ContinueExtractingData if no pending values exist', async () => {
-            // Arrange: state has no pending values (e.g. old state from before this feature)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: { event_type: extraction_1.EventType.ContinueExtractingData },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: no extraction timestamps are set
-            expect(event.payload.event_context.extract_from).toBeUndefined();
-            expect(event.payload.event_context.extract_to).toBeUndefined();
-        });
-        it('should reuse pending values on StartExtractingAttachments', async () => {
-            // Arrange: state has pending values from the StartExtractingMetadata phase
-            const pendingOldest = '1970-01-01T00:00:00.000Z';
-            const pendingNewest = '2026-03-26T08:00:00.000Z';
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                context: {
-                    snap_in_version_id: 'test_snap_in_version_id',
-                },
-                payload: { event_type: extraction_1.EventType.StartExtractingAttachments },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-                pendingWorkersOldest: pendingOldest,
-                pendingWorkersNewest: pendingNewest,
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            jest.spyOn(console, 'log').mockImplementation(() => { });
-            // Act
-            await (0, state_1.createAdapterState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: pending values are reused
-            expect(event.payload.event_context.extract_from).toBe(pendingOldest);
-            expect(event.payload.event_context.extract_to).toBe(pendingNewest);
-        });
-    });
     it('should populate extractionScope from API response', async () => {
         // Arrange
         const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
@@ -731,7 +230,6 @@ describe(state_1.State.name, () => {
                 users: { extract: true },
             }),
         });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
         const result = await (0, state_1.createAdapterState)({
             event,
@@ -758,7 +256,6 @@ describe(state_1.State.name, () => {
         });
         installInitialDomainMappingSpy.mockResolvedValue({ success: true });
         postStateSpy.mockResolvedValue({ success: true });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
         // Act
         const result = await (0, state_1.createAdapterState)({
             event,
@@ -782,4 +279,24 @@ describe(state_1.State.name, () => {
         // Assert
         expect(result.extractionScope).toEqual({});
     });
+    it('should continue with empty extractionScope when objects field contains invalid JSON', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: { snap_in_version_id: '1.0.0' },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+            objects: 'NOT_VALID_JSON',
+        });
+        // Act
+        const result = await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: should not crash, extractionScope is empty (default)
+        expect(result.extractionScope).toEqual({});
+        expect(processExitSpy).not.toHaveBeenCalled();
+    });
 });

package/dist/state/state.time-value-resolution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.time-value-resolution.test.d.ts.map

package/dist/state/state.time-value-resolution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.time-value-resolution.test.d.ts","sourceRoot":"","sources":["../../src/state/state.time-value-resolution.test.ts"],"names":[],"mappings":""}