@intellegens/cornerstone-client 0.0.44 → 0.0.9999-alpha-1

package/utils/index.d.ts

@@ -0,0 +1,37 @@
+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;

package/utils/index.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:
+ *   - 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));
+}

package/data/api/dto/response/EmptyMetadata.d.ts

@@ -1,4 +0,0 @@
-/**
- * Default, empty metadata.
- */
-export type EmptyMetadata = object;

package/services/api/HttpService/AngularHttpService.d.ts

@@ -1,9 +0,0 @@
-import { IHttpService, HttpRequestConfig, HttpResponse } from './index';
-/**
- * Angular HttpClient-based HTTP service implementation
- */
-export declare class AngularHttpService implements IHttpService {
-    private httpClient;
-    constructor(httpClient: any);
-    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-}

package/services/api/HttpService/AngularHttpService.js

@@ -1,86 +0,0 @@
-// Ignore eslint any error in this file
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Angular HttpClient-based HTTP service implementation
- */
-export class AngularHttpService {
-    httpClient;
-    constructor(httpClient) {
-        if (!httpClient) {
-            throw new Error('Angular HttpClient instance is required');
-        }
-        this.httpClient = httpClient;
-    }
-    async request(url, config) {
-        try {
-            const method = config?.method || 'GET';
-            const headers = config?.headers || {};
-            const body = config?.body;
-            const withCredentials = config?.credentials === 'include';
-            const options = {
-                headers,
-                withCredentials,
-                observe: 'response',
-                responseType: 'json',
-            };
-            let response;
-            switch (method.toUpperCase()) {
-                case 'GET':
-                    response = await this.httpClient.get(url, options).toPromise();
-                    break;
-                case 'POST':
-                    response = await this.httpClient.post(url, body ? JSON.parse(body) : null, options).toPromise();
-                    break;
-                case 'PUT':
-                    response = await this.httpClient.put(url, body ? JSON.parse(body) : null, options).toPromise();
-                    break;
-                case 'DELETE':
-                    response = await this.httpClient.delete(url, options).toPromise();
-                    break;
-                case 'PATCH':
-                    response = await this.httpClient.patch(url, body ? JSON.parse(body) : null, options).toPromise();
-                    break;
-                default:
-                    throw new Error(`Unsupported HTTP method: ${method}`);
-            }
-            // Convert Angular HttpResponse headers to plain object
-            const responseHeaders = {};
-            if (response.headers) {
-                response.headers.keys().forEach((key) => {
-                    responseHeaders[key] = response.headers.get(key);
-                });
-            }
-            return {
-                ok: response.status >= 200 && response.status < 300,
-                status: response.status,
-                statusText: response.statusText || 'OK',
-                headers: responseHeaders,
-                json: async () => response.body,
-                text: async () => (typeof response.body === 'string' ? response.body : JSON.stringify(response.body)),
-            };
-        }
-        catch (error) {
-            if (error.status !== undefined) {
-                // Angular HttpErrorResponse
-                const errorHeaders = {};
-                if (error.headers) {
-                    error.headers.keys().forEach((key) => {
-                        errorHeaders[key] = error.headers.get(key);
-                    });
-                }
-                return {
-                    ok: false,
-                    status: error.status,
-                    statusText: error.statusText || 'Error',
-                    headers: errorHeaders,
-                    json: async () => error.error,
-                    text: async () => (typeof error.error === 'string' ? error.error : JSON.stringify(error.error)),
-                };
-            }
-            else {
-                // Other errors
-                throw error;
-            }
-        }
-    }
-}

package/services/api/HttpService/AxiosHttpService.d.ts

@@ -1,10 +0,0 @@
-import { IHttpService, HttpRequestConfig, HttpResponse } from './index';
-/**
- * Axios-based HTTP service implementation
- * Note: This requires axios to be installed as a dependency
- */
-export declare class AxiosHttpService implements IHttpService {
-    private readonly axios;
-    constructor(axiosInstance?: any);
-    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-}

package/services/api/HttpService/AxiosHttpService.js

@@ -1,53 +0,0 @@
-// Ignore eslint any error in this file
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Axios-based HTTP service implementation
- * Note: This requires axios to be installed as a dependency
- */
-export class AxiosHttpService {
-    axios;
-    constructor(axiosInstance) {
-        if (!axiosInstance) {
-            throw new Error('Axios instance is required');
-        }
-        this.axios = axiosInstance;
-    }
-    async request(url, config) {
-        try {
-            const axiosConfig = {
-                url,
-                method: config?.method || 'GET',
-                headers: config?.headers,
-                data: config?.body,
-                withCredentials: config?.credentials === 'include',
-            };
-            const response = await this.axios(axiosConfig);
-            return {
-                ok: response.status >= 200 && response.status < 300,
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                json: async () => response.data,
-                text: async () => (typeof response.data === 'string' ? response.data : JSON.stringify(response.data)),
-            };
-        }
-        catch (error) {
-            if (error.response) {
-                // The request was made and the server responded with a status code
-                // that falls out of the range of 2xx
-                return {
-                    ok: false,
-                    status: error.response.status,
-                    statusText: error.response.statusText,
-                    headers: error.response.headers,
-                    json: async () => error.response.data,
-                    text: async () => (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data)),
-                };
-            }
-            else {
-                // Something happened in setting up the request that triggered an Error
-                throw error;
-            }
-        }
-    }
-}