npm - @devrev/ts-adaas - Versions diffs - 1.12.3-beta.2 → 1.12.3-beta.3 - Mend

@devrev/ts-adaas 1.12.3-beta.2 → 1.12.3-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (85) hide show

package/dist/workers/worker-adapter.js CHANGED Viewed

@@ -12,7 +12,6 @@ const constants_1 = require("../common/constants");
 const control_protocol_1 = require("../common/control-protocol");
 const helpers_1 = require("../common/helpers");
 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 repo_1 = require("../repo/repo");
@@ -94,19 +93,15 @@ class WorkerAdapter {
         });
     }
     getRepo(itemType) {
-        return (0, logger_context_1.runWithSdkLogContext)(() => {
-            const repo = this.repos.find((repo) => repo.itemType === itemType);
-            if (!repo) {
-                console.error(`Repo for item type ${itemType} not found.`);
-                return;
-            }
-            return repo;
-        });
+        const repo = this.repos.find((repo) => repo.itemType === itemType);
+        if (!repo) {
+            console.error(`Repo for item type ${itemType} not found.`);
+            return;
+        }
+        return repo;
     }
     async postState() {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            await this.adapterState.postState();
-        });
+        await this.adapterState.postState();
     }
     get artifacts() {
         return this._artifacts;
@@ -123,65 +118,63 @@ class WorkerAdapter {
      * @param data - The data to be sent with the event
      */
     async emit(newEventType, data) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            if (this.hasWorkerEmitted) {
-                console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
-                return;
-            }
-            // We want to upload all the repos before emitting the event, except for the external sync units done event
-            if (newEventType !== extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsDone) {
-                console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
-                try {
-                    await this.uploadAllRepos();
-                }
-                catch (error) {
-                    console.error('Error while uploading repos', error);
-                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
-                    this.hasWorkerEmitted = true;
-                    return;
-                }
-            }
-            // If the extraction is done, we want to save the timestamp of the last successful sync
-            if (newEventType === extraction_1.ExtractorEventType.ExtractionAttachmentsDone) {
-                console.log(`Overwriting lastSuccessfulSyncStarted with lastSyncStarted (${this.state.lastSyncStarted}).`);
-                this.state.lastSuccessfulSyncStarted = this.state.lastSyncStarted;
-                this.state.lastSyncStarted = '';
+        if (this.hasWorkerEmitted) {
+            console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
+            return;
+        }
+        // We want to upload all the repos before emitting the event, except for the external sync units done event
+        if (newEventType !== extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone) {
+            console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
+            try {
+                await this.uploadAllRepos();
             }
-            // We want to save the state every time we emit an event, except for the start and delete events
-            if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
-                console.log(`Saving state before emitting event with event type: ${newEventType}.`);
-                try {
-                    await this.adapterState.postState(this.state);
-                }
-                catch (error) {
-                    console.error('Error while posting state', error);
-                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
-                    this.hasWorkerEmitted = true;
-                    return;
-                }
+            catch (error) {
+                console.error('Error while uploading repos', error);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                this.hasWorkerEmitted = true;
+                return;
             }
+        }
+        // If the extraction is done, we want to save the timestamp of the last successful sync
+        if (newEventType === extraction_1.ExtractorEventType.AttachmentExtractionDone) {
+            console.log(`Overwriting lastSuccessfulSyncStarted with lastSyncStarted (${this.state.lastSyncStarted}).`);
+            this.state.lastSuccessfulSyncStarted = this.state.lastSyncStarted;
+            this.state.lastSyncStarted = '';
+        }
+        // We want to save the state every time we emit an event, except for the start and delete events
+        if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
+            console.log(`Saving state before emitting event with event type: ${newEventType}.`);
             try {
-                await (0, control_protocol_1.emit)({
-                    eventType: newEventType,
-                    event: this.event,
-                    data: Object.assign(Object.assign({}, data), (constants_1.ALLOWED_EXTRACTION_EVENT_TYPES.includes(this.event.payload.event_type)
-                        ? { artifacts: this.artifacts }
-                        : {})),
-                });
-                const message = {
-                    subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
-                    payload: { eventType: newEventType },
-                };
-                this.artifacts = [];
-                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
-                this.hasWorkerEmitted = true;
+                await this.adapterState.postState(this.state);
             }
             catch (error) {
-                console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
+                console.error('Error while posting state', error);
                 node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
                 this.hasWorkerEmitted = true;
+                return;
             }
-        });
+        }
+        try {
+            await (0, control_protocol_1.emit)({
+                eventType: newEventType,
+                event: this.event,
+                data: Object.assign(Object.assign({}, data), (constants_1.ALLOWED_EXTRACTION_EVENT_TYPES.includes(this.event.payload.event_type)
+                    ? { artifacts: this.artifacts }
+                    : {})),
+            });
+            const message = {
+                subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
+                payload: { eventType: newEventType },
+            };
+            this.artifacts = [];
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
+            this.hasWorkerEmitted = true;
+        }
+        catch (error) {
+            console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+            this.hasWorkerEmitted = true;
+        }
     }
     async uploadAllRepos() {
         for (const repo of this.repos) {
@@ -196,383 +189,373 @@ class WorkerAdapter {
         this.isTimeout = true;
     }
     async loadItemTypes({ itemTypesToLoad, }) {
-        return (0, logger_context_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,
-                    };
-                }
-                const filesToLoad = await this.getLoaderBatches({
-                    supportedItemTypes: itemTypes,
-                });
-                this.adapterState.state.fromDevRev = {
-                    filesToLoad,
-                };
-            }
-            if (!this.adapterState.state.fromDevRev ||
-                !this.adapterState.state.fromDevRev.filesToLoad.length) {
-                console.warn('No files to load, returning.');
+        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,
                 };
             }
-            console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
-            outerloop: for (const fileToLoad of this.adapterState.state.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}.`);
+            const filesToLoad = await this.getLoaderBatches({
+                supportedItemTypes: itemTypes,
+            });
+            this.adapterState.state.fromDevRev = {
+                filesToLoad,
+            };
+        }
+        if (!this.adapterState.state.fromDevRev ||
+            !this.adapterState.state.fromDevRev.filesToLoad.length) {
+            console.warn('No files to load, returning.');
+            return {
+                reports: this.reports,
+                processed_files: this.processedFiles,
+            };
+        }
+        console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
+        outerloop: for (const fileToLoad of this.adapterState.state.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, {
+                    error: {
+                        message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
+                    },
+                });
+                break;
+            }
+            if (!fileToLoad.completed) {
+                const transformerFile = (await this.uploader.getJsonObjectByArtifactId({
+                    artifactId: fileToLoad.id,
+                    isGzipped: true,
+                }));
+                if (!transformerFile) {
+                    console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
                     await this.emit(loading_1.LoaderEventType.DataLoadingError, {
                         error: {
-                            message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
+                            message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
                         },
                     });
-                    break;
                 }
-                if (!fileToLoad.completed) {
-                    const transformerFile = (await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    }));
-                    if (!transformerFile) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                        await this.emit(loading_1.LoaderEventType.DataLoadingError, {
-                            error: {
-                                message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
-                            },
+                for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                    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;
                     }
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadItem({
-                            item: transformerFile[i],
-                            itemTypeToLoad,
+                    if (report) {
+                        (0, helpers_1.addReportToLoaderReport)({
+                            loaderReports: this.loaderReports,
+                            report,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelay, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
-                            });
-                            break outerloop;
-                        }
-                        if (report) {
-                            (0, 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);
+            }
+        }
+        return {
+            reports: this.reports,
+            processed_files: this.processedFiles,
+        };
+    }
+    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 statsFile = (await this.uploader.getJsonObjectByArtifactId({
+                artifactId: statsFileArtifactId,
+            }));
+            if (!statsFile || statsFile.length === 0) {
+                return [];
             }
+            const filesToLoad = (0, helpers_1.getFilesToLoad)({
+                supportedItemTypes,
+                statsFile,
+            });
+            return filesToLoad;
+        }
+        return [];
+    }
+    async loadAttachments({ create, }) {
+        var _a, _b;
+        if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
+            this.adapterState.state.fromDevRev = {
+                filesToLoad: await this.getLoaderBatches({
+                    supportedItemTypes: ['attachment'],
+                }),
+            };
+        }
+        if (!this.adapterState.state.fromDevRev ||
+            ((_a = this.adapterState.state.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,
             };
-        });
-    }
-    async getLoaderBatches({ supportedItemTypes, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a;
-            const statsFileArtifactId = (_a = this.event.payload.event_data) === null || _a === void 0 ? void 0 : _a.stats_file;
-            if (statsFileArtifactId) {
-                const statsFile = (await this.uploader.getJsonObjectByArtifactId({
-                    artifactId: statsFileArtifactId,
+        }
+        const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
+        outerloop: for (const fileToLoad of filesToLoad) {
+            if (!fileToLoad.completed) {
+                const transformerFile = (await this.uploader.getJsonObjectByArtifactId({
+                    artifactId: fileToLoad.id,
+                    isGzipped: true,
                 }));
-                if (!statsFile || statsFile.length === 0) {
-                    return [];
+                if (!transformerFile) {
+                    console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                    break outerloop;
                 }
-                const filesToLoad = (0, helpers_1.getFilesToLoad)({
-                    supportedItemTypes,
-                    statsFile,
-                });
-                return filesToLoad;
-            }
-            return [];
-        });
-    }
-    async loadAttachments({ create, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a, _b;
-            if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
-                this.adapterState.state.fromDevRev = {
-                    filesToLoad: await this.getLoaderBatches({
-                        supportedItemTypes: ['attachment'],
-                    }),
-                };
-            }
-            if (!this.adapterState.state.fromDevRev ||
-                ((_a = this.adapterState.state.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,
-                };
-            }
-            const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
-            outerloop: for (const fileToLoad of filesToLoad) {
-                if (!fileToLoad.completed) {
-                    const transformerFile = (await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    }));
-                    if (!transformerFile) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                    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.DataLoadingDelayed, {
+                            delay: rateLimit.delay,
+                            reports: this.reports,
+                            processed_files: this.processedFiles,
+                        });
                         break outerloop;
                     }
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadAttachment({
-                            item: transformerFile[i],
-                            create,
+                    if (report) {
+                        (0, helpers_1.addReportToLoaderReport)({
+                            loaderReports: this.loaderReports,
+                            report,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelay, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
-                            });
-                            break outerloop;
-                        }
-                        if (report) {
-                            (0, 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);
             }
-            return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
-            };
-        });
+        }
+        return {
+            reports: this.reports,
+            processed_files: this.processedFiles,
+        };
     }
     async loadItem({ item, itemTypeToLoad, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a;
-            const devrevId = item.id.devrev;
-            try {
-                const syncMapperRecordResponse = 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.');
+        var _a;
+        const devrevId = item.id.devrev;
+        try {
+            const syncMapperRecordResponse = 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 {
+                    error: {
+                        message: 'Failed to get sync mapper record from response.',
+                    },
+                };
+            }
+            // Update item in external system
+            const { id, modifiedDate, delay, error } = await itemTypeToLoad.update({
+                item,
+                mappers: this._mappers,
+                event: this.event,
+            });
+            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 && {
+                        external_versions: {
+                            add: [
+                                {
+                                    modified_date: modifiedDate,
+                                    recipe_version: 0,
+                                },
+                            ],
+                        },
+                    })), { external_ids: {
+                            add: [id],
+                        }, targets: {
+                            add: [devrevId],
+                        } }));
+                    console.log('Successfully updated sync mapper record.', syncMapperRecordUpdateResponse.data);
+                }
+                catch (error) {
+                    console.warn('Failed to update sync mapper record.', (0, logger_1.serializeError)(error));
                     return {
                         error: {
-                            message: 'Failed to get sync mapper record from response.',
+                            message: 'Failed to update sync mapper record' + (0, logger_1.serializeError)(error),
                         },
                     };
                 }
-                // Update item in external system
-                const { id, modifiedDate, delay, error } = await itemTypeToLoad.update({
-                    item,
-                    mappers: this._mappers,
-                    event: this.event,
-                });
-                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 && {
-                            external_versions: {
-                                add: [
+                return {
+                    report: {
+                        item_type: itemTypeToLoad.itemType,
+                        [loading_1.ActionType.UPDATED]: 1,
+                    },
+                };
+            }
+            else if (delay) {
+                console.log(`Rate limited while updating item in external system, delaying for ${delay} seconds.`);
+                return {
+                    rateLimit: {
+                        delay,
+                    },
+                };
+            }
+            else {
+                console.warn('Failed to update item in external system', error);
+                return {
+                    report: {
+                        item_type: itemTypeToLoad.itemType,
+                        [loading_1.ActionType.FAILED]: 1,
+                    },
+                };
+            }
+            // TODO: Update mapper (optional)
+        }
+        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) {
+                        // 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 && {
+                                external_versions: [
                                     {
                                         modified_date: modifiedDate,
                                         recipe_version: 0,
                                     },
                                 ],
-                            },
-                        })), { external_ids: {
-                                add: [id],
-                            }, targets: {
-                                add: [devrevId],
-                            } }));
-                        console.log('Successfully updated sync mapper record.', syncMapperRecordUpdateResponse.data);
-                    }
-                    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,
-                        },
-                    };
-                }
-                else if (delay) {
-                    console.log(`Rate limited while updating item in external system, delaying for ${delay} seconds.`);
-                    return {
-                        rateLimit: {
-                            delay,
-                        },
-                    };
-                }
-                else {
-                    console.warn('Failed to update item in external system', error);
-                    return {
-                        report: {
-                            item_type: itemTypeToLoad.itemType,
-                            [loading_1.ActionType.FAILED]: 1,
-                        },
-                    };
-                }
-                // TODO: Update mapper (optional)
-            }
-            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) {
-                            // 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 && {
-                                    external_versions: [
-                                        {
-                                            modified_date: modifiedDate,
-                                            recipe_version: 0,
-                                        },
-                                    ],
-                                })));
-                                console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
-                                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) {
+                            })));
+                            console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
                             return {
-                                rateLimit: {
-                                    delay,
+                                report: {
+                                    item_type: itemTypeToLoad.itemType,
+                                    [loading_1.ActionType.CREATED]: 1,
                                 },
                             };
                         }
-                        else {
-                            console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
+                        catch (error) {
+                            console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
                             return {
-                                report: {
-                                    item_type: itemTypeToLoad.itemType,
-                                    [loading_1.ActionType.FAILED]: 1,
+                                error: {
+                                    message: 'Failed to create sync mapper record. ' +
+                                        (0, logger_1.serializeError)(error),
                                 },
                             };
                         }
                     }
+                    else if (delay) {
+                        return {
+                            rateLimit: {
+                                delay,
+                            },
+                        };
+                    }
                     else {
-                        console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
+                        console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
                         return {
-                            error: {
-                                message: error.message,
+                            report: {
+                                item_type: itemTypeToLoad.itemType,
+                                [loading_1.ActionType.FAILED]: 1,
                             },
                         };
                     }
                 }
-                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),
-                    },
-                };
+                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));
+            return {
+                error: {
+                    message: 'Failed to get sync mapper record. ' + (0, logger_1.serializeError)(error),
+                },
+            };
+        }
     }
     async processAttachment(attachment, stream) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a, _b;
-            const { httpStream, delay, error } = await stream({
-                item: attachment,
-                event: this.event,
-            });
-            if (error) {
-                return { error };
+        var _a, _b;
+        const { httpStream, delay, error } = await stream({
+            item: attachment,
+            event: this.event,
+        });
+        if (error) {
+            return { error };
+        }
+        else if (delay) {
+            return { delay };
+        }
+        if (httpStream) {
+            const fileType = ((_a = httpStream.headers) === null || _a === void 0 ? void 0 : _a['content-type']) || 'application/octet-stream';
+            // Get upload URL
+            const preparedArtifact = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType);
+            if (!preparedArtifact) {
+                console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment.`);
+                this.destroyHttpStream(httpStream);
+                return;
             }
-            else if (delay) {
-                return { delay };
+            if (this.isTimeout) {
+                this.destroyHttpStream(httpStream);
+                return;
             }
-            if (httpStream) {
-                const fileType = ((_a = httpStream.headers) === null || _a === void 0 ? void 0 : _a['content-type']) || 'application/octet-stream';
-                // Get upload URL
-                const preparedArtifact = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType);
-                if (!preparedArtifact) {
-                    console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment.`);
-                    this.destroyHttpStream(httpStream);
-                    return;
-                }
-                if (this.isTimeout) {
-                    this.destroyHttpStream(httpStream);
-                    return;
-                }
-                // Stream attachment
-                const uploadedArtifact = await this.uploader.streamArtifact(preparedArtifact, httpStream);
-                if (!uploadedArtifact) {
-                    console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment.`);
-                    this.destroyHttpStream(httpStream);
-                    return;
-                }
-                // Confirm attachment upload
-                const confirmArtifactUploadResponse = await this.uploader.confirmArtifactUpload(preparedArtifact.artifact_id);
-                if (!confirmArtifactUploadResponse) {
-                    console.warn('Error while confirming upload for attachment ID ' + attachment.id);
-                    return;
-                }
-                const ssorAttachment = {
-                    id: {
-                        devrev: preparedArtifact.artifact_id,
-                        external: attachment.id,
-                    },
-                    parent_id: {
-                        external: attachment.parent_id,
-                    },
+            // Stream attachment
+            const uploadedArtifact = await this.uploader.streamArtifact(preparedArtifact, httpStream);
+            if (!uploadedArtifact) {
+                console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment.`);
+                this.destroyHttpStream(httpStream);
+                return;
+            }
+            // Confirm attachment upload
+            const confirmArtifactUploadResponse = await this.uploader.confirmArtifactUpload(preparedArtifact.artifact_id);
+            if (!confirmArtifactUploadResponse) {
+                console.warn('Error while confirming upload for attachment ID ' + attachment.id);
+                return;
+            }
+            const ssorAttachment = {
+                id: {
+                    devrev: preparedArtifact.artifact_id,
+                    external: attachment.id,
+                },
+                parent_id: {
+                    external: attachment.parent_id,
+                },
+            };
+            if (attachment.author_id) {
+                ssorAttachment.actor_id = {
+                    external: attachment.author_id,
                 };
-                if (attachment.author_id) {
-                    ssorAttachment.actor_id = {
-                        external: attachment.author_id,
-                    };
-                }
-                // This will set inline flag in ssor_attachment only if it is explicity
-                // set in the attachment object.
-                if (attachment.inline === true) {
-                    ssorAttachment.inline = true;
-                }
-                else if (attachment.inline === false) {
-                    ssorAttachment.inline = false;
-                }
-                await ((_b = this.getRepo('ssor_attachment')) === null || _b === void 0 ? void 0 : _b.push([ssorAttachment]));
             }
-            return;
-        });
+            // This will set inline flag in ssor_attachment only if it is explicity
+            // set in the attachment object.
+            if (attachment.inline === true) {
+                ssorAttachment.inline = true;
+            }
+            else if (attachment.inline === false) {
+                ssorAttachment.inline = false;
+            }
+            await ((_b = this.getRepo('ssor_attachment')) === null || _b === void 0 ? void 0 : _b.push([ssorAttachment]));
+        }
+        return;
     }
     /**
      * Destroys a stream to prevent memory leaks.
@@ -594,50 +577,48 @@ class WorkerAdapter {
         }
     }
     async loadAttachment({ item, create, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            // Create item
-            const { id, delay, error } = await create({
-                item,
-                mappers: this._mappers,
-                event: this.event,
-            });
-            if (delay) {
-                return {
-                    rateLimit: {
-                        delay,
-                    },
-                };
-            }
-            else if (id) {
-                try {
-                    const syncMapperRecordCreateResponse = 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,
-                    });
-                    console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
-                }
-                catch (error) {
-                    console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
-                }
-                return {
-                    report: {
-                        item_type: 'attachment',
-                        [loading_1.ActionType.CREATED]: 1,
-                    },
-                };
+        // Create item
+        const { id, delay, error } = await create({
+            item,
+            mappers: this._mappers,
+            event: this.event,
+        });
+        if (delay) {
+            return {
+                rateLimit: {
+                    delay,
+                },
+            };
+        }
+        else if (id) {
+            try {
+                const syncMapperRecordCreateResponse = 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,
+                });
+                console.log('Successfully created sync mapper record.', syncMapperRecordCreateResponse.data);
             }
-            else {
-                console.warn('Failed to create attachment in external system', error);
-                return {
-                    report: {
-                        item_type: 'attachment',
-                        [loading_1.ActionType.FAILED]: 1,
-                    },
-                };
+            catch (error) {
+                console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
             }
-        });
+            return {
+                report: {
+                    item_type: 'attachment',
+                    [loading_1.ActionType.CREATED]: 1,
+                },
+            };
+        }
+        else {
+            console.warn('Failed to create attachment in external system', error);
+            return {
+                report: {
+                    item_type: 'attachment',
+                    [loading_1.ActionType.FAILED]: 1,
+                },
+            };
+        }
     }
     /**
      * Streams the attachments to the DevRev platform.
@@ -648,88 +629,86 @@ class WorkerAdapter {
      */
     async streamAttachments({ stream, processors, batchSize = 1, // By default, we want to stream one attachment at a time
      }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a, _b;
-            if (batchSize <= 0) {
-                console.warn(`The specified batch size (${batchSize}) is invalid. Using 1 instead.`);
-                batchSize = 1;
+        var _a, _b;
+        if (batchSize <= 0) {
+            console.warn(`The specified batch size (${batchSize}) is invalid. Using 1 instead.`);
+            batchSize = 1;
+        }
+        if (batchSize > 50) {
+            console.warn(`The specified batch size (${batchSize}) is too large. Using 50 instead.`);
+            batchSize = 50;
+        }
+        const repos = [
+            {
+                itemType: 'ssor_attachment',
+            },
+        ];
+        this.initializeRepos(repos);
+        const attachmentsMetadata = (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata;
+        // If there are no attachments metadata artifact IDs in state, finish here
+        if (!((_b = attachmentsMetadata === null || attachmentsMetadata === void 0 ? void 0 : attachmentsMetadata.artifactIds) === null || _b === void 0 ? void 0 : _b.length)) {
+            console.log(`No attachments metadata artifact IDs found in state.`);
+            return;
+        }
+        else {
+            console.log(`Found ${attachmentsMetadata.artifactIds.length} attachments metadata artifact IDs in state.`);
+        }
+        // Loop through the attachments metadata artifact IDs
+        while (attachmentsMetadata.artifactIds.length > 0) {
+            const attachmentsMetadataArtifactId = attachmentsMetadata.artifactIds[0];
+            console.log(`Started processing attachments for attachments metadata artifact ID: ${attachmentsMetadataArtifactId}.`);
+            const { attachments, error } = await this.uploader.getAttachmentsFromArtifactId({
+                artifact: attachmentsMetadataArtifactId,
+            });
+            if (error) {
+                console.error(`Failed to get attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                return { error };
             }
-            if (batchSize > 50) {
-                console.warn(`The specified batch size (${batchSize}) is too large. Using 50 instead.`);
-                batchSize = 50;
+            if (!attachments || attachments.length === 0) {
+                console.warn(`No attachments found for artifact ID: ${attachmentsMetadataArtifactId}.`);
+                // Remove empty artifact and reset lastProcessed
+                attachmentsMetadata.artifactIds.shift();
+                attachmentsMetadata.lastProcessed = 0;
+                continue;
             }
-            const repos = [
-                {
-                    itemType: 'ssor_attachment',
-                },
-            ];
-            this.initializeRepos(repos);
-            const attachmentsMetadata = (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata;
-            // If there are no attachments metadata artifact IDs in state, finish here
-            if (!((_b = attachmentsMetadata === null || attachmentsMetadata === void 0 ? void 0 : attachmentsMetadata.artifactIds) === null || _b === void 0 ? void 0 : _b.length)) {
-                console.log(`No attachments metadata artifact IDs found in state.`);
-                return;
+            console.log(`Found ${attachments.length} attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+            let response;
+            if (processors) {
+                console.log(`Using custom processors for attachments.`);
+                const reducer = processors.reducer;
+                const iterator = processors.iterator;
+                const reducedAttachments = reducer({
+                    attachments,
+                    adapter: this,
+                    batchSize,
+                });
+                response = await iterator({
+                    reducedAttachments,
+                    adapter: this,
+                    stream,
+                });
             }
             else {
-                console.log(`Found ${attachmentsMetadata.artifactIds.length} attachments metadata artifact IDs in state.`);
-            }
-            // Loop through the attachments metadata artifact IDs
-            while (attachmentsMetadata.artifactIds.length > 0) {
-                const attachmentsMetadataArtifactId = attachmentsMetadata.artifactIds[0];
-                console.log(`Started processing attachments for attachments metadata artifact ID: ${attachmentsMetadataArtifactId}.`);
-                const { attachments, error } = await this.uploader.getAttachmentsFromArtifactId({
-                    artifact: attachmentsMetadataArtifactId,
+                console.log(`Using attachments streaming pool for attachments streaming.`);
+                const attachmentsPool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                    adapter: this,
+                    attachments,
+                    batchSize,
+                    stream,
                 });
-                if (error) {
-                    console.error(`Failed to get attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                    return { error };
-                }
-                if (!attachments || attachments.length === 0) {
-                    console.warn(`No attachments found for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                    // Remove empty artifact and reset lastProcessed
-                    attachmentsMetadata.artifactIds.shift();
-                    attachmentsMetadata.lastProcessed = 0;
-                    continue;
-                }
-                console.log(`Found ${attachments.length} attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                let response;
-                if (processors) {
-                    console.log(`Using custom processors for attachments.`);
-                    const reducer = processors.reducer;
-                    const iterator = processors.iterator;
-                    const reducedAttachments = reducer({
-                        attachments,
-                        adapter: this,
-                        batchSize,
-                    });
-                    response = await iterator({
-                        reducedAttachments,
-                        adapter: this,
-                        stream,
-                    });
-                }
-                else {
-                    console.log(`Using attachments streaming pool for attachments streaming.`);
-                    const attachmentsPool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                        adapter: this,
-                        attachments,
-                        batchSize,
-                        stream,
-                    });
-                    response = await attachmentsPool.streamAll();
-                }
-                if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
-                    return response;
-                }
-                console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
-                attachmentsMetadata.artifactIds.shift();
-                attachmentsMetadata.lastProcessed = 0;
-                if (attachmentsMetadata.lastProcessedAttachmentsIdsList) {
-                    attachmentsMetadata.lastProcessedAttachmentsIdsList.length = 0;
-                }
+                response = await attachmentsPool.streamAll();
             }
-            return;
-        });
+            if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
+                return response;
+            }
+            console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+            attachmentsMetadata.artifactIds.shift();
+            attachmentsMetadata.lastProcessed = 0;
+            if (attachmentsMetadata.lastProcessedAttachmentsIdsList) {
+                attachmentsMetadata.lastProcessedAttachmentsIdsList.length = 0;
+            }
+        }
+        return;
     }
 }
 exports.WorkerAdapter = WorkerAdapter;