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

package/dist/adapters/collection-view-adapter.d.ts

@@ -0,0 +1,123 @@
+import { PropertyPathDto, ReadSelectedOrderingDirection, ReadSelectedSearchDefinitionDto } from '../data';
+import { IHasObservableProperty, SingularEventTarget } from '../utils';
+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 declare class CollectionViewAdapter<TDto> implements ICollectionViewAdapter<TDto> {
+    readonly isLoadingChanged: SingularEventTarget<boolean>;
+    readonly pageDataChanged: SingularEventTarget<readonly TDto[] | undefined>;
+    readonly errorChanged: SingularEventTarget<string | undefined>;
+    readonly totalItemCountChanged: SingularEventTarget<number>;
+    readonly pageIndexChanged: SingularEventTarget<number>;
+    readonly pageSizeChanged: SingularEventTarget<number>;
+    readonly selectionChanged: SingularEventTarget<readonly TDto[]>;
+    readonly searchChanged: SingularEventTarget<ReadSelectedSearchDefinitionDto<TDto> | undefined>;
+    readonly orderingChanged: SingularEventTarget<readonly {
+        path: PropertyPathDto;
+        direction: ReadSelectedOrderingDirection;
+    }[]>;
+    private _readClient;
+    private _isLoading;
+    private _pageData;
+    private _error;
+    private _totalItemCount;
+    private _pageIndex;
+    private _pageSize;
+    private _selection;
+    private _search;
+    private _ordering;
+    private _currentAbortController?;
+    private _fetchTimeout?;
+    private _defaultOptions;
+    private _currentOptions;
+    /**
+     * 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);
+    get isLoading(): boolean;
+    get pageData(): readonly TDto[] | undefined;
+    get error(): string | undefined;
+    get totalItemCount(): number;
+    get pageIndex(): number;
+    get pageSize(): number;
+    get selection(): readonly TDto[];
+    get search(): ReadSelectedSearchDefinitionDto<TDto>;
+    setSearch(searchDefinition: ReadSelectedSearchDefinitionDto<TDto>): void;
+    get ordering(): readonly {
+        path: PropertyPathDto;
+        direction: ReadSelectedOrderingDirection;
+    }[];
+    setOrdering(propertyPath: PropertyPathDto, orderDirection: ReadSelectedOrderingDirection): void;
+    setPageIndex(pageIndex: number): void;
+    setPageSize(pageSize: number): void;
+    refreshData(): void;
+    private _getItemKey;
+    private get _selectionEnabled();
+    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;
+    private _scheduleFetch;
+    private _executeFetch;
+    private _cancelPendingRequests;
+    private _parseOptionsToDefinition;
+    private _arePropertyPathsEqual;
+    private _calculateTotal;
+}

package/dist/adapters/collection-view-adapter.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/collection-view-adapter.integration.test.js

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { CollectionViewAdapter } from '.';
+import { ReadSelectedComparisonOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '../data';
+import { dateInterval, searchTerm } from '../utils';
+import { ApiReadControllerClient } from '../services';
+describe('CollectionViewAdapter', () => {
+    const options = {
+        primaryKey: 'id',
+        pagination: { defaultPageSize: 5, defaultPageIndex: 0 },
+        ordering: { maxOrderingColumns: 1 },
+    };
+    let adapter;
+    const waitForData = async (adapterInstance, 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('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('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('PetsSlim'));
+        const from = new Date('2017-01-01T00:00:00.000Z');
+        const to = new Date('2017-12-31T00:00:00.000Z');
+        const searchDefinition = dateInterval(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/dist/adapters/collection-view-adapter.js

@@ -0,0 +1,352 @@
+import { ErrorCode, ReadSelectedLogicalOperator, } from '../data';
+import { SingularEventTarget, toPascalCase } from '../utils';
+import { ApiReadControllerClient } from '../services';
+/**
+ * Adapter for managing a collection view of data
+ */
+export class CollectionViewAdapter {
+    // #region Event targets
+    isLoadingChanged = new SingularEventTarget();
+    pageDataChanged = new SingularEventTarget();
+    errorChanged = new SingularEventTarget();
+    totalItemCountChanged = new SingularEventTarget();
+    pageIndexChanged = new SingularEventTarget();
+    pageSizeChanged = new SingularEventTarget();
+    selectionChanged = new SingularEventTarget();
+    searchChanged = new SingularEventTarget();
+    orderingChanged = new SingularEventTarget();
+    // #endregion
+    _readClient;
+    _isLoading = false;
+    _pageData = undefined;
+    _error = undefined;
+    _totalItemCount = 0;
+    _pageIndex = 0;
+    _pageSize = 0;
+    _selection = [];
+    _search = { logicalOperator: ReadSelectedLogicalOperator.And };
+    _ordering = [];
+    _currentAbortController;
+    _fetchTimeout;
+    _defaultOptions = {
+        pagination: {
+            defaultPageSize: 10,
+            defaultPageIndex: 0,
+        },
+        ordering: {
+            maxOrderingColumns: 1,
+            defaultOrdering: undefined,
+        },
+        search: {
+            defaultSearch: undefined,
+        },
+        selection: {
+            enabled: false,
+            defaultSelection: [],
+        },
+    };
+    _currentOptions;
+    /**
+     * 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, client) {
+        this._readClient = typeof client === 'string' ? new ApiReadControllerClient(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
+    get isLoading() {
+        return this._isLoading;
+    }
+    get pageData() {
+        return this._pageData;
+    }
+    get error() {
+        return this._error;
+    }
+    get totalItemCount() {
+        return this._totalItemCount;
+    }
+    get pageIndex() {
+        return this._pageIndex;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    get selection() {
+        return this._selection;
+    }
+    get search() {
+        return this._search;
+    }
+    // #endregion
+    // #region Search
+    setSearch(searchDefinition) {
+        this._search = searchDefinition;
+        this._pageIndex = 0;
+        this.searchChanged.dispatchEvent(searchDefinition);
+        this.pageIndexChanged.dispatchEvent(0);
+        this._scheduleFetch();
+    }
+    get ordering() {
+        return this._ordering;
+    }
+    // #endregion
+    // #region Ordering
+    setOrdering(propertyPath, orderDirection) {
+        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
+    setPageIndex(pageIndex) {
+        this._pageIndex = pageIndex;
+        this.pageIndexChanged.dispatchEvent(pageIndex);
+        this._scheduleFetch();
+    }
+    setPageSize(pageSize) {
+        this._pageSize = pageSize;
+        this._pageIndex = 0;
+        this.pageSizeChanged.dispatchEvent(pageSize);
+        this.pageIndexChanged.dispatchEvent(0);
+        this._scheduleFetch();
+    }
+    refreshData() {
+        this._scheduleFetch();
+    }
+    // #endregion
+    // #region Selection
+    _getItemKey(item) {
+        const pk = this._currentOptions.primaryKey;
+        if (typeof pk === 'function')
+            return pk(item);
+        return String(item[pk]);
+    }
+    get _selectionEnabled() {
+        return this._currentOptions.selection?.enabled ?? false;
+    }
+    selectionToggle(item) {
+        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);
+    }
+    selectionAdd(item) {
+        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);
+    }
+    selectionRemove(item) {
+        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);
+    }
+    selectionClear() {
+        if (!this._selectionEnabled)
+            throw new Error('Selection is not enabled');
+        this._selection = [];
+        this.selectionChanged.dispatchEvent(this._selection);
+    }
+    isSelected(item) {
+        if (!this._selectionEnabled)
+            throw new Error('Selection is not enabled');
+        const key = this._getItemKey(item);
+        return this._selection.some(x => this._getItemKey(x) === key);
+    }
+    selectionAddPage() {
+        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);
+        }
+    }
+    selectionRemovePage() {
+        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);
+    }
+    isSelectedPage() {
+        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));
+    }
+    isSomeSelectedPage() {
+        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
+    destroy() {
+        this._cancelPendingRequests();
+    }
+    // #endregion
+    // #region Private
+    _scheduleFetch() {
+        this._isLoading = true;
+        this.isLoadingChanged.dispatchEvent(true);
+        if (this._fetchTimeout !== undefined) {
+            clearTimeout(this._fetchTimeout);
+        }
+        this._fetchTimeout = setTimeout(() => this._executeFetch(), 50);
+    }
+    async _executeFetch() {
+        let abortController;
+        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) {
+            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);
+            }
+        }
+    }
+    _cancelPendingRequests() {
+        if (this._fetchTimeout !== undefined) {
+            clearTimeout(this._fetchTimeout);
+            this._fetchTimeout = undefined;
+        }
+        if (this._currentAbortController) {
+            try {
+                this._currentAbortController.abort();
+            }
+            catch {
+                // Ignore abort errors
+            }
+            this._currentAbortController = undefined;
+        }
+    }
+    _parseOptionsToDefinition() {
+        const definition = {
+            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)),
+                    direction: o.direction,
+                })),
+            };
+        }
+        definition.searchDefinition = this._search;
+        return definition;
+    }
+    _arePropertyPathsEqual(path1, path2) {
+        if (path1.length !== path2.length)
+            return false;
+        return path1.every((segment, index) => segment === path2[index]);
+    }
+    _calculateTotal(pageSize, pageIndex, itemsOnCurrentPageCount, previousTotal) {
+        if (itemsOnCurrentPageCount === 0) {
+            if (pageSize === 0)
+                return 0;
+            return pageSize * pageIndex;
+        }
+        if (itemsOnCurrentPageCount < pageSize) {
+            return pageSize * pageIndex + itemsOnCurrentPageCount;
+        }
+        return previousTotal;
+    }
+}

package/dist/adapters/index.d.ts

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

package/dist/adapters/index.js

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