@forge/realtime 0.0.7-next.0 → 0.1.0-experimental-3f68b81

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

@@ -8,7 +8,8 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
         "x-forge-context-token": "my.context.token",
@@ -27,7 +28,28 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "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  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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",
@@ -46,7 +68,8 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
         "x-forge-context-token": "my.context.token",
@@ -65,7 +88,8 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
       },
@@ -83,7 +107,27 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "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  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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",
       },
@@ -101,7 +145,8 @@ 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}}",
+      "body": "{"query":"mutation publishRealtimeChannel(\\n  $installationId: ID!\\n  $name: String!\\n  $payload: String!\\n  $isGlobal: Boolean\\n  $token: String\\n){\\n  ecosystem {\\n    publishRealtimeChannel(\\n      installationId: $installationId\\n      name: $name\\n      payload: $payload\\n      isGlobal: $isGlobal\\n      token: $token\\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,"token":"my-token"}}",
+      "errors": [],
       "headers": {
         "Content-Type": "application/json",
       },

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

@@ -0,0 +1,58 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`signRealtimeToken should send a signRealtimeToken request and recieve a jwt and expiresAt 1`] = `
+[
+  [
+    {
+      "type": "realtime",
+    },
+    "/",
+    {
+      "body": "{"query":"mutation signRealtimeToken(\\n  $channelName: String!\\n  $claims: JSON!\\n){\\n  ecosystem {\\n    signRealtimeToken(\\n        channelName: $channelName\\n        claims: $claims\\n    ) {\\n        errors {\\n            message\\n            extensions {\\n            errorType\\n            statusCode\\n            }\\n        }\\n        forgeRealtimeToken {\\n            jwt\\n            expiresAt\\n        }\\n        success\\n    }\\n  }\\n}","variables":{"channelName":"my-channel","claims":{"test-key":"test-value"}}}",
+      "errors": [],
+      "headers": {
+        "Content-Type": "application/json",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`;
+
+exports[`signRealtimeToken should send generic error when errors are returned 1`] = `
+[
+  [
+    {
+      "type": "realtime",
+    },
+    "/",
+    {
+      "body": "{"query":"mutation signRealtimeToken(\\n  $channelName: String!\\n  $claims: JSON!\\n){\\n  ecosystem {\\n    signRealtimeToken(\\n        channelName: $channelName\\n        claims: $claims\\n    ) {\\n        errors {\\n            message\\n            extensions {\\n            errorType\\n            statusCode\\n            }\\n        }\\n        forgeRealtimeToken {\\n            jwt\\n            expiresAt\\n        }\\n        success\\n    }\\n  }\\n}","variables":{"channelName":"my-channel","claims":{"test-key":"test-value"}}}",
+      "errors": [],
+      "headers": {
+        "Content-Type": "application/json",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`;
+
+exports[`signRealtimeToken should throw an error when Forge Outbound Proxy returns an error 1`] = `
+[
+  [
+    {
+      "type": "realtime",
+    },
+    "/",
+    {
+      "body": "{"query":"mutation signRealtimeToken(\\n  $channelName: String!\\n  $claims: JSON!\\n){\\n  ecosystem {\\n    signRealtimeToken(\\n        channelName: $channelName\\n        claims: $claims\\n    ) {\\n        errors {\\n            message\\n            extensions {\\n            errorType\\n            statusCode\\n            }\\n        }\\n        forgeRealtimeToken {\\n            jwt\\n            expiresAt\\n        }\\n        success\\n    }\\n  }\\n}","variables":{"channelName":"my-channel","claims":{"test-key":"test-value"}}}",
+      "errors": [],
+      "headers": {
+        "Content-Type": "application/json",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`;

package/src/__test__/publish.test.ts

@@ -2,6 +2,36 @@ import * as runtime from '../runtime';
 import { publish, publishGlobal } from '../publish';
 import { FORGE_RUNTIME } from './utils';
 
+const TEST_EVENT_ID = 'event-id';
+const TEST_EVENT_TIMESTAMP = '1234567890';
+const MOCK_CHANNEL = 'my-channel';
+const MOCK_PUBLISH_OPTIONS = { token: 'my-token' };
+const MOCK_EVENT_PAYLOAD_STRING = 'this is an event payload';
+const MOCK_EVENT_PAYLOAD_OBJECT = { value: 'this is a test payload', funLevel: 100 };
+
+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,16 +42,16 @@ describe('publish', () => {
     jest.spyOn(runtime, '__getRuntime').mockReturnValue(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 as any).__forge_fetch__ = mockForgeFetch;
 
-    const response = await publish('my-channel', 'this is an event payload');
+    const response = await publish(MOCK_CHANNEL, MOCK_EVENT_PAYLOAD_STRING, MOCK_PUBLISH_OPTIONS);
 
-    expect(response.status).toBe(200);
+    expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
     expect(mockForgeFetch.mock.calls).toMatchSnapshot();
   });
 
@@ -29,17 +59,16 @@ describe('publish', () => {
     jest.spyOn(runtime, '__getRuntime').mockReturnValue(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 as any).__forge_fetch__ = mockForgeFetch;
 
-    const payload = { value: 'this is a test payload', funLevel: 100 };
-    const response = await publish('my-channel', JSON.stringify(payload));
+    const response = await publish(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
 
-    expect(response.status).toBe(200);
+    expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
     expect(mockForgeFetch.mock.calls).toMatchSnapshot();
   });
 
@@ -54,14 +83,38 @@ describe('publish', () => {
 
     (global as any).__forge_fetch__ = mockForgeFetch;
 
-    const payload = { value: 'this is a test payload', funLevel: 100 };
-    const response = publish('my-channel', JSON.stringify(payload));
+    const response = publish(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
 
     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(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 as any).__forge_fetch__ = mockForgeFetch;
+
+    const payload = { value: 'this is a test payload', funLevel: 100 };
+    const response = await publish('my-channel', JSON.stringify(payload));
+
+    expect(response).toEqual({ eventId: null, eventTimestamp: null, errors: MOCK_ERRORS });
+    expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+  });
 });
 
 describe('publishGlobal', () => {
@@ -74,16 +127,16 @@ describe('publishGlobal', () => {
     jest.spyOn(runtime, '__getRuntime').mockReturnValue(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 as any).__forge_fetch__ = mockForgeFetch;
 
-    const response = await publishGlobal('my-channel', 'this is an event payload');
+    const response = await publishGlobal(MOCK_CHANNEL, MOCK_EVENT_PAYLOAD_STRING, MOCK_PUBLISH_OPTIONS);
 
-    expect(response.status).toBe(200);
+    expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
     expect(mockForgeFetch.mock.calls).toMatchSnapshot();
   });
 
@@ -91,17 +144,16 @@ describe('publishGlobal', () => {
     jest.spyOn(runtime, '__getRuntime').mockReturnValue(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 as any).__forge_fetch__ = mockForgeFetch;
 
-    const payload = { value: 'this is a test payload', funLevel: 100 };
-    const response = await publishGlobal('my-channel', JSON.stringify(payload));
+    const response = await publishGlobal(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
 
-    expect(response.status).toBe(200);
+    expect(response).toEqual({ eventId: TEST_EVENT_ID, eventTimestamp: TEST_EVENT_TIMESTAMP });
     expect(mockForgeFetch.mock.calls).toMatchSnapshot();
   });
 
@@ -116,12 +168,36 @@ describe('publishGlobal', () => {
 
     (global as any).__forge_fetch__ = mockForgeFetch;
 
-    const payload = { value: 'this is a test payload', funLevel: 100 };
-    const response = publishGlobal('my-channel', JSON.stringify(payload));
+    const response = publishGlobal(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
 
     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(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 as any).__forge_fetch__ = mockForgeFetch;
+
+    const payload = { value: 'this is a test payload', funLevel: 100 };
+    const response = await publishGlobal('my-channel', JSON.stringify(payload));
+
+    expect(response).toEqual({ eventId: null, eventTimestamp: null, errors: MOCK_ERRORS });
+    expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+  });
+});

package/src/__test__/signRealtimeToken.test.ts

@@ -0,0 +1,96 @@
+import * as runtime from '../runtime';
+import { signRealtimeToken } from '../signRealtimeToken';
+import { FORGE_RUNTIME } from './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(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 as any).__forge_fetch__ = mockForgeFetch;
+
+      const response = await signRealtimeToken('my-channel', { 'test-key': 'test-value' });
+
+      expect(response).toEqual({ token: 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(FORGE_RUNTIME);
+
+      const mockForgeFetch = jest.fn().mockResolvedValue({
+        text: jest.fn().mockResolvedValue('Error occurred'),
+        status: 502,
+        headers: { get: jest.fn().mockReturnValue('UPSTREAM_FAILURE') }
+      });
+
+      (global as any).__forge_fetch__ = mockForgeFetch;
+
+      const response = 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(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 as any).__forge_fetch__ = mockForgeFetch;
+
+      const response = await signRealtimeToken('my-channel', { 'test-key': 'test-value' });
+
+      expect(response).toEqual({ token: null, expiresAt: null, errors: MOCK_ERRORS });
+      expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
+  });

package/src/__test__/utils.ts

@@ -15,7 +15,28 @@ export const FORGE_RUNTIME: ForgeRuntime = {
     functionKey: 'functionKey',
     moduleType: 'moduleType',
     moduleKey: 'moduleKey',
-    license: { isActive: true }
+    license: { isActive: true },
+    permissions: {
+      scopes: ['read:confluence-content.summary', 'write:confluence-content'],
+      content: {
+        scripts: [],
+        styles: []
+      },
+      external: {
+        fetch: {
+          backend: [],
+          client: []
+        },
+        fonts: [],
+        frames: [],
+        navigation: [],
+        images: [],
+        media: [],
+        scripts: [],
+        styles: []
+      },
+      format: () => ''
+    }
   },
   tracing: {
     traceId: 'traceId',

package/src/index.ts

@@ -1 +1,2 @@
 export { publish, publishGlobal } from './publish';
+export { signRealtimeToken } from './signRealtimeToken';

package/src/publish.ts

@@ -1,20 +1,12 @@
-import { ProxyRequestError } from '@forge/api';
-
 import { __getRuntime } from './runtime';
-
-export const getForgeProxyError = (response: Response) => response.headers.get('forge-proxy-error');
-export const handleProxyResponseErrors = (response: Response): void => {
-  const errorReason = getForgeProxyError(response);
-  if (errorReason) {
-    throw new ProxyRequestError(response.status, errorReason);
-  }
-};
+import { handleProxyResponseErrors, prodEnvErrorMessage } from './utils';
 
 const graphqlBody = `mutation publishRealtimeChannel(
   $installationId: ID!
   $name: String!
   $payload: String!
   $isGlobal: Boolean
+  $token: String
 ){
   ecosystem {
     publishRealtimeChannel(
@@ -22,6 +14,7 @@ const graphqlBody = `mutation publishRealtimeChannel(
       name: $name
       payload: $payload
       isGlobal: $isGlobal
+      token: $token
     ) {
         eventId,
         eventTimestamp
@@ -29,10 +22,11 @@ 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.';
+interface PublishOptions {
+  token?: string;
+}
 
-export const publish = async (channelName: string, eventPayload: string) => {
+export const publish = async (channelName: string, eventPayload: string, options?: PublishOptions) => {
   const { appContext, realtime } = __getRuntime();
 
   if (appContext?.environmentType === 'PRODUCTION') {
@@ -53,9 +47,11 @@ export const publish = async (channelName: string, eventPayload: string) => {
           installationId: appContext.installationId,
           name: channelName,
           payload: eventPayload,
-          isGlobal: false
+          isGlobal: false,
+          token: options?.token
         }
       }),
+      errors: [],
       headers: {
         'Content-Type': 'application/json',
         'x-forge-context-token': realtime?.contextToken
@@ -65,10 +61,39 @@ export const publish = async (channelName: string, eventPayload: string) => {
 
   handleProxyResponseErrors(response);
 
-  return 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
+  };
 };
 
-export const publishGlobal = async (channelName: string, eventPayload: string) => {
+export const publishGlobal = async (channelName: string, eventPayload: string, options?: PublishOptions) => {
   const { appContext } = __getRuntime();
 
   if (appContext?.environmentType === 'PRODUCTION') {
@@ -89,9 +114,11 @@ export const publishGlobal = async (channelName: string, eventPayload: string) =
           installationId: appContext.installationId,
           name: channelName,
           payload: eventPayload,
-          isGlobal: true
+          isGlobal: true,
+          token: options?.token
         }
       }),
+      errors: [],
       headers: {
         'Content-Type': 'application/json'
       }
@@ -100,5 +127,34 @@ export const publishGlobal = async (channelName: string, eventPayload: string) =
 
   handleProxyResponseErrors(response);
 
-  return 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
+  };
 };