@devrev/airsync-sdk 2.0.0-beta.6 → 2.0.0-beta.8

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

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

package/dist/multithreading/emit.d.ts.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;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"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/multithreading/emit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAClB,cAAc,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC;AAED,eAAO,MAAM,IAAI,GAAU,8CAKxB,aAAa,KAAG,OAAO,CAAC,aAAa,CA+BvC,CAAC"}

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

@@ -1 +1 @@
-{"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"}
+{"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;AAuF5D,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

@@ -13,22 +13,28 @@ const spawn_helpers_1 = require("./spawn/spawn.helpers");
 /**
  * Shared worker-thread driver: builds the adapter, runs the task, maps the
  * returned {@link TaskResult} to a platform event and emits it exactly once.
- * On soft timeout the timeout outcome always wins: the `onTimeout` result (or
- * a phase-appropriate default) is emitted and the task's return value is
- * ignored.
+ * On soft timeout a returned `success`/`progress` is replaced by the
+ * `onTimeout` result (or a phase-appropriate default); a returned `error` or
+ * `delay` is emitted as is.
  */
 async function runWorkerTask(buildAdapter, { task, onTimeout }) {
+    let adapter;
     try {
-        const adapter = await buildAdapter();
+        adapter = await buildAdapter();
+        const workerAdapter = adapter;
         node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.on(workers_1.WorkerEvent.WorkerMessage, (message) => {
             if (message.subject !== workers_1.WorkerMessageSubject.WorkerMessageExit) {
                 return;
             }
             console.log('Timeout received. Waiting for the task to finish.');
-            adapter.isTimeout = true;
+            workerAdapter.isTimeout = true;
         });
+        console.log('Event passed from SDK to the connector:', adapter.event);
         let result = await task({ adapter });
-        if (adapter.isTimeout) {
+        // A returned error or delay is a real outcome and must reach the platform;
+        // only a success/progress is replaced so a timed-out phase hands off.
+        const canBeReplaced = result.status === 'success' || result.status === 'progress';
+        if (adapter.isTimeout && canBeReplaced) {
             if (onTimeout) {
                 result = await onTimeout({ adapter });
             }
@@ -50,6 +56,18 @@ async function runWorkerTask(buildAdapter, { task, onTimeout }) {
         process.exit(0);
     }
     catch (error) {
+        if (adapter && !adapter.hasWorkerEmitted) {
+            try {
+                await adapter.emitError(error);
+            }
+            catch (emitError) {
+                console.error('Error while emitting task failure.', (0, logger_1.serializeError)(emitError));
+            }
+        }
+        if (adapter === null || adapter === void 0 ? void 0 : adapter.hasWorkerEmitted) {
+            process.exit(1);
+            return;
+        }
         const errorMessage = `Error while processing task. ${(0, logger_1.serializeError)(error)}`;
         console.error(errorMessage);
         node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({

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

@@ -1,10 +1,15 @@
 import { SpawnFactoryInterface, SpawnInterface } from '../../types/workers';
+/**
+ * Local mode is opt-in through AIRSYNC_LOCAL_DEVELOPMENT only, and refused on
+ * Lambda so a stray flag can never change production behavior.
+ */
+export declare function isLocalDevelopment(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Spawns a worker thread for the event and manages its lifecycle (control
  * events, graceful exit, lambda timeout handling). Resolves when the worker
  * run is fully finished.
  */
-export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
+export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options: spawnOptions, baseWorkerPath, workerPathOverrides, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
 export declare class Spawn {
     private event;
     private alreadyEmitted;