@forge/teamwork-graph 1.2.0-next.5 → 2.0.0-experimental-8191ad1

package/out/__test__/error-handling.test.js

@@ -1,105 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_fetch_1 = require("node-fetch");
-const error_handling_1 = require("../error-handling");
+const error_handling_1 = require("../utils/error-handling");
 const errors_1 = require("../utils/errors");
-describe('checkResponseError in @forge/teamwork-graph', () => {
-    const traceId = 'trace-id';
-    describe('when response has JSON body', () => {
-        const baseErrorShape = {
-            responseDetails: {
-                status: 400,
-                statusText: 'Bad Request',
-                traceId
-            }
-        };
-        it('should use provided code and message', async () => {
-            const mockResponse = new node_fetch_1.Response(JSON.stringify({ code: 'CUSTOM_ERROR', message: 'Custom error message' }), {
-                status: 400,
-                statusText: 'Bad Request',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse)).rejects.toMatchObject({
-                ...baseErrorShape,
-                code: 'CUSTOM_ERROR',
-                message: 'Custom error message'
-            });
+describe('TeamWorkGraphClient - Error Handling Functions', () => {
+    describe('handleError', () => {
+        test('should handle validation errors correctly', () => {
+            const validationError = new errors_1.ForgeTeamWorkGraphValidationError('Invalid entity data', 'entities');
+            const result = (0, error_handling_1.handleError)(validationError, 'set entities');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid entity data');
+            expect(result.originalError).toBe(validationError);
+            expect(result.results).toBeUndefined();
         });
-        it('should use status-based code when no code provided', async () => {
-            const mockResponse = new node_fetch_1.Response(JSON.stringify({ message: 'Error message' }), {
-                status: 400,
-                statusText: 'Bad Request',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse)).rejects.toMatchObject({
-                ...baseErrorShape,
-                code: errors_1.errorCodes.INVALID_REQUEST_BODY,
-                message: 'Error message'
-            });
+        test('should handle generic errors correctly', () => {
+            const genericError = new Error('Network timeout');
+            const result = (0, error_handling_1.handleError)(genericError, 'delete entities');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Failed to delete entities: Network timeout');
+            expect(result.originalError).toBe(genericError);
+            expect(result.results).toBeUndefined();
         });
-        it('should use default message when no message provided', async () => {
-            const mockResponse = new node_fetch_1.Response(JSON.stringify({ code: 'CUSTOM_ERROR' }), {
-                status: 400,
-                statusText: 'Bad Request',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse, 'Default message')).rejects.toMatchObject({
-                ...baseErrorShape,
-                code: 'CUSTOM_ERROR',
-                message: 'Default message'
-            });
+        test('should handle unknown errors correctly', () => {
+            const unknownError = 'Something went wrong';
+            const result = (0, error_handling_1.handleError)(unknownError, 'fetch data');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Failed to fetch data: Unknown error');
+            expect(result.originalError).toBe(unknownError);
+            expect(result.data).toBeUndefined();
         });
-        it('should include context if provided', async () => {
-            const mockResponse = new node_fetch_1.Response(JSON.stringify({
-                code: 'CUSTOM_ERROR',
-                message: 'Error message',
-                context: { details: 'Additional info' }
-            }), {
-                status: 400,
-                statusText: 'Bad Request',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse)).rejects.toMatchObject({
-                ...baseErrorShape,
-                code: 'CUSTOM_ERROR',
-                message: 'Error message',
-                context: { details: 'Additional info' }
-            });
-        });
-    });
-    describe('when response has invalid or no body', () => {
-        const serverErrorShape = {
-            responseDetails: {
-                status: 500,
-                statusText: 'Internal Server Error',
-                traceId
-            }
-        };
-        it('should handle invalid JSON', async () => {
-            const mockResponse = new node_fetch_1.Response('Invalid JSON', {
-                status: 500,
-                statusText: 'Internal Server Error',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse, 'Default message')).rejects.toMatchObject({
-                ...serverErrorShape,
-                code: errors_1.errorCodes.UNKNOWN_ERROR,
-                message: 'Default message',
-                context: { responseText: 'Invalid JSON' }
-            });
-        });
-        it('should handle empty response', async () => {
-            const mockResponse = new node_fetch_1.Response('', {
-                status: 500,
-                statusText: 'Internal Server Error',
-                headers: { 'x-trace-id': traceId }
-            });
-            await expect((0, error_handling_1.handleResponseError)(mockResponse)).rejects.toMatchObject({
-                ...serverErrorShape,
-                code: errors_1.errorCodes.UNKNOWN_ERROR,
-                message: 'Failed to parse error response',
-                context: { responseText: '' }
-            });
+        test('should work with different response types', () => {
+            const error = new Error('API rate limit exceeded');
+            const bulkResult = (0, error_handling_1.handleError)(error, 'set entities');
+            const deleteResult = (0, error_handling_1.handleError)(error, 'delete entities');
+            const fetchResult = (0, error_handling_1.handleError)(error, 'fetch data');
+            expect(bulkResult.success).toBe(false);
+            expect(deleteResult.success).toBe(false);
+            expect(fetchResult.success).toBe(false);
+            expect(bulkResult.error).toBe('Failed to set entities: API rate limit exceeded');
+            expect(deleteResult.error).toBe('Failed to delete entities: API rate limit exceeded');
+            expect(fetchResult.error).toBe('Failed to fetch data: API rate limit exceeded');
+            expect(bulkResult.originalError).toBe(error);
+            expect(deleteResult.originalError).toBe(error);
+            expect(fetchResult.originalError).toBe(error);
         });
     });
 });

package/out/__test__/graph-extended.test.js

@@ -56,10 +56,15 @@ describe('TeamWorkGraphClient - Extended Features', () => {
             const result = await graphClient.fetchData(request);
             expect(result).toEqual({
                 success: false,
-                error: 'Remote call failed with status: 401'
+                error: 'Remote call failed with status: 401',
+                originalError: expect.any(Error)
             });
             expect(request.onResult).not.toHaveBeenCalled();
         });
+        it('should throw error for validation errors', async () => {
+            const request = {};
+            await expect(graphClient.fetchData(request)).rejects.toThrow('requestConfig is required and must be an object');
+        });
     });
     describe('transformData', () => {
         it('should transform data using the provided transform method', async () => {
@@ -96,8 +101,13 @@ describe('TeamWorkGraphClient - Extended Features', () => {
             const result = await graphClient.transformData(request);
             expect(result).toEqual({
                 success: false,
-                error: 'Transform failed'
+                error: 'Transform failed',
+                originalError: expect.any(Error)
             });
         });
+        it('should throw error for validation errors', async () => {
+            const request = {};
+            await expect(graphClient.transformData(request)).rejects.toThrow('transformMethod is required and must be a function');
+        });
     });
 });

package/out/__test__/group-operations.test.js

@@ -91,7 +91,7 @@ describe('TeamWorkGraphClient - Group Operations', () => {
             const manyGroups = Array(validators_1.MAX_BULK_GROUPS + 1).fill(groupPayload);
             await expect(graphClient.setGroups({
                 groups: manyGroups
-            })).rejects.toThrow(`Bulk group ingestion supports maximum ${validators_1.MAX_BULK_GROUPS} groups`);
+            })).rejects.toThrow(`Bulk group ingestion supports maximum ${validators_1.MAX_BULK_GROUPS} groups. Received ${validators_1.MAX_BULK_GROUPS + 1}`);
         });
         it('should throw error when groups is not an array', async () => {
             await expect(graphClient.setGroups({
@@ -182,10 +182,10 @@ describe('TeamWorkGraphClient - Group Operations', () => {
                 headers: {
                     get: () => null
                 },
-                text: () => Promise.resolve(JSON.stringify({
+                json: () => Promise.resolve({
                     code: 'GROUP_NOT_FOUND',
                     message: 'Group not found'
-                }))
+                })
             };
             mockFetch.mockResolvedValueOnce(errorResponse);
             const result = await graphClient.getGroupByExternalId({
@@ -193,7 +193,8 @@ describe('TeamWorkGraphClient - Group Operations', () => {
             });
             expect(result).toEqual({
                 success: false,
-                error: 'Group not found'
+                error: 'Failed to get group by external ID: Not Found - Group not found',
+                originalError: expect.any(Error)
             });
         });
         it('should throw error when externalId is missing', async () => {

package/out/__test__/user-operations.test.js

@@ -70,7 +70,12 @@ describe('TeamWorkGraphClient - User Operations', () => {
             const manyUsers = Array(validators_1.MAX_BULK_USERS + 1).fill(userPayload);
             await expect(graphClient.setUsers({
                 users: manyUsers
-            })).rejects.toThrow(`Bulk user ingestion supports maximum ${validators_1.MAX_BULK_USERS} users`);
+            })).rejects.toThrow(`Bulk user ingestion supports maximum ${validators_1.MAX_BULK_USERS} users. Received ${validators_1.MAX_BULK_USERS + 1}`);
+        });
+        it('should throw error when users is not an array', async () => {
+            await expect(graphClient.setUsers({
+                users: null
+            })).rejects.toThrow('users must be an array');
         });
     });
     describe('deleteUsersByExternalId', () => {
@@ -102,6 +107,11 @@ describe('TeamWorkGraphClient - User Operations', () => {
                 externalIds: []
             })).rejects.toThrow('externalIds array cannot be empty');
         });
+        it('should throw error when externalIds is not an array', async () => {
+            await expect(graphClient.deleteUsersByExternalId({
+                externalIds: null
+            })).rejects.toThrow('externalIds must be an array');
+        });
     });
     describe('getUserByExternalId', () => {
         const expectedUser = {
@@ -155,10 +165,10 @@ describe('TeamWorkGraphClient - User Operations', () => {
                 headers: {
                     get: () => null
                 },
-                text: () => Promise.resolve(JSON.stringify({
+                json: () => Promise.resolve({
                     code: 'USER_NOT_FOUND',
                     message: 'User not found'
-                }))
+                })
             };
             mockFetch.mockResolvedValueOnce(errorResponse);
             const result = await graphClient.getUserByExternalId({
@@ -166,7 +176,8 @@ describe('TeamWorkGraphClient - User Operations', () => {
             });
             expect(result).toEqual({
                 success: false,
-                error: 'User not found'
+                error: 'Failed to get user by external ID: Not Found - User not found',
+                originalError: expect.any(Error)
             });
         });
         it('should throw error when externalId is missing', async () => {
@@ -260,7 +271,7 @@ describe('TeamWorkGraphClient - User Operations', () => {
             const manyMappings = Array(validators_1.MAX_USER_MAPPINGS + 1).fill(mappingWithAccountId);
             await expect(graphClient.mapUsers({
                 directMappings: manyMappings
-            })).rejects.toThrow(`Bulk user mapping supports maximum ${validators_1.MAX_USER_MAPPINGS} mappings`);
+            })).rejects.toThrow(`Bulk user mapping supports maximum ${validators_1.MAX_USER_MAPPINGS} mappings. Received ${validators_1.MAX_USER_MAPPINGS + 1}`);
         });
         it('should throw error when directMappings is not an array', async () => {
             await expect(graphClient.mapUsers({