@devrev/ts-adaas 1.17.1-beta.7 → 1.17.1-beta.8

package/dist/state/state.js

@@ -80,7 +80,7 @@ async function createAdapterState({ event, initialState, initialDomainMapping, o
             ];
             for (const { source, target, pending } of timeFields) {
                 const timeValue = eventContext[source];
-                if (timeValue) {
+                if (timeValue && timeValue.type) {
                     try {
                         const resolved = (0, time_value_resolver_1.resolveTimeValue)(timeValue, as.state);
                         eventContext[target] = resolved;

package/dist/state/state.test.js

@@ -280,6 +280,99 @@ describe(state_1.State.name, () => {
             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_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    extraction_start_time: {},
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                        value: '2025-06-01T00:00:00Z',
+                    },
+                },
+                contextOverrides: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+            });
+            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_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                        value: '2024-01-01T00:00:00Z',
+                    },
+                    extraction_end_time: {},
+                },
+                contextOverrides: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+            });
+            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_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    extraction_start_time: { value: 'some-value' },
+                    extraction_end_time: { value: 'some-value' },
+                },
+                contextOverrides: {
+                    snap_in_version_id: 'test_snap_in_version_id',
+                },
+            });
+            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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.17.1-beta.7",
+  "version": "1.17.1-beta.8",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",