@forge/migrations 0.0.0-experimental-416047f

package/src/migration/index.ts

@@ -0,0 +1,33 @@
+import { Migration } from './migration';
+import { Progress } from './migration-adaptor';
+import { DefaultQueryBuilder } from './query-api';
+
+export const getMigrationInstance = (adapter: Migration) => {
+  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),
+    getMappings: (transferId: string, namespace: string) =>
+      new DefaultQueryBuilder(adapter, { transferId: transferId, namespace: namespace }),
+    getContainers: (transferId: string, containerType: string) =>
+      new DefaultQueryBuilder(adapter, { transferId: transferId, containerType: containerType })
+  };
+};
+
+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),
+  getMappings: (transferId: string, namespace: string) =>
+    getMigrationInstance(new Migration()).getMappings(transferId, namespace),
+  getContainers: (transferId: string, containerType: string) =>
+    getMigrationInstance(new Migration()).getContainers(transferId, containerType)
+};

package/src/migration/migration-adaptor.ts

@@ -0,0 +1,71 @@
+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;
+}
+
+export interface PaginationMappingResponse {
+  meta: PaginationResponseMeta;
+  items: Map<string, string>;
+}
+
+interface PaginationResponseMeta {
+  pageSize: number;
+  hasNext: boolean;
+  lastEntity?: string;
+}
+
+export interface PaginationContainerResponse {
+  containers: Array<object>;
+  meta: PaginationResponseMeta;
+}
+
+export interface ListOptions {
+  transferId: string;
+  namespace?: string;
+  containerType?: string;
+  cursor?: string;
+}
+
+export interface Result {
+  key: string;
+  value: object;
+}
+
+export interface ListResults {
+  results: Result[];
+  nextCursor?: string;
+}
+
+export interface QueryBuilder {
+  cursor(cursor: string): QueryBuilder;
+  getMany(): Promise<ListResults>;
+  getOne(): Promise<Result | undefined>;
+}

package/src/migration/migration.ts

@@ -0,0 +1,111 @@
+import fetch, { Response } from 'node-fetch';
+
+import {
+  AppDataListResponse,
+  AppDataPayloadResponse,
+  MappingResponse,
+  MigrationAdapter,
+  Progress,
+  ListOptions,
+  ListResults,
+  Result,
+  PaginationContainerResponse,
+  PaginationMappingResponse
+} 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);
+  };
+
+  getMappings = async (
+    transferId: string,
+    namespace?: string,
+    lastEntity?: string,
+    pageSize?: number
+  ): Promise<ListResults> => {
+    let queryParams = `namespace=${namespace}`;
+    if (pageSize != undefined) {
+      queryParams = queryParams + `&pageSize=${pageSize}`;
+    }
+    if (lastEntity != undefined) {
+      queryParams = queryParams + `&lastEntity=${lastEntity}`;
+    }
+
+    const result = await invokeGETApi(`${this.basePath}/mapping/${transferId}/page?${queryParams}`);
+    const mappingResponse: PaginationMappingResponse = await getResponseBody(result);
+
+    let results: Result[] = [];
+    if (mappingResponse.items != null) {
+      results = Object.entries(mappingResponse.items).map((item) => {
+        return { key: item[0], value: item[1] as object };
+      });
+    }
+
+    return {
+      results: results,
+      nextCursor: mappingResponse.meta.lastEntity != null ? mappingResponse.meta.lastEntity : undefined
+    };
+  };
+
+  getContainers = async (
+    transferId: string,
+    containerType?: string,
+    lastEntity?: string,
+    pageSize?: number
+  ): Promise<ListResults> => {
+    let queryParams = `containerType=${containerType}`;
+    if (pageSize != undefined) {
+      queryParams = queryParams + `&pageSize=${pageSize}`;
+    }
+    if (lastEntity != undefined) {
+      queryParams = queryParams + `&lastEntity=${lastEntity}`;
+    }
+
+    const result = await invokeGETApi(`${this.basePath}/container/${transferId}/page?${queryParams}`);
+    const containerResponse: PaginationContainerResponse = await getResponseBody(result);
+    let results: Result[] = [];
+    if (containerResponse.containers != null) {
+      results = Object.entries(containerResponse.containers).map((item) => {
+        return { key: item[0], value: item[1] };
+      });
+    }
+
+    return {
+      results: results,
+      nextCursor: containerResponse.meta.lastEntity != null ? containerResponse.meta.lastEntity : undefined
+    };
+  };
+
+  list = async (options: ListOptions, pageSize?: number): Promise<ListResults> => {
+    if (options.namespace != undefined)
+      return this.getMappings(options.transferId, options.namespace, options.cursor, pageSize);
+    else return this.getContainers(options.transferId, options.containerType, options.cursor, pageSize);
+  };
+}

package/src/migration/query-api.ts

@@ -0,0 +1,24 @@
+import { QueryBuilder, Result, ListOptions, ListResults } from './migration-adaptor';
+import { Migration } from './migration';
+
+export class DefaultQueryBuilder implements QueryBuilder {
+  constructor(private migration: Pick<Migration, 'list'>, private queryOptions: ListOptions) {}
+
+  cursor(cursor: string): QueryBuilder {
+    return new DefaultQueryBuilder(this.migration, {
+      ...this.queryOptions,
+      cursor
+    });
+  }
+
+  async getOne(): Promise<Result | undefined> {
+    const listResults = await this.migration.list(this.queryOptions, 1);
+    if (listResults.results && listResults.results.length > 0) {
+      return listResults.results[0];
+    }
+  }
+
+  async getMany(): Promise<ListResults> {
+    return this.migration.list(this.queryOptions);
+  }
+}

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"
+    }
+  ]
+}