@forge/migrations 0.0.0

package/src/__test__/migration.test.ts

@@ -0,0 +1,242 @@
+import { APIError, migration } from '../migration';
+import { Progress } from '../migration/migration-adaptor';
+import { when } from 'jest-when';
+import fetch, { Response } from 'node-fetch';
+import { mocked } from 'ts-jest/utils';
+
+let transferId: string;
+let invalidTransferId: string;
+let progress: Progress;
+let keys: string[];
+let invalidKeys: string[];
+let namespace: string;
+let mappingByKeyResponseWithKeys: string;
+let mappingByKeyResponseWithInvalidKeys: string;
+let s3Key: string;
+let invalidS3Key: string;
+let feedbackPayload: object;
+let appDataListResponse: string;
+let appDataPayloadResponse: string;
+jest.mock('node-fetch');
+
+describe('migration', () => {
+  beforeAll(() => {
+    (global as any).api = {
+      asApp: jest.fn().mockReturnValue({
+        __requestAtlassian: jest.fn()
+      })
+    };
+    transferId = '521ee36a-b673-3dc6-b60b-12460332c200';
+    invalidTransferId = '521ee36a-b673-3dc6-b60b-12460332c001';
+  });
+
+  describe('sendMigrationProgress', () => {
+    beforeAll(() => {
+      progress = { status: 'IN_PROGRESS', percent: 10, message: 'reporting' };
+      when((global as any).api.asApp().__requestAtlassian)
+        .calledWith(`/app/migration/forge/v1/progress/${transferId}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(progress)
+        })
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockImplementationOnce(() => Promise.resolve()),
+          json: jest.fn().mockImplementationOnce(() => Promise.resolve())
+        })
+        .calledWith(`/app/migration/forge/v1/progress/${invalidTransferId}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(progress)
+        })
+        .mockReturnValue({
+          status: 403,
+          statusText: 'Forbidden'
+        });
+    });
+
+    it('should update progress when sendProgress method called with valid transferId', async () => {
+      const returnedValue = migration.sendProgress(transferId, progress);
+      await expect(returnedValue).resolves.toBeUndefined();
+    });
+
+    it('should return 403 when sendProgress method called with invalid transferId', async () => {
+      const returnedValue = migration.sendProgress(invalidTransferId, progress);
+      await expect(returnedValue).rejects.toThrow(APIError.forStatus(403, 'Forbidden'));
+    });
+  });
+
+  describe('getMappingById', () => {
+    beforeAll(() => {
+      keys = ['email/abc@example.com', 'email/admin@example.com'];
+      invalidKeys = ['email/abc@example.com', 'email/admin@example'];
+      namespace = 'identity:user';
+      mappingByKeyResponseWithKeys =
+        '{"email/abc@example.com":"5a20a4d7c6bd4a32df3a711","email/admin@example.com":"5a29c4ae20cfc31b0dc0e112"}';
+      mappingByKeyResponseWithInvalidKeys = '{"email/abc@example.com":"5a20a4d7c6bd4a32df3a711"}';
+
+      when((global as any).api.asApp().__requestAtlassian)
+        .calledWith(`/app/migration/forge/v1/mapping/${transferId}/find?namespace=${namespace}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(keys)
+        })
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockResolvedValue(mappingByKeyResponseWithKeys),
+          json: jest.fn().mockResolvedValue(JSON.parse(mappingByKeyResponseWithKeys))
+        })
+        .calledWith(`/app/migration/forge/v1/mapping/${transferId}/find?namespace=${namespace}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(invalidKeys)
+        })
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockResolvedValue(mappingByKeyResponseWithInvalidKeys),
+          json: jest.fn().mockResolvedValue(JSON.parse(mappingByKeyResponseWithInvalidKeys))
+        })
+        .calledWith(`/app/migration/forge/v1/mapping/${invalidTransferId}/find?namespace=${namespace}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(keys)
+        })
+        .mockReturnValue({
+          status: 403,
+          statusText: 'Forbidden'
+        });
+    });
+
+    it('should return MappingResponse when getMappingById method called with valid transferId', async () => {
+      const returnedValue = await migration.getMappingById(transferId, namespace, keys);
+      expect(JSON.stringify(returnedValue)).toEqual(mappingByKeyResponseWithKeys);
+    });
+
+    it('should return 403 when getMappingById method called with invalid transferId', async () => {
+      const returnedValue = migration.getMappingById(invalidTransferId, namespace, keys);
+      await expect(returnedValue).rejects.toThrow(APIError.forStatus(403, 'Forbidden'));
+    });
+
+    it('should return MappingResponse except for invalid keys when getMappingById method called with valid transferId', async () => {
+      const returnedValue = await migration.getMappingById(transferId, namespace, invalidKeys);
+      expect(JSON.stringify(returnedValue)).toEqual(mappingByKeyResponseWithInvalidKeys);
+    });
+  });
+
+  describe('getAppDataList', () => {
+    beforeAll(() => {
+      appDataListResponse =
+        '[{"s3Key":"2ea231e3-ab0d-4236-97f7-26f951df1c11","label":null},{"s3Key":"317a3631-2fef-4940-a418-7096e971eb11","label":null}]';
+
+      when((global as any).api.asApp().__requestAtlassian)
+        .calledWith(`/app/migration/forge/v1/data/${transferId}/all`)
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockResolvedValue(appDataListResponse),
+          json: jest.fn().mockResolvedValue(JSON.parse(appDataListResponse))
+        })
+        .calledWith(`/app/migration/forge/v1/data/${invalidTransferId}/all`)
+        .mockReturnValue({
+          status: 403,
+          statusText: 'Forbidden'
+        });
+    });
+
+    it('should return AppDataListResponse when getAppDataList method called with valid transferId', async () => {
+      const returnedValue = await migration.getAppDataList(transferId);
+      expect(returnedValue).toEqual(JSON.parse(appDataListResponse));
+    });
+
+    it('should return 403 when getAppDataList method called with invalid transferId', async () => {
+      const returnedValue = migration.getAppDataList(invalidTransferId);
+      await expect(returnedValue).rejects.toThrow(APIError.forStatus(403, 'Forbidden'));
+    });
+  });
+
+  describe('getAppDataPayload', () => {
+    beforeAll(() => {
+      s3Key = '7941b65d-094b-4305-97f2-e2b412c6db0a';
+      invalidS3Key = '7941b65d-094b-4305-97f2-e2b412c000';
+      appDataPayloadResponse = '{ "url": "https://rps--stg-east--app-migration-service--ams.s3.amazonaws.com/test"}';
+
+      mocked(fetch).mockImplementation(() =>
+        Promise.resolve({
+          text: () => Promise.resolve('Sample app data')
+        } as Response)
+      );
+
+      when((global as any).api.asApp().__requestAtlassian)
+        .calledWith(`/app/migration/forge/v1/data/${s3Key}`)
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockResolvedValue(JSON.stringify(appDataPayloadResponse)),
+          json: jest.fn().mockResolvedValue(JSON.parse(appDataPayloadResponse))
+        })
+        .calledWith(`/app/migration/forge/v1/data/${invalidS3Key}`)
+        .mockReturnValue({
+          status: 403,
+          statusText: 'Forbidden'
+        });
+    });
+
+    it('should return Response when getAppDataPayload method called with valid S3Key', async () => {
+      const returnedValue = await migration.getAppDataPayload(s3Key);
+      await expect(returnedValue.text()).resolves.toBe('Sample app data');
+    });
+
+    it('should return 403 when getAppDataPayload method called with invalid S3Key', async () => {
+      const returnedValue = migration.getAppDataPayload(invalidS3Key);
+      await expect(returnedValue).rejects.toThrow(APIError.forStatus(403, 'Forbidden'));
+    });
+  });
+
+  describe('updateFeedback', () => {
+    beforeAll(() => {
+      feedbackPayload = { transferId: transferId, msg: 'Current Data processed, send next' };
+      when((global as any).api.asApp().__requestAtlassian)
+        .calledWith(`/app/migration/forge/v1/feedback/${transferId}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(feedbackPayload)
+        })
+        .mockReturnValue({
+          status: 200,
+          text: jest.fn().mockImplementationOnce(() => Promise.resolve()),
+          json: jest.fn().mockImplementationOnce(() => Promise.resolve())
+        })
+        .calledWith(`/app/migration/forge/v1/feedback/${invalidTransferId}`, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify(feedbackPayload)
+        })
+        .mockReturnValue({
+          status: 403,
+          statusText: 'Forbidden'
+        });
+    });
+
+    it('should send feedback when updateFeedback method called with valid transferId', async () => {
+      const returnedValue = migration.updateFeedback(transferId, feedbackPayload);
+      await expect(returnedValue).resolves.toBeUndefined();
+    });
+
+    it('should return 403 when updateFeedback method called with invalid transferId', async () => {
+      const returnedValue = migration.updateFeedback(invalidTransferId, feedbackPayload);
+      await expect(returnedValue).rejects.toThrow(APIError.forStatus(403, 'Forbidden'));
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+import { migration } from './migration';
+
+export { migration };

package/src/migration/errors.ts

@@ -0,0 +1,13 @@
+export class APIError extends Error {
+  private constructor(message: string) {
+    super(message);
+  }
+
+  public static forStatus(status: number, message: string): APIError {
+    return new APIError(message);
+  }
+
+  public static forUnexpected(message: string): APIError {
+    return new APIError(message);
+  }
+}

package/src/migration/index.ts

@@ -0,0 +1,26 @@
+import { Migration } from './migration';
+import { MigrationAdapter, Progress } from './migration-adaptor';
+
+export { APIError } from './errors';
+
+export const getMigrationInstance = (adapter: MigrationAdapter) => {
+  return {
+    sendProgress: (transferId: string, progress: Progress) => adapter.sendProgress(transferId, progress),
+    getMappingById: (transferId: string, namespace: string, keys: Array<string>) =>
+      adapter.getMappingById(transferId, namespace, keys),
+    updateFeedback: (transferId: string, feedback: object) => adapter.updateFeedback(transferId, feedback),
+    getAppDataList: (transferId: string) => adapter.getAppDataList(transferId),
+    getAppDataPayload: (s3Key: string) => adapter.getAppDataPayload(s3Key)
+  };
+};
+
+export const migration = {
+  sendProgress: (transferId: string, progress: Progress) =>
+    getMigrationInstance(new Migration()).sendProgress(transferId, progress),
+  getMappingById: (transferId: string, namespace: string, keys: Array<string>) =>
+    getMigrationInstance(new Migration()).getMappingById(transferId, namespace, keys),
+  updateFeedback: (transferId: string, feedback: object) =>
+    getMigrationInstance(new Migration()).updateFeedback(transferId, feedback),
+  getAppDataList: (transferId: string) => getMigrationInstance(new Migration()).getAppDataList(transferId),
+  getAppDataPayload: (s3Key: string) => getMigrationInstance(new Migration()).getAppDataPayload(s3Key)
+};

package/src/migration/migration-adaptor.ts

@@ -0,0 +1,32 @@
+import { Response } from 'node-fetch';
+
+export interface MigrationAdapter {
+  sendProgress(transferId: string, progress: Progress): Promise<void>;
+  getMappingById(transferId: string, namespace: string, keys: Array<string>): Promise<MappingResponse>;
+  getAppDataList(transferId: string): Promise<AppDataListResponse>;
+  getAppDataPayload(s3Key: string): Promise<Response>;
+  updateFeedback(transferId: string, feedback: object): Promise<void>;
+}
+
+export interface MappingResponse {
+  result: Map<string, string>;
+}
+
+export interface AppData {
+  s3Key: string;
+  label: string;
+}
+
+export interface AppDataListResponse {
+  result: Set<AppData>;
+}
+
+export interface AppDataPayloadResponse {
+  url: string;
+}
+
+export interface Progress {
+  status: string;
+  percent: number;
+  message: string;
+}

package/src/migration/migration.ts

@@ -0,0 +1,41 @@
+import fetch, { Response } from 'node-fetch';
+
+import {
+  AppDataListResponse,
+  AppDataPayloadResponse,
+  MappingResponse,
+  MigrationAdapter,
+  Progress
+} from './migration-adaptor';
+
+import { getResponseBody, invokeGETApi, invokePOSTApi } from './utils';
+
+export class Migration implements MigrationAdapter {
+  private readonly basePath = '/app/migration/forge/v1';
+
+  sendProgress = async (transferId: string, progress: Progress): Promise<void> => {
+    const result = await invokePOSTApi(`${this.basePath}/progress/${transferId}`, progress);
+    return getResponseBody(result);
+  };
+
+  getMappingById = async (transferId: string, namespace: string, keys: Array<string>): Promise<MappingResponse> => {
+    const result = await invokePOSTApi(`${this.basePath}/mapping/${transferId}/find?namespace=${namespace}`, keys);
+    return getResponseBody(result);
+  };
+
+  getAppDataList = async (transferId: string): Promise<AppDataListResponse> => {
+    const result = await invokeGETApi(`${this.basePath}/data/${transferId}/all`);
+    return getResponseBody(result);
+  };
+
+  getAppDataPayload = async (s3Key: string): Promise<Response> => {
+    const result = await invokeGETApi(`${this.basePath}/data/${s3Key}`);
+    const responseBody: AppDataPayloadResponse = await getResponseBody(result);
+    return fetch(responseBody.url);
+  };
+
+  updateFeedback = async (transferId: string, feedback: object): Promise<void> => {
+    const result = await invokePOSTApi(`${this.basePath}/feedback/${transferId}`, feedback);
+    return getResponseBody(result);
+  };
+}

package/src/migration/utils.ts

@@ -0,0 +1,31 @@
+import { APIResponse } from '@forge/api';
+import { APIError } from './errors';
+
+export async function getResponseBody(response: APIResponse): Promise<any> {
+  if (response.status !== 200) {
+    throw APIError.forStatus(response.status, response.statusText);
+  }
+
+  const responseText = await response.text();
+  try {
+    if (responseText !== '' && responseText !== undefined) {
+      return JSON.parse(responseText);
+    }
+  } catch (error) {
+    throw APIError.forUnexpected(`Response text was not a valid JSON: ${responseText}`);
+  }
+}
+
+export async function invokePOSTApi(url: string, payload: any): Promise<APIResponse> {
+  return (global as any).api.asApp().__requestAtlassian(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+}
+
+export async function invokeGETApi(url: string): Promise<APIResponse> {
+  return (global as any).api.asApp().__requestAtlassian(url);
+}

package/tsconfig.json

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