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

package/src/adapters/collection-view-adapter.integration.test.ts

@@ -0,0 +1,172 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { CollectionViewAdapter, CollectionViewAdapterOptions } from '.';
+import { ReadSelectedComparisonOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '@/data';
+import { dateInterval, searchTerm } from '@/utils';
+import { ApiReadControllerClient } from '@services';
+
+type TestDto = { id: number; name: string; dateOfBirth: string; rowVersion: string };
+
+describe('CollectionViewAdapter', () => {
+  const options: CollectionViewAdapterOptions<TestDto> = {
+    primaryKey: 'id',
+    pagination: { defaultPageSize: 5, defaultPageIndex: 0 },
+    ordering: { maxOrderingColumns: 1 },
+  };
+
+  let adapter: CollectionViewAdapter<TestDto>;
+
+  const waitForData = async (adapterInstance: CollectionViewAdapter<TestDto>, timeout = 2000) => {
+    const start = Date.now();
+    while (adapterInstance.isLoading && Date.now() - start < timeout) {
+      await new Promise(res => setTimeout(res, 50));
+    }
+  };
+
+  beforeEach(() => {
+    options.pagination = { defaultPageSize: 5, defaultPageIndex: 0 };
+    options.ordering = { maxOrderingColumns: 1 };
+  });
+
+  it('returns correct loading status and collection data', async () => {
+    adapter = new CollectionViewAdapter(options, 'AnythingManuallyMappedRead');
+    await waitForData(adapter);
+
+    expect(adapter.isLoading).toBe(false);
+    expect(adapter.pageData).toBeDefined();
+    expect(adapter.pageData!.length).toBeGreaterThan(0);
+    expect(adapter.error).toBeUndefined();
+  });
+
+  it('adapter options set correct ordering', async () => {
+    adapter = new CollectionViewAdapter(options, 'AnythingManuallyMappedRead');
+    await waitForData(adapter);
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData(adapter);
+
+    expect(adapter.ordering).toEqual([
+      {
+        path: ['name'],
+        direction: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+  });
+
+  it('text search is applied to adapter', async () => {
+    const searchDefinition = searchTerm('Flu', ['name'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    adapter = new CollectionViewAdapter(options, new ApiReadControllerClient<number, TestDto, TestDto>('AnythingManuallyMappedRead'));
+    await waitForData(adapter);
+    adapter.setSearch(searchDefinition);
+    await waitForData(adapter);
+
+    expect(adapter.pageData).toBeDefined();
+    expect(adapter.pageData!.length).toBeGreaterThan(0);
+    for (const item of adapter.pageData!) {
+      expect(item.name).toMatch(/flu/i);
+    }
+  });
+
+  it('numeric search is applied to adapter', async () => {
+    const searchDefinition = searchTerm('10000001', ['id'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    adapter = new CollectionViewAdapter(options, new ApiReadControllerClient<number, TestDto, TestDto>('AnythingManuallyMappedRead'));
+    await waitForData(adapter);
+    adapter.setSearch(searchDefinition);
+    await waitForData(adapter);
+
+    expect(adapter.pageData).toBeDefined();
+    expect(adapter.pageData!.length).toBe(1);
+    for (const item of adapter.pageData!) {
+      expect(item.id).toBe(10000001);
+    }
+  });
+
+  it('applies date range filter from-to on the same date type property', async () => {
+    adapter = new CollectionViewAdapter(options, new ApiReadControllerClient<number, TestDto, TestDto>('PetsSlim'));
+    const from = new Date('2017-01-01T00:00:00.000Z');
+    const to = new Date('2017-12-31T00:00:00.000Z');
+
+    const searchDefinition = dateInterval<TestDto>(
+      from,
+      to,
+      ReadSelectedComparisonOperator.GreaterOrEqual,
+      ReadSelectedComparisonOperator.LessOrEqual,
+      ReadSelectedPropertyType.DateOnly,
+      'dateOfBirth',
+    );
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    await waitForData(adapter);
+    adapter.setSearch(searchDefinition);
+    await waitForData(adapter);
+
+    expect(adapter.pageData).toBeDefined();
+  });
+
+  it('applies pagination: page size and jump to page set skip/limit', async () => {
+    adapter = new CollectionViewAdapter(options, 'AnythingManuallyMappedRead');
+    await waitForData(adapter);
+    const firstPageData = [...adapter.pageData!];
+    adapter.setPageIndex(3);
+    await waitForData(adapter);
+
+    expect(adapter.pageData).toBeDefined();
+    expect(adapter.pageData!.length).toBe(5);
+    expect([...adapter.pageData!]).not.toEqual(firstPageData);
+  });
+
+  it('calculates total when server does not return totalCount', async () => {
+    options.pagination = { defaultPageSize: 10, defaultPageIndex: 0 };
+    adapter = new CollectionViewAdapter(options, 'AnythingManuallyMappedRead');
+    await waitForData(adapter);
+    const firstPageLength = adapter.pageData!.length;
+    adapter.setPageIndex(2);
+    await waitForData(adapter);
+
+    expect(adapter.totalItemCount).toBe(firstPageLength + adapter.pageData!.length);
+  });
+
+  it('setOrdering correctly handles PropertyPathDto array comparison and limits columns', async () => {
+    options.ordering = { maxOrderingColumns: 2 };
+    adapter = new CollectionViewAdapter(options, 'AnythingManuallyMappedRead');
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData(adapter);
+
+    expect(adapter.ordering).toEqual([
+      {
+        path: ['name'],
+        direction: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // Add second ordering
+    adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Ascending);
+    await waitForData(adapter);
+
+    // Should have both orderings, with 'id' first (most recent)
+    expect(adapter.ordering).toEqual([
+      {
+        path: ['id'],
+        direction: ReadSelectedOrderingDirection.Ascending,
+      },
+      {
+        path: ['name'],
+        direction: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // Add third ordering - should remove the oldest one (name)
+    adapter.setOrdering(['description'], ReadSelectedOrderingDirection.Descending);
+    await waitForData(adapter);
+
+    expect(adapter.ordering).toEqual([
+      {
+        path: ['description'],
+        direction: ReadSelectedOrderingDirection.Descending,
+      },
+      {
+        path: ['id'],
+        direction: ReadSelectedOrderingDirection.Ascending,
+      },
+    ]);
+  });
+});

package/src/adapters/collection-view-adapter.ts

@@ -0,0 +1,458 @@
+import {
+  ErrorCode,
+  PropertyPathDto,
+  ReadSelectedDefinitionDto,
+  ReadSelectedLogicalOperator,
+  ReadSelectedOrderingDirection,
+  ReadSelectedSearchDefinitionDto,
+} from '@data';
+import { IHasObservableProperty, SingularEventTarget, toPascalCase } from '@utils';
+import { ApiReadControllerClient } from '@services';
+import { IReadSelectedClient } from '@services/api';
+
+/**
+ * Options for the CollectionViewAdapter
+ */
+export type CollectionViewAdapterOptions<TDto> = {
+  pagination?: {
+    defaultPageSize?: number;
+    defaultPageIndex?: number;
+  };
+  ordering?: {
+    maxOrderingColumns?: number;
+    defaultOrdering?: {
+      path: PropertyPathDto;
+      direction: ReadSelectedOrderingDirection;
+    }[];
+  };
+  search?: {
+    defaultSearch?: ReadSelectedSearchDefinitionDto<TDto>;
+  };
+} & {
+  primaryKey: string | ((item: TDto) => string);
+  selection?: {
+    enabled: 'single' | 'multiple' | false;
+    defaultSelection?: TDto[];
+  };
+};
+
+/**
+ * Adapter for managing a collection view of data
+ */
+export interface ICollectionViewAdapter<TDto>
+  extends
+    IHasObservableProperty<'isLoading', boolean>,
+    IHasObservableProperty<'pageData', readonly TDto[] | undefined>,
+    IHasObservableProperty<'error', string | undefined>,
+    IHasObservableProperty<'totalItemCount', number>,
+    IHasObservableProperty<'pageIndex', number>,
+    IHasObservableProperty<'pageSize', number>,
+    IHasObservableProperty<'ordering', readonly { path: PropertyPathDto; direction: ReadSelectedOrderingDirection }[]>,
+    IHasObservableProperty<'selection', readonly TDto[]>,
+    IHasObservableProperty<'search', ReadSelectedSearchDefinitionDto<TDto>> {
+  setSearch(searchDefinition: ReadSelectedSearchDefinitionDto<TDto>): void;
+
+  setOrdering(propertyPath: PropertyPathDto, orderDirection: ReadSelectedOrderingDirection): void;
+
+  setPageIndex(pageNumber: number): void;
+  setPageSize(pageSize: number): void;
+  refreshData(): void;
+
+  selectionToggle(item: TDto): void;
+  selectionAdd(item: TDto): void;
+  selectionRemove(item: TDto): void;
+  selectionClear(): void;
+  isSelected(item: TDto): boolean;
+  selectionAddPage(): void;
+  selectionRemovePage(): void;
+  isSelectedPage(): boolean;
+  isSomeSelectedPage(): boolean;
+
+  destroy(): void;
+}
+
+/**
+ * Adapter for managing a collection view of data
+ */
+export class CollectionViewAdapter<TDto> implements ICollectionViewAdapter<TDto> {
+  // #region Event targets
+
+  public readonly isLoadingChanged = new SingularEventTarget<boolean>();
+  public readonly pageDataChanged = new SingularEventTarget<readonly TDto[] | undefined>();
+  public readonly errorChanged = new SingularEventTarget<string | undefined>();
+  public readonly totalItemCountChanged = new SingularEventTarget<number>();
+  public readonly pageIndexChanged = new SingularEventTarget<number>();
+  public readonly pageSizeChanged = new SingularEventTarget<number>();
+  public readonly selectionChanged = new SingularEventTarget<readonly TDto[]>();
+  public readonly searchChanged = new SingularEventTarget<ReadSelectedSearchDefinitionDto<TDto> | undefined>();
+  public readonly orderingChanged = new SingularEventTarget<readonly { path: PropertyPathDto; direction: ReadSelectedOrderingDirection }[]>();
+  // #endregion
+
+  private _readClient: IReadSelectedClient<any, any>;
+
+  private _isLoading = false;
+  private _pageData: TDto[] | undefined = undefined;
+  private _error: string | undefined = undefined;
+  private _totalItemCount = 0;
+  private _pageIndex = 0;
+  private _pageSize = 0;
+  private _selection: TDto[] = [];
+  private _search: ReadSelectedSearchDefinitionDto<TDto> = { logicalOperator: ReadSelectedLogicalOperator.And };
+  private _ordering: { path: PropertyPathDto; direction: ReadSelectedOrderingDirection }[] = [];
+  private _currentAbortController?: AbortController;
+  private _fetchTimeout?: ReturnType<typeof setTimeout>;
+
+  private _defaultOptions: Partial<CollectionViewAdapterOptions<TDto>> = {
+    pagination: {
+      defaultPageSize: 10,
+      defaultPageIndex: 0,
+    },
+    ordering: {
+      maxOrderingColumns: 1,
+      defaultOrdering: undefined,
+    },
+    search: {
+      defaultSearch: undefined,
+    },
+    selection: {
+      enabled: false,
+      defaultSelection: [],
+    },
+  };
+
+  private _currentOptions: CollectionViewAdapterOptions<TDto>;
+
+  /**
+   * Creates a new instance of CollectionViewAdapter
+   * @param options Options for the adapter
+   * @param client The client to use for reading data. If a string is provided, it will be used as the controller name for the ApiReadControllerClient, otherwise the provided client will be used directly.
+   */
+  constructor(options: CollectionViewAdapterOptions<TDto>, client: IReadSelectedClient<any, any> | string) {
+    this._readClient = typeof client === 'string' ? new ApiReadControllerClient<any, any, any>(client) : client;
+
+    this._currentOptions = {
+      ...options,
+      pagination: {
+        ...this._defaultOptions.pagination,
+        ...options.pagination,
+      },
+      ordering: {
+        ...this._defaultOptions.ordering,
+        ...options.ordering,
+      },
+      search: {
+        ...this._defaultOptions.search,
+        ...options.search,
+      },
+      selection: options.selection ?? this._defaultOptions.selection,
+    };
+
+    this._pageIndex = this._currentOptions.pagination?.defaultPageIndex ?? this._pageIndex;
+    this._pageSize = this._currentOptions.pagination?.defaultPageSize ?? this._pageSize;
+    this._search = this._currentOptions.search?.defaultSearch ?? this._search;
+    this._selection = this._currentOptions.selection?.defaultSelection ?? this._selection;
+    this._ordering = this._currentOptions.ordering?.defaultOrdering ?? this._ordering;
+
+    this._scheduleFetch();
+  }
+
+  // #region Getters
+
+  public get isLoading(): boolean {
+    return this._isLoading;
+  }
+
+  public get pageData(): readonly TDto[] | undefined {
+    return this._pageData;
+  }
+
+  public get error(): string | undefined {
+    return this._error;
+  }
+
+  public get totalItemCount(): number {
+    return this._totalItemCount;
+  }
+
+  public get pageIndex(): number {
+    return this._pageIndex;
+  }
+
+  public get pageSize(): number {
+    return this._pageSize;
+  }
+
+  public get selection(): readonly TDto[] {
+    return this._selection;
+  }
+
+  public get search(): ReadSelectedSearchDefinitionDto<TDto> {
+    return this._search;
+  }
+
+  // #endregion
+  // #region Search
+
+  public setSearch(searchDefinition: ReadSelectedSearchDefinitionDto<TDto>): void {
+    this._search = searchDefinition;
+    this._pageIndex = 0;
+    this.searchChanged.dispatchEvent(searchDefinition);
+    this.pageIndexChanged.dispatchEvent(0);
+    this._scheduleFetch();
+  }
+
+  public get ordering(): readonly { path: PropertyPathDto; direction: ReadSelectedOrderingDirection }[] {
+    return this._ordering;
+  }
+
+  // #endregion
+  // #region Ordering
+
+  public setOrdering(propertyPath: PropertyPathDto, orderDirection: ReadSelectedOrderingDirection): void {
+    this._ordering = this._ordering.filter(p => !this._arePropertyPathsEqual(p.path, propertyPath));
+
+    this._ordering = [{ path: propertyPath, direction: orderDirection }, ...this._ordering];
+
+    const maxColumns = this._currentOptions.ordering?.maxOrderingColumns ?? 1;
+    if (this._ordering.length > maxColumns) {
+      this._ordering = this._ordering.slice(0, maxColumns);
+    }
+
+    this._pageIndex = 0;
+    this.orderingChanged.dispatchEvent(this._ordering);
+    this.pageIndexChanged.dispatchEvent(0);
+    this._scheduleFetch();
+  }
+
+  // #endregion
+
+  // #region Pagination
+
+  public setPageIndex(pageIndex: number): void {
+    this._pageIndex = pageIndex;
+    this.pageIndexChanged.dispatchEvent(pageIndex);
+    this._scheduleFetch();
+  }
+
+  public setPageSize(pageSize: number): void {
+    this._pageSize = pageSize;
+    this._pageIndex = 0;
+    this.pageSizeChanged.dispatchEvent(pageSize);
+    this.pageIndexChanged.dispatchEvent(0);
+    this._scheduleFetch();
+  }
+
+  public refreshData(): void {
+    this._scheduleFetch();
+  }
+
+  // #endregion
+  // #region Selection
+
+  private _getItemKey(item: TDto): string {
+    const pk = this._currentOptions.primaryKey;
+    if (typeof pk === 'function') return pk(item);
+    return String((item as Record<string, unknown>)[pk]);
+  }
+
+  private get _selectionEnabled(): 'single' | 'multiple' | false {
+    return this._currentOptions.selection?.enabled ?? false;
+  }
+
+  public selectionToggle(item: TDto): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    const key = this._getItemKey(item);
+    if (this._selection.find(x => this._getItemKey(x) === key)) {
+      this._selection = this._selection.filter(x => this._getItemKey(x) !== key);
+    } else if (this._selectionEnabled === 'single') {
+      this._selection = [item];
+    } else {
+      this._selection = [...this._selection, item];
+    }
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  public selectionAdd(item: TDto): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    const key = this._getItemKey(item);
+    if (this._selection.find(x => this._getItemKey(x) === key)) return;
+    if (this._selectionEnabled === 'single') {
+      this._selection = [item];
+    } else {
+      this._selection = [...this._selection, item];
+    }
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  public selectionRemove(item: TDto): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    const key = this._getItemKey(item);
+    this._selection = this._selection.filter(x => this._getItemKey(x) !== key);
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  public selectionClear(): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    this._selection = [];
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  public isSelected(item: TDto): boolean {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    const key = this._getItemKey(item);
+    return this._selection.some(x => this._getItemKey(x) === key);
+  }
+
+  public selectionAddPage(): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    if (this._selectionEnabled !== 'multiple' || !this._pageData) return;
+    const newItems = this._pageData.filter(item => !this.isSelected(item));
+    if (newItems.length > 0) {
+      this._selection = [...this._selection, ...newItems];
+      this.selectionChanged.dispatchEvent(this._selection);
+    }
+  }
+
+  public selectionRemovePage(): void {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    if (!this._pageData) return;
+    const pageItemKeys = new Set(this._pageData.map(item => this._getItemKey(item)));
+    this._selection = this._selection.filter(item => !pageItemKeys.has(this._getItemKey(item)));
+    this.selectionChanged.dispatchEvent(this._selection);
+  }
+
+  public isSelectedPage(): boolean {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    if (!this._pageData || this._pageData.length === 0) return false;
+    return this._pageData.every(item => this.isSelected(item));
+  }
+
+  public isSomeSelectedPage(): boolean {
+    if (!this._selectionEnabled) throw new Error('Selection is not enabled');
+    if (!this._pageData || this._pageData.length === 0) return false;
+    const selectedCount = this._pageData.filter(item => this.isSelected(item)).length;
+    return selectedCount > 0 && selectedCount < this._pageData.length;
+  }
+
+  // #endregion
+
+  // #region Lifecycle
+
+  public destroy(): void {
+    this._cancelPendingRequests();
+  }
+
+  // #endregion
+
+  // #region Private
+
+  private _scheduleFetch(): void {
+    this._isLoading = true;
+    this.isLoadingChanged.dispatchEvent(true);
+    if (this._fetchTimeout !== undefined) {
+      clearTimeout(this._fetchTimeout);
+    }
+    this._fetchTimeout = setTimeout(() => this._executeFetch(), 50);
+  }
+
+  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._parseOptionsToDefinition();
+      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';
+        this._pageData = [];
+      } else {
+        this._error = undefined;
+        this._pageData = response.result;
+
+        if (response.metadata.totalCount !== undefined) {
+          this._totalItemCount = response.metadata.totalCount;
+        } else {
+          this._totalItemCount = this._calculateTotal(this._pageSize, this._pageIndex, this._pageData.length, this._totalItemCount);
+        }
+      }
+    } 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.pageDataChanged.dispatchEvent(this._pageData);
+        this.errorChanged.dispatchEvent(this._error);
+        this.totalItemCountChanged.dispatchEvent(this._totalItemCount);
+      }
+    }
+  }
+
+  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;
+    }
+  }
+
+  private _parseOptionsToDefinition(): ReadSelectedDefinitionDto<TDto> {
+    const definition: ReadSelectedDefinitionDto<TDto> = {
+      paginationDefinition: {
+        skip: this._pageIndex * this._pageSize,
+        limit: this._pageSize,
+      },
+    };
+
+    if (this._ordering.length > 0) {
+      definition.orderingDefinition = {
+        order: this._ordering.map(o => ({
+          propertyPath: o.path.map(x => toPascalCase(x)) as PropertyPathDto,
+          direction: o.direction,
+        })),
+      };
+    }
+
+    definition.searchDefinition = this._search;
+
+    return definition;
+  }
+
+  private _arePropertyPathsEqual(path1: PropertyPathDto, path2: PropertyPathDto): boolean {
+    if (path1.length !== path2.length) return false;
+    return path1.every((segment, index) => segment === path2[index]);
+  }
+
+  private _calculateTotal(pageSize: number, pageIndex: number, itemsOnCurrentPageCount: number, previousTotal: number): number {
+    if (itemsOnCurrentPageCount === 0) {
+      if (pageSize === 0) return 0;
+      return pageSize * pageIndex;
+    }
+    if (itemsOnCurrentPageCount < pageSize) {
+      return pageSize * pageIndex + itemsOnCurrentPageCount;
+    }
+    return previousTotal;
+  }
+
+  // #endregion
+}

package/src/adapters/index.ts

@@ -1,2 +1,2 @@
-export * from './CollectionViewAdapter';
-export * from './SearchAdapter';
+export * from './collection-view-adapter';
+export * from './search-adapter';