@intellegens/cornerstone-client 0.0.9999-alpha-30 → 0.0.9999-alpha-32

package/src/services/api/UserManagementControllerClient/index.integration.test.ts

@@ -0,0 +1,69 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { UserManagementControllerClient } from '.';
+import { IHttpService } from '../HttpService';
+import fetchOrig from 'node-fetch';
+import fetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+
+// Create a fetch instance that handles auth cookies
+const jar = new CookieJar();
+const cookieFetch = fetchCookie(fetchOrig, jar);
+// Custom IHttpService implementation for tests
+class CookieFetchHttpService implements IHttpService {
+  async request(url: string, config?: any): Promise<any> {
+    const response = await cookieFetch(url, {
+      method: config?.method || 'GET',
+      headers: config?.headers,
+      body: config?.body,
+      signal: config?.signal,
+    });
+    const headers: Record<string, string> = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      json: () => response.json(),
+      text: () => response.text(),
+    };
+  }
+}
+const credentials = {
+  username: 'admin@test.com',
+  password: 'Password1234!',
+};
+const baseUrl = 'http://localhost:5000/api';
+
+describe('UserManagementControllerClient', () => {
+  let client: UserManagementControllerClient<number, any, any, any, any>;
+  let fetchService: CookieFetchHttpService = new CookieFetchHttpService();
+
+  beforeAll(async () => {
+    await fetchService.request(`${baseUrl}/auth/signin`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(credentials),
+    });
+  });
+
+  beforeEach(() => {
+    client = new UserManagementControllerClient('/users', fetchService);
+  });
+
+  it('should use injected HTTP service for getUserRoles', async () => {
+    const result = (await client.getUserRoles(1)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+  });
+
+  it('should use injected HTTP service for getUserClaims', async () => {
+    const result = (await client.getUserClaims(1)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+  });
+});

package/src/services/api/UserManagementControllerClient/index.ts

@@ -94,38 +94,6 @@ export class UserManagementControllerClient<
     }
   }
 
-  /**
-   * Gets all available roles in the system
-   * @param {AbortSignal} [signal] - Optional cancellation signal
-   * @returns List of all role names
-   */
-  public async getAllRoles(signal?: AbortSignal): Promise<ApiResponseDto<string[], ReadMetadataDto>> {
-    try {
-      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetAllRoles');
-      const res = await this.httpService.request(url, {
-        method: 'GET',
-        credentials: 'include',
-        signal,
-      });
-
-      if (!res.ok) {
-        return fail<ApiSuccessResponseDto<string[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
-      }
-
-      return ok<ApiSuccessResponseDto<string[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
-    } catch (err) {
-      console.error(err);
-
-      return fail<ApiSuccessResponseDto<string[], ReadMetadataDto>, ApiErrorResponseDto>({
-        error: {
-          code: ErrorCode.UnknownError,
-          message: 'Unknown error while fetching all roles',
-          metadata: {} as EmptyMetadataDto,
-        },
-      });
-    }
-  }
-
   /**
    * Changes the password for a user
    * @param id - The ID of the user

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

@@ -1,5 +1,5 @@
 import { apiInitializationService, IHttpService } from '@services';
-import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto, ErrorCode, IPolicy, PolicyBase, UserDto, UserInfoDto } from '@data';
+import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto, ErrorCode, UserDto, UserInfoDto, RegisterRequestDto } from '@data';
 import { fail, ok } from '@utils';
 
 export { UserDto, UserInfoDto };
@@ -11,7 +11,7 @@ export { UserDto, UserInfoDto };
  * @export
  * @class AuthService
  */
-export class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKey>> {
+export class AuthService<TKey, TRegisterUser extends RegisterRequestDto = RegisterRequestDto, TUser extends UserDto<TKey> = UserDto<TKey>> {
   /**
    * Constructor
    * @param baseControllerPath Base path to Auth API controller
@@ -168,6 +168,52 @@ export class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKey>> {
     }
   }
 
+  /**
+   * Registers a new user by sending user details to the API.
+   *
+   * @param {TRegisterUser} user User object containing registration data (e.g. username, password, and optionally firstName, lastName, etc.)
+   * @return {Promise<ApiResponseDto<TUser, EmptyMetadataDto>>} API response with registered user details or error info
+   * @throws {Error} Error if the request fails
+   */
+  public async register(user: TRegisterUser): Promise<ApiResponseDto<TUser, EmptyMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, '/register');
+      const res = await this.httpService.request(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(user),
+        credentials: 'include',
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<TUser, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      // TODO: Handle tokens if not using cookies
+
+      const whoAmIRes = await this.whoAmI();
+
+      if (!whoAmIRes.ok) {
+        return whoAmIRes;
+      }
+
+      return ok<ApiSuccessResponseDto<TUser, EmptyMetadataDto>, ApiErrorResponseDto>({
+        result: whoAmIRes.result.user,
+        metadata: whoAmIRes.metadata,
+      });
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<TUser, EmptyMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Failed registering user',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
   /**
    * If any API response returns an "Unauthenticated" response, call this method
    * to update local authentication state to unauthenticated

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

@@ -0,0 +1,110 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { AuthorizationManagementControllerClient } from '.';
+import fetchOrig from 'node-fetch';
+import fetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+import { IHttpService } from '@/services';
+import { RoleDto } from '@/data';
+
+// Create a fetch instance that handles auth cookies
+const jar = new CookieJar();
+const cookieFetch = fetchCookie(fetchOrig, jar);
+// Custom IHttpService implementation for tests
+class CookieFetchHttpService implements IHttpService {
+  async request(url: string, config?: any): Promise<any> {
+    const response = await cookieFetch(url, {
+      method: config?.method || 'GET',
+      headers: config?.headers,
+      body: config?.body,
+      signal: config?.signal,
+    });
+    const headers: Record<string, string> = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      json: () => response.json(),
+      text: () => response.text(),
+    };
+  }
+}
+const credentials = {
+  username: 'admin@test.com',
+  password: 'Password1234!',
+};
+const baseUrl = 'http://localhost:5000/api';
+
+describe('AuthorizationManagementControllerClient', () => {
+  let client: AuthorizationManagementControllerClient;
+  let fetchService: CookieFetchHttpService = new CookieFetchHttpService();
+
+  beforeAll(async () => {
+    await fetchService.request(`${baseUrl}/auth/signin`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(credentials),
+    });
+  });
+
+  beforeEach(() => {
+    client = new AuthorizationManagementControllerClient('/AuthorizationManagement', fetchService);
+  });
+
+  it('should fetch all roles', async () => {
+    const result = (await client.getAllRoles(false)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+  });
+
+  it('should fetch all roles with claims', async () => {
+    const result = (await client.getAllRoles(true)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(result.result[0].claims).toBeDefined();
+  });
+
+  it('should return role with claims by name', async () => {
+    const newRole: RoleDto = { name: 'New Role Test Claims', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+
+    const create = (await client.upsertRole(newRole)) as { ok: boolean; result: any };
+
+    expect(create.ok).toBe(true);
+
+    const result = (await client.getRoleWithClaims(newRole.name)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(result.result.claims).toBeDefined();
+    expect(result.result.name).toBe(newRole.name);
+    expect(result.result.claims.length).toBe(newRole.claims.length);
+    expect(result.result.claims).toEqual(newRole.claims);
+  });
+
+  it('should create a new role with claims', async () => {
+    const newRole: RoleDto = { name: 'New Role', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+
+    const result = (await client.upsertRole(newRole)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(result.result.name).toBe(newRole.name);
+    expect(result.result.claims.length).toBe(newRole.claims.length);
+    expect(result.result.claims).toEqual(newRole.claims);
+  });
+
+  it('should delete role', async () => {
+    const role: RoleDto = { name: 'Temp Role', claims: [] };
+
+    const create = (await client.upsertRole(role)) as { ok: boolean; result: any };
+    expect(create.ok).toBe(true);
+
+    const deleteResult = await client.deleteRole(role.name);
+    expect(deleteResult.ok).toBe(true);
+  });
+});

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/**'],
+        },
+      },
+    ],
+  },
+});

package/jest.config.js

@@ -1,29 +0,0 @@
-export default {
-  preset: 'ts-jest/presets/default-esm',
-  extensionsToTreatAsEsm: ['.ts'],
-  testEnvironment: 'jsdom',
-  roots: ['<rootDir>/src', '<rootDir>/tests'],
-  testMatch: ['**/__tests__/**/*.+(ts|tsx|js)', '**/*.(test|spec).+(ts|tsx|js)'],
-  transform: {
-    '^.+\\.(ts|tsx)$': [
-      'ts-jest',
-      {
-        useESM: true,
-      },
-    ],
-  },
-  collectCoverageFrom: ['src/**/*.{ts,tsx}', '!src/**/*.d.ts', '!src/**/index.ts'],
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/src/$1',
-    '^@adapters/(.*)$': '<rootDir>/src/adapters/$1',
-    '^@adapters$': '<rootDir>/src/adapters',
-    '^@data/(.*)$': '<rootDir>/src/data/$1',
-    '^@data$': '<rootDir>/src/data',
-    '^@services/(.*)$': '<rootDir>/src/services/$1',
-    '^@services$': '<rootDir>/src/services',
-    '^@utils/(.*)$': '<rootDir>/src/utils/$1',
-    '^@utils$': '<rootDir>/src/utils',
-  },
-  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
-  testTimeout: 10000,
-};