use reflow to migrate from flow to typescript

scm-ui/ui-components/src/apiclient.ts

@@ -0,0 +1,118 @@
+import { contextPath } from './urls';
+import {
+  createBackendError,
+  ForbiddenError,
+  isBackendError,
+  UnauthorizedError,
+} from './errors';
+import { BackendErrorContent } from './errors';
+
+const applyFetchOptions: (p: RequestOptions) => RequestOptions = o => {
+  o.credentials = 'same-origin';
+  o.headers = {
+    Cache: 'no-cache',
+    // identify the request as ajax request
+    'X-Requested-With': 'XMLHttpRequest',
+  };
+  return o;
+};
+
+function handleFailure(response: Response) {
+  if (!response.ok) {
+    if (isBackendError(response)) {
+      return response.json().then((content: BackendErrorContent) => {
+        throw createBackendError(content, response.status);
+      });
+    } else {
+      if (response.status === 401) {
+        throw new UnauthorizedError('Unauthorized', 401);
+      } else if (response.status === 403) {
+        throw new ForbiddenError('Forbidden', 403);
+      }
+
+      throw new Error('server returned status code ' + response.status);
+    }
+  }
+  return response;
+}
+
+export function createUrl(url: string) {
+  if (url.includes('://')) {
+    return url;
+  }
+  let urlWithStartingSlash = url;
+  if (url.indexOf('/') !== 0) {
+    urlWithStartingSlash = '/' + urlWithStartingSlash;
+  }
+  return `${contextPath}/api/v2${urlWithStartingSlash}`;
+}
+
+class ApiClient {
+  get(url: string): Promise<Response> {
+    return fetch(createUrl(url), applyFetchOptions({})).then(handleFailure);
+  }
+
+  post(url: string, payload: any, contentType: string = 'application/json') {
+    return this.httpRequestWithJSONBody('POST', url, contentType, payload);
+  }
+
+  postBinary(url: string, fileAppender: (p: FormData) => void) {
+    let formData = new FormData();
+    fileAppender(formData);
+
+    let options: RequestOptions = {
+      method: 'POST',
+      body: formData,
+    };
+    return this.httpRequestWithBinaryBody(options, url);
+  }
+
+  put(url: string, payload: any, contentType: string = 'application/json') {
+    return this.httpRequestWithJSONBody('PUT', url, contentType, payload);
+  }
+
+  head(url: string) {
+    let options: RequestOptions = {
+      method: 'HEAD',
+    };
+    options = applyFetchOptions(options);
+    return fetch(createUrl(url), options).then(handleFailure);
+  }
+
+  delete(url: string): Promise<Response> {
+    let options: RequestOptions = {
+      method: 'DELETE',
+    };
+    options = applyFetchOptions(options);
+    return fetch(createUrl(url), options).then(handleFailure);
+  }
+
+  httpRequestWithJSONBody(
+    method: string,
+    url: string,
+    contentType: string,
+    payload: any,
+  ): Promise<Response> {
+    let options: RequestOptions = {
+      method: method,
+      body: JSON.stringify(payload),
+    };
+    return this.httpRequestWithBinaryBody(options, url, contentType);
+  }
+
+  httpRequestWithBinaryBody(
+    options: RequestOptions,
+    url: string,
+    contentType?: string,
+  ) {
+    options = applyFetchOptions(options);
+    if (contentType) {
+      // $FlowFixMe
+      options.headers['Content-Type'] = contentType;
+    }
+
+    return fetch(createUrl(url), options).then(handleFailure);
+  }
+}
+
+export let apiClient = new ApiClient();