@forge/teamwork-graph 1.2.0-next.3-experimental-255e232 → 1.2.0-next.5

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const api_1 = require("@forge/api");
 const graph_1 = require("../graph");
+const validators_1 = require("../utils/validators");
 jest.mock('@forge/api');
 describe('TeamWorkGraphClient - setEntities', () => {
     let graphClient;
@@ -16,7 +17,7 @@ describe('TeamWorkGraphClient - setEntities', () => {
         const req = { entities: [] };
         await expect(graphClient.setEntities(req)).rejects.toThrow('entities array cannot be empty');
     });
-    it('throws if more than 100 entities', async () => {
+    it(`throws if more than ${validators_1.MAX_BULK_ENTITIES} entities`, async () => {
         const documentEntity = {
             schemaVersion: '1.0',
             id: 'my-document',
@@ -48,9 +49,9 @@ describe('TeamWorkGraphClient - setEntities', () => {
             }
         };
         const req = {
-            entities: Array(101).fill(documentEntity)
+            entities: Array(validators_1.MAX_BULK_ENTITIES + 1).fill(documentEntity)
         };
-        await expect(graphClient.setEntities(req)).rejects.toThrow('Bulk ingestion supports maximum 100 entities');
+        await expect(graphClient.setEntities(req)).rejects.toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_ENTITIES} entities`);
     });
     it('posts to /api/v1/entities/bulk and returns response', async () => {
         const documentEntity = {
@@ -314,11 +315,11 @@ describe('TeamWorkGraphClient - deleteEntitiesByExternalId', () => {
         })).rejects.toThrow('externalIds array cannot be empty');
     });
     it('should throw error when externalIds array exceeds limit', async () => {
-        const manyExternalIds = Array(101).fill('pipelines/123/builds/456');
+        const manyExternalIds = Array(validators_1.MAX_BULK_ENTITIES_DELETE + 1).fill('pipelines/123/builds/456');
         await expect(graphClient.deleteEntitiesByExternalId({
             entityType: 'atlassian:document',
             externalIds: manyExternalIds
-        })).rejects.toThrow('Bulk entity deletion supports maximum 100 entities');
+        })).rejects.toThrow(`Bulk entity deletion supports maximum ${validators_1.MAX_BULK_ENTITIES_DELETE} entities`);
     });
     it('should throw error when externalIds is not an array', async () => {
         await expect(graphClient.deleteEntitiesByExternalId({
@@ -402,4 +403,80 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
     it('should throw error when properties object is empty', async () => {
         await expect(graphClient.deleteEntitiesByProperties({})).rejects.toThrow('properties object cannot be empty');
     });
+    it('posts branch entities to /api/v1/entities/bulk and returns response', async () => {
+        const branchEntity = {
+            schemaVersion: '2.0',
+            id: 'branch-1',
+            updateSequenceNumber: 1,
+            displayName: 'feature-branch',
+            url: 'https://github.com/org/repo/tree/feature-branch',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:branch': {}
+        };
+        const req = { entities: [branchEntity] };
+        const expected = { success: true, results: [{ entityId: 'branch-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
+    it('posts commit entities to /api/v1/entities/bulk and returns response', async () => {
+        const commitEntity = {
+            schemaVersion: '2.0',
+            id: 'commit-1',
+            updateSequenceNumber: 1,
+            displayName: 'abc123 - Add new feature',
+            url: 'https://github.com/org/repo/commit/abc123',
+            createdAt: '2024-07-09T14:27:37.000Z',
+            lastUpdatedAt: '2024-07-09T14:27:37.000Z',
+            permissions: {
+                accessControls: [
+                    {
+                        principals: [
+                            {
+                                type: 'EVERYONE'
+                            }
+                        ]
+                    }
+                ]
+            },
+            'atlassian:commit': {
+                flags: ['flag1', 'flag2'],
+                fileCount: 10,
+                files: [
+                    {
+                        path: 'path/to/file.txt',
+                        url: 'https://github.com/org/repo/blob/abc123/path/to/file.txt',
+                        changeType: 'ADDED',
+                        linesAdded: 10,
+                        linesRemoved: 5
+                    }
+                ]
+            }
+        };
+        const req = { entities: [commitEntity] };
+        const expected = { success: true, results: [{ entityId: 'commit-1', success: true }] };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(expected)
+        });
+        const result = await graphClient.setEntities(req);
+        expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
+        expect(result).toEqual(expected);
+    });
 });

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

@@ -6,22 +6,13 @@ jest.mock('@forge/api', () => ({
     __fetchProduct: jest.fn(),
     fetch: jest.fn()
 }));
-describe('Teamwork Graph Client Extended Features', () => {
+describe('TeamWorkGraphClient - Extended Features', () => {
     let graphClient;
-    let mockContext;
     beforeEach(() => {
         graphClient = new graph_1.TeamWorkGraphClient();
-        mockContext = {
-            ingestionContext: { id: 'test' },
-            installContext: 'test-installation',
-            principal: { accountId: 'test' },
-            license: { isActive: true }
-        };
-        jest.spyOn(graphClient, 'saveToStage').mockImplementation(() => Promise.resolve());
-        jest.spyOn(graphClient, 'validateData').mockImplementation(() => Promise.resolve());
         jest.clearAllMocks();
     });
-    describe('fetchExternalData', () => {
+    describe('fetchData', () => {
         it('should successfully fetch and process external data', async () => {
             const mockData = { items: [{ id: 1, name: 'Task 1' }] };
             const mockResponse = {
@@ -30,33 +21,44 @@ describe('Teamwork Graph Client Extended Features', () => {
                 json: jest.fn().mockResolvedValue(mockData)
             };
             api_1.fetch.mockResolvedValue(mockResponse);
-            const requestConfig = {
-                url: 'https://api.gitbook.com/api/tasks',
-                method: 'GET',
-                headers: { Authorization: 'Bearer token' }
+            const request = {
+                requestConfig: {
+                    url: 'https://api.gitbook.com/api/tasks',
+                    method: 'GET',
+                    headers: { Authorization: 'Bearer token' }
+                },
+                onResult: jest.fn()
             };
-            const onResult = jest.fn();
-            const result = await graphClient.fetchData(mockContext, requestConfig, onResult);
+            const result = await graphClient.fetchData(request);
             expect(api_1.fetch).toHaveBeenCalledWith('https://api.gitbook.com/api/tasks', {
                 method: 'GET',
                 headers: { Authorization: 'Bearer token' }
             });
-            expect(onResult).toHaveBeenCalledWith(mockData);
-            expect(result).toEqual(mockData);
+            expect(request.onResult).toHaveBeenCalledWith(mockData);
+            expect(result).toEqual({
+                success: true,
+                data: mockData
+            });
         });
-        it('should throw error when fetch fails', async () => {
+        it('should return error response when fetch fails', async () => {
             const mockResponse = {
                 ok: false,
                 status: 401
             };
             api_1.fetch.mockResolvedValue(mockResponse);
-            const requestConfig = {
-                url: 'https://api.gitbook.com/api/tasks',
-                method: 'GET'
+            const request = {
+                requestConfig: {
+                    url: 'https://api.gitbook.com/api/tasks',
+                    method: 'GET'
+                },
+                onResult: jest.fn()
             };
-            const onResult = jest.fn();
-            await expect(graphClient.fetchData(mockContext, requestConfig, onResult)).rejects.toThrow(`Remote call failed with status: ${mockResponse.status}`);
-            expect(onResult).not.toHaveBeenCalled();
+            const result = await graphClient.fetchData(request);
+            expect(result).toEqual({
+                success: false,
+                error: 'Remote call failed with status: 401'
+            });
+            expect(request.onResult).not.toHaveBeenCalled();
         });
     });
     describe('transformData', () => {
@@ -69,10 +71,32 @@ describe('Teamwork Graph Client Extended Features', () => {
                     type: 'task'
                 }))
             }));
-            const result = await graphClient.transformData(mockContext, inputData, transformMethod);
+            const request = {
+                data: inputData,
+                transformMethod
+            };
+            const result = await graphClient.transformData(request);
             expect(transformMethod).toHaveBeenCalledWith(inputData);
             expect(result).toEqual({
-                entities: [{ id: 'task-1', name: 'Task 1', type: 'task' }]
+                success: true,
+                transformedData: {
+                    entities: [{ id: 'task-1', name: 'Task 1', type: 'task' }]
+                }
+            });
+        });
+        it('should return error response when transform method throws', async () => {
+            const inputData = { items: [{ id: 1, name: 'Task 1' }] };
+            const transformMethod = jest.fn().mockImplementation(() => {
+                throw new Error('Transform failed');
+            });
+            const request = {
+                data: inputData,
+                transformMethod
+            };
+            const result = await graphClient.transformData(request);
+            expect(result).toEqual({
+                success: false,
+                error: 'Transform failed'
             });
         });
     });

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const api_1 = require("@forge/api");
 const graph_1 = require("../graph");
+const validators_1 = require("../utils/validators");
 jest.mock('@forge/api');
 describe('TeamWorkGraphClient - Group Operations', () => {
     let graphClient;
@@ -87,10 +88,10 @@ describe('TeamWorkGraphClient - Group Operations', () => {
             })).rejects.toThrow('groups array cannot be empty');
         });
         it('should throw error when groups array exceeds limit', async () => {
-            const manyGroups = Array(101).fill(groupPayload);
+            const manyGroups = Array(validators_1.MAX_BULK_GROUPS + 1).fill(groupPayload);
             await expect(graphClient.setGroups({
                 groups: manyGroups
-            })).rejects.toThrow('Bulk group ingestion supports maximum 100 groups');
+            })).rejects.toThrow(`Bulk group ingestion supports maximum ${validators_1.MAX_BULK_GROUPS} groups`);
         });
         it('should throw error when groups is not an array', async () => {
             await expect(graphClient.setGroups({

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const api_1 = require("@forge/api");
 const graph_1 = require("../graph");
+const validators_1 = require("../utils/validators");
 jest.mock('@forge/api');
 describe('TeamWorkGraphClient - User Operations', () => {
     let graphClient;
@@ -66,10 +67,10 @@ describe('TeamWorkGraphClient - User Operations', () => {
             })).rejects.toThrow('users array cannot be empty');
         });
         it('should throw error when users array exceeds limit', async () => {
-            const manyUsers = Array(101).fill(userPayload);
+            const manyUsers = Array(validators_1.MAX_BULK_USERS + 1).fill(userPayload);
             await expect(graphClient.setUsers({
                 users: manyUsers
-            })).rejects.toThrow('Bulk user ingestion supports maximum 100 users');
+            })).rejects.toThrow(`Bulk user ingestion supports maximum ${validators_1.MAX_BULK_USERS} users`);
         });
     });
     describe('deleteUsersByExternalId', () => {
@@ -256,10 +257,10 @@ describe('TeamWorkGraphClient - User Operations', () => {
             })).rejects.toThrow('directMappings array cannot be empty');
         });
         it('should throw error when directMappings array exceeds limit', async () => {
-            const manyMappings = Array(101).fill(mappingWithAccountId);
+            const manyMappings = Array(validators_1.MAX_USER_MAPPINGS + 1).fill(mappingWithAccountId);
             await expect(graphClient.mapUsers({
                 directMappings: manyMappings
-            })).rejects.toThrow('Bulk user mapping supports maximum 100 mappings');
+            })).rejects.toThrow(`Bulk user mapping supports maximum ${validators_1.MAX_USER_MAPPINGS} mappings`);
         });
         it('should throw error when directMappings is not an array', async () => {
             await expect(graphClient.mapUsers({

package/out/__test__/validators.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validators.test.d.ts.map

package/out/__test__/validators.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.test.d.ts","sourceRoot":"","sources":["../../src/__test__/validators.test.ts"],"names":[],"mappings":""}

package/out/__test__/validators.test.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("../utils/validators");
+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' });
+            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 for empty array', () => {
+            expect(() => (0, validators_1.validateSetEntitiesRequest)([])).toThrow('entities array cannot be empty');
+        });
+        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}`);
+        });
+    });
+    describe('validateSetUsersRequest', () => {
+        it('should pass for valid users array', () => {
+            const users = Array(validators_1.MAX_BULK_USERS).fill({ id: 'test' });
+            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 for empty array', () => {
+            expect(() => (0, validators_1.validateSetUsersRequest)([])).toThrow('users array cannot be empty');
+        });
+        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}`);
+        });
+    });
+    describe('validateSetGroupsRequest', () => {
+        it('should pass for valid groups array', () => {
+            const groups = Array(validators_1.MAX_BULK_GROUPS).fill({ id: 'test' });
+            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 for empty array', () => {
+            expect(() => (0, validators_1.validateSetGroupsRequest)([])).toThrow('groups array cannot be empty');
+        });
+        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}`);
+        });
+    });
+    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 throw for empty entityType', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('', ['test'])).toThrow('entityType is required');
+        });
+        it('should throw for whitespace entityType', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('   ', ['test'])).toThrow('entityType is required');
+        });
+        it('should throw for non-array externalIds', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByExternalIdRequest)('type', 'not array')).toThrow('externalIds must be an array');
+        });
+        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}`);
+        });
+    });
+    describe('validateDeleteUsersByExternalIdRequest', () => {
+        it('should pass for valid externalIds array', () => {
+            const externalIds = ['id1', 'id2'];
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)(externalIds)).not.toThrow();
+        });
+        it('should throw for non-array', () => {
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)('not array')).toThrow('externalIds must be an array');
+        });
+        it('should throw for empty array', () => {
+            expect(() => (0, validators_1.validateDeleteUsersByExternalIdRequest)([])).toThrow('externalIds array cannot be empty');
+        });
+    });
+    describe('validateDeleteGroupsByExternalIdRequest', () => {
+        it('should pass for valid externalIds array', () => {
+            const externalIds = ['id1', 'id2'];
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)(externalIds)).not.toThrow();
+        });
+        it('should throw for non-array', () => {
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)('not array')).toThrow('externalIds must be an array');
+        });
+        it('should throw for empty array', () => {
+            expect(() => (0, validators_1.validateDeleteGroupsByExternalIdRequest)([])).toThrow('externalIds array cannot be empty');
+        });
+    });
+    describe('validateGetEntityByExternalIdRequest', () => {
+        it('should pass for valid request', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('type', 'id')).not.toThrow();
+        });
+        it('should throw for empty entityType', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('', 'id')).toThrow('entityType is required');
+        });
+        it('should throw for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetEntityByExternalIdRequest)('type', '')).toThrow('externalId is required');
+        });
+    });
+    describe('validateGetUserByExternalIdRequest', () => {
+        it('should pass for valid externalId', () => {
+            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('valid-id')).not.toThrow();
+        });
+        it('should throw for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetUserByExternalIdRequest)('')).toThrow('externalId is required');
+        });
+    });
+    describe('validateGetGroupByExternalIdRequest', () => {
+        it('should pass for valid externalId', () => {
+            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('valid-id')).not.toThrow();
+        });
+        it('should throw for empty externalId', () => {
+            expect(() => (0, validators_1.validateGetGroupByExternalIdRequest)('')).toThrow('externalId is required');
+        });
+    });
+    describe('validateMapUsersRequest', () => {
+        it('should pass for valid mappings', () => {
+            const directMappings = [
+                { externalId: 'id1', accountId: 'acc1' },
+                { externalId: 'id2', externalEmailAddress: 'email@test.com' }
+            ];
+            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).not.toThrow();
+        });
+        it('should throw for non-array', () => {
+            expect(() => (0, validators_1.validateMapUsersRequest)('not array')).toThrow('directMappings must be an array');
+        });
+        it('should throw for empty array', () => {
+            expect(() => (0, validators_1.validateMapUsersRequest)([])).toThrow('directMappings array cannot be empty');
+        });
+        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 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 for mapping without externalId', () => {
+            const directMappings = [{ accountId: 'acc' }];
+            expect(() => (0, validators_1.validateMapUsersRequest)(directMappings)).toThrow('Each mapping must have an externalId');
+        });
+    });
+    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 throw for non-object', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)('not object')).toThrow('properties must be an object');
+        });
+        it('should throw for empty object', () => {
+            expect(() => (0, validators_1.validateDeleteEntitiesByPropertiesRequest)({})).toThrow('properties object cannot be empty');
+        });
+    });
+    describe('validateFetchDataRequest', () => {
+        it('should pass for valid request', () => {
+            const request = {
+                requestConfig: {
+                    url: 'https://test.com',
+                    method: 'GET',
+                    headers: { 'Content-Type': 'application/json' }
+                },
+                onResult: () => {
+                }
+            };
+            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 for non-object request', () => {
+            expect(() => (0, validators_1.validateFetchDataRequest)('not object')).toThrow('request must be an object');
+        });
+        it('should throw for missing requestConfig', () => {
+            const request = {
+                onResult: () => {
+                }
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig is required and must be an object');
+        });
+        it('should throw for non-object requestConfig', () => {
+            const request = {
+                requestConfig: 'not object',
+                onResult: () => {
+                }
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig is required and must be an object');
+        });
+        it('should throw for missing url', () => {
+            const request = {
+                requestConfig: { method: 'GET' },
+                onResult: () => {
+                }
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.url is required and must be a string');
+        });
+        it('should throw for non-string url', () => {
+            const request = {
+                requestConfig: { url: 123, method: 'GET' },
+                onResult: () => {
+                }
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.url is required and must be a string');
+        });
+        it('should throw for missing method', () => {
+            const request = {
+                requestConfig: { url: 'https://test.com' },
+                onResult: () => {
+                }
+            };
+            expect(() => (0, validators_1.validateFetchDataRequest)(request)).toThrow('requestConfig.method is required and must be a string');
+        });
+        it('should throw for non-string method', () => {
+            const request = {
+                requestConfig: { url: 'https://test.com', method: 123 },
+                onResult: () => {
+                }
+            };
+            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');
+        });
+        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');
+        });
+    });
+    describe('validateTransformDataRequest', () => {
+        it('should pass for valid request', () => {
+            const request = {
+                data: { test: 'data' },
+                transformMethod: () => {
+                }
+            };
+            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 for non-object request', () => {
+            expect(() => (0, validators_1.validateTransformDataRequest)('not object')).toThrow('request must be an object');
+        });
+        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 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');
+        });
+    });
+});