@blueprint-ts/core 1.0.0

package/src/service/requests/contracts/RequestLoaderFactoryContract.ts

@@ -0,0 +1,5 @@
+import { type RequestLoaderContract } from './RequestLoaderContract'
+
+export interface RequestLoaderFactoryContract<T> {
+  make(): RequestLoaderContract<T>
+}

package/src/service/requests/contracts/ResponseContract.ts

@@ -0,0 +1,7 @@
+import type { ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+
+export interface ResponseContract<ResponseBodyInterface> {
+  getAcceptHeader(): string
+
+  setResponse(response: ResponseHandlerContract): Promise<ResponseBodyInterface>
+}

package/src/service/requests/drivers/contracts/ResponseHandlerContract.ts

@@ -0,0 +1,10 @@
+import { type HeadersContract } from '../../contracts/HeadersContract'
+
+export interface ResponseHandlerContract {
+  getStatusCode(): number | undefined
+  getHeaders(): HeadersContract
+  getRawResponse(): Response
+  json<ResponseBodyInterface>(): Promise<ResponseBodyInterface>
+  text(): Promise<string>
+  blob(): Promise<Blob>
+}

package/src/service/requests/drivers/fetch/FetchDriver.ts

@@ -0,0 +1,115 @@
+import { ResponseException } from '../../exceptions/ResponseException'
+import { FetchResponse } from './FetchResponse'
+import { RequestMethodEnum } from '../../RequestMethod.enum'
+import { type HeadersContract, type HeaderValue } from '../../contracts/HeadersContract'
+import { type BodyContract } from '../../contracts/BodyContract'
+import { type RequestDriverContract } from '../../contracts/RequestDriverContract'
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract'
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract'
+
+enum FetchDriverCredentialConfigEnum {
+  OMIT = 'omit',
+  INCLUDE = 'include'
+}
+
+interface FetchDriverConfig {
+  method: RequestMethodEnum
+  headers: HeadersContract
+  credentials?: FetchDriverCredentialConfigEnum | undefined
+  signal?: AbortSignal | undefined
+  body?: string | FormData | Blob | ArrayBuffer | ArrayBufferView | URLSearchParams | undefined
+}
+
+export class FetchDriver implements RequestDriverContract {
+  public constructor(protected config?: DriverConfigContract) {}
+
+  public async send(
+    url: URL | string,
+    method: RequestMethodEnum,
+    headers: HeadersContract,
+    body?: BodyContract,
+    requestConfig?: DriverConfigContract
+  ): Promise<ResponseHandlerContract> {
+    const mergedConfig: DriverConfigContract = {
+      // Global config
+      ...this.config,
+
+      // Request specific overrides
+      ...(requestConfig ?? {})
+    }
+
+    const mergedHeaders: HeadersContract = {
+      // Set global headers
+      ...this.config?.headers,
+
+      // Set headers from the request
+      ...headers,
+
+      // Set Content-Type header
+      ...body?.getHeaders()
+    }
+
+    const resolvedHeaders = this.resolveHeaders(mergedHeaders)
+
+    const fetchConfig = this.buildRequestConfig(mergedConfig, method, resolvedHeaders, body)
+
+    const response = await fetch(url, fetchConfig as RequestInit)
+
+    const fetchResponse = new FetchResponse(response)
+
+    if (!response.ok) {
+      throw new ResponseException(fetchResponse)
+    }
+
+    return fetchResponse
+  }
+
+  protected buildRequestConfig(
+    config: DriverConfigContract,
+    method: RequestMethodEnum,
+    headers: HeadersContract,
+    body?: BodyContract
+  ): FetchDriverConfig {
+    return {
+      method: method,
+      headers: headers,
+      credentials: this.getCorsWithCredentials(config.corsWithCredentials),
+      signal: config.abortSignal ?? undefined,
+      body: [RequestMethodEnum.GET, RequestMethodEnum.HEAD].includes(method) ? undefined : body?.getContent()
+    }
+  }
+
+  protected getCorsWithCredentials(corsWithCredentials: boolean | undefined): FetchDriverCredentialConfigEnum {
+    // Request takes precedence
+    if (corsWithCredentials === true) {
+      return FetchDriverCredentialConfigEnum.INCLUDE
+    }
+
+    if (corsWithCredentials === false) {
+      return FetchDriverCredentialConfigEnum.OMIT
+    }
+
+    // Fallback to default config
+    if (this.config) {
+      return this.config.corsWithCredentials ? FetchDriverCredentialConfigEnum.INCLUDE : FetchDriverCredentialConfigEnum.OMIT
+    }
+
+    // Fallback to safe option if no default set
+    return FetchDriverCredentialConfigEnum.OMIT
+  }
+
+  protected resolveHeaders(headers: HeadersContract): HeadersContract {
+    const resolved: HeadersContract = {}
+    for (const key in headers) {
+      const value: HeaderValue | undefined = headers[key]
+
+      if (value === undefined) {
+        continue
+      }
+
+      resolved[key] = typeof value === 'function' ? value() : value
+    }
+
+    return resolved
+  }
+}

package/src/service/requests/drivers/fetch/FetchResponse.ts

@@ -0,0 +1,30 @@
+import { type HeadersContract } from '../../contracts/HeadersContract'
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract'
+
+export class FetchResponse implements ResponseHandlerContract {
+  public constructor(protected response: Response) {}
+
+  public getStatusCode(): number | undefined {
+    return this.response.status
+  }
+
+  public getHeaders(): HeadersContract {
+    return Object.fromEntries(this.response.headers)
+  }
+
+  public getRawResponse(): Response {
+    return this.response
+  }
+
+  public async json<ResponseBodyInterface>(): Promise<ResponseBodyInterface> {
+    return await this.response.json()
+  }
+
+  public async text(): Promise<string> {
+    return await this.response.text()
+  }
+
+  public async blob(): Promise<Blob> {
+    return await this.response.blob()
+  }
+}

package/src/service/requests/exceptions/NoResponseReceivedException.ts

@@ -0,0 +1,3 @@
+import { ResponseException } from './ResponseException'
+
+export class NoResponseReceivedException extends ResponseException {}

package/src/service/requests/exceptions/NotFoundException.ts

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

package/src/service/requests/exceptions/PageExpiredException.ts

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

package/src/service/requests/exceptions/ResponseBodyException.ts

@@ -0,0 +1,15 @@
+import { ResponseException } from './ResponseException'
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+
+export class ResponseBodyException<ResponseErrorBody> extends ResponseException {
+  public constructor(
+    response: ResponseHandlerContract,
+    protected body: ResponseErrorBody
+  ) {
+    super(response)
+  }
+
+  public getBody(): ResponseErrorBody {
+    return this.body
+  }
+}

package/src/service/requests/exceptions/ResponseException.ts

@@ -0,0 +1,11 @@
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+
+export class ResponseException extends Error {
+  constructor(protected response: ResponseHandlerContract) {
+    super()
+  }
+
+  public getResponse(): ResponseHandlerContract {
+    return this.response
+  }
+}

package/src/service/requests/exceptions/ServerErrorException.ts

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

package/src/service/requests/exceptions/UnauthorizedException.ts

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

package/src/service/requests/exceptions/ValidationException.ts

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

package/src/service/requests/exceptions/index.ts

@@ -0,0 +1,19 @@
+import { ValidationException } from './ValidationException'
+import { NotFoundException } from './NotFoundException'
+import { NoResponseReceivedException } from './NoResponseReceivedException'
+import { UnauthorizedException } from './UnauthorizedException'
+import { PageExpiredException } from './PageExpiredException'
+import { ServerErrorException } from './ServerErrorException'
+import { ResponseException } from './ResponseException'
+import { ResponseBodyException } from './ResponseBodyException'
+
+export {
+  ValidationException,
+  NotFoundException,
+  NoResponseReceivedException,
+  UnauthorizedException,
+  PageExpiredException,
+  ServerErrorException,
+  ResponseException,
+  ResponseBodyException
+}

package/src/service/requests/factories/FormDataFactory.ts

@@ -0,0 +1,9 @@
+import { FormDataBody } from '../bodies/FormDataBody'
+import { type BodyFactoryContract } from '../contracts/BodyFactoryContract'
+import { type BodyContract } from '../contracts/BodyContract'
+
+export class FormDataFactory<RequestBodyInterface> implements BodyFactoryContract<RequestBodyInterface> {
+  public make(body: RequestBodyInterface): BodyContract {
+    return new FormDataBody<RequestBodyInterface>(body)
+  }
+}

package/src/service/requests/factories/JsonBodyFactory.ts

@@ -0,0 +1,9 @@
+import { JsonBody } from '../bodies/JsonBody'
+import { type BodyFactoryContract } from '../contracts/BodyFactoryContract'
+import { type BodyContract } from '../contracts/BodyContract'
+
+export class JsonBodyFactory<RequestBodyInterface> implements BodyFactoryContract<RequestBodyInterface> {
+  public make(body: RequestBodyInterface): BodyContract {
+    return new JsonBody<RequestBodyInterface>(body)
+  }
+}

package/src/service/requests/index.ts

@@ -0,0 +1,50 @@
+import { FetchDriver } from './drivers/fetch/FetchDriver'
+import { BaseResponse } from './responses/BaseResponse'
+import { JsonResponse } from './responses/JsonResponse'
+import { PlainTextResponse } from './responses/PlainTextResponse'
+import { BlobResponse } from './responses/BlobResponse'
+import { BaseRequest } from './BaseRequest'
+import { ErrorHandler } from './ErrorHandler'
+import { RequestEvents } from './RequestEvents.enum'
+import { RequestMethodEnum } from './RequestMethod.enum'
+import { JsonBodyFactory } from './factories/JsonBodyFactory'
+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'
+import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract'
+import { type BaseRequestContract } from './contracts/BaseRequestContract'
+import { ResponseException } from './exceptions/ResponseException'
+import { type HeadersContract } from './contracts/HeadersContract'
+
+export {
+  FetchDriver,
+  BaseResponse,
+  JsonResponse,
+  BlobResponse,
+  PlainTextResponse,
+  BaseRequest,
+  ErrorHandler,
+  RequestEvents,
+  RequestMethodEnum,
+  ResponseException,
+  JsonBodyFactory,
+  FormDataFactory
+}
+
+export type {
+  PaginationParamsContract,
+  RequestDriverContract,
+  RequestLoaderContract,
+  BodyContract,
+  RequestLoaderFactoryContract,
+  DriverConfigContract,
+  BodyFactoryContract,
+  ResponseHandlerContract,
+  BaseRequestContract,
+  HeadersContract
+}

package/src/service/requests/responses/BaseResponse.ts

@@ -0,0 +1,41 @@
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract'
+import { type HeadersContract } from '../contracts/HeadersContract'
+import { type ResponseContract } from '../contracts/ResponseContract'
+
+export abstract class BaseResponse<ResponseInterface> implements ResponseContract<ResponseInterface> {
+  private body?: ResponseInterface
+
+  protected response?: ResponseHandlerContract
+
+  public abstract getAcceptHeader(): string
+
+  protected abstract resolveBody(): Promise<ResponseInterface>
+
+  public async setResponse(response: ResponseHandlerContract): Promise<ResponseInterface> {
+    this.response = response
+
+    this.body = await this.resolveBody()
+
+    return this.body
+  }
+
+  public getRawResponse(): Response | undefined {
+    return this.response?.getRawResponse()
+  }
+
+  public getStatusCode(): number | undefined {
+    return this.response?.getStatusCode()
+  }
+
+  public getHeaders(): HeadersContract | undefined {
+    return this.response?.getHeaders()
+  }
+
+  public getBody(): ResponseInterface {
+    if (this.body === undefined) {
+      throw new Error('Response body is not set')
+    }
+
+    return this.body
+  }
+}

package/src/service/requests/responses/BlobResponse.ts

@@ -0,0 +1,19 @@
+import { BaseResponse } from './BaseResponse'
+
+export class BlobResponse extends BaseResponse<Blob> {
+  public constructor(protected mimeType: string = 'application/octet-stream') {
+    super()
+  }
+
+  public getAcceptHeader(): string {
+    return this.mimeType
+  }
+
+  protected resolveBody(): Promise<Blob> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.blob()
+  }
+}

package/src/service/requests/responses/JsonResponse.ts

@@ -0,0 +1,15 @@
+import { BaseResponse } from './BaseResponse'
+
+export class JsonResponse<ResponseBodyInterface> extends BaseResponse<ResponseBodyInterface> {
+  public getAcceptHeader(): string {
+    return 'application/json'
+  }
+
+  protected resolveBody(): Promise<ResponseBodyInterface> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.json<ResponseBodyInterface>()
+  }
+}

package/src/service/requests/responses/PlainTextResponse.ts

@@ -0,0 +1,15 @@
+import { BaseResponse } from './BaseResponse'
+
+export class PlainTextResponse extends BaseResponse<string> {
+  public getAcceptHeader(): string {
+    return 'text/plain'
+  }
+
+  protected resolveBody(): Promise<string> {
+    if (!this.response) {
+      throw new Error('Response is not set')
+    }
+
+    return this.response.text()
+  }
+}

package/src/service/support/DeferredPromise.ts

@@ -0,0 +1,67 @@
+/**
+ * A new instance of deferred is constructed by calling `new DeferredPromse<T>()`.
+ * The purpose of the deferred object is to expose the associated Promise
+ * instance APIs that can be used for signaling the successful
+ * or unsuccessful completion, as well as the state of the task.
+ * @export
+ * @class DeferredPromise
+ * @implements {Promise<T>}
+ * @template T
+ * @example
+ * const deferred = new DeferredPromse<string>();
+ * console.log(deferred.state); // 'pending'
+ *
+ * deferred
+ * .then(str => console.log(str))
+ * .catch(err => console.error(err));
+ *
+ * deferred.resolve('Foo');
+ * console.log(deferred.state); // 'fulfilled'
+ * // deferred.reject('Bar');
+ *
+ * https://gist.github.com/GFoley83/5877f6c09fbcfd62569c51dc91444cf0
+ */
+export class DeferredPromise<T> implements Promise<T> {
+  readonly [Symbol.toStringTag]: 'Promise' = 'Promise'
+
+  private _promise: Promise<T>
+  private _resolve!: (value: T | PromiseLike<T>) => void
+  private _reject!: (reason?: unknown) => void
+  private _state: 'pending' | 'fulfilled' | 'rejected' = 'pending'
+
+  public get state(): 'pending' | 'fulfilled' | 'rejected' {
+    return this._state
+  }
+
+  public constructor() {
+    this._promise = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve
+      this._reject = reject
+    })
+  }
+
+  public then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2> {
+    return this._promise.then(onfulfilled, onrejected)
+  }
+
+  public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult> {
+    return this._promise.catch(onrejected)
+  }
+
+  public finally(onfinally?: (() => void) | null): Promise<T> {
+    return this._promise.finally(onfinally)
+  }
+
+  public resolve(value: T | PromiseLike<T>): void {
+    this._resolve(value)
+    this._state = 'fulfilled'
+  }
+
+  public reject(reason?: unknown): void {
+    this._reject(reason)
+    this._state = 'rejected'
+  }
+}

package/src/service/support/index.ts

@@ -0,0 +1,3 @@
+import { DeferredPromise } from './DeferredPromise'
+
+export { DeferredPromise }

package/src/vue/composables/useConfirmDialog.ts

@@ -0,0 +1,59 @@
+import { getCurrentInstance, h, onUnmounted, render } from 'vue'
+import { type Component } from 'vue'
+
+export type ConfirmDialogSeverity = 'info' | 'warning' | 'danger'
+
+export interface ConfirmDialogOptions {
+  getMessage(): string
+
+  getSeverity(): ConfirmDialogSeverity
+
+  getTitle(): string
+
+  getOkText(): string
+
+  getCancelText(): string
+}
+
+/**
+ * The provided component needs to expose an "open" method, which
+ * should return a promise resolving into true or false.
+ */
+export default function (confirmDialogComponent: Component, querySelector: string = 'body') {
+  const self = getCurrentInstance()
+
+  /**
+   * https://stackoverflow.com/a/78448128
+   */
+  function mountConfirmDialog(options: ConfirmDialogOptions) {
+    if (!self?.appContext) {
+      throw new Error('ConfirmationDialog: useConfirmDialog must be called inside a setup function')
+    }
+
+    const vNode = h(confirmDialogComponent, { options })
+    vNode.key = Symbol()
+    vNode.appContext = self.appContext
+    render(vNode, document.querySelector(querySelector) as Element)
+    return vNode.component
+  }
+
+  function unmountConfirmDialog() {
+    render(null, document.querySelector(querySelector) as Element)
+  }
+
+  onUnmounted(() => {
+    unmountConfirmDialog()
+  })
+
+  async function openConfirmDialog(options: ConfirmDialogOptions): Promise<boolean> {
+    const dialogComponent = mountConfirmDialog(options)
+
+    if (dialogComponent?.exposed == undefined || dialogComponent?.exposed['open'] === undefined) {
+      throw new Error('ConfirmationDialog: Provided component does not expose an "open" method')
+    }
+
+    return dialogComponent?.exposed['open']
+  }
+
+  return { openConfirmDialog }
+}