@intellegens/cornerstone-client 0.0.0-experimental-upgrade-20260302-1

package/dist/utils/search/index.js

@@ -0,0 +1,106 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, } from '../../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all ReadSelectedSearchPropertyDefinitionDto property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - propertyName: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export function condition(logicalOperator, ...conditions) {
+    return {
+        logicalOperator: logicalOperator,
+        propertyCriteria: conditions.map(condition => ({
+            propertyName: toPascalCase(condition.propertyName),
+            comparisonOperator: condition.operator,
+            valueType: condition.valueType,
+            value: condition.value,
+        })),
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.And,
+        searches: definitions,
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.Or,
+        searches: definitions,
+    };
+}
+/**
+ * Preset implementation for filtering by searchTerm. String types will search by provided `textSearchableProperties` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchableProperties`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export function searchTerm(searchTerm, textSearchableProperties, numericSearchableProperties) {
+    let comparisonOperator;
+    let valueType;
+    let searchableProperties;
+    let searchValue;
+    try {
+        const numericValue = parseInt(searchTerm);
+        if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
+            comparisonOperator = ReadSelectedComparisonOperator.Equal;
+            valueType = ReadSelectedPropertyType.Int;
+            searchableProperties = numericSearchableProperties;
+            searchValue = numericValue;
+        }
+        else {
+            comparisonOperator = ReadSelectedComparisonOperator.Contains;
+            valueType = ReadSelectedPropertyType.String;
+            searchableProperties = textSearchableProperties;
+            searchValue = searchTerm;
+        }
+        const searchConditions = searchableProperties.map(propertyName => ({
+            propertyName: toPascalCase(propertyName),
+            operator: comparisonOperator,
+            value: searchValue,
+            valueType: valueType,
+        }));
+        return condition(ReadSelectedLogicalOperator.Or, ...searchConditions);
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchableProperty`.
+ */
+export function dateInterval(fromDate, toDate, fromDateComparisonOperator, toDateComparisonOperator, valueType, searchableProperty) {
+    try {
+        if (!(valueType === ReadSelectedPropertyType.DateOnly ||
+            valueType === ReadSelectedPropertyType.DateTime ||
+            valueType === ReadSelectedPropertyType.DateTimeOffset)) {
+            return;
+        }
+        return condition(ReadSelectedLogicalOperator.And, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: fromDateComparisonOperator,
+            value: fromDate,
+            valueType: valueType,
+        }, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: toDateComparisonOperator,
+            value: toDate,
+            valueType: valueType,
+        });
+    }
+    catch {
+        return;
+    }
+}
+export function toPascalCase(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@intellegens/cornerstone-client",
+  "version": "0.0.0-experimental-upgrade-20260302-1",
+  "private": false,
+  "publishable": true,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "author": "Intellegens",
+  "license": "MIT",
+  "description": "",
+  "keywords": [
+    "intellegens",
+    "cornerstone"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.3.1",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "express": "^5.2.1",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1",
+    "rxjs": "~7.8.2",
+    "tsc-alias": "^1.8.16",
+    "typescript-eslint": "^8.56.1",
+    "vite": "7.3.1",
+    "vitest": "^4.0.18",
+    "zod": "^3.25.76"
+  },
+  "dependencies": {
+    "http-proxy-middleware": "^3.0.5",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "clean": "pnpx rimraf '{dist}'",
+    "test": "vitest run --passWithNoTests",
+    "test:unit": "vitest run --project unit --passWithNoTests",
+    "test:integration": "vitest run --project integration --passWithNoTests",
+    "coverage": "vitest run --coverage",
+    "build": "pnpm run clean && tsc && tsc-alias",
+    "start": "pnpm run build && pnpx vite build && pnpx tsx ./demo"
+  }
+}

package/src/adapters/CollectionViewAdapter/index.integration.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { CollectionViewAdapter, CollectionViewAdapterOptions } from '.';
+import { ReadSelectedComparisonOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '@/data';
+import { dateInterval, searchTerm } from '@/utils';
+
+type TestDto = { id: number; name: string; dateOfBirth: string; rowVersion: string };
+
+describe('CollectionViewAdapter', () => {
+  let data: TestDto[] | undefined;
+  let error: string | undefined;
+  let isLoading: boolean | undefined;
+
+  const callback = vi.fn((_isLoading: boolean, _data: TestDto[] | undefined, _error: string | undefined) => {
+    isLoading = _isLoading;
+    data = _data;
+    error = _error;
+  });
+
+  const options: CollectionViewAdapterOptions<TestDto> = {
+    pagination: { useTotalItemCount: true, pageSize: 5, pageNumber: 1 },
+    ordering: { maxActiveOrderingColumns: 1, orderByPaths: [] },
+    search: { textSearchableProperties: ['name'], numericSearchableProperties: ['id'] },
+  };
+
+  let adapter: CollectionViewAdapter<number, TestDto, TestDto>;
+
+  const waitForData = async (timeout = 2000) => {
+    const start = Date.now();
+    while (isLoading !== false && Date.now() - start < timeout) {
+      await new Promise(res => setTimeout(res, 50));
+    }
+  };
+
+  const resetAdapterState = () => {
+    data = undefined;
+    error = undefined;
+    isLoading = undefined;
+  };
+
+  beforeEach(() => {
+    data = undefined;
+    error = undefined;
+    isLoading = undefined;
+  });
+
+  it('callback returns correct loading status and collection data', async () => {
+    options.pagination.useTotalItemCount = true;
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+
+    expect(callback).toHaveBeenNthCalledWith(1, true, undefined, undefined);
+    expect(callback).toHaveBeenLastCalledWith(false, data, undefined);
+    expect(data).toBeDefined();
+  });
+
+  it('adapter options set correct ordering', async () => {
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['name'],
+        orderDirection: 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('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBeGreaterThan(0);
+    for (const item of data!) {
+      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('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBe(1);
+    for (const item of data!) {
+      expect(item.id).toBe(10000001);
+    }
+  });
+
+  it('applies date range filter from-to on the same date type property', async () => {
+    adapter = new CollectionViewAdapter('PetsSlim', callback, options);
+    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();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+  });
+
+  it('applies pagination: page size and jump to page set skip/limit', async () => {
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    const firstPageData = data;
+    resetAdapterState();
+    adapter.jumpToPage(3);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBe(5);
+    // Check that data is different from first page
+    expect(data).not.toEqual(firstPageData);
+  });
+
+  it('calculates total when useTotalItemCount=false and last page is partial', async () => {
+    options.pagination.useTotalItemCount = false;
+    options.pagination.pageSize = 10;
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    const firstPageData = data;
+    resetAdapterState();
+    adapter.jumpToPage(2);
+    await waitForData();
+
+    expect(adapter.totalItemCount).toBe(firstPageData!.length + data!.length);
+  });
+
+  it('setOrdering correctly handles PropertyPathDto array comparison and limits columns', async () => {
+    options.ordering.maxActiveOrderingColumns = 2;
+    // Add first ordering
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['name'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // Add second ordering
+    adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Ascending);
+    await waitForData();
+
+    // Should have both orderings, with 'id' first (most recent)
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['id'],
+        orderDirection: ReadSelectedOrderingDirection.Ascending,
+      },
+      {
+        orderByPath: ['name'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // // Add third ordering - should remove the oldest one (name)
+    adapter.setOrdering(['description'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['description'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+      {
+        orderByPath: ['id'],
+        orderDirection: ReadSelectedOrderingDirection.Ascending,
+      },
+    ]);
+  });
+});