@devrev/airsync-sdk 2.0.0-beta.1 → 2.0.0-beta.2

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

@@ -0,0 +1,390 @@
+"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 },
+        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('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":""}