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

package/src/services/auth/client/AuthorizationManagementControllerClient/index.ts

@@ -0,0 +1,165 @@
+import { apiInitializationService, IHttpService } from '@services';
+import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto, ErrorCode, ReadMetadataDto, RoleDto } from '@data';
+import { fail, ok } from '@utils/result';
+
+/**
+ * Client for authorization management operations
+ *
+ * @export
+ * @class AuthorizationManagementControllerClient
+ */
+export class AuthorizationManagementControllerClient {
+  /**
+   * Constructor
+   * @param baseControllerPath Base path to API controller
+   * @param httpService HTTP service implementation to use for requests
+   */
+  constructor(
+    protected readonly baseControllerPath: string = 'AuthorizationManagement',
+    httpService?: IHttpService,
+  ) {
+    this._httpService = httpService;
+  }
+
+  // #region HTTP service
+  private readonly _httpService?: IHttpService = undefined;
+
+  /**
+   * Gets globally selected HTTP service
+   */
+  protected get httpService(): IHttpService {
+    return this._httpService || apiInitializationService._getHttpService();
+  }
+
+  // #endregion
+
+  /**
+   * Gets all roles in the system
+   * @param includeClaims - Whether to include claims in the response
+   * @param signal - Optional cancellation signal
+   * @returns List of all roles
+   */
+  public async getAllRoles(includeClaims: boolean, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto[], ReadMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
+      const res = await this.httpService.request(url, {
+        credentials: 'include',
+        signal,
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error fetching all roles',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Gets a role with its claims
+   * @param roleName - The name of the role
+   * @param signal
+   * @returns The role with its claims
+   */
+  public async getRoleWithClaims(roleName: string, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto, ReadMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
+      const res = await this.httpService.request(url, {
+        credentials: 'include',
+        signal,
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error fetching role with claims',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Creates or updates a role
+   * @param roleDto - The role to create or update
+   * @returns The created or updated role
+   */
+  public async upsertRole(roleDto: RoleDto): Promise<ApiResponseDto<RoleDto, EmptyMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/UpsertRole`);
+      const res = await this.httpService.request(url, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(roleDto),
+        credentials: 'include',
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error upserting role',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Deletes a role
+   * @param roleName - The name of the role to delete
+   * @returns Promise that resolves when the role is deleted successfully
+   */
+  public async deleteRole(roleName: string): Promise<ApiResponseDto<undefined, EmptyMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
+      const res = await this.httpService.request(url, {
+        method: 'DELETE',
+        credentials: 'include',
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>(undefined);
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: `Unknown error while deleting the role ${roleName}`,
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+}

package/src/services/auth/client/index.ts

@@ -0,0 +1,2 @@
+export * from './AuthorizationManagementControllerClient';
+export * from './AuthService';

package/src/services/auth/index.ts

@@ -0,0 +1 @@
+export * from './client';

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './auth';

package/src/utils/authorization/index.ts

@@ -0,0 +1,47 @@
+import { IPolicy, PolicyBase } from '@data';
+
+/**
+ * Checks if a policy is valid for the given parameters.
+ *
+ * @param policy Policy to check, either an instance or a class.
+ * @param params Parameters to pass to the policy check function.
+ * @returns A promise that resolves if the policy is valid, rejects otherwise.
+ */
+export async function check<TParams extends unknown[]>(policy: IPolicy<TParams> | (new () => IPolicy<TParams>), ...params: TParams): Promise<boolean> {
+  // If passed an instance of a policy
+  if (policy instanceof PolicyBase) {
+    return (policy as IPolicy<TParams>).check(...params);
+  }
+  // If passed a policy class
+  else {
+    return new (policy as new () => IPolicy<TParams>)().check(...params);
+  }
+}
+
+/**
+ * Composes multiple policies into a single policy.
+ *
+ * @param composition Composition method, either 'AND' or 'OR'.
+ * @param policies Policies to compose.
+ * @returns A new policy that represents the composition of the policies.
+ */
+export function compose<TParams extends unknown[]>(composition: 'AND' | 'OR', ...policies: IPolicy<TParams>[]): IPolicy<TParams> {
+  return {
+    check: async (...params: TParams): Promise<boolean> => {
+      // Check all policies
+      if (composition === 'AND') {
+        const results = await Promise.allSettled(policies.map(policy => policy.check(...params)));
+        return results.every(result => result);
+      }
+      // Check any policies, exit as soon as any are true
+      else if (composition === 'OR') {
+        const results = await Promise.allSettled(policies.map(policy => policy.check(...params)));
+        return results.some(result => result);
+      }
+      // Invalid composition
+      else {
+        throw new Error('Invalid composition');
+      }
+    },
+  };
+}

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/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "paths": {
+      "@": ["./src"],
+      "@/*": ["./src/*"],
+      "@adapters": ["./src/adapters"],
+      "@adapters/*": ["./src/adapters/*"],
+      "@data": ["./src/data"],
+      "@data/*": ["./src/data/*"],
+      "@services": ["./src/services"],
+      "@services/*": ["./src/services/*"],
+      "@utils": ["./src/utils"],
+      "@utils/*": ["./src/utils/*"]
+    }
+  },
+  "include": ["src/**/*.ts"]
+}

package/vitest-setup.ts

@@ -0,0 +1,43 @@
+import { vi } from 'vitest';
+import fetch from 'node-fetch';
+
+// Global fetch mock for Vitest integration tests.
+// Purpose:
+// - Provide deterministic configuration for app/service initialization that loads `websettings.json`
+// - Only fetch requests for `websettings.json` are mocked; all other network requests are real
+//
+// Any fetch request that targets `websettings.json` (typically during app or service init) will receive a mocked response.
+// All other requests are forwarded to the real `node-fetch` implementation, so real network requests are still possible in tests.
+
+const MOCKED_WEBSETTINGS_JSON = {
+  api: 'http://localhost:5000/api',
+};
+
+// Use new Headers() to simulate Fetch API Headers behavior.
+// This ensures compatibility with code that uses headers.forEach() for iteration.
+const MOCKED_RESPONSE_HEADERS = new Headers({
+  'Content-Type': 'application/json',
+});
+
+const mockFetch = vi.fn(async (url: string, config?: RequestInit) => {
+  if (url.includes('websettings.json')) {
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+
+      // Minimal Headers mock for compatibility with project code.
+      headers: MOCKED_RESPONSE_HEADERS,
+
+      // Mocked JSON payload returned by fetch().json()
+      json: vi.fn<() => Promise<any>>().mockResolvedValue(MOCKED_WEBSETTINGS_JSON),
+    };
+  }
+
+  // Forward all non-config requests to the real fetch implementation.
+  // `any` cast is intentional to avoid RequestInit type mismatches in Node.
+  return fetch(url, config as any);
+});
+
+// Override global fetch for all tests
+global.fetch = mockFetch as any;

package/vitest.config.ts

@@ -0,0 +1,59 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+const aliasConfig = {
+  '@': path.resolve(__dirname, './src'),
+  '@adapters': path.resolve(__dirname, './src/adapters'),
+  '@data': path.resolve(__dirname, './src/data'),
+  '@data/*': path.resolve(__dirname, './src/data/*'),
+  '@services': path.resolve(__dirname, './src/services'),
+  '@utils': path.resolve(__dirname, './src/utils'),
+};
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    projects: [
+      {
+        resolve: {
+          alias: aliasConfig,
+        },
+        test: {
+          name: 'unit',
+          environment: 'jsdom',
+          testTimeout: 60000,
+          include: ['./**/*.unit.test.{ts,tsx,js}', '**/*.unit.test.{ts,tsx,js}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+      {
+        resolve: {
+          alias: aliasConfig,
+        },
+        test: {
+          name: 'integration',
+          environment: 'jsdom',
+          testTimeout: 60000,
+          globalSetup: [path.resolve(__dirname, '../../vitest-setup-integration.ts')],
+          setupFiles: [path.resolve(__dirname, './vitest-setup.ts')],
+          include: ['./**/*.integration.test.{ts,tsx,js}', '**/*.integration.test.{ts,tsx,js}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+      {
+        resolve: {
+          alias: aliasConfig,
+        },
+        test: {
+          name: 'debug',
+          testTimeout: 60000,
+          globalSetup: [path.resolve(__dirname, '../../vitest-setup-integration.ts')],
+          setupFiles: [path.resolve(__dirname, './vitest-setup.ts')],
+          include: ['./**/*.{test,spec,debug}.{js,ts}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+    ],
+  },
+});