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

package/dist/multithreading/spawn/spawn.test.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const constants_1 = require("../../common/constants");
+const extraction_1 = require("../../types/extraction");
+const workers_1 = require("../../types/workers");
+const test_utils_1 = require("../../common/test-utils");
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+jest.mock('../create-worker', () => ({
+    createWorker: jest.fn(),
+}));
+jest.mock('../../common/control-protocol', () => ({
+    emit: jest.fn().mockResolvedValue({}),
+}));
+jest.mock('../../logger/logger', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        log: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        logFn: jest.fn(),
+    })),
+    serializeError: jest.fn((e) => String(e)),
+}));
+jest.mock('../../common/helpers', () => ({
+    getLibraryVersion: jest.fn().mockReturnValue('1.0.0-test'),
+    getMemoryUsage: jest.fn().mockReturnValue({
+        formattedMessage: 'Memory: RSS 100/512MB (19.53%) [...]',
+        rssUsedMB: '100.00',
+        rssUsedPercent: '19.53%',
+        heapUsedPercent: '30.00%',
+        externalMB: '10.00',
+        arrayBuffersMB: '5.00',
+    }),
+    sleep: jest.fn(),
+    truncateFilename: jest.fn((f) => f),
+    truncateMessage: jest.fn((m) => m),
+}));
+// ---------------------------------------------------------------------------
+// Imports after mocks
+// ---------------------------------------------------------------------------
+const spawn_1 = require("./spawn");
+const create_worker_1 = require("../create-worker");
+const control_protocol_1 = require("../../common/control-protocol");
+const helpers_1 = require("../../common/helpers");
+// ---------------------------------------------------------------------------
+// Factory for a fake worker (EventEmitter with postMessage + terminate)
+// ---------------------------------------------------------------------------
+function makeWorker() {
+    const w = new events_1.EventEmitter();
+    w.postMessage = jest.fn();
+    w.terminate = jest.fn().mockResolvedValue(0);
+    return w;
+}
+// ---------------------------------------------------------------------------
+// Helper: instantiate Spawn directly, injecting a mock logger via console swap
+// ---------------------------------------------------------------------------
+function buildSpawn(overrides) {
+    var _a;
+    const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
+        payload: { event_type: extraction_1.EventType.StartExtractingData },
+    });
+    const mockLogger = {
+        log: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        logFn: jest.fn(),
+    };
+    const originalConsole = console;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    global.console = mockLogger;
+    const s = new spawn_1.Spawn({
+        event,
+        worker: overrides.worker,
+        options: overrides.options,
+        resolve: (_a = overrides.resolve) !== null && _a !== void 0 ? _a : jest.fn(),
+        originalConsole: originalConsole,
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    global.console = originalConsole;
+    return s;
+}
+// ---------------------------------------------------------------------------
+// spawn() factory tests
+// ---------------------------------------------------------------------------
+describe('spawn() factory', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers({ legacyFakeTimers: true });
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('should emit a no-script event and NOT spawn a worker for an unknown event type', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
+            payload: { event_type: extraction_1.EventType.UnknownEventType },
+        });
+        // Act
+        await (0, spawn_1.spawn)({ event, initialState: {} });
+        // Assert: no worker process should be started, but the platform should
+        // still receive a terminal event (so the run doesn't hang).
+        expect(create_worker_1.createWorker).not.toHaveBeenCalled();
+        expect(control_protocol_1.emit).toHaveBeenCalledWith(expect.objectContaining({ event, eventType: expect.any(String) }));
+    });
+    it('should reject the returned promise when createWorker throws', async () => {
+        // Arrange
+        create_worker_1.createWorker.mockRejectedValue(new Error('worker boom'));
+        const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        // Act & Assert
+        await expect((0, spawn_1.spawn)({ event, initialState: {}, workerPath: '/fake/path.js' })).rejects.toThrow('worker boom');
+    });
+});
+// ---------------------------------------------------------------------------
+// Spawn class — lifecycle tests
+// ---------------------------------------------------------------------------
+describe('Spawn class', () => {
+    let worker;
+    let resolveMock;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers({ legacyFakeTimers: true });
+        worker = makeWorker();
+        resolveMock = jest.fn();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    // -------------------------------------------------------------------------
+    // WorkerMessageFailed captured and propagated in error emit
+    // -------------------------------------------------------------------------
+    it('should include the WorkerMessageFailed reason in the error event emitted to the platform', async () => {
+        // Arrange
+        buildSpawn({ worker, resolve: resolveMock });
+        // Act
+        worker.emit(workers_1.WorkerEvent.WorkerMessage, {
+            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+            payload: { message: 'connector exploded' },
+        });
+        worker.emit(workers_1.WorkerEvent.WorkerExit, 1);
+        await Promise.resolve();
+        await Promise.resolve();
+        // Assert: the platform receives an error event whose message contains
+        // the reason sent by the worker — this is what operators see in the run log.
+        expect(control_protocol_1.emit).toHaveBeenCalledWith(expect.objectContaining({
+            data: expect.objectContaining({
+                error: expect.objectContaining({
+                    message: expect.stringContaining('connector exploded'),
+                }),
+            }),
+        }));
+        expect(resolveMock).toHaveBeenCalled();
+    });
+    it('should emit a data extraction error when the worker exits without ever emitting', async () => {
+        // Arrange
+        buildSpawn({ worker, resolve: resolveMock });
+        // Act
+        worker.emit(workers_1.WorkerEvent.WorkerExit, 1);
+        await Promise.resolve();
+        await Promise.resolve();
+        // Assert: a silent worker exit must surface a DataExtractionError to the
+        // platform with a non-empty message. The event type is the upstream
+        // contract; the exact message wording is implementation detail.
+        expect(control_protocol_1.emit).toHaveBeenCalledTimes(1);
+        const [emitted] = control_protocol_1.emit.mock.calls[0];
+        expect(emitted.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        expect(emitted.data.error.message).toEqual(expect.any(String));
+        expect(emitted.data.error.message.length).toBeGreaterThan(0);
+        expect(resolveMock).toHaveBeenCalled();
+    });
+    // Soft-timeout and hard-timeout timer behavior is covered end-to-end by
+    // src/tests/timeout-handling/ (real workers, real timers). Unit tests with
+    // fake timers only re-asserted the mocked setTimeout call and gave no signal.
+    // -------------------------------------------------------------------------
+    // Memory monitoring — error clears the interval
+    // -------------------------------------------------------------------------
+    it('should clear the memory monitoring interval when getMemoryUsage throws to prevent repeated crashes', async () => {
+        // Arrange
+        helpers_1.getMemoryUsage.mockImplementation(() => {
+            throw new Error('OOM');
+        });
+        const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+        buildSpawn({ worker, resolve: resolveMock });
+        // Act
+        jest.advanceTimersByTime(30001); // MEMORY_LOG_INTERVAL = 30 s
+        await Promise.resolve();
+        // Assert
+        expect(clearIntervalSpy).toHaveBeenCalled();
+    });
+    // -------------------------------------------------------------------------
+    // Soft-timeout race: worker emits AFTER softTimeoutSent — no double-emit
+    // -------------------------------------------------------------------------
+    it('should NOT emit an error when the worker successfully emits just after receiving the soft-timeout signal', async () => {
+        // Arrange
+        buildSpawn({ worker, resolve: resolveMock });
+        // Act: trigger soft timeout — sends WorkerMessageExit to the worker
+        jest.advanceTimersByTime(constants_1.DEFAULT_LAMBDA_TIMEOUT + 1);
+        await Promise.resolve();
+        // Confirm the soft-timeout path actually fired — guards against a silent
+        // pass if the timeout constant changes and the timer never runs.
+        expect(worker.postMessage).toHaveBeenCalledWith(expect.objectContaining({
+            subject: workers_1.WorkerMessageSubject.WorkerMessageExit,
+        }));
+        // Worker responds: emits its event successfully, then exits normally
+        worker.emit(workers_1.WorkerEvent.WorkerMessage, {
+            subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
+        });
+        worker.emit(workers_1.WorkerEvent.WorkerExit, 0);
+        // The exit handler defers via setImmediate when softTimeoutSent=true
+        jest.runAllImmediates();
+        await Promise.resolve();
+        await Promise.resolve();
+        // Assert: no error should reach the platform — the worker completed its job
+        const errorEmits = control_protocol_1.emit.mock.calls.filter((call) => { var _a, _b; return (_b = (_a = call[0]) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error; });
+        expect(errorEmits).toHaveLength(0);
+        expect(resolveMock).toHaveBeenCalled();
+    });
+});

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

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

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

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

package/dist/multithreading/worker-adapter/worker-adapter.emit.test.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../common/constants");
+const state_1 = require("../../state/state");
+const jest_setup_1 = require("../../tests/jest.setup");
+const test_utils_1 = require("../../common/test-utils");
+const types_1 = require("../../types");
+const loading_1 = require("../../types/loading");
+const worker_adapter_1 = require("./worker-adapter");
+/* eslint-disable @typescript-eslint/no-require-imports */
+jest.mock('../../common/control-protocol', () => ({
+    emit: jest.fn().mockResolvedValue({}),
+}));
+jest.mock('../../mappers/mappers');
+jest.mock('../../uploader/uploader');
+jest.mock('../../repo/repo');
+jest.mock('node:worker_threads', () => ({
+    parentPort: { postMessage: jest.fn() },
+}));
+jest.mock('../../attachments-streaming/attachments-streaming-pool', () => ({
+    AttachmentsStreamingPool: jest.fn().mockImplementation(() => ({
+        streamAll: jest.fn().mockResolvedValue(undefined),
+    })),
+}));
+function makeAdapter(eventType = types_1.EventType.StartExtractingData) {
+    const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+        payload: { event_type: eventType },
+    });
+    const initialState = {
+        attachments: { completed: false },
+        lastSyncStarted: '',
+        lastSuccessfulSyncStarted: '',
+        snapInVersionId: '',
+        toDevRev: {
+            attachmentsMetadata: {
+                artifactIds: [],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        },
+    };
+    const adapterState = new state_1.State({ event, initialState });
+    const adapter = new worker_adapter_1.WorkerAdapter({ event, adapterState });
+    return { adapter, event, adapterState };
+}
+describe(`${worker_adapter_1.WorkerAdapter.name}.emit`, () => {
+    let adapter;
+    let mockPostMessage;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ({ adapter } = makeAdapter());
+        const workerThreads = require('node:worker_threads');
+        mockPostMessage = jest.fn();
+        if (workerThreads.parentPort) {
+            jest
+                .spyOn(workerThreads.parentPort, 'postMessage')
+                .mockImplementation(mockPostMessage);
+        }
+        else {
+            workerThreads.parentPort = { postMessage: mockPostMessage };
+        }
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should emit only one event when multiple events of same type are sent', async () => {
+        // Arrange
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        // Assert
+        expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    });
+    it('should emit only once even when a different event type follows', async () => {
+        // Arrange
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        await adapter.emit(types_1.ExtractorEventType.DataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        await adapter.emit(types_1.ExtractorEventType.AttachmentExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        // Assert
+        expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    });
+    it('should correctly emit one event even if postState errors', async () => {
+        // Arrange
+        adapter['adapterState'].postState = jest
+            .fn()
+            .mockRejectedValue(new Error('postState error'));
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        // Assert
+        expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    });
+    it('should correctly emit one event even if uploadAllRepos errors', async () => {
+        // Arrange
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest
+            .fn()
+            .mockRejectedValue(new Error('uploadAllRepos error'));
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+            reports: [],
+            processed_files: [],
+        });
+        // Assert
+        expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    });
+    it('should include artifacts in data for extraction events', async () => {
+        // Arrange
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        adapter['_artifacts'] = [
+            { id: 'art-1', item_count: 10, item_type: 'issues' },
+        ];
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.DataExtractionDone);
+        // Assert
+        expect(mockEmit).toHaveBeenCalledWith(expect.objectContaining({
+            data: expect.objectContaining({
+                artifacts: expect.arrayContaining([
+                    expect.objectContaining({ id: 'art-1' }),
+                ]),
+            }),
+        }));
+        const callData = mockEmit.mock.calls[0][0].data;
+        expect(callData).not.toHaveProperty('reports');
+        expect(callData).not.toHaveProperty('processed_files');
+    });
+    it('should include reports and processed_files in data for loader events', async () => {
+        // Arrange
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        adapter['loaderReports'] = [
+            { item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 },
+        ];
+        adapter['_processedFiles'] = ['file-1', 'file-2'];
+        // Act
+        await adapter.emit(types_1.LoaderEventType.DataLoadingDone);
+        // Assert
+        expect(mockEmit).toHaveBeenCalledWith(expect.objectContaining({
+            data: expect.objectContaining({
+                reports: expect.arrayContaining([
+                    expect.objectContaining({ item_type: 'tasks' }),
+                ]),
+                processed_files: ['file-1', 'file-2'],
+            }),
+        }));
+        const callData = mockEmit.mock.calls[0][0].data;
+        expect(callData).not.toHaveProperty('artifacts');
+    });
+    it('should not include artifacts, reports, or processed_files for unknown event types', async () => {
+        // Arrange
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        adapter['_artifacts'] = [
+            { id: 'art-1', item_count: 10, item_type: 'issues' },
+        ];
+        adapter['loaderReports'] = [
+            { item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 },
+        ];
+        adapter['_processedFiles'] = ['file-1'];
+        // Act
+        await adapter.emit('SOME_UNKNOWN_EVENT');
+        // Assert
+        const callData = mockEmit.mock.calls[0][0].data;
+        expect(callData).not.toHaveProperty('artifacts');
+        expect(callData).not.toHaveProperty('reports');
+        expect(callData).not.toHaveProperty('processed_files');
+    });
+    it('should include artifacts for all ExtractorEventType values', async () => {
+        var _a, _b;
+        // Arrange
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        const extractorEvents = [
+            types_1.ExtractorEventType.DataExtractionDone,
+            types_1.ExtractorEventType.DataExtractionProgress,
+            types_1.ExtractorEventType.DataExtractionError,
+            types_1.ExtractorEventType.AttachmentExtractionDone,
+            types_1.ExtractorEventType.AttachmentExtractionProgress,
+        ];
+        for (const eventType of extractorEvents) {
+            jest.clearAllMocks();
+            adapter.hasWorkerEmitted = false;
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockResolvedValue(undefined);
+            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+            // Act
+            await adapter.emit(eventType);
+            // Assert
+            const callData = (_b = (_a = mockEmit.mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data;
+            expect(callData).toHaveProperty('artifacts');
+            expect(callData).not.toHaveProperty('reports');
+        }
+    });
+    it('should include reports and processed_files for all LoaderEventType values', async () => {
+        var _a, _b;
+        // Arrange
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        const loaderEvents = [
+            types_1.LoaderEventType.DataLoadingDone,
+            types_1.LoaderEventType.DataLoadingProgress,
+            types_1.LoaderEventType.DataLoadingError,
+            types_1.LoaderEventType.AttachmentLoadingDone,
+            types_1.LoaderEventType.AttachmentLoadingProgress,
+        ];
+        for (const eventType of loaderEvents) {
+            jest.clearAllMocks();
+            adapter.hasWorkerEmitted = false;
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockResolvedValue(undefined);
+            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+            // Act
+            await adapter.emit(eventType);
+            // Assert
+            const callData = (_b = (_a = mockEmit.mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data;
+            expect(callData).toHaveProperty('reports');
+            expect(callData).toHaveProperty('processed_files');
+            expect(callData).not.toHaveProperty('artifacts');
+        }
+    });
+    it('should truncate a long error message, preserving the original prefix', async () => {
+        var _a, _b;
+        // Arrange
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        const longMessage = 'E'.repeat(20000);
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.DataExtractionError, {
+            error: { message: longMessage },
+        });
+        // Assert
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        const emittedMessage = (_b = (_a = mockEmit.mock.calls[0][0].data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.message;
+        expect(emittedMessage.length).toBeLessThan(longMessage.length);
+        expect(emittedMessage.startsWith('E'.repeat(100))).toBe(true);
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name}.emit — ExternalSyncUnitExtractionDone legacy path`, () => {
+    it('should upload ESUs via a repo and strip external_sync_units from the emitted payload', async () => {
+        // Arrange
+        const { adapter } = makeAdapter(types_1.EventType.StartExtractingExternalSyncUnits);
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+        const pushMock = jest.fn().mockResolvedValue(undefined);
+        jest.spyOn(adapter, 'initializeRepos');
+        jest.spyOn(adapter, 'getRepo').mockReturnValue({ push: pushMock });
+        const esus = [{ id: 'esu-1' }, { id: 'esu-2' }];
+        // Act
+        await adapter.emit(types_1.ExtractorEventType.ExternalSyncUnitExtractionDone, {
+            external_sync_units: esus,
+        });
+        // Assert
+        expect(pushMock).toHaveBeenCalledWith(esus);
+        // external_sync_units must NOT appear in the payload sent to the platform
+        // (it would be too large for SQS — that is the entire reason this path exists).
+        const { emit: mockEmit } = require('../../common/control-protocol');
+        const emittedData = mockEmit.mock.calls[0][0].data;
+        expect(emittedData).not.toHaveProperty('external_sync_units');
+    });
+});
+describe('WorkerAdapter — workersOldest / workersNewest boundary updates', () => {
+    let adapter;
+    let mockPostMessage;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ({ adapter } = makeAdapter());
+        const workerThreads = require('node:worker_threads');
+        mockPostMessage = jest.fn();
+        if (workerThreads.parentPort) {
+            jest
+                .spyOn(workerThreads.parentPort, 'postMessage')
+                .mockImplementation(mockPostMessage);
+        }
+        else {
+            workerThreads.parentPort = { postMessage: mockPostMessage };
+        }
+        adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
+        adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    async function emitDone(adapterInstance, extractionStart, extractionEnd) {
+        adapterInstance.event.payload.event_context.extract_from = extractionStart;
+        adapterInstance.event.payload.event_context.extract_to = extractionEnd;
+        // Reset the emit guard so we can emit multiple times within one test.
+        adapterInstance['hasWorkerEmitted'] = false;
+        await adapterInstance.emit(types_1.ExtractorEventType.AttachmentExtractionDone, {
+            reports: [],
+            processed_files: [],
+        });
+    }
+    describe('initial import with UNBOUNDED start', () => {
+        it('should set workersOldest to UNBOUNDED_DATE_TIME_VALUE and workersNewest to extraction end', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
+        });
+    });
+    describe('reconciliation after UNBOUNDED initial import', () => {
+        it('should NOT overwrite workersOldest when reconciliation start is later than sentinel', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
+        });
+        it('should NOT overwrite workersOldest even when reconciliation start is very early', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            await emitDone(adapter, '1980-01-01T00:00:00.000Z', '1990-01-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
+        });
+    });
+    describe('forward sync after UNBOUNDED initial import', () => {
+        it('should expand workersNewest forward while preserving workersOldest', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-06-01T00:00:00.000Z', '2025-07-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapter.state.workersNewest).toBe('2025-07-01T00:00:00.000Z');
+        });
+    });
+    describe('reconciliation with end beyond current newest', () => {
+        it('should expand workersNewest when reconciliation end is later', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            await emitDone(adapter, '2024-01-01T00:00:00.000Z', '2025-08-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapter.state.workersNewest).toBe('2025-08-01T00:00:00.000Z');
+        });
+    });
+    describe('first sync with absolute dates (no UNBOUNDED)', () => {
+        it('should set both boundaries from the extraction range', async () => {
+            await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
+        });
+    });
+    describe('reconciliation after absolute initial sync', () => {
+        it('should expand workersOldest backward when reconciliation start is earlier', async () => {
+            await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
+            await emitDone(adapter, '2024-06-01T00:00:00.000Z', '2025-02-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe('2024-06-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
+        });
+        it('should NOT change boundaries when reconciliation is within existing range', async () => {
+            await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-01-15T00:00:00.000Z', '2025-02-15T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
+        });
+        it('should expand both boundaries when reconciliation exceeds both', async () => {
+            await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
+            await emitDone(adapter, '2024-06-01T00:00:00.000Z', '2025-09-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe('2024-06-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-09-01T00:00:00.000Z');
+        });
+    });
+    describe('multiple forward syncs', () => {
+        it('should progressively expand workersNewest while preserving workersOldest', async () => {
+            await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-06-01T00:00:00.000Z', '2025-07-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-07-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-07-01T00:00:00.000Z', '2025-08-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-08-01T00:00:00.000Z');
+            expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+        });
+    });
+    describe('non-AttachmentExtractionDone events should NOT update boundaries', () => {
+        it.each([
+            types_1.ExtractorEventType.DataExtractionDone,
+            types_1.ExtractorEventType.DataExtractionProgress,
+            types_1.ExtractorEventType.MetadataExtractionError,
+            types_1.ExtractorEventType.AttachmentExtractionError,
+        ])('should not update boundaries on %s', async (eventType) => {
+            adapter.state.workersOldest = '2025-01-01T00:00:00.000Z';
+            adapter.state.workersNewest = '2025-03-01T00:00:00.000Z';
+            adapter.event.payload.event_context.extract_from =
+                '2024-01-01T00:00:00.000Z';
+            adapter.event.payload.event_context.extract_to =
+                '2025-12-01T00:00:00.000Z';
+            await adapter.emit(eventType, {
+                reports: [],
+                processed_files: [],
+            });
+            expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
+        });
+    });
+});

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

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

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

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