@devrev/airsync-sdk 2.0.0-beta.0

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const test_helpers_1 = require("../tests/test-helpers");
+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 () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const worker = worker_threads_1.isMainThread
+            ? await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+                }),
+                initialState: {},
+                workerPath,
+            })
+            : null;
+        expect(worker).not.toBeNull();
+        expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+        if (worker) {
+            await worker.terminate();
+        }
+    });
+    it('should throw error when not in main thread', async () => {
+        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';
+        await expect((0, create_worker_1.createWorker)({
+            event: (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+            }),
+            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 () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+                }),
+                initialState: {},
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
+    it('[edge] should handle worker creation with complex initial state', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const complexState = {
+            nested: {
+                data: [1, 2, 3],
+                config: { enabled: true },
+            },
+        };
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionDataStart,
+                }),
+                initialState: complexState,
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
+    it('[edge] should handle different event types', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionMetadataStart,
+                }),
+                initialState: {},
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
+});

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

@@ -0,0 +1,3 @@
+import { ProcessTaskInterface } from '../types/workers';
+export declare function processTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ConnectorState>): void;
+//# sourceMappingURL=process-task.d.ts.map

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

@@ -0,0 +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,QAmEtC"}

package/dist/multithreading/process-task.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTask = processTask;
+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 workers_1 = require("../types/workers");
+const worker_adapter_1 = require("./worker-adapter/worker-adapter");
+function processTask({ task, onTimeout, }) {
+    if (!node_worker_threads_1.isMainThread) {
+        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,
+                    });
+                    if (node_worker_threads_1.parentPort && node_worker_threads_1.workerData.event) {
+                        const adapter = new worker_adapter_1.WorkerAdapter({
+                            event,
+                            adapterState,
+                            options,
+                        });
+                        node_worker_threads_1.parentPort.on(workers_1.WorkerEvent.WorkerMessage, (message) => void (async () => {
+                            await (0, logger_context_1.runWithSdkLogContext)(async () => {
+                                if (message.subject === workers_1.WorkerMessageSubject.WorkerMessageExit) {
+                                    console.log('Worker received message to gracefully exit. Setting isTimeout flag and executing onTimeout function.');
+                                    adapter.handleTimeout();
+                                    await (0, logger_context_1.runWithUserLogContext)(async () => onTimeout({ adapter }));
+                                    console.log('Finished executing onTimeout function. Exiting worker.');
+                                    process.exit(0);
+                                }
+                            });
+                        })());
+                        await (0, logger_context_1.runWithUserLogContext)(async () => task({ adapter }));
+                        process.exit(0);
+                    }
+                }
+                catch (error) {
+                    console.error('Error while processing task.', (0, logger_1.serializeError)(error));
+                    process.exit(1);
+                }
+            });
+        })();
+    }
+}

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

@@ -0,0 +1,30 @@
+import { SpawnFactoryInterface, SpawnInterface } from '../../types/workers';
+/**
+ * Creates a new instance of Spawn class.
+ * Spawn class is responsible for spawning a new worker thread and managing the lifecycle of the worker.
+ * 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 {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 class Spawn {
+    private event;
+    private alreadyEmitted;
+    private defaultLambdaTimeout;
+    private lambdaTimeout;
+    private softTimeoutTimer;
+    private hardTimeoutTimer;
+    private memoryMonitoringInterval;
+    private resolve;
+    private originalConsole;
+    private logger;
+    constructor({ event, worker, options, resolve, originalConsole, }: SpawnInterface);
+    private clearTimeouts;
+    private exitFromMainThread;
+}
+//# sourceMappingURL=spawn.d.ts.map

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

@@ -0,0 +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,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;IAiGjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}

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

@@ -0,0 +1,21 @@
+import { EventType, ExtractorEventType } from '../../types/extraction';
+import { LoaderEventType } from '../../types/loading';
+/**
+ * Gets the event type for the timeout error.
+ * @param {EventType} eventType - The event type to get the timeout error event type for
+ * @returns {ExtractorEventType | LoaderEventType} The event type for the timeout error
+ */
+export declare function getTimeoutErrorEventType(eventType: EventType): {
+    eventType: ExtractorEventType | LoaderEventType;
+};
+/**
+ * Gets the event type for the no script error.
+ * @param {EventType} eventType - The event type to get the no script error event type for
+ * @returns {ExtractorEventType | LoaderEventType} The event type for the no script error
+ */
+export declare function getNoScriptEventType(eventType: EventType): {
+    eventType: ExtractorEventType;
+} | {
+    eventType: LoaderEventType;
+};
+//# sourceMappingURL=spawn.helpers.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutErrorEventType = getTimeoutErrorEventType;
+exports.getNoScriptEventType = getNoScriptEventType;
+const extraction_1 = require("../../types/extraction");
+const loading_1 = require("../../types/loading");
+/**
+ * Gets the event type for the timeout error.
+ * @param {EventType} eventType - The event type to get the timeout error event type for
+ * @returns {ExtractorEventType | LoaderEventType} The event type for the timeout error
+ */
+function getTimeoutErrorEventType(eventType) {
+    switch (eventType) {
+        // Metadata extraction (handles both old and new enum members)
+        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)
+        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)
+        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)
+        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)
+        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)
+        case extraction_1.EventType.StartExtractingExternalSyncUnits:
+        case extraction_1.EventType.ExtractionExternalSyncUnitsStart:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
+            };
+        // Loading data
+        case extraction_1.EventType.StartLoadingData:
+        case extraction_1.EventType.ContinueLoadingData:
+            return {
+                eventType: loading_1.LoaderEventType.DataLoadingError,
+            };
+        // Deleting loader state
+        case extraction_1.EventType.StartDeletingLoaderState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderStateDeletionError,
+            };
+        // Loading attachments
+        case extraction_1.EventType.StartLoadingAttachments:
+        case extraction_1.EventType.ContinueLoadingAttachments:
+            return {
+                eventType: loading_1.LoaderEventType.AttachmentLoadingError,
+            };
+        // Deleting loader attachment state
+        case extraction_1.EventType.StartDeletingLoaderAttachmentState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderAttachmentStateDeletionError,
+            };
+        default:
+            console.error('Event type not recognized in getTimeoutErrorEventType function: ' +
+                eventType);
+            return {
+                eventType: loading_1.LoaderEventType.UnknownEventType,
+            };
+    }
+}
+/**
+ * Gets the event type for the no script error.
+ * @param {EventType} eventType - The event type to get the no script error event type for
+ * @returns {ExtractorEventType | LoaderEventType} The event type for the no script error
+ */
+function getNoScriptEventType(eventType) {
+    switch (eventType) {
+        case extraction_1.EventType.StartDeletingExtractorState:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingLoaderState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingLoaderAttachmentState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
+            };
+        default:
+            console.error('Event type not recognized in getNoScriptEventType function: ' +
+                eventType);
+            return {
+                eventType: loading_1.LoaderEventType.UnknownEventType,
+            };
+    }
+}

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

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

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

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

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

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../../types/extraction");
+const loading_1 = require("../../types/loading");
+const spawn_helpers_1 = require("./spawn.helpers");
+describe(spawn_helpers_1.getTimeoutErrorEventType.name, () => {
+    describe('metadata extraction', () => {
+        it('should return MetadataExtractionError for StartExtractingMetadata', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartExtractingMetadata;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.MetadataExtractionError);
+        });
+        it('should return MetadataExtractionError for deprecated ExtractionMetadataStart', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionMetadataStart;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.MetadataExtractionError);
+        });
+    });
+    describe('data extraction', () => {
+        it('should return DataExtractionError for StartExtractingData', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartExtractingData;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        });
+        it('should return DataExtractionError for ContinueExtractingData', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ContinueExtractingData;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        });
+        it('should return DataExtractionError for deprecated ExtractionDataStart', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionDataStart;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        });
+        it('should return DataExtractionError for deprecated ExtractionDataContinue', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionDataContinue;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        });
+    });
+    describe('extractor state deletion', () => {
+        it('should return ExtractorStateDeletionError for StartDeletingExtractorState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingExtractorState;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorStateDeletionError);
+        });
+        it('should return ExtractorStateDeletionError for deprecated ExtractionDataDelete', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionDataDelete;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorStateDeletionError);
+        });
+    });
+    describe('attachments extraction', () => {
+        it('should return AttachmentExtractionError for StartExtractingAttachments', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartExtractingAttachments;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.AttachmentExtractionError);
+        });
+        it('should return AttachmentExtractionError for ContinueExtractingAttachments', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ContinueExtractingAttachments;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.AttachmentExtractionError);
+        });
+        it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsStart', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionAttachmentsStart;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.AttachmentExtractionError);
+        });
+        it('should return AttachmentExtractionError for deprecated ExtractionAttachmentsContinue', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionAttachmentsContinue;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.AttachmentExtractionError);
+        });
+    });
+    describe('extractor attachments state deletion', () => {
+        it('should return ExtractorAttachmentsStateDeletionError for StartDeletingExtractorAttachmentsState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingExtractorAttachmentsState;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError);
+        });
+        it('should return ExtractorAttachmentsStateDeletionError for deprecated ExtractionAttachmentsDelete', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionAttachmentsDelete;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError);
+        });
+    });
+    describe('external sync units extraction', () => {
+        it('should return ExternalSyncUnitExtractionError for StartExtractingExternalSyncUnits', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartExtractingExternalSyncUnits;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError);
+        });
+        it('should return ExternalSyncUnitExtractionError for deprecated ExtractionExternalSyncUnitsStart', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ExtractionExternalSyncUnitsStart;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError);
+        });
+    });
+    describe('data loading', () => {
+        it('should return DataLoadingError for StartLoadingData', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartLoadingData;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.DataLoadingError);
+        });
+        it('should return DataLoadingError for ContinueLoadingData', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ContinueLoadingData;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.DataLoadingError);
+        });
+    });
+    describe('loader state deletion', () => {
+        it('should return LoaderStateDeletionError for StartDeletingLoaderState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingLoaderState;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.LoaderStateDeletionError);
+        });
+    });
+    describe('attachment loading', () => {
+        it('should return AttachmentLoadingError for StartLoadingAttachments', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartLoadingAttachments;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.AttachmentLoadingError);
+        });
+        it('should return AttachmentLoadingError for ContinueLoadingAttachments', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.ContinueLoadingAttachments;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.AttachmentLoadingError);
+        });
+    });
+    describe('loader attachment state deletion', () => {
+        it('should return LoaderAttachmentStateDeletionError for StartDeletingLoaderAttachmentState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingLoaderAttachmentState;
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.LoaderAttachmentStateDeletionError);
+        });
+    });
+    describe('unknown event types', () => {
+        it('[edge] should return UnknownEventType and log error for unrecognized event type', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.UnknownEventType;
+            const consoleErrorSpy = jest
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Act
+            const result = (0, spawn_helpers_1.getTimeoutErrorEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.UnknownEventType);
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Event type not recognized in getTimeoutErrorEventType function: ' +
+                eventType);
+            // Cleanup
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});
+describe(spawn_helpers_1.getNoScriptEventType.name, () => {
+    describe('extractor state deletion', () => {
+        it('should return ExtractorStateDeletionDone for StartDeletingExtractorState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingExtractorState;
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorStateDeletionDone);
+        });
+    });
+    describe('extractor attachments state deletion', () => {
+        it('should return ExtractorAttachmentsStateDeletionDone for StartDeletingExtractorAttachmentsState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingExtractorAttachmentsState;
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone);
+        });
+    });
+    describe('loader state deletion', () => {
+        it('should return LoaderStateDeletionDone for StartDeletingLoaderState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingLoaderState;
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.LoaderStateDeletionDone);
+        });
+    });
+    describe('loader attachment state deletion', () => {
+        it('should return LoaderAttachmentStateDeletionDone for StartDeletingLoaderAttachmentState', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartDeletingLoaderAttachmentState;
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone);
+        });
+    });
+    describe('unknown event types', () => {
+        it('[edge] should return UnknownEventType and log error for unrecognized event type', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartExtractingData;
+            const consoleErrorSpy = jest
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.UnknownEventType);
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Event type not recognized in getNoScriptEventType function: ' +
+                eventType);
+            // Cleanup
+            consoleErrorSpy.mockRestore();
+        });
+        it('[edge] should return UnknownEventType for StartLoadingData', () => {
+            // Arrange
+            const eventType = extraction_1.EventType.StartLoadingData;
+            const consoleErrorSpy = jest
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Act
+            const result = (0, spawn_helpers_1.getNoScriptEventType)(eventType);
+            // Assert
+            expect(result.eventType).toBe(loading_1.LoaderEventType.UnknownEventType);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            // Cleanup
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});