@forge/realtime 0.0.7-next.0 → 0.1.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @forge/realtime
 
+## 0.1.0-next.1
+
+### Minor Changes
+
+- 4242274: Adds new signRealtimeToken method to the forge realtime package
+
 ## 0.0.7-next.0
 
 ### Patch Changes

package/out/__test__/publish.test.js

@@ -4,6 +4,29 @@ const tslib_1 = require("tslib");
 const runtime = tslib_1.__importStar(require("../runtime"));
 const publish_1 = require("../publish");
 const utils_1 = require("./utils");
+const TEST_EVENT_ID = 'event-id';
+const TEST_EVENT_TIMESTAMP = '1234567890';
+const MOCK_FETCH_RESPONSE = {
+    errors: [],
+    data: {
+        ecosystem: {
+            publishRealtimeChannel: {
+                eventId: TEST_EVENT_ID,
+                eventTimestamp: TEST_EVENT_TIMESTAMP
+            },
+            success: true
+        }
+    }
+};
+const MOCK_ERRORS = [
+    {
+        message: 'Error message',
+        extensions: {
+            errorType: 'Error type',
+            statusCode: 500
+        }
+    }
+];
 describe('publish', () => {
     beforeEach(() => {
         jest.restoreAllMocks();
@@ -12,26 +35,26 @@ describe('publish', () => {
     it('should publish an event with FCT in header', async () => {
         jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
         const mockForgeFetch = jest.fn().mockResolvedValue({
-            text: jest.fn().mockResolvedValue('Hello Magic'),
+            json: jest.fn().mockResolvedValue(MOCK_FETCH_RESPONSE),
             status: 200,
             headers: { get: jest.fn().mockReturnValue(undefined) }
         });
         global.__forge_fetch__ = mockForgeFetch;
         const response = await (0, publish_1.publish)('my-channel', 'this is an event payload');
-        expect(response.status).toBe(200);
+        expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
     it('should publish an event when the payload is an object', async () => {
         jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
         const mockForgeFetch = jest.fn().mockResolvedValue({
-            text: jest.fn().mockResolvedValue('Hello Magic'),
+            json: jest.fn().mockResolvedValue(MOCK_FETCH_RESPONSE),
             status: 200,
             headers: { get: jest.fn().mockReturnValue(undefined) }
         });
         global.__forge_fetch__ = mockForgeFetch;
         const payload = { value: 'this is a test payload', funLevel: 100 };
         const response = await (0, publish_1.publish)('my-channel', JSON.stringify(payload));
-        expect(response.status).toBe(200);
+        expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
     it('should throw an error when Forge Outbound Proxy returns an error', async () => {
@@ -47,6 +70,26 @@ describe('publish', () => {
         await expect(response).rejects.toThrow('Forge platform failed to process runtime HTTP request - 502 - UPSTREAM_FAILURE');
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
+    it('should return null eventId and eventTimestamp when the response has errors', async () => {
+        jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
+        const mockForgeFetch = jest.fn().mockResolvedValue({
+            json: jest.fn().mockResolvedValue({
+                errors: MOCK_ERRORS,
+                data: {
+                    ecosystem: {
+                        publishRealtimeChannel: null,
+                    }
+                }
+            }),
+            status: 200,
+            headers: { get: jest.fn().mockReturnValue(undefined) }
+        });
+        global.__forge_fetch__ = mockForgeFetch;
+        const payload = { value: 'this is a test payload', funLevel: 100 };
+        const response = await (0, publish_1.publish)('my-channel', JSON.stringify(payload));
+        expect(response).toEqual({ eventId: null, eventTimestamp: null, errors: MOCK_ERRORS });
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
 });
 describe('publishGlobal', () => {
     beforeEach(() => {
@@ -56,26 +99,26 @@ describe('publishGlobal', () => {
     it('should publish an event', async () => {
         jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
         const mockForgeFetch = jest.fn().mockResolvedValue({
-            text: jest.fn().mockResolvedValue('Hello Magic'),
+            json: jest.fn().mockResolvedValue(MOCK_FETCH_RESPONSE),
             status: 200,
             headers: { get: jest.fn().mockReturnValue(undefined) }
         });
         global.__forge_fetch__ = mockForgeFetch;
         const response = await (0, publish_1.publishGlobal)('my-channel', 'this is an event payload');
-        expect(response.status).toBe(200);
+        expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
     it('should publish an event when the payload is an object', async () => {
         jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
         const mockForgeFetch = jest.fn().mockResolvedValue({
-            text: jest.fn().mockResolvedValue('Hello Magic'),
+            json: jest.fn().mockResolvedValue(MOCK_FETCH_RESPONSE),
             status: 200,
             headers: { get: jest.fn().mockReturnValue(undefined) }
         });
         global.__forge_fetch__ = mockForgeFetch;
         const payload = { value: 'this is a test payload', funLevel: 100 };
         const response = await (0, publish_1.publishGlobal)('my-channel', JSON.stringify(payload));
-        expect(response.status).toBe(200);
+        expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
     it('should throw an error when Forge Outbound Proxy returns an error', async () => {
@@ -91,4 +134,24 @@ describe('publishGlobal', () => {
         await expect(response).rejects.toThrow('Forge platform failed to process runtime HTTP request - 502 - UPSTREAM_FAILURE');
         expect(mockForgeFetch.mock.calls).toMatchSnapshot();
     });
+    it('should return null eventId and eventTimestamp when the response has errors', async () => {
+        jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
+        const mockForgeFetch = jest.fn().mockResolvedValue({
+            json: jest.fn().mockResolvedValue({
+                errors: MOCK_ERRORS,
+                data: {
+                    ecosystem: {
+                        publishRealtimeChannel: null,
+                    }
+                }
+            }),
+            status: 200,
+            headers: { get: jest.fn().mockReturnValue(undefined) }
+        });
+        global.__forge_fetch__ = mockForgeFetch;
+        const payload = { value: 'this is a test payload', funLevel: 100 };
+        const response = await (0, publish_1.publishGlobal)('my-channel', JSON.stringify(payload));
+        expect(response).toEqual({ eventId: null, eventTimestamp: null, errors: MOCK_ERRORS });
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
 });

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

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

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

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

package/out/__test__/signRealtimeToken.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const runtime = tslib_1.__importStar(require("../runtime"));
+const signRealtimeToken_1 = require("../signRealtimeToken");
+const utils_1 = require("./utils");
+const TEST_TOKEN = 'jwt-token';
+const TEST_EXPIRES_AT = '1234567890';
+const MOCK_ERRORS = [
+    {
+        message: 'Error message',
+        extensions: {
+            errorType: 'Error type',
+            statusCode: 500
+        }
+    }
+];
+describe('signRealtimeToken', () => {
+    beforeEach(() => {
+        jest.restoreAllMocks();
+        jest.resetAllMocks();
+    });
+    it('should send a signRealtimeToken request and recieve a jwt and expiresAt', async () => {
+        jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
+        const mockForgeFetch = jest.fn().mockResolvedValue({
+            json: jest.fn().mockResolvedValue({
+                errors: [],
+                data: {
+                    ecosystem: {
+                        signRealtimeToken: {
+                            errors: [],
+                            forgeRealtimeToken: {
+                                jwt: TEST_TOKEN,
+                                expiresAt: TEST_EXPIRES_AT
+                            },
+                            success: true
+                        }
+                    }
+                }
+            }),
+            status: 200,
+            headers: { get: jest.fn().mockReturnValue(undefined) }
+        });
+        global.__forge_fetch__ = mockForgeFetch;
+        const response = await (0, signRealtimeToken_1.signRealtimeToken)('my-channel', { 'test-key': 'test-value' });
+        expect(response).toEqual({ jwt: TEST_TOKEN, expiresAt: TEST_EXPIRES_AT });
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
+    it('should throw an error when Forge Outbound Proxy returns an error', async () => {
+        jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
+        const mockForgeFetch = jest.fn().mockResolvedValue({
+            text: jest.fn().mockResolvedValue('Error occurred'),
+            status: 502,
+            headers: { get: jest.fn().mockReturnValue('UPSTREAM_FAILURE') }
+        });
+        global.__forge_fetch__ = mockForgeFetch;
+        const response = (0, signRealtimeToken_1.signRealtimeToken)('my-channel', { 'test-key': 'test-value' });
+        await expect(response).rejects.toThrow('Forge platform failed to process runtime HTTP request - 502 - UPSTREAM_FAILURE');
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
+    it('should send generic error when errors are returned', async () => {
+        jest.spyOn(runtime, '__getRuntime').mockReturnValue(utils_1.FORGE_RUNTIME);
+        const mockForgeFetch = jest.fn().mockResolvedValue({
+            json: jest.fn().mockResolvedValue({
+                errors: MOCK_ERRORS,
+                data: {
+                    ecosystem: {
+                        signRealtimeToken: null,
+                    }
+                }
+            }),
+            status: 200,
+            headers: { get: jest.fn().mockReturnValue(undefined) }
+        });
+        global.__forge_fetch__ = mockForgeFetch;
+        const response = await (0, signRealtimeToken_1.signRealtimeToken)('my-channel', { 'test-key': 'test-value' });
+        expect(response).toEqual({ jwt: null, expiresAt: null, errors: MOCK_ERRORS });
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
+});

package/out/index.d.ts

@@ -1,2 +1,3 @@
 export { publish, publishGlobal } from './publish';
+export { signRealtimeToken } from './signRealtimeToken';
 //# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/out/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishGlobal = exports.publish = void 0;
+exports.signRealtimeToken = exports.publishGlobal = exports.publish = void 0;
 var publish_1 = require("./publish");
 Object.defineProperty(exports, "publish", { enumerable: true, get: function () { return publish_1.publish; } });
 Object.defineProperty(exports, "publishGlobal", { enumerable: true, get: function () { return publish_1.publishGlobal; } });
+var signRealtimeToken_1 = require("./signRealtimeToken");
+Object.defineProperty(exports, "signRealtimeToken", { enumerable: true, get: function () { return signRealtimeToken_1.signRealtimeToken; } });

package/out/publish.d.ts

@@ -1,5 +1,19 @@
-export declare const getForgeProxyError: (response: Response) => string | null;
-export declare const handleProxyResponseErrors: (response: Response) => void;
-export declare const publish: (channelName: string, eventPayload: string) => Promise<any>;
-export declare const publishGlobal: (channelName: string, eventPayload: string) => Promise<any>;
+export declare const publish: (channelName: string, eventPayload: string) => Promise<{
+    eventId: null;
+    eventTimestamp: null;
+    errors: any;
+} | {
+    eventId: any;
+    eventTimestamp: any;
+    errors?: undefined;
+}>;
+export declare const publishGlobal: (channelName: string, eventPayload: string) => Promise<{
+    eventId: null;
+    eventTimestamp: null;
+    errors: any;
+} | {
+    eventId: any;
+    eventTimestamp: any;
+    errors?: undefined;
+}>;
 //# sourceMappingURL=publish.d.ts.map

package/out/publish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../src/publish.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,aAAc,QAAQ,kBAA8C,CAAC;AACpG,eAAO,MAAM,yBAAyB,aAAc,QAAQ,KAAG,IAK9D,CAAC;AAwBF,eAAO,MAAM,OAAO,gBAAuB,MAAM,gBAAgB,MAAM,iBAkCtE,CAAC;AAEF,eAAO,MAAM,aAAa,gBAAuB,MAAM,gBAAgB,MAAM,iBAiC5E,CAAC"}
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../src/publish.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,OAAO,gBAAuB,MAAM,gBAAgB,MAAM;;;;;;;;EAgEtE,CAAC;AAEF,eAAO,MAAM,aAAa,gBAAuB,MAAM,gBAAgB,MAAM;;;;;;;;EA+D5E,CAAC"}

package/out/publish.js

@@ -1,17 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishGlobal = exports.publish = exports.handleProxyResponseErrors = exports.getForgeProxyError = void 0;
-const api_1 = require("@forge/api");
+exports.publishGlobal = exports.publish = void 0;
 const runtime_1 = require("./runtime");
-const getForgeProxyError = (response) => response.headers.get('forge-proxy-error');
-exports.getForgeProxyError = getForgeProxyError;
-const handleProxyResponseErrors = (response) => {
-    const errorReason = (0, exports.getForgeProxyError)(response);
-    if (errorReason) {
-        throw new api_1.ProxyRequestError(response.status, errorReason);
-    }
-};
-exports.handleProxyResponseErrors = handleProxyResponseErrors;
+const utils_1 = require("./utils");
 const graphqlBody = `mutation publishRealtimeChannel(
   $installationId: ID!
   $name: String!
@@ -30,11 +21,10 @@ const graphqlBody = `mutation publishRealtimeChannel(
     }
   }
 }`;
-const prodEnvErrorMessage = 'Forge realtime usage is restricted to Forge apps in a non-production environment. Please see https://developer.atlassian.com/platform/forge/cli-reference/environments/ for reference on Forge app environments.';
 const publish = async (channelName, eventPayload) => {
     const { appContext, realtime } = (0, runtime_1.__getRuntime)();
     if (appContext?.environmentType === 'PRODUCTION') {
-        throw new Error(prodEnvErrorMessage);
+        throw new Error(utils_1.prodEnvErrorMessage);
     }
     const response = await global.__forge_fetch__({
         type: 'realtime'
@@ -49,19 +39,44 @@ const publish = async (channelName, eventPayload) => {
                 isGlobal: false
             }
         }),
+        errors: [],
         headers: {
             'Content-Type': 'application/json',
             'x-forge-context-token': realtime?.contextToken
         }
     });
-    (0, exports.handleProxyResponseErrors)(response);
-    return response;
+    (0, utils_1.handleProxyResponseErrors)(response);
+    const awaitedResponse = await response.json();
+    const { data, errors } = awaitedResponse;
+    if (errors && errors.length > 0) {
+        return {
+            eventId: null,
+            eventTimestamp: null,
+            errors
+        };
+    }
+    if (!data) {
+        return {
+            eventId: null,
+            eventTimestamp: null,
+            errors: [
+                {
+                    message: 'Error publishing event to channel.'
+                }
+            ]
+        };
+    }
+    const { eventId, eventTimestamp } = awaitedResponse.data.ecosystem.publishRealtimeChannel;
+    return {
+        eventId,
+        eventTimestamp
+    };
 };
 exports.publish = publish;
 const publishGlobal = async (channelName, eventPayload) => {
     const { appContext } = (0, runtime_1.__getRuntime)();
     if (appContext?.environmentType === 'PRODUCTION') {
-        throw new Error(prodEnvErrorMessage);
+        throw new Error(utils_1.prodEnvErrorMessage);
     }
     const response = await global.__forge_fetch__({
         type: 'realtime'
@@ -76,11 +91,36 @@ const publishGlobal = async (channelName, eventPayload) => {
                 isGlobal: true
             }
         }),
+        errors: [],
         headers: {
             'Content-Type': 'application/json'
         }
     });
-    (0, exports.handleProxyResponseErrors)(response);
-    return response;
+    (0, utils_1.handleProxyResponseErrors)(response);
+    const awaitedResponse = await response.json();
+    const { data, errors } = awaitedResponse;
+    if (errors && errors.length > 0) {
+        return {
+            eventId: null,
+            eventTimestamp: null,
+            errors
+        };
+    }
+    if (!data) {
+        return {
+            eventId: null,
+            eventTimestamp: null,
+            errors: [
+                {
+                    message: 'Error publishing global event to channel.'
+                }
+            ]
+        };
+    }
+    const { eventId, eventTimestamp } = data.ecosystem.publishRealtimeChannel;
+    return {
+        eventId,
+        eventTimestamp
+    };
 };
 exports.publishGlobal = publishGlobal;

package/out/signRealtimeToken.d.ts

@@ -0,0 +1,10 @@
+export declare const signRealtimeToken: (channelName: string, claims: any) => Promise<{
+    jwt: null;
+    expiresAt: null;
+    errors: any;
+} | {
+    jwt: any;
+    expiresAt: any;
+    errors?: undefined;
+}>;
+//# sourceMappingURL=signRealtimeToken.d.ts.map

package/out/signRealtimeToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signRealtimeToken.d.ts","sourceRoot":"","sources":["../src/signRealtimeToken.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,iBAAiB,gBAAuB,MAAM,UAAU,GAAG;;;;;;;;EA6DvE,CAAC"}

package/out/signRealtimeToken.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signRealtimeToken = void 0;
+const runtime_1 = require("./runtime");
+const utils_1 = require("./utils");
+const graphqlBody = `mutation signRealtimeToken(
+  $channelName: String!
+  $claims: JSON!
+){
+  ecosystem {
+    signRealtimeToken(
+        channelName: $channelName
+        claims: $claims
+    ) {
+        errors {
+            message
+            extensions {
+            errorType
+            statusCode
+            }
+        }
+        forgeRealtimeToken {
+            jwt
+            expiresAt
+        }
+        success
+    }
+  }
+}`;
+const signRealtimeToken = async (channelName, claims) => {
+    const { appContext } = (0, runtime_1.__getRuntime)();
+    if (appContext?.environmentType === 'PRODUCTION') {
+        throw new Error(utils_1.prodEnvErrorMessage);
+    }
+    const response = await global.__forge_fetch__({
+        type: 'realtime'
+    }, '/', {
+        method: 'POST',
+        body: JSON.stringify({
+            query: graphqlBody,
+            variables: {
+                channelName,
+                claims
+            }
+        }),
+        errors: [],
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+    (0, utils_1.handleProxyResponseErrors)(response);
+    const awaitedResponse = await response.json();
+    const { data, errors } = awaitedResponse;
+    if (errors && errors.length > 0) {
+        return {
+            jwt: null,
+            expiresAt: null,
+            errors
+        };
+    }
+    if (!data) {
+        return {
+            jwt: null,
+            expiresAt: null,
+            errors: [
+                {
+                    message: 'Error signing realtime token.'
+                }
+            ]
+        };
+    }
+    const { jwt, expiresAt } = data.ecosystem.signRealtimeToken.forgeRealtimeToken;
+    return {
+        jwt,
+        expiresAt
+    };
+};
+exports.signRealtimeToken = signRealtimeToken;

package/out/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const handleProxyResponseErrors: (response: Response) => void;
+export declare const prodEnvErrorMessage = "Forge realtime usage is restricted to Forge apps in a non-production environment. Please see https://developer.atlassian.com/platform/forge/cli-reference/environments/ for reference on Forge app environments.";
+//# sourceMappingURL=utils.d.ts.map

package/out/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yBAAyB,aAAc,QAAQ,KAAG,IAK9D,CAAC;AAEF,eAAO,MAAM,mBAAmB,qNACoL,CAAC"}

package/out/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prodEnvErrorMessage = exports.handleProxyResponseErrors = void 0;
+const api_1 = require("@forge/api");
+const getForgeProxyError = (response) => response.headers.get('forge-proxy-error');
+const handleProxyResponseErrors = (response) => {
+    const errorReason = getForgeProxyError(response);
+    if (errorReason) {
+        throw new api_1.ProxyRequestError(response.status, errorReason);
+    }
+};
+exports.handleProxyResponseErrors = handleProxyResponseErrors;
+exports.prodEnvErrorMessage = 'Forge realtime usage is restricted to Forge apps in a non-production environment. Please see https://developer.atlassian.com/platform/forge/cli-reference/environments/ for reference on Forge app environments.';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/realtime",
-  "version": "0.0.7-next.0",
+  "version": "0.1.0-next.1",
   "description": "Forge realtime",
   "main": "out/index.js",
   "types": "out/index.d.ts",
@@ -14,7 +14,7 @@
   },
   "devDependencies": {
     "@atlassian/metrics-interface": "4.0.0",
-    "@forge/api": "6.1.0",
+    "@forge/api": "6.1.1-next.0",
     "@types/node": "20.19.1"
   },
   "publishConfig": {

package/src/__test__/__snapshots__/publish.test.ts.snap

@@ -9,6 +9,7 @@ exports[`publish should publish an event when the payload is an object 1`] = `
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":false}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
         "x-forge-context-token": "my.context.token",
@@ -28,6 +29,27 @@ exports[`publish should publish an event with FCT in header 1`] = `
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"this is an event payload","isGlobal":false}}",
+      "errors": [],
+      "headers": {
+        "Content-Type": "application/json",
+        "x-forge-context-token": "my.context.token",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`;
+
+exports[`publish should return null eventId and eventTimestamp when the response has errors 1`] = `
+[
+  [
+    {
+      "type": "realtime",
+    },
+    "/",
+    {
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":false}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
         "x-forge-context-token": "my.context.token",
@@ -47,6 +69,7 @@ exports[`publish should throw an error when Forge Outbound Proxy returns an erro
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":false}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
         "x-forge-context-token": "my.context.token",
@@ -66,6 +89,7 @@ exports[`publishGlobal should publish an event 1`] = `
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"this is an event payload","isGlobal":true}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
       },
@@ -84,6 +108,26 @@ exports[`publishGlobal should publish an event when the payload is an object 1`]
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":true}}",
+      "errors": [],
+      "headers": {
+        "Content-Type": "application/json",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`;
+
+exports[`publishGlobal should return null eventId and eventTimestamp when the response has errors 1`] = `
+[
+  [
+    {
+      "type": "realtime",
+    },
+    "/",
+    {
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":true}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
       },
@@ -102,6 +146,7 @@ exports[`publishGlobal should throw an error when Forge Outbound Proxy returns a
     "/",
     {
       "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n    ) {\\n        eventId,\\n        eventTimestamp\\n    }\\n  }\\n}","variables":{"installationId":"iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii","name":"my-channel","payload":"{\\"value\\":\\"this is a test payload\\",\\"funLevel\\":100}","isGlobal":true}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
       },