@devrev/typescript-sdk 1.1.51 → 1.1.53

package/dist/snap-ins/beta-devrev-sdk-util.d.ts

@@ -0,0 +1,9 @@
+import { betaSDK } from '../index';
+import { FileObject } from './util-types';
+export declare class BetaSdkUtil {
+    private readonly devrevSdk;
+    constructor(devrevSdk: betaSDK.Api<unknown>);
+    getAllRevUsersFromAccount(accountId: string): Promise<betaSDK.RevUser[] | undefined>;
+    getFileContentFromArtifact(artifactId: string): Promise<any | undefined>;
+    uploadFileToArtifact(fileObject: FileObject): Promise<string | undefined>;
+}

package/dist/snap-ins/beta-devrev-sdk-util.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetaSdkUtil = void 0;
+const axios_1 = __importStar(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const stream_1 = require("stream");
+const util_1 = require("./constants/util");
+const error_1 = require("./error");
+class BetaSdkUtil {
+    constructor(devrevSdk) {
+        this.devrevSdk = devrevSdk;
+    }
+    getAllRevUsersFromAccount(accountId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const revUserListPayload = {
+                    associations: [accountId],
+                };
+                const revUsers = [];
+                do {
+                    const revUserListResponse = yield this.devrevSdk.revUsersList(revUserListPayload);
+                    if (!revUserListResponse.data.rev_users || revUserListResponse.data.rev_users.length === 0)
+                        break;
+                    revUsers.push(...revUserListResponse.data.rev_users);
+                    revUserListPayload.cursor = revUserListResponse.data.next_cursor;
+                } while (revUserListPayload.cursor);
+                return revUsers;
+            }
+            catch (error) {
+                (0, error_1.handleApiError)(error);
+            }
+        });
+    }
+    getFileContentFromArtifact(artifactId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.devrevSdk.artifactsLocate({
+                    id: artifactId,
+                });
+                const artifactData = response.data.url;
+                const fileContentResponse = yield axios_1.default.get(artifactData);
+                return fileContentResponse.data;
+            }
+            catch (error) {
+                (0, error_1.handleApiError)(error);
+            }
+        });
+    }
+    uploadFileToArtifact(fileObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stream = new stream_1.Readable();
+            try {
+                if (fileObject.file_type === util_1.MIMETypes.OTHERS && !fileObject.custom_file_type) {
+                    throw new axios_1.AxiosError('Custom file type is required for OTHERS file type');
+                }
+                const fileType = fileObject.file_type === util_1.MIMETypes.OTHERS && fileObject.custom_file_type
+                    ? fileObject.custom_file_type
+                    : fileObject.file_type;
+                const response = yield this.devrevSdk.artifactsPrepare({
+                    file_name: fileObject.file_name,
+                    file_type: fileType,
+                });
+                const { url, form_data: formData, id } = response.data;
+                const form = new form_data_1.default();
+                for (const data of formData) {
+                    form.append(data.key, data.value);
+                }
+                stream.push(fileObject.file);
+                stream.push(null);
+                form.append('file', stream, {
+                    filename: url,
+                    knownLength: stream.readableLength,
+                });
+                yield axios_1.default.post(url, form, undefined);
+                return id;
+            }
+            catch (error) {
+                (0, error_1.handleApiError)(error);
+            }
+            finally {
+                stream.destroy();
+            }
+        });
+    }
+}
+exports.BetaSdkUtil = BetaSdkUtil;

package/dist/snap-ins/constants/error.d.ts

@@ -0,0 +1,5 @@
+export declare const UNKNOWN_TYPE: string;
+export declare const UNKNOWN_FUNCTION: string;
+export declare const UNKNOWN_MESSAGE: string;
+export declare const UNKNOWN_STATUS: number;
+export declare const UNKNOWN_URL: string;

package/dist/snap-ins/constants/error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN_URL = exports.UNKNOWN_STATUS = exports.UNKNOWN_MESSAGE = exports.UNKNOWN_FUNCTION = exports.UNKNOWN_TYPE = void 0;
+exports.UNKNOWN_TYPE = 'unknown_type';
+exports.UNKNOWN_FUNCTION = 'unknown_function';
+exports.UNKNOWN_MESSAGE = 'An unknown error occurred';
+exports.UNKNOWN_STATUS = 500;
+exports.UNKNOWN_URL = 'unknown_url';

package/dist/snap-ins/constants/util.d.ts

@@ -0,0 +1,12 @@
+export declare enum MIMETypes {
+    CSV = "text/csv",
+    HTML = "text/html",
+    JPEG = "image/jpeg",
+    JSON = "application/json",
+    PDF = "application/pdf",
+    PNG = "image/png",
+    TXT = "text/plain",
+    RTE = "devrev/rt",
+    XML = "application/xml",
+    OTHERS = "others"
+}

package/dist/snap-ins/constants/util.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIMETypes = void 0;
+var MIMETypes;
+(function (MIMETypes) {
+    MIMETypes["CSV"] = "text/csv";
+    MIMETypes["HTML"] = "text/html";
+    MIMETypes["JPEG"] = "image/jpeg";
+    MIMETypes["JSON"] = "application/json";
+    MIMETypes["PDF"] = "application/pdf";
+    MIMETypes["PNG"] = "image/png";
+    MIMETypes["TXT"] = "text/plain";
+    MIMETypes["RTE"] = "devrev/rt";
+    MIMETypes["XML"] = "application/xml";
+    MIMETypes["OTHERS"] = "others";
+})(MIMETypes = exports.MIMETypes || (exports.MIMETypes = {}));

package/dist/snap-ins/error.d.ts

@@ -0,0 +1 @@
+export declare const handleApiError: (error: unknown) => void;

package/dist/snap-ins/error.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = void 0;
+const axios_1 = require("axios");
+const error_1 = require("./constants/error");
+const getCallerName = (error) => {
+    if (!error.stack) {
+        return error_1.UNKNOWN_FUNCTION;
+    }
+    const stackLines = error.stack.split('\n');
+    const callerLine = stackLines[stackLines.length - 2];
+    const callerMatch = callerLine.match(/at async\s+(\S+)/);
+    return callerMatch ? callerMatch[1] : error_1.UNKNOWN_FUNCTION;
+};
+const handleApiError = (error) => {
+    const errorDetails = {
+        api: error_1.UNKNOWN_URL,
+        function_name: error_1.UNKNOWN_FUNCTION,
+        message: error_1.UNKNOWN_MESSAGE,
+        status: error_1.UNKNOWN_STATUS,
+        type: error_1.UNKNOWN_TYPE,
+    };
+    if (error instanceof axios_1.AxiosError && error.response) {
+        errorDetails.api = error.response.config.url || error_1.UNKNOWN_URL;
+        errorDetails.function_name = getCallerName(error) || error_1.UNKNOWN_FUNCTION;
+        errorDetails.message = error.response.data.message || error_1.UNKNOWN_MESSAGE;
+        errorDetails.type = error.response.data.type || error_1.UNKNOWN_TYPE;
+        errorDetails.status = error.response.status || error_1.UNKNOWN_STATUS;
+    }
+    const logMessage = [
+        '\n=== Error Details ===',
+        `Service: ${errorDetails.function_name}`,
+        `API: ${errorDetails.api}`,
+        `Error Type: ${errorDetails.type}`,
+        `Status Code: ${errorDetails.status}`,
+        `Message: ${errorDetails.message}`,
+    ].filter(Boolean).join('\n');
+    console.error(logMessage);
+    return;
+};
+exports.handleApiError = handleApiError;

package/dist/snap-ins/util-types.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { betaSDK, publicSDK } from "../index";
+import { MIMETypes } from "./constants/util";
+export type FileObject = {
+    file_name: string;
+    file_type: MIMETypes;
+    file: Buffer;
+    custom_file_type?: string;
+};
+export type ErrorDetails = (betaSDK.Error | publicSDK.Error) & {
+    api: string;
+    function_name: string;
+};

package/dist/snap-ins/util-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests/beta-devrev-sdk-util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/beta-devrev-sdk-util.test.js

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('axios');
+jest.mock('form-data');
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const stream_1 = require("stream");
+const util_1 = require("../snap-ins/constants/util");
+const beta_devrev_sdk_util_1 = require("../snap-ins/beta-devrev-sdk-util");
+describe('BetaSDKUtil', () => {
+    let mockDevrevBetaSdk;
+    let betaSDKUtil;
+    beforeEach(() => {
+        mockDevrevBetaSdk = {
+            revUsersList: jest.fn(),
+            artifactsLocate: jest.fn(),
+            artifactsPrepare: jest.fn(),
+        };
+        betaSDKUtil = new beta_devrev_sdk_util_1.BetaSdkUtil(mockDevrevBetaSdk);
+        jest.clearAllMocks();
+    });
+    describe('getAllRevUsersFromAccount', () => {
+        it('should retrieve all rev users for a given account', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRevUsers1 = [
+                { id: '1', display_name: 'User 1' },
+                { id: '2', display_name: 'User 2' },
+            ];
+            const mockRevUsers2 = [
+                { id: '3', display_name: 'User 3' },
+                { id: '4', display_name: 'User 4' },
+            ];
+            mockDevrevBetaSdk.revUsersList
+                .mockResolvedValueOnce({
+                data: {
+                    rev_users: mockRevUsers1,
+                    next_cursor: 'cursor1',
+                },
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    rev_users: mockRevUsers2,
+                    next_cursor: null,
+                },
+            });
+            const result = yield betaSDKUtil.getAllRevUsersFromAccount('accountId');
+            expect(result).toEqual([...mockRevUsers1, ...mockRevUsers2]);
+        }));
+        it('should handle empty response from API', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockDevrevBetaSdk.revUsersList.mockResolvedValueOnce({
+                data: {
+                    rev_users: [],
+                    next_cursor: null,
+                },
+            });
+            const result = yield betaSDKUtil.getAllRevUsersFromAccount('accountId');
+            expect(result).toEqual([]);
+            expect(mockDevrevBetaSdk.revUsersList).toHaveBeenCalledTimes(1);
+        }));
+        it('should handle null response from API', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockDevrevBetaSdk.revUsersList.mockResolvedValueOnce({
+                data: {
+                    rev_users: null,
+                    next_cursor: null,
+                },
+            });
+            const result = yield betaSDKUtil.getAllRevUsersFromAccount('accountId');
+            expect(result).toEqual([]);
+            expect(mockDevrevBetaSdk.revUsersList).toHaveBeenCalledTimes(1);
+        }));
+    });
+    describe('getFileContentFromArtifact', () => {
+        it('should retrieve file content from an artifact', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockArtifactUrl = 'https://example.com/artifact';
+            const mockFileContent = { data: 'File content' };
+            mockDevrevBetaSdk.artifactsLocate.mockResolvedValue({
+                data: { url: mockArtifactUrl },
+            });
+            axios_1.default.get.mockResolvedValue({
+                data: mockFileContent,
+            });
+            const result = yield betaSDKUtil.getFileContentFromArtifact('artifactId');
+            expect(result).toEqual(mockFileContent);
+            expect(mockDevrevBetaSdk.artifactsLocate).toHaveBeenCalledWith({
+                id: 'artifactId',
+            });
+            expect(axios_1.default.get).toHaveBeenCalledWith(mockArtifactUrl);
+        }));
+        it('should handle artifact location failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockDevrevBetaSdk.artifactsLocate.mockRejectedValue(new Error('Failed to locate artifact'));
+            const result = yield betaSDKUtil.getFileContentFromArtifact('artifactId');
+            expect(result).toBeUndefined();
+            expect(mockDevrevBetaSdk.artifactsLocate).toHaveBeenCalledWith({
+                id: 'artifactId',
+            });
+            expect(axios_1.default.get).not.toHaveBeenCalled();
+        }));
+    });
+    describe('uploadFileToArtifact', () => {
+        it('should upload file with specific file type successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFileObject = {
+                file_name: 'test.json',
+                file_type: util_1.MIMETypes.JSON,
+                file: Buffer.from('test content'),
+            };
+            const mockPrepareResponse = {
+                data: {
+                    url: 'https://example.com/upload',
+                    form_data: [
+                        { key: 'key1', value: 'value1' },
+                        { key: 'key2', value: 'value2' },
+                    ],
+                    id: 'artifactId',
+                },
+            };
+            mockDevrevBetaSdk.artifactsPrepare.mockResolvedValue(mockPrepareResponse);
+            axios_1.default.post.mockResolvedValue({});
+            const result = yield betaSDKUtil.uploadFileToArtifact(mockFileObject);
+            expect(result).toBe('artifactId');
+            expect(mockDevrevBetaSdk.artifactsPrepare).toHaveBeenCalledWith({
+                file_name: 'test.json',
+                file_type: util_1.MIMETypes.JSON,
+            });
+        }));
+        it('should upload file with custom file type successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFileObject = {
+                file_name: 'test.custom',
+                file_type: util_1.MIMETypes.OTHERS,
+                custom_file_type: 'custom/type',
+                file: Buffer.from('test content'),
+            };
+            const mockPrepareResponse = {
+                data: {
+                    url: 'https://example.com/upload',
+                    form_data: [{ key: 'key1', value: 'value1' }],
+                    id: 'artifactId',
+                },
+            };
+            mockDevrevBetaSdk.artifactsPrepare.mockResolvedValue(mockPrepareResponse);
+            axios_1.default.post.mockResolvedValue({});
+            const result = yield betaSDKUtil.uploadFileToArtifact(mockFileObject);
+            expect(result).toBe('artifactId');
+            expect(mockDevrevBetaSdk.artifactsPrepare).toHaveBeenCalledWith({
+                file_name: 'test.custom',
+                file_type: 'custom/type',
+            });
+        }));
+        it('should handle file upload failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFileObject = {
+                file_name: 'test.json',
+                file_type: util_1.MIMETypes.JSON,
+                file: Buffer.from('test content'),
+            };
+            mockDevrevBetaSdk.artifactsPrepare.mockResolvedValue({
+                data: {
+                    url: 'https://example.com/upload',
+                    form_data: [{ key: 'key1', value: 'value1' }],
+                    id: 'artifactId',
+                },
+            });
+            axios_1.default.post.mockRejectedValue(new Error('Upload failed'));
+            const result = yield betaSDKUtil.uploadFileToArtifact(mockFileObject);
+            expect(result).toBeUndefined();
+        }));
+        it('should handle artifact prepare failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFileObject = {
+                file_name: 'test.json',
+                file_type: util_1.MIMETypes.JSON,
+                file: Buffer.from('test content'),
+            };
+            mockDevrevBetaSdk.artifactsPrepare.mockRejectedValue(new Error('Prepare failed'));
+            const result = yield betaSDKUtil.uploadFileToArtifact(mockFileObject);
+            expect(result).toBeUndefined();
+            expect(axios_1.default.post).not.toHaveBeenCalled();
+        }));
+        it('should validate FormData creation and stream handling', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFileObject = {
+                file_name: 'test.json',
+                file_type: util_1.MIMETypes.JSON,
+                file: Buffer.from('test content'),
+            };
+            const mockPrepareResponse = {
+                data: {
+                    url: 'https://example.com/upload',
+                    form_data: [{ key: 'key1', value: 'value1' }],
+                    id: 'artifactId',
+                },
+            };
+            mockDevrevBetaSdk.artifactsPrepare.mockResolvedValue(mockPrepareResponse);
+            axios_1.default.post.mockResolvedValue({});
+            const result = yield betaSDKUtil.uploadFileToArtifact(mockFileObject);
+            expect(result).toBe('artifactId');
+            // Verify FormData handling
+            expect(form_data_1.default).toHaveBeenCalled();
+            const formDataInstance = form_data_1.default.mock.instances[0];
+            expect(formDataInstance.append).toHaveBeenCalledWith('key1', 'value1');
+            expect(formDataInstance.append).toHaveBeenCalledWith('file', expect.any(stream_1.Readable), expect.any(Object));
+        }));
+    });
+});

package/dist/tests/error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/error.test.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const error_1 = require("../snap-ins/constants/error");
+const error_2 = require("../snap-ins/error");
+// Mock console.error to prevent actual console logs during tests
+const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => { });
+describe('handleApiError', () => {
+    beforeEach(() => {
+        // Clear mock calls before each test
+        mockConsoleError.mockClear();
+    });
+    afterAll(() => {
+        // Restore original console.error after all tests
+        mockConsoleError.mockRestore();
+    });
+    it('should handle valid AxiosError with complete response data', () => {
+        const mockAxiosError = new axios_1.AxiosError();
+        mockAxiosError.response = {
+            config: {
+                url: 'https://api.example.com/users',
+                headers: {},
+            },
+            data: {
+                message: 'User not found',
+                type: 'NOT_FOUND',
+            },
+            status: 404,
+            statusText: 'Not Found',
+            headers: {},
+        };
+        mockAxiosError.stack = '\nError: Request failed\nat process ticks\nat async getUserData\nat processRequest';
+        (0, error_2.handleApiError)(mockAxiosError);
+        // Expected log message
+        const expectedLog = [
+            '\n=== Error Details ===',
+            'Service: getUserData',
+            'API: https://api.example.com/users',
+            'Error Type: NOT_FOUND',
+            'Status Code: 404',
+            'Message: User not found',
+        ].join('\n');
+        // Verify exact match of console.error message
+        expect(mockConsoleError).toHaveBeenCalledWith(expectedLog);
+    });
+    it('should handle AxiosError with missing response data', () => {
+        const mockAxiosError = new axios_1.AxiosError();
+        mockAxiosError.response = {
+            config: { headers: {} },
+            data: {},
+            status: 500,
+            statusText: 'Internal Server Error',
+            headers: {},
+        };
+        (0, error_2.handleApiError)(mockAxiosError);
+        const expectedLog = [
+            '\n=== Error Details ===',
+            `Service: runTestInternal`,
+            `API: ${error_1.UNKNOWN_URL}`,
+            `Error Type: ${error_1.UNKNOWN_TYPE}`,
+            'Status Code: 500',
+            `Message: ${error_1.UNKNOWN_MESSAGE}`,
+        ].join('\n');
+        expect(mockConsoleError).toHaveBeenCalledWith(expectedLog);
+    });
+    it('should handle non-AxiosError', () => {
+        const regularError = new Error('Regular error');
+        (0, error_2.handleApiError)(regularError);
+        const expectedLog = [
+            '\n=== Error Details ===',
+            `Service: ${error_1.UNKNOWN_FUNCTION}`,
+            `API: ${error_1.UNKNOWN_URL}`,
+            `Error Type: ${error_1.UNKNOWN_TYPE}`,
+            `Status Code: ${error_1.UNKNOWN_STATUS}`,
+            `Message: ${error_1.UNKNOWN_MESSAGE}`,
+        ].join('\n');
+        expect(mockConsoleError).toHaveBeenCalledWith(expectedLog);
+    });
+    it('should handle undefined error', () => {
+        (0, error_2.handleApiError)(undefined);
+        const expectedLog = [
+            '\n=== Error Details ===',
+            `Service: ${error_1.UNKNOWN_FUNCTION}`,
+            `API: ${error_1.UNKNOWN_URL}`,
+            `Error Type: ${error_1.UNKNOWN_TYPE}`,
+            `Status Code: ${error_1.UNKNOWN_STATUS}`,
+            `Message: ${error_1.UNKNOWN_MESSAGE}`,
+        ].join('\n');
+        expect(mockConsoleError).toHaveBeenCalledWith(expectedLog);
+    });
+    it('should handle AxiosError with missing stack trace', () => {
+        const mockAxiosError = new axios_1.AxiosError();
+        mockAxiosError.response = {
+            config: {
+                url: 'https://api.example.com/users',
+                headers: {},
+            },
+            data: {
+                message: 'User not found',
+                type: 'NOT_FOUND',
+            },
+            status: 404,
+            statusText: 'Not Found',
+            headers: {},
+        };
+        mockAxiosError.stack = undefined;
+        (0, error_2.handleApiError)(mockAxiosError);
+        const expectedLog = [
+            '\n=== Error Details ===',
+            `Service: ${error_1.UNKNOWN_FUNCTION}`,
+            'API: https://api.example.com/users',
+            'Error Type: NOT_FOUND',
+            'Status Code: 404',
+            'Message: User not found',
+        ].join('\n');
+        expect(mockConsoleError).toHaveBeenCalledWith(expectedLog);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/typescript-sdk",
-  "version": "1.1.51",
+  "version": "1.1.53",
   "description": "## SDK Generation",
   "main": "./dist/index.js",
   "scripts": {