@forge/teamwork-graph 2.2.0-next.2 → 2.2.0-next.3

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

@@ -43,7 +43,7 @@ describe('TeamWorkGraphClient - setObjects', () => {
             ],
             'atlassian:document': {
                 type: {
-                    category: 'document',
+                    category: 'DOCUMENT',
                     iconUrl: 'http://icon.com'
                 },
                 content: {
@@ -81,7 +81,7 @@ describe('TeamWorkGraphClient - setObjects', () => {
             ],
             'atlassian:document': {
                 type: {
-                    category: 'document',
+                    category: 'DOCUMENT',
                     iconUrl: 'http://icon.com'
                 },
                 content: {
@@ -91,13 +91,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             }
         };
         const req = { objects: [documentObject] };
-        const expected = { success: true, results: [{ objectId: 'my-document', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:document',
+                    entityId: { id: 'my-document' },
+                    thirdPartyAri: 'ari:third-party:test::document/my-document'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts message entities to /api/v1/entities/bulk and returns response', async () => {
@@ -142,13 +154,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             }
         };
         const req = { objects: [messageObject] };
-        const expected = { success: true, results: [{ objectId: 'message-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:message',
+                    entityId: { id: 'message-1' },
+                    thirdPartyAri: 'ari:third-party:test::message/message-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts organisation entities to /api/v1/entities/bulk and returns response', async () => {
@@ -182,13 +206,25 @@ describe('TeamWorkGraphClient - setObjects', () => {
             'atlassian:organisation': {}
         };
         const req = { objects: [organisationObject] };
-        const expected = { success: false, results: [{ objectId: 'org-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:organisation',
+                    entityId: { id: 'org-1' },
+                    thirdPartyAri: 'ari:third-party:test::organisation/org-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('throws if objects is not an array', async () => {
@@ -224,13 +260,13 @@ describe('TeamWorkGraphClient - getObjectByExternalId', () => {
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expectedObject)
+            json: () => Promise.resolve({ entities: [expectedObject] })
         });
         const result = await graphClient.getObjectByExternalId({
             objectType: 'atlassian:document',
             externalId: 'pipelines/123/builds/456'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.GET_BY_EXTERNAL_ID), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.GET_BY_EXTERNAL_ID), {
             method: 'POST',
             redirect: 'follow',
             headers: { 'Content-Type': 'application/json' },
@@ -291,22 +327,25 @@ describe('TeamWorkGraphClient - deleteObjectsByExternalId', () => {
         jest.clearAllMocks();
     });
     it('should successfully delete objects in bulk', async () => {
+        const backendResponse = {
+            deleted: [
+                { entityType: 'atlassian:document', entityId: { entityId: 'pipelines/123/builds/456' } },
+                { entityType: 'atlassian:document', entityId: { entityId: 'pipelines/123/builds/789' } }
+            ]
+        };
         const expectedResponse = {
             success: true,
-            results: [
-                { externalId: 'pipelines/123/builds/456', success: true },
-                { externalId: 'pipelines/123/builds/789', success: true }
-            ]
+            results: backendResponse.deleted
         };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expectedResponse)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.deleteObjectsByExternalId({
             objectType: 'atlassian:document',
             externalIds: ['pipelines/123/builds/456', 'pipelines/123/builds/789']
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK_DELETE), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK_DELETE), {
             method: 'DELETE',
             body: JSON.stringify({
                 entityType: 'atlassian:document',
@@ -368,7 +407,7 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             environment: 'staging',
             status: 'failed'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.DELETE_BY_PROPERTIES), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.DELETE_BY_PROPERTIES), {
             method: 'DELETE',
             body: JSON.stringify({
                 environment: 'staging',
@@ -395,7 +434,7 @@ describe('TeamWorkGraphClient - deleteObjectsByProperties', () => {
             team: 'backend',
             region: 'us-east-1'
         });
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.DELETE_BY_PROPERTIES), {
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.DELETE_BY_PROPERTIES), {
             method: 'DELETE',
             body: JSON.stringify({
                 environment: 'production',
@@ -453,13 +492,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             'atlassian:branch': {}
         };
         const req = { objects: [branchObject] };
-        const expected = { success: true, results: [{ objectId: 'branch-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:branch',
+                    entityId: { id: 'branch-1' },
+                    thirdPartyAri: 'ari:third-party:test::branch/branch-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts commit entities to /api/v1/entities/bulk and returns response', async () => {
@@ -499,13 +550,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [commitObject] };
-        const expected = { success: true, results: [{ objectId: 'commit-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:commit',
+                    entityId: { id: 'commit-1' },
+                    thirdPartyAri: 'ari:third-party:test::commit/commit-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts build entities to /api/v1/entities/bulk and returns response', async () => {
@@ -557,13 +620,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [buildObject] };
-        const expected = { success: true, results: [{ objectId: 'build-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:build',
+                    entityId: { id: 'build-1' },
+                    thirdPartyAri: 'ari:third-party:test::build/build-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts calendar event entities to /api/v1/entities/bulk and returns response', async () => {
@@ -630,13 +705,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [calendarEventObject] };
-        const expected = { success: true, results: [{ objectId: 'calendar-event-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:calendar-event',
+                    entityId: { id: 'calendar-event-1' },
+                    thirdPartyAri: 'ari:third-party:test::calendar-event/calendar-event-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts comment entities to /api/v1/entities/bulk and returns response', async () => {
@@ -677,13 +764,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [commentObject] };
-        const expected = { success: true, results: [{ objectId: 'comment-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:comment',
+                    entityId: { id: 'comment-1' },
+                    thirdPartyAri: 'ari:third-party:test::comment/comment-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts conversation entities to /api/v1/entities/bulk and returns response', async () => {
@@ -743,13 +842,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [conversationObject] };
-        const expected = { success: true, results: [{ objectId: 'conversation-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:conversation',
+                    entityId: { id: 'conversation-1' },
+                    thirdPartyAri: 'ari:third-party:test::conversation/conversation-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts customer org entities to /api/v1/entities/bulk and returns response', async () => {
@@ -818,13 +929,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [customerOrgObject] };
-        const expected = { success: true, results: [{ objectId: 'customer-org-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:customer-org',
+                    entityId: { id: 'customer-org-1' },
+                    thirdPartyAri: 'ari:third-party:test::customer-org/customer-org-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deal entities to /api/v1/entities/bulk and returns response', async () => {
@@ -893,13 +1016,21 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [dealObject] };
-        const expected = { success: true, results: [{ objectId: 'deal-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                { entityType: 'atlassian:deal', entityId: { id: 'deal-1' }, thirdPartyAri: 'ari:third-party:test::deal/deal-1' }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts deployment entities to /api/v1/entities/bulk and returns response', async () => {
@@ -964,13 +1095,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [deploymentObject] };
-        const expected = { success: true, results: [{ objectId: 'deployment-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:deployment',
+                    entityId: { id: 'deployment-1' },
+                    thirdPartyAri: 'ari:third-party:test::deployment/deployment-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts design entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1005,13 +1148,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [designObject] };
-        const expected = { success: true, results: [{ objectId: 'design-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:design',
+                    entityId: { id: 'design-1' },
+                    thirdPartyAri: 'ari:third-party:test::design/design-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts position entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1057,13 +1212,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [positionObject] };
-        const expected = { success: true, results: [{ objectId: 'position-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:position',
+                    entityId: { id: 'position-1' },
+                    thirdPartyAri: 'ari:third-party:test::position/position-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts project entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1138,13 +1305,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [projectObject] };
-        const expected = { success: true, results: [{ objectId: 'project-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:project',
+                    entityId: { id: 'project-1' },
+                    thirdPartyAri: 'ari:third-party:test::project/project-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts pull request entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1220,13 +1399,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [pullRequestObject] };
-        const expected = { success: true, results: [{ objectId: 'pr-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:pull-request',
+                    entityId: { id: 'pr-1' },
+                    thirdPartyAri: 'ari:third-party:test::pull-request/pr-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts remote link entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1286,13 +1477,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [remoteLinkObject] };
-        const expected = { success: true, results: [{ objectId: 'remote-link-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:remote-link',
+                    entityId: { id: 'remote-link-1' },
+                    thirdPartyAri: 'ari:third-party:test::remote-link/remote-link-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts repository entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1325,13 +1528,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [repositoryObject] };
-        const expected = { success: true, results: [{ objectId: 'repository-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:repository',
+                    entityId: { id: 'repository-1' },
+                    thirdPartyAri: 'ari:third-party:test::repository/repository-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts software service entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1373,13 +1588,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [softwareServiceObject] };
-        const expected = { success: true, results: [{ objectId: 'software-service-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:software-service',
+                    entityId: { id: 'software-service-1' },
+                    thirdPartyAri: 'ari:third-party:test::software-service/software-service-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts space entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1418,13 +1645,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [spaceObject] };
-        const expected = { success: true, results: [{ objectId: 'space-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:space',
+                    entityId: { id: 'space-1' },
+                    thirdPartyAri: 'ari:third-party:test::space/space-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts video entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1535,13 +1774,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [videoObject] };
-        const expected = { success: true, results: [{ objectId: 'video-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:video',
+                    entityId: { id: 'video-1' },
+                    thirdPartyAri: 'ari:third-party:test::video/video-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts work item entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1631,13 +1882,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [workItemObject] };
-        const expected = { success: true, results: [{ objectId: 'work-item-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:work-item',
+                    entityId: { id: 'work-item-1' },
+                    thirdPartyAri: 'ari:third-party:test::work-item/work-item-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts worker entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1678,13 +1941,25 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [workerObject] };
-        const expected = { success: true, results: [{ objectId: 'worker-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:worker',
+                    entityId: { id: 'worker-1' },
+                    thirdPartyAri: 'ari:third-party:test::worker/worker-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: { accepted: backendResponse.accepted, rejected: undefined, validEntities: undefined }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts dashboard entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1723,13 +1998,29 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [dashboardObject] };
-        const expected = { success: true, results: [{ objectId: 'dashboard-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:dashboard',
+                    entityId: { id: 'dashboard-1' },
+                    thirdPartyAri: 'ari:third-party:test::dashboard/dashboard-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts test entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1764,13 +2055,29 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [testObject] };
-        const expected = { success: true, results: [{ objectId: 'test-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test',
+                    entityId: { id: 'test-1' },
+                    thirdPartyAri: 'ari:third-party:test::test/test-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts test execution entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1803,13 +2110,29 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [testExecutionObject] };
-        const expected = { success: true, results: [{ objectId: 'test-execution-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-execution',
+                    entityId: { id: 'test-execution-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-execution/test-execution-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts test plan entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1838,13 +2161,29 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             'atlassian:test-plan': {}
         };
         const req = { objects: [testPlanObject] };
-        const expected = { success: true, results: [{ objectId: 'test-plan-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-plan',
+                    entityId: { id: 'test-plan-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-plan/test-plan-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
     it('posts test run entities to /api/v1/entities/bulk and returns response', async () => {
@@ -1888,13 +2227,29 @@ describe('TeamWorkGraphClient - bulk entities', () => {
             }
         };
         const req = { objects: [testRunObject] };
-        const expected = { success: true, results: [{ objectId: 'test-run-1', success: true }] };
+        const backendResponse = {
+            accepted: [
+                {
+                    entityType: 'atlassian:test-run',
+                    entityId: { id: 'test-run-1' },
+                    thirdPartyAri: 'ari:third-party:test::test-run/test-run-1'
+                }
+            ]
+        };
+        const expected = {
+            success: true,
+            results: {
+                accepted: backendResponse.accepted,
+                rejected: undefined,
+                validEntities: undefined
+            }
+        };
         mockFetch.mockResolvedValueOnce({
             ok: true,
-            json: () => Promise.resolve(expected)
+            json: () => Promise.resolve(backendResponse)
         });
         const result = await graphClient.setObjects(req);
-        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.ENTITIES.BULK), expect.objectContaining({ method: 'POST' }));
+        expect(mockFetch).toHaveBeenCalledWith((0, endpoints_1.getFullPath)(endpoints_1.ENDPOINTS.OBJECTS.BULK), expect.objectContaining({ method: 'POST' }));
         expect(result).toEqual(expected);
     });
 });