@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

package/src/bulkRequests/BulkRequestSender.ts

@@ -1,196 +0,0 @@
-import { BulkRequestWrapper } from './BulkRequestWrapper'
-import { BulkRequestEventEnum } from './BulkRequestEvent.enum'
-
-export enum BulkRequestExecutionMode {
-  PARALLEL = 'parallel',
-  SEQUENTIAL = 'sequential'
-}
-
-export class BulkRequestSender<
-  RequestLoaderLoadingType = unknown,
-  RequestBodyInterface = unknown,
-  ResponseClass = unknown,
-  RequestParamsInterface extends object = object
-> {
-  protected events: Map<
-    BulkRequestEventEnum,
-    ((req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) => void)[]
-  > = new Map()
-  protected abortController: AbortController | undefined = undefined
-
-  public constructor(
-    protected requests: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>[] = [],
-    protected executionMode: BulkRequestExecutionMode = BulkRequestExecutionMode.PARALLEL,
-    protected retryCount: number = 0
-  ) {}
-
-  public setRequests(requests: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>[] = []) {
-    this.requests = requests
-
-    return this
-  }
-
-  public setExecutionMode(mode: BulkRequestExecutionMode): this {
-    this.executionMode = mode
-
-    return this
-  }
-
-  public setRetryCount(count: number): this {
-    this.retryCount = count
-
-    return this
-  }
-
-  public get isLoading(): boolean {
-    return this.requests.some((req) => Boolean(req.isLoading() as unknown))
-  }
-
-  public on(
-    event: BulkRequestEventEnum,
-    callback: (req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) => void
-  ): this {
-    if (!this.events.has(event)) {
-      this.events.set(event, [])
-    }
-
-    this.events.get(event)!.push(callback)
-
-    return this
-  }
-
-  public off(event: BulkRequestEventEnum): this {
-    this.events.delete(event)
-
-    return this
-  }
-
-  protected emit(
-    event: BulkRequestEventEnum,
-    req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>
-  ): void {
-    const callbacks = this.events.get(event) || []
-
-    callbacks.forEach((callback) => callback(req))
-  }
-
-  public get signal(): AbortSignal | undefined {
-    return this.abortController?.signal
-  }
-
-  public abort(): void {
-    this.abortController?.abort()
-  }
-
-  public async send() {
-    this.abortController = new AbortController()
-
-    try {
-      if (this.executionMode === BulkRequestExecutionMode.PARALLEL) {
-        await this.sendParallel()
-      } else {
-        await this.sendSequential()
-      }
-    } catch (error) {
-      // If an abort occurs, the underlying fetch (or request mechanism) should throw an AbortError.
-      console.error('Bulk operation aborted or encountered an error:', error)
-    }
-
-    return {
-      getSuccessCount: () => this.requests.filter((r) => !r.hasError()).length,
-      getErrorCount: () => this.requests.filter((r) => r.hasError()).length,
-      getSuccessfulResponses: () =>
-        this.requests
-          .filter((r) => !r.hasError())
-          .map((r) => r.getResponse())
-          .filter((response): response is ResponseClass => response !== null),
-      getFailedResponses: () => this.requests.filter((r) => r.hasError()).map((r) => r.getError())
-    }
-  }
-
-  protected async sendParallel() {
-    // First attempt for all requests
-    await Promise.all(
-      this.requests.map((req) =>
-        req.send(this.abortController?.signal).then(() => {
-          if (!req.hasError()) {
-            this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
-          }
-        })
-      )
-    )
-
-    // Retry logic for failed requests
-    let retriesLeft = this.retryCount
-    while (retriesLeft > 0) {
-      const failedRequests = this.requests.filter((req) => req.hasError())
-
-      if (failedRequests.length === 0) {
-        break // No failed requests to retry
-      }
-
-      console.log(`Retrying ${failedRequests.length} failed requests. Attempts left: ${retriesLeft}`)
-
-      await Promise.all(
-        failedRequests.map((req) =>
-          req.send(this.abortController?.signal).then(() => {
-            if (!req.hasError()) {
-              // Success after retry
-              this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
-            }
-          })
-        )
-      )
-
-      retriesLeft--
-    }
-
-    // Emit failed events for any requests that still have errors after all retries
-    this.requests
-      .filter((req) => req.hasError())
-      .forEach((req) => {
-        this.emit(BulkRequestEventEnum.REQUEST_FAILED, req)
-      })
-  }
-
-  protected async sendSequential() {
-    // First attempt for all requests
-    for (const req of this.requests) {
-      await req.send(this.abortController?.signal)
-
-      if (!req.hasError()) {
-        this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
-      }
-    }
-
-    // Retry logic for failed requests
-    let retriesLeft = this.retryCount
-    while (retriesLeft > 0) {
-      const failedRequests = this.requests.filter((req) => req.hasError())
-
-      if (failedRequests.length === 0) {
-        break // No failed requests to retry
-      }
-
-      console.log(`Retrying ${failedRequests.length} failed requests sequentially. Attempts left: ${retriesLeft}`)
-
-      for (const req of failedRequests) {
-        await req.send(this.abortController?.signal)
-
-        if (!req.hasError()) {
-          // Success after retry
-          this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req)
-        }
-      }
-
-      retriesLeft--
-    }
-
-    // Emit failed events for any requests that still have errors after all retries
-    this.requests
-      .filter((req) => req.hasError())
-      .forEach((req) => {
-        this.emit(BulkRequestEventEnum.REQUEST_FAILED, req)
-      })
-  }
-}

package/src/bulkRequests/BulkRequestWrapper.ts

@@ -1,49 +0,0 @@
-import { type BaseRequestContract } from '../requests'
-
-export class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
-  protected response: ResponseClass | null = null
-  protected error: unknown | null = null
-  protected sent: boolean = false
-
-  public constructor(protected request: BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) {}
-
-  public async send(signal?: AbortSignal) {
-    try {
-      if (signal !== undefined) {
-        this.request.setAbortSignal(signal)
-      }
-
-      this.response = await this.request.send()
-    } catch (err) {
-      console.error(err)
-
-      this.error = err
-    }
-
-    this.sent = true
-  }
-
-  public isLoading(): RequestLoaderLoadingType {
-    return this.request.isLoading()
-  }
-
-  public getResponse(): ResponseClass | null {
-    return this.response
-  }
-
-  public getError(): unknown | null {
-    return this.error
-  }
-
-  public getRequest(): BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface> {
-    return this.request
-  }
-
-  public hasError(): boolean {
-    return this.error !== null
-  }
-
-  public wasSent(): boolean {
-    return this.sent
-  }
-}

package/src/bulkRequests/index.ts

@@ -1,6 +0,0 @@
-import { BulkRequestWrapper } from './BulkRequestWrapper'
-import { BulkRequestSender } from './BulkRequestSender'
-import { BulkRequestEventEnum } from './BulkRequestEvent.enum'
-import { BulkRequestExecutionMode } from './BulkRequestSender'
-
-export { BulkRequestEventEnum, BulkRequestWrapper, BulkRequestSender, BulkRequestExecutionMode }

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

@@ -1,30 +0,0 @@
-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

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

package/src/laravel/requests/JsonBaseRequest.ts

@@ -1,35 +0,0 @@
-import { BaseRequest } from '../../requests/BaseRequest'
-import { JsonResponse } from './responses/JsonResponse'
-import { JsonBodyFactory } from '../../requests/factories/JsonBodyFactory'
-import { type BodyFactoryContract } from '../../requests/contracts/BodyFactoryContract'
-
-export interface JsonResponseInterface<ResourceInterface> {
-  data: ResourceInterface
-}
-
-/**
- * This requests expects a response in the JSON format
- * and automatically sets the required headers.
- */
-export abstract class JsonBaseRequest<
-  RequestLoaderLoadingType,
-  ResponseErrorBody,
-  ResourceInterface,
-  RequestBodyInterface = undefined,
-  RequestParamsInterface extends object = object
-> extends BaseRequest<
-  RequestLoaderLoadingType,
-  ResponseErrorBody,
-  JsonResponseInterface<ResourceInterface>,
-  JsonResponse<ResourceInterface>,
-  RequestBodyInterface,
-  RequestParamsInterface
-> {
-  public getResponse(): JsonResponse<ResourceInterface> {
-    return new JsonResponse<ResourceInterface>()
-  }
-
-  public override getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined> {
-    return new JsonBodyFactory<RequestBodyInterface>()
-  }
-}

package/src/laravel/requests/PaginationJsonBaseRequest.ts

@@ -1,29 +0,0 @@
-import { BaseRequest } from '../../requests/BaseRequest'
-import { type PaginationResponseBodyContract } from '../pagination/contracts/PaginationResponseBodyContract'
-import { type PaginationResponseContract } from '../../pagination/contracts/PaginationResponseContract'
-import { PaginationResponse } from './responses/PaginationResponse'
-
-export abstract class PaginationJsonBaseRequest<
-  RequestLoaderLoadingType,
-  ResponseErrorBodyInterface,
-  ResourceInterface,
-  RequestParamsInterface extends object
-> extends BaseRequest<
-  RequestLoaderLoadingType,
-  ResponseErrorBodyInterface,
-  PaginationResponseBodyContract<ResourceInterface>,
-  PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface>,
-  undefined,
-  RequestParamsInterface
-> {
-  public getResponse(): PaginationResponse<ResourceInterface> {
-    return new PaginationResponse()
-  }
-
-  public setPaginationParams(page: number, size: number): this {
-    return this.withParams({
-      page_number: page,
-      page_size: size
-    } as RequestParamsInterface)
-  }
-}

package/src/laravel/requests/index.ts

@@ -1,9 +0,0 @@
-import { JsonResponse } from './responses/JsonResponse'
-import { PaginationResponse } from './responses/PaginationResponse'
-import { JsonBaseRequest } from './JsonBaseRequest'
-import { PaginationJsonBaseRequest } from './PaginationJsonBaseRequest'
-import { type JsonResponseInterface } from './JsonBaseRequest'
-
-export { JsonResponse, PaginationResponse, JsonBaseRequest, PaginationJsonBaseRequest }
-
-export type { JsonResponseInterface }

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

@@ -1,8 +0,0 @@
-import { JsonResponse as ParentJsonResponse } from '../../../requests/responses/JsonResponse'
-import { type JsonResponseInterface } from '../JsonBaseRequest'
-
-export class JsonResponse<ResourceInterface> extends ParentJsonResponse<JsonResponseInterface<ResourceInterface>> {
-  public getData(): ResourceInterface {
-    return this.getBody().data
-  }
-}

package/src/laravel/requests/responses/PaginationResponse.ts

@@ -1,16 +0,0 @@
-import { JsonResponse } from '../../../requests/responses/JsonResponse'
-import { type PaginationResponseBodyContract } from '../../pagination/contracts/PaginationResponseBodyContract'
-import { type PaginationResponseContract } from '../../../pagination/contracts/PaginationResponseContract'
-
-export class PaginationResponse<ResourceInterface>
-  extends JsonResponse<PaginationResponseBodyContract<ResourceInterface>>
-  implements PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface>
-{
-  public getTotal(): number {
-    return this.getBody().meta.total
-  }
-
-  public getData(): ResourceInterface {
-    return this.getBody().data
-  }
-}

package/src/pagination/BasePaginator.ts

@@ -1,94 +0,0 @@
-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/pagination/InfiniteScroller.ts

@@ -1,22 +0,0 @@
-import { PageAwarePaginator } from './PageAwarePaginator'
-import { PaginationDataDto } from './dtos/PaginationDataDto'
-import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions'
-
-export class InfiniteScroller<ResourceInterface> extends PageAwarePaginator<ResourceInterface> {
-  protected override passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options: PaginatorLoadDataOptions = {}) {
-    const { flush = false, replace = false } = options
-
-    if (flush) {
-      this.flush()
-    }
-
-    if (replace) {
-      this.viewDriver.setData(dto.getData())
-    } else {
-      this.viewDriver.setData(this.viewDriver.getData().concat(dto.getData()))
-    }
-
-    this.viewDriver.setTotal(dto.getTotal())
-    this.initialized = true
-  }
-}

package/src/pagination/PageAwarePaginator.ts

@@ -1,132 +0,0 @@
-import { PaginationDataDto } from './dtos/PaginationDataDto'
-import { type ViewDriverContract } from './contracts/ViewDriverContract'
-import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract'
-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
-}
-
-export class PageAwarePaginator<ResourceInterface> extends BasePaginator<ResourceInterface, ViewDriverContract<ResourceInterface[]>> {
-  protected static viewDriverFactory: ViewDriverFactoryContract
-
-  protected override viewDriver: ViewDriverContract<ResourceInterface[]>
-
-  public static setViewDriverFactory(value: ViewDriverFactoryContract): void {
-    PageAwarePaginator.viewDriverFactory = value
-  }
-
-  public constructor(
-    protected override dataDriver: PaginationDataDriverContract<ResourceInterface[]>,
-    pageNumber: number = 1,
-    pageSize: number = 10,
-    options?: PageAwarePaginatorOptions
-  ) {
-    super(dataDriver)
-    this.viewDriver = options?.viewDriverFactory
-      ? options.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
-      : PageAwarePaginator.viewDriverFactory.make<ResourceInterface>(pageNumber, pageSize)
-  }
-
-  public setDataDriver(dataDriver: PaginationDataDriverContract<ResourceInterface[]>): this {
-    this.dataDriver = dataDriver
-
-    return this
-  }
-
-  public getDataDriver(): PaginationDataDriverContract<ResourceInterface[]> {
-    return this.dataDriver
-  }
-
-  public load(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>> {
-    if (pageNumber !== undefined) {
-      this.setPageNumber(pageNumber)
-    }
-
-    return this.loadData(this.getCurrentPage(), this.getPageSize(), options)
-  }
-
-  public setPageNumber(pageNumber: number): this {
-    this.viewDriver.setPage(pageNumber)
-
-    return this
-  }
-
-  public getLastPage(): number {
-    return this.viewDriver.getLastPage()
-  }
-
-  public toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.setPageNumber(this.getCurrentPage() + 1)
-
-    return this.load()
-  }
-
-  public toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.setPageNumber(1)
-
-    return this.load()
-  }
-
-  public toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.setPageNumber(this.viewDriver.getLastPage())
-
-    return this.load()
-  }
-
-  public toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>> {
-    this.setPageNumber(this.getCurrentPage() - 1)
-
-    return this.load()
-  }
-
-  public getCurrentPage(): number {
-    return this.viewDriver.getCurrentPage()
-  }
-
-  public getFromItemNumber(): number {
-    return (this.getCurrentPage() - 1) * this.getPageSize() + 1
-  }
-
-  public getToItemNumber(): number {
-    return this.getCurrentPage() * this.getPageSize()
-  }
-
-  public getPageSize(): number {
-    return this.viewDriver.getPageSize()
-  }
-
-  public setPageSize(pageSize: number): this {
-    this.viewDriver.setPageSize(pageSize)
-
-    if (this.getCurrentPage() * pageSize > this.getTotal()) {
-      this.setPageNumber(1)
-    }
-
-    return this
-  }
-
-  public getPages(): number[] {
-    return this.viewDriver.getPages()
-  }
-
-  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
-      })
-      .catch((error) => {
-        if (error instanceof StaleResponseException) {
-          return this.handleStaleResponse()
-        }
-
-        throw error
-      })
-  }
-}