@forge/teamwork-graph 2.0.0 → 2.1.0-next.0-experimental-ab129b0

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

@@ -4,7 +4,7 @@ const api_1 = require("@forge/api");
 const graph_1 = require("../graph");
 const validators_1 = require("../utils/validators");
 jest.mock('@forge/api');
-describe('TeamWorkGraphClient - setEntities', () => {
+describe('TeamWorkGraphClient - setObjects', () => {
     let graphClient;
     let mockFetch;
     beforeEach(() => {
@@ -13,13 +13,13 @@ describe('TeamWorkGraphClient - setEntities', () => {
         api_1.__fetchProduct.mockReturnValue(mockFetch);
         jest.clearAllMocks();
     });
-    it('throws if entities array is empty', async () => {
-        await expect(graphClient.setEntities({
-            entities: []
-        })).rejects.toThrow('entities array cannot be empty');
+    it('throws if objects array is empty', async () => {
+        await expect(graphClient.setObjects({
+            objects: []
+        })).rejects.toThrow('objects array cannot be empty');
     });
-    it('throws if more than 100 entities', async () => {
-        const documentEntity = {
+    it('throws if more than 100 objects', async () => {
+        const documentObject = {
             schemaVersion: '1.0',
             id: 'my-document',
             updateSequenceNumber: 123,
@@ -27,17 +27,19 @@ describe('TeamWorkGraphClient - setEntities', () => {
             url: 'https://document.com',
             createdAt: '2024-04-16T09:01:32+00:00',
             lastUpdatedAt: '2024-04-16T09:01:32+00:00',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:document': {
                 type: {
                     category: 'document',
@@ -49,13 +51,13 @@ describe('TeamWorkGraphClient - setEntities', () => {
                 }
             }
         };
-        const manyEntities = Array(validators_1.MAX_BULK_ENTITIES + 1).fill(documentEntity);
-        await expect(graphClient.setEntities({
-            entities: manyEntities
-        })).rejects.toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_ENTITIES} entities. Received ${validators_1.MAX_BULK_ENTITIES + 1}`);
+        const manyObjects = Array(validators_1.MAX_BULK_OBJECTS + 1).fill(documentObject);
+        await expect(graphClient.setObjects({
+            objects: manyObjects
+        })).rejects.toThrow(`Bulk ingestion supports maximum ${validators_1.MAX_BULK_OBJECTS} objects. Received ${validators_1.MAX_BULK_OBJECTS + 1}`);
     });
     it('posts to /api/v1/entities/bulk and returns response', async () => {
-        const documentEntity = {
+        const documentObject = {
             schemaVersion: '1.0',
             id: 'my-document',
             updateSequenceNumber: 123,
@@ -63,17 +65,19 @@ describe('TeamWorkGraphClient - setEntities', () => {
             url: 'https://document.com',
             createdAt: '2024-04-16T09:01:32+00:00',
             lastUpdatedAt: '2024-04-16T09:01:32+00:00',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:document': {
                 type: {
                     category: 'document',
@@ -85,18 +89,18 @@ describe('TeamWorkGraphClient - setEntities', () => {
                 }
             }
         };
-        const req = { entities: [documentEntity] };
-        const expected = { success: true, results: [{ entityId: 'my-document', success: true }] };
+        const req = { objects: [documentObject] };
+        const expected = { success: true, results: [{ objectId: 'my-document', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts message entities to /api/v1/entities/bulk and returns response', async () => {
-        const messageEntity = {
+        const messageObject = {
             schemaVersion: '2.0',
             id: 'message-1',
             updateSequenceNumber: 1,
@@ -104,21 +108,23 @@ describe('TeamWorkGraphClient - setEntities', () => {
             url: 'https://atlassian.slack.com/archives/C03DZ3WCN94/p1722400000000000',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             containerKey: {
                 type: 'atlassian:conversation',
                 value: {
-                    entityId: 'CFG3W7TKJ'
+                    objectId: 'CFG3W7TKJ'
                 }
             },
             'atlassian:message': {
@@ -134,18 +140,18 @@ describe('TeamWorkGraphClient - setEntities', () => {
                 lastActive: '2024-07-09T15:27:37.000Z'
             }
         };
-        const req = { entities: [messageEntity] };
-        const expected = { success: true, results: [{ entityId: 'message-1', success: true }] };
+        const req = { objects: [messageObject] };
+        const expected = { success: true, results: [{ objectId: 'message-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts organisation entities to /api/v1/entities/bulk and returns response', async () => {
-        const organisationEntity = {
+        const organisationObject = {
             schemaVersion: '2.0',
             id: 'org-1',
             updateSequenceNumber: 2,
@@ -153,41 +159,43 @@ describe('TeamWorkGraphClient - setEntities', () => {
             url: 'https://workday.atlassian.com/path-to-org',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             parentKey: {
                 type: 'atlassian:organisation',
                 value: {
-                    entityId: 'id of the parent org of this org'
+                    objectId: 'id of the parent org of this org'
                 }
             },
             'atlassian:organisation': {}
         };
-        const req = { entities: [organisationEntity] };
-        const expected = { success: false, results: [{ entityId: 'org-1', success: true }] };
+        const req = { objects: [organisationObject] };
+        const expected = { success: false, results: [{ objectId: 'org-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
-    it('throws if entities is not an array', async () => {
-        const req = { entities: null };
-        await expect(graphClient.setEntities(req)).rejects.toThrow('entities must be an array');
+    it('throws if objects is not an array', async () => {
+        const req = { objects: null };
+        await expect(graphClient.setObjects(req)).rejects.toThrow('objects must be an array');
     });
 });
-describe('TeamWorkGraphClient - getEntityByExternalId', () => {
+describe('TeamWorkGraphClient - getObjectByExternalId', () => {
     let graphClient;
     let mockFetch;
     beforeEach(() => {
@@ -196,11 +204,11 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
         api_1.__fetchProduct.mockReturnValue(mockFetch);
         jest.clearAllMocks();
     });
-    it('should successfully get entity by external ID and entity type', async () => {
-        const expectedEntity = {
-            id: 'ari:cloud:teamwork-graph:entity/123',
+    it('should successfully get object by external ID and object type', async () => {
+        const expectedObject = {
+            id: 'ari:cloud:teamwork-graph:object/123',
             externalId: 'pipelines/123/builds/456',
-            entityType: 'atlassian:document',
+            objectType: 'atlassian:document',
             displayName: 'Build Documentation',
             description: 'Documentation for build process',
             url: 'https://example.com/builds/456',
@@ -215,10 +223,10 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expectedEntity)
+            json: () => Promise.resolve(expectedObject)
         });
-        const result = await graphClient.getEntityByExternalId({
-            entityType: 'atlassian:document',
+        const result = await graphClient.getObjectByExternalId({
+            objectType: 'atlassian:document',
             externalId: 'pipelines/123/builds/456'
         });
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities?entityType=atlassian%3Adocument&externalId=pipelines%2F123%2Fbuilds%2F456', {
@@ -228,10 +236,10 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
         });
         expect(result).toEqual({
             success: true,
-            entity: expectedEntity
+            object: expectedObject
         });
     });
-    it('should handle entity not found', async () => {
+    it('should handle object not found', async () => {
         const errorResponse = {
             ok: false,
             status: 404,
@@ -245,30 +253,30 @@ describe('TeamWorkGraphClient - getEntityByExternalId', () => {
             })
         };
         mockFetch.mockResolvedValueOnce(errorResponse);
-        const result = await graphClient.getEntityByExternalId({
-            entityType: 'atlassian:document',
+        const result = await graphClient.getObjectByExternalId({
+            objectType: 'atlassian:document',
             externalId: 'nonexistent-entity'
         });
         expect(result).toEqual({
             success: false,
-            error: 'Failed to get entity by external ID: Not Found - Entity not found',
+            error: 'Failed to get object by external ID: Not Found - Entity not found',
             originalError: expect.any(Error)
         });
     });
-    it('should throw error when entityType is missing', async () => {
-        await expect(graphClient.getEntityByExternalId({
-            entityType: '',
+    it('should throw error when objectType is missing', async () => {
+        await expect(graphClient.getObjectByExternalId({
+            objectType: '',
             externalId: 'pipelines/123/builds/456'
-        })).rejects.toThrow('entityType is required');
+        })).rejects.toThrow('objectType is required');
     });
     it('should throw error when externalId is missing', async () => {
-        await expect(graphClient.getEntityByExternalId({
-            entityType: 'atlassian:document',
+        await expect(graphClient.getObjectByExternalId({
+            objectType: 'atlassian:document',
             externalId: ''
         })).rejects.toThrow('externalId is required');
     });
 });
-describe('TeamWorkGraphClient - deleteEntitiesByExternalId', () => {
+describe('TeamWorkGraphClient - deleteObjectsByExternalId', () => {
     let graphClient;
     let mockFetch;
     beforeEach(() => {
@@ -277,7 +285,7 @@ describe('TeamWorkGraphClient - deleteEntitiesByExternalId', () => {
         api_1.__fetchProduct.mockReturnValue(mockFetch);
         jest.clearAllMocks();
     });
-    it('should successfully delete entities in bulk', async () => {
+    it('should successfully delete objects in bulk', async () => {
         const expectedResponse = {
             success: true,
             results: [
@@ -289,8 +297,8 @@ describe('TeamWorkGraphClient - deleteEntitiesByExternalId', () => {
             ok: true,
             json: () => Promise.resolve(expectedResponse)
         });
-        const result = await graphClient.deleteEntitiesByExternalId({
-            entityType: 'atlassian:document',
+        const result = await graphClient.deleteObjectsByExternalId({
+            objectType: 'atlassian:document',
             externalIds: ['pipelines/123/builds/456', 'pipelines/123/builds/789']
         });
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk/delete', {
@@ -304,33 +312,33 @@ describe('TeamWorkGraphClient - deleteEntitiesByExternalId', () => {
         });
         expect(result).toEqual(expectedResponse);
     });
-    it('should throw error when entityType is missing', async () => {
-        await expect(graphClient.deleteEntitiesByExternalId({
-            entityType: '',
+    it('should throw error when objectType is missing', async () => {
+        await expect(graphClient.deleteObjectsByExternalId({
+            objectType: '',
             externalIds: ['pipelines/123/builds/456']
-        })).rejects.toThrow('entityType is required');
+        })).rejects.toThrow('objectType is required');
     });
     it('should throw error when externalIds array is empty', async () => {
-        await expect(graphClient.deleteEntitiesByExternalId({
-            entityType: 'atlassian:document',
+        await expect(graphClient.deleteObjectsByExternalId({
+            objectType: 'atlassian:document',
             externalIds: []
         })).rejects.toThrow('externalIds array cannot be empty');
     });
     it('should throw error when externalIds array exceeds limit', async () => {
-        const manyExternalIds = Array(validators_1.MAX_BULK_ENTITIES_DELETE + 1).fill('pipelines/123/builds/456');
-        await expect(graphClient.deleteEntitiesByExternalId({
-            entityType: 'atlassian:document',
+        const manyExternalIds = Array(validators_1.MAX_BULK_OBJECTS_DELETE + 1).fill('pipelines/123/builds/456');
+        await expect(graphClient.deleteObjectsByExternalId({
+            objectType: 'atlassian:document',
             externalIds: manyExternalIds
-        })).rejects.toThrow(`Bulk entity deletion supports maximum ${validators_1.MAX_BULK_ENTITIES_DELETE} entities`);
+        })).rejects.toThrow(`Bulk object deletion supports maximum ${validators_1.MAX_BULK_OBJECTS_DELETE} objects`);
     });
     it('should throw error when externalIds is not an array', async () => {
-        await expect(graphClient.deleteEntitiesByExternalId({
-            entityType: 'atlassian:document',
+        await expect(graphClient.deleteObjectsByExternalId({
+            objectType: 'atlassian:document',
             externalIds: null
         })).rejects.toThrow('externalIds must be an array');
     });
 });
-describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
+describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
     let graphClient;
     let mockFetch;
     beforeEach(() => {
@@ -339,19 +347,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
         api_1.__fetchProduct.mockReturnValue(mockFetch);
         jest.clearAllMocks();
     });
-    it('should successfully delete entities by properties', async () => {
+    it('should successfully delete objects by properties', async () => {
         const expectedResponse = {
             success: true,
             results: [
-                { entityId: 'entity-123', success: true },
-                { entityId: 'entity-456', success: true }
+                { objectId: 'entity-123', success: true },
+                { objectId: 'entity-456', success: true }
             ]
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expectedResponse)
         });
-        const result = await graphClient.deleteEntitiesByProperties({
+        const result = await graphClient.deleteObjectsByProperties({
             environment: 'staging',
             status: 'failed'
         });
@@ -369,13 +377,13 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
     it('should handle complex properties object', async () => {
         const expectedResponse = {
             success: true,
-            results: [{ entityId: 'entity-789', success: true }]
+            results: [{ objectId: 'entity-789', success: true }]
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expectedResponse)
         });
-        const result = await graphClient.deleteEntitiesByProperties({
+        const result = await graphClient.deleteObjectsByProperties({
             environment: 'production',
             status: 'completed',
             priority: 'high',
@@ -397,16 +405,16 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
         expect(result).toEqual(expectedResponse);
     });
     it('should throw error when properties is missing', async () => {
-        await expect(graphClient.deleteEntitiesByProperties(null)).rejects.toThrow('properties must be an object');
+        await expect(graphClient.deleteObjectsByProperties(null)).rejects.toThrow('properties must be an object');
     });
     it('should throw error when properties is not an object', async () => {
-        await expect(graphClient.deleteEntitiesByProperties('not-an-object')).rejects.toThrow('properties must be an object');
+        await expect(graphClient.deleteObjectsByProperties('not-an-object')).rejects.toThrow('properties must be an object');
     });
     it('should throw error when properties object is empty', async () => {
-        await expect(graphClient.deleteEntitiesByProperties({})).rejects.toThrow('properties object cannot be empty');
+        await expect(graphClient.deleteObjectsByProperties({})).rejects.toThrow('properties object cannot be empty');
     });
     it('posts branch entities to /api/v1/entities/bulk and returns response', async () => {
-        const branchEntity = {
+        const branchObject = {
             schemaVersion: '2.0',
             id: 'branch-1',
             updateSequenceNumber: 1,
@@ -414,31 +422,33 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             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'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:branch': {}
         };
-        const req = { entities: [branchEntity] };
-        const expected = { success: true, results: [{ entityId: 'branch-1', success: true }] };
+        const req = { objects: [branchObject] };
+        const expected = { success: true, results: [{ objectId: 'branch-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(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 = {
+        const commitObject = {
             schemaVersion: '2.0',
             id: 'commit-1',
             updateSequenceNumber: 1,
@@ -446,17 +456,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             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'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:commit': {
                 flags: ['flag1', 'flag2'],
                 fileCount: 10,
@@ -471,18 +483,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             }
         };
-        const req = { entities: [commitEntity] };
-        const expected = { success: true, results: [{ entityId: 'commit-1', success: true }] };
+        const req = { objects: [commitObject] };
+        const expected = { success: true, results: [{ objectId: 'commit-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts build entities to /api/v1/entities/bulk and returns response', async () => {
-        const buildEntity = {
+        const buildObject = {
             schemaVersion: '2.0',
             id: 'build-1',
             updateSequenceNumber: 1,
@@ -490,17 +502,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://ci.example.com/builds/42',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:build': {
                 pipelineId: 'pipeline-123',
                 buildNumber: 42,
@@ -527,18 +541,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             }
         };
-        const req = { entities: [buildEntity] };
-        const expected = { success: true, results: [{ entityId: 'build-1', success: true }] };
+        const req = { objects: [buildObject] };
+        const expected = { success: true, results: [{ objectId: 'build-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts calendar event entities to /api/v1/entities/bulk and returns response', async () => {
-        const calendarEventEntity = {
+        const calendarEventObject = {
             schemaVersion: '2.0',
             id: 'calendar-event-1',
             updateSequenceNumber: 1,
@@ -548,17 +562,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             createdAt: '2024-07-09T14:27:37.000Z',
             createdBy: {},
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:calendar-event': {
                 eventStartTime: '2024-07-10T09:00:00.000Z',
                 eventEndTime: '2024-07-10T10:00:00.000Z',
@@ -598,18 +614,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             }
         };
-        const req = { entities: [calendarEventEntity] };
-        const expected = { success: true, results: [{ entityId: 'calendar-event-1', success: true }] };
+        const req = { objects: [calendarEventObject] };
+        const expected = { success: true, results: [{ objectId: 'calendar-event-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts comment entities to /api/v1/entities/bulk and returns response', async () => {
-        const commentEntity = {
+        const commentObject = {
             schemaVersion: '2.0',
             id: 'comment-1',
             updateSequenceNumber: 1,
@@ -622,17 +638,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 displayName: 'Jane Developer'
             },
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:comment': {
                 text: 'This is a really well-implemented feature. The code is clean and the tests are comprehensive. Thanks for the hard work!',
                 reactionsV2: [
@@ -643,18 +661,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             }
         };
-        const req = { entities: [commentEntity] };
-        const expected = { success: true, results: [{ entityId: 'comment-1', success: true }] };
+        const req = { objects: [commentObject] };
+        const expected = { success: true, results: [{ objectId: 'comment-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts conversation entities to /api/v1/entities/bulk and returns response', async () => {
-        const conversationEntity = {
+        const conversationObject = {
             schemaVersion: '2.0',
             id: 'conversation-1',
             updateSequenceNumber: 1,
@@ -663,17 +681,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://slack.com/channels/dev-team',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:conversation': {
                 type: 'channel',
                 membershipType: 'public',
@@ -707,18 +727,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 memberCount: 3
             }
         };
-        const req = { entities: [conversationEntity] };
-        const expected = { success: true, results: [{ entityId: 'conversation-1', success: true }] };
+        const req = { objects: [conversationObject] };
+        const expected = { success: true, results: [{ objectId: 'conversation-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts customer org entities to /api/v1/entities/bulk and returns response', async () => {
-        const customerOrgEntity = {
+        const customerOrgObject = {
             schemaVersion: '2.0',
             id: 'customer-org-1',
             updateSequenceNumber: 1,
@@ -727,17 +747,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://crm.example.com/customers/acme-corp',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:customer-org': {
                 contacts: [
                     {
@@ -780,18 +802,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 accountType: 'Enterprise'
             }
         };
-        const req = { entities: [customerOrgEntity] };
-        const expected = { success: true, results: [{ entityId: 'customer-org-1', success: true }] };
+        const req = { objects: [customerOrgObject] };
+        const expected = { success: true, results: [{ objectId: 'customer-org-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deal entities to /api/v1/entities/bulk and returns response', async () => {
-        const dealEntity = {
+        const dealObject = {
             schemaVersion: '2.0',
             id: 'deal-1',
             updateSequenceNumber: 1,
@@ -800,17 +822,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://crm.example.com/deals/enterprise-software-123',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:deal': {
                 contact: {
                     accountId: 'contact-deal-123',
@@ -853,18 +877,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 isClosed: false
             }
         };
-        const req = { entities: [dealEntity] };
-        const expected = { success: true, results: [{ entityId: 'deal-1', success: true }] };
+        const req = { objects: [dealObject] };
+        const expected = { success: true, results: [{ objectId: 'deal-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deployment entities to /api/v1/entities/bulk and returns response', async () => {
-        const deploymentEntity = {
+        const deploymentObject = {
             schemaVersion: '2.0',
             id: 'deployment-1',
             updateSequenceNumber: 1,
@@ -873,17 +897,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://ci.example.com/deployments/prod-api-v2.4.5',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:deployment': {
                 deploymentSequenceNumber: 12345,
                 label: 'v2.4.5 - Bug fixes and performance improvements',
@@ -922,18 +948,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 region: 'us-east-1'
             }
         };
-        const req = { entities: [deploymentEntity] };
-        const expected = { success: true, results: [{ entityId: 'deployment-1', success: true }] };
+        const req = { objects: [deploymentObject] };
+        const expected = { success: true, results: [{ objectId: 'deployment-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts design entities to /api/v1/entities/bulk and returns response', async () => {
-        const designEntity = {
+        const designObject = {
             schemaVersion: '2.0',
             id: 'design-1',
             updateSequenceNumber: 1,
@@ -942,17 +968,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://figma.com/design/mobile-login-screen',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:design': {
                 liveEmbedUrl: 'https://figma.com/embed/mobile-login-screen',
                 inspectUrl: 'https://figma.com/inspect/mobile-login-screen',
@@ -961,18 +989,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 iconUrl: 'https://figma.com/icons/mobile-login-screen.svg'
             }
         };
-        const req = { entities: [designEntity] };
-        const expected = { success: true, results: [{ entityId: 'design-1', success: true }] };
+        const req = { objects: [designObject] };
+        const expected = { success: true, results: [{ objectId: 'design-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts position entities to /api/v1/entities/bulk and returns response', async () => {
-        const positionEntity = {
+        const positionObject = {
             schemaVersion: '2.0',
             id: 'position-1',
             updateSequenceNumber: 1,
@@ -980,21 +1008,23 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://hr.example.com/positions/senior-backend-engineer',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             parentKey: {
                 type: 'atlassian:organisation',
                 value: {
-                    entityId: 'org-tech-company-123'
+                    objectId: 'org-tech-company-123'
                 }
             },
             associations: {
@@ -1011,18 +1041,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 jobTitle: 'Senior Software Engineer - Backend'
             }
         };
-        const req = { entities: [positionEntity] };
-        const expected = { success: true, results: [{ entityId: 'position-1', success: true }] };
+        const req = { objects: [positionObject] };
+        const expected = { success: true, results: [{ objectId: 'position-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts project entities to /api/v1/entities/bulk and returns response', async () => {
-        const projectEntity = {
+        const projectObject = {
             schemaVersion: '2.0',
             id: 'project-1',
             updateSequenceNumber: 1,
@@ -1042,17 +1072,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             },
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:project': {
                 key: 'ECOM-123',
                 dueDate: '2024-12-31T23:59:59.000Z',
@@ -1090,18 +1122,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 watchersCount: 8
             }
         };
-        const req = { entities: [projectEntity] };
-        const expected = { success: true, results: [{ entityId: 'project-1', success: true }] };
+        const req = { objects: [projectObject] };
+        const expected = { success: true, results: [{ objectId: 'project-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts pull request entities to /api/v1/entities/bulk and returns response', async () => {
-        const pullRequestEntity = {
+        const pullRequestObject = {
             schemaVersion: '2.0',
             id: 'pr-1',
             updateSequenceNumber: 1,
@@ -1112,21 +1144,23 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             containerKey: {
                 type: 'atlassian:repository',
                 value: {
-                    entityId: 'repo-company-main-123'
+                    objectId: 'repo-company-main-123'
                 }
             },
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:pull-request': {
                 title: 'Add user authentication feature',
                 displayId: 'PR-42',
@@ -1170,35 +1204,37 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 taskCount: 3
             }
         };
-        const req = { entities: [pullRequestEntity] };
-        const expected = { success: true, results: [{ entityId: 'pr-1', success: true }] };
+        const req = { objects: [pullRequestObject] };
+        const expected = { success: true, results: [{ objectId: 'pr-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts remote link entities to /api/v1/entities/bulk and returns response', async () => {
-        const remoteLinkEntity = {
+        const remoteLinkObject = {
             schemaVersion: '2.0',
             id: 'remote-link-1',
             updateSequenceNumber: 1,
             displayName: 'JIRA Issue Link - Fix user authentication bug',
             url: 'https://company.atlassian.net/browse/AUTH-123',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:remote-link': {
                 type: 'issue',
                 status: {
@@ -1234,18 +1270,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 fullNounThirdPartyAri: 'ari:cloud:jira:company-site:issue/AUTH-123'
             }
         };
-        const req = { entities: [remoteLinkEntity] };
-        const expected = { success: true, results: [{ entityId: 'remote-link-1', success: true }] };
+        const req = { objects: [remoteLinkObject] };
+        const expected = { success: true, results: [{ objectId: 'remote-link-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts repository entities to /api/v1/entities/bulk and returns response', async () => {
-        const repositoryEntity = {
+        const repositoryObject = {
             schemaVersion: '2.0',
             id: 'repository-1',
             updateSequenceNumber: 1,
@@ -1253,17 +1289,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://github.com/company/ecommerce-backend',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:repository': {
                 name: 'ecommerce-backend',
                 forkOf: 'https://github.com/upstream/ecommerce-platform',
@@ -1271,18 +1309,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 avatarDescription: 'Company logo representing the ecommerce backend repository'
             }
         };
-        const req = { entities: [repositoryEntity] };
-        const expected = { success: true, results: [{ entityId: 'repository-1', success: true }] };
+        const req = { objects: [repositoryObject] };
+        const expected = { success: true, results: [{ objectId: 'repository-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts software service entities to /api/v1/entities/bulk and returns response', async () => {
-        const softwareServiceEntity = {
+        const softwareServiceObject = {
             schemaVersion: '2.0',
             id: 'software-service-1',
             updateSequenceNumber: 1,
@@ -1290,17 +1328,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://monitoring.example.com/services/payment-processor',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:software-service': {
                 description: 'Microservice responsible for processing all payment transactions with secure payment gateway integration',
                 associationsMetadata: {
@@ -1317,18 +1357,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 serviceType: 'REST API'
             }
         };
-        const req = { entities: [softwareServiceEntity] };
-        const expected = { success: true, results: [{ entityId: 'software-service-1', success: true }] };
+        const req = { objects: [softwareServiceObject] };
+        const expected = { success: true, results: [{ objectId: 'software-service-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts space entities to /api/v1/entities/bulk and returns response', async () => {
-        const spaceEntity = {
+        const spaceObject = {
             schemaVersion: '2.0',
             id: 'space-1',
             updateSequenceNumber: 1,
@@ -1336,17 +1376,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://company.atlassian.net/wiki/spaces/ENGDOC',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:space': {
                 key: 'ENGDOC',
                 spaceType: 'global',
@@ -1360,18 +1402,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 labels: ['engineering', 'documentation', 'team-resources', 'best-practices', 'onboarding']
             }
         };
-        const req = { entities: [spaceEntity] };
-        const expected = { success: true, results: [{ entityId: 'space-1', success: true }] };
+        const req = { objects: [spaceObject] };
+        const expected = { success: true, results: [{ objectId: 'space-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts video entities to /api/v1/entities/bulk and returns response', async () => {
-        const videoEntity = {
+        const videoObject = {
             schemaVersion: '2.0',
             id: 'video-1',
             updateSequenceNumber: 1,
@@ -1379,17 +1421,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://company.video.com/watch/react-hooks-intro',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:video': {
                 thumbnailUrl: 'https://company.video.com/thumbnails/react-hooks-intro.jpg',
                 embedUrl: 'https://company.video.com/embed/react-hooks-intro',
@@ -1475,18 +1519,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 ]
             }
         };
-        const req = { entities: [videoEntity] };
-        const expected = { success: true, results: [{ entityId: 'video-1', success: true }] };
+        const req = { objects: [videoObject] };
+        const expected = { success: true, results: [{ objectId: 'video-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts work item entities to /api/v1/entities/bulk and returns response', async () => {
-        const workItemEntity = {
+        const workItemObject = {
             schemaVersion: '2.0',
             id: 'work-item-1',
             updateSequenceNumber: 1,
@@ -1497,21 +1541,23 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             containerKey: {
                 type: 'atlassian:space',
                 value: {
-                    entityId: 'space-engineering-team-docs'
+                    objectId: 'space-engineering-team-docs'
                 }
             },
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:work-item': {
                 dueDate: '2024-08-15T17:00:00.000Z',
                 assignee: {
@@ -1569,18 +1615,18 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 team: 'Backend Infrastructure Team'
             }
         };
-        const req = { entities: [workItemEntity] };
-        const expected = { success: true, results: [{ entityId: 'work-item-1', success: true }] };
+        const req = { objects: [workItemObject] };
+        const expected = { success: true, results: [{ objectId: 'work-item-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts worker entities to /api/v1/entities/bulk and returns response', async () => {
-        const workerEntity = {
+        const workerObject = {
             schemaVersion: '2.0',
             id: 'worker-1',
             updateSequenceNumber: 1,
@@ -1588,17 +1634,19 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
             url: 'https://hr.example.com/employees/sarah-johnson',
             createdAt: '2024-07-09T14:27:37.000Z',
             lastUpdatedAt: '2024-07-09T14:27:37.000Z',
-            permissions: {
-                accessControls: [
-                    {
-                        principals: [
-                            {
-                                type: 'EVERYONE'
-                            }
-                        ]
-                    }
-                ]
-            },
+            permissions: [
+                {
+                    accessControls: [
+                        {
+                            principals: [
+                                {
+                                    type: 'EVERYONE'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
             'atlassian:worker': {
                 hiredAt: '2022-03-15T09:00:00.000Z',
                 workerUser: {
@@ -1614,13 +1662,13 @@ describe('TeamWorkGraphClient - deleteEntitiesByProperties', () => {
                 customAndSensitiveData: 'Employee ID: EMP001234, Department: Engineering, Salary Grade: L5, Manager: Alex Rodriguez, Office Location: San Francisco HQ'
             }
         };
-        const req = { entities: [workerEntity] };
-        const expected = { success: true, results: [{ entityId: 'worker-1', success: true }] };
+        const req = { objects: [workerObject] };
+        const expected = { success: true, results: [{ objectId: 'worker-1', success: true }] };
         mockFetch.mockResolvedValueOnce({
             ok: true,
             json: () => Promise.resolve(expected)
         });
-        const result = await graphClient.setEntities(req);
+        const result = await graphClient.setObjects(req);
         expect(mockFetch).toHaveBeenCalledWith('/graph/connector/api/v1/entities/bulk', expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });