@uipath/apollo-wind 0.7.2-pr188.4865fad

package/dist/components/forms/data-fetcher.js

@@ -0,0 +1,207 @@
+import { get } from "../../lib/index.js";
+class FetchAdapter {
+    async fetch(request) {
+        const { url, method, params, body } = request;
+        const requestOptions = {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...request.headers
+            }
+        };
+        if ('POST' === method && body) requestOptions.body = JSON.stringify(body);
+        let fullUrl = url;
+        if ('GET' === method && params) {
+            const queryParams = new URLSearchParams(params);
+            fullUrl = `${url}?${queryParams}`;
+        }
+        const response = await fetch(fullUrl, requestOptions);
+        return {
+            data: await response.json(),
+            status: response.status,
+            ok: response.ok
+        };
+    }
+}
+class DataFetcher {
+    static cache = new Map();
+    static cacheTTL = 300000;
+    static adapter = new FetchAdapter();
+    static setAdapter(adapter) {
+        DataFetcher.adapter = adapter;
+    }
+    static getAdapter() {
+        return DataFetcher.adapter;
+    }
+    static resetAdapter() {
+        DataFetcher.adapter = new FetchAdapter();
+    }
+    static async fetch(source, formValues) {
+        switch(source.type){
+            case 'static':
+                return DataFetcher.fetchStatic(source);
+            case 'fetch':
+                return DataFetcher.fetchRemote(source, formValues);
+            case 'computed':
+                return DataFetcher.fetchComputed(source, formValues);
+            case 'remote':
+                return DataFetcher.fetchRemote(source, formValues);
+            default:
+                throw new Error(`Unknown data source type: ${source.type}`);
+        }
+    }
+    static fetchStatic(source) {
+        return source.options;
+    }
+    static async fetchRemote(source, formValues) {
+        const url = 'url' in source ? source.url : source.endpoint;
+        const method = 'method' in source ? source.method || 'GET' : 'GET';
+        const params = 'params' in source ? DataFetcher.resolveParams(source.params || {}, formValues) : {};
+        const cacheKey = DataFetcher.buildCacheKey(url, method, source, formValues);
+        const cached = DataFetcher.getFromCache(cacheKey);
+        if (cached) return cached;
+        try {
+            const response = await DataFetcher.adapter.fetch({
+                url,
+                method,
+                params,
+                body: 'POST' === method ? params : void 0
+            });
+            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+            let data = response.data;
+            if ('transform' in source && source.transform) data = DataFetcher.applyTransform(source.transform, data, formValues);
+            DataFetcher.setCache(cacheKey, data);
+            return data;
+        } catch (error) {
+            console.error('Data fetch error:', error);
+            throw error;
+        }
+    }
+    static fetchComputed(source, formValues) {
+        const dependencyValues = source.dependency.map((dep)=>get(formValues, dep));
+        try {
+            const computeFn = new Function(...source.dependency, `return ${source.compute}`);
+            return computeFn(...dependencyValues);
+        } catch (error) {
+            console.error('Computed value error:', error);
+            return;
+        }
+    }
+    static resolveParams(params, formValues) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(params))if ('string' == typeof value && value.startsWith('$')) {
+            const fieldPath = value.slice(1);
+            resolved[key] = get(formValues, fieldPath);
+        } else resolved[key] = value;
+        return resolved;
+    }
+    static applyTransform(transform, data, formValues) {
+        try {
+            const transformFn = new Function('data', 'formValues', `return ${transform}`);
+            return transformFn(data, formValues);
+        } catch (error) {
+            console.error('Transform error:', error);
+            return data;
+        }
+    }
+    static buildCacheKey(url, method, source, formValues) {
+        const params = 'params' in source ? source.params || {} : {};
+        const resolvedParams = DataFetcher.resolveParams(params, formValues);
+        return `${method}:${url}:${JSON.stringify(resolvedParams)}`;
+    }
+    static getFromCache(key) {
+        const cached = DataFetcher.cache.get(key);
+        if (!cached) return null;
+        if (Date.now() - cached.timestamp > DataFetcher.cacheTTL) {
+            DataFetcher.cache.delete(key);
+            return null;
+        }
+        return cached.data;
+    }
+    static setCache(key, data) {
+        DataFetcher.cache.set(key, {
+            data,
+            timestamp: Date.now()
+        });
+    }
+    static clearCache(pattern) {
+        if (!pattern) return void DataFetcher.cache.clear();
+        for (const key of DataFetcher.cache.keys())if (key.includes(pattern)) DataFetcher.cache.delete(key);
+    }
+    static setCacheTTL(ttl) {
+        DataFetcher.cacheTTL = ttl;
+    }
+}
+class DataSourceBuilder {
+    static static(options) {
+        return {
+            type: 'static',
+            options
+        };
+    }
+    static get(url, params) {
+        return {
+            type: 'remote',
+            endpoint: url,
+            params
+        };
+    }
+    static post(url, _params) {
+        return {
+            type: 'fetch',
+            url,
+            method: 'POST',
+            transform: 'data'
+        };
+    }
+    static computed(dependencies, computeExpression) {
+        return {
+            type: 'computed',
+            dependency: dependencies,
+            compute: computeExpression
+        };
+    }
+    static dependent(url, dependencyField, paramName = 'id') {
+        return {
+            type: 'remote',
+            endpoint: url,
+            params: {
+                [paramName]: `$${dependencyField}`
+            }
+        };
+    }
+    static searchable(url, searchParam = 'q') {
+        return {
+            type: 'remote',
+            endpoint: url,
+            params: {
+                [searchParam]: '$search'
+            }
+        };
+    }
+}
+class DataTransformers {
+    static toOptions(labelKey = 'name', valueKey = 'id') {
+        return `data.map(item => ({ label: item.${labelKey}, value: item.${valueKey} }))`;
+    }
+    static filter(predicate) {
+        return `data.filter(item => ${predicate})`;
+    }
+    static sort(key, order = 'asc') {
+        const comparator = 'asc' === order ? `(a, b) => a.${key} > b.${key} ? 1 : -1` : `(a, b) => a.${key} < b.${key} ? 1 : -1`;
+        return `data.sort(${comparator})`;
+    }
+    static map(expression) {
+        return `data.map(item => ${expression})`;
+    }
+    static extract(path) {
+        return `data.${path}`;
+    }
+    static pipe(...transforms) {
+        return transforms.reduce((acc, transform, index)=>{
+            if (0 === index) return transform;
+            return transform.replace('data', `(${acc})`);
+        });
+    }
+}
+export { DataFetcher, DataSourceBuilder, DataTransformers, FetchAdapter };