@devrev/ts-adaas 1.12.3-beta.6 → 1.12.3-beta.7

package/dist/tests/oom-handling/oom-handling.test.js

@@ -0,0 +1,407 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../../types/extraction");
+const mock_server_1 = require("../mock-server");
+const test_helpers_1 = require("../test-helpers");
+const extraction_2 = __importDefault(require("./extraction"));
+describe('OOM handling', () => {
+    let mockServer;
+    beforeAll(async () => {
+        mockServer = new mock_server_1.MockServer(3010);
+        await mockServer.start();
+    });
+    afterAll(async () => {
+        if (mockServer) {
+            await mockServer.stop();
+        }
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockServer.clearRequests();
+    });
+    describe('basic OOM detection', () => {
+        it('should emit error event with OOM details when worker runs out of memory', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Run the OOM worker - this should trigger OOM and emit an error event
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            // Expect last request to be emission of error event
+            expect(lastRequest.url).toContain('airdrop.external-extractor.message');
+            expect(lastRequest.method).toBe('POST');
+            // The event type should be an error event
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+            // The error should contain OOM information
+            expect(lastRequest.body.event_data).toBeDefined();
+            expect(lastRequest.body.event_data.error).toBeDefined();
+            expect(lastRequest.body.event_data.error.message).toContain('out of memory');
+            // OOM error info should be present
+            const oomErrorInfo = lastRequest.body.event_data.error.oom_error_info;
+            expect(oomErrorInfo).toBeDefined();
+            expect(oomErrorInfo.type).toBe('OOM_ERROR');
+            expect(oomErrorInfo.memoryLimitMb).toBeGreaterThan(0);
+            expect(oomErrorInfo.eventType).toBe(extraction_1.EventType.StartExtractingData);
+        }, 120000);
+        it('should keep parent thread stable when worker dies from OOM', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Run the OOM worker
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker');
+            // If we get here, the parent thread survived
+            expect(true).toBe(true);
+            // Verify we can still make requests (parent is functional)
+            const requests = mockServer.getRequests();
+            expect(requests.length).toBeGreaterThan(0);
+        }, 120000);
+    });
+    describe('OOM with alreadyEmitted', () => {
+        it('should handle OOM gracefully when worker has done some work before crashing', async () => {
+            var _a, _b, _c, _d;
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Run the worker that attempts to emit before causing OOM
+            // Use a larger memory limit (256MB) to give the worker time to initialize and emit
+            await (0, extraction_2.default)([event], __dirname + '/oom-after-emit-worker', {
+                testMemoryLimitMb: 256,
+            });
+            const requests = mockServer.getRequests();
+            // Filter for callback requests (event emissions)
+            const callbackRequests = requests.filter((r) => r.url.includes('airdrop.external-extractor.message') &&
+                r.method === 'POST');
+            // Should have at least one event (either progress or error)
+            // The key is that the system handles this gracefully without crashing
+            expect(callbackRequests.length).toBeGreaterThanOrEqual(1);
+            // Check if we got a progress event (worker emitted before OOM)
+            const progressRequest = callbackRequests.find((r) => { var _a; return ((_a = r.body) === null || _a === void 0 ? void 0 : _a.event_type) === extraction_1.ExtractorEventType.DataExtractionProgress; });
+            // Check if we got an error event (OOM error)
+            const errorRequest = callbackRequests.find((r) => { var _a; return ((_a = r.body) === null || _a === void 0 ? void 0 : _a.event_type) === extraction_1.ExtractorEventType.DataExtractionError; });
+            // At least one of these should be present
+            expect(progressRequest || errorRequest).toBeTruthy();
+            // If progress was emitted, verify it's valid
+            if (progressRequest) {
+                expect((_a = progressRequest.body) === null || _a === void 0 ? void 0 : _a.event_context).toBeDefined();
+            }
+            // If error was emitted, verify it contains OOM info
+            if (errorRequest) {
+                expect((_d = (_c = (_b = errorRequest.body) === null || _b === void 0 ? void 0 : _b.event_data) === null || _c === void 0 ? void 0 : _c.error) === null || _d === void 0 ? void 0 : _d.oom_error_info).toBeDefined();
+            }
+        }, 120000);
+    });
+    describe('gradual memory leak OOM', () => {
+        it('should detect OOM from gradual memory consumption', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-gradual-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.url).toContain('airdrop.external-extractor.message');
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info).toBeDefined();
+        }, 120000);
+    });
+    describe('OOM with disabled memory limits', () => {
+        it('should still function when memory limits are disabled', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Run with memory limits disabled - worker won't hit OOM limit
+            // but will eventually run out of system memory or hit timeout
+            // This test verifies the system doesn't crash when limits are disabled
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker', {
+                enableMemoryLimits: false,
+                testMemoryLimitMb: undefined,
+            });
+            // Parent should still be functional after worker exits
+            const requests = mockServer.getRequests();
+            expect(requests.length).toBeGreaterThan(0);
+        }, 120000);
+    });
+    describe('OOM for different event types', () => {
+        it('should handle OOM during metadata extraction', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingMetadata,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-metadata-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.MetadataExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info).toBeDefined();
+            expect(lastRequest.body.event_data.error.oom_error_info.eventType).toBe(extraction_1.EventType.StartExtractingMetadata);
+        }, 120000);
+        it('should handle OOM during attachments extraction', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingAttachments,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-attachments-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.AttachmentExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info).toBeDefined();
+            expect(lastRequest.body.event_data.error.oom_error_info.eventType).toBe(extraction_1.EventType.StartExtractingAttachments);
+        }, 120000);
+        it('should handle OOM during external sync units extraction', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingExternalSyncUnits,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-external-sync-units-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info).toBeDefined();
+            expect(lastRequest.body.event_data.error.oom_error_info.eventType).toBe(extraction_1.EventType.StartExtractingExternalSyncUnits);
+        }, 120000);
+    });
+    describe('OOM error info completeness', () => {
+        it('should include all required fields in OOM error info', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            const oomErrorInfo = lastRequest.body.event_data.error.oom_error_info;
+            // Verify all required fields are present
+            expect(oomErrorInfo).toHaveProperty('type', 'OOM_ERROR');
+            expect(oomErrorInfo).toHaveProperty('message');
+            expect(oomErrorInfo).toHaveProperty('memoryLimitMb');
+            expect(oomErrorInfo).toHaveProperty('totalAvailableMemoryMb');
+            expect(oomErrorInfo).toHaveProperty('isLambda');
+            expect(oomErrorInfo).toHaveProperty('isLocalDevelopment');
+            expect(oomErrorInfo).toHaveProperty('exitCode');
+            expect(oomErrorInfo).toHaveProperty('eventType');
+            // Verify types
+            expect(typeof oomErrorInfo.message).toBe('string');
+            expect(typeof oomErrorInfo.memoryLimitMb).toBe('number');
+            expect(typeof oomErrorInfo.totalAvailableMemoryMb).toBe('number');
+            expect(typeof oomErrorInfo.isLambda).toBe('boolean');
+            expect(typeof oomErrorInfo.isLocalDevelopment).toBe('boolean');
+            expect(typeof oomErrorInfo.exitCode).toBe('number');
+        }, 120000);
+        it('should correctly identify local development environment in OOM info', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker');
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            const oomErrorInfo = lastRequest.body.event_data.error.oom_error_info;
+            // Test runs in local development mode
+            expect(oomErrorInfo.isLocalDevelopment).toBe(true);
+            expect(oomErrorInfo.isLambda).toBe(false);
+        }, 120000);
+    });
+    describe('memory limit edge cases', () => {
+        it('should handle very small memory limit (32MB)', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Use a very small memory limit
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker', {
+                testMemoryLimitMb: 32,
+            });
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info.memoryLimitMb).toBe(32);
+        }, 120000);
+        it('should handle moderate memory limit (128MB)', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker', {
+                testMemoryLimitMb: 128,
+            });
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info.memoryLimitMb).toBe(128);
+        }, 120000);
+    });
+    describe('memory monitoring during OOM', () => {
+        it('should not cause issues when memory monitoring runs during OOM buildup', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Gradual worker gives time for memory monitoring to run
+            await (0, extraction_2.default)([event], __dirname + '/oom-gradual-worker');
+            // Parent thread should still be functional
+            const requests = mockServer.getRequests();
+            expect(requests.length).toBeGreaterThan(0);
+            // Should still receive OOM error
+            const lastRequest = requests[requests.length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        }, 120000);
+        it('should properly clean up after OOM and allow subsequent operations', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            // First OOM event
+            const event1 = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event1], __dirname + '/oom-worker');
+            const requestsAfterFirst = mockServer.getRequests().length;
+            // Clear and run second OOM event
+            mockServer.clearRequests();
+            const event2 = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            await (0, extraction_2.default)([event2], __dirname + '/oom-worker');
+            const requestsAfterSecond = mockServer.getRequests().length;
+            // Both runs should have completed and made requests
+            expect(requestsAfterFirst).toBeGreaterThan(0);
+            expect(requestsAfterSecond).toBeGreaterThan(0);
+            // Both should have emitted OOM errors
+            const lastRequest = mockServer.getRequests()[mockServer.getRequests().length - 1];
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+        }, 240000); // 4 minute timeout for two OOM tests
+    });
+    describe('race condition handling', () => {
+        it('should handle rapid OOM (error before any logging)', async () => {
+            const baseUrl = mockServer.getBaseUrl();
+            const event = (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.StartExtractingData,
+                eventContextOverrides: {
+                    callback_url: `${baseUrl}/internal/airdrop.external-extractor.message`,
+                    worker_data_url: `${baseUrl}/internal/airdrop.external-worker`,
+                },
+                executionMetadataOverrides: {
+                    devrev_endpoint: `${baseUrl}`,
+                },
+            });
+            // Very small limit causes near-instant OOM
+            await (0, extraction_2.default)([event], __dirname + '/oom-worker', {
+                testMemoryLimitMb: 16,
+            });
+            const requests = mockServer.getRequests();
+            const lastRequest = requests[requests.length - 1];
+            // Should still properly detect and report OOM
+            expect(lastRequest.body.event_type).toBe(extraction_1.ExtractorEventType.DataExtractionError);
+            expect(lastRequest.body.event_data.error.oom_error_info).toBeDefined();
+        }, 120000);
+    });
+});

package/dist/tests/oom-handling/oom-metadata-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=oom-metadata-worker.d.ts.map

package/dist/tests/oom-handling/oom-metadata-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oom-metadata-worker.d.ts","sourceRoot":"","sources":["../../../src/tests/oom-handling/oom-metadata-worker.ts"],"names":[],"mappings":""}

package/dist/tests/oom-handling/oom-metadata-worker.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Worker that causes OOM during metadata extraction.
+ * Tests OOM handling for EventType.StartExtractingMetadata.
+ */
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        console.log('OOM metadata worker starting');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const memoryHog = [];
+        while (true) {
+            const chunk = [];
+            for (let i = 0; i < 10000; i++) {
+                chunk.push({
+                    data: 'metadata'.repeat(12),
+                    index: i,
+                });
+            }
+            memoryHog.push(chunk);
+        }
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.MetadataExtractionDone);
+    },
+});

package/dist/tests/oom-handling/oom-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=oom-worker.d.ts.map

package/dist/tests/oom-handling/oom-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oom-worker.d.ts","sourceRoot":"","sources":["../../../src/tests/oom-handling/oom-worker.ts"],"names":[],"mappings":""}

package/dist/tests/oom-handling/oom-worker.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+/**
+ * Worker that intentionally causes an OOM error by allocating large arrays.
+ * This is used to test OOM detection and handling in the parent thread.
+ *
+ * Note: We use JavaScript arrays/objects to allocate V8 heap memory,
+ * not Buffers (which use external memory and aren't limited by resourceLimits).
+ */
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        console.log('OOM worker starting - will intentionally cause OOM');
+        // Array to hold references to prevent garbage collection
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const memoryHog = [];
+        try {
+            // Allocate memory in chunks until we run out
+            // Each chunk is approximately 1MB of heap memory (array of objects)
+            let totalAllocated = 0;
+            while (true) {
+                // Create an array of objects to consume V8 heap memory
+                // Each object with strings consumes heap memory
+                const chunk = [];
+                for (let i = 0; i < 10000; i++) {
+                    chunk.push({
+                        data: 'x'.repeat(100), // 100 bytes per string
+                        index: i,
+                    });
+                }
+                memoryHog.push(chunk);
+                totalAllocated += 1; // Approximately 1MB per chunk
+                if (totalAllocated % 10 === 0) {
+                    console.log(`Allocated approximately ${totalAllocated}MB of heap memory`);
+                }
+                // Small delay to allow logging (but not too long to avoid timeout)
+                if (totalAllocated % 50 === 0) {
+                    await new Promise((resolve) => setTimeout(resolve, 1));
+                }
+            }
+        }
+        catch (error) {
+            // This catch block may not be reached if OOM kills the process
+            console.error('Error during memory allocation:', error);
+            await adapter.emit(index_1.ExtractorEventType.DataExtractionError, {
+                error: { message: 'Memory allocation failed' },
+            });
+        }
+    },
+    onTimeout: async ({ adapter }) => {
+        // This should not be called in OOM scenario
+        console.log('OOM worker timeout handler called');
+        await adapter.emit(index_1.ExtractorEventType.DataExtractionProgress);
+    },
+});

package/dist/tests/oom-handling/worker-memory.test.d.ts

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

package/dist/tests/oom-handling/worker-memory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-memory.test.d.ts","sourceRoot":"","sources":["../../../src/tests/oom-handling/worker-memory.test.ts"],"names":[],"mappings":""}