@forge/events 1.0.3 → 2.0.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @forge/events
 
+## 2.0.0-next.1
+
+### Major Changes
+
+- a89e05a: Restrict async events payload to objects
+- 81174c3: Change `queue.push()` to accept events containing body and delay
+- 9227948: Simplify JobProgress.getStats to return stats directly and remove unneeded response from JobProgress.cancel
+
+## 1.1.0-next.0
+
+### Minor Changes
+
+- 34386db: App events API
+
 ## 1.0.3
 
 ### Patch Changes

package/README.md

@@ -1,39 +1,45 @@
-Library for asynchronous data processing.
+# Forge Events
 
-Usage example:
+Library for [asynchronous data processing](https://developer.atlassian.com/platform/forge/runtime-reference/async-events-api/) in Forge.
 
-```javascript
-import fetch, { RequestInit } from 'node-fetch';
+## Requirements
 
-import { Queue } from './index';
+See [Set up Forge](https://developer.atlassian.com/platform/forge/set-up-forge/) for details of the software required to develop Forge apps.
 
-const API_BASE = 'https://api.atlassian.com';
+## Usage
 
-// For Async service auth
-const appContextAri = 'ari:cloud:jira::site/...';
-const token = '...';
+### Pushing events to the queue
 
-async function apiClient(path: string, init: RequestInit): Promise<APIResponse> {
-  const url = API_BASE + path;
+```typescript
 
-  const extraHeaders = {
-    // See add-forge-user-agent.ts
-    'X-Forge-Context': appContextAri,
+async function pushEvent() {
+  const { jobId } = await queue.push({
+    body: {
+      hello: 'world'
+    }
+  });
 
-    Authorization: `Bearer ${token}`
-  };
-
-  init.headers = Object.assign(init.headers!, extraHeaders);
-  return fetch(url, init);
+  const jobProgress = queue.getJob(jobId);
+  const { success, inProgress, failed } = await jobProgress.getStats();
 }
+```
+
+### Consuming events from the queue
+
+```typescript
+import { AsyncEvent } from '@forge/events';
 
-async function demo() {
-  const queue = new Queue({key: "queue-name"}, apiClient);
-  const payloads = {
-    page: 1
+export async function eventListener(event: AsyncEvent, context) {
+  const jobProgress = queue.getJob(event.jobId);
+
+  try {
+    // process the event
+  } catch (error) {
+    await jobProgress.cancel();
   }
-  await queue.push([payloads])
 }
-
-demo();
 ```
+
+## Support
+
+See [Get help](https://developer.atlassian.com/platform/forge/get-help/) for how to get help and provide feedback.

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

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

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

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

package/out/__test__/appEvents.test.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const appEvents_1 = require("../appEvents");
+const queries_1 = require("../queries");
+const api_1 = require("@forge/api");
+jest.mock('../queries', () => ({
+    post: jest.fn()
+}));
+jest.mock('@forge/api', () => ({
+    __requestAtlassianAsApp: jest.fn()
+}));
+describe('appEvents', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('publishEvent', () => {
+        it('should call post with the correct parameters', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({
+                    failedEvents: []
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(queries_1.post).toHaveBeenCalledTimes(1);
+            expect(queries_1.post).toHaveBeenCalledWith('/forge/events/v1/app-events', {
+                events: [
+                    {
+                        key: event.key
+                    }
+                ]
+            }, api_1.__requestAtlassianAsApp);
+            expect(result).toEqual({ type: 'success', failedEvents: [] });
+        });
+        it('should return a success result for successful requests', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({
+                    failedEvents: []
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({ type: 'success', failedEvents: [] });
+        });
+        it('should return an error result for failed requests', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: false,
+                status: 500,
+                json: jest.fn().mockResolvedValue({
+                    errorMessages: ['Internal server error']
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({
+                type: 'error',
+                errorType: 'SERVICE_ERROR',
+                errorMessage: 'Internal server error'
+            });
+        });
+        it('should handle validation errors', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: false,
+                status: 400,
+                json: jest.fn().mockResolvedValue({
+                    errorMessages: ['Invalid event type']
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({
+                type: 'error',
+                errorType: 'VALIDATION_ERROR',
+                errorMessage: 'Invalid event type'
+            });
+        });
+        it('should handle errors object in the error response', async () => {
+            const event = { key: 'test-event' };
+            const errorResponse = {
+                errorMessages: [],
+                errors: { key: 'Event key is required' }
+            };
+            const mockResponse = {
+                ok: false,
+                status: 400,
+                json: jest.fn().mockResolvedValue(errorResponse)
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({
+                type: 'error',
+                errorType: 'VALIDATION_ERROR',
+                errorMessage: 'key: Event key is required'
+            });
+        });
+        it('should use OTHER as errorType for unknown status codes', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: false,
+                status: 418,
+                json: jest.fn().mockResolvedValue({
+                    errorMessages: ['I refuse to brew coffee']
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({
+                type: 'error',
+                errorType: 'OTHER',
+                errorMessage: 'I refuse to brew coffee'
+            });
+        });
+        it('should handle empty error messages', async () => {
+            const event = { key: 'test-event' };
+            const mockResponse = {
+                ok: false,
+                status: 500,
+                json: jest.fn().mockResolvedValue({
+                    errorMessages: []
+                })
+            };
+            queries_1.post.mockResolvedValue(mockResponse);
+            const result = await appEvents_1.appEvents.publish(event);
+            expect(result).toEqual({
+                type: 'error',
+                errorType: 'SERVICE_ERROR',
+                errorMessage: '{"errorMessages":[]}'
+            });
+        });
+    });
+});

package/out/__test__/jobProgress.test.js

@@ -5,7 +5,7 @@ const errors_1 = require("../errors");
 const jobProgress_1 = require("../jobProgress");
 const api_1 = require("@forge/api");
 jest.mock('@forge/api', () => ({
-    __requestAtlassianAsApp: (0, utils_1.getMockFetchMethod)('done', 200)
+    __requestAtlassianAsApp: (0, utils_1.getMockFetchMethod)({ done: true }, 200)
 }));
 const getJobProgress = (jobId, apiClientMock) => new jobProgress_1.JobProgress(jobId, apiClientMock);
 describe('JobProgress methods', () => {
@@ -17,8 +17,7 @@ describe('JobProgress methods', () => {
                 failed: 1
             }, 200);
             const jobProgress = getJobProgress('test-queue-name#test-job-id', apiClientMock);
-            const response = await jobProgress.getStats();
-            const { success, inProgress, failed } = await response.json();
+            const { success, inProgress, failed } = await jobProgress.getStats();
             (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
                 queueName: 'test-queue-name',
                 jobId: 'test-job-id'
@@ -66,12 +65,11 @@ describe('JobProgress methods', () => {
         it('should call the queue/cancel endpoint', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 204);
             const jobProgress = getJobProgress('test-queue-name#test-job-id', apiClientMock);
-            const response = await jobProgress.cancel();
+            await jobProgress.cancel();
             (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/cancel/{contextAri}/{environmentId}/{appId}/{appVersion}', {
                 queueName: 'test-queue-name',
                 jobId: 'test-job-id'
             });
-            expect(response.status).toEqual(204);
         });
         it('should throw JobDoesNotExistError', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)({

package/out/__test__/queue.test.js

@@ -16,20 +16,51 @@ describe('Queue methods', () => {
             expect(() => getQueue('invalid name', apiClientMock)).toThrowError(new errors_1.InvalidQueueNameError('Queue names can only contain alphanumeric characters, dashes and underscores.'));
         });
     });
+    const PAYLOAD = { body: { page: 1 } };
     describe('push', () => {
-        it('should call the queue/publish endpoint', async () => {
+        it.each([
+            ['single payload', PAYLOAD, [PAYLOAD]],
+            ['payload array', [PAYLOAD, PAYLOAD], [PAYLOAD, PAYLOAD]]
+        ])('should call the queue/publish endpoint when given %s', async (_, payload, expectedPayload) => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)();
             const queue = getQueue('name', apiClientMock);
-            const payload = {
-                page: 1
-            };
-            await queue.push([payload]);
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [payload], 'name');
+            await queue.push(payload);
+            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, expectedPayload, 'name');
+        });
+        it.each([
+            ['number', 1],
+            ['string', 'test'],
+            ['boolean', true],
+            ['array', [1, 2, 3]],
+            ['null', null],
+            ['undefined', undefined],
+            ['array with non-object', [1]],
+            ['array with an array', [[2, 3]]]
+        ])('rejects non-object (%s) event', async (_, payload) => {
+            const apiClientMock = (0, utils_1.getMockFetchMethod)();
+            const queue = getQueue('name', apiClientMock);
+            await expect(queue.push(payload)).rejects.toThrow(new errors_1.InvalidPayloadError(`Event must be an object.`));
+            expect(apiClientMock).toHaveBeenCalledTimes(0);
+        });
+        it.each([
+            ['number', 1],
+            ['string', 'test'],
+            ['boolean', true],
+            ['array', [1, 2, 3]],
+            ['null', null],
+            ['undefined', undefined],
+            ['array with non-object', [1]],
+            ['array with an array', [[2, 3]]]
+        ])('rejects non-object (%s) event body', async (_, body) => {
+            const apiClientMock = (0, utils_1.getMockFetchMethod)();
+            const queue = getQueue('name', apiClientMock);
+            await expect(queue.push({ body })).rejects.toThrow(new errors_1.InvalidPayloadError(`Event body must be an object.`));
+            expect(apiClientMock).toHaveBeenCalledTimes(0);
         });
         it('should throw InvalidPushSettingsError for delay', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)();
             const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(1, { delayInSeconds: 901 })).rejects.toThrow(new errors_1.InvalidPushSettingsError(`The delayInSeconds setting must be between 0 and 900.`));
+            await expect(queue.push({ ...PAYLOAD, delayInSeconds: 901 })).rejects.toThrow(new errors_1.InvalidPushSettingsError(`The delayInSeconds setting must be between 0 and 900.`));
             expect(apiClientMock).toHaveBeenCalledTimes(0);
         });
         it('should throw NoEventsToPushError', async () => {
@@ -41,28 +72,26 @@ describe('Queue methods', () => {
         it('should throw TooManyEventsError', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)();
             const queue = getQueue('name', apiClientMock);
-            await expect(queue.push([...Array(51).keys()])).rejects.toThrow(new errors_1.TooManyEventsError(`This push contains more than the 50 events allowed.`));
+            await expect(queue.push(Array(51).fill(PAYLOAD))).rejects.toThrow(new errors_1.TooManyEventsError(`This push contains more than the 50 events allowed.`));
             expect(apiClientMock).toHaveBeenCalledTimes(0);
         });
         it('should throw PayloadTooBigError', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)();
             const queue = getQueue('name', apiClientMock);
-            await expect(queue.push('x'.repeat(201 * 1024))).rejects.toThrow(new errors_1.PayloadTooBigError(`The maximum payload size is 200KB.`));
+            await expect(queue.push({ body: { content: 'x'.repeat(201 * 1024) } })).rejects.toThrow(new errors_1.PayloadTooBigError(`The maximum payload size is 200KB.`));
             expect(apiClientMock).toHaveBeenCalledTimes(0);
         });
         it('should throw RateLimitError', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 429);
             const queue = getQueue('name', apiClientMock);
-            const payload = [...Array(10).keys()];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.RateLimitError(`Too many requests.`));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
+            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.RateLimitError(`Too many requests.`));
+            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
         });
         it('should throw InvocationLimitReachedError', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 405);
             const queue = getQueue('name', apiClientMock);
-            const payload = [...Array(5).keys()];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.InvocationLimitReachedError(`The limit on cyclic invocation has been reached.`));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
+            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InvocationLimitReachedError(`The limit on cyclic invocation has been reached.`));
+            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
         });
         it('should throw PartialSuccessError when there are failed events', async () => {
             const apiClientMock = (0, utils_1.getMockFetchMethod)({
@@ -80,26 +109,36 @@ describe('Queue methods', () => {
             const queue = getQueue('name', apiClientMock);
             const payload = [
                 {
-                    content: 'payload-1'
+                    body: {
+                        content: 'payload-1'
+                    }
                 },
                 {
-                    content: 'payload-2'
+                    body: {
+                        content: 'payload-2'
+                    }
                 },
                 {
-                    content: 'payload-3'
+                    body: {
+                        content: 'payload-3'
+                    }
                 }
             ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 2 event(s).`, [
+            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 2 event(s).`, { jobId: 'some-job-id' }, [
                 {
                     errorMessage: 'failed-1',
-                    payload: {
-                        content: 'payload-1'
+                    event: {
+                        body: {
+                            content: 'payload-1'
+                        }
                     }
                 },
                 {
                     errorMessage: 'failed-3',
-                    payload: {
-                        content: 'payload-3'
+                    event: {
+                        body: {
+                            content: 'payload-3'
+                        }
                     }
                 }
             ]));
@@ -112,16 +151,22 @@ describe('Queue methods', () => {
             const queue = getQueue('name', apiClientMock);
             const payload = [
                 {
-                    content: 'payload-1'
+                    body: {
+                        content: 'payload-1'
+                    }
                 },
                 {
-                    content: 'payload-2'
+                    body: {
+                        content: 'payload-2'
+                    }
                 },
                 {
-                    content: 'payload-3'
+                    body: {
+                        content: 'payload-3'
+                    }
                 }
             ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to create stats for job name#12345`, []));
+            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to create stats for job name#12345`, { jobId: 'some-job-id' }, []));
             (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
         });
         it('should throw PartialSuccessError when there are failed events and backend failed to create job stats', async () => {
@@ -137,17 +182,23 @@ describe('Queue methods', () => {
             const queue = getQueue('name', apiClientMock);
             const payload = [
                 {
-                    content: 'payload-1'
+                    body: {
+                        content: 'payload-1'
+                    }
                 },
                 {
-                    content: 'payload-2'
+                    body: {
+                        content: 'payload-2'
+                    }
                 }
             ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 1 event(s). Failed to create stats for job name#12345`, [
+            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 1 event(s). Failed to create stats for job name#12345`, { jobId: 'some-job-id' }, [
                 {
                     errorMessage: 'failed-1',
-                    payload: {
-                        content: 'payload-1'
+                    event: {
+                        body: {
+                            content: 'payload-1'
+                        }
                     }
                 }
             ]));
@@ -160,20 +211,18 @@ describe('Queue methods', () => {
                 details: 'The request processing has failed because of an unknown error, exception or failure'
             }, 500);
             const queue = getQueue('name', apiClientMock);
-            const payload = [...Array(9).keys()];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.InternalServerError(`500 Status Text: AWS SQS timed out`, 500, 'The request processing has failed because of an unknown error, exception or failure'));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
+            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InternalServerError(`500 Status Text: AWS SQS timed out`, 500, 'The request processing has failed because of an unknown error, exception or failure'));
+            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
         });
         it('should throw InternalServerError for error response without response body', async () => {
             const apiClientMock = (0, utils_1.getApiClientMockWithoutResponseBody)(504, 'Gateway Timeout');
             const queue = getQueue('name', apiClientMock);
-            const payload = [1];
-            await expect(queue.push(1)).rejects.toThrow(new errors_1.InternalServerError(`504 Gateway Timeout`, 504));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
+            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InternalServerError(`504 Gateway Timeout`, 504));
+            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
         });
         it('requests stargate if no api client is provided', async () => {
             const queue = getQueue('queue');
-            await queue.push({ test: 'stargate' });
+            await queue.push({ body: { test: 'stargate' } });
             expect(api_1.__requestAtlassianAsApp).toHaveBeenCalledTimes(1);
         });
     });

package/out/__test__/utils.js

@@ -33,7 +33,7 @@ exports.verifyApiClientCalledWith = verifyApiClientCalledWith;
 const verifyApiClientCalledPushPathWith = (apiClientMock, payloads, name) => {
     (0, exports.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/publish/{contextAri}/{environmentId}/{appId}/{appVersion}', {
         queueName: name,
-        schema: 'ari:cloud:ecosystem::forge/app-event',
+        schema: 'ari:cloud:ecosystem::forge/app-event-2',
         type: 'avi:forge:app:event',
         payload: payloads
     });

package/out/appEvents.d.ts

@@ -0,0 +1,22 @@
+export interface AppEvent {
+    key: string;
+}
+export declare type AppEventPublishResult = AppEventPublishSuccess | AppEventPublishError;
+export declare type AppEventPublishSuccess = {
+    type: 'success';
+    failedEvents: AppEventPublishFailure[];
+};
+export interface AppEventPublishFailure {
+    event: AppEvent;
+    errorMessage: string;
+}
+export interface AppEventPublishError {
+    type: 'error';
+    errorType: AppEventErrorType;
+    errorMessage: string;
+}
+export declare type AppEventErrorType = 'VALIDATION_ERROR' | 'AUTHENTICATION_ERROR' | 'AUTHORIZATION_ERROR' | 'RATE_LIMIT' | 'SERVICE_ERROR' | 'SERVICE_UNAVAILABLE' | `OTHER`;
+export declare const appEvents: {
+    publish(events: AppEvent | AppEvent[]): Promise<AppEventPublishResult>;
+};
+//# sourceMappingURL=appEvents.d.ts.map

package/out/appEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appEvents.d.ts","sourceRoot":"","sources":["../src/appEvents.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,oBAAY,qBAAqB,GAAG,sBAAsB,GAAG,oBAAoB,CAAC;AASlF,oBAAY,sBAAsB,GAAG;IACnC,IAAI,EAAE,SAAS,CAAC;IAEhB,YAAY,EAAE,sBAAsB,EAAE,CAAC;CACxC,CAAC;AAKF,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,QAAQ,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAMD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,iBAAiB,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,oBAAY,iBAAiB,GACzB,kBAAkB,GAClB,sBAAsB,GACtB,qBAAqB,GACrB,YAAY,GACZ,eAAe,GACf,qBAAqB,GACrB,OAAO,CAAC;AAsBZ,eAAO,MAAM,SAAS;oBACE,QAAQ,GAAG,QAAQ,EAAE,GAAG,QAAQ,qBAAqB,CAAC;CAwB7E,CAAC"}

package/out/appEvents.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appEvents = void 0;
+const queries_1 = require("./queries");
+const api_1 = require("@forge/api");
+const errorTypes = {
+    400: 'VALIDATION_ERROR',
+    401: 'AUTHENTICATION_ERROR',
+    403: 'AUTHORIZATION_ERROR',
+    429: 'RATE_LIMIT',
+    500: 'SERVICE_ERROR',
+    503: 'SERVICE_UNAVAILABLE'
+};
+const endpoint = '/forge/events/v1/app-events';
+exports.appEvents = {
+    async publish(events) {
+        const eventsArray = Array.isArray(events) ? events : [events];
+        const body = {
+            events: eventsArray.map((e) => ({
+                key: e.key
+            }))
+        };
+        const response = await (0, queries_1.post)(endpoint, body, api_1.__requestAtlassianAsApp);
+        const responseBody = await response.json();
+        if (!response.ok) {
+            return {
+                type: 'error',
+                errorType: errorTypes[response.status] ?? 'OTHER',
+                errorMessage: getErrorMessage(responseBody)
+            };
+        }
+        return {
+            type: 'success',
+            failedEvents: responseBody.failedEvents ?? []
+        };
+    }
+};
+function getErrorMessage(responseBody) {
+    if (responseBody.errorMessages && responseBody.errorMessages.length > 0) {
+        return responseBody.errorMessages.join(', ');
+    }
+    else if (responseBody.errors) {
+        return Object.entries(responseBody.errors)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(', ');
+    }
+    else {
+        return JSON.stringify(responseBody);
+    }
+}

package/out/errors.d.ts

@@ -1,35 +1,33 @@
-import { FailedEvent } from './types';
-export declare class InvalidPushSettingsError extends Error {
+import { FailedEvent, PushResult } from './types';
+export declare class EventsError extends Error {
     constructor(message: string);
 }
-export declare class InvalidQueueNameError extends Error {
-    constructor(message: string);
+export declare class InvalidPushSettingsError extends EventsError {
 }
-export declare class TooManyEventsError extends Error {
-    constructor(message: string);
+export declare class InvalidQueueNameError extends EventsError {
 }
-export declare class PayloadTooBigError extends Error {
-    constructor(message: string);
+export declare class InvalidPayloadError extends EventsError {
 }
-export declare class NoEventsToPushError extends Error {
-    constructor(message: string);
+export declare class TooManyEventsError extends EventsError {
 }
-export declare class RateLimitError extends Error {
-    constructor(message: string);
+export declare class PayloadTooBigError extends EventsError {
 }
-export declare class PartialSuccessError extends Error {
-    constructor(message: string, failedEvents: FailedEvent[]);
+export declare class NoEventsToPushError extends EventsError {
+}
+export declare class RateLimitError extends EventsError {
+}
+export declare class PartialSuccessError extends EventsError {
+    result: PushResult;
     failedEvents: FailedEvent[];
+    constructor(message: string, result: PushResult, failedEvents: FailedEvent[]);
 }
-export declare class InternalServerError extends Error {
+export declare class InternalServerError extends EventsError {
     constructor(message: string, errorCode?: number, details?: string);
     errorCode?: number;
     details?: string;
 }
-export declare class JobDoesNotExistError extends Error {
-    constructor(message: string);
+export declare class JobDoesNotExistError extends EventsError {
 }
-export declare class InvocationLimitReachedError extends Error {
-    constructor(message: string);
+export declare class InvocationLimitReachedError extends EventsError {
 }
 //# sourceMappingURL=errors.d.ts.map

package/out/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE;IAKxD,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;IAMjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM;CAG5B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAElD,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,wBAAyB,SAAQ,WAAW;CAAG;AAE5D,qBAAa,qBAAsB,SAAQ,WAAW;CAAG;AAEzD,qBAAa,mBAAoB,SAAQ,WAAW;CAAG;AAEvD,qBAAa,kBAAmB,SAAQ,WAAW;CAAG;AAEtD,qBAAa,kBAAmB,SAAQ,WAAW;CAAG;AAEtD,qBAAa,mBAAoB,SAAQ,WAAW;CAAG;AAEvD,qBAAa,cAAe,SAAQ,WAAW;CAAG;AAElD,qBAAa,mBAAoB,SAAQ,WAAW;IAGzC,MAAM,EAAE,UAAU;IAClB,YAAY,EAAE,WAAW,EAAE;gBAFlC,OAAO,EAAE,MAAM,EACR,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,WAAW,EAAE;CAIrC;AAED,qBAAa,mBAAoB,SAAQ,WAAW;gBACtC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;IAMjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,oBAAqB,SAAQ,WAAW;CAAG;AAExD,qBAAa,2BAA4B,SAAQ,WAAW;CAAG"}