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

package/dist/mock-server/mock-server.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockServer = void 0;
+const http_1 = require("http");
+const mock_server_interfaces_1 = require("./mock-server.interfaces");
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10mb
+/**
+ * Parses the JSON body from an incoming request.
+ */
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                reject(new Error('Request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (chunks.length === 0) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                const raw = Buffer.concat(chunks).toString('utf-8');
+                resolve(JSON.parse(raw));
+            }
+            catch (_a) {
+                resolve(undefined);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Wraps a ServerResponse with helper methods (status, json, set, send).
+ */
+function wrapResponse(res) {
+    const mock = res;
+    let statusCode = 200;
+    mock.set = (headers) => {
+        for (const [key, value] of Object.entries(headers)) {
+            res.setHeader(key, value);
+        }
+        return mock;
+    };
+    mock.status = (code) => {
+        statusCode = code;
+        return mock;
+    };
+    mock.json = (data) => {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    mock.send = () => {
+        res.writeHead(statusCode);
+        res.end();
+    };
+    return mock;
+}
+/**
+ * MockServer used in tests to mock internal AirSync endpoints.
+ * This is a simple mock server that listens on a port and responds to requests.
+ * Supports per-test route configuration to simulate different response scenarios.
+ */
+class MockServer {
+    constructor(port = mock_server_interfaces_1.DEFAULT_MOCK_SERVER_PORT) {
+        this.server = null;
+        this.routeHandlers = new Map();
+        this.requests = [];
+        this.requestCounts = new Map();
+        this.internalPort = port;
+        this.port = port;
+        this.baseUrl = `http://localhost:${this.port}`;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = (0, http_1.createServer)((req, res) => {
+                this.handleRequest(req, res).catch(() => {
+                    res.writeHead(500);
+                    res.end();
+                });
+            });
+            this.server.listen(this.internalPort, () => {
+                var _a, _b;
+                const actualPort = (_b = (_a = this.server) === null || _a === void 0 ? void 0 : _a.address()) === null || _b === void 0 ? void 0 : _b.port;
+                if (actualPort) {
+                    this.port = actualPort;
+                    this.baseUrl = `http://localhost:${this.port}`;
+                }
+                console.log(`Mock server running on http://localhost:${this.port}.`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    console.log('Mock server stopped.');
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    async handleRequest(raw, rawRes) {
+        const req = raw;
+        const res = wrapResponse(rawRes);
+        const urlPath = (req.url || '/').split('?')[0];
+        req.path = urlPath;
+        req.body = await parseJsonBody(req);
+        const requestInfo = Object.assign({ method: req.method || 'GET', url: req.url || urlPath }, (req.body !== undefined && req.body !== null
+            ? { body: req.body }
+            : {}));
+        this.requests.push(requestInfo);
+        const method = (req.method || 'GET').toUpperCase();
+        const key = `${method}:${urlPath}`;
+        const customHandler = this.routeHandlers.get(key);
+        if (customHandler) {
+            customHandler(req, res);
+        }
+        else {
+            this.defaultRouteHandler(req, res);
+        }
+    }
+    /**
+     * Default route handler for the mock server. Returns { success: true } for
+     * routes that are not explicitly set.
+     */
+    defaultRouteHandler(req, res) {
+        if (req.method === 'GET' && req.path === '/worker_data_url.get') {
+            res.status(200).json({
+                state: JSON.stringify({}),
+            });
+        }
+        else if (req.method === 'GET' && req.path === '/internal/snap-ins.get') {
+            res.status(200).json({
+                snap_in: {
+                    imports: [{ name: 'test_import_slug' }],
+                    snap_in_version: { slug: 'test_snap_in_slug' },
+                },
+            });
+        }
+        else if (req.method === 'GET' &&
+            req.path === '/internal/airdrop.artifacts.upload-url') {
+            const artifactId = `artifact-${Date.now()}-${Math.random()
+                .toString(36)
+                .substr(2, 9)}`;
+            res.status(200).json({
+                upload_url: `${this.baseUrl}/file-upload-url`,
+                artifact_id: artifactId,
+                form_data: [],
+            });
+        }
+        else {
+            res.status(200).json({ success: true });
+        }
+    }
+    getRouteKey(method, path) {
+        return `${method.toUpperCase()}:${path}`;
+    }
+    /**
+     * Configures a route to return a specific status code and optional response body.
+     */
+    setRoute(config) {
+        const { path, method, status, body, retry, headers, delay } = config;
+        const key = this.getRouteKey(method, path);
+        if (retry) {
+            this.requestCounts.set(key, 0);
+        }
+        this.routeHandlers.set(key, (req, res) => {
+            const sendResponse = (responseDelay) => {
+                const send = () => {
+                    var _a, _b;
+                    if (retry) {
+                        const currentCount = this.requestCounts.get(key) || 0;
+                        const failureCount = (_a = retry.failureCount) !== null && _a !== void 0 ? _a : 4;
+                        const errorStatus = (_b = retry.errorStatus) !== null && _b !== void 0 ? _b : 500;
+                        if (currentCount < failureCount) {
+                            this.requestCounts.set(key, currentCount + 1);
+                            const sendFailure = () => {
+                                if (retry.headers) {
+                                    res.set(retry.headers);
+                                }
+                                if (retry.errorBody !== undefined) {
+                                    res.status(errorStatus).json(retry.errorBody);
+                                }
+                                else {
+                                    res.status(errorStatus).send();
+                                }
+                            };
+                            if (retry.delay) {
+                                setTimeout(sendFailure, retry.delay);
+                            }
+                            else {
+                                sendFailure();
+                            }
+                        }
+                        else {
+                            this.requestCounts.set(key, currentCount + 1);
+                            if (headers) {
+                                res.set(headers);
+                            }
+                            if (body !== undefined) {
+                                res.status(status).json(body);
+                            }
+                            else {
+                                this.defaultRouteHandler(req, res);
+                            }
+                        }
+                    }
+                    else {
+                        if (headers) {
+                            res.set(headers);
+                        }
+                        if (body !== undefined) {
+                            res.status(status).json(body);
+                        }
+                        else {
+                            res.status(status).send();
+                        }
+                    }
+                };
+                if (responseDelay) {
+                    setTimeout(send, responseDelay);
+                }
+                else {
+                    send();
+                }
+            };
+            sendResponse(delay);
+        });
+    }
+    /**
+     * Resets all custom route handlers, restoring all default handlers.
+     * Also clears request tracking data.
+     */
+    resetRoutes() {
+        this.routeHandlers.clear();
+        this.requestCounts.clear();
+        this.requests = [];
+    }
+    /**
+     * Returns the most recent request or undefined if no requests exist.
+     */
+    getLastRequest() {
+        if (this.requests.length === 0) {
+            return undefined;
+        }
+        return this.requests[this.requests.length - 1];
+    }
+    /**
+     * Gets the number of requests made to a specific endpoint.
+     */
+    getRequestCount(method, path) {
+        return this.getRequests(method, path).length;
+    }
+    /**
+     * Gets all requests made to a specific endpoint.
+     */
+    getRequests(method, path) {
+        const pathWithoutQuery = path.split('?')[0];
+        return this.requests.filter((req) => req.method.toUpperCase() === method.toUpperCase() &&
+            req.url.split('?')[0] === pathWithoutQuery);
+    }
+}
+exports.MockServer = MockServer;

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.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":"AAOA,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,wBAAgB,WAAW,CAAC,cAAc,EAAE,EAC1C,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,cAAc,CAAC,QAwDtC"}

package/dist/multithreading/process-task.js

@@ -2,7 +2,6 @@
 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");
@@ -16,8 +15,6 @@ function processTask({ task, onTimeout, }) {
         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;
@@ -34,59 +31,29 @@ function processTask({ task, onTimeout, }) {
                     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);
-                        }
-                    });
+                    console.log('Timeout received. Waiting for the task to finish.');
+                    adapter.isTimeout = true;
                 });
-                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);
+                await (0, logger_context_1.runWithUserLogContext)(async () => task({ adapter }));
+                if (adapter.isTimeout && !adapter.hasWorkerEmitted) {
+                    await (0, logger_context_1.runWithUserLogContext)(async () => onTimeout({ adapter }));
                 }
+                process.exit(0);
             }
             catch (error) {
-                console.error('Error while processing task.', (0, logger_1.serializeError)(error));
-                process.exit(1);
+                (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);
+                });
             }
         });
     })();

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/state', () => ({
+    createAdapterState: jest.fn(),
+}));
+jest.mock('./worker-adapter/worker-adapter', () => ({
+    WorkerAdapter: jest.fn().mockImplementation(() => ({
+        isTimeout: false,
+        hasWorkerEmitted: false,
+    })),
+}));
+const process_task_1 = require("./process-task");
+const state_1 = require("../state/state");
+const worker_adapter_1 = require("./worker-adapter/worker-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 processTask run.
+const flush = async () => new Promise((r) => setTimeout(r, 0));
+describe(process_task_1.processTask.name, () => {
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockIsMainThread = false;
+        processExitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation((() => { }));
+        state_1.createAdapterState.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 };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ 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 };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ 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 };
+        worker_adapter_1.WorkerAdapter.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.processTask)({ 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;