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

package/dist/state/state.time-value-resolution.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const state_1 = require("./state");
+describe('State — TimeValue resolution', () => {
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    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 });
+            // 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 });
+            // 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 });
+            // 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 });
+            // 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 });
+            // 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();
+        });
+    });
+});

package/dist/types/extraction.test.js

@@ -3,52 +3,84 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const test_utils_1 = require("../common/test-utils");
 const jest_setup_1 = require("../tests/jest.setup");
 const extraction_1 = require("./extraction");
-// Test the EventContext interface and related extraction types
 describe('ExtractionTypes', () => {
-    const baseEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-        payload: { event_type: extraction_1.EventType.StartExtractingData },
-    });
-    it('should create event context without optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        // If this compiles, the test passes
-        expect(event).toBeDefined();
-        expect(event.payload.event_context).toBeDefined();
-    });
     it('should create event context with all optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', extract_to: '2024-06-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extract_from: true });
-        expect(event).toBeDefined();
+        // Arrange & Act
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingData,
+                event_context: {
+                    extract_from: '2024-01-01T00:00:00Z',
+                    extract_to: '2024-06-01T00:00:00Z',
+                    initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED,
+                    reset_extract_from: true,
+                },
+            },
+        });
+        // Assert
         expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
         expect(event.payload.event_context.extract_to).toBe('2024-06-01T00:00:00Z');
         expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.TIME_SCOPED);
         expect(event.payload.event_context.reset_extract_from).toBe(true);
     });
     it('should create event context with partial optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z' });
-        expect(event).toBeDefined();
+        // Arrange & Act
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingData,
+                event_context: {
+                    extract_from: '2024-01-01T00:00:00Z',
+                },
+            },
+        });
+        // Assert
         expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
     });
     it('should handle different InitialSyncScope values', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { initial_sync_scope: extraction_1.InitialSyncScope.FULL_HISTORY });
+        // Arrange & Act
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingData,
+                event_context: {
+                    initial_sync_scope: extraction_1.InitialSyncScope.FULL_HISTORY,
+                },
+            },
+        });
+        // Assert
         expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.FULL_HISTORY);
     });
     it('[edge] should handle null event context gracefully', () => {
-        const event = Object.assign({}, baseEvent);
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        // Act
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         event.payload.event_context = null;
+        // Assert
         expect(event.payload.event_context).toBeNull();
     });
     it('[edge] should handle undefined optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: undefined, extract_to: undefined, initial_sync_scope: undefined, reset_extract_from: undefined });
+        // Arrange & Act
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingData,
+                event_context: {
+                    extract_from: undefined,
+                    extract_to: undefined,
+                    initial_sync_scope: undefined,
+                    reset_extract_from: undefined,
+                },
+            },
+        });
+        // Assert
         expect(event.payload.event_context.extract_from).toBeUndefined();
         expect(event.payload.event_context.extract_to).toBeUndefined();
         expect(event.payload.event_context.initial_sync_scope).toBeUndefined();
         expect(event.payload.event_context.reset_extract_from).toBeUndefined();
     });
     it('[edge] should handle explicit boolean values for reset_extract_from', () => {
+        // Arrange & Act
         const eventWithTrue = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
             payload: {
                 event_type: extraction_1.EventType.StartExtractingData,
@@ -65,6 +97,7 @@ describe('ExtractionTypes', () => {
                 },
             },
         });
+        // Assert
         expect(eventWithTrue.payload.event_context.reset_extract_from).toBe(true);
         expect(eventWithFalse.payload.event_context.reset_extract_from).toBe(false);
         expect(typeof eventWithTrue.payload.event_context.reset_extract_from).toBe('boolean');
@@ -72,6 +105,7 @@ describe('ExtractionTypes', () => {
     });
     describe('TimeValueType enum', () => {
         it('should have all expected values', () => {
+            // Assert
             expect(extraction_1.TimeValueType.WORKERS_OLDEST).toBe('workers_oldest');
             expect(extraction_1.TimeValueType.WORKERS_OLDEST_MINUS_WINDOW).toBe('workers_oldest_minus_window');
             expect(extraction_1.TimeValueType.WORKERS_NEWEST).toBe('workers_newest');
@@ -81,7 +115,9 @@ describe('ExtractionTypes', () => {
             expect(extraction_1.TimeValueType.UNBOUNDED).toBe('unbounded');
         });
         it('should have exactly seven values', () => {
+            // Act
             const values = Object.values(extraction_1.TimeValueType);
+            // Assert
             expect(values.length).toBe(7);
         });
     });

package/dist/uploader/uploader.helpers.test.js

@@ -10,19 +10,8 @@ const zlib_1 = __importDefault(require("zlib"));
 const constants_1 = require("../common/constants");
 const uploader_helpers_1 = require("./uploader.helpers");
 describe('uploader.helpers', () => {
-    let consoleErrorSpy;
-    let consoleLogSpy;
-    let consoleWarnSpy;
-    beforeEach(() => {
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-    });
     afterEach(() => {
         jest.clearAllMocks();
-        consoleErrorSpy.mockRestore();
-        consoleLogSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
     });
     describe(uploader_helpers_1.compressGzip.name, () => {
         it('should compress a string to gzip buffer', () => {

package/dist/uploader/uploader.test.js

@@ -87,7 +87,6 @@ describe(uploader_1.Uploader.name, () => {
             // Act
             const result = await uploader.upload(itemType, fetchedObjects);
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.artifact).toBeUndefined();
         });
@@ -100,7 +99,6 @@ describe(uploader_1.Uploader.name, () => {
             // Act
             const result = await uploader.upload(itemType, fetchedObjects);
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.artifact).toBeUndefined();
         });
@@ -115,7 +113,6 @@ describe(uploader_1.Uploader.name, () => {
             // Act
             const result = await uploader.upload(itemType, fetchedObjects);
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.artifact).toBeUndefined();
         });
@@ -127,7 +124,6 @@ describe(uploader_1.Uploader.name, () => {
             // Act
             const result = await uploader.upload(itemType, fetchedObjects);
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.artifact).toBeUndefined();
         });
@@ -246,7 +242,6 @@ describe(uploader_1.Uploader.name, () => {
             const result = await uploader.confirmArtifactUpload(artifactId);
             // Assert
             expect(result.response).toBeUndefined();
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
         });
     });
@@ -476,7 +471,6 @@ describe(uploader_1.Uploader.name, () => {
                 artifact: artifactId,
             });
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.attachments).toBeUndefined();
         });
@@ -490,7 +484,6 @@ describe(uploader_1.Uploader.name, () => {
                 artifact: artifactId,
             });
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.attachments).toBeUndefined();
         });
@@ -506,7 +499,6 @@ describe(uploader_1.Uploader.name, () => {
                 artifact: artifactId,
             });
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.attachments).toBeUndefined();
         });
@@ -523,7 +515,6 @@ describe(uploader_1.Uploader.name, () => {
                 artifact: artifactId,
             });
             // Assert
-            expect(result.error).toBeDefined();
             expect(result.error).toHaveProperty('message');
             expect(result.attachments).toBeUndefined();
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.19.4-beta.0",
+  "version": "1.19.5",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -11,11 +11,12 @@
     "start": "ts-node src/index.ts",
     "lint": "eslint .",
     "lint:fix": "eslint .  --fix",
-    "test": "jest --forceExit --maxWorkers=50% --selectProjects default --",
-    "test:backwards-compatibility": "jest --forceExit --selectProjects backwards-compatibility --",
-    "test:timeout-handling": "jest --forceExit --selectProjects timeout-handling --",
-    "test:slow": "jest --forceExit --selectProjects slow --",
-    "test:coverage": "jest --forceExit --coverage --runInBand --"
+    "test": "jest --silent --forceExit --maxWorkers=50% --selectProjects default --",
+    "test:backwards-compatibility": "jest --silent --forceExit --selectProjects backwards-compatibility --",
+    "test:timeout-handling": "jest --silent --forceExit --selectProjects timeout-handling --",
+    "test:slow": "jest --silent --forceExit --selectProjects slow --",
+    "test:coverage": "jest --silent --forceExit --coverage --runInBand --",
+    "test:debug": "jest --forceExit --selectProjects default --"
   },
   "repository": {
     "type": "git",

package/dist/multithreading/worker-adapter/worker-adapter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=worker-adapter.test.d.ts.map

package/dist/multithreading/worker-adapter/worker-adapter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-adapter.test.d.ts","sourceRoot":"","sources":["../../../src/multithreading/worker-adapter/worker-adapter.test.ts"],"names":[],"mappings":""}