@api-client/core 0.8.22 → 0.9.1

package/src/models/store/File.ts

@@ -6,10 +6,43 @@ import { IThing, Thing } from '../Thing.js';
 import v4 from '../../lib/uuid.js';
 import { ICapabilities } from './Capabilities.js';
 // this causes error
-// import { Kind as WorkspaceKind } from '../Workspace.js';
+// import { Kind as FolderKind } from '../Folder.js';
 
 export const DefaultOwner = 'default';
 
+export interface FileAddOptions {
+  /**
+   * The parent folder where to put the file.
+   * The `parents` array is always cleared from the file object before adding it to the store.
+   */
+  parent?: string;
+}
+
+export interface MediaReadOptions {
+  /**
+   * When set it reads the file that was marked as `_deleted`. By default it throws when file was deleted.
+   */
+  deleted?: boolean;
+}
+
+/**
+ * A breadcrumb when creating the breadcrumb list for a file.
+ */
+export interface FileBreadcrumb {
+  /**
+   * The datastore key of the object.
+   */
+  key: string;
+  /**
+   * THe kind of the object.
+   */
+  kind: string;
+  /**
+   * The name of the object.
+   */
+  name: string;
+}
+
 export interface IStoredFile {
   /**
    * The kind of the File
@@ -160,7 +193,7 @@ export class StoredFile {
   [ownerSymbol]: string = DefaultOwner;
 
   /**
-   * The owner of this space. The id of the User object.
+   * The owner of this file. This is the id of the User object.
    * Set to `default` when there are no users in the system (no authentication).
    */
   get owner(): string {
@@ -354,15 +387,15 @@ export class StoredFile {
       canUntrash: isOwner,
       canReadMedia: false,
     };
-    // Do not use the `WorkspaceKind` reference here as it's circular and creates
+    // Do not use the `FolderKind` reference here as it's circular and creates
     // an error.
-    if (file.kind === 'Core#Space' && isWriter) {
+    if (file.kind === 'Core#Folder' && isWriter) {
       result.canAddChildren = true;
     }
-    if (file.kind === 'Core#Space') {
+    if (file.kind === 'Core#Folder') {
       result.canListChildren = isReader;
     }
-    if (file.kind !== 'Core#Space') {
+    if (file.kind !== 'Core#Folder') {
       result.canReadMedia = isReader;
     }
     return result;

package/src/proxy/HttpProjectProxy.ts

@@ -25,6 +25,10 @@ export interface IHttpProjectStoreProxyInit extends ProxyInit {
    * Project key
    */
   pid: string;
+  /**
+   * The parent space key.
+   */
+  space: string;
 }
 
 /**
@@ -35,7 +39,7 @@ export default class HttpProjectProxy extends Proxy {
   options?: IProjectRunnerOptions;
 
   protected async configureStore(init: IHttpProjectStoreProxyInit, token: string, baseUri: string): Promise<void> {
-    const { pid, options } = init;
+    const { pid, options, space } = init;
     if (!pid) {
       throw new ApiError({
         error: true,
@@ -44,6 +48,14 @@ export default class HttpProjectProxy extends Proxy {
         code: 400,
       });
     }
+    if (!space) {
+      throw new ApiError({
+        error: true,
+        message: 'Invalid request',
+        detail: 'The "space" parameter is required.',
+        code: 400,
+      });
+    }
     if (!options) {
       throw new ApiError({
         error: true,
@@ -80,7 +92,7 @@ export default class HttpProjectProxy extends Proxy {
     sdk.token = token;
     let project: IHttpProject;
     try {
-      project = await sdk.file.read(pid, true) as IHttpProject;
+      project = await sdk.file.read(space, pid, true) as IHttpProject;
     } catch (cause) {
       const e = cause as Error;
       throw new ApiError(e.message, 400);

package/src/proxy/ProxyService.ts

@@ -1,6 +1,5 @@
 import { IProjectExecutionLog } from "../runtime/reporters/Reporter.js";
 import { IRequestLog } from "../models/RequestLog.js";
-import AppProjectProxy, { IAppProjectProxyInit } from "./AppProjectProxy.js";
 import HttpProjectProxy, { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from "./HttpProjectProxy.js";
 import { IProxyResult } from "./Proxy.js";
 import RequestProxy, { IRequestProxyInit } from "./RequestProxy.js";
@@ -31,18 +30,4 @@ export default class ProxyService {
     await proxy.configure(init, token, storeUri);
     return proxy.execute();
   }
-
-  /**
-   * Executes an AppProject.
-   * 
-   * @param token The user access token to read data from the store.
-   * @param storeUri The store's base URI.
-   * @param init The project run configuration.
-   * @returns The key under which the proxy is cached.
-   */
-  async proxyAppProject(token: string, storeUri: string, init: IAppProjectProxyInit): Promise<IProxyResult<IProjectExecutionLog>> {
-    const proxy = new AppProjectProxy();
-    await proxy.configure(init, token, storeUri);
-    return proxy.execute() as Promise<IProxyResult<IProjectExecutionLog>>;
-  }
 }

package/src/proxy/readme.md

@@ -4,6 +4,5 @@ The libraries to create an HTTP/Socket proxy for API things (projects, requests)
 
 ## Libraries
 
-- `AppProjectProxy` - a class that runs request from an `AppProject`
 - `HttpProjectProxy` - a class that runs request from an `HttpProject`
 - `RequestProxy` - a class that runs a single request as `HttpRequest`

package/src/runtime/node/InteropInterfaces.ts

@@ -4,7 +4,6 @@ import { Environment } from '../../models/Environment.js';
 import { Logger } from '../../lib/logging/Logger.js';
 import { IRequestLog } from '../../models/RequestLog.js';
 import { CookieJar } from '../../cookies/CookieJar.js';
-import { IAppProject } from 'browser.js';
 
 export interface IRequestRunnerOptions {
   /**
@@ -72,7 +71,7 @@ export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {
 }
 
 export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
-  project: IHttpProject | IAppProject;
+  project: IHttpProject;
 }
 
 export interface IProjectRunnerOptions {

package/src/runtime/node/ProjectParallelRunner.ts

@@ -3,7 +3,6 @@ import { cpus } from 'os';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { HttpProject } from '../../models/HttpProject.js';
-import { AppProject } from '../../models/AppProject.js';
 import { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
 import { BaseRunner } from './BaseRunner.js';
 import { State } from './enums.js';
@@ -67,13 +66,13 @@ export interface ProjectParallelRunner {
  * change. This event can be user to refresh the UI to reflect the newest state.
  */
 export class ProjectParallelRunner extends BaseRunner {
-  project: HttpProject | AppProject;
+  project: HttpProject;
   options: IProjectParallelRunnerOptions;
   workers: WorkerInfoInternal[] = [];
   private mainResolver?: (report: IProjectExecutionLog) => void;
   private mainRejecter?: (err: Error) => void;
 
-  constructor(project: HttpProject | AppProject, opts: IProjectParallelRunnerOptions = {}) {
+  constructor(project: HttpProject, opts: IProjectParallelRunnerOptions = {}) {
     super();
     this.project = project;
     this.options = opts;

package/src/runtime/node/ProjectRequestRunner.ts

@@ -14,7 +14,6 @@ import { IProjectExecutionResult, IRequestRunnerOptions, IRequestRunnerRunOption
 import { State } from './enums.js';
 import { HttpRequestRunner } from '../http-runner/HttpRequestRunner.js';
 import { CookieJar } from '../../cookies/CookieJar.js';
-import { AppProject, AppProjectFolder, AppProjectFolderKind, AppProjectItem, AppProjectRequest, AppProjectRequestKind } from '../../models/AppProject.js';
 import { ProjectItem } from '../../models/ProjectItem.js';
 
 export interface ProjectRequestRunner {
@@ -53,7 +52,7 @@ export interface ProjectRequestRunner {
  */
 export class ProjectRequestRunner extends EventEmitter {
   logger?: Logger;
-  project: HttpProject | AppProject;
+  project: HttpProject;
   /**
    * An instance of a cookie jar (store) to put/read cookies.
    */
@@ -73,7 +72,7 @@ export class ProjectRequestRunner extends EventEmitter {
     return this._state;
   }
 
-  constructor(project: HttpProject | AppProject, opts: IRequestRunnerOptions = {}) {
+  constructor(project: HttpProject, opts: IRequestRunnerOptions = {}) {
     super();
     this.project = project;
     this.logger = opts.logger;
@@ -126,32 +125,32 @@ export class ProjectRequestRunner extends EventEmitter {
     }
   }
 
-  protected async * _runIterator(items: (ProjectItem | AppProjectItem)[], variables: Record<string, string>, options: IRequestRunnerRunOptions): AsyncGenerator<IRunResult> {
+  protected async * _runIterator(items: ProjectItem[], variables: Record<string, string>, options: IRequestRunnerRunOptions): AsyncGenerator<IRunResult> {
     for (const item of items) {
       const current = item.getItem();
       if (!current) {
         continue;
       }
-      if (current.kind === AppProjectRequestKind || current.kind === ProjectRequestKind) {
+      if (current.kind === ProjectRequestKind) {
         if (Array.isArray(options.ignore) && options.ignore.includes(current.key)) {
           continue;
         }
         if (Array.isArray(options.requests) && !options.requests.includes(current.key) && !options.requests.includes(current.info.name || '')) {
           continue;
         }
-        const info = await this._runItem(current as AppProjectRequest | ProjectRequest, variables);
+        const info = await this._runItem(current as ProjectRequest, variables);
         yield info;
-      } else if (current.kind === ProjectFolderKind || current.kind === AppProjectFolderKind) {
+      } else if (current.kind === ProjectFolderKind) {
         if (!options.recursive) {
           continue;
         }
-        const parent = current as ProjectFolder | AppProjectFolder;
+        const parent = current as ProjectFolder;
         // make a copy so the variables executed in the encapsulated environment won't leak out to the current environment.
         let encapsulated = false;
         // we restore the `baseUri` after exiting the folder.
         const currentBaseUri = variables.baseUri;
         const { items: parentItems } = parent;
-        const envItem = (parentItems as (ProjectItem | AppProjectItem)[]).find(i => i.kind === EnvironmentKind);
+        const envItem = (parentItems as ProjectItem[]).find(i => i.kind === EnvironmentKind);
         let parentVariables: Record<string, string> = {};
         let childVariables = variables;
         if (envItem) {
@@ -214,7 +213,7 @@ export class ProjectRequestRunner extends EventEmitter {
     }
   }
 
-  private async _runItem(request: ProjectRequest | AppProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
+  private async _runItem(request: ProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
     if (this._state === State.Aborted) {
       throw new Error(`The execution has been aborted.`);
     }
@@ -226,7 +225,7 @@ export class ProjectRequestRunner extends EventEmitter {
     return info;
   } 
 
-  protected async execute(request: ProjectRequest | AppProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
+  protected async execute(request: ProjectRequest, variables: Record<string, string>): Promise<IRunResult> {
     const config = request.getConfig();
     const factory = new HttpRequestRunner();
     factory.variables = variables;
@@ -285,14 +284,14 @@ export class ProjectRequestRunner extends EventEmitter {
     return info;
   }
 
-  protected async getVariables(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Record<string, string>> {
+  protected async getVariables(parent: HttpProject | ProjectFolder): Promise<Record<string, string>> {
     if (this.masterEnvironment) {
       return this.applyVariables([this.masterEnvironment]);
     }
     return this.createEnvironment(parent);
   }
 
-  protected async createEnvironment(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Record<string, string>> {
+  protected async createEnvironment(parent: HttpProject | ProjectFolder): Promise<Record<string, string>> {
     const envs = await this.readEnvironments(parent);
     return this.applyVariables(envs);
   }
@@ -300,7 +299,7 @@ export class ProjectRequestRunner extends EventEmitter {
   /**
    * Reads the list of the environments to apply to this runtime.
    */
-  protected async readEnvironments(parent: HttpProject | AppProject | ProjectFolder | AppProjectFolder): Promise<Environment[]> {
+  protected async readEnvironments(parent: HttpProject | ProjectFolder): Promise<Environment[]> {
     const folderKey = parent.kind === ProjectFolderKind ? (parent as ProjectFolder).key : undefined;
     return this.project.readEnvironments({ parent: folderKey });
   }

package/src/runtime/node/ProjectRunner.ts

@@ -11,9 +11,8 @@ import { pathExists, readJson } from '../../lib/fs/Fs.js';
 import { BaseRunner } from './BaseRunner.js';
 import { IProjectRunnerOptions, IRequestRunnerOptions } from './InteropInterfaces.js';
 import { State } from './enums.js';
-import { AppProject, AppProjectFolder } from '../../models/AppProject.js';
 
-type ProjectParent = HttpProject | ProjectFolder | AppProject | AppProjectFolder;
+type ProjectParent = HttpProject | ProjectFolder;
 
 export interface ProjectRunner {
   /**
@@ -90,7 +89,7 @@ export abstract class ProjectRunner extends BaseRunner {
   /**
    * The HTTP project to run requests from.
    */
-  project?: HttpProject | AppProject;
+  project?: HttpProject;
   /**
    * The execution options for the project.
    */
@@ -173,7 +172,7 @@ export abstract class ProjectRunner extends BaseRunner {
    * A required step before running the project.
    * It configures the execution context. It may throw an error when configuration is not valid.
    */
-  async configure(project: HttpProject | AppProject, opts: IProjectRunnerOptions = {}): Promise<void> {
+  async configure(project: HttpProject, opts: IProjectRunnerOptions = {}): Promise<void> {
     this.project = project;
     this.options = opts || {};
     if (typeof this.options.iterations === 'number' && this.options.iterations >= 0) {

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -3,7 +3,6 @@
 import process from 'process';
 import cluster from 'cluster';
 import { HttpProject, Kind as HttpProjectKind } from '../../models/HttpProject.js';
-import { AppProject, AppProjectKind } from '../../models/AppProject.js';
 import { IProjectExecutionLog } from '../reporters/Reporter.js';
 import { IWorkerMessage } from './ProjectParallelRunner.js';
 import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
@@ -33,11 +32,9 @@ class ProjectExeWorker extends ProjectRunner {
     options.cookies = new InMemoryCookieJar();
     try {
       const schema = options.project;
-      let project: HttpProject | AppProject;
+      let project: HttpProject;
       if (schema.kind === HttpProjectKind) {
         project = new HttpProject(schema);
-      } else if (schema.kind === AppProjectKind) {
-        project = new AppProject(schema);
       } else {
         throw new Error(`Unknown project kind: ${schema.kind}`);
       }

package/src/runtime/store/CertificatesSdk.ts

@@ -0,0 +1,231 @@
+import { SdkBase, E_RESPONSE_STATUS, E_RESPONSE_NO_VALUE, E_INVALID_JSON, E_RESPONSE_UNKNOWN, ISdkRequestOptions } from './SdkBase.js';
+import { RouteBuilder } from './RouteBuilder.js';
+import { ContextChangeRecord, ContextDeleteRecord, ContextListResult, ContextSpaceListOptions, IBulkOperationResult } from '../../events/BaseEvents.js';
+import { HttpCertificate } from '../../models/ClientCertificate.js';
+import { SdkError } from './Errors.js';
+
+export class CertificatesSdk extends SdkBase {
+  /**
+   * Inserts a certificate to the store
+   * 
+   * @param value The value to insert.
+   * @param space The parent space of the certificate.
+   */
+  async add(value: HttpCertificate, space: string, request: ISdkRequestOptions = {}): Promise<ContextChangeRecord<HttpCertificate>> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificates());
+    url.searchParams.set('space', space);
+    const body = JSON.stringify(value);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a certificate. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: ContextChangeRecord<HttpCertificate>;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!data.key) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Adds certificates in a bulk operation.
+   * @param value The lits of certificates to add.
+   * @param space The parent workspace
+   * @returns The list of inserted certificates. `undefined` when there was an error inserting a certificate.
+   */
+  async addBulk(values: HttpCertificate[], space: string, request: ISdkRequestOptions = {}): Promise<IBulkOperationResult<ContextChangeRecord<HttpCertificate>>> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificateBatchCreate());
+    url.searchParams.set('space', space);
+    const body = JSON.stringify(values);
+    const result = await this.sdk.http.post(url.toString(), { token, body });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to create a bulk certificates. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: IBulkOperationResult<ContextChangeRecord<HttpCertificate>>;
+    try {
+      data = JSON.parse(result.body).items;
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!data.items) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * @param key The key of the certificate to read.
+   */
+  async read(key: string, request: ISdkRequestOptions = {}): Promise<HttpCertificate> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificate(key));
+    const result = await this.sdk.http.get(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to read a certificate. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: HttpCertificate;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!data.kind) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Lists certificate entires.
+   * 
+   * @param space The parent space of the certificate.
+   * @param options The list query options.
+   */
+  async list(options?: ContextSpaceListOptions, request: ISdkRequestOptions = {}): Promise<ContextListResult<HttpCertificate>> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificates());
+    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 certificates. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+    let data: ContextListResult<HttpCertificate>;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Marks the certificate as deleted.
+   * 
+   * @param key The key of the certificate to delete.
+   */
+  async delete(key: string, request: ISdkRequestOptions = {}): Promise<void> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificate(key));
+    const result = await this.sdk.http.delete(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status, result.body);
+    const E_PREFIX = 'Unable to delete the certificate. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Removed certificates in a bulk operation.
+   * @param keys The list of certificate keys to delete.
+   */
+  async deleteBulk(keys: string[], request: ISdkRequestOptions = {}): Promise<IBulkOperationResult<ContextDeleteRecord>> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificateBatchDelete());
+    const result = await this.sdk.http.post(url.toString(), { token, body: JSON.stringify(keys) });
+    this.inspectCommonStatusCodes(result.status);
+    const E_PREFIX = 'Unable to delete history. ';
+    if (result.status !== 200) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+    if (!result.body) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`);
+    }
+
+    let data: IBulkOperationResult<ContextDeleteRecord>;
+    try {
+      data = JSON.parse(result.body);
+    } catch (e) {
+      throw new Error(`${E_PREFIX}${E_INVALID_JSON}.`);
+    }
+    if (!Array.isArray(data.items)) {
+      throw new Error(`${E_PREFIX}${E_RESPONSE_UNKNOWN}.`);
+    }
+    return data;
+  }
+
+  /**
+   * Removes all certificates from the store for the given workspace.
+   * @param space The parent workspace key
+   */
+  async empty(space: string, request: ISdkRequestOptions = {}): Promise<void> {
+    const token = request.token || this.sdk.token;
+    const url = this.sdk.getUrl(RouteBuilder.certificatesEmpty(space));
+    const result = await this.sdk.http.delete(url.toString(), { token });
+    this.inspectCommonStatusCodes(result.status, result.body);
+    const E_PREFIX = 'Unable to delete the certificate. ';
+    if (result.status !== 204) {
+      this.logInvalidResponse(result);
+      let e = this.createGenericSdkError(result.body)
+      if (!e) {
+        e = new SdkError(`${E_PREFIX}${E_RESPONSE_STATUS}${result.status}`, result.status);
+        e.response = result.body;
+      }
+      throw e;
+    }
+  }
+}