@devrev/ts-adaas 1.5.1 → 1.6.0

package/dist/tests/mock-server.js

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockServer = void 0;
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+class MockServer {
+    constructor(port) {
+        this.server = null;
+        this.consoleLogs = [];
+        this.requests = [];
+        this.port = port || 3001; // Default to standard test port
+    }
+    getDefaultWorkerState() {
+        return {
+            lastSyncStarted: '',
+            lastSuccessfulSyncStarted: '',
+            snapInVersionId: 'test-snap-in-version-id',
+            toDevRev: {
+                attachmentsMetadata: {
+                    artifactIds: [],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            },
+        };
+    }
+    handleRequest(req, res) {
+        const parsedUrl = url.parse(req.url || '', true);
+        const pathname = parsedUrl.pathname || '';
+        const method = req.method || 'GET';
+        // Track this request
+        const requestInfo = {
+            method,
+            url: req.url || '',
+        };
+        // For POST requests, capture the body
+        if (method === 'POST') {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk.toString()));
+            req.on('end', () => {
+                try {
+                    requestInfo.body = JSON.parse(body);
+                }
+                catch (_a) {
+                    requestInfo.body = body;
+                }
+                this.requests.push(requestInfo);
+            });
+        }
+        else {
+            this.requests.push(requestInfo);
+        }
+        // Set CORS headers for all requests
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        res.setHeader('Content-Type', 'application/json');
+        switch (method) {
+            case 'OPTIONS':
+                // Handle preflight CORS requests
+                res.writeHead(200);
+                res.end();
+                break;
+            case 'GET':
+                switch (true) {
+                    case pathname.includes('airdrop.external-worker'):
+                        // Worker state GET endpoint
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            state: JSON.stringify(this.getDefaultWorkerState()),
+                        }));
+                        break;
+                    case pathname.includes('snap-ins.get'):
+                        // Snap-ins endpoint for install-initial-domain-mapping
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            snap_in: {
+                                imports: [{ name: 'test_import_slug' }],
+                                snap_in_version: { slug: 'test_snap_in_slug' },
+                            },
+                        }));
+                        break;
+                    case pathname.includes('/upload') || pathname.includes('/download'):
+                        // Generic file download endpoints for artifacts
+                        res.writeHead(200);
+                        res.setHeader('Content-Type', 'application/octet-stream');
+                        res.end(Buffer.from('mock file content'));
+                        break;
+                    default:
+                        // Unknown GET endpoint
+                        res.writeHead(404);
+                        res.end(JSON.stringify({
+                            error: 'GET endpoint not found',
+                            code: 'ENDPOINT_NOT_FOUND',
+                        }));
+                }
+                break;
+            case 'POST':
+                switch (true) {
+                    case pathname.includes('airdrop.external-worker'):
+                        // Worker state POST/UPDATE endpoint
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            success: true,
+                            updated_at: new Date().toISOString(),
+                        }));
+                        break;
+                    case pathname.includes('airdrop.external-extractor.message'):
+                        // Callback endpoint for event emissions
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            success: true,
+                            received_at: new Date().toISOString(),
+                        }));
+                        break;
+                    case pathname.includes('recipe.blueprints.create'):
+                        // Recipe blueprint creation endpoint
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            recipe_blueprint: { id: 'test_recipe_blueprint_id' },
+                        }));
+                        break;
+                    case pathname.includes('initial-domain-mappings.install'):
+                        // Domain mappings installation endpoint
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            success: true,
+                            message: 'Initial domain mappings installed successfully',
+                        }));
+                        break;
+                    case pathname.includes('artifacts.prepare'):
+                        // Artifacts prepare endpoint for uploader
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            id: `test_artifact_${Date.now()}`,
+                            url: `${this.getBaseUrl()}/upload`,
+                            form_data: [
+                                { key: 'key', value: 'test-key' },
+                                { key: 'x-amz-algorithm', value: 'AWS4-HMAC-SHA256' },
+                                { key: 'x-amz-credential', value: 'test-credential' },
+                                { key: 'x-amz-date', value: new Date().toISOString() },
+                                { key: 'policy', value: 'test-policy' },
+                                { key: 'x-amz-signature', value: 'test-signature' },
+                            ],
+                        }));
+                        break;
+                    case pathname.includes('artifacts.locate'):
+                        // Artifacts locate endpoint for uploader
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            url: `${this.getBaseUrl()}/download/artifact.jsonl.gz`,
+                        }));
+                        break;
+                    case pathname.includes('/upload'):
+                        // File upload endpoint for artifacts
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            success: true,
+                            message: 'File uploaded successfully',
+                            ETag: '"test-etag-12345"',
+                        }));
+                        break;
+                    default:
+                        // Unknown POST endpoint
+                        res.writeHead(404);
+                        res.end(JSON.stringify({
+                            error: 'POST endpoint not found',
+                            code: 'ENDPOINT_NOT_FOUND',
+                        }));
+                }
+                break;
+            case 'PUT':
+                switch (true) {
+                    case pathname.includes('/upload'):
+                        // PUT file upload endpoint for artifacts (alternative upload method)
+                        res.writeHead(200);
+                        res.end(JSON.stringify({
+                            success: true,
+                            message: 'File uploaded successfully via PUT',
+                            ETag: '"test-etag-put-12345"',
+                        }));
+                        break;
+                    default:
+                        // Unknown PUT endpoint
+                        res.writeHead(404);
+                        res.end(JSON.stringify({
+                            error: 'PUT endpoint not found',
+                            code: 'ENDPOINT_NOT_FOUND',
+                        }));
+                }
+                break;
+            default:
+                // Unsupported HTTP method
+                res.writeHead(405);
+                res.end(JSON.stringify({
+                    error: `Method ${method} not allowed`,
+                    code: 'METHOD_NOT_ALLOWED',
+                }));
+        }
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                this.handleRequest(req, res);
+            });
+            this.server.listen(this.port, () => {
+                console.log(`Mock server running on port ${this.port}`);
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('Mock server stopped');
+                    this.server = null;
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getBaseUrl() {
+        return `http://localhost:${this.port}`;
+    }
+    getPort() {
+        return this.port;
+    }
+    getConsoleLogs() {
+        return [...this.consoleLogs];
+    }
+    getRequests() {
+        return [...this.requests];
+    }
+    clearRequests() {
+        this.requests = [];
+    }
+}
+exports.MockServer = MockServer;

package/dist/tests/test-helpers.d.ts

@@ -1,7 +1,7 @@
 import { Item, NormalizedAttachment, NormalizedItem } from '../repo/repo.interfaces';
 import { AirdropEvent } from '../types/extraction';
 import { CreateEventInterface } from './test-helpers.interfaces';
-export declare function createEvent({ eventType, externalSyncUnits, progress, error, delay, contextOverrides, payloadOverrides, }: CreateEventInterface): AirdropEvent;
+export declare function createEvent({ eventType, externalSyncUnits, progress, error, delay, contextOverrides, payloadOverrides, eventContextOverrides, executionMetadataOverrides, }: CreateEventInterface): AirdropEvent;
 export declare function createItem(id: number): Item;
 export declare function createItems(count: number): Item[];
 export declare function normalizeItem(item: Item): NormalizedItem;

package/dist/tests/test-helpers.interfaces.d.ts

@@ -1,5 +1,5 @@
 import { ErrorRecord } from '../types/common';
-import { AirdropEvent, EventType, ExternalSyncUnit } from '../types/extraction';
+import { AirdropEvent, EventType, ExternalSyncUnit, EventContext } from '../types/extraction';
 export interface CreateEventInterface {
     eventType: EventType;
     externalSyncUnits?: ExternalSyncUnit[];
@@ -8,4 +8,6 @@ export interface CreateEventInterface {
     delay?: number;
     contextOverrides?: Partial<AirdropEvent['context']>;
     payloadOverrides?: Partial<AirdropEvent['payload']>;
+    eventContextOverrides?: Partial<EventContext>;
+    executionMetadataOverrides?: Partial<AirdropEvent['execution_metadata']>;
 }

package/dist/tests/test-helpers.js

@@ -6,7 +6,31 @@ exports.createItems = createItems;
 exports.normalizeItem = normalizeItem;
 exports.createAttachment = createAttachment;
 exports.createAttachments = createAttachments;
-function createEvent({ eventType, externalSyncUnits = [], progress, error, delay, contextOverrides = {}, payloadOverrides = {}, }) {
+function createEvent({ eventType, externalSyncUnits = [], progress, error, delay, contextOverrides = {}, payloadOverrides = {}, eventContextOverrides = {}, executionMetadataOverrides = {}, }) {
+    const defaultEventContext = {
+        callback_url: 'test_callback_url',
+        dev_org: 'test_dev_org',
+        dev_org_id: 'test_dev_org_id',
+        dev_user: 'test_dev_user',
+        dev_user_id: 'test_dev_user_id',
+        external_sync_unit: 'test_external_sync_unit',
+        external_sync_unit_id: 'test_external_sync_unit_id',
+        external_sync_unit_name: 'test_external_sync_unit_name',
+        external_system: 'test_external_system',
+        external_system_type: 'test_external_system_type',
+        import_slug: 'test_import_slug',
+        mode: 'test_mode',
+        request_id: 'test_request_id',
+        snap_in_slug: 'test_snap_in_slug',
+        snap_in_version_id: 'test_snap_in_version_id',
+        sync_run: 'test_sync_run',
+        sync_run_id: 'test_sync_run_id',
+        sync_tier: 'test_sync_tier',
+        sync_unit: 'test_sync_unit',
+        sync_unit_id: 'test_sync_unit_id',
+        uuid: 'test_uuid',
+        worker_data_url: 'test_worker_data_url',
+    };
     return {
         context: Object.assign({ secrets: {
                 service_account_token: 'test_token',
@@ -16,38 +40,13 @@ function createEvent({ eventType, externalSyncUnits = [], progress, error, delay
                 org_name: 'test_org_name',
                 key: 'test_key',
                 key_type: 'test_key_type',
-            }, event_context: {
-                callback_url: 'test_callback_url',
-                dev_org: 'test_dev_org',
-                dev_org_id: 'test_dev_org_id',
-                dev_user: 'test_dev_user',
-                dev_user_id: 'test_dev_user_id',
-                external_sync_unit: 'test_external_sync_unit',
-                external_sync_unit_id: 'test_external_sync_unit_id',
-                external_sync_unit_name: 'test_external_sync_unit_name',
-                external_system: 'test_external_system',
-                external_system_type: 'test_external_system_type',
-                import_slug: 'test_import_slug',
-                mode: 'test_mode',
-                request_id: 'test_request_id',
-                snap_in_slug: 'test_snap_in_slug',
-                snap_in_version_id: 'test_snap_in_version_id',
-                sync_run: 'test_sync_run',
-                sync_run_id: 'test_sync_run_id',
-                sync_tier: 'test_sync_tier',
-                sync_unit: 'test_sync_unit',
-                sync_unit_id: 'test_sync_unit_id',
-                uuid: 'test_uuid',
-                worker_data_url: 'test_worker_data_url',
-            }, event_type: eventType, event_data: {
+            }, event_context: Object.assign(Object.assign({}, defaultEventContext), eventContextOverrides), event_type: eventType, event_data: {
                 external_sync_units: externalSyncUnits,
                 progress,
                 error,
                 delay,
             } }, payloadOverrides),
-        execution_metadata: {
-            devrev_endpoint: 'test_devrev_endpoint',
-        },
+        execution_metadata: Object.assign({ devrev_endpoint: 'test_devrev_endpoint' }, executionMetadataOverrides),
         input_data: {
             global_values: {
                 test_global_key: 'test_global_value',

package/dist/tests/timeout-handling/extraction.d.ts

@@ -0,0 +1,3 @@
+import { AirdropEvent } from '../../index';
+declare const run: (events: AirdropEvent[], workerPath: string) => Promise<void>;
+export default run;

package/dist/tests/timeout-handling/extraction.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const initialState = {};
+const initialDomainMapping = {};
+const run = async (events, workerPath) => {
+    for (const event of events) {
+        await (0, index_1.spawn)({
+            event,
+            initialState,
+            workerPath,
+            initialDomainMapping,
+            options: {
+                batchSize: 1000,
+                timeout: 5 * 1000, // 5 seconds
+                isLocalDevelopment: true,
+            },
+        });
+    }
+};
+exports.default = run;

package/dist/tests/timeout-handling/timeout-1.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-1.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        for (let i = 0; i < 10; i++) {
+            console.log('timeout-1 iteration', i);
+        }
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataDone);
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataProgress);
+    },
+});

package/dist/tests/timeout-handling/timeout-1.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-1.test.js

@@ -0,0 +1,45 @@
+"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 test_helpers_1 = require("../test-helpers");
+const extraction_2 = __importDefault(require("./extraction"));
+const mock_server_1 = require("../mock-server");
+describe('timeout-1', () => {
+    let mockServer;
+    beforeAll(async () => {
+        mockServer = new mock_server_1.MockServer(3001);
+        await mockServer.start();
+    });
+    afterAll(async () => {
+        if (mockServer) {
+            await mockServer.stop();
+        }
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockServer.clearRequests();
+    });
+    it('should emit done event since there is no timeout', async () => {
+        const baseUrl = mockServer.getBaseUrl();
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            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 + '/timeout-1');
+        const requests = mockServer.getRequests();
+        const lastRequest = requests[requests.length - 1];
+        // Expect last request to be emission of done event
+        expect(lastRequest.url).toContain('airdrop.external-extractor.message');
+        expect(lastRequest.method).toBe('POST');
+        expect(lastRequest.body.event_type).toBe('EXTRACTION_DATA_DONE');
+    });
+});

package/dist/tests/timeout-handling/timeout-2.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-2.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+// Simulate a network request with variable delays
+const simulateNetworkRequest = (url, delay) => {
+    return new Promise((resolve) => {
+        console.log(`Starting network request to ${url}...`);
+        setTimeout(() => {
+            console.log(`Completed network request to ${url} after ${delay}ms`);
+            resolve({ status: 200, data: `Response from ${url}` });
+        }, delay);
+    });
+};
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        console.log('Starting network requests simulation...');
+        // Define request configurations
+        const requestConfigs = [
+            { url: '/api/users', delay: 3000 },
+            { url: '/api/products', delay: 4000 },
+            { url: '/api/orders', delay: 5000 },
+            { url: '/api/analytics', delay: 6000 },
+            { url: '/api/reports', delay: 4000 },
+        ];
+        try {
+            // Execute requests sequentially - this will take approximately 22 seconds total
+            for (const config of requestConfigs) {
+                const response = await simulateNetworkRequest(config.url, config.delay);
+                console.log('Network request completed:', response.data);
+            }
+            console.log('All network requests completed successfully');
+            await adapter.emit(index_1.ExtractorEventType.ExtractionDataDone);
+        }
+        catch (error) {
+            console.error('Network request failed:', error);
+            await adapter.emit(index_1.ExtractorEventType.ExtractionDataDone);
+        }
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataProgress);
+    },
+});

package/dist/tests/timeout-handling/timeout-2.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-2.test.js

@@ -0,0 +1,46 @@
+"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 test_helpers_1 = require("../test-helpers");
+const extraction_2 = __importDefault(require("./extraction"));
+const mock_server_1 = require("../mock-server");
+jest.setTimeout(15000);
+describe('timeout-2', () => {
+    let mockServer;
+    beforeAll(async () => {
+        mockServer = new mock_server_1.MockServer(3001);
+        await mockServer.start();
+    });
+    afterAll(async () => {
+        if (mockServer) {
+            await mockServer.stop();
+        }
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockServer.clearRequests();
+    });
+    it('should emit progress event when soft timeout is reached', async () => {
+        const baseUrl = mockServer.getBaseUrl();
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            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 + '/timeout-2');
+        const requests = mockServer.getRequests();
+        const lastRequest = requests[requests.length - 1];
+        // Expect last request to be emission of progress event
+        expect(lastRequest.url).toContain('airdrop.external-extractor.message');
+        expect(lastRequest.method).toBe('POST');
+        expect(lastRequest.body.event_type).toBe('EXTRACTION_DATA_PROGRESS');
+    });
+});

package/dist/tests/timeout-handling/timeout-3a.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-3a.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        console.log('Starting intensive computation...');
+        let result = 0;
+        // Intensive loop - calibrated to exceed timeout
+        for (let i = 1; i <= 30000; i++) {
+            for (let num = 2; num <= 2000; num++) {
+                let isPrime = true;
+                for (let divisor = 2; divisor <= Math.sqrt(num); divisor++) {
+                    if (num % divisor === 0) {
+                        isPrime = false;
+                        break;
+                    }
+                }
+                if (isPrime) {
+                    for (let j = 0; j < 200; j++) {
+                        result +=
+                            Math.sin(num * j) * Math.cos(i * j) * Math.sqrt(num + i + j);
+                        result = Math.abs(result) % 1000000;
+                    }
+                }
+            }
+            // Log every 500 iterations to see progress before timeout
+            if (i % 500 === 0) {
+                console.log(`timeout-3a iteration ${i}, result: ${result}`);
+            }
+        }
+        console.log(`Final computation result: ${result}`);
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataDone);
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataProgress);
+    },
+});

package/dist/tests/timeout-handling/timeout-3a.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/timeout-handling/timeout-3a.test.js

@@ -0,0 +1,46 @@
+"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 test_helpers_1 = require("../test-helpers");
+const extraction_2 = __importDefault(require("./extraction"));
+const mock_server_1 = require("../mock-server");
+jest.setTimeout(15000);
+describe('timeout-3a', () => {
+    let mockServer;
+    beforeAll(async () => {
+        mockServer = new mock_server_1.MockServer(3001);
+        await mockServer.start();
+    });
+    afterAll(async () => {
+        if (mockServer) {
+            await mockServer.stop();
+        }
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockServer.clearRequests();
+    });
+    it('should emit error event when hard timeout is reached', async () => {
+        const baseUrl = mockServer.getBaseUrl();
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            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 + '/timeout-3a');
+        const requests = mockServer.getRequests();
+        const lastRequest = requests[requests.length - 1];
+        // Expect last request to be emission of error event since we force-kill the worker
+        expect(lastRequest.url).toContain('airdrop.external-extractor.message');
+        expect(lastRequest.method).toBe('POST');
+        expect(lastRequest.body.event_type).toBe('EXTRACTION_DATA_ERROR');
+    });
+});

package/dist/tests/timeout-handling/timeout-3b.d.ts

@@ -0,0 +1 @@
+export {};