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

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/RequestErrorRouter.ts

@@ -0,0 +1,89 @@
+import { BadRequestException } from './exceptions/BadRequestException'
+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 { ForbiddenException } from './exceptions/ForbiddenException'
+import { LockedException } from './exceptions/LockedException'
+import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException'
+import { NotFoundException } from './exceptions/NotFoundException'
+import { NotImplementedException } from './exceptions/NotImplementedException'
+import { BadGatewayException } from './exceptions/BadGatewayException'
+import { PageExpiredException } from './exceptions/PageExpiredException'
+import { ResponseBodyException } from './exceptions/ResponseBodyException'
+import { ResponseException } from './exceptions/ResponseException'
+import { ServerErrorException } from './exceptions/ServerErrorException'
+import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException'
+import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException'
+import { TooManyRequestsException } from './exceptions/TooManyRequestsException'
+import { UnauthorizedException } from './exceptions/UnauthorizedException'
+import { ValidationException } from './exceptions/ValidationException'
+import { InvalidJsonException } from './exceptions/InvalidJsonException'
+
+type RequestExceptionConstructor =
+  | typeof BadRequestException
+  | typeof MethodNotAllowedException
+  | typeof RequestTimeoutException
+  | typeof ConflictException
+  | typeof GoneException
+  | typeof PreconditionFailedException
+  | typeof PayloadTooLargeException
+  | typeof UnsupportedMediaTypeException
+  | typeof UnauthorizedException
+  | typeof ForbiddenException
+  | typeof NotFoundException
+  | typeof PageExpiredException
+  | typeof ValidationException
+  | typeof LockedException
+  | typeof TooManyRequestsException
+  | typeof ServerErrorException
+  | typeof NotImplementedException
+  | typeof BadGatewayException
+  | typeof ServiceUnavailableException
+  | typeof GatewayTimeoutException
+  | typeof NoResponseReceivedException
+  | typeof InvalidJsonException
+  | typeof ResponseBodyException
+  | typeof ResponseException
+
+type ErrorHandlerCallback<T extends Error> = (error: T) => void | Promise<void>
+
+type UnknownErrorHandlerCallback = (error: unknown) => void | Promise<void>
+
+export class RequestErrorRouter {
+  protected handlers: Array<{ ctor: RequestExceptionConstructor; handler: ErrorHandlerCallback<Error> }> = []
+  protected defaultHandler: UnknownErrorHandlerCallback | undefined = undefined
+
+  public on<C extends RequestExceptionConstructor>(ctor: C, handler: ErrorHandlerCallback<InstanceType<C>>): this {
+    this.handlers.push({ ctor, handler: handler as ErrorHandlerCallback<Error> })
+
+    return this
+  }
+
+  public otherwise(handler: UnknownErrorHandlerCallback): this {
+    this.defaultHandler = handler
+
+    return this
+  }
+
+  public async handle(error: unknown): Promise<boolean> {
+    for (const entry of this.handlers) {
+      if (error instanceof entry.ctor) {
+        await entry.handler(error)
+
+        return true
+      }
+    }
+
+    if (this.defaultHandler !== undefined) {
+      await this.defaultHandler(error)
+
+      return true
+    }
+
+    return false
+  }
+}

package/src/{service/requests → requests}/bodies/FormDataBody.ts

@@ -1,8 +1,11 @@
 import { type BodyContract } from '../contracts/BodyContract'
 import { type HeadersContract } from '../contracts/HeadersContract'
-import { isObject } from '../../../helpers'
+import { isObject } from '../../support/helpers'
 
-export class FormDataBody<RequestBody> implements BodyContract {
+type FormDataPrimitive = string | number | boolean | null | Date | Blob
+type FormDataValue = FormDataPrimitive | FormDataValue[] | { [key: string]: FormDataValue }
+
+export class FormDataBody<RequestBody extends Record<string, FormDataValue | undefined>> implements BodyContract {
   protected data: FormData
 
   public constructor(data: RequestBody) {
@@ -17,12 +20,12 @@ export class FormDataBody<RequestBody> implements BodyContract {
     return {}
   }
 
-  protected toFormData(data: RequestBody, form: FormData = new FormData(), namespace: string | null = null): FormData {
+  protected toFormData(data: Record<string, FormDataValue | undefined>, form: FormData = new FormData(), namespace: string | null = null): FormData {
     for (const property in data) {
       if (Object.prototype.hasOwnProperty.call(data, property)) {
         const formKey = namespace ? namespace + '[' + property + ']' : property
 
-        const value = (data as any)[property]
+        const value = data[property]
 
         // Null is a valid "explicitly empty" value in many APIs.
         // In multipart FormData we encode it as an empty string so the key is still present.
@@ -45,7 +48,8 @@ export class FormDataBody<RequestBody> implements BodyContract {
         // Support arrays via bracket notation: key[0], key[1], ...
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i++) {
-            this.toFormData({ [String(i)]: value[i] } as any, form, formKey)
+            const indexed: Record<string, FormDataValue | undefined> = { [String(i)]: value[i] }
+            this.toFormData(indexed, form, formKey)
           }
           continue
         }
@@ -58,7 +62,7 @@ export class FormDataBody<RequestBody> implements BodyContract {
 
         // if the property is an object, use recursivity.
         if (isObject(value)) {
-          this.toFormData(value as any, form, formKey)
+          this.toFormData(value as Record<string, FormDataValue | undefined>, form, formKey)
           continue
         }
 

package/src/requests/exceptions/BadGatewayException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class BadGatewayException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/BadRequestException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class BadRequestException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/ConflictException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class ConflictException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/ForbiddenException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class ForbiddenException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/GatewayTimeoutException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class GatewayTimeoutException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/GoneException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class GoneException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/InvalidJsonException.ts

@@ -0,0 +1,15 @@
+import { ResponseException } from './ResponseException'
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+
+export class InvalidJsonException extends ResponseException {
+  public constructor(
+    response: ResponseHandlerContract,
+    protected cause: unknown
+  ) {
+    super(response)
+  }
+
+  public getCause(): unknown {
+    return this.cause
+  }
+}

package/src/requests/exceptions/LockedException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class LockedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/MethodNotAllowedException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class MethodNotAllowedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/NotImplementedException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class NotImplementedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/PayloadTooLargeException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class PayloadTooLargeException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/PreconditionFailedException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class PreconditionFailedException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/RequestTimeoutException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class RequestTimeoutException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/ServiceUnavailableException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class ServiceUnavailableException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/TooManyRequestsException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class TooManyRequestsException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/UnsupportedMediaTypeException.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException'
+
+export class UnsupportedMediaTypeException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {}

package/src/requests/exceptions/index.ts

@@ -0,0 +1,51 @@
+import { ValidationException } from './ValidationException'
+import { NotFoundException } from './NotFoundException'
+import { NoResponseReceivedException } from './NoResponseReceivedException'
+import { UnauthorizedException } from './UnauthorizedException'
+import { ForbiddenException } from './ForbiddenException'
+import { BadRequestException } from './BadRequestException'
+import { MethodNotAllowedException } from './MethodNotAllowedException'
+import { RequestTimeoutException } from './RequestTimeoutException'
+import { ConflictException } from './ConflictException'
+import { GoneException } from './GoneException'
+import { PreconditionFailedException } from './PreconditionFailedException'
+import { PayloadTooLargeException } from './PayloadTooLargeException'
+import { UnsupportedMediaTypeException } from './UnsupportedMediaTypeException'
+import { PageExpiredException } from './PageExpiredException'
+import { ServerErrorException } from './ServerErrorException'
+import { NotImplementedException } from './NotImplementedException'
+import { BadGatewayException } from './BadGatewayException'
+import { ServiceUnavailableException } from './ServiceUnavailableException'
+import { GatewayTimeoutException } from './GatewayTimeoutException'
+import { TooManyRequestsException } from './TooManyRequestsException'
+import { LockedException } from './LockedException'
+import { InvalidJsonException } from './InvalidJsonException'
+import { ResponseException } from './ResponseException'
+import { ResponseBodyException } from './ResponseBodyException'
+
+export {
+  ValidationException,
+  NotFoundException,
+  NoResponseReceivedException,
+  UnauthorizedException,
+  PageExpiredException,
+  ServerErrorException,
+  NotImplementedException,
+  BadGatewayException,
+  ServiceUnavailableException,
+  GatewayTimeoutException,
+  TooManyRequestsException,
+  LockedException,
+  InvalidJsonException,
+  ResponseException,
+  ResponseBodyException,
+  ForbiddenException,
+  BadRequestException,
+  MethodNotAllowedException,
+  RequestTimeoutException,
+  ConflictException,
+  GoneException,
+  PreconditionFailedException,
+  PayloadTooLargeException,
+  UnsupportedMediaTypeException
+}

package/src/requests/factories/FormDataFactory.ts

@@ -0,0 +1,17 @@
+import { FormDataBody } from '../bodies/FormDataBody'
+import { type BodyFactoryContract } from '../contracts/BodyFactoryContract'
+import { type BodyContract } from '../contracts/BodyContract'
+
+type FormDataPrimitive = string | number | boolean | null | Date | Blob
+
+export type FormDataValue = FormDataPrimitive | FormDataValue[] | { [key: string]: FormDataValue }
+
+export class FormDataFactory<
+  RequestBodyInterface extends {
+    [K in keyof RequestBodyInterface]: FormDataValue | undefined
+  }
+> implements BodyFactoryContract<RequestBodyInterface> {
+  public make(body: RequestBodyInterface): BodyContract {
+    return new FormDataBody<RequestBodyInterface>(body)
+  }
+}

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

@@ -5,6 +5,7 @@ import { PlainTextResponse } from './responses/PlainTextResponse'
 import { BlobResponse } from './responses/BlobResponse'
 import { BaseRequest } from './BaseRequest'
 import { ErrorHandler } from './ErrorHandler'
+import { RequestErrorRouter } from './RequestErrorRouter'
 import { RequestEvents } from './RequestEvents.enum'
 import { RequestMethodEnum } from './RequestMethod.enum'
 import { JsonBodyFactory } from './factories/JsonBodyFactory'
@@ -12,7 +13,6 @@ import { FormDataFactory } from './factories/FormDataFactory'
 import { type BodyContract } from './contracts/BodyContract'
 import { type RequestLoaderContract } from './contracts/RequestLoaderContract'
 import { type RequestDriverContract } from './contracts/RequestDriverContract'
-import { type PaginationParamsContract } from '../laravel/pagination/contracts/PaginationParamsContract'
 import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract'
 import { type DriverConfigContract } from './contracts/DriverConfigContract'
 import { type BodyFactoryContract } from './contracts/BodyFactoryContract'
@@ -29,6 +29,7 @@ export {
   PlainTextResponse,
   BaseRequest,
   ErrorHandler,
+  RequestErrorRouter,
   RequestEvents,
   RequestMethodEnum,
   ResponseException,
@@ -37,7 +38,6 @@ export {
 }
 
 export type {
-  PaginationParamsContract,
   RequestDriverContract,
   RequestLoaderContract,
   BodyContract,

package/src/{service/support → support}/DeferredPromise.ts

@@ -22,7 +22,7 @@
  * https://gist.github.com/GFoley83/5877f6c09fbcfd62569c51dc91444cf0
  */
 export class DeferredPromise<T> implements Promise<T> {
-  readonly [Symbol.toStringTag]: 'Promise' = 'Promise'
+  readonly [Symbol.toStringTag] = 'Promise' as const
 
   private _promise: Promise<T>
   private _resolve!: (value: T | PromiseLike<T>) => void

package/src/support/index.ts

@@ -0,0 +1,4 @@
+import { DeferredPromise } from './DeferredPromise'
+import { getCookie, getDisplayablePages, isAtBottom, isObject, mergeDeep } from './helpers'
+
+export { DeferredPromise, getCookie, getDisplayablePages, isAtBottom, isObject, mergeDeep }

package/src/vue/composables/useConfirmDialog.ts

@@ -1,7 +1,11 @@
 import { getCurrentInstance, h, onUnmounted, render } from 'vue'
 import { type Component } from 'vue'
 
-export type ConfirmDialogSeverity = 'info' | 'warning' | 'danger'
+export enum ConfirmDialogSeverity {
+  INFO = 'info',
+  WARNING = 'warning',
+  DANGER = 'danger'
+}
 
 export interface ConfirmDialogOptions {
   getMessage(): string

package/src/vue/composables/useModelWrapper.ts

@@ -6,6 +6,9 @@ export interface ModelValueOptions<T> extends ParentModelValueOptions {
   callback?: (value: T) => void
 }
 
+/**
+ * @deprecated Use Vue 3.4+ `defineModel()` instead.
+ */
 export default function <T, EmitType>(props: ModelValueProps, emit: EmitType, options: ModelValueOptions<T> = {}) {
   const { name = 'modelValue', callback = () => {} } = options