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

package/dist/mock-server/mock-server.interfaces.d.ts

@@ -0,0 +1,73 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const DEFAULT_MOCK_SERVER_PORT = 3001;
+export interface ParsedRequest extends IncomingMessage {
+    /** Parsed URL path (without query string) */
+    path: string;
+    /** Parsed JSON body (if any) */
+    body?: unknown;
+}
+export interface MockResponse extends ServerResponse {
+    /** Set response headers from a record */
+    set(headers: Record<string, string>): MockResponse;
+    /** Set the HTTP status code */
+    status(code: number): MockResponse;
+    /** Send a JSON response */
+    json(data: unknown): void;
+    /** Send an empty response */
+    send(): void;
+}
+/**
+ * Configuration for retry simulation behavior.
+ */
+export interface RetryConfig {
+    /** Number of times to return error before succeeding (default: 4) */
+    failureCount?: number;
+    /** 5xx status code to return during failures (default: 500) */
+    errorStatus?: number;
+    /** Optional error response body to send as JSON during failures */
+    errorBody?: unknown;
+    /** Optional headers to send with the error response */
+    headers?: Record<string, string>;
+    /** Optional delay in milliseconds before sending each failure response */
+    delay?: number;
+}
+/**
+ * Configuration object for setting up a route response.
+ */
+export interface RouteConfig {
+    /** The path of the route (e.g., '/callback_url', '/worker_data_url.get') */
+    path: string;
+    /** The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') */
+    method: string;
+    /** The HTTP status code to return (e.g., 200, 401, 500) */
+    status: number;
+    /** Optional response body to send as JSON */
+    body?: unknown;
+    /** Optional headers to send with the response */
+    headers?: Record<string, string>;
+    /** Optional retry configuration for simulating failures before success */
+    retry?: RetryConfig;
+    /** Optional delay in milliseconds before sending the response */
+    delay?: number;
+}
+/**
+ * Type for custom route handler functions.
+ */
+export type RouteHandler = (req: ParsedRequest, res: MockResponse) => unknown;
+/**
+ * Information about a request received by the mock server.
+ */
+export interface RequestInfo {
+    /** The HTTP method (e.g., 'GET', 'POST') */
+    method: string;
+    /** The full URL path of the request */
+    url: string;
+    /** Optional request body (for POST/PUT requests) */
+    body?: unknown;
+}
+export type RouteHandlers = Map<string, RouteHandler>;
+/**
+ * Type for tracking request counts per route.
+ */
+export type RequestCounts = Map<string, number>;
+//# sourceMappingURL=mock-server.interfaces.d.ts.map

package/dist/mock-server/mock-server.interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.interfaces.d.ts","sourceRoot":"","sources":["../../src/mock-server/mock-server.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEvD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,yCAAyC;IACzC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC;IACnD,+BAA+B;IAC/B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;IACnC,2BAA2B;IAC3B,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,6BAA6B;IAC7B,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MOCK_SERVER_PORT = void 0;
+exports.DEFAULT_MOCK_SERVER_PORT = 3001;

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,QAmEtC"}
+{"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,57 +2,59 @@
 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);
+    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;
+                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,
+                });
+                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);
-                }
-            });
-        })();
-    }
+                });
+            }
+        });
+    })();
 }

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":""}