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

package/dist/multithreading/adapters/base-adapter.d.ts

@@ -0,0 +1,56 @@
+import { BaseState } from '../../state/base-state';
+import { BaseSdkState } from '../../state/state.interfaces';
+import { AirSyncEvent, EventData, ExtractorEventType } from '../../types/extraction';
+import { LoaderEventType } from '../../types/loading';
+import { WorkerAdapterOptions } from '../../types/workers';
+import { Uploader } from '../../uploader/uploader';
+/**
+ * BaseAdapter holds the state and behavior shared by both sync modes and owns
+ * the `emit` control-protocol flow as a template method. Mode-specific adapters
+ * (`ExtractionAdapter`, `LoadingAdapter`) implement the abstract hooks to inject
+ * their own pre-emit work and event payload shaping.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ * @typeParam StateClass - the mode's `BaseState` subclass
+ */
+export declare abstract class BaseAdapter<ConnectorState, StateClass extends BaseState<ConnectorState, BaseSdkState>> {
+    readonly event: AirSyncEvent;
+    readonly options?: WorkerAdapterOptions;
+    isTimeout: boolean;
+    hasWorkerEmitted: boolean;
+    protected adapterState: StateClass;
+    protected uploader: Uploader;
+    constructor({ event, adapterState, options, }: {
+        event: AirSyncEvent;
+        adapterState: StateClass;
+        options?: WorkerAdapterOptions;
+    });
+    get state(): ConnectorState;
+    set state(value: ConnectorState);
+    postState(): Promise<void>;
+    /**
+     * Pre-emit hook run before any state is persisted or the event is sent.
+     * Extraction uploads pending repos and updates extraction boundaries here;
+     * loading has nothing to do. Throwing aborts the emit (the caller signals
+     * worker exit).
+     */
+    protected abstract beforeEmit(newEventType: ExtractorEventType | LoaderEventType): Promise<void>;
+    /**
+     * Builds the mode-specific extras merged into the emitted event payload
+     * (extraction: artifacts; loading: reports + processed files).
+     */
+    protected abstract buildEmitPayload(newEventType: ExtractorEventType | LoaderEventType): EventData;
+    /**
+     * Post-emit hook run after the event has been sent successfully. Extraction
+     * clears its accumulated artifacts here; loading has nothing to do.
+     */
+    protected abstract afterEmit(newEventType: ExtractorEventType | LoaderEventType): void;
+    /**
+     *  Emits an event to the platform.
+     *
+     * @param newEventType - The event type to be emitted
+     * @param data - The data to be sent with the event
+     */
+    emit(newEventType: ExtractorEventType | LoaderEventType, data?: EventData): Promise<void>;
+}
+//# sourceMappingURL=base-adapter.d.ts.map

package/dist/multithreading/adapters/base-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.d.ts","sourceRoot":"","sources":["../../../src/multithreading/adapters/base-adapter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EACL,YAAY,EACZ,SAAS,EACT,kBAAkB,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EACL,oBAAoB,EAGrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD;;;;;;;;GAQG;AACH,8BAAsB,WAAW,CAC/B,cAAc,EACd,UAAU,SAAS,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC;IAE1D,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC;IACxC,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAE1B,SAAS,CAAC,YAAY,EAAE,UAAU,CAAC;IACnC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC;gBAEjB,EACV,KAAK,EACL,YAAY,EACZ,OAAO,GACR,EAAE;QACD,KAAK,EAAE,YAAY,CAAC;QACpB,YAAY,EAAE,UAAU,CAAC;QACzB,OAAO,CAAC,EAAE,oBAAoB,CAAC;KAChC;IAYD,IAAI,KAAK,IAAI,cAAc,CAE1B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,cAAc,EAE9B;IAEK,SAAS;IAMf;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,UAAU,CAC3B,YAAY,EAAE,kBAAkB,GAAG,eAAe,GACjD,OAAO,CAAC,IAAI,CAAC;IAEhB;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CACjC,YAAY,EAAE,kBAAkB,GAAG,eAAe,GACjD,SAAS;IAEZ;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAC1B,YAAY,EAAE,kBAAkB,GAAG,eAAe,GACjD,IAAI;IAEP;;;;;OAKG;IACG,IAAI,CACR,YAAY,EAAE,kBAAkB,GAAG,eAAe,EAClD,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,IAAI,CAAC;CAkEjB"}

package/dist/multithreading/adapters/base-adapter.emit.test.d.ts

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

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

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

package/dist/multithreading/adapters/base-adapter.emit.test.js

@@ -0,0 +1,403 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../common/constants");
+const extraction_state_1 = require("../../state/extraction-state");
+const loading_state_1 = require("../../state/loading-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 extraction_adapter_1 = require("./extraction-adapter");
+const loading_adapter_1 = require("./loading-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 },
+    };
+    const adapterState = new extraction_state_1.ExtractionState({ event, initialState });
+    adapterState.sdkState.snapInVersionId = '';
+    adapterState.sdkState.toDevRev = {
+        attachmentsMetadata: {
+            artifactIds: [],
+            lastProcessed: 0,
+            lastProcessedAttachmentsIdsList: [],
+        },
+    };
+    const adapter = new extraction_adapter_1.ExtractionAdapter({ event, adapterState });
+    return { adapter, event, adapterState };
+}
+function makeLoadingAdapter(eventType = types_1.EventType.StartLoadingData) {
+    const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+        payload: { event_type: eventType },
+    });
+    const initialState = {
+        attachments: { completed: false },
+    };
+    const adapterState = new loading_state_1.LoadingState({ event, initialState });
+    adapterState.sdkState.snapInVersionId = '';
+    const adapter = new loading_adapter_1.LoadingAdapter({ event, adapterState });
+    return { adapter, event, adapterState };
+}
+describe(`${extraction_adapter_1.ExtractionAdapter.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');
+        const { adapter: loadingAdapter } = makeLoadingAdapter();
+        loadingAdapter['adapterState'].postState = jest
+            .fn()
+            .mockResolvedValue(undefined);
+        loadingAdapter['loaderReports'] = [
+            { item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 },
+        ];
+        loadingAdapter['_processedFiles'] = ['file-1', 'file-2'];
+        // Act
+        await loadingAdapter.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' },
+        ];
+        // 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,
+        ];
+        const { adapter: loadingAdapter } = makeLoadingAdapter();
+        loadingAdapter['adapterState'].postState = jest
+            .fn()
+            .mockResolvedValue(undefined);
+        for (const eventType of loaderEvents) {
+            jest.clearAllMocks();
+            loadingAdapter.hasWorkerEmitted = false;
+            // Act
+            await loadingAdapter.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 adapterState;
+    let mockPostMessage;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ({ adapter, adapterState } = 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(adapterState.sdkState.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe('2024-06-01T00:00:00.000Z');
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe('2024-06-01T00:00:00.000Z');
+            expect(adapterState.sdkState.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(adapterState.sdkState.workersNewest).toBe('2025-07-01T00:00:00.000Z');
+            await emitDone(adapter, '2025-07-01T00:00:00.000Z', '2025-08-01T00:00:00.000Z');
+            expect(adapterState.sdkState.workersNewest).toBe('2025-08-01T00:00:00.000Z');
+            expect(adapterState.sdkState.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) => {
+            adapterState.sdkState.workersOldest = '2025-01-01T00:00:00.000Z';
+            adapterState.sdkState.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(adapterState.sdkState.workersOldest).toBe('2025-01-01T00:00:00.000Z');
+            expect(adapterState.sdkState.workersNewest).toBe('2025-03-01T00:00:00.000Z');
+        });
+    });
+});

package/dist/multithreading/adapters/base-adapter.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const constants_1 = require("../../common/constants");
+const control_protocol_1 = require("../../common/control-protocol");
+const helpers_1 = require("../../common/helpers");
+const logger_1 = require("../../logger/logger");
+const logger_context_1 = require("../../logger/logger.context");
+const workers_1 = require("../../types/workers");
+const uploader_1 = require("../../uploader/uploader");
+/**
+ * BaseAdapter holds the state and behavior shared by both sync modes and owns
+ * the `emit` control-protocol flow as a template method. Mode-specific adapters
+ * (`ExtractionAdapter`, `LoadingAdapter`) implement the abstract hooks to inject
+ * their own pre-emit work and event payload shaping.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ * @typeParam StateClass - the mode's `BaseState` subclass
+ */
+class BaseAdapter {
+    constructor({ event, adapterState, options, }) {
+        this.event = event;
+        this.options = options;
+        this.adapterState = adapterState;
+        this.hasWorkerEmitted = false;
+        this.isTimeout = false;
+        this.uploader = new uploader_1.Uploader({
+            event,
+            options,
+        });
+    }
+    get state() {
+        return this.adapterState.state;
+    }
+    set state(value) {
+        this.adapterState.state = value;
+    }
+    async postState() {
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            await this.adapterState.postState();
+        });
+    }
+    /**
+     *  Emits an event to the platform.
+     *
+     * @param newEventType - The event type to be emitted
+     * @param data - The data to be sent with the event
+     */
+    async emit(newEventType, data) {
+        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+            var _a;
+            if (this.hasWorkerEmitted) {
+                console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
+                return;
+            }
+            try {
+                await this.beforeEmit(newEventType);
+            }
+            catch (error) {
+                console.error('Error while preparing to emit event', error);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                this.hasWorkerEmitted = true;
+                return;
+            }
+            // We want to save the state every time we emit an event, except for the start and delete events
+            if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
+                console.log(`Saving state before emitting event with event type: ${newEventType}.`);
+                try {
+                    await this.adapterState.postState();
+                }
+                catch (error) {
+                    console.error('Error while posting state', error);
+                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                    this.hasWorkerEmitted = true;
+                    return;
+                }
+            }
+            try {
+                // Always prune error messages to make them shorter before emit
+                if ((_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message) {
+                    data.error.message = (0, helpers_1.truncateMessage)(data.error.message);
+                }
+                await (0, control_protocol_1.emit)({
+                    eventType: newEventType,
+                    event: this.event,
+                    data: Object.assign(Object.assign({}, data), this.buildEmitPayload(newEventType)),
+                });
+                const message = {
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
+                    payload: { eventType: newEventType },
+                };
+                this.afterEmit(newEventType);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
+                this.hasWorkerEmitted = true;
+            }
+            catch (error) {
+                console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                this.hasWorkerEmitted = true;
+            }
+        });
+    }
+}
+exports.BaseAdapter = BaseAdapter;

package/dist/multithreading/adapters/extraction-adapter.artifacts.test.d.ts

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

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

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

package/dist/multithreading/{worker-adapter/worker-adapter.artifacts.test.js → adapters/extraction-adapter.artifacts.test.js}

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const state_1 = require("../../state/state");
+const constants_1 = require("../../common/constants");
+const extraction_state_1 = require("../../state/extraction-state");
+const jest_setup_1 = require("../../tests/jest.setup");
 const test_helpers_1 = require("../../tests/test-helpers");
+const test_utils_1 = require("../../common/test-utils");
 const types_1 = require("../../types");
-const worker_adapter_1 = require("./worker-adapter");
+const extraction_adapter_1 = require("./extraction-adapter");
 // 1. Create a mock function for the method you want to override.
 const mockUpload = (itemType, objects) => {
     return {
@@ -49,12 +52,14 @@ describe('Artifact ordering when artifacts overflow batch sizes in repositories'
     let testAdapter;
     beforeEach(() => {
         // Create a fresh adapter instance for this test to avoid mocking conflicts
-        const mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
-        const mockAdapterState = new state_1.State({
+        const mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: types_1.EventType.StartExtractingData },
+        });
+        const mockAdapterState = new extraction_state_1.ExtractionState({
             event: mockEvent,
             initialState: { attachments: { completed: false } },
         });
-        testAdapter = new worker_adapter_1.WorkerAdapter({
+        testAdapter = new extraction_adapter_1.ExtractionAdapter({
             event: mockEvent,
             adapterState: mockAdapterState,
             options: {
@@ -125,3 +130,46 @@ describe('Artifact ordering when artifacts overflow batch sizes in repositories'
         expect(checkArtifactOrder(artifacts, repos)).toBe(true);
     });
 });
+describe('External sync units splitting into artifacts', () => {
+    let testAdapter;
+    beforeEach(() => {
+        const mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: types_1.EventType.StartExtractingExternalSyncUnits },
+        });
+        const mockAdapterState = new extraction_state_1.ExtractionState({
+            event: mockEvent,
+            initialState: {},
+        });
+        testAdapter = new extraction_adapter_1.ExtractionAdapter({
+            event: mockEvent,
+            adapterState: mockAdapterState,
+        });
+    });
+    it('should split 125k external sync units into 5 artifacts', async () => {
+        const BATCH_SIZE = 25000;
+        const TOTAL_UNITS = 125000;
+        const externalSyncUnits = Array.from({ length: TOTAL_UNITS }, (_, i) => ({
+            id: String(i),
+            name: `Unit ${i}`,
+            description: `Description ${i}`,
+        }));
+        testAdapter.initializeRepos([
+            {
+                itemType: constants_1.AirSyncDefaultItemTypes.EXTERNAL_SYNC_UNITS,
+                overridenOptions: {
+                    batchSize: BATCH_SIZE,
+                    skipConfirmation: true,
+                },
+            },
+        ]);
+        const repo = testAdapter.getRepo(constants_1.AirSyncDefaultItemTypes.EXTERNAL_SYNC_UNITS);
+        const chunkSize = 10000;
+        for (let i = 0; i < TOTAL_UNITS; i += chunkSize) {
+            await (repo === null || repo === void 0 ? void 0 : repo.push(externalSyncUnits.slice(i, i + chunkSize)));
+        }
+        await testAdapter.uploadAllRepos();
+        expect(testAdapter.artifacts.length).toBe(TOTAL_UNITS / BATCH_SIZE // 5
+        );
+        expect(testAdapter.artifacts.every((a) => a.item_type === constants_1.AirSyncDefaultItemTypes.EXTERNAL_SYNC_UNITS)).toBe(true);
+    });
+});