edgevector/dist/react.js

Official TypeScript/JavaScript SDK for EdgeVector - Edge-native multi-paradigm database with AI-first features

'use strict';

var React = require('react');
var index = require('./index');

/**
 * EdgeVector React Hooks
 * React-specific utilities and hooks for EdgeVector
 */
/**
 * Hook for EdgeVector client instance
 */
function useEdgeVector(options = {}) {
    const clientRef = React.useRef();
    if (!clientRef.current) {
        clientRef.current = new index.EdgeVector({
            apiKey: options.apiKey,
            endpoint: options.endpoint,
            headers: options.appName ? { 'X-App-Name': options.appName } : {}
        });
    }
    return clientRef.current;
}
/**
 * Hook for collection operations
 */
function useCollection(collectionName, options = {}) {
    const client = useEdgeVector(options);
    const [data, setData] = React.useState([]);
    const [loading, setLoading] = React.useState(true);
    const [error, setError] = React.useState(null);
    const collection = client.collection(collectionName);
    const refresh = React.useCallback(async (filter = {}) => {
        setLoading(true);
        setError(null);
        try {
            const results = await collection.find(filter);
            setData(results);
        }
        catch (err) {
            setError(err);
        }
        finally {
            setLoading(false);
        }
    }, [collection]);
    const insertOne = React.useCallback(async (document) => {
        try {
            const result = await collection.insertOne(document);
            await refresh(); // Refresh data
            return result;
        }
        catch (err) {
            setError(err);
            throw err;
        }
    }, [collection, refresh]);
    const updateOne = React.useCallback(async (filter, update) => {
        try {
            const result = await collection.updateOne(filter, update);
            await refresh(); // Refresh data
            return result;
        }
        catch (err) {
            setError(err);
            throw err;
        }
    }, [collection, refresh]);
    const deleteOne = React.useCallback(async (filter) => {
        try {
            const result = await collection.deleteOne(filter);
            await refresh(); // Refresh data
            return result;
        }
        catch (err) {
            setError(err);
            throw err;
        }
    }, [collection, refresh]);
    // Initial load
    React.useEffect(() => {
        refresh();
    }, [refresh]);
    return {
        data,
        loading,
        error,
        collection,
        refresh,
        insertOne,
        updateOne,
        deleteOne
    };
}
/**
 * Hook for vector search operations
 */
function useVectorSearch(collectionName, options = {}) {
    const client = useEdgeVector(options);
    const [results, setResults] = React.useState([]);
    const [loading, setLoading] = React.useState(false);
    const [error, setError] = React.useState(null);
    const collection = client.collection(collectionName);
    const search = React.useCallback(async (searchOptions) => {
        setLoading(true);
        setError(null);
        try {
            const searchResults = await collection.vectorSearch(searchOptions);
            setResults(searchResults);
            return searchResults;
        }
        catch (err) {
            setError(err);
            setResults([]);
            throw err;
        }
        finally {
            setLoading(false);
        }
    }, [collection]);
    const searchByText = React.useCallback(async (text, searchOptions = {}) => {
        return search({ text, ...searchOptions });
    }, [search]);
    const searchByVector = React.useCallback(async (vector, searchOptions = {}) => {
        return search({ vector, ...searchOptions });
    }, [search]);
    return {
        results,
        loading,
        error,
        search,
        searchByText,
        searchByVector
    };
}
/**
 * Hook for real-time data subscriptions
 */
function useRealTime(collectionName, filter = {}, options = {}) {
    const client = useEdgeVector(options);
    const [data, setData] = React.useState(null);
    const [connected, setConnected] = React.useState(false);
    const [error, setError] = React.useState(null);
    const unsubscribeRef = React.useRef(null);
    React.useEffect(() => {
        const collection = client.collection(collectionName);
        const subscribe = async () => {
            try {
                const unsubscribe = await collection.watch(filter, (event) => {
                    setData(event);
                    setConnected(true);
                });
                unsubscribeRef.current = unsubscribe;
                setConnected(true);
            }
            catch (err) {
                setError(err);
                setConnected(false);
            }
        };
        subscribe();
        return () => {
            if (unsubscribeRef.current) {
                unsubscribeRef.current();
                unsubscribeRef.current = null;
            }
            setConnected(false);
        };
    }, [client, collectionName, JSON.stringify(filter)]);
    return {
        data,
        connected,
        error
    };
}
/**
 * Hook for health monitoring
 */
function useHealth(options = {}) {
    const client = useEdgeVector(options);
    const [health, setHealth] = React.useState(null);
    const [loading, setLoading] = React.useState(true);
    const [error, setError] = React.useState(null);
    const checkHealth = React.useCallback(async () => {
        setLoading(true);
        setError(null);
        try {
            const healthData = await client.health();
            setHealth(healthData);
        }
        catch (err) {
            setError(err);
            setHealth(null);
        }
        finally {
            setLoading(false);
        }
    }, [client]);
    // Auto-refresh health every 30 seconds
    React.useEffect(() => {
        checkHealth();
        const interval = setInterval(checkHealth, 30000);
        return () => clearInterval(interval);
    }, [checkHealth]);
    return {
        health,
        loading,
        error,
        refresh: checkHealth
    };
}
/**
 * Hook for time series operations
 */
function useTimeSeries(collectionName, options = {}) {
    const client = useEdgeVector(options);
    const [data, setData] = React.useState([]);
    const [loading, setLoading] = React.useState(false);
    const [error, setError] = React.useState(null);
    const timeseries = client.timeseries(collectionName);
    const write = React.useCallback(async (points) => {
        try {
            await timeseries.write(points);
        }
        catch (err) {
            setError(err);
            throw err;
        }
    }, [timeseries]);
    const query = React.useCallback(async (queryOptions) => {
        setLoading(true);
        setError(null);
        try {
            const results = await timeseries.query(queryOptions);
            setData(results);
            return results;
        }
        catch (err) {
            setError(err);
            setData([]);
            throw err;
        }
        finally {
            setLoading(false);
        }
    }, [timeseries]);
    const detectAnomalies = React.useCallback(async (metric, detectOptions = {}) => {
        setLoading(true);
        setError(null);
        try {
            const anomalies = await timeseries.detectAnomalies(metric, detectOptions);
            return anomalies;
        }
        catch (err) {
            setError(err);
            throw err;
        }
        finally {
            setLoading(false);
        }
    }, [timeseries]);
    return {
        data,
        loading,
        error,
        write,
        query,
        detectAnomalies
    };
}
const EdgeVectorContext = React.createContext(null);
function EdgeVectorProvider({ client, children }) {
    return React.createElement(EdgeVectorContext.Provider, { value: client }, children);
}
function useEdgeVectorContext() {
    const client = React.useContext(EdgeVectorContext);
    if (!client) {
        throw new Error('useEdgeVectorContext must be used within an EdgeVectorProvider');
    }
    return client;
}

exports.EdgeVectorProvider = EdgeVectorProvider;
exports.useCollection = useCollection;
exports.useEdgeVector = useEdgeVector;
exports.useEdgeVectorContext = useEdgeVectorContext;
exports.useHealth = useHealth;
exports.useRealTime = useRealTime;
exports.useTimeSeries = useTimeSeries;
exports.useVectorSearch = useVectorSearch;
//# sourceMappingURL=react.js.map