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

package/dist/services/api/api-read-controller-client.d.ts

@@ -0,0 +1,62 @@
+import { IHttpService } from '../../services';
+import { ApiResponseDto, EmptyMetadataDto, IIdentifiable, ReadMetadataDto, ReadSelectedDefinitionDto } from '../../data';
+/**
+ * Client for reading all entities from a read controller.
+ */
+export interface IReadAllClient<TKey, TResultDto extends IIdentifiable<TKey>> {
+    readAll(signal?: AbortSignal): Promise<ApiResponseDto<TResultDto[], ReadMetadataDto>>;
+}
+/**
+ * Client for reading selected entities from a read controller.
+ */
+export interface IReadSelectedClient<TKey, TResultDto extends IIdentifiable<TKey>> {
+    readSelected(definition: ReadSelectedDefinitionDto<TResultDto>, signal?: AbortSignal): Promise<ApiResponseDto<TResultDto[], ReadMetadataDto>>;
+}
+/**
+ * Client for reading a single entity from a read controller.
+ */
+export interface IReadSingleClient<TKey, TResultDto extends IIdentifiable<TKey>> {
+    readSingle(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<TResultDto, EmptyMetadataDto>>;
+}
+/**
+ * Client for reading entities from a read controller.
+ */
+export interface IApiReadControllerClient<TKey, TResultDto extends IIdentifiable<TKey>, TSingleResultDto extends IIdentifiable<TKey>> extends IReadAllClient<TKey, TResultDto>, IReadSelectedClient<TKey, TResultDto>, IReadSingleClient<TKey, TSingleResultDto> {
+}
+/**
+ * Base client for read-only API controllers
+ */
+export declare class ApiReadControllerClient<TKey, TResultDto extends IIdentifiable<TKey>, TSingleResultDto extends IIdentifiable<TKey>> implements IApiReadControllerClient<TKey, TResultDto, TSingleResultDto> {
+    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;
+    /**
+     * Fetches all entities from the read controller.
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} List of all entities with metadata
+     */
+    readAll(signal?: AbortSignal): Promise<ApiResponseDto<TResultDto[], ReadMetadataDto>>;
+    /**
+     * Fetches selected entities based on a filter definition.
+     * @param {any} definition - The filter definition object
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} The result of the read operation with metadata
+     */
+    readSelected(definition: ReadSelectedDefinitionDto<TResultDto>, signal?: AbortSignal): Promise<ApiResponseDto<TResultDto[], ReadMetadataDto>>;
+    /**
+     * Fetches a single entity by its ID.
+     * @param {TKey} id - The ID of the entity
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto, EmptyMetadataDto>>} The requested entity
+     */
+    readSingle(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<TSingleResultDto, EmptyMetadataDto>>;
+}

package/dist/services/api/api-read-controller-client.integration.test.d.ts

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

package/dist/services/api/api-read-controller-client.integration.test.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ApiReadControllerClient } from '.';
+import { FetchHttpService } from '..';
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType } from '../../data';
+describe('ApiReadControllerClient', () => {
+    let client;
+    let fetchService;
+    beforeEach(() => {
+        fetchService = new FetchHttpService();
+        client = new ApiReadControllerClient('/VehiclesSlim', fetchService);
+    });
+    it('should use injected HTTP service for readAll', async () => {
+        const result = (await client.readAll());
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should use injected HTTP service for readSingle', async () => {
+        const testId = 1;
+        const result = (await client.readSingle(testId));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(typeof result.result).toBe('object');
+        expect(result.result.id).toBe(testId);
+    });
+    it('should use injected HTTP service for readSelected', async () => {
+        const definition = {
+            searchDefinition: {
+                searches: [
+                    {
+                        propertyCriteria: [
+                            {
+                                propertyName: 'Brand',
+                                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                                valueType: ReadSelectedPropertyType.String,
+                                value: 'Audi',
+                            },
+                            {
+                                propertyName: 'Brand',
+                                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                                valueType: ReadSelectedPropertyType.String,
+                                value: 'BMW',
+                            },
+                        ],
+                        logicalOperator: ReadSelectedLogicalOperator.Or,
+                    },
+                ],
+                logicalOperator: ReadSelectedLogicalOperator.And,
+            },
+        };
+        const result = (await client.readSelected(definition));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should handle HTTP errors properly', async () => {
+        const invalidClient = new ApiReadControllerClient('/InvalidPath', fetchService);
+        const result = await invalidClient.readAll();
+        expect(result.ok).toBe(false);
+    });
+});

package/dist/services/api/api-read-controller-client.js

@@ -0,0 +1,129 @@
+import { apiInitializationService } from '../../services';
+import { ErrorCode, } from '../../data';
+import { fail, ok } from '../../utils/result';
+function isAbortError(err) {
+    return err instanceof DOMException && err.name === 'AbortError';
+}
+/**
+ * Base client for read-only API controllers
+ */
+export class ApiReadControllerClient {
+    baseControllerPath;
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath, 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
+    // #region API
+    /**
+     * Fetches all entities from the read controller.
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} List of all entities with metadata
+     */
+    async readAll(signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadAll`);
+            const res = await this.httpService.request(url, { method: 'GET', credentials: 'include', signal });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
+        }
+        catch (err) {
+            if (isAbortError(err)) {
+                return fail({
+                    error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} },
+                });
+            }
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error fetching all records',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Fetches selected entities based on a filter definition.
+     * @param {any} definition - The filter definition object
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} The result of the read operation with metadata
+     */
+    async readSelected(definition, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSelected`);
+            const res = await this.httpService.request(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(definition),
+                credentials: 'include',
+                signal,
+            });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
+        }
+        catch (err) {
+            if (isAbortError(err)) {
+                return fail({
+                    error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} },
+                });
+            }
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: 'Unknown error fetching selected records',
+                    metadata: {},
+                },
+            });
+        }
+    }
+    /**
+     * Fetches a single entity by its ID.
+     * @param {TKey} id - The ID of the entity
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto, EmptyMetadataDto>>} The requested entity
+     */
+    async readSingle(id, signal) {
+        try {
+            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSingle?id=${encodeURIComponent(String(id))}`);
+            const res = await this.httpService.request(url, { method: 'GET', credentials: 'include', signal });
+            if (!res.ok) {
+                return fail(await res.json());
+            }
+            return ok(await res.json());
+        }
+        catch (err) {
+            if (isAbortError(err)) {
+                return fail({
+                    error: { code: ErrorCode.Aborted, message: 'Request was aborted', metadata: {} },
+                });
+            }
+            console.error(err);
+            return fail({
+                error: {
+                    code: ErrorCode.UnknownError,
+                    message: `Unknown error fetching record with id ${id}`,
+                    metadata: {},
+                },
+            });
+        }
+    }
+}

package/dist/services/api/http-service/fetch-http-service.d.ts

@@ -0,0 +1,7 @@
+import { HttpRequestConfig, HttpResponse, IHttpService } from '../../../services';
+/**
+ * Default HTTP service implementation using the Fetch API
+ */
+export declare class FetchHttpService implements IHttpService {
+    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+}

package/dist/services/api/http-service/fetch-http-service.integration.test.d.ts

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

package/dist/services/api/http-service/fetch-http-service.integration.test.js

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { FetchHttpService } from '../..';
+const baseUrl = 'http://localhost:5000/api';
+const credentials = {
+    username: 'admin@test.com',
+    password: 'Password1234!',
+};
+describe('FetchHttpService', () => {
+    let fetchService;
+    beforeEach(() => {
+        fetchService = new FetchHttpService();
+    });
+    it('should make a GET request successfully', async () => {
+        const result = await fetchService.request(`${baseUrl}/AnythingManuallyMappedRead/ReadAll`);
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(200);
+        expect(result.statusText).toBe('OK');
+        const jsonData = await result.json();
+        expect(jsonData.result).toBeDefined();
+        expect(jsonData.error).toBeNull();
+    });
+    it('should make a POST request with body', async () => {
+        const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(credentials),
+        });
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(204);
+    });
+    it('should handle non-ok responses', async () => {
+        const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ username: credentials.username, password: `${credentials.password}wrong` }),
+        });
+        expect(result.ok).toBe(false);
+        expect(result.status).toBe(400);
+        expect(result.statusText).toBe('Bad Request');
+        const jsonData = await result.json();
+        expect(jsonData.result).toBeNull();
+        expect(jsonData.error).toBeDefined();
+        expect(jsonData.error.code).toBe(400);
+        expect(jsonData.error.message).toBe('Invalid email or password');
+    });
+    it('should handle fetch errors from backend', async () => {
+        const result = await fetchService.request('http://localhost:5000/api/error');
+        expect(result.ok).toBe(false);
+        expect(result.status).toBe(404);
+        expect(result.statusText).toBe('Not Found');
+    });
+});

package/dist/services/api/http-service/fetch-http-service.js

@@ -0,0 +1,29 @@
+// Ignore eslint any error in this file
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Default HTTP service implementation using the Fetch API
+ */
+export class FetchHttpService {
+    async request(url, config) {
+        const response = await fetch(url, {
+            method: config?.method || 'GET',
+            headers: config?.headers,
+            body: config?.body,
+            credentials: config?.credentials || 'include',
+            signal: config?.signal,
+        });
+        // Convert Headers to a plain object
+        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(),
+        };
+    }
+}

package/dist/services/api/http-service/http-request-config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * HTTP request configuration interface
+ */
+export interface HttpRequestConfig {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: string;
+    credentials?: RequestCredentials;
+    signal?: AbortSignal;
+}

package/dist/services/api/http-service/http-request-config.js

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

package/dist/services/api/http-service/http-response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * HTTP response interface
+ */
+export interface HttpResponse<T = any> {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    json(): Promise<T>;
+    text(): Promise<string>;
+}

package/dist/services/api/http-service/http-response.js

@@ -0,0 +1,3 @@
+// Ignore eslint any error in this file
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

package/dist/services/api/http-service/http-service.d.ts

@@ -0,0 +1,5 @@
+import { FetchHttpService } from './fetch-http-service';
+/**
+ * Default HTTP service instance
+ */
+export declare const defaultHttpService: FetchHttpService;

package/dist/services/api/http-service/http-service.js

@@ -0,0 +1,5 @@
+import { FetchHttpService } from './fetch-http-service';
+/**
+ * Default HTTP service instance
+ */
+export const defaultHttpService = new FetchHttpService();

package/dist/services/api/http-service/ihttp-service.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequestConfig, HttpResponse } from '../../../services';
+/**
+ * Abstract HTTP service interface that can be implemented by different HTTP clients
+ */
+export interface IHttpService {
+    /**
+     * Performs an HTTP request
+     * @param url - The URL to make the request to
+     * @param config - Request configuration
+     * @returns Promise that resolves to the HTTP response
+     */
+    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+}

package/dist/services/api/http-service/ihttp-service.js

@@ -0,0 +1,3 @@
+// Ignore eslint any error in this file
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

package/dist/services/api/http-service/index.d.ts

@@ -0,0 +1,5 @@
+export * from './http-service';
+export * from './fetch-http-service';
+export * from './http-request-config';
+export * from './http-response';
+export * from './ihttp-service';

package/dist/services/api/http-service/index.js

@@ -0,0 +1,5 @@
+export * from './http-service';
+export * from './fetch-http-service';
+export * from './http-request-config';
+export * from './http-response';
+export * from './ihttp-service';

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

@@ -1,5 +1,5 @@
-export * from './HttpService';
-export * from './ApiInitializationService';
-export * from './ApiReadControllerClient';
-export * from './ApiCrudControllerClient';
-export * from './UserManagementControllerClient';
+export * from './http-service';
+export * from './api-initialization-service';
+export * from './api-read-controller-client';
+export * from './api-crud-controller-client';
+export * from './user-management-controller-client';

package/dist/services/api/index.js

@@ -1,5 +1,5 @@
-export * from './HttpService';
-export * from './ApiInitializationService';
-export * from './ApiReadControllerClient';
-export * from './ApiCrudControllerClient';
-export * from './UserManagementControllerClient';
+export * from './http-service';
+export * from './api-initialization-service';
+export * from './api-read-controller-client';
+export * from './api-crud-controller-client';
+export * from './user-management-controller-client';

package/dist/services/api/user-management-controller-client.d.ts

@@ -0,0 +1,80 @@
+import { ApiCrudControllerClient, IHttpService } from '../../services';
+import { ApiResponseDto, ClaimDto, EmptyMetadataDto, ReadMetadataDto, UserDto } from '../../data';
+/**
+ * Client for user management operations
+ *
+ * @export
+ * @class UserManagementControllerClient
+ * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
+ * @template TUser - Data Transfer Object representing the user entity
+ */
+export declare class UserManagementControllerClient<TKey, TResultDto extends UserDto<TKey>, TSingleResultDto extends UserDto<TKey>, TInsertRequestDto extends UserDto<TKey>, TUpdateRequestDto extends UserDto<TKey>> extends ApiCrudControllerClient<TKey, TResultDto, TSingleResultDto, TInsertRequestDto, TUpdateRequestDto> {
+    /**
+     * Constructor
+     * @param baseControllerPath Base path to API controller
+     * @param httpService HTTP service implementation to use for requests
+     */
+    constructor(baseControllerPath: string, httpService?: IHttpService);
+    /**
+     * Gets the roles assigned to a user
+     * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns List of role names assigned to the user
+     */
+    getUserRoles(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<string[], ReadMetadataDto>>;
+    /**
+     * Gets the claims assigned to a user
+     * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns List of claims assigned to the user
+     */
+    getUserClaims(id: TKey, signal?: AbortSignal): Promise<ApiResponseDto<ClaimDto[], ReadMetadataDto>>;
+    /**
+     * Sets the roles for a user, replacing all existing roles
+     * @param id - The ID of the user
+     * @param roles - The list of role names to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are set successfully
+     */
+    setUserRoles(id: TKey, roles: string[], signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * Adds roles to a user
+     * @param id - The ID of the user
+     * @param roles - The list of role names to add
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are added successfully
+     */
+    addRolesToUser(id: TKey, roles: string[], signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * Removes roles from a user
+     * @param id - The ID of the user
+     * @param roles - The list of role names to remove
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the roles are removed successfully
+     */
+    removeRolesFromUser(id: TKey, roles: string[], signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * Adds claims to a user
+     * @param id - The ID of the user
+     * @param claims - The list of claims to add
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the claims are added successfully
+     */
+    addUserClaims(id: TKey, claims: ClaimDto[], signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * Removes claims from a user
+     * @param id - The ID of the user
+     * @param claims - The list of claims to remove
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the claims are removed successfully
+     */
+    removeUserClaims(id: TKey, claims: ClaimDto[], signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+    /**
+     * Changes the password for a user
+     * @param id - The ID of the user
+     * @param newPassword - The new password to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns Promise that resolves when the password is changed successfully
+     */
+    changePassword(id: TKey, newPassword: string, signal?: AbortSignal): Promise<ApiResponseDto<undefined, EmptyMetadataDto>>;
+}

package/dist/services/api/user-management-controller-client.integration.test.d.ts

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

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

@@ -0,0 +1,60 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { UserManagementControllerClient } 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('UserManagementControllerClient', () => {
+    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 UserManagementControllerClient('/users', fetchService);
+    });
+    it('should use injected HTTP service for getUserRoles', async () => {
+        const result = (await client.getUserRoles(1));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should use injected HTTP service for getUserClaims', async () => {
+        const result = (await client.getUserClaims(1));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+});