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

package/dist/services/auth/client/authorization-management-controller-client.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/authorization-management-controller-client.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

@@ -1,2 +1,2 @@
-export * from './AuthorizationManagementControllerClient';
-export * from './AuthService';
+export * from './authorization-management-controller-client';
+export * from './auth-service';

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

@@ -1,2 +1,2 @@
-export * from './AuthorizationManagementControllerClient';
-export * from './AuthService';
+export * from './authorization-management-controller-client';
+export * from './auth-service';

package/dist/utils/authorization.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.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/events.d.ts

@@ -0,0 +1,19 @@
+export declare class SingularEventTarget<T> {
+    private _target;
+    addEventListener(callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener(callback: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
+    dispatchEvent(value: T): void;
+}
+/**
+ * Defines a readable property with a companion change event target.
+ * Use with intersection types to compose observable interfaces.
+ *
+ * @example
+ * type MyObservable = IHasObservableProperty<'name', string>
+ *   & IHasObservableProperty<'age', number>;
+ */
+export type IHasObservableProperty<TName extends string, T> = {
+    readonly [K in TName]: T;
+} & {
+    readonly [K in `${TName}Changed`]: SingularEventTarget<T>;
+};

package/dist/utils/events.js

@@ -0,0 +1,12 @@
+export class SingularEventTarget {
+    _target = new EventTarget();
+    addEventListener(callback, options) {
+        this._target.addEventListener('change', callback, options);
+    }
+    removeEventListener(callback, options) {
+        this._target.removeEventListener('change', callback, options);
+    }
+    dispatchEvent(value) {
+        this._target.dispatchEvent(new CustomEvent('change', { detail: value }));
+    }
+}

package/dist/utils/index.d.ts

@@ -1,2 +1,4 @@
+export * from './events';
 export * from './result';
 export * from './search';
+export * from './authorization';

package/dist/utils/index.js

@@ -1,2 +1,4 @@
+export * from './events';
 export * from './result';
 export * from './search';
+export * from './authorization';

package/dist/utils/result.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.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.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;

package/dist/utils/search.js

@@ -0,0 +1,106 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, } 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 function condition(logicalOperator, ...conditions) {
+    return {
+        logicalOperator: logicalOperator,
+        propertyCriteria: conditions.map(condition => ({
+            propertyName: toPascalCase(condition.propertyName),
+            comparisonOperator: condition.operator,
+            valueType: condition.valueType,
+            value: condition.value,
+        })),
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.And,
+        searches: definitions,
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.Or,
+        searches: definitions,
+    };
+}
+/**
+ * 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 function searchTerm(searchTerm, textSearchableProperties, numericSearchableProperties) {
+    let comparisonOperator;
+    let valueType;
+    let searchableProperties;
+    let searchValue;
+    try {
+        const numericValue = parseInt(searchTerm);
+        if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
+            comparisonOperator = ReadSelectedComparisonOperator.Equal;
+            valueType = ReadSelectedPropertyType.Int;
+            searchableProperties = numericSearchableProperties;
+            searchValue = numericValue;
+        }
+        else {
+            comparisonOperator = ReadSelectedComparisonOperator.Contains;
+            valueType = ReadSelectedPropertyType.String;
+            searchableProperties = textSearchableProperties;
+            searchValue = searchTerm;
+        }
+        const searchConditions = searchableProperties.map(propertyName => ({
+            propertyName: toPascalCase(propertyName),
+            operator: comparisonOperator,
+            value: searchValue,
+            valueType: valueType,
+        }));
+        return condition(ReadSelectedLogicalOperator.Or, ...searchConditions);
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * 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 function dateInterval(fromDate, toDate, fromDateComparisonOperator, toDateComparisonOperator, valueType, searchableProperty) {
+    try {
+        if (!(valueType === ReadSelectedPropertyType.DateOnly ||
+            valueType === ReadSelectedPropertyType.DateTime ||
+            valueType === ReadSelectedPropertyType.DateTimeOffset)) {
+            return;
+        }
+        return condition(ReadSelectedLogicalOperator.And, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: fromDateComparisonOperator,
+            value: fromDate,
+            valueType: valueType,
+        }, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: toDateComparisonOperator,
+            value: toDate,
+            valueType: valueType,
+        });
+    }
+    catch {
+        return;
+    }
+}
+export function toPascalCase(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellegens/cornerstone-client",
-  "version": "0.0.9999-alpha-41",
+  "version": "0.0.9999-alpha-43",
   "private": false,
   "publishable": true,
   "main": "./dist/index.js",
@@ -16,18 +16,18 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/express": "^5.0.6",
-    "@types/node": "^25.3.1",
-    "eslint": "^10.0.2",
+    "@types/node": "^25.4.0",
+    "eslint": "^10.0.3",
     "eslint-config-prettier": "^10.1.8",
     "express": "^5.2.1",
-    "globals": "^17.3.0",
+    "globals": "^17.4.0",
     "prettier": "^3.8.1",
     "rxjs": "~7.8.2",
     "tsc-alias": "^1.8.16",
-    "typescript-eslint": "^8.56.1",
+    "typescript-eslint": "^8.57.0",
     "vite": "7.3.1",
     "vitest": "^4.0.18",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.18",
     "zod": "^3.25.76"
   },
   "dependencies": {