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

package/out/__test__/validators.test.js

@@ -1,329 +1,365 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const validators_1 = require("../utils/validators");
+const errors_1 = require("../utils/errors");
 describe('TeamWorkGraphClient - Validators', () => {
-    describe('validateArray', () => {
-        it('should pass for valid array', () => {
-            expect(() => (0, validators_1.validateArray)([1, 2, 3], 'test')).not.toThrow();
-        });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateArray)('not an array', 'test')).toThrow('test must be an array');
-        });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateArray)([], 'test')).toThrow('test array cannot be empty');
-        });
-        it('should throw for null', () => {
-            expect(() => (0, validators_1.validateArray)(null, 'test')).toThrow('test must be an array');
-        });
-        it('should throw for undefined', () => {
-            expect(() => (0, validators_1.validateArray)(undefined, 'test')).toThrow('test must be an array');
-        });
-    });
-    describe('validateArrayMaxLength', () => {
-        it('should pass for array within limit', () => {
-            expect(() => (0, validators_1.validateArrayMaxLength)([1, 2], 'test', 5)).not.toThrow();
-        });
-        it('should pass for array at limit', () => {
-            expect(() => (0, validators_1.validateArrayMaxLength)([1, 2, 3], 'test', 3)).not.toThrow();
-        });
-        it('should throw for array exceeding limit', () => {
-            expect(() => (0, validators_1.validateArrayMaxLength)([1, 2, 3, 4], 'test', 3)).toThrow('test supports maximum 3 items. Received 4');
-        });
-    });
-    describe('validateRequiredString', () => {
-        it('should pass for valid string', () => {
-            expect(() => (0, validators_1.validateRequiredString)('valid string', 'test')).not.toThrow();
-        });
-        it('should throw for empty string', () => {
-            expect(() => (0, validators_1.validateRequiredString)('', 'test')).toThrow('test is required');
-        });
-        it('should throw for whitespace string', () => {
-            expect(() => (0, validators_1.validateRequiredString)('   ', 'test')).toThrow('test is required');
-        });
-        it('should throw for null', () => {
-            expect(() => (0, validators_1.validateRequiredString)(null, 'test')).toThrow('test is required');
-        });
-        it('should throw for undefined', () => {
-            expect(() => (0, validators_1.validateRequiredString)(undefined, 'test')).toThrow('test is required');
-        });
-    });
-    describe('validateObject', () => {
-        it('should pass for valid object', () => {
-            expect(() => (0, validators_1.validateObject)({ key: 'value' }, 'test')).not.toThrow();
-        });
-        it('should throw for null', () => {
-            expect(() => (0, validators_1.validateObject)(null, 'test')).toThrow('test must be an object');
-        });
-        it('should throw for undefined', () => {
-            expect(() => (0, validators_1.validateObject)(undefined, 'test')).toThrow('test must be an object');
-        });
-        it('should throw for non-object', () => {
-            expect(() => (0, validators_1.validateObject)('not an object', 'test')).toThrow('test must be an object');
-        });
-        it('should throw for empty object', () => {
-            expect(() => (0, validators_1.validateObject)({}, 'test')).toThrow('test object cannot be empty');
-        });
-    });
     describe('validateSetEntitiesRequest', () => {
-        it('should pass for valid entities array', () => {
-            const entities = Array(validators_1.MAX_BULK_ENTITIES).fill({ id: 'test' });
+        it('should pass with valid entities array', () => {
+            const entities = [{ id: '1', name: 'Entity 1' }];
             expect(() => (0, validators_1.validateSetEntitiesRequest)(entities)).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateSetEntitiesRequest)('not array')).toThrow('entities must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateSetEntitiesRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetEntitiesRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetEntitiesRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateSetEntitiesRequest)([])).toThrow('entities array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateSetEntitiesRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for array exceeding limit', () => {
-            const entities = Array(validators_1.MAX_BULK_ENTITIES + 1).fill({ id: 'test' });
-            expect(() => (0, validators_1.validateSetEntitiesRequest)(entities)).toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_ENTITIES} entities. Received ${validators_1.MAX_BULK_ENTITIES + 1}`);
+        it('should throw validation error for array exceeding max length', () => {
+            const entities = Array(validators_1.MAX_BULK_ENTITIES + 1).fill({ id: '1', name: 'Entity' });
+            expect(() => (0, validators_1.validateSetEntitiesRequest)(entities)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateSetUsersRequest', () => {
-        it('should pass for valid users array', () => {
-            const users = Array(validators_1.MAX_BULK_USERS).fill({ id: 'test' });
+        it('should pass with valid users array', () => {
+            const users = [{ id: '1', name: 'User 1' }];
             expect(() => (0, validators_1.validateSetUsersRequest)(users)).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateSetUsersRequest)('not array')).toThrow('users must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateSetUsersRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetUsersRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetUsersRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateSetUsersRequest)([])).toThrow('users array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateSetUsersRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for array exceeding limit', () => {
-            const users = Array(validators_1.MAX_BULK_USERS + 1).fill({ id: 'test' });
-            expect(() => (0, validators_1.validateSetUsersRequest)(users)).toThrow(`Bulk user ingestion supports maximum ${validators_1.MAX_BULK_USERS} users. Received ${validators_1.MAX_BULK_USERS + 1}`);
+        it('should throw validation error for array exceeding max length', () => {
+            const users = Array(validators_1.MAX_BULK_USERS + 1).fill({ id: '1', name: 'User' });
+            expect(() => (0, validators_1.validateSetUsersRequest)(users)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateSetGroupsRequest', () => {
-        it('should pass for valid groups array', () => {
-            const groups = Array(validators_1.MAX_BULK_GROUPS).fill({ id: 'test' });
+        it('should pass with valid groups array', () => {
+            const groups = [{ id: '1', name: 'Group 1' }];
             expect(() => (0, validators_1.validateSetGroupsRequest)(groups)).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateSetGroupsRequest)('not array')).toThrow('groups must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateSetGroupsRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetGroupsRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateSetGroupsRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateSetGroupsRequest)([])).toThrow('groups array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateSetGroupsRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for array exceeding limit', () => {
-            const groups = Array(validators_1.MAX_BULK_GROUPS + 1).fill({ id: 'test' });
-            expect(() => (0, validators_1.validateSetGroupsRequest)(groups)).toThrow(`Bulk group ingestion supports maximum ${validators_1.MAX_BULK_GROUPS} groups. Received ${validators_1.MAX_BULK_GROUPS + 1}`);
+        it('should throw validation error for array exceeding max length', () => {
+            const groups = Array(validators_1.MAX_BULK_GROUPS + 1).fill({ id: '1', name: 'Group' });
+            expect(() => (0, validators_1.validateSetGroupsRequest)(groups)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateDeleteEntitiesByExternalIdRequest', () => {
-        it('should pass for valid request', () => {
-            const entityType = 'test-type';
-            const externalIds = Array(validators_1.MAX_BULK_ENTITIES_DELETE).fill('test-id');
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)(entityType, externalIds)).not.toThrow();
+        it('should pass with valid parameters', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('issue', ['1', '2'])).not.toThrow();
         });
-        it('should throw for empty entityType', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('', ['test'])).toThrow('entityType is required');
+        it('should throw validation error for empty entityType', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('', ['1'])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('   ', ['1'])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for whitespace entityType', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('   ', ['test'])).toThrow('entityType is required');
+        it('should throw validation error for non-array externalIds', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('issue', 'invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('issue', null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-array externalIds', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('type', 'not array')).toThrow('externalIds must be an array');
+        it('should throw validation error for empty externalIds array', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('issue', [])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty externalIds array', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('type', [])).toThrow('externalIds array cannot be empty');
-        });
-        it('should throw for externalIds exceeding limit', () => {
-            const externalIds = Array(validators_1.MAX_BULK_ENTITIES_DELETE + 1).fill('test-id');
-            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('type', externalIds)).toThrow(`Bulk entity deletion supports maximum ${validators_1.MAX_BULK_ENTITIES_DELETE} entities. Received ${validators_1.MAX_BULK_ENTITIES_DELETE + 1}`);
+        it('should throw validation error for array exceeding max length', () => {
+            const externalIds = Array(validators_1.MAX_BULK_ENTITIES_DELETE + 1).fill('id');
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('issue', externalIds)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateDeleteUsersByExternalIdRequest', () => {
-        it('should pass for valid externalIds array', () => {
-            const externalIds = ['id1', 'id2'];
-            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)(externalIds)).not.toThrow();
+        it('should pass with valid externalIds array', () => {
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)(['1', '2'])).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)('not array')).toThrow('externalIds must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)([])).toThrow('externalIds array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateDeleteGroupsByExternalIdRequest', () => {
-        it('should pass for valid externalIds array', () => {
-            const externalIds = ['id1', 'id2'];
-            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)(externalIds)).not.toThrow();
+        it('should pass with valid externalIds array', () => {
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)(['1', '2'])).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)('not array')).toThrow('externalIds must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)([])).toThrow('externalIds array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateGetEntityByExternalIdRequest', () => {
-        it('should pass for valid request', () => {
-            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('type', 'id')).not.toThrow();
+        it('should pass with valid parameters', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('issue', '123')).not.toThrow();
         });
-        it('should throw for empty entityType', () => {
-            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('', 'id')).toThrow('entityType is required');
+        it('should throw validation error for empty entityType', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('', '123')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('   ', '123')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty externalId', () => {
-            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('type', '')).toThrow('externalId is required');
+        it('should throw validation error for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('issue', '')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('issue', '   ')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateGetUserByExternalIdRequest', () => {
-        it('should pass for valid externalId', () => {
-            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('valid-id')).not.toThrow();
+        it('should pass with valid externalId', () => {
+            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('123')).not.toThrow();
         });
-        it('should throw for empty externalId', () => {
-            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('')).toThrow('externalId is required');
+        it('should throw validation error for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('   ')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateGetGroupByExternalIdRequest', () => {
-        it('should pass for valid externalId', () => {
-            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('valid-id')).not.toThrow();
+        it('should pass with valid externalId', () => {
+            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('123')).not.toThrow();
         });
-        it('should throw for empty externalId', () => {
-            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('')).toThrow('externalId is required');
+        it('should throw validation error for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('   ')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateMapUsersRequest', () => {
-        it('should pass for valid mappings', () => {
-            const directMappings = [
-                { externalId: 'id1', accountId: 'acc1' },
-                { externalId: 'id2', externalEmailAddress: 'email@test.com' }
+        it('should pass with valid mappings', () => {
+            const mappings = [
+                { externalId: '1', accountId: 'acc1' },
+                { externalId: '2', externalEmailAddress: 'user@example.com' }
             ];
-            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).not.toThrow();
+            expect(() => (0, validators_1.validateMapUsersRequest)(mappings)).not.toThrow();
         });
-        it('should throw for non-array', () => {
-            expect(() => (0, validators_1.validateMapUsersRequest)('not array')).toThrow('directMappings must be an array');
+        it('should throw validation error for non-array input', () => {
+            expect(() => (0, validators_1.validateMapUsersRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateMapUsersRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateMapUsersRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty array', () => {
-            expect(() => (0, validators_1.validateMapUsersRequest)([])).toThrow('directMappings array cannot be empty');
+        it('should throw validation error for empty array', () => {
+            expect(() => (0, validators_1.validateMapUsersRequest)([])).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for array exceeding limit', () => {
-            const directMappings = Array(validators_1.MAX_USER_MAPPINGS + 1).fill({ externalId: 'id', accountId: 'acc' });
-            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).toThrow(`Bulk user mapping supports maximum ${validators_1.MAX_USER_MAPPINGS} mappings. Received ${validators_1.MAX_USER_MAPPINGS + 1}`);
+        it('should throw validation error for array exceeding max length', () => {
+            const mappings = Array(validators_1.MAX_USER_MAPPINGS + 1).fill({ externalId: '1', accountId: 'acc1' });
+            expect(() => (0, validators_1.validateMapUsersRequest)(mappings)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for mapping without accountId or externalEmailAddress', () => {
-            const directMappings = [{ externalId: 'id' }];
-            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).toThrow('Each mapping must have either accountId or externalEmailAddress');
+        it('should throw validation error for mapping without accountId or externalEmailAddress', () => {
+            const mappings = [{ externalId: '1' }];
+            expect(() => (0, validators_1.validateMapUsersRequest)(mappings)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for mapping without externalId', () => {
-            const directMappings = [{ accountId: 'acc' }];
-            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).toThrow('Each mapping must have an externalId');
+        it('should throw validation error for mapping without externalId', () => {
+            const mappings = [{ accountId: 'acc1' }];
+            expect(() => (0, validators_1.validateMapUsersRequest)(mappings)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateDeleteEntitiesByPropertiesRequest', () => {
-        it('should pass for valid properties object', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)({ key: 'value' })).not.toThrow();
-        });
-        it('should throw for null', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)(null)).toThrow('properties must be an object');
+        it('should pass with valid properties object', () => {
+            const properties = { type: 'issue', status: 'open' };
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)(properties)).not.toThrow();
         });
-        it('should throw for non-object', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)('not object')).toThrow('properties must be an object');
+        it('should throw validation error for non-object input', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for empty object', () => {
-            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)({})).toThrow('properties object cannot be empty');
+        it('should throw validation error for empty object', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)({})).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateFetchDataRequest', () => {
-        it('should pass for valid request', () => {
+        it('should pass with valid request', () => {
             const request = {
                 requestConfig: {
-                    url: 'https://test.com',
+                    url: 'https://api.example.com/data',
                     method: 'GET',
-                    headers: { 'Content-Type': 'application/json' }
+                    headers: {}
                 },
-                onResult: () => {
-                }
+                onResult: jest.fn()
             };
             expect(() => (0, validators_1.validateFetchDataRequest)(request)).not.toThrow();
         });
-        it('should throw for null request', () => {
-            expect(() => (0, validators_1.validateFetchDataRequest)(null)).toThrow('request must be an object');
+        it('should throw validation error for non-object request', () => {
+            expect(() => (0, validators_1.validateFetchDataRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateFetchDataRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateFetchDataRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-object request', () => {
-            expect(() => (0, validators_1.validateFetchDataRequest)('not object')).toThrow('request must be an object');
+        it('should throw validation error for missing requestConfig', () => {
+            const request = { onResult: jest.fn() };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for missing requestConfig', () => {
+        it('should throw validation error for non-object requestConfig', () => {
             const request = {
-                onResult: () => {
-                }
+                requestConfig: 'invalid',
+                onResult: jest.fn()
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig is required and must be an object');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-object requestConfig', () => {
+        it('should throw validation error for missing url', () => {
             const request = {
-                requestConfig: 'not object',
-                onResult: () => {
-                }
+                requestConfig: {
+                    method: 'GET',
+                    headers: {}
+                },
+                onResult: jest.fn()
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig is required and must be an object');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for missing url', () => {
+        it('should throw validation error for non-string url', () => {
             const request = {
-                requestConfig: { method: 'GET' },
-                onResult: () => {
-                }
+                requestConfig: {
+                    url: 123,
+                    method: 'GET',
+                    headers: {}
+                },
+                onResult: jest.fn()
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.url is required and must be a string');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-string url', () => {
+        it('should throw validation error for missing method', () => {
             const request = {
-                requestConfig: { url: 123, method: 'GET' },
-                onResult: () => {
-                }
+                requestConfig: {
+                    url: 'https://api.example.com/data',
+                    headers: {}
+                },
+                onResult: jest.fn()
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.url is required and must be a string');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for missing method', () => {
+        it('should throw validation error for non-string method', () => {
             const request = {
-                requestConfig: { url: 'https://test.com' },
-                onResult: () => {
-                }
+                requestConfig: {
+                    url: 'https://api.example.com/data',
+                    method: 123,
+                    headers: {}
+                },
+                onResult: jest.fn()
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.method is required and must be a string');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-string method', () => {
+        it('should throw validation error for missing onResult', () => {
             const request = {
-                requestConfig: { url: 'https://test.com', method: 123 },
-                onResult: () => {
+                requestConfig: {
+                    url: 'https://api.example.com/data',
+                    method: 'GET',
+                    headers: {}
                 }
             };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.method is required and must be a string');
-        });
-        it('should throw for missing onResult', () => {
-            const request = { requestConfig: { url: 'https://test.com', method: 'GET' } };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('onResult is required and must be a function');
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-function onResult', () => {
-            const request = { requestConfig: { url: 'https://test.com', method: 'GET' }, onResult: 'not function' };
-            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('onResult is required and must be a function');
+        it('should throw validation error for non-function onResult', () => {
+            const request = {
+                requestConfig: {
+                    url: 'https://api.example.com/data',
+                    method: 'GET',
+                    headers: {}
+                },
+                onResult: 'not a function'
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
     });
     describe('validateTransformDataRequest', () => {
-        it('should pass for valid request', () => {
+        it('should pass with valid request', () => {
             const request = {
-                data: { test: 'data' },
-                transformMethod: () => {
-                }
+                data: { key: 'value' },
+                transformMethod: jest.fn()
             };
             expect(() => (0, validators_1.validateTransformDataRequest)(request)).not.toThrow();
         });
-        it('should throw for null request', () => {
-            expect(() => (0, validators_1.validateTransformDataRequest)(null)).toThrow('request must be an object');
+        it('should throw validation error for non-object request', () => {
+            expect(() => (0, validators_1.validateTransformDataRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateTransformDataRequest)(null)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            expect(() => (0, validators_1.validateTransformDataRequest)(undefined)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-object request', () => {
-            expect(() => (0, validators_1.validateTransformDataRequest)('not object')).toThrow('request must be an object');
+        it('should throw validation error for missing transformMethod', () => {
+            const request = { data: { key: 'value' } };
+            expect(() => (0, validators_1.validateTransformDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for missing transformMethod', () => {
-            const request = { data: { test: 'data' } };
-            expect(() => (0, validators_1.validateTransformDataRequest)(request)).toThrow('transformMethod is required and must be a function');
+        it('should throw validation error for non-function transformMethod', () => {
+            const request = {
+                data: { key: 'value' },
+                transformMethod: 'not a function'
+            };
+            expect(() => (0, validators_1.validateTransformDataRequest)(request)).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
         });
-        it('should throw for non-function transformMethod', () => {
-            const request = { data: { test: 'data' }, transformMethod: 'not function' };
-            expect(() => (0, validators_1.validateTransformDataRequest)(request)).toThrow('transformMethod is required and must be a function');
+    });
+    describe('Error Handling Integration', () => {
+        it('should handle validation errors with proper error types', () => {
+            expect(() => (0, validators_1.validateSetEntitiesRequest)('invalid')).toThrow(errors_1.ForgeTeamWorkGraphValidationError);
+            try {
+                (0, validators_1.validateSetEntitiesRequest)([]);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain('entities array cannot be empty');
+            }
+        });
+        it('should handle array max length validation with proper error details', () => {
+            const entities = Array(validators_1.MAX_BULK_ENTITIES + 1).fill({ id: '1' });
+            try {
+                (0, validators_1.validateSetEntitiesRequest)(entities);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain(`supports maximum ${validators_1.MAX_BULK_ENTITIES} entities`);
+                expect(error.message).toContain(`Received ${validators_1.MAX_BULK_ENTITIES + 1}`);
+            }
+        });
+        it('should handle user mapping validation with proper error details', () => {
+            const mappings = [{ externalId: '1' }];
+            try {
+                (0, validators_1.validateMapUsersRequest)(mappings);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain('Each mapping must have either accountId or externalEmailAddress');
+            }
+        });
+        it('should handle required string validation with proper error details', () => {
+            try {
+                (0, validators_1.validateGetEntityByExternalIdRequest)('', '123');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain('entityType is required');
+            }
+        });
+        it('should handle object validation with proper error details', () => {
+            try {
+                (0, validators_1.validateDeleteEntitiesByPropertiesRequest)({});
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain('properties object cannot be empty');
+            }
+        });
+        it('should handle function validation with proper error details', () => {
+            const request = {
+                requestConfig: {
+                    url: 'https://api.example.com/data',
+                    method: 'GET',
+                    headers: {}
+                },
+                onResult: 'not a function'
+            };
+            try {
+                (0, validators_1.validateFetchDataRequest)(request);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ForgeTeamWorkGraphValidationError);
+                expect(error.message).toContain('onResult is required and must be a function');
+            }
         });
     });
 });

package/out/graph.d.ts

@@ -13,9 +13,6 @@ export declare class TeamWorkGraphClient implements TeamWorkGraph {
     mapUsers: (request: MapUsersRequest) => Promise<MapUsersResponse>;
     fetchData: (request: FetchDataRequest) => Promise<FetchDataResponse>;
     transformData: (request: TransformDataRequest) => Promise<TransformDataResponse>;
-    private sendPostRequest;
-    private sendDeleteRequest;
-    private sendGetRequest;
     private sendRequest;
 }
 export declare const teamworkgraph: TeamWorkGraphClient;

package/out/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAiBA,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,+BAA+B,EAC/B,gCAAgC,EAChC,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,kCAAkC,EAClC,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAIjB,qBAAa,mBAAoB,YAAW,aAAa;IACvD,WAAW,YAAmB,iBAAiB,KAAG,QAAQ,kBAAkB,CAAC,CAM3E;IAKF,qBAAqB,YAAmB,4BAA4B,KAAG,QAAQ,6BAA6B,CAAC,CAoB3G;IAKF,0BAA0B,YACf,iCAAiC,KACzC,QAAQ,kCAAkC,CAAC,CAS5C;IAKF,0BAA0B,YACf,iCAAiC,KACzC,QAAQ,kCAAkC,CAAC,CAK5C;IAKF,SAAS,YAAmB,iBAAiB,KAAG,QAAQ,kBAAkB,CAAC,CAMzE;IAKF,wBAAwB,YACb,+BAA+B,KACvC,QAAQ,gCAAgC,CAAC,CAQ1C;IAKF,oBAAoB,YAAmB,2BAA2B,KAAG,QAAQ,4BAA4B,CAAC,CAmBxG;IAEF,QAAQ,YAAmB,gBAAgB,KAAG,QAAQ,iBAAiB,CAAC,CAMtE;IAEF,uBAAuB,YACZ,8BAA8B,KACtC,QAAQ,+BAA+B,CAAC,CAQzC;IAEF,mBAAmB,YAAmB,0BAA0B,KAAG,QAAQ,2BAA2B,CAAC,CAmBrG;IAEF,QAAQ,YAAmB,eAAe,KAAG,QAAQ,gBAAgB,CAAC,CAQpE;IAEF,SAAS,YAAmB,gBAAgB,KAAG,QAAQ,iBAAiB,CAAC,CA6BvE;IAEF,aAAa,YAAmB,oBAAoB,KAAG,QAAQ,qBAAqB,CAAC,CAiBnF;YAEY,eAAe;YAaf,iBAAiB;YAajB,cAAc;YAYd,WAAW;CAY1B;AAED,eAAO,MAAM,aAAa,qBAA4B,CAAC"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,+BAA+B,EAC/B,gCAAgC,EAChC,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,kCAAkC,EAClC,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAIjB,qBAAa,mBAAoB,YAAW,aAAa;IACvD,WAAW,YAAmB,iBAAiB,KAAG,QAAQ,kBAAkB,CAAC,CAa3E;IAKF,qBAAqB,YAAmB,4BAA4B,KAAG,QAAQ,6BAA6B,CAAC,CAmB3G;IAKF,0BAA0B,YACf,iCAAiC,KACzC,QAAQ,kCAAkC,CAAC,CAa5C;IAKF,0BAA0B,YACf,iCAAiC,KACzC,QAAQ,kCAAkC,CAAC,CAY5C;IAKF,SAAS,YAAmB,iBAAiB,KAAG,QAAQ,kBAAkB,CAAC,CAazE;IAKF,wBAAwB,YACb,+BAA+B,KACvC,QAAQ,gCAAgC,CAAC,CAa1C;IAKF,oBAAoB,YAAmB,2BAA2B,KAAG,QAAQ,4BAA4B,CAAC,CAkBxG;IAEF,QAAQ,YAAmB,gBAAgB,KAAG,QAAQ,iBAAiB,CAAC,CAatE;IAEF,uBAAuB,YACZ,8BAA8B,KACtC,QAAQ,+BAA+B,CAAC,CAazC;IAEF,mBAAmB,YAAmB,0BAA0B,KAAG,QAAQ,2BAA2B,CAAC,CAkBrG;IAEF,QAAQ,YAAmB,eAAe,KAAG,QAAQ,gBAAgB,CAAC,CAapE;IAEF,SAAS,YAAmB,gBAAgB,KAAG,QAAQ,iBAAiB,CAAC,CA2BvE;IAEF,aAAa,YAAmB,oBAAoB,KAAG,QAAQ,qBAAqB,CAAC,CAoBnF;YAEY,WAAW;CA2B1B;AAED,eAAO,MAAM,aAAa,qBAA4B,CAAC"}