@devrev/ts-adaas 1.6.0 → 1.7.0-beta.1

package/dist/common/install-initial-domain-mapping.js

@@ -42,13 +42,7 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
             console.log('Successfully created recipe blueprint with id: ' + recipeBlueprintId);
         }
         catch (error) {
-            const errorMessage = `Error while creating recipe blueprint. Continuing without it.`;
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error(errorMessage, (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error(errorMessage, error);
-            }
+            console.warn('Error while creating recipe blueprint. Continuing without it.', (0, logger_1.serializeError)(error));
         }
     }
     // Install the initial domain mappings
@@ -60,6 +54,5 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
             Authorization: devrevToken,
         },
     });
-    console.log('Successfully installed initial domain mapping: ' +
-        JSON.stringify(initialDomainMappingInstallResponse.data));
+    console.log(`Successfully installed initial domain mapping ${JSON.stringify(initialDomainMappingInstallResponse.data)}`);
 }

package/dist/common/install-initial-domain-mapping.test.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
 const install_initial_domain_mapping_1 = require("./install-initial-domain-mapping");
 const axios_client_1 = require("../http/axios-client");
-const logger_1 = require("../logger/logger");
 const test_helpers_1 = require("../tests/test-helpers");
 const extraction_1 = require("../types/extraction");
 // Mock dependencies
@@ -15,7 +14,6 @@ jest.mock('../http/axios-client');
 jest.mock('../logger/logger');
 const mockAxiosClient = axios_client_1.axiosClient;
 const mockIsAxiosError = axios_1.default.isAxiosError;
-const mockSerializeAxiosError = logger_1.serializeAxiosError;
 describe('installInitialDomainMapping', () => {
     // Create mock objects
     const mockEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
@@ -46,7 +44,9 @@ describe('installInitialDomainMapping', () => {
         // Re-initialize the spy and its mock implementation
         mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
         mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => { });
+        mockConsoleError = jest
+            .spyOn(console, 'error')
+            .mockImplementation(() => { });
     });
     // After each test, clear all mocks to prevent state from leaking.
     afterEach(() => {
@@ -104,7 +104,7 @@ describe('installInitialDomainMapping', () => {
             },
         });
         expect(mockConsoleLog).toHaveBeenCalledWith('Successfully created recipe blueprint with id: recipe-blueprint-123');
-        expect(mockConsoleLog).toHaveBeenCalledWith('Successfully installed initial domain mapping: {"success":true,"mapping_id":"mapping-123"}');
+        expect(mockConsoleLog).toHaveBeenCalledWith(`Successfully installed initial domain mapping ${JSON.stringify(mockDomainMappingResponse.data)}`);
     });
     it('should successfully install without recipe blueprint when not provided', async () => {
         const mappingWithoutBlueprint = {

package/dist/logger/logger.d.ts

@@ -3,7 +3,9 @@ import { LoggerFactoryInterface, LogLevel, PrintableState } from './logger.inter
 import { AxiosError, RawAxiosResponseHeaders } from 'axios';
 export declare class Logger extends Console {
     private options?;
+    private tags;
     constructor({ event, options }: LoggerFactoryInterface);
+    private valueToString;
     logFn(args: unknown[], level: LogLevel): void;
     log(...args: unknown[]): void;
     info(...args: unknown[]): void;
@@ -15,7 +17,7 @@ export declare function getPrintableState(state: Record<string, any>): Printable
  * @deprecated
  */
 export declare function formatAxiosError(error: AxiosError): object;
-export declare const serializeError: (error: unknown) => Error;
+export declare const serializeError: (error: unknown) => unknown;
 export declare function serializeAxiosError(error: AxiosError): {
     config: {
         method: string | undefined;

package/dist/logger/logger.js

@@ -1,26 +1,30 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeError = exports.Logger = void 0;
 exports.getPrintableState = getPrintableState;
 exports.formatAxiosError = formatAxiosError;
 exports.serializeAxiosError = serializeAxiosError;
-const lambda_log_1 = __importDefault(require("lambda-log"));
 const node_console_1 = require("node:console");
+const node_util_1 = require("node:util");
 const logger_interfaces_1 = require("./logger.interfaces");
 const node_worker_threads_1 = require("node:worker_threads");
 const workers_1 = require("../types/workers");
-const helpers_1 = require("../common/helpers");
+const axios_1 = require("axios");
 class Logger extends node_console_1.Console {
     constructor({ event, options }) {
         super(process.stdout, process.stderr);
         this.options = options;
-        lambda_log_1.default.options.levelKey = null;
-        lambda_log_1.default.options.tagsKey = null;
-        lambda_log_1.default.options.messageKey = 'message';
-        lambda_log_1.default.options.meta = Object.assign(Object.assign({}, event.payload.event_context), { dev_oid: event.payload.event_context.dev_org });
+        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { dev_oid: event.payload.event_context.dev_org });
+    }
+    valueToString(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        // Use Node.js built-in inspect for everything including errors
+        return (0, node_util_1.inspect)(value, {
+            compact: false,
+            depth: Infinity,
+        });
     }
     logFn(args, level) {
         var _a;
@@ -29,14 +33,28 @@ class Logger extends node_console_1.Console {
                 console[level](...args);
             }
             else {
-                lambda_log_1.default.log(level, JSON.stringify(args));
+                let message;
+                if (args.length === 1 && typeof args[0] === 'string') {
+                    // Single string argument - use directly
+                    message = args[0];
+                }
+                else if (args.length === 1) {
+                    // Single non-string argument - convert to string properly
+                    message = this.valueToString(args[0]);
+                }
+                else {
+                    // Multiple arguments - create a readable format
+                    message = args.map((arg) => this.valueToString(arg)).join(' ');
+                }
+                const logObject = Object.assign({ message }, this.tags);
+                console[level](JSON.stringify(logObject));
             }
         }
         else {
             node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
                 subject: workers_1.WorkerMessageSubject.WorkerMessageLog,
                 payload: {
-                    args: JSON.parse(JSON.stringify(args, (0, helpers_1.getCircularReplacer)())),
+                    args: args.map((arg) => this.valueToString(arg)),
                     level,
                 },
             });
@@ -93,14 +111,10 @@ function formatAxiosError(error) {
     return serializeAxiosError(error);
 }
 const serializeError = (error) => {
-    let serializedError = error;
-    try {
-        serializedError = JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)));
-    }
-    catch (err) {
-        console.error('Failed to serialize error object for logger', err);
+    if ((0, axios_1.isAxiosError)(error)) {
+        return serializeAxiosError(error);
     }
-    return serializedError;
+    return error;
 };
 exports.serializeError = serializeError;
 function serializeAxiosError(error) {

package/dist/logger/logger.test.js

@@ -1,6 +1,184 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
 const logger_1 = require("./logger");
+const extraction_1 = require("../types/extraction");
+const test_helpers_1 = require("../tests/test-helpers");
+// Mock console methods
+const mockConsoleInfo = jest.spyOn(console, 'info').mockImplementation();
+const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation();
+const mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+// Mock worker_threads
+jest.mock('node:worker_threads', () => ({
+    isMainThread: true,
+    parentPort: null,
+}));
+describe('Logger', () => {
+    let mockEvent;
+    let mockOptions;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockEvent = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            eventContextOverrides: {
+                dev_org: 'DEV-test',
+                dev_org_id: 'DEV-test-id',
+                dev_user: 'DEVU-test',
+                dev_user_id: 'DEVU-test-id',
+                external_sync_unit: 'test-unit',
+                external_sync_unit_id: 'test-unit-id',
+                external_sync_unit_name: 'test-unit-name',
+                external_system: 'test-system',
+                external_system_type: 'test-type',
+                import_slug: 'test-import',
+                request_id: 'test-request-id',
+                snap_in_slug: 'test-snap-slug',
+                sync_run: 'test-sync-run',
+                sync_run_id: 'test-sync-run-id',
+            },
+        });
+        mockOptions = {
+            isLocalDevelopment: false,
+        };
+    });
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe('constructor', () => {
+        it('should initialize logger with event context and dev_oid', () => {
+            const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+            // Access private property for testing
+            const tags = logger.tags;
+            expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org }));
+        });
+    });
+    describe('production logging', () => {
+        let logger;
+        beforeEach(() => {
+            mockOptions.isLocalDevelopment = false;
+            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        });
+        it('should log single string message without backslashes', () => {
+            const message = 'Worker is online. Started processing the task.';
+            logger.info(message);
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+        });
+        it('should log single object message with JSON stringify', () => {
+            const data = { id: 123, name: 'test' };
+            logger.info(data);
+            const expectedMessage = (0, node_util_1.inspect)(data, {
+                compact: false,
+                depth: Infinity,
+            });
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+        });
+        it('should log multiple arguments joined with space', () => {
+            const text = 'Successfully fetched';
+            const data = { count: 42 };
+            logger.info(text, data);
+            const expectedDataMessage = (0, node_util_1.inspect)(data, {
+                compact: false,
+                depth: Infinity,
+            });
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+        });
+        it('should handle mixed string and object arguments', () => {
+            const text1 = 'Processing';
+            const data = { id: 123 };
+            const text2 = 'completed';
+            logger.info(text1, data, text2);
+            const expectedDataMessage = (0, node_util_1.inspect)(data, {
+                compact: false,
+                depth: Infinity,
+            });
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+        });
+    });
+    describe('local development logging', () => {
+        let logger;
+        beforeEach(() => {
+            mockOptions.isLocalDevelopment = true;
+            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        });
+        it('should use regular console methods in local development', () => {
+            const message = 'Test message';
+            const data = { test: true };
+            logger.info(message, data);
+            expect(mockConsoleInfo).toHaveBeenCalledWith(message, data);
+        });
+    });
+    describe('log levels', () => {
+        let logger;
+        beforeEach(() => {
+            mockOptions.isLocalDevelopment = false;
+            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        });
+        it('should call console.info for info level', () => {
+            logger.info('test message');
+            expect(mockConsoleInfo).toHaveBeenCalled();
+        });
+        it('should call console.warn for warn level', () => {
+            logger.warn('test warning');
+            expect(mockConsoleWarn).toHaveBeenCalled();
+        });
+        it('should call console.error for error level', () => {
+            logger.error('test error');
+            expect(mockConsoleError).toHaveBeenCalled();
+        });
+        it('should call console.info for log level', () => {
+            logger.log('test log');
+            expect(mockConsoleInfo).toHaveBeenCalled();
+        });
+    });
+    describe('edge cases', () => {
+        let logger;
+        beforeEach(() => {
+            mockOptions.isLocalDevelopment = false;
+            logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        });
+        it('should handle empty string message', () => {
+            logger.info('');
+            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+            const callArgs = mockConsoleInfo.mock.calls[0][0];
+            const logObject = JSON.parse(callArgs);
+            expect(logObject.message).toBe('');
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+            expect(logObject.request_id).toBe(mockEvent.payload.event_context.request_id);
+        });
+        it('should handle null and undefined values', () => {
+            logger.info('test', null, undefined);
+            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+            const callArgs = mockConsoleInfo.mock.calls[0][0];
+            const logObject = JSON.parse(callArgs);
+            // inspect shows 'null' and 'undefined' as strings
+            expect(logObject.message).toBe('test null undefined');
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+        });
+        it('should handle complex nested objects', () => {
+            const complexObject = {
+                level1: {
+                    level2: {
+                        array: [1, 2, 3],
+                        string: 'nested',
+                    },
+                },
+            };
+            logger.info(complexObject);
+            expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+            const callArgs = mockConsoleInfo.mock.calls[0][0];
+            const logObject = JSON.parse(callArgs);
+            // The logger uses inspect() with formatting, not JSON.stringify()
+            const expectedMessage = require('util').inspect(complexObject, {
+                compact: false,
+                depth: Infinity,
+            });
+            expect(logObject.message).toBe(expectedMessage);
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+            expect(typeof logObject.callback_url).toBe('string');
+        });
+    });
+});
 it('getPrintableState should return printable state', () => {
     const state = {
         test_key: 'test_value',

package/dist/state/state.js

@@ -36,12 +36,7 @@ async function createAdapterState({ event, initialState, initialDomainMapping, o
                 }
             }
             catch (error) {
-                if (axios_client_1.axios.isAxiosError(error)) {
-                    console.error('Error while installing initial domain mapping', (0, logger_1.serializeAxiosError)(error));
-                }
-                else {
-                    console.error('Error while installing initial domain mapping', error);
-                }
+                console.error('Error while installing initial domain mapping.', (0, logger_1.serializeError)(error));
             }
         }
         // Set lastSyncStarted if the event type is ExtractionDataStart
@@ -108,12 +103,7 @@ class State {
             console.log('State updated successfully to', (0, logger_1.getPrintableState)(this.state));
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Failed to update state', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Failed to update state', error);
-            }
+            console.error('Failed to update the state.', (0, logger_1.serializeError)(error));
             process.exit(1);
         }
     }

package/dist/types/extraction.d.ts

@@ -139,7 +139,11 @@ export interface EventContext {
     initial_sync_scope?: InitialSyncScope;
     mode: string;
     request_id: string;
+    /**
+     * @deprecated reset_extraction is deprecated and should not be used. Use reset_extract_from instead.
+     */
     reset_extraction?: boolean;
+    reset_extract_from?: boolean;
     snap_in_slug: string;
     snap_in_version_id: string;
     sync_run: string;

package/dist/types/extraction.test.js

@@ -11,7 +11,7 @@ describe('EventContext type tests', () => {
     });
     it('should handle context with all optional fields', () => {
         const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extraction: true });
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extract_from: true });
         // Test with all optionals present
         expect(event).toBeDefined();
     });

package/dist/uploader/uploader.js

@@ -73,7 +73,7 @@ class Uploader {
         const file = this.compressGzip(js_jsonl_1.jsonl.stringify(fetchedObjects));
         if (!file) {
             return {
-                error: { message: 'Error while compressing jsonl object.' },
+                error: new Error('Error while compressing jsonl object.'),
             };
         }
         const filename = itemType + '.jsonl.gz';
@@ -82,21 +82,21 @@ class Uploader {
         const preparedArtifact = await this.getArtifactUploadUrl(filename, fileType);
         if (!preparedArtifact) {
             return {
-                error: { message: 'Error while getting artifact upload URL.' },
+                error: new Error('Error while getting artifact upload URL.'),
             };
         }
         // Upload prepared artifact to the given url
         const uploadItemResponse = await this.uploadArtifact(preparedArtifact, file);
         if (!uploadItemResponse) {
             return {
-                error: { message: 'Error while uploading artifact.' },
+                error: new Error('Error while uploading artifact.'),
             };
         }
         // Confirm upload
         const confirmArtifactUploadResponse = await this.confirmArtifactUpload(preparedArtifact.artifact_id);
         if (!confirmArtifactUploadResponse) {
             return {
-                error: { message: 'Error while confirming artifact upload.' },
+                error: new Error('Error while confirming artifact upload.'),
             };
         }
         // Return the artifact information to the platform
@@ -121,12 +121,7 @@ class Uploader {
             return response.data;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while getting artifact upload URL.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while getting artifact upload URL.', error);
-            }
+            console.error('Error while getting artifact upload URL.', (0, logger_1.serializeError)(error));
         }
     }
     async uploadArtifact(artifact, file) {
@@ -142,12 +137,7 @@ class Uploader {
             return response;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while uploading artifact.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while uploading artifact.', error);
-            }
+            console.error('Error while uploading artifact.', (0, logger_1.serializeError)(error));
         }
     }
     async streamArtifact(artifact, fileStream) {
@@ -171,12 +161,7 @@ class Uploader {
             return response;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while streaming artifact.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while streaming artifact.', error);
-            }
+            console.error('Error while streaming artifact.', (0, logger_1.serializeError)(error));
             return;
         }
     }
@@ -192,12 +177,7 @@ class Uploader {
             return response;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while confirming artifact upload.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while confirming artifact upload.', error);
-            }
+            console.error('Error while confirming artifact upload.', (0, logger_1.serializeError)(error));
         }
     }
     async getAttachmentsFromArtifactId({ artifact, }) {
@@ -205,28 +185,28 @@ class Uploader {
         const artifactUrl = await this.getArtifactDownloadUrl(artifact);
         if (!artifactUrl) {
             return {
-                error: { message: 'Error while getting artifact download URL.' },
+                error: new Error('Error while getting artifact download URL.'),
             };
         }
         // Download artifact from the URL
         const gzippedJsonlObject = await this.downloadArtifact(artifactUrl);
         if (!gzippedJsonlObject) {
             return {
-                error: { message: 'Error while downloading gzipped jsonl object.' },
+                error: new Error('Error while downloading gzipped jsonl object.'),
             };
         }
         // Decompress the gzipped jsonl object
         const jsonlObject = this.decompressGzip(gzippedJsonlObject);
         if (!jsonlObject) {
             return {
-                error: { message: 'Error while decompressing gzipped jsonl object.' },
+                error: new Error('Error while decompressing gzipped jsonl object.'),
             };
         }
         // Parse the jsonl object to get the attachment metadata
         const jsonObject = this.parseJsonl(jsonlObject);
         if (!jsonObject) {
             return {
-                error: { message: 'Error while parsing jsonl object.' },
+                error: new Error('Error while parsing jsonl object.'),
             };
         }
         return { attachments: jsonObject };
@@ -244,12 +224,7 @@ class Uploader {
             return response.data.download_url;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while getting artifact download URL.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while getting artifact download URL.', error);
-            }
+            console.error('Error while getting artifact download URL.', (0, logger_1.serializeError)(error));
         }
     }
     async downloadArtifact(artifactUrl) {
@@ -260,12 +235,7 @@ class Uploader {
             return response.data;
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while downloading artifact from URL.', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while downloading artifact from URL.', error);
-            }
+            console.error('Error while downloading artifact from URL.', (0, logger_1.serializeError)(error));
         }
     }
     compressGzip(jsonlObject) {

package/dist/uploader/uploader.test.js

@@ -56,16 +56,17 @@ describe('Uploader Class Tests', () => {
         });
     });
     it('should handle failure in getArtifactUploadUrl', async () => {
+        var _a;
         // Mock unsuccessful response for getArtifactUploadUrl
         axios_client_1.axiosClient.get.mockResolvedValueOnce(undefined);
         const entity = 'entity';
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
-        expect(uploadResponse).toEqual({
-            error: { message: 'Error while getting artifact upload URL.' },
-        });
+        expect(uploadResponse.error).toBeInstanceOf(Error);
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while getting artifact upload URL.');
     });
     it('should handle failure in uploadArtifact', async () => {
+        var _a;
         // Mock successful response for getArtifactUploadUrl
         axios_client_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
         // Mock unsuccessful response for uploadArtifact
@@ -73,11 +74,11 @@ describe('Uploader Class Tests', () => {
         const entity = 'entity';
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
-        expect(uploadResponse).toEqual({
-            error: { message: 'Error while uploading artifact.' },
-        });
+        expect(uploadResponse.error).toBeInstanceOf(Error);
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while uploading artifact.');
     });
     it('should handle failure in confirmArtifactUpload', async () => {
+        var _a;
         // Mock successful response for getArtifactUploadUrl
         axios_client_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
         // Mock successful response from uploadArtifact
@@ -87,8 +88,7 @@ describe('Uploader Class Tests', () => {
         const entity = 'entity';
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
-        expect(uploadResponse).toEqual({
-            error: { message: 'Error while confirming artifact upload.' },
-        });
+        expect(uploadResponse.error).toBeInstanceOf(Error);
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while confirming artifact upload.');
     });
 });

package/dist/workers/spawn.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Spawn = void 0;
 exports.spawn = spawn;
-const axios_1 = __importDefault(require("axios"));
 const helpers_1 = require("yargs/helpers");
 const yargs_1 = __importDefault(require("yargs"));
 const extraction_1 = require("../types/extraction");
@@ -124,12 +123,7 @@ async function spawn({ event, initialState, workerPath, initialDomainMapping, op
             });
         }
         catch (error) {
-            if (axios_1.default.isAxiosError(error)) {
-                console.error('Error while emitting event', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while emitting event', error);
-            }
+            console.error('Error while emitting event.', (0, logger_1.serializeError)(error));
         }
     }
 }
@@ -217,12 +211,7 @@ class Spawn {
             this.resolve();
         }
         catch (error) {
-            if (axios_1.default.isAxiosError(error)) {
-                console.error('Error while emitting event', (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error('Error while emitting event', error);
-            }
+            console.error('Error while emitting event.', (0, logger_1.serializeError)(error));
         }
     }
 }

package/dist/workers/worker-adapter.js

@@ -92,7 +92,7 @@ class WorkerAdapter {
             }
             // Loop through the batches of attachments
             for (let i = lastProcessedBatchIndex; i < reducedAttachments.length; i++) {
-                // Check if we hit timeout 
+                // Check if we hit timeout
                 if (adapter.isTimeout) {
                     await (0, helpers_2.sleep)(constants_1.DEFAULT_SLEEP_DELAY_MS);
                 }
@@ -263,12 +263,7 @@ class WorkerAdapter {
             node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
         }
         catch (error) {
-            if (axios_client_1.axios.isAxiosError(error)) {
-                console.error(`Error while emitting event with event type: ${newEventType}`, (0, logger_1.serializeAxiosError)(error));
-            }
-            else {
-                console.error(`Unknown error while emitting event with event type: ${newEventType}`, 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);
         }
     }
@@ -487,22 +482,12 @@ class WorkerAdapter {
                         });
                     }
                     catch (error) {
-                        if (axios_client_1.axios.isAxiosError(error)) {
-                            console.warn('Failed to update sync mapper record', (0, logger_1.serializeAxiosError)(error));
-                            return {
-                                error: {
-                                    message: error.message,
-                                },
-                            };
-                        }
-                        else {
-                            console.warn('Failed to update sync mapper record', error);
-                            return {
-                                error: {
-                                    message: 'Failed to update sync mapper record' + 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 {
@@ -557,18 +542,11 @@ class WorkerAdapter {
                             };
                         }
                         catch (error) {
-                            if (axios_client_1.axios.isAxiosError(error)) {
-                                console.warn('Failed to create sync mapper record', (0, logger_1.serializeAxiosError)(error));
-                                return {
-                                    error: {
-                                        message: error.message,
-                                    },
-                                };
-                            }
-                            console.warn('Failed to create sync mapper record', error);
+                            console.warn('Failed to create sync mapper record.', (0, logger_1.serializeError)(error));
                             return {
                                 error: {
-                                    message: 'Failed to create sync mapper record' + error,
+                                    message: 'Failed to create sync mapper record. ' +
+                                        (0, logger_1.serializeError)(error),
                                 },
                             };
                         }
@@ -581,7 +559,7 @@ class WorkerAdapter {
                         };
                     }
                     else {
-                        console.warn('Failed to create item in external system', error);
+                        console.warn('Failed to create item in external system.', (0, logger_1.serializeError)(error));
                         return {
                             report: {
                                 item_type: itemTypeToLoad.itemType,
@@ -591,7 +569,7 @@ class WorkerAdapter {
                     }
                 }
                 else {
-                    console.warn('Failed to get sync mapper record', (0, logger_1.serializeAxiosError)(error));
+                    console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
                     return {
                         error: {
                             message: error.message,
@@ -599,10 +577,10 @@ class WorkerAdapter {
                     };
                 }
             }
-            console.warn('Failed to get sync mapper record', error);
+            console.warn('Failed to get sync mapper record.', (0, logger_1.serializeError)(error));
             return {
                 error: {
-                    message: 'Failed to get sync mapper record' + error,
+                    message: 'Failed to get sync mapper record. ' + (0, logger_1.serializeError)(error),
                 },
             };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.6.0",
+  "version": "1.7.0-beta.1",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -34,8 +34,7 @@
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^5.1.3",
     "jest": "^29.7.0",
-    "ts-jest": "^29.3.3",
-    "typescript": "^5.3.3"
+    "ts-jest": "^29.3.3"
   },
   "dependencies": {
     "@devrev/typescript-sdk": "^1.1.59",
@@ -43,8 +42,8 @@
     "axios-retry": "^4.5.0",
     "form-data": "^4.0.1",
     "js-jsonl": "^1.1.1",
-    "lambda-log": "^3.1.0",
     "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
     "yargs": "^17.7.2"
   },
   "files": [