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

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

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingAdapter = void 0;
+const logger_1 = require("../../logger/logger");
+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");
+/** Adapter passed to loading tasks (item/attachment loading, loader reports). @public */
+class LoadingAdapter extends base_adapter_1.BaseAdapter {
+    /** @internal */
+    constructor(params) {
+        super(params);
+        this.loaderReports = [];
+        this._processedFiles = [];
+    }
+    get reports() {
+        return this.loaderReports;
+    }
+    get processedFiles() {
+        return this._processedFiles;
+    }
+    /** @internal */
+    async beforeEmit() {
+        // Loading has no pre-emit work.
+    }
+    /** @internal */
+    buildEmitPayload(newEventType) {
+        const isLoaderEvent = Object.values(loading_1.LoaderEventType).includes(newEventType);
+        return isLoaderEvent
+            ? {
+                reports: this.reports,
+                processed_files: this.processedFiles,
+            }
+            : {};
+    }
+    /** @internal */
+    afterEmit() {
+        // Loading keeps its accumulated reports/processed files across emits.
+    }
+    async loadItemTypes({ itemTypesToLoad, }) {
+        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' };
+            }
+            this.adapterState.sdkState.fromDevRev = {
+                filesToLoad: await this.getLoaderBatches(itemTypes),
+            };
+        }
+        return this.loadFiles('data', (fileToLoad) => {
+            const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
+            if (!itemTypeToLoad) {
+                return;
+            }
+            return async (item) => this.loadItem({ item, itemTypeToLoad });
+        });
+    }
+    async loadAttachments({ create, }) {
+        if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
+            this.adapterState.sdkState.fromDevRev = {
+                filesToLoad: await this.getLoaderBatches(['attachment']),
+            };
+        }
+        return this.loadFiles('attachment', () => async (item) => this.loadAttachment({ item, create }));
+    }
+    /**
+     * Walks the transformer files in `fromDevRev.filesToLoad`, resuming from
+     * each file's `lineToProcess`. `getLoader` returns undefined when a file has
+     * an item type the connector can't load, which fails the phase.
+     */
+    async loadFiles(kind, getLoader) {
+        var _a;
+        const filesToLoad = (_a = this.adapterState.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad;
+        if (!(filesToLoad === null || filesToLoad === void 0 ? void 0 : filesToLoad.length)) {
+            console.log('No files to load, returning.');
+            return { status: 'success' };
+        }
+        console.log('Files to load in state', filesToLoad);
+        try {
+            for (const fileToLoad of filesToLoad) {
+                if (fileToLoad.completed) {
+                    continue;
+                }
+                const load = getLoader(fileToLoad);
+                if (!load) {
+                    const message = `Item type to load not found for item type: ${fileToLoad.itemType}.`;
+                    console.error(message);
+                    return { status: 'error', error: { message } };
+                }
+                const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                    artifactId: fileToLoad.id,
+                    isGzipped: true,
+                });
+                if (transformerFileError) {
+                    const message = `Transformer file not found for artifact ID: ${fileToLoad.id}.`;
+                    console.error(message);
+                    return { status: 'error', error: { message } };
+                }
+                const transformerFile = response;
+                for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                    if (this.isTimeout) {
+                        console.log(`Timeout detected during ${kind} loading. Returning progress to allow continuation.`);
+                        return { status: 'progress' };
+                    }
+                    const { report, rateLimit } = await load(transformerFile[i]);
+                    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 ${kind} loading.`, (0, logger_1.serializeError)(error));
+            return {
+                status: 'error',
+                error: {
+                    message: `Error during ${kind} loading. ${(0, logger_1.serializeError)(error)}`,
+                },
+            };
+        }
+        return { status: 'success' };
+    }
+    async getLoaderBatches(supportedItemTypes) {
+        var _a;
+        const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
+        if (!statsFileArtifactId) {
+            return [];
+        }
+        const { response, error: statsFileError } = await this.uploader.getJsonObjectByArtifactId({
+            artifactId: statsFileArtifactId,
+        });
+        const statsFile = response;
+        if (statsFileError || statsFile.length === 0) {
+            return [];
+        }
+        return (0, loading_adapter_helpers_1.getFilesToLoad)({ supportedItemTypes, statsFile });
+    }
+    async loadItem({ item, itemTypeToLoad, }) {
+        const devrevId = item.id.devrev;
+        const syncUnit = this.event.payload.event_context.sync_unit;
+        let syncMapperRecord;
+        try {
+            syncMapperRecord = await this.mappers.getByTargetId({
+                sync_unit: syncUnit,
+                target: devrevId,
+            });
+        }
+        catch (error) {
+            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),
+                },
+            };
+        }
+        const loadParams = { item, mappers: this.mappers, event: this.event };
+        if (syncMapperRecord) {
+            const response = await itemTypeToLoad.update(loadParams);
+            if (response.status !== 'success') {
+                return this.toFailedLoad(itemTypeToLoad.itemType, 'update', response);
+            }
+            try {
+                const syncMapperRecordUpdate = await this.mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: syncUnit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL }, (response.modifiedDate && {
+                    external_versions: {
+                        add: [
+                            {
+                                modified_date: response.modifiedDate,
+                                recipe_version: 0,
+                            },
+                        ],
+                    },
+                })), { external_ids: {
+                        add: [response.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,
+                },
+            };
+        }
+        const response = await itemTypeToLoad.create(loadParams);
+        if (response.status !== 'success') {
+            return this.toFailedLoad(itemTypeToLoad.itemType, 'create', response);
+        }
+        try {
+            const syncMapperRecordCreate = await this.mappers.create(Object.assign({ sync_unit: syncUnit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [response.id], targets: [devrevId] }, (response.modifiedDate && {
+                external_versions: [
+                    {
+                        modified_date: response.modifiedDate,
+                        recipe_version: 0,
+                    },
+                ],
+            })));
+            console.log('Successfully created sync mapper record.', syncMapperRecordCreate);
+        }
+        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),
+                },
+            };
+        }
+        return {
+            report: {
+                item_type: itemTypeToLoad.itemType,
+                [loading_1.ActionType.CREATED]: 1,
+            },
+        };
+    }
+    /** Maps a non-success connector response to a delay or a failed report. */
+    toFailedLoad(itemType, action, response) {
+        if (response.status === 'delay') {
+            console.log(`Rate limited during ${action} in external system, delaying for ${response.delaySeconds} seconds.`);
+            return { rateLimit: { delay: response.delaySeconds } };
+        }
+        console.warn(`Failed to ${action} item in external system.`, response.error.message);
+        return {
+            report: {
+                item_type: itemType,
+                [loading_1.ActionType.FAILED]: 1,
+            },
+        };
+    }
+    async loadAttachment({ item, create, }) {
+        const response = await create({
+            item,
+            mappers: this.mappers,
+            event: this.event,
+        });
+        if (response.status !== 'success') {
+            return this.toFailedLoad('attachments', 'create', response);
+        }
+        try {
+            const syncMapperRecordCreate = await this.mappers.create({
+                sync_unit: this.event.payload.event_context.sync_unit,
+                external_ids: [response.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: 'attachments',
+                [loading_1.ActionType.CREATED]: 1,
+            },
+        };
+    }
+}
+exports.LoadingAdapter = LoadingAdapter;

package/dist/multithreading/emit.d.ts

@@ -0,0 +1,11 @@
+import { AxiosResponse } from 'axios';
+import { AirSyncEvent, EventData, ExtractorEventType, WorkerMetadata } from '../types/extraction';
+import { LoaderEventType } from '../types/loading';
+export interface EmitInterface {
+    event: AirSyncEvent;
+    eventType: ExtractorEventType | LoaderEventType;
+    data?: EventData;
+    worker_metadata?: WorkerMetadata;
+}
+export declare const emit: ({ event, eventType, data, worker_metadata, }: EmitInterface) => Promise<AxiosResponse>;
+//# 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;AAItC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAClB,cAAc,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC;AAED,eAAO,MAAM,IAAI,GAAU,8CAKxB,aAAa,KAAG,OAAO,CAAC,aAAa,CA+BvC,CAAC"}

package/dist/multithreading/emit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emit = void 0;
+const constants_1 = require("../common/constants");
+const client_1 = require("../http/client");
+const emit = async ({ event, eventType, data, worker_metadata, }) => {
+    const newEvent = {
+        event_type: eventType,
+        event_context: event.payload.event_context,
+        event_data: Object.assign({}, data),
+        worker_metadata: Object.assign(Object.assign({}, worker_metadata), { newest_state_date: event.payload.event_context.extract_to, oldest_state_date: event.payload.event_context.extract_from, adaas_library_version: constants_1.LIBRARY_VERSION }),
+    };
+    console.info('Emitting event', 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,
+            'Content-Type': 'application/json',
+            'X-DevRev-Client-Platform': event.payload.event_context.snap_in_slug,
+            'X-DevRev-Client-Id': event.payload.event_context.snap_in_version_id,
+            'X-DevRev-Client-Version': constants_1.LIBRARY_VERSION,
+        },
+    });
+};
+exports.emit = emit;

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

@@ -1,3 +1,8 @@
 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. @public */
+export declare function processExtractionTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ExtractionAdapter<ConnectorState>>): void;
+/** Entry point for a loading worker. @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":"AAQA,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,wBAAgB,WAAW,CAAC,cAAc,EAAE,EAC1C,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,cAAc,CAAC,QAqGtC"}
+{"version":3,"file":"process-task.d.ts","sourceRoot":"","sources":["../../src/multithreading/process-task.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,oBAAoB,EAIrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAyF5D,oDAAoD;AACpD,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,EACpD,IAAI,EACJ,SAAS,GACV,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,QA6BzD;AAED,gDAAgD;AAChD,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,93 +1,131 @@
 "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 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 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;
+const extraction_adapter_1 = require("./adapters/extraction-adapter");
+const loading_adapter_1 = require("./adapters/loading-adapter");
+const spawn_helpers_1 = require("./spawn/spawn.helpers");
+/**
+ * Shared worker-thread driver: builds the adapter, runs the task, maps the
+ * returned {@link TaskResult} to a platform event and emits it exactly once.
+ * On soft timeout a returned `progress` is replaced by the `onTimeout` result
+ * (or a phase-appropriate default), and so is a `success` in resumable phases.
+ * A returned `error` or `delay`, or a `success` in a non-resumable phase, is
+ * emitted as is.
+ */
+async function runWorkerTask(buildAdapter, { task, onTimeout }) {
+    let adapter;
+    try {
+        adapter = await buildAdapter();
+        const workerAdapter = adapter;
+        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.');
+            workerAdapter.isTimeout = true;
+        });
+        console.log('Event passed from SDK to the connector:', adapter.event);
+        let result = await task({ adapter });
+        if (adapter.isTimeout) {
+            // A returned error or delay is a real outcome and must reach the
+            // platform. A success is replaced only where the phase can hand off
+            // with progress; a non-resumable phase that finished late is still done.
+            const eventType = adapter.event.payload.event_type;
+            const isResumable = !(0, spawn_helpers_1.getEventTypeForResult)(eventType, 'progress').illegal;
+            const canBeReplaced = result.status === 'progress' ||
+                (result.status === 'success' && isResumable);
+            if (canBeReplaced && onTimeout) {
+                result = await onTimeout({ adapter });
+            }
+            else if (canBeReplaced) {
+                result = isResumable
+                    ? { status: 'progress' }
+                    : {
+                        status: 'error',
+                        error: {
+                            message: `Worker timed out during a non-resumable phase (${eventType}), which cannot be continued.`,
+                        },
+                    };
+            }
+        }
+        await adapter.emitFromResult(result);
+        process.exit(0);
     }
-    void (async () => {
-        await (0, logger_context_1.runWithSdkLogContext)(async () => {
+    catch (error) {
+        if (adapter && !adapter.hasWorkerEmitted) {
             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,
-                });
-                const adapter = new worker_adapter_1.WorkerAdapter({
-                    event,
-                    adapterState,
-                    options,
-                });
-                // Timeout handling flow:
-                // The task() runs in the main flow below. Meanwhile, the parent thread may send
-                // a timeout message at any point. When that happens, the message handler signals
-                // the adapter to stop (handleTimeout), waits for task() to finish, then runs onTimeout().
-                // If task() completes before any timeout message arrives, the worker exits normally.
-                // isTimeoutReceived prevents both flows from calling process.exit.
-                let isTimeoutReceived = false;
-                let taskExecution;
-                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
-                    if (message.subject !== workers_1.WorkerMessageSubject.WorkerMessageExit) {
-                        return;
-                    }
-                    isTimeoutReceived = true;
-                    void (0, logger_context_1.runWithSdkLogContext)(async () => {
-                        try {
-                            console.log('Timeout received. Waiting for the task to finish.');
-                            adapter.handleTimeout();
-                            try {
-                                await taskExecution;
-                            }
-                            catch (taskError) {
-                                console.warn('Task error during timeout:', (0, logger_1.serializeError)(taskError));
-                            }
-                            console.log('Task finished. Running onTimeout handler.');
-                            await (0, logger_context_1.runWithUserLogContext)(async () => onTimeout({ adapter }));
-                            console.log('onTimeout handler complete. Exiting worker.');
-                            process.exit(0);
-                        }
-                        catch (onTimeoutError) {
-                            console.error('Error in onTimeout handler:', (0, logger_1.serializeError)(onTimeoutError));
-                            process.exit(1);
-                        }
-                    });
-                });
-                taskExecution = (0, logger_context_1.runWithUserLogContext)(async () => task({ adapter }));
-                try {
-                    await taskExecution;
-                }
-                catch (taskError) {
-                    if (isTimeoutReceived) {
-                        console.log('Task threw during timeout. Letting timeout handler finish.');
-                        return;
-                    }
-                    throw taskError;
-                }
-                if (!isTimeoutReceived) {
-                    console.log('Task completed. Exiting worker.');
-                    process.exit(0);
-                }
+                await adapter.emitError(error);
             }
-            catch (error) {
-                console.error('Error while processing task.', (0, logger_1.serializeError)(error));
-                process.exit(1);
+            catch (emitError) {
+                console.error('Error while emitting task failure.', (0, logger_1.serializeError)(emitError));
             }
+        }
+        if (adapter === null || adapter === void 0 ? void 0 : adapter.hasWorkerEmitted) {
+            process.exit(1);
+            return;
+        }
+        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. @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. @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 });
 }

package/dist/multithreading/spawn/spawn.d.ts

@@ -1,17 +1,15 @@
 import { SpawnFactoryInterface, SpawnInterface } from '../../types/workers';
 /**
- * Creates a new instance of Spawn class.
- * Spawn class is responsible for spawning a new worker thread and managing the lifecycle of the worker.
- * The class provides utilities to emit control events to the platform and exit the worker gracefully.
- * In case of lambda timeout, the class emits a lambda timeout event to the platform.
- * @param {SpawnFactoryInterface} options - The options to create a new instance of Spawn class
- * @param {AirdropEvent} options.event - The event object received from the platform
- * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.workerPath] Remove getWorkerPath function and use baseWorkerPath: __dirname instead of workerPath
- * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
- * @returns {Promise<Spawn>} - A new instance of Spawn class
+ * Local mode is opt-in through AIRSYNC_LOCAL_DEVELOPMENT only, and refused on
+ * Lambda so a stray flag can never change production behavior.
  */
-export declare function spawn<ConnectorState>({ event, initialState, workerPath, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
+export declare function isLocalDevelopment(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Spawns a worker thread for the event and manages its lifecycle (control
+ * events, graceful exit, lambda timeout handling). Resolves when the worker
+ * run is fully finished.
+ */
+export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options: spawnOptions, baseWorkerPath, workerPathOverrides, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
 export declare class Spawn {
     private event;
     private alreadyEmitted;
@@ -24,6 +22,7 @@ export declare class Spawn {
     private resolve;
     private originalConsole;
     private logger;
+    private workerFailedMessage;
     constructor({ event, worker, options, resolve, originalConsole, }: SpawnInterface);
     private clearTimeouts;
     private exitFromMainThread;

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

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IA4GjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AASA,OAAO,EAGL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AAe7B;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,oBAAc,GAAG,OAAO,CAY7D;AAoCD;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,EAAE,YAAY,EACrB,cAAc,EACd,mBAAmB,GACpB,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0DvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAqB;gBACpC,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IA0GjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAoCjC"}

package/dist/multithreading/spawn/spawn.helpers.d.ts

@@ -1,21 +1,22 @@
 import { EventType, ExtractorEventType } from '../../types/extraction';
 import { LoaderEventType } from '../../types/loading';
+import { TaskStatus } from '../../types/workers';
 /**
- * Gets the event type for the timeout error.
- * @param {EventType} eventType - The event type to get the timeout error event type for
- * @returns {ExtractorEventType | LoaderEventType} The event type for the timeout error
+ * Resolves the outgoing event type to emit for an incoming event type and a
+ * {@link TaskResult} status. Resumable phases honor every status
+ * (success/progress/delay/error -> *_DONE/*_PROGRESS/*_DELAYED/*_ERROR);
+ * non-resumable phases only have done/error, so `progress`/`delay` there is
+ * illegal and maps to the phase's error event.
  */
+export declare function getEventTypeForResult(eventType: EventType, status: TaskStatus): {
+    eventType: ExtractorEventType | LoaderEventType;
+    illegal: boolean;
+};
 export declare function getTimeoutErrorEventType(eventType: EventType): {
     eventType: ExtractorEventType | LoaderEventType;
 };
-/**
- * Gets the event type for the no script error.
- * @param {EventType} eventType - The event type to get the no script error event type for
- * @returns {ExtractorEventType | LoaderEventType} The event type for the no script error
- */
+/** Event type to emit when no worker script exists for the incoming event. */
 export declare function getNoScriptEventType(eventType: EventType): {
-    eventType: ExtractorEventType;
-} | {
-    eventType: LoaderEventType;
+    eventType: ExtractorEventType | LoaderEventType;
 };
 //# sourceMappingURL=spawn.helpers.d.ts.map

package/dist/multithreading/spawn/spawn.helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAmFA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}
+{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,UAAU,GACjB;IACD,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,OAAO,EAAE,OAAO,CAAC;CAClB,CAiCA;AAgHD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAEA;AAED,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;eA+BhB,kBAAkB,GAAG,eAAe;EAG5E"}