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

package/dist/services/auth/client/AuthService/index.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/AuthorizationManagementControllerClient/index.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/AuthorizationManagementControllerClient/index.integration.test.d.ts

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

package/dist/services/auth/client/AuthorizationManagementControllerClient/index.integration.test.js

@@ -0,0 +1,89 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { AuthorizationManagementControllerClient } from '.';
+import fetchOrig from 'node-fetch';
+import fetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+// 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('AuthorizationManagementControllerClient', () => {
+    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 AuthorizationManagementControllerClient('/AuthorizationManagement', fetchService);
+    });
+    it('should fetch all roles', async () => {
+        const result = (await client.getAllRoles(false));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should fetch all roles with claims', async () => {
+        const result = (await client.getAllRoles(true));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result[0].claims).toBeDefined();
+    });
+    it('should return role with claims by name', async () => {
+        const newRole = { name: 'New Role Test Claims', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+        const create = (await client.upsertRole(newRole));
+        expect(create.ok).toBe(true);
+        const result = (await client.getRoleWithClaims(newRole.name));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.claims).toBeDefined();
+        expect(result.result.name).toBe(newRole.name);
+        expect(result.result.claims.length).toBe(newRole.claims.length);
+        expect(result.result.claims).toEqual(newRole.claims);
+    });
+    it('should create a new role with claims', async () => {
+        const newRole = { name: 'New Role', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+        const result = (await client.upsertRole(newRole));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.name).toBe(newRole.name);
+        expect(result.result.claims.length).toBe(newRole.claims.length);
+        expect(result.result.claims).toEqual(newRole.claims);
+    });
+    it('should delete role', async () => {
+        const role = { name: 'Temp Role', claims: [] };
+        const create = (await client.upsertRole(role));
+        expect(create.ok).toBe(true);
+        const deleteResult = await client.deleteRole(role.name);
+        expect(deleteResult.ok).toBe(true);
+    });
+});

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

@@ -0,0 +1,148 @@
+import { apiInitializationService } from '../../..';
+import { ErrorCode } from '../../../../data';
+import { fail, ok } from '../../../../utils/result';
+/**
+ * Client for authorization management operations
+ *
+ * @export
+ * @class AuthorizationManagementControllerClient
+ */
+export class AuthorizationManagementControllerClient {
+    baseControllerPath;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath = 'AuthorizationManagement', 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
+    /**
+     * 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
+     */
+    async getAllRoles(includeClaims, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
+            const res = await this.httpService.request(url, {
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error fetching all roles',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Gets a role with its claims
+     * @param roleName - The name of the role
+     * @param signal
+     * @returns The role with its claims
+     */
+    async getRoleWithClaims(roleName, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
+            const res = await this.httpService.request(url, {
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
+        }
+        catch (err) {
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error fetching role with claims',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * 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 res = await this.httpService.request(url, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(roleDto),
+                credentials: 'include',
+            });
+            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 upserting role',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * 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 res = await this.httpService.request(url, {
+                method: 'DELETE',
+                credentials: 'include',
+            });
+            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 deleting the role ${roleName}`,
+                    metadata: {},
+                },
+            });
+        }
+    }
+}

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

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

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

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

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

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

package/dist/services/auth/index.js

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

package/dist/services/index.d.ts

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

package/dist/services/index.js

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

package/dist/utils/authorization/index.d.ts

@@ -0,0 +1,17 @@
+import { IPolicy } from '../../data';
+/**
+ * Checks if a policy is valid for the given parameters.
+ *
+ * @param policy Policy to check, either an instance or a class.
+ * @param params Parameters to pass to the policy check function.
+ * @returns A promise that resolves if the policy is valid, rejects otherwise.
+ */
+export declare function check<TParams extends unknown[]>(policy: IPolicy<TParams> | (new () => IPolicy<TParams>), ...params: TParams): Promise<boolean>;
+/**
+ * Composes multiple policies into a single policy.
+ *
+ * @param composition Composition method, either 'AND' or 'OR'.
+ * @param policies Policies to compose.
+ * @returns A new policy that represents the composition of the policies.
+ */
+export declare function compose<TParams extends unknown[]>(composition: 'AND' | 'OR', ...policies: IPolicy<TParams>[]): IPolicy<TParams>;

package/dist/utils/authorization/index.js

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

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './search';

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './search';

package/dist/utils/result/index.d.ts

@@ -0,0 +1,21 @@
+type TResultBase = {
+    readonly ok: boolean;
+};
+/**
+ * Represents a result of an operation.
+ * It can be either a success or an error.
+ */
+export type Result<TSuccess extends TResultBase, TError extends TResultBase> = TSuccess | TError;
+/**
+ * Creates a success result from the given argument.
+ * @param arg - The argument to create a success result from.
+ * @returns A success result.
+ */
+export declare function ok<TSuccess extends TResultBase, TError extends TResultBase>(arg?: Omit<TSuccess, 'ok'>): Result<TSuccess, TError>;
+/**
+ * Creates an error result from the given argument.
+ * @param arg - The argument to create an error result from.
+ * @returns An error result.
+ */
+export declare function fail<TSuccess extends TResultBase, TError extends TResultBase>(arg: Omit<TError, 'ok'>): Result<TSuccess, TError>;
+export {};

package/dist/utils/result/index.js

@@ -0,0 +1,16 @@
+/**
+ * Creates a success result from the given argument.
+ * @param arg - The argument to create a success result from.
+ * @returns A success result.
+ */
+export function ok(arg) {
+    return { ok: true, ...arg };
+}
+/**
+ * Creates an error result from the given argument.
+ * @param arg - The argument to create an error result from.
+ * @returns An error result.
+ */
+export function fail(arg) {
+    return { ok: false, ...arg };
+}

package/dist/utils/search/index.d.ts

@@ -0,0 +1,34 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, ReadSelectedSearchDefinitionDto } from '../../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all ReadSelectedSearchPropertyDefinitionDto property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - propertyName: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export declare function condition<T>(logicalOperator: ReadSelectedLogicalOperator, ...conditions: Array<{
+    propertyName: keyof T;
+    operator: ReadSelectedComparisonOperator;
+    value: unknown;
+    valueType: ReadSelectedPropertyType;
+}>): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export declare function and<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export declare function or<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Preset implementation for filtering by searchTerm. String types will search by provided `textSearchableProperties` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchableProperties`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export declare function searchTerm<T>(searchTerm: string, textSearchableProperties: (keyof T)[], numericSearchableProperties: (keyof T)[]): void | ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchableProperty`.
+ */
+export declare function dateInterval<T>(fromDate: Date, toDate: Date, fromDateComparisonOperator: ReadSelectedComparisonOperator, toDateComparisonOperator: ReadSelectedComparisonOperator, valueType: ReadSelectedPropertyType, searchableProperty: keyof T): void | ReadSelectedSearchDefinitionDto<T>;
+export declare function toPascalCase<T>(str: keyof T): keyof T;