@devrev/ts-adaas 1.5.1 → 1.7.0-beta.0

package/dist/common/constants.d.ts

@@ -5,10 +5,14 @@ export declare const ALLOWED_LOADING_EVENT_TYPES: EventType[];
 export declare const ALLOWED_EVENT_TYPES: EventType[];
 export declare const ARTIFACT_BATCH_SIZE = 2000;
 export declare const MAX_DEVREV_ARTIFACT_SIZE = 262144000;
+export declare const MAX_DEVREV_FILENAME_LENGTH = 256;
+export declare const MAX_DEVREV_FILENAME_EXTENSION_LENGTH = 20;
 export declare const AIRDROP_DEFAULT_ITEM_TYPES: {
     EXTERNAL_DOMAIN_METADATA: string;
     ATTACHMENTS: string;
     SSOR_ATTACHMENT: string;
 };
 export declare const LIBRARY_VERSION: any;
-export declare const DEFAULT_SLEEP_DELAY_MS = 180000;
+export declare const DEFAULT_LAMBDA_TIMEOUT: number;
+export declare const HARD_TIMEOUT_MULTIPLIER = 1.3;
+export declare const DEFAULT_SLEEP_DELAY_MS: number;

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SLEEP_DELAY_MS = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = void 0;
+exports.DEFAULT_SLEEP_DELAY_MS = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = void 0;
 const extraction_1 = require("../types/extraction");
 const helpers_1 = require("./helpers");
 exports.STATELESS_EVENT_TYPES = [
@@ -33,10 +33,14 @@ exports.ALLOWED_EVENT_TYPES = [
 ];
 exports.ARTIFACT_BATCH_SIZE = 2000;
 exports.MAX_DEVREV_ARTIFACT_SIZE = 262144000; // 250MB
+exports.MAX_DEVREV_FILENAME_LENGTH = 256;
+exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = 20; // 20 characters for the file extension
 exports.AIRDROP_DEFAULT_ITEM_TYPES = {
     EXTERNAL_DOMAIN_METADATA: 'external_domain_metadata',
     ATTACHMENTS: 'attachments',
     SSOR_ATTACHMENT: 'ssor_attachment',
 };
 exports.LIBRARY_VERSION = (0, helpers_1.getLibraryVersion)();
-exports.DEFAULT_SLEEP_DELAY_MS = 180000; // 3 minutes
+exports.DEFAULT_LAMBDA_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+exports.HARD_TIMEOUT_MULTIPLIER = 1.3;
+exports.DEFAULT_SLEEP_DELAY_MS = 3 * 60 * 1000; // 3 minutes

package/dist/common/control-protocol.js

@@ -12,7 +12,7 @@ const emit = async ({ event, eventType, data, }) => {
             adaas_library_version: constants_1.LIBRARY_VERSION,
         },
     };
-    console.info('Emitting event', JSON.stringify(newEvent));
+    console.info('Emitting event', newEvent);
     return axios_client_1.axiosClient.post(event.payload.event_context.callback_url, Object.assign({}, newEvent), {
         headers: {
             Accept: 'application/json, text/plain, */*',

package/dist/common/helpers.d.ts

@@ -2,7 +2,7 @@ import { AirdropEvent, EventType, ExtractorEventType } from '../types/extraction
 import { FileToLoad, LoaderEventType, LoaderReport, StatsFileObject } from '../types/loading';
 export declare function getTimeoutErrorEventType(eventType: EventType): {
     eventType: ExtractorEventType | LoaderEventType;
-} | null;
+};
 export declare function getSyncDirection({ event }: {
     event: AirdropEvent;
 }): string;
@@ -17,3 +17,4 @@ export declare function addReportToLoaderReport({ loaderReports, report, }: {
 export declare function getCircularReplacer(): (key: any, value: any) => any;
 export declare function getLibraryVersion(): any;
 export declare function sleep(ms: number): Promise<unknown>;
+export declare function truncateFilename(filename: string): string;

package/dist/common/helpers.js

@@ -40,10 +40,12 @@ exports.addReportToLoaderReport = addReportToLoaderReport;
 exports.getCircularReplacer = getCircularReplacer;
 exports.getLibraryVersion = getLibraryVersion;
 exports.sleep = sleep;
+exports.truncateFilename = truncateFilename;
 const extraction_1 = require("../types/extraction");
 const loading_1 = require("../types/loading");
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const constants_1 = require("./constants");
 function getTimeoutErrorEventType(eventType) {
     switch (eventType) {
         case extraction_1.EventType.ExtractionMetadataStart:
@@ -181,3 +183,16 @@ function sleep(ms) {
     console.log(`Sleeping for ${ms}ms.`);
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function truncateFilename(filename) {
+    // If the filename is already within the limit, return it as is.
+    if (filename.length <= constants_1.MAX_DEVREV_FILENAME_LENGTH) {
+        return filename;
+    }
+    console.warn(`Filename length exceeds the maximum limit of ${constants_1.MAX_DEVREV_FILENAME_LENGTH} characters. Truncating filename.`);
+    let extension = filename.slice(-constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH);
+    // Calculate how many characters are available for the name part after accounting for the extension and "..."
+    const availableNameLength = constants_1.MAX_DEVREV_FILENAME_LENGTH - constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH - 3; // -3 for "..."
+    // Truncate the name part and add an ellipsis
+    const truncatedFilename = filename.slice(0, availableNameLength);
+    return `${truncatedFilename}...${extension}`;
+}

package/dist/{tests/from_devrev/loading.test.js → common/helpers.test.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("../../common/helpers");
+const helpers_1 = require("./helpers");
 describe('getFilesToLoad', () => {
     let statsFile;
     beforeEach(() => {

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

@@ -12,73 +12,53 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
         console.warn('No initial domain mapping found.');
         return;
     }
-    try {
-        const snapInResponse = await axios_client_1.axiosClient.get(devrevEndpoint + '/internal/snap-ins.get', {
-            headers: {
-                Authorization: devrevToken,
-            },
-            params: {
-                id: snapInId,
-            },
-        });
-        const importSlug = (_d = (_c = (_b = (_a = snapInResponse.data) === null || _a === void 0 ? void 0 : _a.snap_in) === null || _b === void 0 ? void 0 : _b.imports) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.name;
-        const snapInSlug = (_g = (_f = (_e = snapInResponse.data) === null || _e === void 0 ? void 0 : _e.snap_in) === null || _f === void 0 ? void 0 : _f.snap_in_version) === null || _g === void 0 ? void 0 : _g.slug;
-        if (!importSlug || !snapInSlug) {
-            console.error('No import slug and snap in slug found in . Snap in response:', snapInResponse.data);
-            return;
-        }
-        const startingRecipeBlueprint = initialDomainMappingJson === null || initialDomainMappingJson === void 0 ? void 0 : initialDomainMappingJson.starting_recipe_blueprint;
-        let recipeBlueprintId;
-        if (startingRecipeBlueprint &&
-            Object.keys(startingRecipeBlueprint).length !== 0) {
-            try {
-                const recipeBlueprintResponse = await axios_client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.blueprints.create`, Object.assign({}, startingRecipeBlueprint), {
-                    headers: {
-                        Authorization: devrevToken,
-                    },
-                });
-                recipeBlueprintId = recipeBlueprintResponse.data.recipe_blueprint.id;
-                console.log('Successfully created recipe blueprint with id: ' + recipeBlueprintId);
-            }
-            catch (error) {
-                if (axios_client_1.axios.isAxiosError(error)) {
-                    console.error('Error while creating recipe blueprint', (0, logger_1.serializeAxiosError)(error));
-                }
-                else {
-                    console.error('Error while creating recipe blueprint', error);
-                }
-            }
-        }
+    // Get snap-in details
+    const snapInResponse = await axios_client_1.axiosClient.get(devrevEndpoint + '/internal/snap-ins.get', {
+        headers: {
+            Authorization: devrevToken,
+        },
+        params: {
+            id: snapInId,
+        },
+    });
+    const importSlug = (_d = (_c = (_b = (_a = snapInResponse.data) === null || _a === void 0 ? void 0 : _a.snap_in) === null || _b === void 0 ? void 0 : _b.imports) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.name;
+    const snapInSlug = (_g = (_f = (_e = snapInResponse.data) === null || _e === void 0 ? void 0 : _e.snap_in) === null || _f === void 0 ? void 0 : _f.snap_in_version) === null || _g === void 0 ? void 0 : _g.slug;
+    if (!importSlug || !snapInSlug) {
+        const errorMessage = `No import slug or snap-in slug found. Snap-in response: ${snapInResponse.data}`;
+        throw new Error(errorMessage);
+    }
+    const startingRecipeBlueprint = initialDomainMappingJson === null || initialDomainMappingJson === void 0 ? void 0 : initialDomainMappingJson.starting_recipe_blueprint;
+    // Try to create a recipe blueprint
+    let recipeBlueprintId;
+    if (startingRecipeBlueprint &&
+        Object.keys(startingRecipeBlueprint).length !== 0) {
         try {
-            // 2. Install the initial domain mappings
-            const additionalMappings = initialDomainMappingJson.additional_mappings || {};
-            const initialDomainMappingInstallResponse = await axios_client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, Object.assign(Object.assign({ external_system_type: 'ADaaS', import_slug: importSlug, snap_in_slug: snapInSlug }, (recipeBlueprintId && {
-                starting_recipe_blueprint: recipeBlueprintId,
-            })), additionalMappings), {
+            const recipeBlueprintResponse = await axios_client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.blueprints.create`, Object.assign({}, startingRecipeBlueprint), {
                 headers: {
                     Authorization: devrevToken,
                 },
             });
-            console.log('Successfully installed initial domain mapping: ' +
-                JSON.stringify(initialDomainMappingInstallResponse.data));
+            recipeBlueprintId = recipeBlueprintResponse.data.recipe_blueprint.id;
+            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('Error while installing initial domain mapping', (0, logger_1.serializeAxiosError)(error));
+                console.error(errorMessage, (0, logger_1.serializeAxiosError)(error));
             }
             else {
-                console.error('Error while installing initial domain mapping', error);
+                console.error(errorMessage, error);
             }
-            return;
         }
     }
-    catch (error) {
-        if (axios_client_1.axios.isAxiosError(error)) {
-            console.error('Error while fetching snap in', (0, logger_1.serializeAxiosError)(error));
-        }
-        else {
-            console.error('Error while fetching snap in', error);
-        }
-        return;
-    }
+    // Install the initial domain mappings
+    const additionalMappings = initialDomainMappingJson.additional_mappings || {};
+    const initialDomainMappingInstallResponse = await axios_client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, Object.assign(Object.assign({ external_system_type: 'ADaaS', import_slug: importSlug, snap_in_slug: snapInSlug }, (recipeBlueprintId && {
+        starting_recipe_blueprint: recipeBlueprintId,
+    })), additionalMappings), {
+        headers: {
+            Authorization: devrevToken,
+        },
+    });
+    console.log(`Successfully installed initial domain mapping ${JSON.stringify(initialDomainMappingInstallResponse.data)}`);
 }

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

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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
+jest.mock('axios', () => (Object.assign(Object.assign({}, jest.requireActual('axios')), { isAxiosError: jest.fn() })));
+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 });
+    const mockInitialDomainMapping = {
+        starting_recipe_blueprint: {
+            name: 'Test Recipe Blueprint',
+            description: 'Test description',
+        },
+        additional_mappings: {
+            custom_field: 'custom_value',
+        },
+    };
+    const mockSnapInResponse = {
+        data: {
+            snap_in: {
+                imports: [{ name: 'import-slug-123' }],
+                snap_in_version: { slug: 'snap-in-slug-123' },
+            },
+        },
+    };
+    const mockEndpoint = 'test_devrev_endpoint';
+    const mockToken = 'test_token';
+    let mockConsoleLog;
+    let mockConsoleWarn;
+    let mockConsoleError;
+    // Before each test, create a fresh spy.
+    beforeEach(() => {
+        // 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(() => { });
+    });
+    // After each test, clear all mocks to prevent state from leaking.
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should successfully install initial domain mapping with recipe blueprint', async () => {
+        // Mock successful snap-in response
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        // Mock successful recipe blueprint creation
+        const mockRecipeBlueprintResponse = {
+            data: {
+                recipe_blueprint: {
+                    id: 'recipe-blueprint-123',
+                },
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockRecipeBlueprintResponse);
+        // Mock successful domain mapping installation
+        const mockDomainMappingResponse = {
+            data: {
+                success: true,
+                mapping_id: 'mapping-123',
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping);
+        // Verify snap-in details request
+        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${mockEndpoint}/internal/snap-ins.get`, {
+            headers: {
+                Authorization: mockToken,
+            },
+            params: {
+                id: 'test_snap_in_id',
+            },
+        });
+        // Verify recipe blueprint creation
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.blueprints.create`, {
+            name: 'Test Recipe Blueprint',
+            description: 'Test description',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+        // Verify domain mapping installation
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, {
+            external_system_type: 'ADaaS',
+            import_slug: 'import-slug-123',
+            snap_in_slug: 'snap-in-slug-123',
+            starting_recipe_blueprint: 'recipe-blueprint-123',
+            custom_field: 'custom_value',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+        expect(mockConsoleLog).toHaveBeenCalledWith('Successfully created recipe blueprint with id: recipe-blueprint-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 = {
+            additional_mappings: {
+                custom_field: 'custom_value',
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mappingWithoutBlueprint);
+        // Should only make one POST request (no recipe blueprint creation)
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(1);
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, {
+            external_system_type: 'ADaaS',
+            import_slug: 'import-slug-123',
+            snap_in_slug: 'snap-in-slug-123',
+            custom_field: 'custom_value',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+    });
+    it('should handle empty starting_recipe_blueprint object', async () => {
+        const mappingWithEmptyBlueprint = {
+            starting_recipe_blueprint: {},
+            additional_mappings: {
+                custom_field: 'custom_value',
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mappingWithEmptyBlueprint);
+        // Should only make one POST request (no recipe blueprint creation for empty object)
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(1);
+    });
+    it('should return early with warning when no initial domain mapping provided', async () => {
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, null);
+        expect(mockConsoleWarn).toHaveBeenCalledWith('No initial domain mapping found.');
+        expect(mockAxiosClient.get).not.toHaveBeenCalled();
+        expect(mockAxiosClient.post).not.toHaveBeenCalled();
+    });
+    it('should return early with warning when undefined initial domain mapping provided', async () => {
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, undefined);
+        expect(mockConsoleWarn).toHaveBeenCalledWith('No initial domain mapping found.');
+        expect(mockAxiosClient.get).not.toHaveBeenCalled();
+        expect(mockAxiosClient.post).not.toHaveBeenCalled();
+    });
+    it('should throw error when import slug is missing', async () => {
+        const snapInResponseWithoutImport = {
+            data: {
+                snap_in: {
+                    imports: [],
+                    snap_in_version: { slug: 'snap-in-slug-123' },
+                },
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutImport);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('No import slug or snap-in slug found');
+    });
+    it('should throw error when snap-in slug is missing', async () => {
+        const snapInResponseWithoutSlug = {
+            data: {
+                snap_in: {
+                    imports: [{ name: 'import-slug-123' }],
+                    snap_in_version: {},
+                },
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutSlug);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('No import slug or snap-in slug found');
+    });
+    it('should handle the error during recipe blueprint creation', async () => {
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const genericError = new Error('Generic error during blueprint creation');
+        // Mock axios.isAxiosError to return false
+        mockIsAxiosError.mockReturnValue(false);
+        mockAxiosClient.post.mockRejectedValueOnce(genericError);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping);
+        // Should still proceed with domain mapping installation
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(2);
+    });
+    it('should propagate error from domain mapping installation', async () => {
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        // Mock successful recipe blueprint creation
+        const mockRecipeBlueprintResponse = {
+            data: {
+                recipe_blueprint: {
+                    id: 'recipe-blueprint-123',
+                },
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockRecipeBlueprintResponse);
+        const domainMappingError = new Error('Domain mapping installation failed');
+        mockAxiosClient.post.mockRejectedValueOnce(domainMappingError);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('Domain mapping installation failed');
+    });
+});

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;

package/dist/logger/logger.js

@@ -1,26 +1,29 @@
 "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");
 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,
+            breakLength: Infinity,
+        });
     }
     logFn(args, level) {
         var _a;
@@ -29,14 +32,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,
                 },
             });