@intellegens/cornerstone-client 0.0.9999-alpha-41 → 0.0.9999-alpha-43

package/dist/services/api/user-management-controller-client.js

@@ -0,0 +1,291 @@
+import { ApiCrudControllerClient, apiInitializationService } from '../../services';
+import { ErrorCode } from '../../data';
+import { fail, ok } from '../../utils/result';
+/**
+ * Client for user management operations
+ *
+ * @export
+ * @class UserManagementControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TUser - Data Transfer Object representing the user entity
+ */
+export class UserManagementControllerClient extends ApiCrudControllerClient {
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath, httpService) {
+        super(baseControllerPath, httpService);
+    }
+    /**
+     * Gets the roles assigned to a user
+     * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns List of role names assigned to the user
+     */
+    async getUserRoles(id, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetUserRoles', encodeURIComponent(String(id)));
+            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 user roles',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Gets the claims assigned to a user
+     * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns List of claims assigned to the user
+     */
+    async getUserClaims(id, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetUserClaims', encodeURIComponent(String(id)));
+            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 user claims',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Sets the roles for a user, replacing all existing roles
+     * @param id - The ID of the user
+     * @param roles - The list of role names to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are set successfully
+     */
+    async setUserRoles(id, roles, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'SetUserRoles', encodeURIComponent(String(id)), 'roles');
+            const res = await this.httpService.request(url, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(roles),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while setting user roles',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Adds roles to a user
+     * @param id - The ID of the user
+     * @param roles - The list of role names to add
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are added successfully
+     */
+    async addRolesToUser(id, roles, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'AddRolesToUser', encodeURIComponent(String(id)), 'roles', 'add');
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(roles),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while adding roles to user',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Removes roles from a user
+     * @param id - The ID of the user
+     * @param roles - The list of role names to remove
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are removed successfully
+     */
+    async removeRolesFromUser(id, roles, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'RemoveRolesFromUser', encodeURIComponent(String(id)), 'roles', 'remove');
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(roles),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while removing roles from user',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Adds claims to a user
+     * @param id - The ID of the user
+     * @param claims - The list of claims to add
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the claims are added successfully
+     */
+    async addUserClaims(id, claims, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'AddUserClaims', encodeURIComponent(String(id)), 'claims', 'add');
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(claims),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while adding user claims',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Removes claims from a user
+     * @param id - The ID of the user
+     * @param claims - The list of claims to remove
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the claims are removed successfully
+     */
+    async removeUserClaims(id, claims, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'RemoveUserClaims', encodeURIComponent(String(id)), 'claims', 'remove');
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(claims),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while removing user claims',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Changes the password for a user
+     * @param id - The ID of the user
+     * @param newPassword - The new password to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the password is changed successfully
+     */
+    async changePassword(id, newPassword, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'ChangePassword', encodeURIComponent(String(id)));
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(newPassword),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while changing password',
+                    metadata: {},
+                },
+            });
+        }
+    }
+}

package/dist/services/auth/client/auth-service.d.ts

@@ -0,0 +1,75 @@
+import { IHttpService } from '../..';
+import { ApiResponseDto, EmptyMetadataDto, UserDto, UserInfoDto, RegisterRequestDto } from '../../../data';
+export { UserDto, UserInfoDto };
+/**
+ * AuthService class is responsible for managing user authentication operations.
+ * It supports login, logout, and checking the current user's details.
+ *
+ * @export
+ * @class AuthService
+ */
+export declare class AuthService<TKey, TRegisterUser extends RegisterRequestDto = RegisterRequestDto, TUser extends UserDto<TKey> = UserDto<TKey>> {
+    protected readonly baseControllerPath: string;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to Auth API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath?: string, httpService?: IHttpService);
+    private readonly _httpService?;
+    /**
+     * Gets globally selected HTTP service
+     */
+    protected get httpService(): IHttpService;
+    /**
+     * Holds currently authenticated user's details
+     */
+    user: TUser | undefined;
+    /**
+     * Initializes the Authentication status by checking with the API if the current user is authenticated or not
+     *
+     * @async
+     * @return {Promise<void>} Resolves when initialization is complete.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Checks if user is authenticated and retrieves the current user's details if they are
+     *
+     * @return {Promise<UserInfoDto<TKey, TUser>>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    whoAmI(): Promise<ApiResponseDto<UserInfoDto<TKey, TUser>, EmptyMetadataDto>>;
+    /**
+     * Authenticates a user using their username and password, and retrieves user's details
+     *
+     * @param {string} username Login credentials: username
+     * @param {string} password Login credentials: password
+     * @return {Promise<TUser>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    signIn(username: string, password: string): Promise<ApiResponseDto<TUser, EmptyMetadataDto>>;
+    /**
+     * Deauthenticates current user
+     *
+     * @return {Promise<void>}
+     * @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
+     */
+    handleNoAuthApiResponse(): void;
+    /**
+     * True if a user is currently loaded (post whoAmI/signIn)
+     */
+    isAuthenticated(): boolean;
+}

package/dist/services/auth/client/auth-service.js

@@ -0,0 +1,200 @@
+import { apiInitializationService } from '../..';
+import { ErrorCode } from '../../../data';
+import { fail, ok } from '../../../utils';
+/**
+ * AuthService class is responsible for managing user authentication operations.
+ * It supports login, logout, and checking the current user's details.
+ *
+ * @export
+ * @class AuthService
+ */
+export class AuthService {
+    baseControllerPath;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to Auth API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath = 'Auth', httpService) {
+        this.baseControllerPath = baseControllerPath;
+        this._httpService = httpService;
+    }
+    // #region HTTP service
+    _httpService = undefined;
+    /**
+     * Gets globally selected HTTP service
+     */
+    get httpService() {
+        return this._httpService || apiInitializationService._getHttpService();
+    }
+    // #endregion
+    /**
+     * Holds currently authenticated user's details
+     */
+    user = undefined;
+    /**
+     * Initializes the Authentication status by checking with the API if the current user is authenticated or not
+     *
+     * @async
+     * @return {Promise<void>} Resolves when initialization is complete.
+     */
+    async initialize() {
+        // Check user's authentication status
+        await this.whoAmI();
+    }
+    /**
+     * Checks if user is authenticated and retrieves the current user's details if they are
+     *
+     * @return {Promise<UserInfoDto<TKey, TUser>>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    async whoAmI() {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, '/whoami');
+            const res = await this.httpService.request(url, { credentials: 'include' });
+            if (!res.ok) {
+                this.user = undefined;
+                return fail(await res.json());
+            }
+            const response = ok(await res.json());
+            if (!response.ok) {
+                this.user = undefined;
+                return response;
+            }
+            this.user = response.result.user;
+            return response;
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed checking authentication status',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Authenticates a user using their username and password, and retrieves user's details
+     *
+     * @param {string} username Login credentials: username
+     * @param {string} password Login credentials: password
+     * @return {Promise<TUser>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    async signIn(username, password) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, '/signin');
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password }),
+                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 signing in',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Deauthenticates current user
+     *
+     * @return {Promise<void>}
+     * @throws {Error} Error if fetch fails
+     */
+    async signOut() {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, '/signout');
+            const res = await this.httpService.request(url, { credentials: 'include' });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            this.user = undefined;
+            return ok(await res.json());
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed signing out',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * 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
+     */
+    handleNoAuthApiResponse() {
+        this.user = undefined;
+    }
+    // #region Client-side authorization helpers
+    /**
+     * True if a user is currently loaded (post whoAmI/signIn)
+     */
+    isAuthenticated() {
+        return !!this.user;
+    }
+}

package/dist/services/auth/client/authorization-management-controller-client.d.ts

@@ -0,0 +1,48 @@
+import { IHttpService } from '../..';
+import { ApiResponseDto, EmptyMetadataDto, ReadMetadataDto, RoleDto } from '../../../data';
+/**
+ * Client for authorization management operations
+ *
+ * @export
+ * @class AuthorizationManagementControllerClient
+ */
+export declare class AuthorizationManagementControllerClient {
+    protected readonly baseControllerPath: string;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath?: string, httpService?: IHttpService);
+    private readonly _httpService?;
+    /**
+     * Gets globally selected HTTP service
+     */
+    protected get httpService(): IHttpService;
+    /**
+     * 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
+     */
+    getAllRoles(includeClaims: boolean, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto[], ReadMetadataDto>>;
+    /**
+     * Gets a role with its claims
+     * @param roleName - The name of the role
+     * @param signal
+     * @returns The role with its claims
+     */
+    getRoleWithClaims(roleName: string, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto, ReadMetadataDto>>;
+    /**
+     * Creates or updates a role
+     * @param roleDto - The role to create or update
+     * @returns The created or updated role
+     */
+    upsertRole(roleDto: RoleDto): Promise<ApiResponseDto<RoleDto, EmptyMetadataDto>>;
+    /**
+     * Deletes a role
+     * @param roleName - The name of the role to delete
+     * @returns Promise that resolves when the role is deleted successfully
+     */
+    deleteRole(roleName: string): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+}

package/dist/services/auth/client/authorization-management-controller-client.integration.test.d.ts

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