@forge/realtime 0.1.1 → 0.2.0-experimental-3ed5db1

package/src/__test__/publish.test.ts

@@ -1,203 +0,0 @@
-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();
-    jest.resetAllMocks();
-  });
-
-  it('should publish an event with FCT in header', async () => {
-    jest.spyOn(runtime, '__getRuntime').mockReturnValue(FORGE_RUNTIME);
-
-    const mockForgeFetch = jest.fn().mockResolvedValue({
-      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(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(FORGE_RUNTIME);
-
-    const mockForgeFetch = jest.fn().mockResolvedValue({
-      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(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 () => {
-    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 = 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', () => {
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.resetAllMocks();
-  });
-
-  it('should publish an event', async () => {
-    jest.spyOn(runtime, '__getRuntime').mockReturnValue(FORGE_RUNTIME);
-
-    const mockForgeFetch = jest.fn().mockResolvedValue({
-      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(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(FORGE_RUNTIME);
-
-    const mockForgeFetch = jest.fn().mockResolvedValue({
-      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(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 () => {
-    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 = 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__/runtime.test.ts

@@ -1,13 +0,0 @@
-import { __getRuntime } from '../runtime';
-import { FORGE_RUNTIME } from './utils';
-
-describe('__getRuntime', () => {
-  it('should return the runtime object', async () => {
-    (global as any).__forge_runtime__ = FORGE_RUNTIME;
-
-    const runtime = __getRuntime();
-
-    expect(runtime.appContext.appId).toBe('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa');
-    expect(runtime.contextAri).toBe('ari:cloud:jira::site/ffffffff-ffff-ffff-ffff-ffffffffffff');
-  });
-});

package/src/__test__/signRealtimeToken.test.ts

@@ -1,96 +0,0 @@
-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

@@ -1,33 +0,0 @@
-import type { ForgeRuntime } from '@forge/api';
-import { NoMetrics } from '@atlassian/metrics-interface';
-
-export const FORGE_RUNTIME: ForgeRuntime = {
-  container: { runtime: 'node', region: 'us-west-2' },
-  proxy: { url: 'https://foo', token: 'token' },
-  contextAri: 'ari:cloud:jira::site/ffffffff-ffff-ffff-ffff-ffffffffffff',
-  appContext: {
-    appId: 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
-    environmentId: 'eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee',
-    environmentType: 'DEVELOPMENT',
-    invocationId: '33333',
-    installationId: 'iiiiiiii-iiii-iiii-iiii-iiiiiiiiiiii',
-    appVersion: '1.2.3',
-    functionKey: 'functionKey',
-    moduleType: 'moduleType',
-    moduleKey: 'moduleKey',
-    license: { isActive: true }
-  },
-  tracing: {
-    traceId: 'traceId',
-    spanId: 'spanId'
-  },
-  lambdaContext: {
-    awsRequestId: '123',
-    getRemainingTimeInMillis: jest.fn()
-  },
-  metrics: new NoMetrics(),
-  realtime: {
-    contextToken: 'my.context.token'
-  },
-  featureFlags: jest.fn()
-};

package/src/index.ts

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

package/src/publish.ts

@@ -1,160 +0,0 @@
-import { __getRuntime } from './runtime';
-import { handleProxyResponseErrors, prodEnvErrorMessage } from './utils';
-
-const graphqlBody = `mutation publishRealtimeChannel(
-  $installationId: ID!
-  $name: String!
-  $payload: String!
-  $isGlobal: Boolean
-  $token: String
-){
-  ecosystem {
-    publishRealtimeChannel(
-      installationId: $installationId
-      name: $name
-      payload: $payload
-      isGlobal: $isGlobal
-      token: $token
-    ) {
-        eventId,
-        eventTimestamp
-    }
-  }
-}`;
-
-interface PublishOptions {
-  token?: string;
-}
-
-export const publish = async (channelName: string, eventPayload: string, options?: PublishOptions) => {
-  const { appContext, realtime } = __getRuntime();
-
-  if (appContext?.environmentType === 'PRODUCTION') {
-    throw new Error(prodEnvErrorMessage);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const response = await (global as any).__forge_fetch__(
-    {
-      type: 'realtime'
-    },
-    '/',
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        query: graphqlBody,
-        variables: {
-          installationId: appContext.installationId,
-          name: channelName,
-          payload: eventPayload,
-          isGlobal: false,
-          token: options?.token
-        }
-      }),
-      errors: [],
-      headers: {
-        'Content-Type': 'application/json',
-        'x-forge-context-token': realtime?.contextToken
-      }
-    }
-  );
-
-  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
-  };
-};
-
-export const publishGlobal = async (channelName: string, eventPayload: string, options?: PublishOptions) => {
-  const { appContext } = __getRuntime();
-
-  if (appContext?.environmentType === 'PRODUCTION') {
-    throw new Error(prodEnvErrorMessage);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const response = await (global as any).__forge_fetch__(
-    {
-      type: 'realtime'
-    },
-    '/',
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        query: graphqlBody,
-        variables: {
-          installationId: appContext.installationId,
-          name: channelName,
-          payload: eventPayload,
-          isGlobal: true,
-          token: options?.token
-        }
-      }),
-      errors: [],
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    }
-  );
-
-  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
-  };
-};

package/src/runtime.ts

@@ -1,9 +0,0 @@
-import type { ForgeRuntime } from '@forge/api';
-
-export function __getRuntime(): ForgeRuntime {
-  const runtime = (global as any).__forge_runtime__;
-  if (!runtime) {
-    throw new Error('Forge runtime not found.');
-  }
-  return runtime as ForgeRuntime;
-}

package/src/signRealtimeToken.ts

@@ -1,90 +0,0 @@
-import { __getRuntime } from './runtime';
-import { handleProxyResponseErrors, prodEnvErrorMessage } from './utils';
-
-const graphqlBody = `mutation signRealtimeToken(
-  $channelName: String!
-  $claims: JSON!
-){
-  ecosystem {
-    signRealtimeToken(
-        channelName: $channelName
-        claims: $claims
-    ) {
-        errors {
-            message
-            extensions {
-            errorType
-            statusCode
-            }
-        }
-        forgeRealtimeToken {
-            jwt
-            expiresAt
-        }
-        success
-    }
-  }
-}`;
-
-export const signRealtimeToken = async (channelName: string, claims: any) => {
-  const { appContext } = __getRuntime();
-
-  if (appContext?.environmentType === 'PRODUCTION') {
-    throw new Error(prodEnvErrorMessage);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const response = await (global as any).__forge_fetch__(
-    {
-      type: 'realtime'
-    },
-    '/',
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        query: graphqlBody,
-        variables: {
-          channelName,
-          claims
-        }
-      }),
-      errors: [],
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    }
-  );
-
-  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
-  };
-};

package/src/utils.ts

@@ -1,12 +0,0 @@
-import { ProxyRequestError } from '@forge/api';
-
-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);
-  }
-};
-
-export 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.';

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "lib": [
-      "es2017",
-      "DOM"
-    ],
-    "outDir": "./out",
-    "rootDir": "src",
-    "composite": true,
-    "moduleResolution": "node"
-  },
-  "references": [
-    {
-      "path": "../forge-api"
-    }
-  ]
-}