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

package/dist/multithreading/create-worker.test.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const worker_threads_1 = require("worker_threads");
-const test_helpers_1 = require("../tests/test-helpers");
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
 const extraction_1 = require("../types/extraction");
 const create_worker_1 = require("./create-worker");
 describe(create_worker_1.createWorker.name, () => {
     it('should create a Worker instance when valid parameters are provided', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingExternalSyncUnits },
+        });
+        // Act
         const worker = worker_threads_1.isMainThread
             ? await (0, create_worker_1.createWorker)({
-                event: (0, test_helpers_1.createEvent)({
-                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
-                }),
+                event,
                 initialState: {},
                 workerPath,
             })
             : null;
+        // Assert
         expect(worker).not.toBeNull();
         expect(worker).toBeInstanceOf(worker_threads_1.Worker);
         if (worker) {
@@ -23,36 +28,43 @@ describe(create_worker_1.createWorker.name, () => {
         }
     });
     it('should throw error when not in main thread', async () => {
+        // Arrange
         const originalIsMainThread = worker_threads_1.isMainThread;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         worker_threads_1.isMainThread = false;
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingExternalSyncUnits },
+        });
+        // Act & Assert
         await expect((0, create_worker_1.createWorker)({
-            event: (0, test_helpers_1.createEvent)({
-                eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
-            }),
+            event,
             initialState: {},
             workerPath,
         })).rejects.toThrow('Worker threads can not start more worker threads.');
-        // Restore original value
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         worker_threads_1.isMainThread = originalIsMainThread;
     });
     it('[edge] should handle worker creation with minimal valid data', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingExternalSyncUnits },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_helpers_1.createEvent)({
-                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
-                }),
+                event,
                 initialState: {},
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }
     });
     it('[edge] should handle worker creation with complex initial state', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
         const complexState = {
             nested: {
@@ -60,28 +72,35 @@ describe(create_worker_1.createWorker.name, () => {
                 config: { enabled: true },
             },
         };
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_helpers_1.createEvent)({
-                    eventType: extraction_1.EventType.ExtractionDataStart,
-                }),
+                event,
                 initialState: complexState,
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }
     });
     it('[edge] should handle different event types', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingMetadata },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_helpers_1.createEvent)({
-                    eventType: extraction_1.EventType.ExtractionMetadataStart,
-                }),
+                event,
                 initialState: {},
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }

package/dist/multithreading/process-task.d.ts

@@ -1,3 +1,18 @@
 import { ProcessTaskInterface } from '../types/workers';
-export declare function processTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ConnectorState>): void;
+import { ExtractionAdapter } from './adapters/extraction-adapter';
+import { LoadingAdapter } from './adapters/loading-adapter';
+/**
+ * Entry point for an extraction worker. Builds an {@link ExtractionAdapter} and
+ * runs the provided task against it.
+ *
+ * @public
+ */
+export declare function processExtractionTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ExtractionAdapter<ConnectorState>>): void;
+/**
+ * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
+ * provided task against it.
+ *
+ * @public
+ */
+export declare function processLoadingTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<LoadingAdapter<ConnectorState>>): void;
 //# sourceMappingURL=process-task.d.ts.map

package/dist/multithreading/process-task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"process-task.d.ts","sourceRoot":"","sources":["../../src/multithreading/process-task.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,wBAAgB,WAAW,CAAC,cAAc,EAAE,EAC1C,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,cAAc,CAAC,QAqGtC"}
+{"version":3,"file":"process-task.d.ts","sourceRoot":"","sources":["../../src/multithreading/process-task.ts"],"names":[],"mappings":"AASA,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAgD5D;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,EACpD,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,QA6BzD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,EACjD,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,QA6BtD"}

package/dist/multithreading/process-task.js

@@ -1,93 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processTask = processTask;
+exports.processExtractionTask = processExtractionTask;
+exports.processLoadingTask = processLoadingTask;
 const node_worker_threads_1 = require("node:worker_threads");
-const event_type_translation_1 = require("../common/event-type-translation");
 const logger_1 = require("../logger/logger");
 const logger_context_1 = require("../logger/logger.context");
-const state_1 = require("../state/state");
+const extraction_state_1 = require("../state/extraction-state");
+const loading_state_1 = require("../state/loading-state");
 const workers_1 = require("../types/workers");
-const worker_adapter_1 = require("./worker-adapter/worker-adapter");
-function processTask({ task, onTimeout, }) {
-    if (node_worker_threads_1.isMainThread) {
-        return;
-    }
-    void (async () => {
-        await (0, logger_context_1.runWithSdkLogContext)(async () => {
-            try {
-                const event = node_worker_threads_1.workerData.event;
-                // TODO: Remove when the old types are completely phased out
-                event.payload.event_type = (0, event_type_translation_1.translateIncomingEventType)(event.payload.event_type);
-                const initialState = node_worker_threads_1.workerData.initialState;
-                const initialDomainMapping = node_worker_threads_1.workerData.initialDomainMapping;
-                const options = node_worker_threads_1.workerData.options;
-                // eslint-disable-next-line no-global-assign
-                console = new logger_1.Logger({ event, options });
-                const adapterState = await (0, state_1.createAdapterState)({
-                    event,
-                    initialState,
-                    initialDomainMapping,
-                    options,
-                });
-                const adapter = new worker_adapter_1.WorkerAdapter({
-                    event,
-                    adapterState,
-                    options,
-                });
-                // Timeout handling flow:
-                // The task() runs in the main flow below. Meanwhile, the parent thread may send
-                // a timeout message at any point. When that happens, the message handler signals
-                // the adapter to stop (handleTimeout), waits for task() to finish, then runs onTimeout().
-                // If task() completes before any timeout message arrives, the worker exits normally.
-                // isTimeoutReceived prevents both flows from calling process.exit.
-                let isTimeoutReceived = false;
-                let taskExecution;
-                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
-                    if (message.subject !== workers_1.WorkerMessageSubject.WorkerMessageExit) {
-                        return;
-                    }
-                    isTimeoutReceived = true;
-                    void (0, logger_context_1.runWithSdkLogContext)(async () => {
-                        try {
-                            console.log('Timeout received. Waiting for the task to finish.');
-                            adapter.handleTimeout();
-                            try {
-                                await taskExecution;
-                            }
-                            catch (taskError) {
-                                console.warn('Task error during timeout:', (0, logger_1.serializeError)(taskError));
-                            }
-                            console.log('Task finished. Running onTimeout handler.');
-                            await (0, logger_context_1.runWithUserLogContext)(async () => onTimeout({ adapter }));
-                            console.log('onTimeout handler complete. Exiting worker.');
-                            process.exit(0);
-                        }
-                        catch (onTimeoutError) {
-                            console.error('Error in onTimeout handler:', (0, logger_1.serializeError)(onTimeoutError));
-                            process.exit(1);
-                        }
-                    });
-                });
-                taskExecution = (0, logger_context_1.runWithUserLogContext)(async () => task({ adapter }));
-                try {
-                    await taskExecution;
-                }
-                catch (taskError) {
-                    if (isTimeoutReceived) {
-                        console.log('Task threw during timeout. Letting timeout handler finish.');
-                        return;
-                    }
-                    throw taskError;
-                }
-                if (!isTimeoutReceived) {
-                    console.log('Task completed. Exiting worker.');
-                    process.exit(0);
+const extraction_adapter_1 = require("./adapters/extraction-adapter");
+const loading_adapter_1 = require("./adapters/loading-adapter");
+/**
+ * Shared worker-thread driver. Builds the logger context, runs the task and
+ * (on timeout) the onTimeout callback against the provided adapter, and wires
+ * the error/exit plumbing. The adapter is constructed by the caller so each
+ * entry point can build its own typed adapter.
+ */
+async function runWorkerTask(buildAdapter, { task, onTimeout }) {
+    await (0, logger_context_1.runWithSdkLogContext)(async () => {
+        try {
+            const adapter = await buildAdapter();
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
+                if (message.subject !== workers_1.WorkerMessageSubject.WorkerMessageExit) {
+                    return;
                 }
+                console.log('Timeout received. Waiting for the task to finish.');
+                adapter.isTimeout = true;
+            });
+            await (0, logger_context_1.runWithUserLogContext)(async () => task({ adapter }));
+            if (adapter.isTimeout && !adapter.hasWorkerEmitted) {
+                await (0, logger_context_1.runWithUserLogContext)(async () => onTimeout({ adapter }));
             }
-            catch (error) {
-                console.error('Error while processing task.', (0, logger_1.serializeError)(error));
+            process.exit(0);
+        }
+        catch (error) {
+            (0, logger_context_1.runWithUserLogContext)(() => {
+                const errorMessage = `Error while processing task. ${(0, logger_1.serializeError)(error)}`;
+                console.error(errorMessage);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                    payload: { message: errorMessage },
+                });
                 process.exit(1);
-            }
+            });
+        }
+    });
+}
+/**
+ * Entry point for an extraction worker. Builds an {@link ExtractionAdapter} and
+ * runs the provided task against it.
+ *
+ * @public
+ */
+function processExtractionTask({ task, onTimeout, }) {
+    if (node_worker_threads_1.isMainThread) {
+        return;
+    }
+    void runWorkerTask(async () => {
+        const event = node_worker_threads_1.workerData.event;
+        const initialState = node_worker_threads_1.workerData.initialState;
+        const initialDomainMapping = node_worker_threads_1.workerData.initialDomainMapping;
+        const options = node_worker_threads_1.workerData.options;
+        // eslint-disable-next-line no-global-assign
+        console = new logger_1.Logger({ event, options });
+        const adapterState = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState,
+            initialDomainMapping,
+            options,
+        });
+        return new extraction_adapter_1.ExtractionAdapter({
+            event,
+            adapterState,
+            options,
+        });
+    }, { task, onTimeout });
+}
+/**
+ * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
+ * provided task against it.
+ *
+ * @public
+ */
+function processLoadingTask({ task, onTimeout, }) {
+    if (node_worker_threads_1.isMainThread) {
+        return;
+    }
+    void runWorkerTask(async () => {
+        const event = node_worker_threads_1.workerData.event;
+        const initialState = node_worker_threads_1.workerData.initialState;
+        const initialDomainMapping = node_worker_threads_1.workerData.initialDomainMapping;
+        const options = node_worker_threads_1.workerData.options;
+        // eslint-disable-next-line no-global-assign
+        console = new logger_1.Logger({ event, options });
+        const adapterState = await (0, loading_state_1.createLoadingState)({
+            event,
+            initialState,
+            initialDomainMapping,
+            options,
+        });
+        return new loading_adapter_1.LoadingAdapter({
+            event,
+            adapterState,
+            options,
         });
-    })();
+    }, { task, onTimeout });
 }

package/dist/multithreading/process-task.test.d.ts

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

package/dist/multithreading/process-task.test.d.ts.map

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

package/dist/multithreading/process-task.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../types/extraction");
+const workers_1 = require("../types/workers");
+// These tests cover logic that is NOT exercised by the end-to-end integration
+// tests under src/tests/timeout-handling/:
+//   - translation of legacy wire event types into the new enum (mutates event in place)
+//   - the hasWorkerEmitted guard that prevents onTimeout from firing after a
+//     successful emit (integration tests only exercise the positive case)
+//   - the error branch that posts WorkerMessageFailed and exits(1)
+//   - the WorkerMessage handler's guard that only flips isTimeout on
+//     WorkerMessageExit (integration tests can't cleanly target non-Exit messages)
+//
+// Tests for the happy path, timeout-signal-reaches-worker behavior, and main-thread
+// early return were removed — they either duplicate what the integration suite
+// already exercises or assert mocked behavior with little signal.
+const mockParentPortPostMessage = jest.fn();
+const mockParentPortOn = jest.fn();
+let mockIsMainThread = false;
+jest.mock('node:worker_threads', () => ({
+    get isMainThread() {
+        return mockIsMainThread;
+    },
+    get parentPort() {
+        return {
+            postMessage: mockParentPortPostMessage,
+            on: mockParentPortOn,
+        };
+    },
+    get workerData() {
+        var _a;
+        return (_a = global.__workerData__) !== null && _a !== void 0 ? _a : {};
+    },
+}));
+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('../logger/logger.context', () => ({
+    runWithSdkLogContext: jest.fn((fn) => fn()),
+    runWithUserLogContext: jest.fn((fn) => fn()),
+}));
+jest.mock('../state/extraction-state', () => ({
+    createExtractionState: jest.fn(),
+}));
+jest.mock('./adapters/extraction-adapter', () => ({
+    ExtractionAdapter: jest.fn().mockImplementation(() => ({
+        isTimeout: false,
+        hasWorkerEmitted: false,
+    })),
+}));
+const process_task_1 = require("./process-task");
+const extraction_state_1 = require("../state/extraction-state");
+const extraction_adapter_1 = require("./adapters/extraction-adapter");
+const test_utils_1 = require("../common/test-utils");
+function setWorkerData(data) {
+    global.__workerData__ = data;
+}
+function makeEvent(eventType = extraction_1.EventType.StartExtractingData) {
+    return (0, test_utils_1.createMockEvent)('http://localhost:0', {
+        payload: { event_type: eventType },
+    });
+}
+// Flush the microtask queue enough to let the async IIFE inside processExtractionTask run.
+const flush = async () => new Promise((r) => setTimeout(r, 0));
+describe(process_task_1.processExtractionTask.name, () => {
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockIsMainThread = false;
+        processExitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation((() => { }));
+        extraction_state_1.createExtractionState.mockResolvedValue({});
+    });
+    afterEach(() => {
+        processExitSpy.mockRestore();
+    });
+    it('should NOT call onTimeout when the worker already emitted before timeout check', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        // Both flags true: a timeout arrived but the worker had already emitted —
+        // onTimeout must be skipped. This is the guard the integration suite cannot
+        // target cleanly because it requires a precise race between emit and timeout.
+        const mockAdapter = { isTimeout: true, hasWorkerEmitted: true };
+        extraction_adapter_1.ExtractionAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processExtractionTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(onTimeout).not.toHaveBeenCalled();
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+    });
+    it('should NOT flip adapter.isTimeout when a non-Exit WorkerMessage arrives', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        extraction_adapter_1.ExtractionAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processExtractionTask)({ task, onTimeout });
+        await flush();
+        // Grab the handler registered for WorkerMessage events and invoke it with
+        // subjects that must NOT flip isTimeout (log messages, unknown subjects).
+        const messageHandlerCall = mockParentPortOn.mock.calls.find(([eventName]) => eventName === workers_1.WorkerEvent.WorkerMessage);
+        expect(messageHandlerCall).toBeDefined();
+        const handler = messageHandlerCall[1];
+        handler({ subject: workers_1.WorkerMessageSubject.WorkerMessageLog });
+        handler({ subject: 'NONSENSE_SUBJECT' });
+        // Assert
+        expect(mockAdapter.isTimeout).toBe(false);
+    });
+    it('should post WorkerMessageFailed with the error message and exit(1) when task throws', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        extraction_adapter_1.ExtractionAdapter.mockImplementation(() => mockAdapter);
+        const taskError = new Error('task boom');
+        const task = jest.fn().mockRejectedValue(taskError);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processExtractionTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(mockParentPortPostMessage).toHaveBeenCalledWith(expect.objectContaining({
+            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+            payload: expect.objectContaining({
+                message: expect.stringContaining('task boom'),
+            }),
+        }));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        expect(onTimeout).not.toHaveBeenCalled();
+    });
+});

package/dist/multithreading/spawn/spawn.d.ts

@@ -5,13 +5,12 @@ import { SpawnFactoryInterface, SpawnInterface } from '../../types/workers';
  * The class provides utilities to emit control events to the platform and exit the worker gracefully.
  * In case of lambda timeout, the class emits a lambda timeout event to the platform.
  * @param {SpawnFactoryInterface} options - The options to create a new instance of Spawn class
- * @param {AirdropEvent} options.event - The event object received from the platform
+ * @param {AirSyncEvent} options.event - The event object received from the platform
  * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.workerPath] Remove getWorkerPath function and use baseWorkerPath: __dirname instead of workerPath
  * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
  * @returns {Promise<Spawn>} - A new instance of Spawn class
  */
-export declare function spawn<ConnectorState>({ event, initialState, workerPath, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
+export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
 export declare class Spawn {
     private event;
     private alreadyEmitted;
@@ -24,6 +23,7 @@ export declare class Spawn {
     private resolve;
     private originalConsole;
     private logger;
+    private workerFailedMessage;
     constructor({ event, worker, options, resolve, originalConsole, }: SpawnInterface);
     private clearTimeouts;
     private exitFromMainThread;

package/dist/multithreading/spawn/spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IA4GjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAqB;gBACpC,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IAiHjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAoCjC"}

package/dist/multithreading/spawn/spawn.helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAmFA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}
+{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CA2EA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}

package/dist/multithreading/spawn/spawn.helpers.js

@@ -11,43 +11,35 @@ const loading_1 = require("../../types/loading");
  */
 function getTimeoutErrorEventType(eventType) {
     switch (eventType) {
-        // Metadata extraction (handles both old and new enum members)
+        // Metadata extraction
         case extraction_1.EventType.StartExtractingMetadata:
-        case extraction_1.EventType.ExtractionMetadataStart:
             return {
                 eventType: extraction_1.ExtractorEventType.MetadataExtractionError,
             };
-        // Data extraction (handles both old and new enum members)
+        // Data extraction
         case extraction_1.EventType.StartExtractingData:
         case extraction_1.EventType.ContinueExtractingData:
-        case extraction_1.EventType.ExtractionDataStart:
-        case extraction_1.EventType.ExtractionDataContinue:
             return {
                 eventType: extraction_1.ExtractorEventType.DataExtractionError,
             };
-        // Data deletion (handles both old and new enum members)
+        // Data deletion
         case extraction_1.EventType.StartDeletingExtractorState:
-        case extraction_1.EventType.ExtractionDataDelete:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
             };
-        // Attachments extraction (handles both old and new enum members)
+        // Attachments extraction
         case extraction_1.EventType.StartExtractingAttachments:
         case extraction_1.EventType.ContinueExtractingAttachments:
-        case extraction_1.EventType.ExtractionAttachmentsStart:
-        case extraction_1.EventType.ExtractionAttachmentsContinue:
             return {
                 eventType: extraction_1.ExtractorEventType.AttachmentExtractionError,
             };
-        // Attachments deletion (handles both old and new enum members)
+        // Attachments deletion
         case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
-        case extraction_1.EventType.ExtractionAttachmentsDelete:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
             };
-        // External sync units (handles both old and new enum members)
+        // External sync units
         case extraction_1.EventType.StartExtractingExternalSyncUnits:
-        case extraction_1.EventType.ExtractionExternalSyncUnitsStart:
             return {
                 eventType: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
             };

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

@@ -15,7 +15,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return MetadataExtractionError for deprecated ExtractionMetadataStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionMetadataStart;
+            const eventType = extraction_1.EventType.StartExtractingMetadata;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -41,7 +41,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return DataExtractionError for deprecated ExtractionDataStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataStart;
+            const eventType = extraction_1.EventType.StartExtractingData;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -49,7 +49,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return DataExtractionError for deprecated ExtractionDataContinue', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataContinue;
+            const eventType = extraction_1.EventType.ContinueExtractingData;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -67,7 +67,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExtractorStateDeletionError for deprecated ExtractionDataDelete', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionDataDelete;
+            const eventType = extraction_1.EventType.StartDeletingExtractorState;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -93,7 +93,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsStart;
+            const eventType = extraction_1.EventType.StartExtractingAttachments;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -101,7 +101,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsContinue', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsContinue;
+            const eventType = extraction_1.EventType.ContinueExtractingAttachments;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -119,7 +119,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExtractorAttachmentsStateDeletionError for deprecated ExtractionAttachmentsDelete', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionAttachmentsDelete;
+            const eventType = extraction_1.EventType.StartDeletingExtractorAttachmentsState;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert
@@ -137,7 +137,7 @@ describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
         });
         it('should return ExternalSyncUnitExtractionError for deprecated ExtractionExternalSyncUnitsStart', () => {
             // Arrange
-            const eventType = extraction_1.EventType.ExtractionExternalSyncUnitsStart;
+            const eventType = extraction_1.EventType.StartExtractingExternalSyncUnits;
             // Act
             const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
             // Assert