@api-client/core 0.3.11 → 0.4.1

package/src/runtime/reporters/Reporter.ts

@@ -1,5 +1,5 @@
 import { IRequestLog } from '../../models/RequestLog.js';
-import { IArcResponse } from '../../models/ArcResponse.js';
+import { IResponse } from '../../models/Response.js';
 import { ErrorResponse } from '../../models/ErrorResponse.js';
 
 export interface IProjectExecutionIteration {
@@ -56,7 +56,7 @@ export abstract class Reporter {
     if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
       return true;
     }
-    const response = log.response as IArcResponse;
+    const response = log.response as IResponse;
     if (response.status >= 400) {
       return true;
     }
@@ -93,7 +93,7 @@ export abstract class Reporter {
         if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
           return;
         }
-        const response = log.response as IArcResponse;
+        const response = log.response as IResponse;
         if (response.status < 400) {
           result++;
         }
@@ -114,7 +114,7 @@ export abstract class Reporter {
         if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
           return;
         }
-        const response = log.response as IArcResponse;
+        const response = log.response as IResponse;
         if (response.loadingTime && response.loadingTime > 0) {
           result += response.loadingTime;
         }

package/src/runtime/store/AuthSdk.ts

@@ -0,0 +1,126 @@
+import { SdkBase, IStoreTokenInfo } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { Headers } from '../../lib/headers/Headers.js';
+import WebSocketNode from 'ws';
+
+export class AuthSdk extends SdkBase {
+  protected getExpires(headers: Headers): number | undefined {
+    const expires = headers.get('expires');
+    if (!expires) {
+      return undefined;
+    }
+    const d = new Date(expires);
+    const time = d.getTime();
+    if (Number.isNaN(time)) {
+      console.warn(`Invalid session response: the expires header cannot be parsed.`);
+      return undefined;
+    }
+    return time;
+  }
+
+  /**
+   * Creates unauthenticated session in the backend.
+   * @returns The JWT for unauthenticated user.
+   */
+  async createSession(): Promise<IStoreTokenInfo> {
+    const url = this.sdk.getUrl(RouteBuilder.sessions());
+    // console.log('Create session: ', url);
+    const result = await this.sdk.http.post(url.toString());
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Unable to create the session. Invalid response status: ${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`Unable to create the session. Response has no token.`);
+    }
+    const info: IStoreTokenInfo = {
+      token: result.body,
+    };
+    const expires = this.getExpires(result.headers);
+    if (expires) {
+      info.expires = expires;
+    }
+    return info;
+  }
+
+  /**
+   * Initializes the authentication session.
+   * @param token The unauthenticated session JWT. Required when not set on the class.
+   * @returns The location of the authorization endpoint.
+   */
+  async createAuthSession(token?: string, loginPath = '/auth/login'): Promise<string> {
+    const url = this.sdk.getUrl(loginPath);
+    const result = await this.sdk.http.post(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const loc = result.headers.get('location');
+    if (!loc) {
+      throw new Error(`The location header not returned by the server.`);
+    }
+    return loc;
+  }
+
+  /**
+   * Listens to the first message coming to the client from the auth endpoint.
+   * @param authPath The authorization path returned by the server info or 401 response.
+   * @param token Optional token to use.
+   */
+  async listenAuth(authPath: string, token?: string): Promise<void> {
+    const url = this.sdk.getUrl(authPath);
+    const client = await this.sdk.ws.createAndConnect(url.toString(), token);
+    return new Promise((resolve, reject) => {
+      const { sdk } = this;
+      async function finishData(data: any): Promise<void> {
+        let message: any;
+        try {
+          message = JSON.parse(data.toString());
+          await sdk.ws.disconnect(client);
+        } catch (cause) {
+          reject(cause);
+          return;
+        }
+        if (message.status === 'OK') {
+          resolve();
+        } else {
+          reject(new Error(message.message || 'Unknown error'));
+        }
+      }
+      const typedNode = client as WebSocketNode;
+      if (typeof typedNode.on === 'function') {
+        typedNode.on('message', (data: Buffer) => {
+          finishData(data);
+        });
+      } else {
+        const typedWeb = client as WebSocket;
+        typedWeb.addEventListener('message', (event) => {
+          finishData(event.data);
+        });
+      }
+    });
+  }
+
+  /**
+   * Renews authenticated token to a new one when the token expires.
+   * @param token Optional token to use.
+   * @returns 
+   */
+  async renewToken(token = this.sdk.token): Promise<IStoreTokenInfo> {
+    const authPath = RouteBuilder.sessionRenew();
+    const url = this.sdk.getUrl(authPath);
+    const result = await this.sdk.http.post(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Unable to renew the token. Invalid response status: ${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`Unable to create the session. Response has no token.`);
+    }
+    const info: IStoreTokenInfo = {
+      token: result.body,
+    };
+    const expires = this.getExpires(result.headers);
+    if (expires) {
+      info.expires = expires;
+    }
+    return info;
+  }
+}

package/src/runtime/store/BackendSdk.ts

@@ -0,0 +1,25 @@
+import { SdkBase } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { IBackendInfo } from '../../models/Backend.js';
+
+export class BackendSdk extends SdkBase {
+  /**
+   * @returns Client information about the store configuration.
+   */
+  async getInfo(): Promise<IBackendInfo> {
+    const url = this.sdk.getUrl(RouteBuilder.backend());
+    const result = await this.sdk.http.get(url.toString());
+    this.inspectCommonStatusCodes(result.status);
+    if (result.status !== 200) {
+      throw new Error(`Invalid store response. Expected 200 status and ${result.status} received.`);
+    }
+    const body = result.body as string;
+    let data;
+    try {
+      data = JSON.parse(body);
+    } catch (e) {
+      throw new Error(`The server returned invalid response. Unable to read store status.`);
+    }
+    return data as IBackendInfo;
+  }
+}

package/src/runtime/store/HistorySdk.ts

@@ -0,0 +1,157 @@
+import { SdkBase, E_RESPONSE_STATUS, E_RESPONSE_NO_VALUE, E_INVALID_JSON, E_RESPONSE_UNKNOWN, E_RESPONSE_LOCATION } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { IListResponse, HistoryListOptions } from '../../models/Backend.js';
+import { IHttpHistory, IHttpHistoryBulkAdd, Kind as HttpHistoryKind } from '../../models/HttpHistory.js';
+
+export class HistorySdk extends SdkBase {
+  /**
+   * Creates a history object.
+   * A history object can be created per app (type = app) or a store's space/[project/[request]].
+   * 
+   * The user can always read their own history. If the history is created for a space/project then 
+   * history records are shared as any other object in the space.
+   * 
+   * Note, history objects cannot be updated. They can only be created or deleted.
+   * 
+   * @param history The history to create
+   * @returns The key of the created history.
+   */
+  async create(history: IHttpHistory): Promise<string> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.history());
+    const body = JSON.stringify(history);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    const location = result.headers.get('location');
+    if (!location) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_LOCATION}`);
+    }
+    const id = location.split('/').pop();
+    return id as string;
+  }
+
+  /**
+   * Creates a multiple history objects in a batch operation.
+   * 
+   * @param info The bulk create info object.
+   */
+  async createBulk(info: IHttpHistoryBulkAdd): Promise<string[]> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.historyBatchCreate());
+    const body = JSON.stringify(info);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a bulk history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: string[];
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Lists the history.
+   * 
+   * @param options Optional query options.
+   */
+  async list(options: HistoryListOptions): Promise<IListResponse> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.history());
+    this.sdk.appendListOptions(url, options);
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to list history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IListResponse;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.data)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Deletes a history object form the store.
+   * 
+   * @param key The key returned by the store when created the history. Also available via the `key` property on the history object.
+   */
+  delete(key: string): Promise<void>;
+  /**
+   * Deletes a list of history objects in a batch operation.
+   * 
+   * @param keys The keys returned by the store when created the history. Also available via the `key` property on the history object.
+   */
+  delete(keys: string[]): Promise<void>;
+  /**
+   * Deletes a history or a list of history objects from the store.
+   * @param key A key or a list of keys.
+   */
+  async delete(key: string | string[]): Promise<void> {
+    const { token } = this.sdk;
+    const isArray = Array.isArray(key);
+    const path = isArray ? RouteBuilder.historyBatchDelete() : RouteBuilder.historyItem(key);
+    const url = this.sdk.getUrl(path);
+
+    const result = isArray ? await this.sdk.http.post(url.toString(), { token, body: JSON.stringify(key) }) : await this.sdk.http.delete(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to delete history. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+  }
+
+  /**
+   * Reads a history definition from the store.
+   * @param key The history key
+   * @returns The history object
+   */
+  async read(key: string): Promise<IHttpHistory> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.historyItem(key));
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to read a history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IHttpHistory;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (data.kind !== HttpHistoryKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+}

package/src/runtime/store/Http.ts

@@ -0,0 +1,18 @@
+import { SdkBase, IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+
+export abstract class Http extends SdkBase {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  abstract get(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract post(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract patch(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+
+  abstract delete(url: string, opts?: IStoreRequestOptions): Promise<IStoreResponse>;
+}

package/src/runtime/store/HttpNode.ts

@@ -0,0 +1,100 @@
+import http from 'http';
+import https from 'https';
+import { Headers } from '../../lib/headers/Headers.js';
+import { Http } from './Http.js';
+import { IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+
+export class HttpNode extends Http {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  async get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const result = await this._get(url, opts);
+    if ([301, 302, 308, 307].includes(result.status)) {
+      const loc = result.headers.get('location');
+      if (!loc) {
+        throw new Error('Expected redirection but no "location" header.')
+      }
+      const newUrl = new URL(loc, url);
+      return this.get(newUrl.toString(), opts);
+    }
+    return result;
+  }
+
+  private _get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    return new Promise((resolve, reject) => {
+      const { method='GET', headers={}, token = this.sdk.token } = opts;
+      if (token) {
+        headers.authorization = `Bearer ${token}`;
+      }
+      const isSsl = url.startsWith('https:');
+      const lib = isSsl ? https : http;
+      // console.log(`${method} ${url}`);
+      const request = lib.request(url, {
+        method,
+        headers,
+        rejectUnauthorized: false,
+      });
+      request.on('response', (response) => {
+        const ro: IStoreResponse = {
+          status: response.statusCode as number,
+          headers: new Headers(response.headers),
+          body: '',
+        };
+        response.on('data', (chunk) => {
+          ro.body += chunk;
+        });
+        response.on('end', () => resolve(ro));
+      });
+      request.on('error', (error) => reject(error));
+      request.end();
+    });
+  }
+
+  post(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    return new Promise((resolve, reject) => {
+      const { method='POST', headers={}, token = this.sdk.token } = opts;
+      if (token) {
+        headers.authorization = `Bearer ${token}`;
+      }
+      const isSsl = url.startsWith('https:');
+      const lib = isSsl ? https : http;
+      const request = lib.request(url, {
+        method,
+        headers,
+      });
+      request.on('response', (response) => {
+        const ro: IStoreResponse = {
+          status: response.statusCode as number,
+          headers: new Headers(response.headers),
+          body: '',
+        };
+        response.on('data', (chunk) => {
+          ro.body += chunk;
+        });
+        response.on('end', () => resolve(ro));
+      });
+      request.on('error', (error) => reject(error));
+      if (opts.body) {
+        request.write(opts.body);
+      }
+      request.end();
+    });
+  }
+
+  patch(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options = { ...opts };
+    options.method = 'PATCH';
+    return this.post(url, options);
+  }
+
+  delete(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options = { ...opts };
+    options.method = 'DELETE';
+    return this.post(url, options);
+  }
+}

package/src/runtime/store/HttpWeb.ts

@@ -0,0 +1,89 @@
+import { Http } from './Http.js';
+import { IStoreRequestOptions, IStoreResponse } from './SdkBase.js';
+import { Headers } from '../../lib/headers/Headers.js';
+
+export class HttpWeb extends Http {
+  /**
+   * Performs the GET request.
+   * 
+   * @param url The request URL
+   * @param opts The request options
+   * @returns The response info.
+   */
+  async get(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const { method='GET', headers={}, token = this.sdk.token } = opts;
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    // eslint-disable-next-line no-undef
+    const init: RequestInit = {
+      method,
+      headers,
+      redirect: 'follow',
+    };
+    const response = await fetch(url, init);
+    let body: string | undefined;
+    try {
+      body = await response.text();
+    } catch (e) {
+      // ...
+    }
+
+    const responseHeaders = new Headers();
+    response.headers.forEach((value: string, key: string) => {
+      responseHeaders.append(key, value);
+    });
+
+    const result: IStoreResponse = {
+      status: response.status,
+      headers: responseHeaders,
+      body,
+    };
+    return result;
+  }
+
+  async post(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const { method='POST', headers={}, token = this.sdk.token } = opts;
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    // eslint-disable-next-line no-undef
+    const init: RequestInit = {
+      method,
+      headers,
+      redirect: 'follow',
+    };
+    if (opts.body) {
+      init.body = opts.body.toString();
+    }
+    const response = await fetch(url, init);
+    let body: string | undefined;
+    try {
+      body = await response.text();
+    } catch (e) {
+      // ...
+    }
+
+    const responseHeaders = new Headers();
+    response.headers.forEach((value: string, key: string) => {
+      responseHeaders.append(key, value);
+    });
+
+    const result: IStoreResponse = {
+      status: response.status,
+      headers: responseHeaders,
+      body,
+    };
+    return result;
+  }
+
+  patch(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options: IStoreRequestOptions = { ...opts, method: 'PATCH' };
+    return this.post(url, options);
+  }
+
+  delete(url: string, opts: IStoreRequestOptions = {}): Promise<IStoreResponse> {
+    const options: IStoreRequestOptions = { ...opts, method: 'DELETE' };
+    return this.post(url, options);
+  }
+}

package/src/runtime/store/ProjectsSdk.ts

@@ -0,0 +1,147 @@
+import { JsonPatch } from 'json8-patch';
+import { SdkBase, E_RESPONSE_STATUS, E_RESPONSE_NO_VALUE, E_INVALID_JSON, E_RESPONSE_UNKNOWN, E_RESPONSE_LOCATION } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { IListOptions, IListResponse } from '../../models/Backend.js';
+import { HttpProject, IHttpProject, Kind as HttpProjectKind } from '../../models/HttpProject.js';
+
+export class ProjectsSdk extends SdkBase {
+  /**
+   * Creates a project in a user space.
+   * 
+   * @param space The user space key
+   * @param project THe project to create
+   * @returns The key of the created project.
+   */
+  async create(space: string, project: IHttpProject | HttpProject): Promise<string> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.spaceProjects(space));
+    const body = JSON.stringify(project);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a project. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    const location = result.headers.get('location');
+    if (!location) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_LOCATION}`);
+    }
+    const id = location.split('/').pop();
+    return id as string;
+  }
+
+  /**
+   * Reads a project definition from the store.
+   * @param space The user space key
+   * @param project The project key
+   * @returns The definition of the project.
+   */
+  async read(space: string, project: string): Promise<IHttpProject> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.spaceProject(space, project));
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to read a project. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IHttpProject;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (data.kind !== HttpProjectKind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Lists projects in the space
+   * 
+   * @param space The user space key
+   * @param options Optional query options.
+   */
+  async list(space: string, options?: IListOptions): Promise<IListResponse> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.spaceProjects(space));
+    this.sdk.appendListOptions(url, options);
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to list projects. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IListResponse;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.data)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Deletes a project form the store.
+   * 
+   * @param space The key of the parent space.
+   * @param project The key of the project to delete.
+   */
+  async delete(space: string, project: string): Promise<void> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.spaceProject(space, project));
+    const result = await this.sdk.http.delete(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to delete a project. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+  }
+
+  /**
+   * Patches a project in the store.
+   * @param space The key of the parent user space
+   * @param project The key of project to patch.
+   * @param value The JSON patch to be processed.
+   * @returns The JSON patch to revert the change using the `json8-patch` library
+   */
+  async patch(space: string, project: string, value: JsonPatch): Promise<JsonPatch> {
+    const { token } = this.sdk;
+    const url = this.sdk.getUrl(RouteBuilder.spaceProject(space, project));
+    const body = JSON.stringify(value);
+    const result = await this.sdk.http.patch(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to patch a project. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      throw new Error(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`);
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: any;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!data.revert) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data.revert as JsonPatch;
+  }
+}