@devrev/airsync-sdk 2.0.0-beta.0

package/dist/logger/logger.test.js

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const constants_1 = require("../common/constants");
+const test_helpers_1 = require("../tests/test-helpers");
+const extraction_1 = require("../types/extraction");
+const logger_1 = require("./logger");
+const logger_constants_1 = require("./logger.constants");
+// Mock console methods
+const mockConsoleInfo = jest.spyOn(console, 'info').mockImplementation();
+const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation();
+const mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+// Mock worker_threads for main-thread specific behavior but keep actual Worker implementation
+jest.mock('node:worker_threads', () => {
+    const actual = jest.requireActual('node:worker_threads');
+    return Object.assign(Object.assign({}, actual), { isMainThread: true, parentPort: null });
+});
+describe(logger_1.Logger.name, () => {
+    let mockEvent;
+    let mockOptions;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockEvent = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.StartExtractingData,
+            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();
+    });
+    it('should initialize with event context and SDK version in tags', () => {
+        // Arrange & Act
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Assert
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tags = logger.tags;
+        expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true }));
+    });
+    it('should log string message as JSON with event context tags in production mode', () => {
+        // Arrange
+        const message = 'Worker is online. Started processing the task.';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(message);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true })));
+    });
+    it('should log object message using inspect with proper formatting in production mode', () => {
+        // Arrange
+        const data = { id: 123, name: 'test' };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true })));
+    });
+    it('should join multiple arguments with space when logging in production mode', () => {
+        // Arrange
+        const text = 'Successfully fetched';
+        const data = { count: 42 };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(text, data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true })));
+    });
+    it('should log mixed string and object arguments joined with spaces in production mode', () => {
+        // Arrange
+        const text1 = 'Processing';
+        const data = { id: 123 };
+        const text2 = 'completed';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(text1, data, text2);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true })));
+    });
+    it('should log directly without JSON wrapping in local development mode', () => {
+        // Arrange
+        const message = 'Test message';
+        const data = { test: true };
+        mockOptions.isLocalDevelopment = true;
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedDataMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(message, data);
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledWith(`${message} ${expectedDataMessage}`);
+    });
+    it('should truncate long strings and show remaining character count', () => {
+        // Arrange
+        const longString = 'C'.repeat(20000);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedTruncatedMessage = `${longString.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${20000 - logger_constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+        // Act
+        logger.info(longString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedTruncatedMessage);
+    });
+    it('should not truncate strings shorter than maximum length', () => {
+        // Arrange
+        const shortString = 'Short message';
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(shortString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(shortString);
+    });
+    it('[edge] should not truncate message exactly at maximum length', () => {
+        // Arrange
+        const messageAtLimit = 'A'.repeat(logger_constants_1.MAX_LOG_STRING_LENGTH);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info(messageAtLimit);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(messageAtLimit);
+        expect(logObject.message.length).toBe(logger_constants_1.MAX_LOG_STRING_LENGTH);
+    });
+    it('[edge] should truncate message one character over maximum length', () => {
+        // Arrange
+        const messageOverLimit = 'B'.repeat(logger_constants_1.MAX_LOG_STRING_LENGTH + 1);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = `${messageOverLimit.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... 1 more characters`;
+        // Act
+        logger.info(messageOverLimit);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('[edge] should handle empty string without truncation', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('');
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('');
+    });
+    it('[edge] should show correct character count for very long messages', () => {
+        // Arrange
+        const veryLongString = 'X'.repeat(50000);
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedCharactersRemaining = 50000 - logger_constants_1.MAX_LOG_STRING_LENGTH;
+        const expectedMessage = `${veryLongString.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${expectedCharactersRemaining} more characters`;
+        // Act
+        logger.info(veryLongString);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+        expect(logObject.message).toContain('40000 more characters');
+    });
+    it('should stringify string arguments and join them with spaces', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('Message 1', 'Message 2');
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('Message 1 Message 2');
+    });
+    it('should stringify object arguments using util.inspect', () => {
+        // Arrange
+        const data = { id: 123 };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(data, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(data);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('should call info method for log level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.log('test log');
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+    });
+    it('should call info method for info level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('test info');
+        // Assert
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+    });
+    it('should call warn method for warn level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.warn('test warning');
+        // Assert
+        expect(mockConsoleWarn).toHaveBeenCalledTimes(1);
+    });
+    it('should call error method for error level', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.error('test error');
+        // Assert
+        expect(mockConsoleError).toHaveBeenCalledTimes(1);
+    });
+    it('[edge] should log empty string as valid message with tags', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('');
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('');
+        expect(logObject.sdk_version).toBe(constants_1.LIBRARY_VERSION);
+        expect(logObject.is_sdk_log).toBe(true);
+    });
+    it('[edge] should handle null and undefined values in log arguments', () => {
+        // Arrange
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act
+        logger.info('test', null, undefined);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe('test null undefined');
+    });
+    it('[edge] should handle deeply nested objects with inspect', () => {
+        // Arrange
+        const complexObject = {
+            level1: {
+                level2: {
+                    array: [1, 2, 3],
+                    string: 'nested',
+                },
+            },
+        };
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        const expectedMessage = (0, node_util_1.inspect)(complexObject, logger_constants_1.INSPECT_OPTIONS);
+        // Act
+        logger.info(complexObject);
+        // Assert
+        const callArgs = mockConsoleInfo.mock.calls[0][0];
+        const logObject = JSON.parse(callArgs);
+        expect(logObject.message).toBe(expectedMessage);
+    });
+    it('[edge] should handle circular references in objects', () => {
+        // Arrange
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const circularObject = { name: 'test' };
+        circularObject.self = circularObject;
+        const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
+        // Act & Assert
+        expect(() => logger.info(circularObject)).not.toThrow();
+        expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
+    });
+});
+describe(logger_1.getPrintableState.name, () => {
+    it('should convert arrays to summary objects with type, length, and boundary items', () => {
+        // Arrange
+        const state = {
+            test_key: 'test_value',
+            big_array: Array.from({ length: 1000 }, (_, index) => index),
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            test_key: 'test_value',
+            big_array: {
+                type: 'array',
+                length: 1000,
+                firstItem: 0,
+                lastItem: 999,
+            },
+        });
+    });
+    it('should recursively process nested objects and arrays', () => {
+        // Arrange
+        const state = {
+            test_key: 'test_value',
+            nested_object: {
+                nested_key: 'nested_value',
+                nested_array: Array.from({ length: 1000 }, (_, index) => index),
+            },
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            test_key: 'test_value',
+            nested_object: {
+                nested_key: 'nested_value',
+                nested_array: {
+                    type: 'array',
+                    length: 1000,
+                    firstItem: 0,
+                    lastItem: 999,
+                },
+            },
+        });
+    });
+    it('should preserve primitive values without modification', () => {
+        // Arrange
+        const state = {
+            string_key: 'string_value',
+            number_key: 42,
+            boolean_key: true,
+            null_key: null,
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual(state);
+    });
+    it('[edge] should handle empty arrays with no first or last items', () => {
+        // Arrange
+        const state = {
+            empty_array: [],
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            empty_array: {
+                type: 'array',
+                length: 0,
+                firstItem: undefined,
+                lastItem: undefined,
+            },
+        });
+    });
+    it('[edge] should handle single-item arrays with same first and last item', () => {
+        // Arrange
+        const state = {
+            single_item_array: [42],
+        };
+        // Act
+        const printableState = (0, logger_1.getPrintableState)(state);
+        // Assert
+        expect(printableState).toEqual({
+            single_item_array: {
+                type: 'array',
+                length: 1,
+                firstItem: 42,
+                lastItem: undefined,
+            },
+        });
+    });
+});
+describe(logger_1.serializeAxiosError.name, () => {
+    it('should serialize Axios error with response data', () => {
+        // Arrange
+        const error = {
+            response: {
+                status: 500,
+                statusText: 'Internal Server Error',
+                data: 'Internal server error',
+                headers: { 'content-type': 'application/json' },
+            },
+            config: {
+                method: 'GET',
+                url: '/api/test',
+                params: { id: 123 },
+            },
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: 'GET',
+                params: { id: 123 },
+                url: '/api/test',
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: false,
+            response: {
+                data: 'Internal server error',
+                headers: { 'content-type': 'application/json' },
+                status: 500,
+                statusText: 'Internal Server Error',
+            },
+        });
+    });
+    it('should serialize Axios error without response as CORS or network error', () => {
+        // Arrange
+        const error = {
+            code: 'ERR_NETWORK',
+            message: 'Network Error',
+            config: {
+                method: 'POST',
+                url: '/api/create',
+            },
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: 'POST',
+                params: undefined,
+                url: '/api/create',
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: true,
+            code: 'ERR_NETWORK',
+            message: 'Network Error',
+        });
+    });
+    it('[edge] should handle Axios error with minimal config information', () => {
+        // Arrange
+        const error = {
+            response: {
+                status: 404,
+                data: 'Not Found',
+            },
+            config: {},
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: undefined,
+                params: undefined,
+                url: undefined,
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: false,
+            response: {
+                data: 'Not Found',
+                headers: undefined,
+                status: 404,
+                statusText: undefined,
+            },
+        });
+    });
+    it('[edge] should handle Axios error with no config', () => {
+        // Arrange
+        const error = {
+            code: 'ERR_TIMEOUT',
+            message: 'Request timeout',
+        };
+        // Act
+        const formattedError = (0, logger_1.serializeAxiosError)(error);
+        // Assert
+        expect(formattedError).toEqual({
+            config: {
+                method: undefined,
+                params: undefined,
+                url: undefined,
+            },
+            isAxiosError: true,
+            isCorsOrNoNetworkError: true,
+            code: 'ERR_TIMEOUT',
+            message: 'Request timeout',
+        });
+    });
+});

package/dist/mappers/mappers.d.ts

@@ -0,0 +1,52 @@
+import { AxiosResponse } from 'axios';
+import { MappersCreateParams, MappersCreateResponse, MappersFactoryInterface, MappersGetByExternalIdParams, MappersGetByExternalIdResponse, MappersGetByTargetIdParams, MappersGetByTargetIdResponse, MappersUpdateParams, MappersUpdateResponse } from './mappers.interface';
+/**
+ * Manages sync mapper records that link external system items to DevRev items.
+ *
+ * Used for tracking relationships between external and DevRev entities during sync operations.
+ */
+export declare class Mappers {
+    private devrevApiEndpoint;
+    private devrevApiToken;
+    constructor({ event }: MappersFactoryInterface);
+    /**
+     * Retrieves a sync mapper record by DevRev ID.
+     *
+     * Used to find the mapping when you know the DevRev ID and want to find the external system ID.
+     *
+     * @param params - Query parameters of type MappersGetByTargetIdParams
+     * @returns Promise with response data containing the sync mapper record
+     */
+    getByTargetId(params: MappersGetByTargetIdParams): Promise<AxiosResponse<MappersGetByTargetIdResponse>>;
+    /**
+     * Retrieves a sync mapper record by external system ID.
+     *
+     * Used to find the mapping when you know the external system ID and want to find the DevRev ID.
+     *
+     * @param params - Query parameters of type MappersGetByExternalIdParams
+     * @returns Promise with response data containing the sync mapper record
+     */
+    getByExternalId(params: MappersGetByExternalIdParams): Promise<AxiosResponse<MappersGetByExternalIdResponse>>;
+    /**
+     * Creates a new sync mapper record to establish a relationship between external system
+     * entities and DevRev entities.
+     *
+     * This is called after importing an item from external system to DevRev to record
+     * the mapping for future synchronization operations.
+     *
+     * @param params - Creation parameters of type MappersCreateParams
+     * @returns Promise with response data containing the created sync mapper record
+     */
+    create(params: MappersCreateParams): Promise<AxiosResponse<MappersCreateResponse>>;
+    /**
+     * Updates an existing sync mapper record.
+     *
+     * Used to modify existing mappings when external system entities change or when
+     * additional DevRev entities need to be associated.
+     *
+     * @param params - Update parameters of type MappersUpdateParams
+     * @returns Promise with response data containing the updated sync mapper record
+     */
+    update(params: MappersUpdateParams): Promise<AxiosResponse<MappersUpdateResponse>>;
+}
+//# sourceMappingURL=mappers.d.ts.map

package/dist/mappers/mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../src/mappers/mappers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAAS;gBAEnB,EAAE,KAAK,EAAE,EAAE,uBAAuB;IAK9C;;;;;;;OAOG;IACG,aAAa,CACjB,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,aAAa,CAAC,4BAA4B,CAAC,CAAC;IAavD;;;;;;;OAOG;IACG,eAAe,CACnB,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,aAAa,CAAC,8BAA8B,CAAC,CAAC;IAazD;;;;;;;;;OASG;IACG,MAAM,CACV,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAYhD;;;;;;;;OAQG;IACG,MAAM,CACV,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;CAWjD"}