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

package/dist/multithreading/emit.d.ts

@@ -1,10 +1,11 @@
 import { AxiosResponse } from 'axios';
-import { AirSyncEvent, EventData, ExtractorEventType } from '../types/extraction';
+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, }: EmitInterface) => Promise<AxiosResponse>;
+export declare const emit: ({ event, eventType, data, worker_metadata, }: EmitInterface) => Promise<AxiosResponse>;
 //# sourceMappingURL=emit.d.ts.map

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

@@ -1 +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"}
+{"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/multithreading/emit.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emit = void 0;
-const client_1 = require("../http/client");
 const constants_1 = require("../common/constants");
-const emit = async ({ event, eventType, data, }) => {
+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 client_1.axiosClient.post(event.payload.event_context.callback_url, Object.assign({}, newEvent), {

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":"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"}
+{"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

@@ -9,66 +9,57 @@ 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, 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.
+ * 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_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;
-            });
-            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 }))
+    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' };
             }
-            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);
-            });
-        }
-    });
+        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;
@@ -93,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

@@ -2,39 +2,20 @@ import { EventType, ExtractorEventType } from '../../types/extraction';
 import { LoaderEventType } from '../../types/loading';
 import { TaskStatus } from '../../types/workers';
 /**
- * Resolves the outgoing event type the SDK should emit for a given incoming
- * event type and the {@link TaskResult} status a worker returned.
- *
- * The mapping follows the per-phase contract documented on `TaskResult`:
- * resumable phases (data/attachment extraction, data/attachment loading) honor
- * every status (success -> *_DONE, progress -> *_PROGRESS, delay -> *_DELAYED,
- * error -> *_ERROR); non-resumable phases (external sync units, metadata, state
- * deletion) only have a done and an error event, so a `progress`/`delay` status
- * there is illegal and is mapped to the phase's error event.
- *
- * @param eventType - The incoming event type that started this worker.
- * @param status - The status the worker's task/onTimeout returned.
- * @returns The outgoing extractor/loader event type to emit, plus whether the
- * status was illegal for the phase (so the caller can attach a descriptive
- * error message).
+ * 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;
 };
-/**
- * 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
- */
 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 | LoaderEventType;
 };

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":"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;;;;;;;;;;;;;;;;GAgBG;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;AAoHD;;;;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;eAwBhB,kBAAkB,GAAG,eAAe;EAG5E"}
+{"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

@@ -7,21 +7,11 @@ const constants_1 = require("../../common/constants");
 const extraction_1 = require("../../types/extraction");
 const loading_1 = require("../../types/loading");
 /**
- * Resolves the outgoing event type the SDK should emit for a given incoming
- * event type and the {@link TaskResult} status a worker returned.
- *
- * The mapping follows the per-phase contract documented on `TaskResult`:
- * resumable phases (data/attachment extraction, data/attachment loading) honor
- * every status (success -> *_DONE, progress -> *_PROGRESS, delay -> *_DELAYED,
- * error -> *_ERROR); non-resumable phases (external sync units, metadata, state
- * deletion) only have a done and an error event, so a `progress`/`delay` status
- * there is illegal and is mapped to the phase's error event.
- *
- * @param eventType - The incoming event type that started this worker.
- * @param status - The status the worker's task/onTimeout returned.
- * @returns The outgoing extractor/loader event type to emit, plus whether the
- * status was illegal for the phase (so the caller can attach a descriptive
- * error message).
+ * 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];
@@ -52,24 +42,18 @@ function getEventTypeForResult(eventType, status) {
             return { eventType: phase.error, illegal: false };
     }
 }
-/**
- * Per-phase outgoing event types, keyed by the incoming {@link EventType}.
- * `resumable` phases define progress/delayed events; non-resumable ones do not.
- */
+/** Per-phase outgoing event types, keyed by the incoming {@link EventType}. */
 const EVENT_PHASE_MAP = {
-    // External sync units (non-resumable)
     [extraction_1.EventType.StartExtractingExternalSyncUnits]: {
         resumable: false,
         done: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone,
         error: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
     },
-    // Metadata (non-resumable)
     [extraction_1.EventType.StartExtractingMetadata]: {
         resumable: false,
         done: extraction_1.ExtractorEventType.MetadataExtractionDone,
         error: extraction_1.ExtractorEventType.MetadataExtractionError,
     },
-    // Data extraction (resumable)
     [extraction_1.EventType.StartExtractingData]: {
         resumable: true,
         done: extraction_1.ExtractorEventType.DataExtractionDone,
@@ -84,13 +68,11 @@ const EVENT_PHASE_MAP = {
         progress: extraction_1.ExtractorEventType.DataExtractionProgress,
         delayed: extraction_1.ExtractorEventType.DataExtractionDelayed,
     },
-    // Extractor state deletion (non-resumable)
     [extraction_1.EventType.StartDeletingExtractorState]: {
         resumable: false,
         done: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
         error: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
     },
-    // Attachment extraction (resumable)
     [extraction_1.EventType.StartExtractingAttachments]: {
         resumable: true,
         done: extraction_1.ExtractorEventType.AttachmentExtractionDone,
@@ -105,13 +87,11 @@ const EVENT_PHASE_MAP = {
         progress: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
         delayed: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
     },
-    // Extractor attachments state deletion (non-resumable)
     [extraction_1.EventType.StartDeletingExtractorAttachmentsState]: {
         resumable: false,
         done: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
         error: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
     },
-    // Data loading (resumable)
     [extraction_1.EventType.StartLoadingData]: {
         resumable: true,
         done: loading_1.LoaderEventType.DataLoadingDone,
@@ -126,7 +106,6 @@ const EVENT_PHASE_MAP = {
         progress: loading_1.LoaderEventType.DataLoadingProgress,
         delayed: loading_1.LoaderEventType.DataLoadingDelayed,
     },
-    // Attachment loading (resumable)
     [extraction_1.EventType.StartLoadingAttachments]: {
         resumable: true,
         done: loading_1.LoaderEventType.AttachmentLoadingDone,
@@ -141,76 +120,59 @@ const EVENT_PHASE_MAP = {
         progress: loading_1.LoaderEventType.AttachmentLoadingProgress,
         delayed: loading_1.LoaderEventType.AttachmentLoadingDelayed,
     },
-    // Loader state deletion (non-resumable)
     [extraction_1.EventType.StartDeletingLoaderState]: {
         resumable: false,
         done: loading_1.LoaderEventType.LoaderStateDeletionDone,
         error: loading_1.LoaderEventType.LoaderStateDeletionError,
     },
-    // Loader attachment state deletion (non-resumable)
     [extraction_1.EventType.StartDeletingLoaderAttachmentState]: {
         resumable: false,
         done: loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
         error: loading_1.LoaderEventType.LoaderAttachmentStateDeletionError,
     },
 };
-/**
- * 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
- */
 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,
@@ -223,11 +185,7 @@ function getTimeoutErrorEventType(eventType) {
             };
     }
 }
-/**
- * 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:

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 emit_1 = require("../emit");
+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 });
@@ -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)({
@@ -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 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);

package/dist/multithreading/worker.js

@@ -1,8 +1,6 @@
 "use strict";
 const { workerData } = require('node:worker_threads');
 require('ts-node').register();
-const { Logger, runWithUserLogContext } = require('../logger/logger');
+const { Logger } = require('../logger/logger');
 console = new Logger({ event: workerData.event, options: workerData.options });
-runWithUserLogContext(() => {
-    require(workerData.workerPath);
-});
+require(workerData.workerPath);

package/dist/repo/repo.d.ts

@@ -10,6 +10,16 @@ export declare class Repo {
     private onUpload;
     private options?;
     uploadedArtifacts: Artifact[];
+    dateRanges: {
+        creationDate: {
+            oldest?: number;
+            newest?: number;
+        };
+        modifiedDate: {
+            oldest?: number;
+            newest?: number;
+        };
+    };
     constructor({ event, itemType, normalize, onUpload, options, }: RepoFactoryInterface);
     getItems(): (NormalizedItem | NormalizedAttachment | Item)[];
     upload(batch?: (NormalizedItem | NormalizedAttachment | Item)[]): Promise<void | ErrorRecord>;

package/dist/repo/repo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../src/repo/repo.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAI3D,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,IAAI;IACf,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAmD;IAChE,OAAO,CAAC,SAAS,CAAC,CAAwD;IAC1E,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAC,CAAuB;IAChC,iBAAiB,EAAE,QAAQ,EAAE,CAAC;gBAEzB,EACV,KAAK,EACL,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,OAAO,GACR,EAAE,oBAAoB;IAUvB,QAAQ,IAAI,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE;IAItD,MAAM,CACV,KAAK,CAAC,EAAE,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE,GACvD,OAAO,CAAC,IAAI,GAAG,WAAW,CAAC;IAqCxB,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAyC5C"}
+{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../src/repo/repo.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,IAAI;IACf,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAmD;IAChE,OAAO,CAAC,SAAS,CAAC,CAAwD;IAC1E,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAC,CAAuB;IAChC,iBAAiB,EAAE,QAAQ,EAAE,CAAC;IAC9B,UAAU,EAAE;QACjB,YAAY,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACnD,YAAY,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KACpD,CAGC;gBAEU,EACV,KAAK,EACL,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,OAAO,GACR,EAAE,oBAAoB;IAUvB,QAAQ,IAAI,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE;IAItD,MAAM,CACV,KAAK,CAAC,EAAE,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE,GACvD,OAAO,CAAC,IAAI,GAAG,WAAW,CAAC;IAsDxB,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAkC5C"}

package/dist/repo/repo.helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function updateRange(range: {
+    oldest?: number;
+    newest?: number;
+}, ms: number): void;
+export declare function toValidTimestamp(value: string): number | undefined;
+//# sourceMappingURL=repo.helpers.d.ts.map

package/dist/repo/repo.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.helpers.d.ts","sourceRoot":"","sources":["../../src/repo/repo.helpers.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CACzB,KAAK,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAC3C,EAAE,EAAE,MAAM,GACT,IAAI,CAON;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGlE"}