@blueprint-ts/core 3.0.0 → 4.0.0-beta.10

package/src/{service/bulkRequests → bulkRequests}/BulkRequestWrapper.ts

@@ -1,8 +1,8 @@
 import { type BaseRequestContract } from '../requests'
 
 export class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
-  protected response: any = null
-  protected error: any = null
+  protected response: ResponseClass | null = null
+  protected error: unknown | null = null
   protected sent: boolean = false
 
   public constructor(protected request: BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) {}
@@ -27,11 +27,11 @@ export class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface,
     return this.request.isLoading()
   }
 
-  public getResponse() {
+  public getResponse(): ResponseClass | null {
     return this.response
   }
 
-  public getError() {
+  public getError(): unknown | null {
     return this.error
   }
 
@@ -40,7 +40,7 @@ export class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface,
   }
 
   public hasError(): boolean {
-    return Boolean(this.getError())
+    return this.error !== null
   }
 
   public wasSent(): boolean {

package/src/laravel/pagination/dataDrivers/RequestDriver.ts

@@ -0,0 +1,30 @@
+import { PaginationDataDto } from '../../../pagination/dtos/PaginationDataDto'
+import { PaginationResponse } from '../../requests/responses/PaginationResponse'
+import { type PaginateableRequestContract } from '../../../pagination/contracts/PaginateableRequestContract'
+import { type PaginationDataDriverContract } from '../../../pagination/contracts/PaginationDataDriverContract'
+
+export class RequestDriver<
+  Resource,
+  TReq extends PaginateableRequestContract<unknown, PaginationResponse<Resource>, unknown, object> = PaginateableRequestContract<
+    unknown,
+    PaginationResponse<Resource>,
+    unknown,
+    object
+  >
+> implements PaginationDataDriverContract<Resource> {
+  public constructor(protected request: TReq) {}
+
+  public get(pageNumber: number, pageSize: number): Promise<PaginationDataDto<Resource>> {
+    return this.request
+      .setPaginationParams(pageNumber, pageSize)
+      .send()
+      .then((response) => {
+        const paginationResponse = response as PaginationResponse<Resource>
+        return new PaginationDataDto<Resource>(paginationResponse.getData(), paginationResponse.getTotal())
+      })
+  }
+
+  public getRequest(): TReq {
+    return this.request
+  }
+}

package/src/laravel/pagination/index.ts

@@ -0,0 +1,6 @@
+import { type PaginationResponseBodyContract } from './contracts/PaginationResponseBodyContract'
+import { RequestDriver } from './dataDrivers/RequestDriver'
+
+export type { PaginationResponseBodyContract }
+
+export { RequestDriver }

package/src/pagination/BasePaginator.ts

@@ -0,0 +1,94 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto'
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract'
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
+
+export abstract class BasePaginator<ResourceInterface, ViewDriver extends BaseViewDriverContract<ResourceInterface[]>> {
+  protected initialized: boolean = false
+
+  protected abstract viewDriver: ViewDriver
+
+  public constructor(protected dataDriver: unknown) {}
+
+  public isInitialized(): boolean {
+    return this.initialized
+  }
+
+  public flush(): void {
+    this.viewDriver.setData([])
+  }
+
+  public getPageData(): ResourceInterface[] {
+    return this.viewDriver.getData()
+  }
+
+  public updateRows(
+    predicate: (row: ResourceInterface, index: number, data: ResourceInterface[]) => boolean,
+    updater: (row: ResourceInterface, index: number, data: ResourceInterface[]) => ResourceInterface | void
+  ): number {
+    const data = this.viewDriver.getData()
+    let updated = 0
+
+    for (let i = 0; i < data.length; i++) {
+      const row = data[i]
+
+      if (row === undefined) {
+        continue
+      }
+
+      if (!predicate(row, i, data)) {
+        continue
+      }
+
+      const result = updater(row, i, data)
+
+      if (result !== undefined) {
+        data[i] = result as ResourceInterface
+      }
+
+      updated++
+    }
+
+    if (updated > 0) {
+      this.viewDriver.setData(data)
+    }
+
+    return updated
+  }
+
+  public removeRows(
+    predicate: (row: ResourceInterface, index: number, data: ResourceInterface[]) => boolean,
+    options?: { adjustTotal?: boolean }
+  ): number {
+    const data = this.viewDriver.getData()
+    const next = data.filter((row, index) => !predicate(row, index, data))
+    const removed = data.length - next.length
+
+    if (removed > 0) {
+      this.viewDriver.setData(next)
+
+      if (options?.adjustTotal ?? true) {
+        this.viewDriver.setTotal(Math.max(0, this.viewDriver.getTotal() - removed))
+      }
+    }
+
+    return removed
+  }
+
+  public getTotal(): number {
+    return this.viewDriver.getTotal()
+  }
+
+  protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void {
+    if (options?.flush) {
+      this.flush()
+    }
+
+    this.viewDriver.setData(dto.getData())
+    this.viewDriver.setTotal(dto.getTotal())
+    this.initialized = true
+  }
+
+  protected handleStaleResponse(): PaginationDataDto<ResourceInterface[]> {
+    return new PaginationDataDto<ResourceInterface[]>(this.viewDriver.getData(), this.viewDriver.getTotal())
+  }
+}

package/src/{service/pagination → pagination}/InfiniteScroller.ts

@@ -17,5 +17,6 @@ export class InfiniteScroller<ResourceInterface> extends PageAwarePaginator<Reso
     }
 
     this.viewDriver.setTotal(dto.getTotal())
+    this.initialized = true
   }
 }

package/src/{service/pagination → pagination}/PageAwarePaginator.ts

@@ -4,6 +4,7 @@ import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryCon
 import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
 import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
 import { BasePaginator } from './BasePaginator'
+import { StaleResponseException } from '../requests/exceptions/StaleResponseException'
 
 export interface PageAwarePaginatorOptions {
   viewDriverFactory?: ViewDriverFactoryContract
@@ -40,28 +41,18 @@ export class PageAwarePaginator<ResourceInterface> extends BasePaginator<Resourc
     return this.dataDriver
   }
 
-  public init(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.initialized = true
-
-    if (pageNumber && pageSize) {
-      return this.loadData(pageNumber, pageSize)
-    }
-
-    return this.loadData(this.getCurrentPage(), this.getPageSize())
-  }
-
-  public refresh(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+  public load(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
     if (pageNumber !== undefined) {
-      return this.setPage(pageNumber, options)
+      this.setPageNumber(pageNumber)
     }
 
     return this.loadData(this.getCurrentPage(), this.getPageSize(), options)
   }
 
-  public setPage(pageNumber: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
+  public setPageNumber(pageNumber: number): this {
     this.viewDriver.setPage(pageNumber)
 
-    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize(), options)
+    return this
   }
 
   public getLastPage(): number {
@@ -69,19 +60,27 @@ export class PageAwarePaginator<ResourceInterface> extends BasePaginator<Resourc
   }
 
   public toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.getCurrentPage() + 1)
+    this.setPageNumber(this.getCurrentPage() + 1)
+
+    return this.load()
   }
 
   public toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(1)
+    this.setPageNumber(1)
+
+    return this.load()
   }
 
   public toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.viewDriver.getLastPage())
+    this.setPageNumber(this.viewDriver.getLastPage())
+
+    return this.load()
   }
 
   public toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.setPage(this.getCurrentPage() - 1)
+    this.setPageNumber(this.getCurrentPage() - 1)
+
+    return this.load()
   }
 
   public getCurrentPage(): number {
@@ -100,14 +99,14 @@ export class PageAwarePaginator<ResourceInterface> extends BasePaginator<Resourc
     return this.viewDriver.getPageSize()
   }
 
-  public setPageSize(pageSize: number): Promise<PaginationDataDto<ResourceInterface[]>> {
+  public setPageSize(pageSize: number): this {
     this.viewDriver.setPageSize(pageSize)
 
     if (this.getCurrentPage() * pageSize > this.getTotal()) {
-      return this.setPage(1)
+      this.setPageNumber(1)
     }
 
-    return this.loadData(this.viewDriver.getCurrentPage(), this.viewDriver.getPageSize())
+    return this
   }
 
   public getPages(): number[] {
@@ -115,10 +114,19 @@ export class PageAwarePaginator<ResourceInterface> extends BasePaginator<Resourc
   }
 
   protected loadData(pageNumber: number, pageSize: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
-    return this.dataDriver.get(pageNumber, pageSize).then((value: PaginationDataDto<ResourceInterface[]>) => {
-      this.passDataToViewDriver(value, options)
-
-      return value
-    })
+    return this.dataDriver
+      .get(pageNumber, pageSize)
+      .then((value: PaginationDataDto<ResourceInterface[]>) => {
+        this.passDataToViewDriver(value, options)
+
+        return value
+      })
+      .catch((error) => {
+        if (error instanceof StaleResponseException) {
+          return this.handleStaleResponse()
+        }
+
+        throw error
+      })
   }
 }

package/src/{service/pagination → pagination}/StatePaginator.ts

@@ -40,14 +40,7 @@ export class StatePaginator<ResourceInterface> extends BasePaginator<ResourceInt
     return this.dataDriver
   }
 
-  public init(): Promise<StatePaginationDataDto<ResourceInterface[]>> {
-    this.initialized = true
-    this.currentState = null
-
-    return this.loadData()
-  }
-
-  public refresh(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>> {
+  public load(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>> {
     this.currentState = null
 
     return this.loadData({ ...options, flush: true })
@@ -88,5 +81,6 @@ export class StatePaginator<ResourceInterface> extends BasePaginator<ResourceInt
     }
 
     this.viewDriver.setTotal(dto.getTotal())
+    this.initialized = true
   }
 }

package/src/{service/pagination → pagination}/index.ts

@@ -2,7 +2,6 @@ import { PaginationDataDto } from './dtos/PaginationDataDto'
 import { StatePaginationDataDto } from './dtos/StatePaginationDataDto'
 import { VuePaginationDriver } from './frontendDrivers/VuePaginationDriver'
 import { VueBaseViewDriver } from './frontendDrivers/VueBaseViewDriver'
-import { Paginator } from './Paginator'
 import { BasePaginator } from './BasePaginator'
 import { PageAwarePaginator } from './PageAwarePaginator'
 import { StatePaginator } from './StatePaginator'
@@ -13,7 +12,7 @@ import { type PaginateableRequestContract } from './contracts/PaginateableReques
 import { type PaginationResponseContract } from './contracts/PaginationResponseContract'
 import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract'
 import { type StatePaginationDataDriverContract } from './contracts/StatePaginationDataDriverContract'
-import { getDisplayablePages } from '../../helpers'
+import { getDisplayablePages } from '../support/helpers'
 import { ArrayDriver } from './dataDrivers/ArrayDriver'
 import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract'
 import { type ViewDriverContract } from './contracts/ViewDriverContract'
@@ -25,7 +24,6 @@ export {
   StatePaginationDataDto,
   VuePaginationDriver,
   VueBaseViewDriver,
-  Paginator,
   BasePaginator,
   PageAwarePaginator,
   StatePaginator,

package/src/{service/requests → requests}/BaseRequest.ts

@@ -4,6 +4,7 @@ import { RequestEvents } from './RequestEvents.enum'
 import { RequestMethodEnum } from './RequestMethod.enum'
 import { BaseResponse } from './responses/BaseResponse'
 import { ResponseException } from './exceptions/ResponseException'
+import { StaleResponseException } from './exceptions/StaleResponseException'
 import { type DriverConfigContract } from './contracts/DriverConfigContract'
 import { type BodyFactoryContract } from './contracts/BodyFactoryContract'
 import { type RequestLoaderContract } from './contracts/RequestLoaderContract'
@@ -13,7 +14,9 @@ import { type BaseRequestContract, type EventHandlerCallback } from './contracts
 import { type HeadersContract } from './contracts/HeadersContract'
 import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
 import { type ResponseContract } from './contracts/ResponseContract'
-import { mergeDeep } from '../../helpers'
+import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions'
+import { RequestConcurrencyMode } from './RequestConcurrencyMode.enum'
+import { mergeDeep } from '../support/helpers'
 import { v4 as uuidv4 } from 'uuid'
 
 export abstract class BaseRequest<
@@ -29,6 +32,7 @@ export abstract class BaseRequest<
   protected requestBody: RequestBodyInterface | undefined = undefined
   protected requestLoader: RequestLoaderContract<RequestLoaderLoadingType> | undefined = undefined
   protected abortSignal: AbortSignal | undefined = undefined
+  protected concurrencyOptions: RequestConcurrencyOptions | undefined = undefined
   /* @ts-expect-error Ignore generics */
   protected events: { [key in RequestEvents]?: EventHandlerCallback[] } = {}
 
@@ -36,6 +40,9 @@ export abstract class BaseRequest<
 
   protected static requestDriver: RequestDriverContract
   protected static requestLoaderFactory: RequestLoaderFactoryContract<unknown>
+  protected static concurrencySequenceByKey: Map<string, number> = new Map()
+  protected static concurrencyAbortControllerByKey: Map<string, AbortController> = new Map()
+  protected static concurrencyInFlightByKey: Map<string, number> = new Map()
 
   public constructor() {
     if (BaseRequest.requestLoaderFactory !== undefined) {
@@ -61,6 +68,12 @@ export abstract class BaseRequest<
     return this
   }
 
+  public setConcurrency(options?: RequestConcurrencyOptions): this {
+    this.concurrencyOptions = options
+
+    return this
+  }
+
   public getRequestId(): string {
     return this.requestId
   }
@@ -124,6 +137,25 @@ export abstract class BaseRequest<
   }
 
   public async send(): Promise<ResponseClass> {
+    const concurrencyMode: RequestConcurrencyMode = this.concurrencyOptions?.mode ?? RequestConcurrencyMode.ALLOW
+    const concurrencyKey = this.concurrencyOptions?.key ?? this.requestId
+    const useReplace = concurrencyMode === RequestConcurrencyMode.REPLACE || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST
+    const useLatest = concurrencyMode === RequestConcurrencyMode.LATEST || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST
+    const sequence = this.bumpConcurrencySequence(concurrencyKey)
+    this.incrementConcurrencyInFlight(concurrencyKey)
+
+    if (useReplace) {
+      const previousController = BaseRequest.concurrencyAbortControllerByKey.get(concurrencyKey)
+
+      if (previousController) {
+        previousController.abort()
+      }
+
+      const controller = new AbortController()
+      BaseRequest.concurrencyAbortControllerByKey.set(concurrencyKey, controller)
+      this.setAbortSignal(controller.signal)
+    }
+
     this.dispatch<boolean>(RequestEvents.LOADING, true)
 
     this.requestLoader?.setLoading(true)
@@ -144,24 +176,42 @@ export abstract class BaseRequest<
         this.getConfig()
       )
       .then(async (responseHandler: ResponseHandlerContract) => {
+        if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+          throw new StaleResponseException()
+        }
+
         await responseSkeleton.setResponse(responseHandler)
 
         return responseSkeleton
       })
       .catch(async (error) => {
+        if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+          throw new StaleResponseException('Stale response ignored', error)
+        }
+
+        if (error instanceof StaleResponseException) {
+          throw error
+        }
+
         if (error instanceof ResponseException) {
           const handler = new ErrorHandler<ResponseErrorBody>(error.getResponse())
 
           await handler.handle()
         }
 
-        console.error('HankIT-UI: Unknown error received.', error)
+        console.error('@blueprint-ts/core: Unknown error received.', error)
 
         throw error
       })
       .finally(() => {
-        this.dispatch<boolean>(RequestEvents.LOADING, false)
-        this.requestLoader?.setLoading(false)
+        const isStale = useLatest && !this.isLatestSequence(concurrencyKey, sequence)
+
+        if (!isStale) {
+          this.dispatch<boolean>(RequestEvents.LOADING, false)
+          this.requestLoader?.setLoading(false)
+        }
+
+        this.decrementConcurrencyInFlight(concurrencyKey)
       })
   }
 
@@ -185,6 +235,41 @@ export abstract class BaseRequest<
     return this
   }
 
+  protected bumpConcurrencySequence(key: string): number {
+    const next = (BaseRequest.concurrencySequenceByKey.get(key) ?? 0) + 1
+    BaseRequest.concurrencySequenceByKey.set(key, next)
+
+    return next
+  }
+
+  protected isLatestSequence(key: string, sequence: number): boolean {
+    return (BaseRequest.concurrencySequenceByKey.get(key) ?? 0) === sequence
+  }
+
+  protected incrementConcurrencyInFlight(key: string): void {
+    const next = (BaseRequest.concurrencyInFlightByKey.get(key) ?? 0) + 1
+    BaseRequest.concurrencyInFlightByKey.set(key, next)
+  }
+
+  protected decrementConcurrencyInFlight(key: string): void {
+    const current = BaseRequest.concurrencyInFlightByKey.get(key)
+
+    if (current === undefined) {
+      return
+    }
+
+    const next = current - 1
+
+    if (next <= 0) {
+      BaseRequest.concurrencyInFlightByKey.delete(key)
+      BaseRequest.concurrencySequenceByKey.delete(key)
+      BaseRequest.concurrencyAbortControllerByKey.delete(key)
+      return
+    }
+
+    BaseRequest.concurrencyInFlightByKey.set(key, next)
+  }
+
   protected baseUrl(): undefined {
     return undefined
   }

package/src/requests/ErrorHandler.ts

@@ -0,0 +1,144 @@
+import { PageExpiredException } from './exceptions/PageExpiredException'
+import { NotFoundException } from './exceptions/NotFoundException'
+import { UnauthorizedException } from './exceptions/UnauthorizedException'
+import { ValidationException } from './exceptions/ValidationException'
+import { ResponseException } from './exceptions/ResponseException'
+import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException'
+import { ServerErrorException } from './exceptions/ServerErrorException'
+import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
+import { ForbiddenException } from './exceptions/ForbiddenException'
+import { TooManyRequestsException } from './exceptions/TooManyRequestsException'
+import { LockedException } from './exceptions/LockedException'
+import { NotImplementedException } from './exceptions/NotImplementedException'
+import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException'
+import { MethodNotAllowedException } from './exceptions/MethodNotAllowedException'
+import { RequestTimeoutException } from './exceptions/RequestTimeoutException'
+import { ConflictException } from './exceptions/ConflictException'
+import { GoneException } from './exceptions/GoneException'
+import { PreconditionFailedException } from './exceptions/PreconditionFailedException'
+import { PayloadTooLargeException } from './exceptions/PayloadTooLargeException'
+import { UnsupportedMediaTypeException } from './exceptions/UnsupportedMediaTypeException'
+import { BadGatewayException } from './exceptions/BadGatewayException'
+import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException'
+import { BadRequestException } from './exceptions/BadRequestException'
+import { InvalidJsonException } from './exceptions/InvalidJsonException'
+
+export type ErrorHandlerCallback = ((response: ResponseHandlerContract) => boolean | void) | undefined
+
+export class ErrorHandler<ResponseErrorBody> {
+  protected body: ResponseErrorBody | undefined = undefined
+  protected static handler: ErrorHandlerCallback = undefined
+
+  public constructor(protected response: ResponseHandlerContract) {}
+
+  public async handle() {
+    // Check if there is a global error handler set
+    if (ErrorHandler.handler !== undefined) {
+      // If handler returns false, we don't process the error further
+      if (ErrorHandler.handler(this.response) === false) {
+        console.debug('Skipping further error handling due to global handler returning false.')
+        return
+      }
+    }
+
+    try {
+      this.body = await this.response.json<ResponseErrorBody>()
+    } catch (error) {
+      throw new InvalidJsonException(this.response, error)
+    }
+
+    if (this.body === undefined) {
+      throw new NoResponseReceivedException(this.response)
+    }
+
+    this.handleResponseError(this.response, this.body)
+  }
+
+  public static registerHandler(callback: ErrorHandlerCallback) {
+    ErrorHandler.handler = callback
+  }
+
+  protected handleResponseError(response: ResponseHandlerContract, body: ResponseErrorBody) {
+    if (response.getStatusCode() === 400) {
+      throw new BadRequestException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 401) {
+      throw new UnauthorizedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 403) {
+      throw new ForbiddenException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 404) {
+      throw new NotFoundException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 405) {
+      throw new MethodNotAllowedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 408) {
+      throw new RequestTimeoutException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 409) {
+      throw new ConflictException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 410) {
+      throw new GoneException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 412) {
+      throw new PreconditionFailedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 413) {
+      throw new PayloadTooLargeException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 415) {
+      throw new UnsupportedMediaTypeException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 419) {
+      throw new PageExpiredException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 422) {
+      throw new ValidationException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 423) {
+      throw new LockedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 429) {
+      throw new TooManyRequestsException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 500) {
+      throw new ServerErrorException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 501) {
+      throw new NotImplementedException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 502) {
+      throw new BadGatewayException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 503) {
+      throw new ServiceUnavailableException<ResponseErrorBody>(response, body)
+    }
+
+    if (response.getStatusCode() === 504) {
+      throw new GatewayTimeoutException<ResponseErrorBody>(response, body)
+    }
+
+    throw new ResponseException(response)
+  }
+}

package/src/requests/RequestConcurrencyMode.enum.ts

@@ -0,0 +1,6 @@
+export enum RequestConcurrencyMode {
+  ALLOW = 'allow',
+  REPLACE = 'replace',
+  LATEST = 'latest',
+  REPLACE_LATEST = 'replace-latest'
+}