@intellegens/cornerstone-client 0.0.17 → 0.0.18

package/data/auth/Role/index.d.ts

@@ -0,0 +1,8 @@
+export interface Role {
+    name: string;
+    claims: Claim[];
+}
+export interface Claim {
+    name: string;
+    value: string;
+}

package/data/auth/Role/index.js

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

package/data/auth/User/index.d.ts

@@ -1,3 +1,4 @@
+import { Claim } from "../../../data";
 /**
  * Represents a user with an identifier and email address.
  *
@@ -5,8 +6,10 @@
  *
  * @param {TId} id The unique identifier for the user.
  * @param {string} email The email address associated with the user.
+ * @param {Claim[]} claims The claims associated with the user.
  */
 export type User<TId> = {
     id: TId;
     email: string;
+    claims: Claim[];
 };

package/data/auth/index.d.ts

@@ -1,2 +1,3 @@
 export * from './User';
 export * from './UserInfo';
+export * from './Role';

package/data/auth/index.js

@@ -1,2 +1,3 @@
 export * from './User';
 export * from './UserInfo';
+export * from './Role';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellegens/cornerstone-client",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "main": "index.js",
   "type": "module",
   "scripts": {

package/services/api/ApiCrudControllerClient/index.d.ts

@@ -0,0 +1,29 @@
+import { ApiReadControllerClient } from '../..';
+/**
+ * Generic API client for consuming any Cornerstone CrudController
+ *
+ * @export
+ * @class ApiReadControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the entity
+ */
+export declare class ApiCrudControllerClient<TKey, TDto> extends ApiReadControllerClient<TKey, TDto> {
+    /**
+     * Creates a new entity.
+     * @param dto - Insert request DTO
+     * @returns The created entity DTO
+     */
+    create(dto: TDto): Promise<TDto>;
+    /**
+     * Updates an existing entity.
+     * @param id - The ID of the entity to update
+     * @param dto - Update request DTO
+     * @returns The updated entity DTO
+     */
+    update(id: TKey, dto: TDto): Promise<TDto>;
+    /**
+     * Deletes an entity by ID.
+     * @param id - The ID of the entity to delete
+     */
+    delete(id: TKey): Promise<void>;
+}

package/services/api/ApiCrudControllerClient/index.js

@@ -0,0 +1,74 @@
+import { apiInitializationService, ApiReadControllerClient } from '../..';
+/**
+ * Generic API client for consuming any Cornerstone CrudController
+ *
+ * @export
+ * @class ApiReadControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the entity
+ */
+export class ApiCrudControllerClient extends ApiReadControllerClient {
+    /**
+     * Creates a new entity.
+     * @param dto - Insert request DTO
+     * @returns The created entity DTO
+     */
+    async create(dto) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/Create`);
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(dto),
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to create record');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error creating record');
+        }
+    }
+    /**
+     * Updates an existing entity.
+     * @param id - The ID of the entity to update
+     * @param dto - Update request DTO
+     * @returns The updated entity DTO
+     */
+    async update(id, dto) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/Update?id=${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(dto),
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to update record');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error updating record');
+        }
+    }
+    /**
+     * Deletes an entity by ID.
+     * @param id - The ID of the entity to delete
+     */
+    async delete(id) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/Delete?id=${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, {
+                method: 'DELETE',
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to delete record');
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error deleting record');
+        }
+    }
+}

package/services/api/ApiInitializationService/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Central API configuration service, fetches and exposes Cornerstone API configuration
+ *
+ * @export
+ * @class ApiInitializationService
+ */
+export declare class ApiInitializationService {
+    /**
+     * Initializes the API configuration
+     *
+     * This method calls all methods that need to be called during the API configuration phase:
+     * - Starts detection of API base URL.
+     *
+     * @async
+     * @return {Promise<void>} Resolves when initialization is complete.
+     */
+    initialize(): Promise<void>;
+    private _apiBaseUrlPromise;
+    /**
+     * If API base URL detection was completed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrlDetected: boolean;
+    /**
+     * If API base URL detection was completed, this property will hold the method by which detection was performed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrlDetectionMethod: string | undefined;
+    /**
+     * If API base URL detection was completed, this property will hold the detected API base URL
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrl: string | undefined;
+    /**
+     * If API base URL detection has failed, this property will hold the error with which it has failed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseError: Error | undefined;
+    /**
+     * Tries detecting API base URL by multiple methods
+     *
+     * - Checks the response headers of the current URL for the `CORNERSTONE-API-BASEURL` header.
+     * - Attempts to load the `websettings.json` file and looks for an `api` field.
+     * - Defaults to `undefined`.
+     *
+     * IMPORTANT: This method is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     *
+     * @async
+     * @return {Promise<string | undefined>} Returns detected API base URL
+     * @throws {Error} Throws error if either of the detection methods fails
+     */
+    _getApiBaseUrl(): Promise<string | undefined>;
+    /**
+     * Composes a full API URL for a provided endpoint path.
+     *
+     * @async
+     * @param relativeEndpointPathSections Relative endpoint path sections
+     * @return {Promise<string | undefined>} Returns the API endpoint's URL
+     * @throws {Error} Throws error if API base URL detection fails
+     */
+    getApiUrl(...relativeEndpointPathSections: string[]): Promise<string>;
+    /**
+     * Removes starting '/' character
+     * @param str String to remove the starting '/' character from
+     * @returns String with starting '/' character  removed
+     */
+    private removeStartsWithSlashChar;
+    /**
+     * Removes ending '/' character
+     * @param str String to remove the ending '/' character from
+     * @returns String with ending '/' character  removed
+     */
+    private removeEndsWithSlashChar;
+}
+/**
+ * Singleton instance of ApiInitializationService
+ */
+export declare const apiInitializationService: ApiInitializationService;

package/services/api/ApiInitializationService/index.js

@@ -0,0 +1,155 @@
+/**
+ * Central API configuration service, fetches and exposes Cornerstone API configuration
+ *
+ * @export
+ * @class ApiInitializationService
+ */
+export class ApiInitializationService {
+    /**
+     * Initializes the API configuration
+     *
+     * This method calls all methods that need to be called during the API configuration phase:
+     * - Starts detection of API base URL.
+     *
+     * @async
+     * @return {Promise<void>} Resolves when initialization is complete.
+     */
+    async initialize() {
+        // (Pre)detect API base URL
+        await this._getApiBaseUrl();
+    }
+    // #region API Base URL detection
+    _apiBaseUrlPromise = undefined;
+    /**
+     * If API base URL detection was completed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrlDetected = false;
+    /**
+     * If API base URL detection was completed, this property will hold the method by which detection was performed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrlDetectionMethod = undefined;
+    /**
+     * If API base URL detection was completed, this property will hold the detected API base URL
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseUrl = undefined;
+    /**
+     * If API base URL detection has failed, this property will hold the error with which it has failed
+     * IMPORTANT: This property is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     */
+    _apiBaseError = undefined;
+    /**
+     * Tries detecting API base URL by multiple methods
+     *
+     * - Checks the response headers of the current URL for the `CORNERSTONE-API-BASEURL` header.
+     * - Attempts to load the `websettings.json` file and looks for an `api` field.
+     * - Defaults to `undefined`.
+     *
+     * IMPORTANT: This method is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
+     *
+     * @async
+     * @return {Promise<string | undefined>} Returns detected API base URL
+     * @throws {Error} Throws error if either of the detection methods fails
+     */
+    async _getApiBaseUrl() {
+        // Check if API already detected; don't reattempt detection
+        if (this._apiBaseUrlDetected)
+            return this._apiBaseUrl;
+        // Check if detection already in progress; don't allow multiple detections in parallel
+        if (this._apiBaseUrlPromise)
+            return this._apiBaseUrlPromise;
+        // Detect API base URL
+        return (this._apiBaseUrlPromise = new Promise((resolve, reject) => (async () => {
+            // Reset
+            this._apiBaseUrlDetected = false;
+            this._apiBaseUrlDetectionMethod = undefined;
+            this._apiBaseUrl = undefined;
+            this._apiBaseError = undefined;
+            // Check CORNERSTONE-API-BASEURL header for API base URL
+            try {
+                const currentUrlResponse = await fetch(window.location.href, { method: 'GET' });
+                const apiHeader = currentUrlResponse.headers.get('CORNERSTONE-API-BASEURL');
+                if (apiHeader) {
+                    this._apiBaseUrlDetected = true;
+                    this._apiBaseUrlDetectionMethod = 'GET / Header:CORNERSTONE-API-BASEURL';
+                    this._apiBaseUrl = apiHeader;
+                    this._apiBaseError = undefined;
+                    this._apiBaseUrlPromise = undefined;
+                    return resolve(this._apiBaseUrl);
+                }
+            }
+            catch (err) {
+                this._apiBaseError = err instanceof Error ? err : new Error('Failed loading API base URL from response header!');
+            }
+            // Check ./websettings.json header for API base URL
+            try {
+                const webSettingsResponse = await fetch('./websettings.json', { method: 'GET' });
+                if (webSettingsResponse.status === 404)
+                    return (this._apiBaseUrl = undefined);
+                const webSettings = await webSettingsResponse.json();
+                if (webSettings?.api) {
+                    this._apiBaseUrlDetected = true;
+                    this._apiBaseUrlDetectionMethod = 'GET websettings.json';
+                    this._apiBaseUrl = webSettings.api;
+                    this._apiBaseError = undefined;
+                    this._apiBaseUrlPromise = undefined;
+                    return resolve(this._apiBaseUrl);
+                }
+            }
+            catch (err) {
+                this._apiBaseError = err instanceof Error ? err : new Error('Failed loading API base URL from settings file!');
+            }
+            // Check if error caught during any of the detection methods
+            if (this._apiBaseError !== undefined) {
+                this._apiBaseUrlDetected = false;
+                this._apiBaseUrlDetectionMethod = undefined;
+                this._apiBaseUrl = undefined;
+                this._apiBaseUrlPromise = undefined;
+                return reject(this._apiBaseError);
+            }
+            // Default to no API found
+            this._apiBaseUrlDetected = true;
+            this._apiBaseUrlDetectionMethod = undefined;
+            this._apiBaseUrl = undefined;
+            this._apiBaseError = undefined;
+            this._apiBaseUrlPromise = undefined;
+            return resolve(this._apiBaseUrl);
+        })()));
+    }
+    /**
+     * Composes a full API URL for a provided endpoint path.
+     *
+     * @async
+     * @param relativeEndpointPathSections Relative endpoint path sections
+     * @return {Promise<string | undefined>} Returns the API endpoint's URL
+     * @throws {Error} Throws error if API base URL detection fails
+     */
+    async getApiUrl(...relativeEndpointPathSections) {
+        const apiBaseUrl = await this._getApiBaseUrl();
+        const domain = !apiBaseUrl ? '/' : `${this.removeEndsWithSlashChar(apiBaseUrl)}/`;
+        const path = relativeEndpointPathSections.map(section => this.removeStartsWithSlashChar(this.removeEndsWithSlashChar(section))).join('/');
+        return `${domain}${path}`;
+    }
+    /**
+     * Removes starting '/' character
+     * @param str String to remove the starting '/' character from
+     * @returns String with starting '/' character  removed
+     */
+    removeStartsWithSlashChar(str) {
+        return !str.startsWith('/') ? str : str.substring(1);
+    }
+    /**
+     * Removes ending '/' character
+     * @param str String to remove the ending '/' character from
+     * @returns String with ending '/' character  removed
+     */
+    removeEndsWithSlashChar(str) {
+        return !str.endsWith('/') ? str : str.substring(0, str.length - 1);
+    }
+}
+/**
+ * Singleton instance of ApiInitializationService
+ */
+export const apiInitializationService = new ApiInitializationService();

package/services/api/ApiReadControllerClient/index.d.ts

@@ -0,0 +1,34 @@
+import { IIdentifiable, ReadSelectedDefinition } from '../../../data';
+/**
+ * Generic API client for consuming any Cornerstone ReadController
+ *
+ * @export
+ * @class ApiReadControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the entity
+ */
+export declare class ApiReadControllerClient<TKey, TDto = IIdentifiable<TKey>> {
+    protected readonly baseControllerPath: string;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     */
+    constructor(baseControllerPath: string);
+    /**
+     * Fetches selected entities based on a filter definition.
+     * @param {any} definition - The filter definition object
+     * @returns {Promise<TDto[]>} List of entities that match the selection criteria
+     */
+    readSelected(definition: ReadSelectedDefinition): Promise<TDto[]>;
+    /**
+     * Fetches a single entity by its ID.
+     * @param {TKey} id - The ID of the entity
+     * @returns {Promise<TDto | undefined>} The requested entity
+     */
+    readSingle(id: TKey): Promise<TDto>;
+    /**
+     * Fetches all entities from the read controller.
+     * @returns {Promise<TDto[]>} List of all entities
+     */
+    readAll(): Promise<TDto[]>;
+}

package/services/api/ApiReadControllerClient/index.js

@@ -0,0 +1,74 @@
+import { apiInitializationService } from '../..';
+/**
+ * Generic API client for consuming any Cornerstone ReadController
+ *
+ * @export
+ * @class ApiReadControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the entity
+ */
+export class ApiReadControllerClient {
+    baseControllerPath;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     */
+    constructor(baseControllerPath) {
+        this.baseControllerPath = baseControllerPath;
+    }
+    /**
+     * Fetches selected entities based on a filter definition.
+     * @param {any} definition - The filter definition object
+     * @returns {Promise<TDto[]>} List of entities that match the selection criteria
+     */
+    async readSelected(definition) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSelected`);
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(definition),
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch selected records');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching selected records');
+        }
+    }
+    /**
+     * Fetches a single entity by its ID.
+     * @param {TKey} id - The ID of the entity
+     * @returns {Promise<TDto | undefined>} The requested entity
+     */
+    async readSingle(id) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSingle?id=${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, { credentials: 'include' });
+            if (!response.ok)
+                throw new Error('Failed to fetch single record');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching single record');
+        }
+    }
+    /**
+     * Fetches all entities from the read controller.
+     * @returns {Promise<TDto[]>} List of all entities
+     */
+    async readAll() {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadAll`);
+            const response = await fetch(url, { credentials: 'include' });
+            if (!response.ok)
+                throw new Error('Failed to fetch all records');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching all records');
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+import { ApiCrudControllerClient } from '../..';
+/**
+ * Client for user management operations
+ *
+ * @export
+ * @class UserManagementControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the user entity
+ */
+export declare class UserManagementControllerClient<TKey, TDto> extends ApiCrudControllerClient<TKey, TDto> {
+    /**
+     * Gets the roles assigned to a user
+     * @param id - The ID of the user
+     * @returns List of role names assigned to the user
+     */
+    getUserRoles(id: TKey): Promise<string[]>;
+    /**
+     * Gets the claims assigned to a user
+     * @param id - The ID of the user
+     * @returns List of claims assigned to the user
+     */
+    getUserClaims(id: TKey): Promise<Record<string, string>>;
+    /**
+     * Gets all available roles in the system
+     * @returns List of all role names
+     */
+    getAllRoles(): Promise<string[]>;
+    /**
+     * Changes the password for a user
+     * @param id - The ID of the user
+     * @param newPassword - The new password to set
+     * @returns Promise that resolves when the password is changed successfully
+     */
+    changePassword(id: TKey, newPassword: string): Promise<void>;
+}

package/services/api/UserManagementControllerClient/index.js

@@ -0,0 +1,93 @@
+import { ApiCrudControllerClient, apiInitializationService } from '../..';
+/**
+ * Client for user management operations
+ *
+ * @export
+ * @class UserManagementControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TDto - Data Transfer Object representing the user entity
+ */
+export class UserManagementControllerClient extends ApiCrudControllerClient {
+    /**
+     * Gets the roles assigned to a user
+     * @param id - The ID of the user
+     * @returns List of role names assigned to the user
+     */
+    async getUserRoles(id) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetUserRoles${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, {
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch user roles');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching user roles');
+        }
+    }
+    /**
+     * Gets the claims assigned to a user
+     * @param id - The ID of the user
+     * @returns List of claims assigned to the user
+     */
+    async getUserClaims(id) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetUserClaims/${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, {
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch user claims');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching user claims');
+        }
+    }
+    /**
+     * Gets all available roles in the system
+     * @returns List of all role names
+     */
+    async getAllRoles() {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles`);
+            const response = await fetch(url, {
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch all roles');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching all roles');
+        }
+    }
+    /**
+     * Changes the password for a user
+     * @param id - The ID of the user
+     * @param newPassword - The new password to set
+     * @returns Promise that resolves when the password is changed successfully
+     */
+    async changePassword(id, newPassword) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ChangePassword/${encodeURIComponent(String(id))}`);
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(newPassword),
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(errorText || 'Failed to change password');
+            }
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error changing password');
+        }
+    }
+}

package/services/api/index.d.ts

@@ -1,2 +1,4 @@
-export * from './initialization';
-export * from './client';
+export * from './ApiCrudControllerClient';
+export * from './ApiInitializationService';
+export * from './ApiReadControllerClient';
+export * from './UserManagementControllerClient';

package/services/api/index.js

@@ -1,2 +1,4 @@
-export * from './initialization';
-export * from './client';
+export * from './ApiCrudControllerClient';
+export * from './ApiInitializationService';
+export * from './ApiReadControllerClient';
+export * from './UserManagementControllerClient';

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

@@ -0,0 +1,50 @@
+import { User, UserInfo } from '../../../../data';
+export { User, UserInfo };
+/**
+ * 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<TId, TUser extends User<TId> = User<TId>> {
+    /**
+     * 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<TUser>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    whoAmI(): Promise<TUser | undefined>;
+    /**
+     * 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<TUser>;
+    /**
+     * Deauthenticates current user
+     *
+     * @return {Promise<void>}
+     * @throws {Error} Error if fetch fails
+     */
+    signout(): Promise<void>;
+    /**
+     * If any API response returns an "Unauthenticated" response, call this method
+     * to update local authentication state to unauthenticated
+     */
+    _handleResponse401(): void;
+}

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

@@ -0,0 +1,113 @@
+import { apiInitializationService } from '../../..';
+/**
+ * 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 {
+    /**
+     * 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<TUser>} Currently logged in user's details
+     * @throws {Error} Error if fetch fails
+     */
+    async whoAmI() {
+        try {
+            const url = await apiInitializationService.getApiUrl('/auth/whoami');
+            const response = await fetch(url, { credentials: 'include' });
+            if (response.ok) {
+                const info = await response.json();
+                return (this.user = info.user);
+            }
+            else if (response.status === 401) {
+                return (this.user = undefined);
+            }
+            else {
+                this.user = undefined;
+                throw new Error('Failed checking authentication status');
+            }
+        }
+        catch (error) {
+            throw error instanceof Error ? error : new Error('Failed checking authentication status');
+        }
+    }
+    /**
+     * 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('/auth/signin');
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password }),
+                credentials: 'include',
+            });
+            if (response.ok) {
+                const user = await this.whoAmI();
+                if (user !== undefined) {
+                    return (this.user = user);
+                }
+                else {
+                    throw new Error('Failed signing in');
+                }
+            }
+            else {
+                throw new Error('Failed signing in');
+            }
+        }
+        catch (error) {
+            throw error instanceof Error ? error : new Error('Failed signing in');
+        }
+    }
+    /**
+     * Deauthenticates current user
+     *
+     * @return {Promise<void>}
+     * @throws {Error} Error if fetch fails
+     */
+    async signout() {
+        try {
+            const url = await apiInitializationService.getApiUrl('/auth/signout');
+            const response = await fetch(url, { credentials: 'include' });
+            if (response.ok) {
+                this.user = undefined;
+                return;
+            }
+            else {
+                throw new Error('Failed signing out');
+            }
+        }
+        catch (error) {
+            throw error instanceof Error ? error : new Error('Failed signing out');
+        }
+    }
+    /**
+     * If any API response returns an "Unauthenticated" response, call this method
+     * to update local authentication state to unauthenticated
+     */
+    _handleResponse401() {
+        this.user = undefined;
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Role } 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
+     */
+    constructor(baseControllerPath?: string);
+    /**
+     * Gets all roles in the system
+     * @param includeClaims - Whether to include claims in the response
+     * @returns List of all roles
+     */
+    getAllRoles(includeClaims: boolean): Promise<Role[]>;
+    /**
+     * Creates or updates a role
+     * @param roleDto - The role to create or update
+     * @returns The created or updated role
+     */
+    upsertRole(roleDto: Role): Promise<Role>;
+    /**
+     * Gets a role with its claims
+     * @param roleName - The name of the role
+     * @returns The role with its claims
+     */
+    getRoleWithClaims(roleName: string): Promise<Role>;
+    /**
+     * 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<void>;
+}

package/services/auth/client/AuthorizationManagementControllerClient/index.js

@@ -0,0 +1,102 @@
+import { apiInitializationService } from '../../..';
+/**
+ * Client for authorization management operations
+ *
+ * @export
+ * @class AuthorizationManagementControllerClient
+ */
+export class AuthorizationManagementControllerClient {
+    baseControllerPath;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     */
+    constructor(baseControllerPath = 'AuthorizationManagement') {
+        this.baseControllerPath = baseControllerPath;
+    }
+    /**
+     * Gets all roles in the system
+     * @param includeClaims - Whether to include claims in the response
+     * @returns List of all roles
+     */
+    async getAllRoles(includeClaims) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
+            const response = await fetch(url, {
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch all roles');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching all roles');
+        }
+    }
+    /**
+     * Creates or updates a role
+     * @param roleDto - The role to create or update
+     * @returns The created or updated role
+     */
+    async upsertRole(roleDto) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/UpsertRole`);
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(roleDto),
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(errorText || 'Failed to upsert role');
+            }
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error upserting role');
+        }
+    }
+    /**
+     * Gets a role with its claims
+     * @param roleName - The name of the role
+     * @returns The role with its claims
+     */
+    async getRoleWithClaims(roleName) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
+            const response = await fetch(url, {
+                credentials: 'include',
+            });
+            if (!response.ok)
+                throw new Error('Failed to fetch role with claims');
+            return response.json();
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error fetching role with claims');
+        }
+    }
+    /**
+     * Deletes a role
+     * @param roleName - The name of the role to delete
+     * @returns Promise that resolves when the role is deleted successfully
+     */
+    async deleteRole(roleName) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
+            const response = await fetch(url, {
+                method: 'DELETE',
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(errorText || 'Failed to delete role');
+            }
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error('Unknown error deleting role');
+        }
+    }
+}

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

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

package/services/auth/client/index.js

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

package/services/auth/index.d.ts

@@ -1,50 +1 @@
-import { User, UserInfo } from '../../data';
-export { User, UserInfo };
-/**
- * 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<TId, TUser = User<TId>> {
-    /**
-     * 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<TUser>} Currently logged in user's details
-     * @throws {Error} Error if fetch fails
-     */
-    whoAmI(): Promise<TUser | undefined>;
-    /**
-     * 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<TUser>;
-    /**
-     * Deauthenticates current user
-     *
-     * @return {Promise<void>}
-     * @throws {Error} Error if fetch fails
-     */
-    signout(): Promise<void>;
-    /**
-     * If any API response returns an "Unauthenticated" response, call this method
-     * to update local authentication state to unauthenticated
-     */
-    _handleResponse401(): void;
-}
+export * from './client';

package/services/auth/index.js

@@ -1,113 +1 @@
-import { apiInitializationService } from '..';
-/**
- * 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 {
-    /**
-     * 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<TUser>} Currently logged in user's details
-     * @throws {Error} Error if fetch fails
-     */
-    async whoAmI() {
-        try {
-            const url = await apiInitializationService.getApiUrl('/auth/whoami');
-            const response = await fetch(url, { credentials: 'include' });
-            if (response.ok) {
-                const info = await response.json();
-                return (this.user = info.user);
-            }
-            else if (response.status === 401) {
-                return (this.user = undefined);
-            }
-            else {
-                this.user = undefined;
-                throw new Error('Failed checking authentication status');
-            }
-        }
-        catch (error) {
-            throw error instanceof Error ? error : new Error('Failed checking authentication status');
-        }
-    }
-    /**
-     * 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('/auth/signin');
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ username, password }),
-                credentials: 'include',
-            });
-            if (response.ok) {
-                const user = await this.whoAmI();
-                if (user !== undefined) {
-                    return (this.user = user);
-                }
-                else {
-                    throw new Error('Failed signing in');
-                }
-            }
-            else {
-                throw new Error('Failed signing in');
-            }
-        }
-        catch (error) {
-            throw error instanceof Error ? error : new Error('Failed signing in');
-        }
-    }
-    /**
-     * Deauthenticates current user
-     *
-     * @return {Promise<void>}
-     * @throws {Error} Error if fetch fails
-     */
-    async signout() {
-        try {
-            const url = await apiInitializationService.getApiUrl('/auth/signout');
-            const response = await fetch(url, { credentials: 'include' });
-            if (response.ok) {
-                this.user = undefined;
-                return;
-            }
-            else {
-                throw new Error('Failed signing out');
-            }
-        }
-        catch (error) {
-            throw error instanceof Error ? error : new Error('Failed signing out');
-        }
-    }
-    /**
-     * If any API response returns an "Unauthenticated" response, call this method
-     * to update local authentication state to unauthenticated
-     */
-    _handleResponse401() {
-        this.user = undefined;
-    }
-}
+export * from './client';