@intellegens/cornerstone-client 0.0.9999-alpha-8 → 0.0.9999-alpha-10

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './search';

package/src/utils/result/index.ts

@@ -0,0 +1,25 @@
+type TResultBase = { readonly ok: boolean };
+
+/**
+ * Represents a result of an operation.
+ * It can be either a success or an error.
+ */
+export type Result<TSuccess extends TResultBase, TError extends TResultBase> = TSuccess | TError;
+
+/**
+ * Creates a success result from the given argument.
+ * @param arg - The argument to create a success result from.
+ * @returns A success result.
+ */
+export function ok<TSuccess extends TResultBase, TError extends TResultBase>(arg?: Omit<TSuccess, 'ok'>): Result<TSuccess, TError> {
+    return {ok: true, ...arg} as TSuccess;
+}
+
+/**
+ * Creates an error result from the given argument.
+ * @param arg - The argument to create an error result from.
+ * @returns An error result.
+ */
+export function fail<TSuccess extends TResultBase, TError extends TResultBase>(arg: Omit<TError, 'ok'>): Result<TSuccess, TError> {
+    return {ok: false, ...arg} as TError;
+}

package/src/utils/search/index.ts

@@ -0,0 +1,150 @@
+import {
+  ReadSelectedComparisonOperator,
+  ReadSelectedLogicalOperator,
+  ReadSelectedPropertyType,
+  ReadSelectedSearchDefinitionDto,
+  ReadSelectedSearchPropertyDefinitionDto,
+} 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<T>(
+  logicalOperator: ReadSelectedLogicalOperator,
+  ...conditions: Array<{
+    propertyName: keyof T;
+    operator: ReadSelectedComparisonOperator;
+    value: unknown;
+    valueType: ReadSelectedPropertyType;
+  }>
+): ReadSelectedSearchDefinitionDto<T> {
+  return {
+    logicalOperator: logicalOperator,
+    propertyCriteria: conditions.map(
+      condition =>
+        ({
+          propertyName: toPascalCase(condition.propertyName),
+          comparisonOperator: condition.operator,
+          valueType: condition.valueType,
+          value: condition.value,
+        }) as ReadSelectedSearchPropertyDefinitionDto<T, keyof T>,
+    ),
+  };
+}
+
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T> {
+  return {
+    logicalOperator: ReadSelectedLogicalOperator.And,
+    searches: definitions,
+  };
+}
+
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T> {
+  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<T>(
+  searchTerm: string,
+  textSearchableProperties: (keyof T)[],
+  numericSearchableProperties: (keyof T)[],
+): void | ReadSelectedSearchDefinitionDto<T> {
+  let comparisonOperator: ReadSelectedComparisonOperator;
+  let valueType: ReadSelectedPropertyType;
+  let searchableProperties: (keyof T)[];
+  let searchValue: string | number;
+  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<T>(
+  fromDate: Date,
+  toDate: Date,
+  fromDateComparisonOperator: ReadSelectedComparisonOperator,
+  toDateComparisonOperator: ReadSelectedComparisonOperator,
+  valueType: ReadSelectedPropertyType,
+  searchableProperty: keyof T,
+): void | ReadSelectedSearchDefinitionDto<T> {
+  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<T>(str: keyof T): keyof T {
+  if (typeof str !== 'string') {
+    return str;
+  }
+
+  return (str.charAt(0).toUpperCase() + str.slice(1)) as keyof T;
+}

package/tests/ApiClients.test.ts

@@ -0,0 +1,284 @@
+import { ApiReadControllerClient, ApiCrudControllerClient, UserManagementControllerClient, IHttpService, HttpResponse } from '../src';
+import { jest } from '@jest/globals';
+import { ReadSelectedLogicalOperator } from '../src/data';
+
+// Mock HTTP Service for testing
+class MockHttpService implements IHttpService {
+  private mockResponses = new Map<string, HttpResponse>();
+  public requestLog: Array<{ url: string; config?: any }> = [];
+
+  setMockResponse(url: string, response: HttpResponse) {
+    this.mockResponses.set(url, response);
+  }
+
+  clearMockResponses() {
+    this.mockResponses.clear();
+    this.requestLog = [];
+  }
+
+  async request<T = any>(url: string, config?: any): Promise<HttpResponse<T>> {
+    this.requestLog.push({ url, config });
+
+    const mockResponse = this.mockResponses.get(url);
+    if (mockResponse) {
+      return mockResponse as HttpResponse<T>;
+    }
+
+    // Default successful response
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      json: async () => ({ success: true }) as T,
+      text: async () => '{"success":true}',
+    };
+  }
+}
+
+// Mock API Initialization Service
+jest.unstable_mockModule('../src/services/api/ApiInitializationService/index', () => ({
+  apiInitializationService: {
+    getApiUrl: jest.fn((...paths: string[]) => Promise.resolve(`https://api.example.com${paths.join('')}`)),
+  },
+}));
+
+describe('API Clients with HTTP Service Abstraction', () => {
+  let mockHttpService: MockHttpService;
+
+  beforeEach(() => {
+    mockHttpService = new MockHttpService();
+    jest.clearAllMocks();
+  });
+
+  describe('ApiReadControllerClient', () => {
+    let client: ApiReadControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new ApiReadControllerClient('/api/test', mockHttpService);
+    });
+
+    it('should use injected HTTP service for readAll', async () => {
+      const mockData = [
+        { id: 1, name: 'Test' },
+        { id: 2, name: 'Test2' },
+      ];
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readAll();
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadAll');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for readSingle', async () => {
+      const mockData = { id: 1, name: 'Test' };
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSingle?id=1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readSingle(1);
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSingle?id=1');
+    });
+
+    it('should use injected HTTP service for readSelected', async () => {
+      const mockData = [{ id: 1, name: 'Test' }];
+      const definition = {
+        searchDefinition: {
+          searches: [],
+          logicalOperator: ReadSelectedLogicalOperator.And,
+        },
+      };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSelected', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readSelected(definition);
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSelected');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
+      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(definition));
+    });
+
+    it('should handle HTTP errors properly', async () => {
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: {},
+        json: async () => ({ error: 'Server error' }),
+        text: async () => '{"error":"Server error"}',
+      });
+
+      try {
+        await client.readAll();
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toContain('Unknown error fetching all records');
+      }
+    });
+  });
+
+  describe('ApiCrudControllerClient', () => {
+    let client: ApiCrudControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new ApiCrudControllerClient('/api/crud', mockHttpService);
+    });
+
+    it('should use injected HTTP service for create', async () => {
+      const newItem = { id: 0, name: 'New Item' };
+      const createdItem = { id: 1, name: 'New Item' };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Create', {
+        ok: true,
+        status: 201,
+        statusText: 'Created',
+        headers: {},
+        json: async () => ({ success: true, result: createdItem, metadata: {} }),
+        text: async () => JSON.stringify({ result: createdItem, metadata: {} }),
+      });
+
+      const result = await client.create(newItem);
+
+      expect(result).toEqual({ result: createdItem, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Create');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
+      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(newItem));
+    });
+
+    it('should use injected HTTP service for update', async () => {
+      const updateItem = { id: 1, name: 'Updated Item' };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Update?id=1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: updateItem, metadata: {} }),
+        text: async () => JSON.stringify({ result: updateItem, metadata: {} }),
+      });
+
+      const result = await client.update(1, updateItem);
+
+      expect(result).toEqual({ result: updateItem, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Update?id=1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('PUT');
+    });
+
+    it('should use injected HTTP service for delete', async () => {
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Delete?id=1', {
+        ok: true,
+        status: 204,
+        statusText: 'No Content',
+        headers: {},
+        json: async () => ({}),
+        text: async () => '',
+      });
+
+      await client.delete(1);
+
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Delete?id=1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('DELETE');
+    });
+  });
+
+  describe('UserManagementControllerClient', () => {
+    let client: UserManagementControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new UserManagementControllerClient('/api/users', mockHttpService);
+    });
+
+    it('should use injected HTTP service for getUserRoles', async () => {
+      const mockRoles = ['admin', 'user'];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserRoles/1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
+      });
+
+      const result = await client.getUserRoles(1);
+
+      expect(result).toEqual({ result: mockRoles, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserRoles/1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for getUserClaims', async () => {
+      const mockClaims = [
+        { type: 'role', value: 'admin' },
+        { type: 'department', value: 'IT' },
+      ];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserClaims/1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockClaims, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockClaims, metadata: {} }),
+      });
+
+      const result = await client.getUserClaims(1);
+
+      expect(result).toEqual({ result: mockClaims, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserClaims/1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for getAllRoles', async () => {
+      const mockRoles = ['admin', 'user', 'moderator'];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetAllRoles', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
+      });
+
+      const result = await client.getAllRoles();
+
+      expect(result).toEqual({ result: mockRoles, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetAllRoles');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+  });
+});