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

package/dist/adapters/CollectionViewAdapter/index.integration.test.d.ts

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

package/dist/adapters/CollectionViewAdapter/index.integration.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { CollectionViewAdapter } from '.';
+import { ReadSelectedComparisonOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '../../data';
+import { dateInterval, searchTerm } from '../../utils';
+describe('CollectionViewAdapter', () => {
+    let data;
+    let error;
+    let isLoading;
+    const callback = vi.fn((_isLoading, _data, _error) => {
+        isLoading = _isLoading;
+        data = _data;
+        error = _error;
+    });
+    const options = {
+        pagination: { useTotalItemCount: true, pageSize: 5, pageNumber: 1 },
+        ordering: { maxActiveOrderingColumns: 1, orderByPaths: [] },
+        search: { textSearchableProperties: ['name'], numericSearchableProperties: ['id'] },
+    };
+    let adapter;
+    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(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,
+            },
+        ]);
+    });
+});

package/dist/adapters/SearchAdapter/index.d.ts

@@ -20,16 +20,20 @@ export interface IGlobalSearchable<TKey> extends IIdentifiable<TKey> {
 export declare class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
     onChange: SingularEventTarget<string>;
     private _readClient;
-    private _options;
+    options: SearchAdapterOptions<TDto>;
     private _isLoading;
     private _currentAbortController?;
     private _lastSearchedValue;
     private _typesToSearch;
     private _fetchResultsDataTimeout?;
     private _fetchResultsPromises;
+    private _totalCount;
     constructor(options: SearchAdapterOptions<TDto>);
     get searchTriggerMinLength(): number;
     get multiselect(): boolean;
+    get isLoading(): boolean;
+    get totalCount(): number;
+    get hasMoreRecords(): boolean;
     private _searchText;
     get searchText(): string;
     set searchText(searchText: string);

package/dist/adapters/SearchAdapter/index.js

@@ -13,22 +13,32 @@ export class SearchAdapter {
     onChange = new SingularEventTarget();
     // inputs
     _readClient;
-    _options;
+    options;
     _isLoading = false;
     _currentAbortController;
-    _lastSearchedValue = '';
+    _lastSearchedValue = undefined;
     _typesToSearch = [];
     _fetchResultsDataTimeout;
     _fetchResultsPromises = [];
+    _totalCount = 0;
     constructor(options) {
-        this._options = options;
+        this.options = options;
         this._readClient = new ApiReadControllerClient(options.controllerName);
     }
     get searchTriggerMinLength() {
-        return this._options.searchTriggerMinLength;
+        return this.options.searchTriggerMinLength;
     }
     get multiselect() {
-        return this._options.multiselect;
+        return this.options.multiselect;
+    }
+    get isLoading() {
+        return this._isLoading;
+    }
+    get totalCount() {
+        return this._totalCount;
+    }
+    get hasMoreRecords() {
+        return this._totalCount > this._searchResults.length;
     }
     _searchText = '';
     get searchText() {
@@ -60,7 +70,7 @@ export class SearchAdapter {
             this.selectedItems = [];
         }
         // selection mode
-        if (this._options.multiselect) {
+        if (this.options.multiselect) {
             if (!this._selectedItems.find(s => s.id === item.id)) {
                 this.selectedItems = [...this.selectedItems, item];
             }
@@ -86,18 +96,19 @@ export class SearchAdapter {
         this.onChange.dispatchEvent('onChange');
     }
     async _trySearch() {
-        const options = this._options;
+        const options = this.options;
         this.searchResults = [];
         if (this._searchText.length < options.searchTriggerMinLength)
             return;
-        if (this._searchText == this._lastSearchedValue)
+        if (this._searchText === this._lastSearchedValue)
             return;
         this._lastSearchedValue = this._searchText;
         this._typesToSearch =
-            options.limitSearchToSelectedType && this._selectedItems.length ? [this._selectedItems[0].type] : this._options.typesToSearch;
+            options.limitSearchToSelectedType && this._selectedItems.length ? [this._selectedItems[0].type] : this.options.typesToSearch;
         this.searchResults = this._sortByName(await this._fetchResults(options.searchDebounceDelay));
     }
     async _fetchResults(debounceDelay) {
+        this._isLoading = true;
         return new Promise((resolve, reject) => {
             this._fetchResultsPromises.push({ resolve, reject });
             if (this._fetchResultsDataTimeout !== undefined) {
@@ -119,7 +130,6 @@ export class SearchAdapter {
         });
     }
     async _fetchResultsDebounced() {
-        this._isLoading = true;
         let abortController;
         let caughtError;
         try {
@@ -139,6 +149,8 @@ export class SearchAdapter {
             if (!response.ok) {
                 throw response.error;
             }
+            // Update total count from response metadata
+            this._totalCount = response.metadata?.totalCount ?? response.result.length;
             // Filter out selected items from new results
             const selectedIds = new Set((this.selectedItems || []).map(item => item.id));
             return response.result.filter(item => !selectedIds.has(item.id));
@@ -168,7 +180,7 @@ export class SearchAdapter {
         const definition = {
             paginationDefinition: {
                 skip: 0,
-                limit: this._options.resultsLimit,
+                limit: this.options.resultsLimit,
             },
         };
         // Apply ordering
@@ -206,8 +218,8 @@ export class SearchAdapter {
                 },
             ];
         }
-        if (this._options.additionalSearchDefinitions && this._options.additionalSearchDefinitions.length > 0) {
-            definition.searchDefinition.searches = [...(definition.searchDefinition.searches ?? []), ...this._options.additionalSearchDefinitions];
+        if (this.options.additionalSearchDefinitions && this.options.additionalSearchDefinitions.length > 0) {
+            definition.searchDefinition.searches = [...(definition.searchDefinition.searches ?? []), ...this.options.additionalSearchDefinitions];
         }
         return definition;
     }

package/dist/data/auth/dto/index.d.ts

@@ -2,3 +2,4 @@ export * from './ClaimDto';
 export * from './UserDto';
 export * from './UserInfoDto';
 export * from './RoleDto';
+export * from './RegisterRequestDto';

package/dist/data/auth/dto/index.js

@@ -2,3 +2,4 @@ export * from './ClaimDto';
 export * from './UserDto';
 export * from './UserInfoDto';
 export * from './RoleDto';
+export * from './RegisterRequestDto';

package/dist/services/api/ApiCrudControllerClient/index.integration.test.d.ts

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

package/dist/services/api/ApiCrudControllerClient/index.integration.test.js

@@ -0,0 +1,34 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ApiCrudControllerClient } from '.';
+import { FetchHttpService } from '../HttpService';
+describe('ApiCrudControllerClient', () => {
+    let client;
+    let fetchService;
+    const testId = 100;
+    beforeEach(() => {
+        fetchService = new FetchHttpService();
+        client = new ApiCrudControllerClient('/VehiclesSlim', fetchService);
+    });
+    it('should use injected HTTP service for create', async () => {
+        const newVehicle = { id: testId, brand: 'New Brand', model: 'New Model' };
+        const result = (await client.create(newVehicle));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.id).toBe(newVehicle.id);
+        expect(result.result.brand).toBe(newVehicle.brand);
+        expect(result.result.model).toBe(newVehicle.model);
+    });
+    it('should use injected HTTP service for update', async () => {
+        const updateVehicle = { id: testId, brand: 'Updated Brand', model: 'Updated Model' };
+        const result = (await client.update(testId, updateVehicle));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.id).toBe(updateVehicle.id);
+        expect(result.result.brand).toBe(updateVehicle.brand);
+        expect(result.result.model).toBe(updateVehicle.model);
+    });
+    it('should use injected HTTP service for delete', async () => {
+        const result = await client.delete(testId);
+        expect(result.ok).toBe(true);
+    });
+});

package/dist/services/api/ApiReadControllerClient/index.integration.test.d.ts

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

package/dist/services/api/ApiReadControllerClient/index.integration.test.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ApiReadControllerClient } from '.';
+import { FetchHttpService } from '../HttpService';
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType } from '../../../data';
+describe('ApiReadControllerClient', () => {
+    let client;
+    let fetchService;
+    beforeEach(() => {
+        fetchService = new FetchHttpService();
+        client = new ApiReadControllerClient('/VehiclesSlim', fetchService);
+    });
+    it('should use injected HTTP service for readAll', async () => {
+        const result = (await client.readAll());
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should use injected HTTP service for readSingle', async () => {
+        const testId = 1;
+        const result = (await client.readSingle(testId));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(typeof result.result).toBe('object');
+        expect(result.result.id).toBe(testId);
+    });
+    it('should use injected HTTP service for readSelected', async () => {
+        const definition = {
+            searchDefinition: {
+                searches: [
+                    {
+                        propertyCriteria: [
+                            {
+                                propertyName: 'Brand',
+                                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                                valueType: ReadSelectedPropertyType.String,
+                                value: 'Audi',
+                            },
+                            {
+                                propertyName: 'Brand',
+                                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                                valueType: ReadSelectedPropertyType.String,
+                                value: 'BMW',
+                            },
+                        ],
+                        logicalOperator: ReadSelectedLogicalOperator.Or,
+                    },
+                ],
+                logicalOperator: ReadSelectedLogicalOperator.And,
+            },
+        };
+        const result = (await client.readSelected(definition));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should handle HTTP errors properly', async () => {
+        const invalidClient = new ApiReadControllerClient('/InvalidPath', fetchService);
+        const result = await invalidClient.readAll();
+        expect(result.ok).toBe(false);
+    });
+});

package/dist/services/api/HttpService/FetchHttpService.integration.test.d.ts

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

package/dist/services/api/HttpService/FetchHttpService.integration.test.js

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { FetchHttpService } from './FetchHttpService';
+const baseUrl = 'http://localhost:5000/api';
+const credentials = {
+    username: 'admin@test.com',
+    password: 'Password1234!',
+};
+describe('FetchHttpService', () => {
+    let fetchService;
+    beforeEach(() => {
+        fetchService = new FetchHttpService();
+    });
+    it('should make a GET request successfully', async () => {
+        const result = await fetchService.request(`${baseUrl}/AnythingManuallyMappedRead/ReadAll`);
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(200);
+        expect(result.statusText).toBe('OK');
+        const jsonData = await result.json();
+        expect(jsonData.result).toBeDefined();
+        expect(jsonData.error).toBeNull();
+    });
+    it('should make a POST request with body', async () => {
+        const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(credentials),
+        });
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(204);
+    });
+    it('should handle non-ok responses', async () => {
+        const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ username: credentials.username, password: `${credentials.password}wrong` }),
+        });
+        expect(result.ok).toBe(false);
+        expect(result.status).toBe(400);
+        expect(result.statusText).toBe('Bad Request');
+        const jsonData = await result.json();
+        expect(jsonData.result).toBeNull();
+        expect(jsonData.error).toBeDefined();
+        expect(jsonData.error.code).toBe(400);
+        expect(jsonData.error.message).toBe('Invalid email or password');
+    });
+    it('should handle fetch errors from backend', async () => {
+        const result = await fetchService.request('http://localhost:5000/api/error');
+        expect(result.ok).toBe(false);
+        expect(result.status).toBe(404);
+        expect(result.statusText).toBe('Not Found');
+    });
+});

package/dist/services/api/UserManagementControllerClient/index.d.ts

@@ -30,12 +30,6 @@ export declare class UserManagementControllerClient<TKey, TResultDto extends Use
      * @returns List of claims assigned to the user
      */
     getUserClaims(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<ClaimDto[], ReadMetadataDto>>;
-    /**
-     * Gets all available roles in the system
-     * @param {AbortSignal} [signal] - Optional cancellation signal
-     * @returns List of all role names
-     */
-    getAllRoles(signal?: AbortSignal): Promise<ApiResponseDto<string[], ReadMetadataDto>>;
     /**
      * Changes the password for a user
      * @param id - The ID of the user

package/dist/services/api/UserManagementControllerClient/index.integration.test.d.ts

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

package/dist/services/api/UserManagementControllerClient/index.integration.test.js

@@ -0,0 +1,60 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { UserManagementControllerClient } from '.';
+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 {
+    async request(url, config) {
+        const response = await cookieFetch(url, {
+            method: config?.method || 'GET',
+            headers: config?.headers,
+            body: config?.body,
+            signal: config?.signal,
+        });
+        const headers = {};
+        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;
+    let fetchService = 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));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should use injected HTTP service for getUserClaims', async () => {
+        const result = (await client.getUserClaims(1));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+});

package/dist/services/api/UserManagementControllerClient/index.js

@@ -79,35 +79,6 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
             });
         }
     }
-    /**
-     * Gets all available roles in the system
-     * @param {AbortSignal} [signal] - Optional cancellation signal
-     * @returns List of all role names
-     */
-    async getAllRoles(signal) {
-        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(await res.json());
-            }
-            return ok(await res.json());
-        }
-        catch (err) {
-            console.error(err);
-            return fail({
-                error: {
-                    code: ErrorCode.UnknownError,
-                    message: 'Unknown error while fetching all roles',
-                    metadata: {},
-                },
-            });
-        }
-    }
     /**
      * Changes the password for a user
      * @param id - The ID of the user

package/dist/services/auth/client/AuthService/index.d.ts

@@ -1,5 +1,5 @@
 import { IHttpService } from '../../..';
-import { ApiResponseDto, EmptyMetadataDto, UserDto, UserInfoDto } from '../../../../data';
+import { ApiResponseDto, EmptyMetadataDto, UserDto, UserInfoDto, RegisterRequestDto } from '../../../../data';
 export { UserDto, UserInfoDto };
 /**
  * AuthService class is responsible for managing user authentication operations.
@@ -8,7 +8,7 @@ export { UserDto, UserInfoDto };
  * @export
  * @class AuthService
  */
-export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKey>> {
+export declare class AuthService<TKey, TRegisterUser extends RegisterRequestDto = RegisterRequestDto, TUser extends UserDto<TKey> = UserDto<TKey>> {
     protected readonly baseControllerPath: string;
     /**
      * Constructor
@@ -55,6 +55,14 @@ export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKe
      * @throws {Error} Error if fetch fails
      */
     signOut(): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * 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
+     */
+    register(user: TRegisterUser): Promise<ApiResponseDto<TUser, EmptyMetadataDto>>;
     /**
      * If any API response returns an "Unauthenticated" response, call this method
      * to update local authentication state to unauthenticated

package/dist/services/auth/client/AuthService/index.js

@@ -143,6 +143,46 @@ export class AuthService {
             });
         }
     }
+    /**
+     * 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
+     */
+    async register(user) {
+        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(await res.json());
+            }
+            // TODO: Handle tokens if not using cookies
+            const whoAmIRes = await this.whoAmI();
+            if (!whoAmIRes.ok) {
+                return whoAmIRes;
+            }
+            return ok({
+                result: whoAmIRes.result.user,
+                metadata: whoAmIRes.metadata,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed registering user',
+                    metadata: {},
+                },
+            });
+        }
+    }
     /**
      * If any API response returns an "Unauthenticated" response, call this method
      * to update local authentication state to unauthenticated

package/dist/services/auth/client/AuthorizationManagementControllerClient/index.integration.test.d.ts

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