@intellegens/cornerstone-client 0.0.9999-alpha-16 → 0.0.9999-alpha-18

package/dist/adapters/SearchAdapter/index.d.ts

@@ -0,0 +1,32 @@
+import { IIdentifiable } from '../../data';
+export declare class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
+    private _readClient;
+    private _isLoading;
+    private _searchResults;
+    private _totalItemCount;
+    private _searchTerm;
+    private _selectedType?;
+    private _lastInputSearchTerm?;
+    private _lastInputType?;
+    private _searchTriggerLength;
+    private _searchTriggerDelay;
+    private _triggeredSearch;
+    private _selection;
+    private _multiSelectMode;
+    constructor(controllerName: string, multiSelect: boolean, searchTriggerLength: number, searchTriggerDelay: number, dataChangedCallback: (isLoading: boolean, data: TDto[] | undefined, error: string | undefined) => void);
+    getSelectedItems(): TDto[];
+    getSelectedType(): string | undefined;
+    getSelectMode(): boolean;
+    addToSelection(item: TDto): void;
+    removeFromSelection(item: TDto): void;
+    search(searchTerm: string, type?: string): Promise<TDto[]>;
+    clearSearch(): void;
+    private readonly _dataChangedCallback;
+    private _fetchCurrentPageDataTimeout?;
+    private _fetchCurrentPageDataPromises;
+    private _currentAbortController?;
+    private _fetchCurrentPageData;
+    private _fetchCurrentPageDataDebounced;
+    private _parseToSearchDefinition;
+    private _sortByName;
+}

package/dist/adapters/SearchAdapter/index.js

@@ -0,0 +1,234 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType, } from '../../data';
+import { ApiReadControllerClient } from '../../services';
+export class SearchAdapter {
+    _readClient;
+    _isLoading = false;
+    _searchResults = [];
+    _totalItemCount = 1000;
+    _searchTerm = '';
+    _selectedType;
+    _lastInputSearchTerm;
+    _lastInputType;
+    _searchTriggerLength;
+    _searchTriggerDelay;
+    _triggeredSearch = false;
+    _selection;
+    _multiSelectMode = true;
+    constructor(controllerName, multiSelect, searchTriggerLength, searchTriggerDelay, dataChangedCallback) {
+        this._readClient = new ApiReadControllerClient(controllerName);
+        this._searchTriggerLength = searchTriggerLength;
+        this._searchTriggerDelay = searchTriggerDelay;
+        this._multiSelectMode = multiSelect;
+        this._dataChangedCallback = dataChangedCallback;
+        this._fetchCurrentPageData();
+    }
+    //#region Public methods
+    getSelectedItems() {
+        return this._selection || [];
+    }
+    getSelectedType() {
+        return this._selectedType;
+    }
+    getSelectMode() {
+        return this._multiSelectMode;
+    }
+    addToSelection(item) {
+        if (!this._selection) {
+            this._selection = [];
+        }
+        if (this._multiSelectMode) {
+            if (!this._selection.find(s => s.id === item.id)) {
+                this._selection.push(item);
+            }
+        }
+        else {
+            // single-select mode - replace the item and return the old one to shown results
+            if (this._selection.length > 0) {
+                this._searchResults = [...this._searchResults, ...this._selection];
+            }
+            this._selection = [item];
+        }
+        this._searchResults = this._searchResults.filter(d => d.id !== item.id);
+        this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+    }
+    removeFromSelection(item) {
+        if (!this._selection) {
+            this._selection = [];
+            return;
+        }
+        this._selection = this._selection.filter(s => s.id !== item.id);
+        this._searchResults = [...this._searchResults, item];
+        this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+    }
+    search(searchTerm, type) {
+        if (this._lastInputSearchTerm === searchTerm && this._lastInputType === type) {
+            // no changes to search condition
+            return Promise.resolve(this._searchResults);
+        }
+        this._lastInputSearchTerm = searchTerm;
+        this._lastInputType = type;
+        if (type !== undefined && type !== null) {
+            // has type selected -> single-select mode
+            if (searchTerm.length >= this._searchTriggerLength) {
+                // include search by string
+                this._searchTerm = searchTerm;
+                this._selectedType = type;
+                this._triggeredSearch = true;
+                return this._fetchCurrentPageData();
+            }
+            else {
+                // search all by type
+                this._searchTerm = '';
+                this._selectedType = type;
+                this._triggeredSearch = true;
+                return this._fetchCurrentPageData();
+            }
+        }
+        else if (searchTerm.length >= this._searchTriggerLength) {
+            // no type involved -> search by input string only
+            this._searchTerm = searchTerm;
+            this._selectedType = type;
+            this._triggeredSearch = true;
+            return this._fetchCurrentPageData();
+        }
+        else if (this._triggeredSearch && searchTerm.length < this._searchTriggerLength) {
+            // user has deleted part of the search term after having seen some results - fetch everything to show
+            this._searchTerm = '';
+            this._selectedType = type;
+            return this._fetchCurrentPageData();
+        }
+        else {
+            // no type, searchTerm < this._searchTriggerLength
+            return Promise.resolve([]);
+        }
+    }
+    clearSearch() {
+        this._selection = [];
+        this._selectedType = undefined;
+        this._searchTerm = '';
+        this._dataChangedCallback(this._isLoading, [], undefined);
+        this._triggeredSearch = false;
+    }
+    //#endregion
+    //#region Private methods
+    _dataChangedCallback;
+    _fetchCurrentPageDataTimeout;
+    _fetchCurrentPageDataPromises = [];
+    _currentAbortController;
+    async _fetchCurrentPageData() {
+        return new Promise((resolve, reject) => {
+            this._fetchCurrentPageDataPromises.push({ resolve, reject });
+            if (this._fetchCurrentPageDataTimeout !== undefined) {
+                clearTimeout(this._fetchCurrentPageDataTimeout);
+            }
+            this._fetchCurrentPageDataTimeout = setTimeout(async () => {
+                try {
+                    const result = await this._fetchCurrentPageDataDebounced();
+                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    for (const p of promises)
+                        p.resolve(result);
+                }
+                catch (err) {
+                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    for (const p of promises)
+                        p.reject(err);
+                }
+            }, this._searchTriggerDelay);
+        });
+    }
+    async _fetchCurrentPageDataDebounced() {
+        this._isLoading = true;
+        this._dataChangedCallback(this._isLoading, undefined, undefined);
+        let abortController;
+        let caughtError;
+        try {
+            // Cancel any in-flight request before starting a new one
+            if (this._currentAbortController) {
+                try {
+                    this._currentAbortController.abort();
+                }
+                catch {
+                    // Ignore abort errors as they are expected when debouncing
+                }
+            }
+            abortController = new AbortController();
+            this._currentAbortController = abortController;
+            const definition = this._parseToSearchDefinition();
+            const response = await this._readClient.readSelected(definition, abortController?.signal);
+            if (!response.ok) {
+                throw response.error;
+            }
+            // Filter out selected items from results
+            const selectedIds = new Set((this._selection || []).map(item => item.id));
+            this._searchResults = response.result.filter(item => !selectedIds.has(item.id));
+            return this._searchResults;
+        }
+        catch (error) {
+            caughtError = error;
+            // Do not log abort-related errors as they are expected when debouncing
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return Promise.reject(error);
+            }
+            console.error('Error fetching data:', error);
+            return Promise.reject(error);
+        }
+        finally {
+            this._isLoading = false;
+            let errorName;
+            if (caughtError && !(caughtError instanceof DOMException && caughtError.name === 'AbortError')) {
+                errorName = caughtError instanceof Error ? caughtError.name : undefined;
+            }
+            this._dataChangedCallback(this._isLoading, this._searchResults, errorName);
+            // Clear the abort controller only if it belongs to this request (avoid racing with a newer one)
+            if (abortController && this._currentAbortController === abortController) {
+                this._currentAbortController = undefined;
+            }
+        }
+    }
+    _parseToSearchDefinition() {
+        const definition = {
+            paginationDefinition: {
+                skip: 0,
+                limit: this._totalItemCount,
+            },
+        };
+        // Apply ordering
+        definition.orderingDefinition = {
+            order: [
+                {
+                    propertyPath: ['Name'],
+                    direction: ReadSelectedOrderingDirection.Ascending,
+                },
+            ],
+        };
+        // Apply search
+        const propertyCriteria = [
+            {
+                propertyName: 'Name',
+                comparisonOperator: ReadSelectedComparisonOperator.IContains,
+                valueType: ReadSelectedPropertyType.String,
+                value: this._searchTerm,
+            },
+        ];
+        if (this._selectedType !== undefined) {
+            propertyCriteria.push({
+                propertyName: 'Type',
+                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                valueType: ReadSelectedPropertyType.String,
+                value: this._selectedType,
+            });
+        }
+        definition.searchDefinition = {
+            logicalOperator: ReadSelectedLogicalOperator.And,
+            propertyCriteria: propertyCriteria,
+        };
+        return definition;
+    }
+    _sortByName(array) {
+        return array.sort((a, b) => {
+            const nameA = a.name?.toLowerCase() || '';
+            const nameB = b.name?.toLowerCase() || '';
+            return nameA.localeCompare(nameB);
+        });
+    }
+}

package/dist/adapters/index.d.ts

@@ -1 +1,2 @@
 export * from './CollectionViewAdapter';
+export * from './SearchAdapter';

package/dist/adapters/index.js

@@ -1 +1,2 @@
 export * from './CollectionViewAdapter';
+export * from './SearchAdapter';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellegens/cornerstone-client",
-  "version": "0.0.9999-alpha-16",
+  "version": "0.0.9999-alpha-18",
   "private": false,
   "publishable": true,
   "main": "./dist/index.js",
@@ -15,6 +15,7 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.21.0",
+    "@jest/globals": "^30.2.0",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.13.9",
@@ -25,6 +26,7 @@
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "prettier": "^3.5.2",
+    "rxjs": "~7.8.0",
     "ts-jest": "^29.1.2",
     "tsc-alias": "^1.8.11",
     "typescript-eslint": "^8.26.0",

package/src/adapters/SearchAdapter/index.ts

@@ -0,0 +1,289 @@
+import {
+  IIdentifiable,
+  ReadSelectedComparisonOperator,
+  ReadSelectedDefinitionDto,
+  ReadSelectedLogicalOperator,
+  ReadSelectedOrderingDirection,
+  ReadSelectedPropertyType,
+  ReadSelectedSearchDefinitionDto,
+  ReadSelectedSearchPropertyDefinitionDto,
+} from '@data';
+import { ApiReadControllerClient } from '@services';
+
+export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
+  private _readClient!: ApiReadControllerClient<TKey, TDto, TDto>;
+
+  private _isLoading = false;
+  private _searchResults: TDto[] = [];
+  private _totalItemCount: number = 1000;
+
+  private _searchTerm: string = '';
+  private _selectedType?: string;
+  private _lastInputSearchTerm?: string;
+  private _lastInputType?: string;
+
+  private _searchTriggerLength!: number;
+  private _searchTriggerDelay!: number;
+  private _triggeredSearch = false;
+
+  private _selection!: TDto[];
+  private _multiSelectMode = true;
+
+  constructor(
+    controllerName: string,
+    multiSelect: boolean,
+    searchTriggerLength: number,
+    searchTriggerDelay: number,
+    dataChangedCallback: (isLoading: boolean, data: TDto[] | undefined, error: string | undefined) => void,
+  ) {
+    this._readClient = new ApiReadControllerClient<TKey, TDto, TDto>(controllerName);
+
+    this._searchTriggerLength = searchTriggerLength;
+    this._searchTriggerDelay = searchTriggerDelay;
+    this._multiSelectMode = multiSelect;
+
+    this._dataChangedCallback = dataChangedCallback;
+    this._fetchCurrentPageData();
+  }
+
+  //#region Public methods
+
+  public getSelectedItems(): TDto[] {
+    return this._selection || [];
+  }
+
+  public getSelectedType(): string | undefined {
+    return this._selectedType;
+  }
+
+  public getSelectMode(): boolean {
+    return this._multiSelectMode;
+  }
+
+  public addToSelection(item: TDto): void {
+    if (!this._selection) {
+      this._selection = [];
+    }
+
+    if (this._multiSelectMode) {
+      if (!this._selection.find(s => s.id === item.id)) {
+        this._selection.push(item);
+      }
+    } else {
+      // single-select mode - replace the item and return the old one to shown results
+      if (this._selection.length > 0) {
+        this._searchResults = [...this._searchResults, ...this._selection];
+      }
+      this._selection = [item];
+    }
+    this._searchResults = this._searchResults.filter(d => d.id !== item.id);
+    this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+  }
+
+  public removeFromSelection(item: TDto): void {
+    if (!this._selection) {
+      this._selection = [];
+      return;
+    }
+
+    this._selection = this._selection.filter(s => s.id !== item.id);
+    this._searchResults = [...this._searchResults, item];
+
+    this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+  }
+
+  public search(searchTerm: string, type?: string) {
+    if (this._lastInputSearchTerm === searchTerm && this._lastInputType === type) {
+      // no changes to search condition
+      return Promise.resolve(this._searchResults);
+    }
+
+    this._lastInputSearchTerm = searchTerm;
+    this._lastInputType = type;
+
+    if (type !== undefined && type !== null) {
+      // has type selected -> single-select mode
+      if (searchTerm.length >= this._searchTriggerLength) {
+        // include search by string
+        this._searchTerm = searchTerm;
+        this._selectedType = type;
+        this._triggeredSearch = true;
+        return this._fetchCurrentPageData();
+      } else {
+        // search all by type
+        this._searchTerm = '';
+        this._selectedType = type;
+        this._triggeredSearch = true;
+        return this._fetchCurrentPageData();
+      }
+    } else if (searchTerm.length >= this._searchTriggerLength) {
+      // no type involved -> search by input string only
+      this._searchTerm = searchTerm;
+      this._selectedType = type;
+      this._triggeredSearch = true;
+      return this._fetchCurrentPageData();
+    } else if (this._triggeredSearch && searchTerm.length < this._searchTriggerLength) {
+      // user has deleted part of the search term after having seen some results - fetch everything to show
+      this._searchTerm = '';
+      this._selectedType = type;
+      return this._fetchCurrentPageData();
+    } else {
+      // no type, searchTerm < this._searchTriggerLength
+      return Promise.resolve([]);
+    }
+  }
+
+  public clearSearch(): void {
+    this._selection = [];
+    this._selectedType = undefined;
+    this._searchTerm = '';
+    this._dataChangedCallback(this._isLoading, [], undefined);
+    this._triggeredSearch = false;
+  }
+
+  //#endregion
+
+  //#region Private methods
+
+  private readonly _dataChangedCallback!: (isLoading: boolean, data: TDto[] | undefined, errorMessage: string | undefined) => void;
+
+  private _fetchCurrentPageDataTimeout?: any;
+
+  private _fetchCurrentPageDataPromises: {
+    resolve: (value: TDto[] | PromiseLike<TDto[]>) => void;
+    reject: (reason?: unknown) => void;
+  }[] = [];
+
+  private _currentAbortController?: AbortController;
+
+  private async _fetchCurrentPageData(): Promise<TDto[]> {
+    return new Promise((resolve, reject) => {
+      this._fetchCurrentPageDataPromises.push({ resolve, reject });
+      if (this._fetchCurrentPageDataTimeout !== undefined) {
+        clearTimeout(this._fetchCurrentPageDataTimeout);
+      }
+      this._fetchCurrentPageDataTimeout = setTimeout(async () => {
+        try {
+          const result = await this._fetchCurrentPageDataDebounced();
+          const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+          for (const p of promises) p.resolve(result);
+        } catch (err) {
+          const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+          for (const p of promises) p.reject(err);
+        }
+      }, this._searchTriggerDelay);
+    });
+  }
+
+  private async _fetchCurrentPageDataDebounced(): Promise<TDto[]> {
+    this._isLoading = true;
+    this._dataChangedCallback(this._isLoading, undefined, undefined);
+    let abortController: AbortController | undefined;
+    let caughtError: unknown;
+
+    try {
+      // Cancel any in-flight request before starting a new one
+      if (this._currentAbortController) {
+        try {
+          this._currentAbortController.abort();
+        } catch {
+          // Ignore abort errors as they are expected when debouncing
+        }
+      }
+      abortController = new AbortController();
+      this._currentAbortController = abortController;
+
+      const definition = this._parseToSearchDefinition();
+      const response = await this._readClient.readSelected(definition, abortController?.signal);
+
+      if (!response.ok) {
+        throw response.error;
+      }
+
+      // Filter out selected items from results
+      const selectedIds = new Set((this._selection || []).map(item => item.id));
+      this._searchResults = response.result.filter(item => !selectedIds.has(item.id));
+
+      return this._searchResults;
+    } catch (error: unknown) {
+      caughtError = error;
+
+      // Do not log abort-related errors as they are expected when debouncing
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        return Promise.reject(error);
+      }
+
+      console.error('Error fetching data:', error);
+      return Promise.reject(error);
+    } finally {
+      this._isLoading = false;
+
+      let errorName: string | undefined;
+      if (caughtError && !(caughtError instanceof DOMException && caughtError.name === 'AbortError')) {
+        errorName = caughtError instanceof Error ? caughtError.name : undefined;
+      }
+      this._dataChangedCallback(this._isLoading, this._searchResults, errorName);
+
+      // Clear the abort controller only if it belongs to this request (avoid racing with a newer one)
+
+      if (abortController && this._currentAbortController === abortController) {
+        this._currentAbortController = undefined;
+      }
+    }
+  }
+
+  private _parseToSearchDefinition(): ReadSelectedDefinitionDto<TDto> {
+    const definition: ReadSelectedDefinitionDto<TDto> = {
+      paginationDefinition: {
+        skip: 0,
+        limit: this._totalItemCount,
+      },
+    };
+
+    // Apply ordering
+    definition.orderingDefinition = {
+      order: [
+        {
+          propertyPath: ['Name'],
+          direction: ReadSelectedOrderingDirection.Ascending,
+        },
+      ],
+    };
+
+    // Apply search
+    const propertyCriteria: ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto>[] = [
+      {
+        propertyName: 'Name' as any,
+        comparisonOperator: ReadSelectedComparisonOperator.IContains,
+        valueType: ReadSelectedPropertyType.String,
+        value: this._searchTerm,
+      },
+    ];
+
+    if (this._selectedType !== undefined) {
+      propertyCriteria.push({
+        propertyName: 'Type',
+        comparisonOperator: ReadSelectedComparisonOperator.Equal,
+        valueType: ReadSelectedPropertyType.String,
+        value: this._selectedType,
+      } as ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto>);
+    }
+
+    definition.searchDefinition = {
+      logicalOperator: ReadSelectedLogicalOperator.And,
+      propertyCriteria: propertyCriteria,
+    } as ReadSelectedSearchDefinitionDto<TDto>;
+
+    return definition;
+  }
+
+  private _sortByName(array: TDto[]): TDto[] {
+    return array.sort((a, b) => {
+      const nameA = (a as any).name?.toLowerCase() || '';
+      const nameB = (b as any).name?.toLowerCase() || '';
+      return nameA.localeCompare(nameB);
+    });
+  }
+
+  //#endregion
+}

package/src/adapters/index.ts

@@ -1 +1,2 @@
 export * from './CollectionViewAdapter';
+export * from './SearchAdapter';

package/tests/CollectionViewAdapter.test.ts

@@ -87,7 +87,7 @@ describe('CollectionViewAdapter', () => {
     };
 
     const callback = jest.fn();
-    const adapter = new CollectionViewAdapter<number, TestDto>('ControllerName', callback, options);
+    const adapter = new CollectionViewAdapter<number, TestDto, TestDto>('ControllerName', callback, options);
 
     return { adapter, callback };
   };