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

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

@@ -60,6 +60,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

@@ -46,7 +46,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 +106,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;

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,
                 },
             });

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,
+                breakLength: 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,
+                breakLength: 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,
+                breakLength: 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,
+                breakLength: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.6.0",
+  "version": "1.7.0-beta.0",
   "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": [