@intellegens/cornerstone-client 0.0.9999-alpha-41 → 0.0.9999-alpha-43

package/src/adapters/search-adapter.ts

@@ -0,0 +1,374 @@
+import {
+  ErrorCode,
+  PropertyPathDto,
+  ReadSelectedComparisonOperator,
+  ReadSelectedDefinitionDto,
+  ReadSelectedLogicalOperator,
+  ReadSelectedOrderingDirection,
+  ReadSelectedPropertyType,
+  ReadSelectedSearchDefinitionDto,
+  ReadSelectedSearchPropertyDefinitionDto,
+} from '@data';
+import { ApiReadControllerClient, IReadSelectedClient } from '@services';
+import { IHasObservableProperty, SingularEventTarget, toPascalCase } from '@utils';
+
+export type SearchAdapterBaseOptions<TDto> = {
+  primaryKey: string | ((item: TDto) => string);
+  multiselect: boolean;
+  defaultSearch?: ReadSelectedSearchDefinitionDto<TDto>;
+  defaultText?: string;
+  searchTriggerMinLength?: number;
+  searchDebounceDelay?: number;
+  ordering?: { path: PropertyPathDto; direction: ReadSelectedOrderingDirection }[];
+  limit?: number;
+};
+
+export type SearchAdapterOptions<TDto> = SearchAdapterBaseOptions<TDto> & (TDto extends { type: string } ? { typesToSearch?: string[] } : {});
+
+export interface ISearchAdapter<TDto>
+  extends
+    IHasObservableProperty<'isLoading', boolean>,
+    IHasObservableProperty<'error', string | undefined>,
+    IHasObservableProperty<'searchData', readonly TDto[]>,
+    IHasObservableProperty<'totalItemCount', number>,
+    IHasObservableProperty<'types', string[] | undefined>,
+    IHasObservableProperty<'search', ReadSelectedSearchDefinitionDto<TDto> | undefined>,
+    IHasObservableProperty<'text', string | undefined>,
+    IHasObservableProperty<'selection', readonly TDto[]> {
+  readonly options: Required<SearchAdapterBaseOptions<TDto>>;
+  readonly searchTriggerMinLength: number;
+
+  setTypes(types: string[] | undefined): void;
+  setSearch(search: ReadSelectedSearchDefinitionDto<TDto> | undefined): void;
+  setText(text: string | undefined): void;
+
+  refresh(): void;
+
+  selectionAdd(item: TDto): void;
+  selectionRemove(item: TDto): void;
+  selectionToggle(item: TDto): void;
+  selectionClear(): void;
+
+  destroy(): void;
+}
+
+const DEFAULT_OPTIONS = {
+  defaultSearch: undefined,
+  defaultText: undefined,
+  searchTriggerMinLength: 1,
+  searchDebounceDelay: 100,
+  ordering: [],
+  limit: undefined,
+} as const;
+
+export class SearchAdapter<TDto> implements ISearchAdapter<TDto> {
+  public readonly options: Required<SearchAdapterBaseOptions<TDto>>;
+
+  public readonly isLoadingChanged = new SingularEventTarget<boolean>();
+  public readonly errorChanged = new SingularEventTarget<string | undefined>();
+  public readonly searchDataChanged = new SingularEventTarget<readonly TDto[]>();
+  public readonly totalItemCountChanged = new SingularEventTarget<number>();
+  public readonly typesChanged = new SingularEventTarget<string[] | undefined>();
+  public readonly searchChanged = new SingularEventTarget<ReadSelectedSearchDefinitionDto<TDto> | undefined>();
+  public readonly textChanged = new SingularEventTarget<string | undefined>();
+  public readonly selectionChanged = new SingularEventTarget<readonly TDto[]>();
+
+  private _readClient: IReadSelectedClient<any, any>;
+  private _isLoading = false;
+  private _error: string | undefined = undefined;
+  private _searchData: TDto[] = [];
+  private _totalItemCount = 0;
+  private _types: string[] | undefined;
+  private _search: ReadSelectedSearchDefinitionDto<TDto> | undefined;
+  private _text: string | undefined;
+  private _selection: TDto[] = [];
+
+  private _lastSearchedText: string | undefined = undefined;
+  private _currentAbortController?: AbortController;
+  private _fetchTimeout?: ReturnType<typeof setTimeout>;
+
+  constructor(options: SearchAdapterOptions<TDto>, client: IReadSelectedClient<any, any> | string) {
+    this._readClient = typeof client === 'string' ? new ApiReadControllerClient<any, any, any>(client) : client;
+
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+    } as Required<SearchAdapterBaseOptions<TDto>>;
+
+    this._types = (options as { typesToSearch?: string[] }).typesToSearch;
+    this._search = this.options.defaultSearch;
+    this._text = this.options.defaultText;
+  }
+
+  // --- Getters ---
+
+  public get isLoading(): boolean {
+    return this._isLoading;
+  }
+
+  public get error(): string | undefined {
+    return this._error;
+  }
+
+  public get searchData(): readonly TDto[] {
+    return this._searchData;
+  }
+
+  public get totalItemCount(): number {
+    return this._totalItemCount;
+  }
+
+  public get types(): string[] | undefined {
+    return this._types;
+  }
+
+  public get search(): ReadSelectedSearchDefinitionDto<TDto> | undefined {
+    return this._search;
+  }
+
+  public get text(): string | undefined {
+    return this._text;
+  }
+
+  public get selection(): readonly TDto[] {
+    return this._selection;
+  }
+
+  public get searchTriggerMinLength(): number {
+    return this.options.searchTriggerMinLength;
+  }
+
+  // --- Mutations ---
+
+  public setTypes(types: string[] | undefined): void {
+    this._types = types;
+    this._lastSearchedText = undefined;
+    this.typesChanged.dispatchEvent(this._types);
+    this._triggerFetch();
+  }
+
+  public setSearch(search: ReadSelectedSearchDefinitionDto<TDto> | undefined): void {
+    this._search = search;
+    this._lastSearchedText = undefined;
+    this.searchChanged.dispatchEvent(this._search);
+    this._triggerFetch();
+  }
+
+  public setText(text: string | undefined): void {
+    if (this._text === text) return;
+    this._text = text;
+    this.textChanged.dispatchEvent(this._text);
+    this._triggerFetch();
+  }
+
+  public refresh(): void {
+    this._lastSearchedText = undefined;
+    this._triggerFetch();
+  }
+
+  // --- Selection ---
+
+  private _getItemKey(item: TDto): string {
+    const pk = this.options.primaryKey;
+    if (typeof pk === 'function') return pk(item);
+    return String((item as Record<string, unknown>)[pk]);
+  }
+
+  public selectionAdd(item: TDto): void {
+    const key = this._getItemKey(item);
+    if (this._selection.find(x => this._getItemKey(x) === key)) return;
+    if (this.options.multiselect) {
+      this._selection = [...this._selection, item];
+    } else {
+      this._selection = [item];
+    }
+    this._searchData = this._searchData.filter(d => this._getItemKey(d) !== key);
+    this.selectionChanged.dispatchEvent(this._selection);
+    this.searchDataChanged.dispatchEvent(this._searchData);
+  }
+
+  public selectionRemove(item: TDto): void {
+    const key = this._getItemKey(item);
+    this._selection = this._selection.filter(s => this._getItemKey(s) !== key);
+    this._searchData = [...this._searchData, item];
+    this.selectionChanged.dispatchEvent(this._selection);
+    this.searchDataChanged.dispatchEvent(this._searchData);
+  }
+
+  public selectionToggle(item: TDto): void {
+    const key = this._getItemKey(item);
+    if (this._selection.find(x => this._getItemKey(x) === key)) {
+      this.selectionRemove(item);
+    } else {
+      this.selectionAdd(item);
+    }
+  }
+
+  public selectionClear(): void {
+    this._selection = [];
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  // --- Lifecycle ---
+
+  public destroy(): void {
+    this._cancelPendingRequests();
+  }
+
+  // --- Private ---
+
+  private _triggerFetch(): void {
+    const textLength = this._text?.length ?? 0;
+    if (textLength < this.options.searchTriggerMinLength) {
+      this._searchData = [];
+      this._lastSearchedText = undefined;
+      this._emitSearchState();
+      return;
+    }
+    if (this._text === this._lastSearchedText) return;
+    this._lastSearchedText = this._text;
+
+    this._searchData = [];
+    this._scheduleFetch();
+  }
+
+  private _scheduleFetch(): void {
+    this._isLoading = true;
+    this.isLoadingChanged.dispatchEvent(true);
+    if (this._fetchTimeout !== undefined) {
+      clearTimeout(this._fetchTimeout);
+    }
+    this._fetchTimeout = setTimeout(() => this._executeFetch(), this.options.searchDebounceDelay);
+  }
+
+  private async _executeFetch(): Promise<void> {
+    let abortController: AbortController | undefined;
+
+    try {
+      if (this._currentAbortController) {
+        try {
+          this._currentAbortController.abort();
+        } catch {
+          // Ignore abort errors
+        }
+      }
+      abortController = new AbortController();
+      this._currentAbortController = abortController;
+
+      const definition = this._buildDefinition();
+      const response = await this._readClient.readSelected(definition, abortController.signal);
+
+      if (!response.ok) {
+        if (response.error.code === ErrorCode.Aborted) return;
+        this._error = response.error.details ?? response.error.message ?? 'Unknown error';
+      } else {
+        this._error = undefined;
+        this._totalItemCount = response.metadata?.totalCount ?? response.result.length;
+
+        const selectedKeys = new Set(this._selection.map(item => this._getItemKey(item)));
+        this._searchData = response.result.filter((item: TDto) => !selectedKeys.has(this._getItemKey(item)));
+      }
+    } catch (error: unknown) {
+      console.error('Error fetching data:', error);
+      this._error = error instanceof Error ? error.message : 'Unknown error';
+    } finally {
+      if (abortController && this._currentAbortController === abortController) {
+        this._isLoading = false;
+        this._currentAbortController = undefined;
+        this.isLoadingChanged.dispatchEvent(false);
+        this.errorChanged.dispatchEvent(this._error);
+        this._emitSearchState();
+      }
+    }
+  }
+
+  private _emitSearchState(): void {
+    this.searchDataChanged.dispatchEvent(this._searchData);
+    this.totalItemCountChanged.dispatchEvent(this._totalItemCount);
+  }
+
+  private _buildDefinition(): ReadSelectedDefinitionDto<TDto> {
+    const definition: ReadSelectedDefinitionDto<TDto> = {};
+
+    // Pagination
+    if (this.options.limit !== undefined) {
+      definition.paginationDefinition = { skip: 0, limit: this.options.limit };
+    }
+
+    // Ordering
+    if (this.options.ordering.length > 0) {
+      definition.orderingDefinition = {
+        order: this.options.ordering.map(o => ({
+          propertyPath: o.path.map(x => toPascalCase(x)) as PropertyPathDto,
+          direction: o.direction,
+        })),
+      };
+    }
+
+    // Search definition (from options or setSearch)
+    if (this._search) {
+      definition.searchDefinition = { ...this._search };
+    }
+
+    // Text search criterion
+    if (this._text) {
+      const textCriterion: ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto> = {
+        propertyName: 'Name' as keyof TDto,
+        comparisonOperator: ReadSelectedComparisonOperator.IContains,
+        valueType: ReadSelectedPropertyType.String,
+        value: this._text,
+      };
+
+      if (!definition.searchDefinition) {
+        definition.searchDefinition = {
+          logicalOperator: ReadSelectedLogicalOperator.And,
+          propertyCriteria: [textCriterion],
+        } as ReadSelectedSearchDefinitionDto<TDto>;
+      } else {
+        definition.searchDefinition.propertyCriteria = [...(definition.searchDefinition.propertyCriteria || []), textCriterion];
+      }
+    }
+
+    // Type criteria
+    if (this._types && this._types.length > 0) {
+      if (!definition.searchDefinition) {
+        definition.searchDefinition = {
+          logicalOperator: ReadSelectedLogicalOperator.And,
+          propertyCriteria: [],
+        } as ReadSelectedSearchDefinitionDto<TDto>;
+      }
+      if (!definition.searchDefinition.searches) {
+        definition.searchDefinition.searches = [];
+      }
+      definition.searchDefinition.searches.push({
+        logicalOperator: ReadSelectedLogicalOperator.Or,
+        propertyCriteria: this._types.map(
+          type =>
+            ({
+              propertyName: 'Type',
+              comparisonOperator: ReadSelectedComparisonOperator.IEqual,
+              valueType: ReadSelectedPropertyType.String,
+              value: type,
+            }) as ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto>,
+        ),
+      });
+    }
+
+    return definition;
+  }
+
+  private _cancelPendingRequests(): void {
+    if (this._fetchTimeout !== undefined) {
+      clearTimeout(this._fetchTimeout);
+      this._fetchTimeout = undefined;
+    }
+    if (this._currentAbortController) {
+      try {
+        this._currentAbortController.abort();
+      } catch {
+        // Ignore abort errors
+      }
+      this._currentAbortController = undefined;
+    }
+  }
+}

package/src/data/api/dto/crud/crud-metadata-dto.ts

@@ -0,0 +1,4 @@
+/**
+ * Metadata associated with a crud result.
+ */
+export type CrudMetadataDto = object;

package/src/data/api/dto/crud/index.ts

@@ -1 +1 @@
-export * from './CrudMetadataDto';
+export * from './crud-metadata-dto';

package/src/data/api/dto/index.ts

@@ -1,4 +1,4 @@
 export * from './response';
 export * from './read';
 export * from './crud';
-export * from './PropertyPathDto';
+export * from './property-path-dto';

package/src/data/api/dto/read/index.ts

@@ -1,10 +1,10 @@
-export * from './ReadMetadataDto';
-export * from './ReadSelectedSearchPropertyDefinitionDto';
-export * from './ReadSelectedNestedCriteriaDto';
-export * from './ReadSelectedNestedCollectionCriteriaDto';
-export * from './ReadSelectedOrderingDefinitionDto';
-export * from './ReadSelectedOrderingPropertyDefinitionDto';
-export * from './ReadSelectedPaginationDefinitionDto';
-export * from './ReadSelectedDefinitionDto';
-export * from './ReadSelectedSearchDefinitionDto';
-export * from './ReadSelectedSearchDefinitionBuilder';
+export * from './read-metadata-dto';
+export * from './read-selected-search-property-definition-dto';
+export * from './read-selected-nested-criteria-dto';
+export * from './read-selected-nested-collection-criteria-dto';
+export * from './read-selected-ordering-definition-dto';
+export * from './read-selected-ordering-property-definition-dto';
+export * from './read-selected-pagination-definition-dto';
+export * from './read-selected-definition-dto';
+export * from './read-selected-search-definition-dto';
+export * from './read-selected-search-definition-builder';

package/src/data/api/dto/read/{ReadSelectedSearchDefinitionBuilder.ts → read-selected-search-definition-builder.ts}

@@ -1,8 +1,8 @@
 import { ReadSelectedCollectionOperator, ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType } from '@data';
-import { ReadSelectedSearchDefinitionDto } from './ReadSelectedSearchDefinitionDto';
-import { ReadSelectedSearchPropertyDefinitionDto } from './ReadSelectedSearchPropertyDefinitionDto';
-import { ReadSelectedNestedCriteriaDto } from './ReadSelectedNestedCriteriaDto';
-import { ReadSelectedNestedCollectionCriteriaDto } from './ReadSelectedNestedCollectionCriteriaDto';
+import { ReadSelectedSearchDefinitionDto } from './read-selected-search-definition-dto';
+import { ReadSelectedSearchPropertyDefinitionDto } from './read-selected-search-property-definition-dto';
+import { ReadSelectedNestedCriteriaDto } from './read-selected-nested-criteria-dto';
+import { ReadSelectedNestedCollectionCriteriaDto } from './read-selected-nested-collection-criteria-dto';
 
 /**
  * Builder class for constructing ReadSelectedSearchDefinitionDto with a fluent API.

package/src/data/api/dto/{ReadResultDto.ts → read-result-dto.ts}

@@ -1,4 +1,4 @@
-import { ReadResultMetadataDto } from './ReadResultMetadataDto';
+import { ReadResultMetadataDto } from './read-result-metadata-dto';
 
 /**
  * Represents a read result containing a collection of results and metadata.

package/src/data/api/dto/response/{ApiErrorDto.ts → api-error-dto.ts}

@@ -16,6 +16,6 @@ export type ApiErrorMetadataDto =
     metadata: ValidationFailedMetadataDto;
 }
     | {
-    code: Omit<number, ErrorCode.ValidationFailed>;
+    code: Exclude<ErrorCode, ErrorCode.ValidationFailed>;
     metadata: EmptyMetadataDto;
 };

package/src/data/api/dto/response/index.ts

@@ -1,5 +1,5 @@
-export * from './ApiResponseDto';
-export * from './ApiSuccessResponseDto';
-export * from './ApiErrorDto';
-export * from './MetadataDto';
-export * from './ApiErrorResponseDto';
+export * from './api-response-dto';
+export * from './api-success-response-dto';
+export * from './api-error-dto';
+export * from './metadata-dto';
+export * from './api-error-response-dto';

package/src/data/api/enum/read/index.ts

@@ -1,5 +1,5 @@
-export * from './ReadSelectedCollectionOperator';
-export * from './ReadSelectedComparisonOperator';
-export * from './ReadSelectedLogicalOperator';
-export * from './ReadSelectedOrderingDirection';
-export * from './ReadSelectedPropertyType';
+export * from './read-selected-collection-operator';
+export * from './read-selected-comparison-operator';
+export * from './read-selected-logical-operator';
+export * from './read-selected-ordering-direction';
+export * from './read-selected-property-type';

package/src/data/api/enum/response/{ErrorCode.ts → error-code.ts}

@@ -10,4 +10,5 @@ export enum ErrorCode {
     GatewayTimeout = 504,
     ValidationFailed = 422,
     UnknownError = 599,
+    Aborted = 0,
 }

package/src/data/api/enum/response/index.ts

@@ -1 +1 @@
-export * from './ErrorCode';
+export * from './error-code';

package/src/data/api/interface/{ICommonIdentifiable.ts → icommon-identifiable.ts}

@@ -1,4 +1,4 @@
-import {IIdentifiable} from "@data";
+import {IIdentifiable} from '@data';
 
 
 export interface ICommonIdentifiable<TKey> extends IIdentifiable<TKey> {

package/src/data/api/interface/{IConcurrencySafe.ts → iconcurrency-safe.ts}

@@ -6,4 +6,4 @@ export interface IConcurrencySafe {
    * Row version
    */
   rowVersion: string;
-};
+}

package/src/data/api/interface/{IIdentifiable.ts → iidentifiable.ts}

@@ -1,4 +1,4 @@
-import { IConcurrencySafe } from './IConcurrencySafe';
+import { IConcurrencySafe } from '@/data';
 
 /**
  * Interface for entities that have a Id property.

package/src/data/api/interface/index.ts

@@ -1,3 +1,4 @@
-export * from './IIdentifiable';
-export * from './IIdentifiableSecondary';
-export * from './IConcurrencySafe';
+export * from './iidentifiable';
+export * from './iidentifiable-secondary';
+export * from './iconcurrency-safe';
+export * from './icommon-identifiable';

package/src/data/auth/dto/index.ts

@@ -1,5 +1,6 @@
-export * from './ClaimDto';
-export * from './UserDto';
-export * from './UserInfoDto';
-export * from './RoleDto';
-export * from './RegisterRequestDto';
+export * from './claim-dto';
+export * from './user-dto';
+export * from './user-info-dto';
+export * from './role-dto';
+export * from './role-with-claims-dto';
+export * from './register-request-dto';

package/src/data/auth/dto/role-with-claims-dto.ts

@@ -0,0 +1,6 @@
+import { ClaimDto } from '@data';
+
+export type RoleWithClaimsDto = {
+  name: string;
+  claims: ClaimDto[];
+};

package/src/data/auth/dto/{UserDto.ts → user-dto.ts}

@@ -1,5 +1,4 @@
-import { ClaimDto } from '@data';
-import { IIdentifiable } from '@data';
+import { ClaimDto, IIdentifiable, RoleWithClaimsDto } from '@data';
 
 /**
  * Represents a user with an identifier and email address.
@@ -8,11 +7,11 @@ import { IIdentifiable } from '@data';
  *
  * @param {TKey} id The unique identifier for the user.
  * @param {string} email The email address associated with the user.
- * @param {string[]} roles The roles associated with the user.
- * @param {ClaimDto[]} claims The claims associated with the user.
+ * @param {RoleWithClaimsDto[]} roles The roles (with their claims) associated with the user.
+ * @param {ClaimDto[]} userClaims The claims associated with the user.
  */
 export type UserDto<TKey> = IIdentifiable<TKey> & {
   email: string;
-  roles: string[];
-  claims: ClaimDto[];
+  roles: RoleWithClaimsDto[];
+  userClaims: ClaimDto[];
 };

package/src/services/api/{ApiCrudControllerClient/index.integration.test.ts → api-crud-controller-client.integration.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import { ApiCrudControllerClient } from '.';
-import { FetchHttpService } from '../HttpService';
+import { FetchHttpService } from '@services';
 
 type VehicleSlimDto = { id: number; brand: string; model: string };
 

package/src/services/api/{ApiCrudControllerClient/index.ts → api-crud-controller-client.ts}

@@ -1,11 +1,48 @@
-import { apiInitializationService } from '../ApiInitializationService';
-import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto } from '../../../data/api/dto';
-import { IIdentifiable } from '../../../data/api/interface';
-import { IHttpService } from '../HttpService';
-import { ApiReadControllerClient } from '../ApiReadControllerClient';
-import { ErrorCode } from '@data';
+import { apiInitializationService, ApiReadControllerClient, IApiReadControllerClient, IHttpService } from '@/services';
+import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto, ErrorCode, IIdentifiable } from '@data';
 import { fail, ok } from '@utils/result';
 
+function isAbortError(err: unknown): boolean {
+  return err instanceof DOMException && err.name === 'AbortError';
+}
+
+/**
+ * Client for creating a new entity in a CRUD controller.
+ */
+export interface ICreateClient<TKey, TResultDto extends IIdentifiable<TKey>, TInsertRequestDto> {
+  create(dto: TInsertRequestDto, signal?: AbortSignal): Promise<ApiResponseDto<TResultDto, EmptyMetadataDto>>;
+}
+
+/**
+ * Client for updating an existing entity in a CRUD controller.
+ */
+export interface IUpdateClient<TKey, TResultDto extends IIdentifiable<TKey>, TUpdateRequestDto> {
+  update(id: TKey, dto: TUpdateRequestDto, signal?: AbortSignal): Promise<ApiResponseDto<TResultDto, EmptyMetadataDto>>;
+}
+
+/**
+ * Client for deleting an entity in a CRUD controller.
+ */
+export interface IDeleteClient<TKey> {
+  delete(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+}
+
+/**
+ * Client for managing CRUD operations on a controller.
+ */
+export interface IApiCrudControllerClient<
+  TKey,
+  TResultDto extends IIdentifiable<TKey>,
+  TSingleResultDto extends IIdentifiable<TKey>,
+  TInsertRequestDto,
+  TUpdateRequestDto,
+>
+  extends
+    IApiReadControllerClient<TKey, TResultDto, TSingleResultDto>,
+    ICreateClient<TKey, TSingleResultDto, TInsertRequestDto>,
+    IUpdateClient<TKey, TSingleResultDto, TUpdateRequestDto>,
+    IDeleteClient<TKey> {}
+
 /**
  * Generic API client for consuming any Cornerstone CrudController
  *
@@ -21,7 +58,10 @@ export class ApiCrudControllerClient<
   TSingleResultDto extends IIdentifiable<TKey>,
   TInsertRequestDto,
   TUpdateRequestDto,
-> extends ApiReadControllerClient<TKey, TResultDto, TSingleResultDto> {
+>
+  extends ApiReadControllerClient<TKey, TResultDto, TSingleResultDto>
+  implements IApiCrudControllerClient<TKey, TResultDto, TSingleResultDto, TInsertRequestDto, TUpdateRequestDto>
+{
   /**
    * Constructor
    * @param baseControllerPath Base path to API controller
@@ -53,6 +93,11 @@ export class ApiCrudControllerClient<
 
       return ok<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
     } catch (err) {
+      if (isAbortError(err)) {
+        return fail<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>({
+          error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} as EmptyMetadataDto },
+        });
+      }
       console.error(err);
 
       return fail<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>({
@@ -89,6 +134,11 @@ export class ApiCrudControllerClient<
 
       return ok<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
     } catch (err) {
+      if (isAbortError(err)) {
+        return fail<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>({
+          error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} as EmptyMetadataDto },
+        });
+      }
       console.error(err);
 
       return fail<ApiSuccessResponseDto<TSingleResultDto, EmptyMetadataDto>, ApiErrorResponseDto>({
@@ -121,6 +171,11 @@ export class ApiCrudControllerClient<
 
       return ok<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
     } catch (err) {
+      if (isAbortError(err)) {
+        return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>({
+          error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} as EmptyMetadataDto },
+        });
+      }
       console.error(err);
 
       return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>({