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

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

@@ -6,19 +6,13 @@ 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");
 const loading_adapter_helpers_1 = require("./loading-adapter.helpers");
-/**
- * LoadingAdapter is the adapter passed to loading tasks. It exposes the loading
- * surface (item/attachment loading, mappers, loader reports).
- *
- * @public
- */
+/** Adapter passed to loading tasks (item/attachment loading, mappers, loader reports). @public */
 class LoadingAdapter extends base_adapter_1.BaseAdapter {
     constructor(params) {
         super(params);
@@ -39,7 +33,7 @@ class LoadingAdapter extends base_adapter_1.BaseAdapter {
         return this._mappers;
     }
     async beforeEmit() {
-        // Loading has no pre-emit work (no repos, no extraction boundaries).
+        // Loading has no pre-emit work.
     }
     buildEmitPayload(newEventType) {
         const isLoaderEvent = Object.values(loading_1.LoaderEventType).includes(newEventType);
@@ -54,408 +48,362 @@ 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 () => {
-            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.');
+        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 {
-                        reports: this.reports,
-                        processed_files: this.processedFiles,
+                        status: 'error',
+                        error: {
+                            message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
+                        },
                     };
                 }
-                const filesToLoad = await this.getLoaderBatches({
-                    supportedItemTypes: itemTypes,
-                });
-                this.adapterState.sdkState.fromDevRev = {
-                    filesToLoad,
-                };
-            }
-            if (!this.adapterState.sdkState.fromDevRev ||
-                !this.adapterState.sdkState.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.sdkState.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
-            try {
-                outerloop: for (const fileToLoad of this.adapterState.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, {
+                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: `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 { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                            artifactId: fileToLoad.id,
-                            isGzipped: true,
+                    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 (transformerFileError) {
-                            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}.`,
-                                },
-                            });
-                            break outerloop;
+                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                            return { status: 'delay', delaySeconds: rateLimit.delay };
                         }
-                        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);
-                            }
-                            const { report, rateLimit } = await this.loadItem({
-                                item: transformerFile[i],
-                                itemTypeToLoad,
+                        if (report) {
+                            (0, loading_adapter_helpers_1.addReportToLoaderReport)({
+                                loaderReports: this.loaderReports,
+                                report,
                             });
-                            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;
-                            }
-                            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 data loading.', (0, logger_1.serializeError)(error));
-                await this.emit(loading_1.LoaderEventType.DataLoadingError, {
-                    error: {
-                        message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
-                    },
-                });
-                process.exit(1);
-            }
+        }
+        catch (error) {
+            console.error('Error during data loading.', (0, logger_1.serializeError)(error));
             return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
+                status: 'error',
+                error: {
+                    message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
+                },
             };
-        });
+        }
+        return { status: 'success' };
     }
     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 { response, error: statsFileError } = await this.uploader.getJsonObjectByArtifactId({
-                    artifactId: statsFileArtifactId,
-                });
-                const statsFile = response;
-                if (statsFileError || statsFile.length === 0) {
-                    return [];
-                }
-                const filesToLoad = (0, loading_adapter_helpers_1.getFilesToLoad)({
-                    supportedItemTypes,
-                    statsFile,
-                });
-                return filesToLoad;
+        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 [];
-        });
+            const filesToLoad = (0, loading_adapter_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.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) {
-                console.log('No files to load, returning.');
-                return {
-                    reports: this.reports,
-                    processed_files: this.processedFiles,
-                };
-            }
-            const filesToLoad = (_b = this.adapterState.sdkState.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
-            try {
-                outerloop: for (const fileToLoad of filesToLoad) {
-                    if (!fileToLoad.completed) {
-                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                            artifactId: fileToLoad.id,
-                            isGzipped: true,
+        var _a, _b;
+        if (this.event.payload.event_type === extraction_1.EventType.StartLoadingAttachments) {
+            this.sdkState.fromDevRev = {
+                filesToLoad: await this.getLoaderBatches({
+                    supportedItemTypes: ['attachment'],
+                }),
+            };
+        }
+        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 { status: 'success' };
+        }
+        const filesToLoad = (_b = this.sdkState.fromDevRev) === null || _b === void 0 ? void 0 : _b.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}.`,
+                            },
+                        };
+                    }
+                    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,
                         });
-                        const transformerFile = response;
-                        if (transformerFileError) {
-                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                            await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
-                                error: {
-                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
-                                },
-                            });
-                            break outerloop;
+                        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. Emitting progress to allow continuation.');
-                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingProgress);
-                                process.exit(0);
-                            }
-                            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) {
-                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingDelayed, {
-                                    delay: rateLimit.delay,
-                                    reports: this.reports,
-                                    processed_files: this.processedFiles,
-                                });
-                                break outerloop;
-                            }
-                            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));
-                await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
-                    error: {
-                        message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
-                    },
-                });
-                process.exit(1);
-            }
+        }
+        catch (error) {
+            console.error('Error during attachment loading.', (0, logger_1.serializeError)(error));
             return {
-                reports: this.reports,
-                processed_files: this.processedFiles,
+                status: 'error',
+                error: {
+                    message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
+                },
             };
-        });
+        }
+        return { status: 'success' };
     }
     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 syncMapperRecord = await this._mappers.getByTargetId({
+                sync_unit: this.event.payload.event_context.sync_unit,
+                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.',
+                    },
+                };
+            }
+            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 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 (0, logger_context_1.runWithUserLogContext)(async () => {
-                    return await itemTypeToLoad.update({
+                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) {
-                    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: [
+                    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,
                                     },
                                 ],
-                            },
-                        })), { 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 (0, logger_context_1.runWithUserLogContext)(async () => {
-                            return 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.', syncMapperRecordCreate);
                             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 loadAttachment({ item, create, }) {
-        return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            // Create item
-            const { id, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => 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,
-                    },
-                };
+        const { id, delay, error } = await create({
+            item,
+            mappers: this._mappers,
+            event: this.event,
+        });
+        if (delay) {
+            return {
+                rateLimit: {
+                    delay,
+                },
+            };
+        }
+        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);
             }
-            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: 'attachments',
+                    [loading_1.ActionType.CREATED]: 1,
+                },
+            };
+        }
+        else {
+            console.warn('Failed to create attachment in external system', error);
+            return {
+                report: {
+                    item_type: 'attachments',
+                    [loading_1.ActionType.FAILED]: 1,
+                },
+            };
+        }
     }
 }
 exports.LoadingAdapter = LoadingAdapter;