@devrev/airsync-sdk 2.0.0-beta.3 → 2.0.0-beta.5

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,EAElB,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/{common/control-protocol.js → multithreading/emit.js}

@@ -1,19 +1,17 @@
 "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 emit = async ({ event, eventType, data, }) => {
+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: {
-            adaas_library_version: constants_1.LIBRARY_VERSION,
-        },
+        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 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,18 +1,8 @@
 import { ProcessTaskInterface } from '../types/workers';
 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
- */
+/** Entry point for an extraction worker. @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
- */
+/** 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":"AASA,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAgD5D;;;;;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"}
+{"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;AA6D5D,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

@@ -4,54 +4,62 @@ 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 extraction_state_1 = require("../state/extraction-state");
 const loading_state_1 = require("../state/loading-state");
 const workers_1 = require("../types/workers");
 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 logger context, runs the task and
- * (on timeout) the onTimeout callback against the provided adapter, and wires
- * the error/exit plumbing. The adapter is constructed by the caller so each
- * entry point can build its own typed adapter.
+ * 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 the timeout outcome always wins: the `onTimeout` result (or
+ * a phase-appropriate default) is emitted and the task's return value is
+ * ignored.
  */
 async function runWorkerTask(buildAdapter, { task, onTimeout }) {
-    await (0, logger_context_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;
-                }
-                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 }));
+    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;
+            }
+            console.log('Timeout received. Waiting for the task to finish.');
+            adapter.isTimeout = true;
+        });
+        let result = await task({ adapter });
+        if (adapter.isTimeout) {
+            if (onTimeout) {
+                result = await onTimeout({ adapter });
+            }
+            else {
+                // Non-resumable phases can't hand off with `progress`; report a timeout error.
+                const eventType = adapter.event.payload.event_type;
+                const { illegal } = (0, spawn_helpers_1.getEventTypeForResult)(eventType, 'progress');
+                result = illegal
+                    ? {
+                        status: 'error',
+                        error: {
+                            message: `Worker timed out during a non-resumable phase (${eventType}), which cannot be continued.`,
+                        },
+                    }
+                    : { status: 'progress' };
             }
-            process.exit(0);
-        }
-        catch (error) {
-            (0, logger_context_1.runWithUserLogContext)(() => {
-                const errorMessage = `Error while processing task. ${(0, logger_1.serializeError)(error)}`;
-                console.error(errorMessage);
-                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
-                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
-                    payload: { message: errorMessage },
-                });
-                process.exit(1);
-            });
         }
-    });
+        await adapter.emitFromResult(result);
+        process.exit(0);
+    }
+    catch (error) {
+        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
- */
+/** Entry point for an extraction worker. @public */
 function processExtractionTask({ task, onTimeout, }) {
     if (node_worker_threads_1.isMainThread) {
         return;
@@ -76,12 +84,7 @@ function processExtractionTask({ task, onTimeout, }) {
         });
     }, { task, onTimeout });
 }
-/**
- * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
- * provided task against it.
- *
- * @public
- */
+/** Entry point for a loading worker. @public */
 function processLoadingTask({ task, onTimeout, }) {
     if (node_worker_threads_1.isMainThread) {
         return;

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

@@ -1,14 +1,8 @@
 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 {AirSyncEvent} options.event - The event object received from the platform
- * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
- * @returns {Promise<Spawn>} - A new instance of Spawn class
+ * 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, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
 export declare class Spawn {

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":"AAOA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA+C7B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyEvD;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;IAiHjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAoCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,qBAAqB,CAAC;AA0C7B;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuEvD;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,CA2EA;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;AAuGD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAiEA;AAED,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;eAwBhB,kBAAkB,GAAG,eAAe;EAG5E"}

package/dist/multithreading/spawn/spawn.helpers.js

@@ -1,66 +1,178 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventTypeForResult = getEventTypeForResult;
 exports.getTimeoutErrorEventType = getTimeoutErrorEventType;
 exports.getNoScriptEventType = getNoScriptEventType;
+const constants_1 = require("../../common/constants");
 const extraction_1 = require("../../types/extraction");
 const loading_1 = require("../../types/loading");
 /**
- * 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.
  */
+function getEventTypeForResult(eventType, status) {
+    const phase = EVENT_PHASE_MAP[eventType];
+    if (!phase) {
+        console.error('Event type not recognized in getEventTypeForResult function: ' +
+            eventType);
+        return {
+            eventType: constants_1.UNKNOWN_EVENT_TYPE,
+            illegal: true,
+        };
+    }
+    // Non-resumable phases only define done/error events.
+    if (!phase.resumable) {
+        if (status === 'success') {
+            return { eventType: phase.done, illegal: false };
+        }
+        // progress/delay are illegal here; collapse them (and error) to the error event.
+        return { eventType: phase.error, illegal: status !== 'error' };
+    }
+    switch (status) {
+        case 'success':
+            return { eventType: phase.done, illegal: false };
+        case 'progress':
+            return { eventType: phase.progress, illegal: false };
+        case 'delay':
+            return { eventType: phase.delayed, illegal: false };
+        case 'error':
+            return { eventType: phase.error, illegal: false };
+    }
+}
+/** Per-phase outgoing event types, keyed by the incoming {@link EventType}. */
+const EVENT_PHASE_MAP = {
+    [extraction_1.EventType.StartExtractingExternalSyncUnits]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone,
+        error: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
+    },
+    [extraction_1.EventType.StartExtractingMetadata]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.MetadataExtractionDone,
+        error: extraction_1.ExtractorEventType.MetadataExtractionError,
+    },
+    [extraction_1.EventType.StartExtractingData]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.DataExtractionDone,
+        error: extraction_1.ExtractorEventType.DataExtractionError,
+        progress: extraction_1.ExtractorEventType.DataExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.DataExtractionDelayed,
+    },
+    [extraction_1.EventType.ContinueExtractingData]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.DataExtractionDone,
+        error: extraction_1.ExtractorEventType.DataExtractionError,
+        progress: extraction_1.ExtractorEventType.DataExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.DataExtractionDelayed,
+    },
+    [extraction_1.EventType.StartDeletingExtractorState]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+        error: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
+    },
+    [extraction_1.EventType.StartExtractingAttachments]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        error: extraction_1.ExtractorEventType.AttachmentExtractionError,
+        progress: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+    },
+    [extraction_1.EventType.ContinueExtractingAttachments]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        error: extraction_1.ExtractorEventType.AttachmentExtractionError,
+        progress: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+    },
+    [extraction_1.EventType.StartDeletingExtractorAttachmentsState]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+        error: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
+    },
+    [extraction_1.EventType.StartLoadingData]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.DataLoadingDone,
+        error: loading_1.LoaderEventType.DataLoadingError,
+        progress: loading_1.LoaderEventType.DataLoadingProgress,
+        delayed: loading_1.LoaderEventType.DataLoadingDelayed,
+    },
+    [extraction_1.EventType.ContinueLoadingData]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.DataLoadingDone,
+        error: loading_1.LoaderEventType.DataLoadingError,
+        progress: loading_1.LoaderEventType.DataLoadingProgress,
+        delayed: loading_1.LoaderEventType.DataLoadingDelayed,
+    },
+    [extraction_1.EventType.StartLoadingAttachments]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.AttachmentLoadingDone,
+        error: loading_1.LoaderEventType.AttachmentLoadingError,
+        progress: loading_1.LoaderEventType.AttachmentLoadingProgress,
+        delayed: loading_1.LoaderEventType.AttachmentLoadingDelayed,
+    },
+    [extraction_1.EventType.ContinueLoadingAttachments]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.AttachmentLoadingDone,
+        error: loading_1.LoaderEventType.AttachmentLoadingError,
+        progress: loading_1.LoaderEventType.AttachmentLoadingProgress,
+        delayed: loading_1.LoaderEventType.AttachmentLoadingDelayed,
+    },
+    [extraction_1.EventType.StartDeletingLoaderState]: {
+        resumable: false,
+        done: loading_1.LoaderEventType.LoaderStateDeletionDone,
+        error: loading_1.LoaderEventType.LoaderStateDeletionError,
+    },
+    [extraction_1.EventType.StartDeletingLoaderAttachmentState]: {
+        resumable: false,
+        done: loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
+        error: loading_1.LoaderEventType.LoaderAttachmentStateDeletionError,
+    },
+};
 function getTimeoutErrorEventType(eventType) {
     switch (eventType) {
-        // Metadata extraction
         case extraction_1.EventType.StartExtractingMetadata:
             return {
                 eventType: extraction_1.ExtractorEventType.MetadataExtractionError,
             };
-        // Data extraction
         case extraction_1.EventType.StartExtractingData:
         case extraction_1.EventType.ContinueExtractingData:
             return {
                 eventType: extraction_1.ExtractorEventType.DataExtractionError,
             };
-        // Data deletion
         case extraction_1.EventType.StartDeletingExtractorState:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
             };
-        // Attachments extraction
         case extraction_1.EventType.StartExtractingAttachments:
         case extraction_1.EventType.ContinueExtractingAttachments:
             return {
                 eventType: extraction_1.ExtractorEventType.AttachmentExtractionError,
             };
-        // Attachments deletion
         case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
             return {
                 eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
             };
-        // External sync units
         case extraction_1.EventType.StartExtractingExternalSyncUnits:
             return {
                 eventType: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
             };
-        // Loading data
         case extraction_1.EventType.StartLoadingData:
         case extraction_1.EventType.ContinueLoadingData:
             return {
                 eventType: loading_1.LoaderEventType.DataLoadingError,
             };
-        // Deleting loader state
         case extraction_1.EventType.StartDeletingLoaderState:
             return {
                 eventType: loading_1.LoaderEventType.LoaderStateDeletionError,
             };
-        // Loading attachments
         case extraction_1.EventType.StartLoadingAttachments:
         case extraction_1.EventType.ContinueLoadingAttachments:
             return {
                 eventType: loading_1.LoaderEventType.AttachmentLoadingError,
             };
-        // Deleting loader attachment state
         case extraction_1.EventType.StartDeletingLoaderAttachmentState:
             return {
                 eventType: loading_1.LoaderEventType.LoaderAttachmentStateDeletionError,
@@ -69,15 +181,11 @@ function getTimeoutErrorEventType(eventType) {
             console.error('Event type not recognized in getTimeoutErrorEventType function: ' +
                 eventType);
             return {
-                eventType: loading_1.LoaderEventType.UnknownEventType,
+                eventType: constants_1.UNKNOWN_EVENT_TYPE,
             };
     }
 }
-/**
- * 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. */
 function getNoScriptEventType(eventType) {
     switch (eventType) {
         case extraction_1.EventType.StartDeletingExtractorState:
@@ -100,7 +208,7 @@ function getNoScriptEventType(eventType) {
             console.error('Event type not recognized in getNoScriptEventType function: ' +
                 eventType);
             return {
-                eventType: loading_1.LoaderEventType.UnknownEventType,
+                eventType: constants_1.UNKNOWN_EVENT_TYPE,
             };
     }
 }

package/dist/multithreading/spawn/spawn.js

@@ -7,13 +7,13 @@ exports.Spawn = void 0;
 exports.spawn = spawn;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
-const control_protocol_1 = require("../../common/control-protocol");
+const constants_1 = require("../../common/constants");
 const helpers_2 = require("../../common/helpers");
 const logger_1 = require("../../logger/logger");
 const extraction_1 = require("../../types/extraction");
 const workers_1 = require("../../types/workers");
-const constants_1 = require("../../common/constants");
 const create_worker_1 = require("../create-worker");
+const emit_1 = require("../emit");
 const spawn_helpers_1 = require("./spawn.helpers");
 function getWorkerPath({ event, workerBasePath, }) {
     let path = null;
@@ -44,18 +44,11 @@ function getWorkerPath({ event, workerBasePath, }) {
     return path ? workerBasePath + path : null;
 }
 /**
- * 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 {AirSyncEvent} options.event - The event object received from the platform
- * @param {object} options.initialState - The initial state of the adapter
- * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
- * @returns {Promise<Spawn>} - A new instance of Spawn class
+ * 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.
  */
 async function spawn({ event, initialState, initialDomainMapping, options, baseWorkerPath, }) {
-    // Read the command line arguments to check if the local flag is passed.
     const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)).argv;
     if (argv._.includes('local') || argv.local) {
         options = Object.assign(Object.assign({}, (options || {})), { isLocalDevelopment: true });
@@ -66,13 +59,13 @@ async function spawn({ event, initialState, initialDomainMapping, options, baseW
     if (options === null || options === void 0 ? void 0 : options.isLocalDevelopment) {
         console.log('Snap-in is running in local development mode.');
     }
-    const eventType = event.payload.event_type;
     let script = null;
     if (baseWorkerPath != null &&
         (options === null || options === void 0 ? void 0 : options.workerPathOverrides) != null &&
-        options.workerPathOverrides[eventType] != null) {
+        options.workerPathOverrides[event.payload.event_type] != null) {
         script =
-            baseWorkerPath + options.workerPathOverrides[eventType];
+            baseWorkerPath +
+                options.workerPathOverrides[event.payload.event_type];
     }
     else {
         script = getWorkerPath({
@@ -80,7 +73,6 @@ async function spawn({ event, initialState, initialDomainMapping, options, baseW
             workerBasePath: baseWorkerPath !== null && baseWorkerPath !== void 0 ? baseWorkerPath : __dirname,
         });
     }
-    // If a script is found for the event type, spawn a new worker.
     if (script) {
         try {
             const worker = await (0, create_worker_1.createWorker)({
@@ -109,7 +101,7 @@ async function spawn({ event, initialState, initialDomainMapping, options, baseW
     }
     else {
         const { eventType } = (0, spawn_helpers_1.getNoScriptEventType)(event.payload.event_type);
-        await (0, control_protocol_1.emit)({
+        await (0, emit_1.emit)({
             event,
             eventType,
         });
@@ -130,7 +122,7 @@ class Spawn {
             ? Math.min(options.timeout, this.defaultLambdaTimeout)
             : this.defaultLambdaTimeout;
         this.resolve = resolve;
-        // If soft timeout is reached, send a message to the worker to gracefully exit.
+        // Soft timeout: ask the worker to gracefully exit.
         this.softTimeoutTimer = setTimeout(() => void (async () => {
             console.log('SOFT TIMEOUT: Sending a message to the worker to gracefully exit.');
             this.softTimeoutSent = true;
@@ -144,7 +136,7 @@ class Spawn {
                 await this.exitFromMainThread();
             }
         })(), this.lambdaTimeout);
-        // If hard timeout is reached, that means the worker did not exit in time. Terminate the worker.
+        // Hard timeout: the worker did not exit in time, terminate it.
         this.hardTimeoutTimer = setTimeout(() => void (async () => {
             console.error('HARD TIMEOUT: Worker did not exit in time. Terminating the worker.');
             if (worker) {
@@ -155,13 +147,10 @@ class Spawn {
                 await this.exitFromMainThread();
             }
         })(), this.lambdaTimeout * constants_1.HARD_TIMEOUT_MULTIPLIER);
-        // If worker exits with process.exit(code), clear the timeouts and exit from
-        // main thread. When a soft timeout was sent, we use setImmediate to defer
-        // processing so that any pending WorkerMessage events (e.g.
-        // WorkerMessageEmitted from onTimeout) already queued in the event loop are
-        // handled first, preventing a race condition where exitFromMainThread sees
-        // alreadyEmitted=false and emits an error even though the worker
-        // successfully emitted an event.
+        // After a soft timeout, defer exit handling via setImmediate so pending
+        // WorkerMessage events (e.g. WorkerMessageEmitted from onTimeout) are
+        // handled first; otherwise exitFromMainThread could see
+        // alreadyEmitted=false and emit a spurious error.
         worker.on(workers_1.WorkerEvent.WorkerExit, (code) => {
             const handler = async () => {
                 console.info('Worker exited with exit code: ' + code + '.');
@@ -176,27 +165,23 @@ class Spawn {
             }
         });
         worker.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
-            var _a, _b, _c, _d, _e;
-            // Since logs from the worker thread are handled differently in snap-in
-            // platform,  we need to catch the log messages from worker thread and log
-            // them in main thread.
+            var _a, _b, _c;
+            // The snap-in platform handles worker-thread logs differently, so worker
+            // log messages are re-logged in the main thread.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageLog) {
                 const stringifiedArgs = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.stringifiedArgs;
                 const level = (_b = message.payload) === null || _b === void 0 ? void 0 : _b.level;
-                const isSdkLog = (_d = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.isSdkLog) !== null && _d !== void 0 ? _d : true;
-                this.logger.logFn(stringifiedArgs, level, isSdkLog);
+                this.logger.logFn(stringifiedArgs, level);
             }
-            // If worker sends a message that it has emitted an event, then set alreadyEmitted to true.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageEmitted) {
-                console.info('Worker has emitted message to the AirSync platform.');
+                console.info('Worker has emitted message to AirSync.');
                 this.alreadyEmitted = true;
             }
-            // If worker sends a failure message before exiting, capture it for use in the error event.
+            // Capture the worker's failure reason for use in the error event.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageFailed) {
-                this.workerFailedMessage = (_e = message.payload) === null || _e === void 0 ? void 0 : _e.message;
+                this.workerFailedMessage = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.message;
             }
         });
-        // Log memory usage every 30 seconds
         this.memoryMonitoringInterval = setInterval(() => {
             try {
                 const memoryInfo = (0, helpers_2.getMemoryUsage)();
@@ -205,7 +190,7 @@ class Spawn {
                 }
             }
             catch (error) {
-                // If memory monitoring fails, log the warning and clear the interval to prevent further issues
+                // Stop monitoring on failure to prevent repeated crashes
                 console.warn('Memory monitoring failed, stopping logging of memory usage interval', error);
                 if (this.memoryMonitoringInterval) {
                     clearInterval(this.memoryMonitoringInterval);
@@ -236,7 +221,7 @@ class Spawn {
         this.alreadyEmitted = true;
         const { eventType } = (0, spawn_helpers_1.getTimeoutErrorEventType)(this.event.payload.event_type);
         try {
-            await (0, control_protocol_1.emit)({
+            await (0, emit_1.emit)({
                 eventType,
                 event: this.event,
                 data: {

package/dist/multithreading/worker.js

@@ -2,8 +2,5 @@
 const { workerData } = require('node:worker_threads');
 require('ts-node').register();
 const { Logger } = require('../logger/logger');
-const { runWithUserLogContext } = require('../logger/logger.context');
 console = new Logger({ event: workerData.event, options: workerData.options });
-runWithUserLogContext(() => {
-    require(workerData.workerPath);
-});
+require(workerData.workerPath);