@intellegens/cornerstone-client 0.0.9999-alpha-2 → 0.0.9999-alpha-4

package/services/api/UserManagementControllerClient/index.js

@@ -1,5 +1,7 @@
 import { ApiCrudControllerClient } from '../ApiCrudControllerClient';
 import { apiInitializationService } from '../ApiInitializationService';
+import { ErrorCode } from '../../../data';
+import { fail, ok } from '../../../utils/result';
 /**
  * Client for user management operations
  *
@@ -31,16 +33,20 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
                 credentials: 'include',
                 signal,
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error fetching user roles');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while fetching user roles',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -57,16 +63,20 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
                 credentials: 'include',
                 signal,
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error fetching user claims');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while fetching user claims',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -82,16 +92,20 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
                 credentials: 'include',
                 signal,
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error fetching all roles');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while fetching all roles',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -104,7 +118,7 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
     async changePasswordAsync(id, newPassword, signal) {
         try {
             const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, 'ChangePassword', encodeURIComponent(String(id)));
-            const response = await this.httpService.requestAsync(url, {
+            const res = await this.httpService.requestAsync(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -113,12 +127,20 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
                 credentials: 'include',
                 signal,
             });
-            if (!response.ok)
-                throw undefined;
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error changing password');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error while changing password',
+                    metadata: {},
+                },
+            });
         }
     }
 }

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

@@ -1,4 +1,4 @@
-import { ApiSuccessResponseDto, EmptyMetadataDto, UserDto, UserInfoDto } from '../../../../data';
+import { ApiResponseDto, EmptyMetadataDto, UserDto, UserInfoDto } from '../../../../data';
 export { UserDto, UserInfoDto };
 /**
  * AuthService class is responsible for managing user authentication operations.
@@ -25,7 +25,7 @@ export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKe
      * @return {Promise<UserInfoDto<TKey, TUser>>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    whoAmIAsync(): Promise<ApiSuccessResponseDto<UserInfoDto<TKey, TUser> | undefined, EmptyMetadataDto>>;
+    whoAmIAsync(): Promise<ApiResponseDto<UserInfoDto<TKey, TUser>, EmptyMetadataDto>>;
     /**
      * Authenticates a user using their username and password, and retrieves user's details
      *
@@ -34,14 +34,14 @@ export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKe
      * @return {Promise<TUser>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    signinAsync(username: string, password: string): Promise<ApiSuccessResponseDto<TUser, EmptyMetadataDto>>;
+    signinAsync(username: string, password: string): Promise<ApiResponseDto<TUser, EmptyMetadataDto>>;
     /**
      * Deauthenticates current user
      *
      * @return {Promise<void>}
      * @throws {Error} Error if fetch fails
      */
-    signoutAsync(): Promise<void>;
+    signoutAsync(): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
     /**
      * If any API response returns an "Unauthenticated" response, call this method
      * to update local authentication state to unauthenticated

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

@@ -1,4 +1,6 @@
 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.
@@ -31,23 +33,21 @@ export class AuthService {
         try {
             const url = await apiInitializationService.getApiUrlAsync('/auth/whoami');
             const res = await fetch(url, { credentials: 'include' });
-            if (!res.ok && res.status !== 401) {
+            if (!res.ok) {
                 this.user = undefined;
-                throw undefined;
+                return fail(await res.json());
             }
-            if (!res.ok && res.status === 401) {
-                this.user = undefined;
-                return { result: this.user, metadata: {} };
-            }
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            this.user = result.user;
-            return { result: { user: this.user, accessTokenExpiry: result.accessTokenExpiry }, metadata };
+            return (await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Failed checking authentication status');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed checking authentication status',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -67,18 +67,28 @@ export class AuthService {
                 body: JSON.stringify({ username, password }),
                 credentials: 'include',
             });
-            if (!res.ok)
-                throw undefined;
+            if (!res.ok) {
+                return fail(await res.json());
+            }
             // TODO: Handle tokens if not using cookies
-            const { result, metadata } = await this.whoAmIAsync();
-            if (result === undefined)
-                throw undefined;
-            this.user = result.user;
-            return { result: this.user, metadata };
+            const whoamIRes = await this.whoAmIAsync();
+            if (!whoamIRes.ok) {
+                return whoamIRes;
+            }
+            return ok({
+                result: whoamIRes.result.user,
+                metadata: whoamIRes.metadata
+            });
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Failed signing in');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed signing in',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -91,14 +101,21 @@ export class AuthService {
         try {
             const url = await apiInitializationService.getApiUrlAsync('/auth/signout');
             const res = await fetch(url, { credentials: 'include' });
-            if (!res.ok)
-                throw undefined;
+            if (!res.ok) {
+                return fail(await res.json());
+            }
             this.user = undefined;
-            return;
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Failed signing out');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Failed signing out',
+                    metadata: {},
+                },
+            });
         }
     }
     /**

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

@@ -1,4 +1,4 @@
-import { ApiSuccessResponseDto, EmptyMetadataDto, ReadMetadataDto, RoleDto } from '../../../../data';
+import { ApiResponseDto, EmptyMetadataDto, ReadMetadataDto, RoleDto } from '../../../../data';
 /**
  * Client for authorization management operations
  *
@@ -15,25 +15,27 @@ export declare class AuthorizationManagementControllerClient {
     /**
      * 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
      */
-    getAllRolesAsync(includeClaims: boolean): Promise<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>>;
+    getAllRolesAsync(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
      */
-    getRoleWithClaimsAsync(roleName: string): Promise<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>>;
+    getRoleWithClaimsAsync(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
      */
-    upsertRoleAsync(roleDto: RoleDto): Promise<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>>;
+    upsertRoleAsync(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
      */
-    deleteRoleAsync(roleName: string): Promise<void>;
+    deleteRoleAsync(roleName: string): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
 }

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

@@ -1,4 +1,6 @@
 import { apiInitializationService } from '../../..';
+import { ErrorCode } from '../../../../data';
+import { fail, ok } from '../../../../utils/result';
 /**
  * Client for authorization management operations
  *
@@ -17,47 +19,59 @@ export class AuthorizationManagementControllerClient {
     /**
      * 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 getAllRolesAsync(includeClaims) {
+    async getAllRolesAsync(includeClaims, signal) {
         try {
             const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
             const res = await fetch(url, {
                 credentials: 'include',
+                signal,
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error fetching all roles');
+            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 getRoleWithClaimsAsync(roleName) {
+    async getRoleWithClaimsAsync(roleName, signal) {
         try {
             const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
             const res = await fetch(url, {
                 credentials: 'include',
+                signal,
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error fetching role with claims');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error fetching role with claims',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -76,16 +90,20 @@ export class AuthorizationManagementControllerClient {
                 body: JSON.stringify(roleDto),
                 credentials: 'include',
             });
-            if (!res.ok)
-                throw undefined;
-            const { success, result, metadata, error } = (await res.json());
-            if (!success)
-                throw new Error(error.message);
-            return { result, metadata };
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error upserting role');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error upserting role',
+                    metadata: {},
+                },
+            });
         }
     }
     /**
@@ -96,16 +114,24 @@ export class AuthorizationManagementControllerClient {
     async deleteRoleAsync(roleName) {
         try {
             const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
-            const response = await fetch(url, {
+            const res = await fetch(url, {
                 method: 'DELETE',
                 credentials: 'include',
             });
-            if (!response.ok)
-                throw undefined;
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(undefined);
         }
         catch (err) {
-            // TODO: Extract error from well-formed response
-            throw err instanceof Error ? err : new Error('Unknown error deleting role');
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: `Unknown error while deleting the role ${roleName}`,
+                    metadata: {},
+                },
+            });
         }
     }
 }

package/utils/index.d.ts

@@ -1,37 +1,2 @@
-import { PropertyPathDto, 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:
- *   - path: 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(logicalOperator: ReadSelectedLogicalOperator, ...conditions: Array<{
-    path: PropertyPathDto;
-    operator: ReadSelectedComparisonOperator;
-    value: any;
-    valueType: ReadSelectedPropertyType;
-}>): ReadSelectedSearchDefinitionDto;
-/**
- * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
- */
-export declare function and(...definitions: ReadSelectedSearchDefinitionDto[]): ReadSelectedSearchDefinitionDto;
-/**
- * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
- */
-export declare function or(...definitions: ReadSelectedSearchDefinitionDto[]): ReadSelectedSearchDefinitionDto;
-/**
- * Preset implementation for filtering by `searchTerm`. String types will search by provided `textSearchablePaths` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchablePaths`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
- */
-export declare function searchTerm(searchTerm: string, textSearchablePaths: string[][], numericSearchablePaths: string[][]): void | ReadSelectedSearchDefinitionDto;
-/**
- * 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 `searchablePath`.
- */
-export declare function dateInterval(fromDate: Date, toDate: Date, fromDateComparisonOperator: ReadSelectedComparisonOperator, toDateComparisonOperator: ReadSelectedComparisonOperator, valueType: ReadSelectedPropertyType, searchablePath: PropertyPathDto): void | ReadSelectedSearchDefinitionDto;
-/**
- * Converts the camel case used on the TS client to Pascal case expected by the API
- */
-export declare function toPascalCase(str: PropertyPathDto): PropertyPathDto;
+export * from './result';
+export * from './search';

package/utils/index.js

@@ -1,106 +1,2 @@
-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:
- *   - path: 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 => ({
-            propertyPath: toPascalCase(condition.path),
-            comparisonOperator: condition.operator,
-            valueType: condition.valueType,
-            value: condition.value,
-        })),
-    };
-}
-/**
- * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
- */
-export function and(...definitions) {
-    return {
-        logicalOperator: ReadSelectedLogicalOperator.And,
-        nestedSearchCriteria: definitions,
-    };
-}
-/**
- * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
- */
-export function or(...definitions) {
-    return {
-        logicalOperator: ReadSelectedLogicalOperator.Or,
-        nestedSearchCriteria: definitions,
-    };
-}
-/**
- * Preset implementation for filtering by `searchTerm`. String types will search by provided `textSearchablePaths` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchablePaths`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
- */
-export function searchTerm(searchTerm, textSearchablePaths, numericSearchablePaths) {
-    let comparisonOperator;
-    let valueType;
-    let searchablePaths;
-    let searchValue;
-    try {
-        const numericValue = parseInt(searchTerm);
-        if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
-            comparisonOperator = ReadSelectedComparisonOperator.Equal;
-            valueType = ReadSelectedPropertyType.Int;
-            searchablePaths = numericSearchablePaths;
-            searchValue = numericValue;
-        }
-        else {
-            comparisonOperator = ReadSelectedComparisonOperator.Contains;
-            valueType = ReadSelectedPropertyType.String;
-            searchablePaths = textSearchablePaths;
-            searchValue = searchTerm;
-        }
-        const searchConditions = searchablePaths.map(path => ({
-            path: toPascalCase(path),
-            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 `searchablePath`.
- */
-export function dateInterval(fromDate, toDate, fromDateComparisonOperator, toDateComparisonOperator, valueType, searchablePath) {
-    try {
-        if (!(valueType === ReadSelectedPropertyType.DateOnly ||
-            valueType === ReadSelectedPropertyType.DateTime ||
-            valueType === ReadSelectedPropertyType.DateTimeOffset)) {
-            return;
-        }
-        return condition(ReadSelectedLogicalOperator.And, {
-            path: toPascalCase(searchablePath),
-            operator: fromDateComparisonOperator,
-            value: fromDate,
-            valueType: valueType,
-        }, {
-            path: toPascalCase(searchablePath),
-            operator: toDateComparisonOperator,
-            value: toDate,
-            valueType: valueType,
-        });
-    }
-    catch {
-        return;
-    }
-}
-/**
- * Converts the camel case used on the TS client to Pascal case expected by the API
- */
-export function toPascalCase(str) {
-    return str.map(part => part.charAt(0).toUpperCase() + part.slice(1));
-}
+export * from './result';
+export * from './search';

package/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/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 };
+}