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

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @forge/realtime
 
+## 0.1.0-experimental-3f68b81
+
+### Patch Changes
+
+- fe2852a: Added backend SDK for permission handling
+- 7b7e598: Rename jwt to token in signRealtimeToken output
+
+## 0.1.0
+
+### Minor Changes
+
+- 4242274: Adds new signRealtimeToken method to the forge realtime package
+
+### Patch Changes
+
+- 32da8c1: Update realtime package publish and publishGlobal to accept new token variable
+- 1bf4466: Updates realtime package publish methods to use the new isGlobal field
+
+## 0.1.0-next.2
+
+### Patch Changes
+
+- 32da8c1: Update realtime package publish and publishGlobal to accept new token variable
+
+## 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,33 @@ 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_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,26 +39,25 @@ 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);
+        const response = await (0, publish_1.publish)(MOCK_CHANNEL, MOCK_EVENT_PAYLOAD_STRING, MOCK_PUBLISH_OPTIONS);
+        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);
+        const response = await (0, publish_1.publish)(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
+        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 () => {
@@ -42,11 +68,30 @@ describe('publish', () => {
             headers: { get: jest.fn().mockReturnValue('UPSTREAM_FAILURE') }
         });
         global.__forge_fetch__ = mockForgeFetch;
-        const payload = { value: 'this is a test payload', funLevel: 100 };
-        const response = (0, publish_1.publish)('my-channel', JSON.stringify(payload));
+        const response = (0, publish_1.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(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 +101,25 @@ 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);
+        const response = await (0, publish_1.publishGlobal)(MOCK_CHANNEL, MOCK_EVENT_PAYLOAD_STRING, MOCK_PUBLISH_OPTIONS);
+        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);
+        const response = await (0, publish_1.publishGlobal)(MOCK_CHANNEL, JSON.stringify(MOCK_EVENT_PAYLOAD_OBJECT), MOCK_PUBLISH_OPTIONS);
+        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 () => {
@@ -86,9 +130,28 @@ describe('publishGlobal', () => {
             headers: { get: jest.fn().mockReturnValue('UPSTREAM_FAILURE') }
         });
         global.__forge_fetch__ = mockForgeFetch;
-        const payload = { value: 'this is a test payload', funLevel: 100 };
-        const response = (0, publish_1.publishGlobal)('my-channel', JSON.stringify(payload));
+        const response = (0, publish_1.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(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({ 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(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({ token: null, expiresAt: null, errors: MOCK_ERRORS });
+        expect(mockForgeFetch.mock.calls).toMatchSnapshot();
+    });
+});

package/out/__test__/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/__test__/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,eAAO,MAAM,aAAa,EAAE,YA6B3B,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/__test__/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,eAAO,MAAM,aAAa,EAAE,YAkD3B,CAAC"}

package/out/__test__/utils.js

@@ -16,7 +16,28 @@ exports.FORGE_RUNTIME = {
         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/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,23 @@
-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>;
+interface PublishOptions {
+    token?: string;
+}
+export declare const publish: (channelName: string, eventPayload: string, options?: PublishOptions) => Promise<{
+    eventId: null;
+    eventTimestamp: null;
+    errors: any;
+} | {
+    eventId: any;
+    eventTimestamp: any;
+    errors?: undefined;
+}>;
+export declare const publishGlobal: (channelName: string, eventPayload: string, options?: PublishOptions) => Promise<{
+    eventId: null;
+    eventTimestamp: null;
+    errors: any;
+} | {
+    eventId: any;
+    eventTimestamp: any;
+    errors?: undefined;
+}>;
+export {};
 //# 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":"AAwBA,UAAU,cAAc;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,OAAO,gBAAuB,MAAM,gBAAgB,MAAM,YAAY,cAAc;;;;;;;;EAiEhG,CAAC;AAEF,eAAO,MAAM,aAAa,gBAAuB,MAAM,gBAAgB,MAAM,YAAY,cAAc;;;;;;;;EAgEtG,CAAC"}

package/out/publish.js

@@ -1,22 +1,14 @@
 "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!
   $payload: String!
   $isGlobal: Boolean
+  $token: String
 ){
   ecosystem {
     publishRealtimeChannel(
@@ -24,17 +16,17 @@ const graphqlBody = `mutation publishRealtimeChannel(
       name: $name
       payload: $payload
       isGlobal: $isGlobal
+      token: $token
     ) {
         eventId,
         eventTimestamp
     }
   }
 }`;
-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 publish = async (channelName, eventPayload, options) => {
     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'
@@ -46,22 +38,48 @@ const publish = async (channelName, eventPayload) => {
                 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
         }
     });
-    (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 publishGlobal = async (channelName, eventPayload, options) => {
     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'
@@ -73,14 +91,40 @@ const publishGlobal = async (channelName, eventPayload) => {
                 installationId: appContext.installationId,
                 name: channelName,
                 payload: eventPayload,
-                isGlobal: true
+                isGlobal: true,
+                token: options?.token
             }
         }),
+        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<{
+    token: null;
+    expiresAt: null;
+    errors: any;
+} | {
+    token: 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 {
+            token: null,
+            expiresAt: null,
+            errors
+        };
+    }
+    if (!data) {
+        return {
+            token: null,
+            expiresAt: null,
+            errors: [
+                {
+                    message: 'Error signing realtime token.'
+                }
+            ]
+        };
+    }
+    const { jwt, expiresAt } = data.ecosystem.signRealtimeToken.forgeRealtimeToken;
+    return {
+        token: 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-experimental-3f68b81",
   "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-experimental-3f68b81",
     "@types/node": "20.19.1"
   },
   "publishConfig": {