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

package/dist/multithreading/adapters/loading-adapter.js

@@ -0,0 +1,431 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingAdapter = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../logger/logger");
+const mappers_1 = require("../../mappers/mappers");
+const mappers_interfaces_1 = require("../../mappers/mappers.interfaces");
+const extraction_1 = require("../../types/extraction");
+const loading_1 = require("../../types/loading");
+const base_adapter_1 = require("./base-adapter");
+const loading_adapter_helpers_1 = require("./loading-adapter.helpers");
+/**
+ * LoadingAdapter is the adapter passed to loading tasks. It exposes the loading
+ * surface (item/attachment loading, mappers, loader reports).
+ *
+ * @public
+ */
+class LoadingAdapter extends base_adapter_1.BaseAdapter {
+    constructor(params) {
+        super(params);
+        this.loaderReports = [];
+        this._processedFiles = [];
+        this._mappers = new mappers_1.Mappers({
+            event: params.event,
+            options: params.options,
+        });
+    }
+    get reports() {
+        return this.loaderReports;
+    }
+    get processedFiles() {
+        return this._processedFiles;
+    }
+    get mappers() {
+        return this._mappers;
+    }
+    async beforeEmit() {
+        // Loading has no pre-emit work (no repos, no extraction boundaries).
+    }
+    buildEmitPayload(newEventType) {
+        const isLoaderEvent = Object.values(loading_1.LoaderEventType).includes(newEventType);
+        return isLoaderEvent
+            ? {
+                reports: this.reports,
+                processed_files: this.processedFiles,
+            }
+            : {};
+    }
+    afterEmit() {
+        // Loading keeps its accumulated reports/processed files across emits.
+    }
+    async loadItemTypes({ itemTypesToLoad, }) {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
+            var _a;
+            if (this.event.payload.event_type === extraction_1.EventType.StartLoadingData) {
+                const itemTypes = itemTypesToLoad.map((itemTypeToLoad) => itemTypeToLoad.itemType);
+                if (!itemTypes.length) {
+                    console.warn('No item types to load, returning.');
+                    return { status: 'success' };
+                }
+                const filesToLoad = await this.getLoaderBatches({
+                    supportedItemTypes: itemTypes,
+                });
+                this.sdkState.fromDevRev = {
+                    filesToLoad,
+                };
+            }
+            if (!this.sdkState.fromDevRev ||
+                !this.sdkState.fromDevRev.filesToLoad.length) {
+                console.warn('No files to load, returning.');
+                return { status: 'success' };
+            }
+            console.log('Files to load in state', (_a = this.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
+            try {
+                for (const fileToLoad of this.sdkState.fromDevRev.filesToLoad) {
+                    const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
+                    if (!itemTypeToLoad) {
+                        console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
+                        return {
+                            status: 'error',
+                            error: {
+                                message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
+                            },
+                        };
+                    }
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
+                        });
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            return {
+                                status: 'error',
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
+                            };
+                        }
+                        const transformerFile = response;
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during data loading. Returning progress to allow continuation.');
+                                return { status: 'progress' };
+                            }
+                            const { report, rateLimit } = await this.loadItem({
+                                item: transformerFile[i],
+                                itemTypeToLoad,
+                            });
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                return { status: 'delay', delaySeconds: rateLimit.delay };
+                            }
+                            if (report) {
+                                (0, loading_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
+                        }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error during data loading.', (0, logger_1.serializeError)(error));
+                return {
+                    status: 'error',
+                    error: {
+                        message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                };
+            }
+            return { status: 'success' };
+        });
+    }
+    async getLoaderBatches({ supportedItemTypes, }) {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
+            var _a;
+            const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
+            if (statsFileArtifactId) {
+                const { response, error: statsFileError } = await this.uploader.getJsonObjectByArtifactId({
+                    artifactId: statsFileArtifactId,
+                });
+                const statsFile = response;
+                if (statsFileError || statsFile.length === 0) {
+                    return [];
+                }
+                const filesToLoad = (0, loading_adapter_helpers_1.getFilesToLoad)({
+                    supportedItemTypes,
+                    statsFile,
+                });
+                return filesToLoad;
+            }
+            return [];
+        });
+    }
+    async loadAttachments({ create, }) {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
+            var _a, _b;
+            if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
+                this.sdkState.fromDevRev = {
+                    filesToLoad: await this.getLoaderBatches({
+                        supportedItemTypes: ['attachment'],
+                    }),
+                };
+            }
+            if (!this.sdkState.fromDevRev ||
+                ((_a = this.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad.length) === 0) {
+                console.log('No files to load, returning.');
+                return { status: 'success' };
+            }
+            const filesToLoad = (_b = this.sdkState.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
+            try {
+                for (const fileToLoad of filesToLoad) {
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
+                        });
+                        const transformerFile = response;
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            return {
+                                status: 'error',
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
+                            };
+                        }
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during attachment loading. Returning progress to allow continuation.');
+                                return { status: 'progress' };
+                            }
+                            const { report, rateLimit } = await this.loadAttachment({
+                                item: transformerFile[i],
+                                create,
+                            });
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                return { status: 'delay', delaySeconds: rateLimit.delay };
+                            }
+                            if (report) {
+                                (0, loading_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
+                        }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error during attachment loading.', (0, logger_1.serializeError)(error));
+                return {
+                    status: 'error',
+                    error: {
+                        message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                };
+            }
+            return { status: 'success' };
+        });
+    }
+    async loadItem({ item, itemTypeToLoad, }) {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
+            var _a;
+            const devrevId = item.id.devrev;
+            try {
+                const syncMapperRecord = await this._mappers.getByTargetId({
+                    sync_unit: this.event.payload.event_context.sync_unit,
+                    target: devrevId,
+                });
+                if (!syncMapperRecord) {
+                    console.warn('Failed to get sync mapper record from response.');
+                    return {
+                        error: {
+                            message: 'Failed to get sync mapper record from response.',
+                        },
+                    };
+                }
+                // Update item in external system
+                const { id, modifiedDate, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => {
+                    return await itemTypeToLoad.update({
+                        item,
+                        mappers: this._mappers,
+                        event: this.event,
+                    });
+                });
+                if (id) {
+                    try {
+                        const syncMapperRecordUpdate = await this._mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL }, (modifiedDate && {
+                            external_versions: {
+                                add: [
+                                    {
+                                        modified_date: modifiedDate,
+                                        recipe_version: 0,
+                                    },
+                                ],
+                            },
+                        })), { external_ids: {
+                                add: [id],
+                            }, targets: {
+                                add: [devrevId],
+                            } }));
+                        console.log('Successfully updated sync mapper record.', syncMapperRecordUpdate);
+                    }
+                    catch (error) {
+                        console.warn('Failed to update sync mapper record.', (0, logger_1.serializeError)(error));
+                        return {
+                            error: {
+                                message: 'Failed to update sync mapper record' + (0, logger_1.serializeError)(error),
+                            },
+                        };
+                    }
+                    return {
+                        report: {
+                            item_type: itemTypeToLoad.itemType,
+                            [loading_1.ActionType.UPDATED]: 1,
+                        },
+                    };
+                }
+                else if (delay) {
+                    console.log(`Rate limited while updating item in external system, delaying for ${delay} seconds.`);
+                    return {
+                        rateLimit: {
+                            delay,
+                        },
+                    };
+                }
+                else {
+                    console.warn('Failed to update item in external system', error);
+                    return {
+                        report: {
+                            item_type: itemTypeToLoad.itemType,
+                            [loading_1.ActionType.FAILED]: 1,
+                        },
+                    };
+                }
+                // TODO: Update mapper (optional)
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error)) {
+                    if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                        // Create item in external system if mapper record not found
+                        const { id, modifiedDate, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => {
+                            return await itemTypeToLoad.create({
+                                item,
+                                mappers: this._mappers,
+                                event: this.event,
+                            });
+                        });
+                        if (id) {
+                            // Create mapper
+                            try {
+                                const syncMapperRecordCreate = await this._mappers.create(Object.assign({ sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [id], targets: [devrevId] }, (modifiedDate && {
+                                    external_versions: [
+                                        {
+                                            modified_date: modifiedDate,
+                                            recipe_version: 0,
+                                        },
+                                    ],
+                                })));
+                                console.log('Successfully created sync mapper record.', syncMapperRecordCreate);
+                                return {
+                                    report: {
+                                        item_type: itemTypeToLoad.itemType,
+                                        [loading_1.ActionType.CREATED]: 1,
+                                    },
+                                };
+                            }
+                            catch (error) {
+                                console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+                                return {
+                                    error: {
+                                        message: 'Failed to create sync mapper record. ' +
+                                            (0, logger_1.serializeError)(error),
+                                    },
+                                };
+                            }
+                        }
+                        else if (delay) {
+                            return {
+                                rateLimit: {
+                                    delay,
+                                },
+                            };
+                        }
+                        else {
+                            console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
+                            return {
+                                report: {
+                                    item_type: itemTypeToLoad.itemType,
+                                    [loading_1.ActionType.FAILED]: 1,
+                                },
+                            };
+                        }
+                    }
+                    else {
+                        console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
+                        return {
+                            error: {
+                                message: error.message,
+                            },
+                        };
+                    }
+                }
+                console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
+                return {
+                    error: {
+                        message: 'Failed to get sync mapper record. ' + (0, logger_1.serializeError)(error),
+                    },
+                };
+            }
+        });
+    }
+    async loadAttachment({ item, create, }) {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
+            // Create item
+            const { id, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => create({
+                item,
+                mappers: this._mappers,
+                event: this.event,
+            }));
+            if (delay) {
+                return {
+                    rateLimit: {
+                        delay,
+                    },
+                };
+            }
+            else if (id) {
+                try {
+                    const syncMapperRecordCreate = await this._mappers.create({
+                        sync_unit: this.event.payload.event_context.sync_unit,
+                        external_ids: [id],
+                        targets: [item.reference_id],
+                        status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL,
+                    });
+                    console.log('Successfully created sync mapper record.', syncMapperRecordCreate);
+                }
+                catch (error) {
+                    console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
+                }
+                return {
+                    report: {
+                        item_type: 'attachment',
+                        [loading_1.ActionType.CREATED]: 1,
+                    },
+                };
+            }
+            else {
+                console.warn('Failed to create attachment in external system', error);
+                return {
+                    report: {
+                        item_type: 'attachment',
+                        [loading_1.ActionType.FAILED]: 1,
+                    },
+                };
+            }
+        });
+    }
+}
+exports.LoadingAdapter = LoadingAdapter;

package/dist/{common/control-protocol.d.ts → multithreading/emit.d.ts}

@@ -7,4 +7,4 @@ export interface EmitInterface {
     data?: EventData;
 }
 export declare const emit: ({ event, eventType, data, }: EmitInterface) => Promise<AxiosResponse>;
-//# sourceMappingURL=control-protocol.d.ts.map
+//# sourceMappingURL=emit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/multithreading/emit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,eAAO,MAAM,IAAI,GAAU,6BAIxB,aAAa,KAAG,OAAO,CAAC,aAAa,CA4BvC,CAAC"}

package/dist/{common/control-protocol.js → multithreading/emit.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emit = void 0;
-const axios_client_internal_1 = require("../http/axios-client-internal");
-const constants_1 = require("./constants");
+const client_1 = require("../http/client");
+const constants_1 = require("../common/constants");
 const emit = async ({ event, eventType, data, }) => {
     const newEvent = {
         event_type: eventType,
@@ -13,7 +13,7 @@ const emit = async ({ event, eventType, data, }) => {
         },
     };
     console.info('Emitting event', newEvent);
-    return axios_client_internal_1.axiosClient.post(event.payload.event_context.callback_url, Object.assign({}, newEvent), {
+    return client_1.axiosClient.post(event.payload.event_context.callback_url, Object.assign({}, newEvent), {
         headers: {
             Accept: 'application/json, text/plain, */*',
             Authorization: event.context.secrets.service_account_token,

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

@@ -1,3 +1,18 @@
 import { ProcessTaskInterface } from '../types/workers';
-export declare function processTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ConnectorState>): void;
+import { ExtractionAdapter } from './adapters/extraction-adapter';
+import { LoadingAdapter } from './adapters/loading-adapter';
+/**
+ * Entry point for an extraction worker. Builds an {@link ExtractionAdapter} and
+ * runs the provided task against it.
+ *
+ * @public
+ */
+export declare function processExtractionTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ExtractionAdapter<ConnectorState>>): void;
+/**
+ * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
+ * provided task against it.
+ *
+ * @public
+ */
+export declare function processLoadingTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<LoadingAdapter<ConnectorState>>): void;
 //# sourceMappingURL=process-task.d.ts.map

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":"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"}
+{"version":3,"file":"process-task.d.ts","sourceRoot":"","sources":["../../src/multithreading/process-task.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,oBAAoB,EAIrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAoE5D;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,EACpD,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,QA6BzD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,EACjD,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,QA6BtD"}

package/dist/multithreading/process-task.js

@@ -1,60 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processTask = processTask;
+exports.processExtractionTask = processExtractionTask;
+exports.processLoadingTask = processLoadingTask;
 const node_worker_threads_1 = require("node:worker_threads");
 const logger_1 = require("../logger/logger");
-const logger_context_1 = require("../logger/logger.context");
-const state_1 = require("../state/state");
+const extraction_state_1 = require("../state/extraction-state");
+const loading_state_1 = require("../state/loading-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) {
-        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 }));
+const extraction_adapter_1 = require("./adapters/extraction-adapter");
+const loading_adapter_1 = require("./adapters/loading-adapter");
+/**
+ * Shared worker-thread driver. Builds the logger context, runs the task and
+ * (on timeout) the onTimeout callback against the provided adapter, maps the
+ * returned {@link TaskResult} to a platform event and emits it exactly once,
+ * and wires the error/exit plumbing.
+ *
+ * The adapter is constructed by the caller so each entry point can build its
+ * own typed adapter.
+ *
+ * If `onTimeout` is omitted, the SDK emits a phase-appropriate default on
+ * timeout: `progress` (resumable phases) or `error` (non-resumable phases) is
+ * handled by the status->event mapping when we emit a `progress` result.
+ *
+ * On timeout the timeout outcome always wins: once the soft timeout has fired,
+ * the SDK emits the `onTimeout` result (or the default `progress`) and ignores
+ * whatever the task returned, because a phase that ran out of time must hand off
+ * for continuation rather than report itself complete.
+ */
+async function runWorkerTask(buildAdapter, { task, onTimeout }) {
+    await (0, logger_1.runWithSdkLogContext)(async () => {
+        try {
+            const adapter = await buildAdapter();
+            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;
                 }
-                process.exit(0);
+                console.log('Timeout received. Waiting for the task to finish.');
+                adapter.isTimeout = true;
+            });
+            let result = await (0, logger_1.runWithUserLogContext)(async () => task({ adapter }));
+            // If the soft timeout fired, the timeout outcome wins regardless of what
+            // the task returned: hand off via onTimeout (or the default progress
+            // result) so the phase continues in a fresh invocation.
+            if (adapter.isTimeout) {
+                result = onTimeout
+                    ? await (0, logger_1.runWithUserLogContext)(async () => onTimeout({ adapter }))
+                    : { status: 'progress' };
             }
-            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);
+            await adapter.emitFromResult(result);
+            process.exit(0);
+        }
+        catch (error) {
+            (0, logger_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);
+            });
+        }
+    });
+}
+/**
+ * Entry point for an extraction worker. Builds an {@link ExtractionAdapter} and
+ * runs the provided task against it.
+ *
+ * @public
+ */
+function processExtractionTask({ task, onTimeout, }) {
+    if (node_worker_threads_1.isMainThread) {
+        return;
+    }
+    void runWorkerTask(async () => {
+        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, extraction_state_1.createExtractionState)({
+            event,
+            initialState,
+            initialDomainMapping,
+            options,
+        });
+        return new extraction_adapter_1.ExtractionAdapter({
+            event,
+            adapterState,
+            options,
+        });
+    }, { task, onTimeout });
+}
+/**
+ * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
+ * provided task against it.
+ *
+ * @public
+ */
+function processLoadingTask({ task, onTimeout, }) {
+    if (node_worker_threads_1.isMainThread) {
+        return;
+    }
+    void runWorkerTask(async () => {
+        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, loading_state_1.createLoadingState)({
+            event,
+            initialState,
+            initialDomainMapping,
+            options,
+        });
+        return new loading_adapter_1.LoadingAdapter({
+            event,
+            adapterState,
+            options,
         });
-    })();
+    }, { task, onTimeout });
 }