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

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

@@ -6,9 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadingAdapter = void 0;
 const axios_1 = __importDefault(require("axios"));
 const logger_1 = require("../../logger/logger");
-const logger_context_1 = require("../../logger/logger.context");
 const mappers_1 = require("../../mappers/mappers");
-const mappers_interface_1 = require("../../mappers/mappers.interface");
+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");
@@ -54,45 +53,38 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
         // Loading keeps its accumulated reports/processed files across emits.
     }
     async loadItemTypes({ itemTypesToLoad, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
             var _a;
             if (this.event.payload.event_type === extraction_1.EventType.StartLoadingData) {
                 const itemTypes = itemTypesToLoad.map((itemTypeToLoad) => itemTypeToLoad.itemType);
                 if (!itemTypes.length) {
                     console.warn('No item types to load, returning.');
-                    return {
-                        reports: this.reports,
-                        processed_files: this.processedFiles,
-                    };
+                    return { status: 'success' };
                 }
                 const filesToLoad = await this.getLoaderBatches({
                     supportedItemTypes: itemTypes,
                 });
-                this.adapterState.sdkState.fromDevRev = {
+                this.sdkState.fromDevRev = {
                     filesToLoad,
                 };
             }
-            if (!this.adapterState.sdkState.fromDevRev ||
-                !this.adapterState.sdkState.fromDevRev.filesToLoad.length) {
+            if (!this.sdkState.fromDevRev ||
+                !this.sdkState.fromDevRev.filesToLoad.length) {
                 console.warn('No files to load, returning.');
-                return {
-                    reports: this.reports,
-                    processed_files: this.processedFiles,
-                };
+                return { status: 'success' };
             }
-            console.log('Files to load in state', (_a = this.adapterState.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
+            console.log('Files to load in state', (_a = this.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
             try {
-                outerloop: for (const fileToLoad of this.adapterState.sdkState
-                    .fromDevRev.filesToLoad) {
+                for (const fileToLoad of this.sdkState.fromDevRev.filesToLoad) {
                     const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
                     if (!itemTypeToLoad) {
                         console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
-                        await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                        return {
+                            status: 'error',
                             error: {
                                 message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
                             },
-                        });
-                        break;
+                        };
                     }
                     if (!fileToLoad.completed) {
                         const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
@@ -101,31 +93,25 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                         });
                         if (transformerFileError) {
                             console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                            await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                            return {
+                                status: 'error',
                                 error: {
                                     message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
                                 },
-                            });
-                            break outerloop;
+                            };
                         }
                         const transformerFile = response;
                         for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
                             if (this.isTimeout) {
-                                console.log('Timeout detected during data loading. Emitting progress to allow continuation.');
-                                await this.emit(loading_1.LoaderEventType.DataLoadingProgress);
-                                process.exit(0);
+                                console.log('Timeout detected during data loading. Returning progress to allow continuation.');
+                                return { status: 'progress' };
                             }
                             const { report, rateLimit } = await this.loadItem({
                                 item: transformerFile[i],
                                 itemTypeToLoad,
                             });
                             if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                                await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                                    delay: rateLimit.delay,
-                                    reports: this.reports,
-                                    processed_files: this.processedFiles,
-                                });
-                                break outerloop;
+                                return { status: 'delay', delaySeconds: rateLimit.delay };
                             }
                             if (report) {
                                 (0, loading_adapter_helpers_1.addReportToLoaderReport)({
@@ -142,21 +128,18 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
             }
             catch (error) {
                 console.error('Error during data loading.', (0, logger_1.serializeError)(error));
-                await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                return {
+                    status: 'error',
                     error: {
                         message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
                     },
-                });
-                process.exit(1);
+                };
             }
-            return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
-            };
+            return { status: 'success' };
         });
     }
     async getLoaderBatches({ supportedItemTypes, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
             var _a;
             const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
             if (statsFileArtifactId) {
@@ -177,26 +160,23 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
         });
     }
     async loadAttachments({ create, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
             var _a, _b;
             if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
-                this.adapterState.sdkState.fromDevRev = {
+                this.sdkState.fromDevRev = {
                     filesToLoad: await this.getLoaderBatches({
                         supportedItemTypes: ['attachment'],
                     }),
                 };
             }
-            if (!this.adapterState.sdkState.fromDevRev ||
-                ((_a = this.adapterState.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad.length) === 0) {
+            if (!this.sdkState.fromDevRev ||
+                ((_a = this.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad.length) === 0) {
                 console.log('No files to load, returning.');
-                return {
-                    reports: this.reports,
-                    processed_files: this.processedFiles,
-                };
+                return { status: 'success' };
             }
-            const filesToLoad = (_b = this.adapterState.sdkState.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
+            const filesToLoad = (_b = this.sdkState.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
             try {
-                outerloop: for (const fileToLoad of filesToLoad) {
+                for (const fileToLoad of filesToLoad) {
                     if (!fileToLoad.completed) {
                         const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
                             artifactId: fileToLoad.id,
@@ -205,30 +185,24 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                         const transformerFile = response;
                         if (transformerFileError) {
                             console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                            await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                            return {
+                                status: 'error',
                                 error: {
                                     message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
                                 },
-                            });
-                            break outerloop;
+                            };
                         }
                         for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
                             if (this.isTimeout) {
-                                console.log('Timeout detected during attachment loading. Emitting progress to allow continuation.');
-                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingProgress);
-                                process.exit(0);
+                                console.log('Timeout detected during attachment loading. Returning progress to allow continuation.');
+                                return { status: 'progress' };
                             }
                             const { report, rateLimit } = await this.loadAttachment({
                                 item: transformerFile[i],
                                 create,
                             });
                             if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingDelayed, {
-                                    delay: rateLimit.delay,
-                                    reports: this.reports,
-                                    processed_files: this.processedFiles,
-                                });
-                                break outerloop;
+                                return { status: 'delay', delaySeconds: rateLimit.delay };
                             }
                             if (report) {
                                 (0, loading_adapter_helpers_1.addReportToLoaderReport)({
@@ -245,29 +219,25 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
             }
             catch (error) {
                 console.error('Error during attachment loading.', (0, logger_1.serializeError)(error));
-                await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                return {
+                    status: 'error',
                     error: {
                         message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
                     },
-                });
-                process.exit(1);
+                };
             }
-            return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
-            };
+            return { status: 'success' };
         });
     }
     async loadItem({ item, itemTypeToLoad, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
             var _a;
             const devrevId = item.id.devrev;
             try {
-                const syncMapperRecordResponse = await this._mappers.getByTargetId({
+                const syncMapperRecord = await this._mappers.getByTargetId({
                     sync_unit: this.event.payload.event_context.sync_unit,
                     target: devrevId,
                 });
-                const syncMapperRecord = syncMapperRecordResponse.data;
                 if (!syncMapperRecord) {
                     console.warn('Failed to get sync mapper record from response.');
                     return {
@@ -277,7 +247,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                     };
                 }
                 // Update item in external system
-                const { id, modifiedDate, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => {
+                const { id, modifiedDate, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => {
                     return await itemTypeToLoad.update({
                         item,
                         mappers: this._mappers,
@@ -286,7 +256,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                 });
                 if (id) {
                     try {
-                        const syncMapperRecordUpdateResponse = await this._mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL }, (modifiedDate && {
+                        const syncMapperRecordUpdate = await this._mappers.update(Object.assign(Object.assign({ id: syncMapperRecord.sync_mapper_record.id, sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL }, (modifiedDate && {
                             external_versions: {
                                 add: [
                                     {
@@ -300,7 +270,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                             }, targets: {
                                 add: [devrevId],
                             } }));
-                        console.log('Successfully updated sync mapper record.', syncMapperRecordUpdateResponse.data);
+                        console.log('Successfully updated sync mapper record.', syncMapperRecordUpdate);
                     }
                     catch (error) {
                         console.warn('Failed to update sync mapper record.', (0, logger_1.serializeError)(error));
@@ -340,7 +310,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                 if (axios_1.default.isAxiosError(error)) {
                     if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
                         // Create item in external system if mapper record not found
-                        const { id, modifiedDate, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => {
+                        const { id, modifiedDate, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => {
                             return await itemTypeToLoad.create({
                                 item,
                                 mappers: this._mappers,
@@ -350,7 +320,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                         if (id) {
                             // Create mapper
                             try {
-                                const syncMapperRecordCreateResponse = await this._mappers.create(Object.assign({ sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [id], targets: [devrevId] }, (modifiedDate && {
+                                const syncMapperRecordCreate = await this._mappers.create(Object.assign({ sync_unit: this.event.payload.event_context.sync_unit, status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL, external_ids: [id], targets: [devrevId] }, (modifiedDate && {
                                     external_versions: [
                                         {
                                             modified_date: modifiedDate,
@@ -358,7 +328,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
                                         },
                                     ],
                                 })));
-                                console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+                                console.log('Successfully created sync mapper record.', syncMapperRecordCreate);
                                 return {
                                     report: {
                                         item_type: itemTypeToLoad.itemType,
@@ -412,9 +382,9 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
         });
     }
     async loadAttachment({ item, create, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
+        return (0, logger_1.runWithSdkLogContext)(async () => {
             // Create item
-            const { id, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => create({
+            const { id, delay, error } = await (0, logger_1.runWithUserLogContext)(async () => create({
                 item,
                 mappers: this._mappers,
                 event: this.event,
@@ -428,13 +398,13 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
             }
             else if (id) {
                 try {
-                    const syncMapperRecordCreateResponse = await this._mappers.create({
+                    const syncMapperRecordCreate = await this._mappers.create({
                         sync_unit: this.event.payload.event_context.sync_unit,
                         external_ids: [id],
                         targets: [item.reference_id],
-                        status: mappers_interface_1.SyncMapperRecordStatus.OPERATIONAL,
+                        status: mappers_interfaces_1.SyncMapperRecordStatus.OPERATIONAL,
                     });
-                    console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
+                    console.log('Successfully created sync mapper record.', syncMapperRecordCreate);
                 }
                 catch (error) {
                     console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));

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

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

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

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

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

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

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

package/dist/multithreading/process-task.js

@@ -4,7 +4,6 @@ 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");
@@ -12,12 +11,24 @@ const extraction_adapter_1 = require("./adapters/extraction-adapter");
 const loading_adapter_1 = require("./adapters/loading-adapter");
 /**
  * Shared worker-thread driver. Builds the logger context, runs the task and
- * (on timeout) the onTimeout callback against the provided adapter, and wires
- * the error/exit plumbing. The adapter is constructed by the caller so each
- * entry point can build its own typed adapter.
+ * (on timeout) the onTimeout callback against the provided adapter, maps the
+ * returned {@link TaskResult} to a platform event and emits it exactly once,
+ * and wires the error/exit plumbing.
+ *
+ * The adapter is constructed by the caller so each entry point can build its
+ * own typed adapter.
+ *
+ * If `onTimeout` is omitted, the SDK emits a phase-appropriate default on
+ * timeout: `progress` (resumable phases) or `error` (non-resumable phases) is
+ * handled by the status->event mapping when we emit a `progress` result.
+ *
+ * On timeout the timeout outcome always wins: once the soft timeout has fired,
+ * the SDK emits the `onTimeout` result (or the default `progress`) and ignores
+ * whatever the task returned, because a phase that ran out of time must hand off
+ * for continuation rather than report itself complete.
  */
 async function runWorkerTask(buildAdapter, { task, onTimeout }) {
-    await (0, logger_context_1.runWithSdkLogContext)(async () => {
+    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) => {
@@ -27,14 +38,20 @@ async function runWorkerTask(buildAdapter, { task, onTimeout }) {
                 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 }));
+            let result = await (0, logger_1.runWithUserLogContext)(async () => task({ adapter }));
+            // If the soft timeout fired, the timeout outcome wins regardless of what
+            // the task returned: hand off via onTimeout (or the default progress
+            // result) so the phase continues in a fresh invocation.
+            if (adapter.isTimeout) {
+                result = onTimeout
+                    ? await (0, logger_1.runWithUserLogContext)(async () => onTimeout({ adapter }))
+                    : { status: 'progress' };
             }
+            await adapter.emitFromResult(result);
             process.exit(0);
         }
         catch (error) {
-            (0, logger_context_1.runWithUserLogContext)(() => {
+            (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({

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

@@ -1,5 +1,27 @@
 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).
+ */
+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
@@ -14,8 +36,6 @@ export declare function getTimeoutErrorEventType(eventType: EventType): {
  * @returns {ExtractorEventType | LoaderEventType} The event type for the no script error
  */
 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;;;;;;;;;;;;;;;;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"}

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

@@ -1,9 +1,159 @@
 "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");
+/**
+ * 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).
+ */
+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}.
+ * `resumable` phases define progress/delayed events; non-resumable ones do not.
+ */
+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,
+        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,
+    },
+    // 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,
+        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,
+    },
+    // 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,
+        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,
+    },
+    // Attachment loading (resumable)
+    [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,
+    },
+    // 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
@@ -69,7 +219,7 @@ 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,
             };
     }
 }
@@ -100,7 +250,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,
             };
     }
 }