@everysk/apps-sdk 0.1.0 → 0.3.0-beta-20261016180126

package/dist/contexts/webSocketContext/provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/webSocketContext/provider.tsx"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\nimport { getWebsocketsConfig } from \"@/api/websocketsConfig\";\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { WebSocketContext } from \".\";\nimport { WebSocketHandler } from \"./handler\";\nimport type { WebSocketContextType, WebSocketNotification, WebSocketProviderProps, WebSocketStatus } from \"./types\";\n\n/**\n * WebSocketProvider\n *\n * React context provider that exposes a receive-only pub/sub API backed by Socket.IO.\n *\n * What this provider does:\n * - Fetches `/api/websockets_config` once on mount to get the connection URL, channel id,\n *   and session uid. Socket.IO handles reconnection internally — the config is not re-fetched.\n * - Opens a `WebSocketHandler` instance that connects and joins the per-user channel.\n * - Exposes `subscribe`, `lastMessage`, and `status` via `WebSocketContext`.\n *\n * Why the pending buffer exists (`pendingRef`):\n * - The handler is created asynchronously (after the config fetch resolves).\n * - Consumers that call `subscribe` before the handler is ready have their callbacks buffered\n *   and registered once the handler initializes, ensuring no early subscriptions are lost.\n *\n * Subscribe buffering behavior:\n * - If `subscribe(fn)` is called before the handler exists, `fn` is stored with a `null` placeholder.\n * - Once the handler is ready, all pending callbacks are registered and their unsubscribe functions\n *   stored back into the map.\n * - The returned cleanup always works: it calls the real unsubscribe if available, or removes\n *   the entry from the pending map.\n *\n * Usage:\n * ```tsx\n * <WebSocketProvider>\n *   <YourPage />\n * </WebSocketProvider>\n * ```\n *\n * Context value (WebSocketContextType):\n * @returns {object}\n *  - `subscribe(fn)`: register a listener; returns an unsubscribe function.\n *  - `lastMessage`: the most recently received notification (or null).\n *  - `status`: current connection status (\"connecting\" | \"connected\" | \"error\").\n */\nexport const WebSocketProvider = ({ children }: WebSocketProviderProps) => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    // Refs keep the latest values accessible inside the mount-only effect without\n    // making it re-run when api or showAlert change.\n    const apiRef = useRef(api);\n    const showAlertRef = useRef(showAlert);\n    useEffect(() => { apiRef.current = api; });\n    useEffect(() => { showAlertRef.current = showAlert; });\n\n    const handlerRef = useRef<WebSocketHandler | null>(null);\n    const unsubscribeProviderRef = useRef<(() => void) | null>(null);\n    const [lastMessage, setLastMessage] = useState<WebSocketNotification | null>(null);\n    const [status, setStatus] = useState<WebSocketStatus>(\"idle\");\n\n    const pendingRef = useRef(new Map<(m: WebSocketNotification) => void, (() => void) | null>());\n\n    useEffect(() => {\n        let cancelled = false;\n        const pending = pendingRef.current;\n\n        getWebsocketsConfig(apiRef.current)\n            .then((config) => {\n                if (cancelled) return;\n\n                setStatus(\"connecting\");\n                const handler = new WebSocketHandler({\n                    ...config,\n                    onStatusChange: (s) => setStatus(s),\n                });\n                handlerRef.current = handler;\n\n                unsubscribeProviderRef.current = handler.listen((message) => setLastMessage(message));\n\n                for (const [fn, unsub] of pending.entries()) {\n                    if (!unsub) {\n                        const realUnsub = handler.listen(fn);\n                        pending.set(fn, realUnsub);\n                    }\n                }\n            })\n            .catch((error) => {\n                if (cancelled) return;\n                console.error(\"Failed to initialize WebSocket connection:\", error);\n                setStatus(\"error\");\n                showAlertRef.current({ message: \"Real-time notifications are unavailable. Please refresh the page.\", severity: \"error\" });\n            });\n\n        return () => {\n            cancelled = true;\n            unsubscribeProviderRef.current?.();\n            unsubscribeProviderRef.current = null;\n            handlerRef.current?.close();\n            handlerRef.current = null;\n            pending.clear();\n        };\n    }, []); // mount-only — Socket.IO handles reconnection; no re-init needed when api changes\n\n    const subscribe = useCallback((fn: (m: WebSocketNotification) => void) => {\n        if (handlerRef.current) {\n            return handlerRef.current.listen(fn);\n        }\n\n        pendingRef.current.set(fn, null);\n\n        return () => {\n            const maybeUnsub = pendingRef.current.get(fn);\n            if (maybeUnsub) maybeUnsub();\n            pendingRef.current.delete(fn);\n        };\n    }, []);\n\n    const value: WebSocketContextType = useMemo(\n        () => ({ subscribe, lastMessage, status }),\n        [subscribe, lastMessage, status]\n    );\n\n    return <WebSocketContext.Provider value={value}>{children}</WebSocketContext.Provider>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,qBAAqB,EAAE,eAAuC;CACvE,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAIlC,MAAM,SAAS,OAAO,GAAG;CACzB,MAAM,eAAe,OAAO,SAAS;CACrC,gBAAgB;EAAE,OAAO,UAAU;CAAK,CAAC;CACzC,gBAAgB;EAAE,aAAa,UAAU;CAAW,CAAC;CAErD,MAAM,aAAa,OAAgC,IAAI;CACvD,MAAM,yBAAyB,OAA4B,IAAI;CAC/D,MAAM,CAAC,aAAa,kBAAkB,SAAuC,IAAI;CACjF,MAAM,CAAC,QAAQ,aAAa,SAA0B,MAAM;CAE5D,MAAM,aAAa,uBAAO,IAAI,IAA6D,CAAC;CAE5F,gBAAgB;EACZ,IAAI,YAAY;EAChB,MAAM,UAAU,WAAW;EAE3B,oBAAoB,OAAO,OAAO,CAAC,CAC9B,MAAM,WAAW;GACd,IAAI,WAAW;GAEf,UAAU,YAAY;GACtB,MAAM,UAAU,IAAI,iBAAiB;IACjC,GAAG;IACH,iBAAiB,MAAM,UAAU,CAAC;GACtC,CAAC;GACD,WAAW,UAAU;GAErB,uBAAuB,UAAU,QAAQ,QAAQ,YAAY,eAAe,OAAO,CAAC;GAEpF,KAAK,MAAM,CAAC,IAAI,UAAU,QAAQ,QAAQ,GACtC,IAAI,CAAC,OAAO;IACR,MAAM,YAAY,QAAQ,OAAO,EAAE;IACnC,QAAQ,IAAI,IAAI,SAAS;GAC7B;EAER,CAAC,CAAC,CACD,OAAO,UAAU;GACd,IAAI,WAAW;GACf,QAAQ,MAAM,8CAA8C,KAAK;GACjE,UAAU,OAAO;GACjB,aAAa,QAAQ;IAAE,SAAS;IAAqE,UAAU;GAAQ,CAAC;EAC5H,CAAC;EAEL,aAAa;GACT,YAAY;GACZ,uBAAuB,UAAU;GACjC,uBAAuB,UAAU;GACjC,WAAW,SAAS,MAAM;GAC1B,WAAW,UAAU;GACrB,QAAQ,MAAM;EAClB;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,YAAY,aAAa,OAA2C;EACtE,IAAI,WAAW,SACX,OAAO,WAAW,QAAQ,OAAO,EAAE;EAGvC,WAAW,QAAQ,IAAI,IAAI,IAAI;EAE/B,aAAa;GACT,MAAM,aAAa,WAAW,QAAQ,IAAI,EAAE;GAC5C,IAAI,YAAY,WAAW;GAC3B,WAAW,QAAQ,OAAO,EAAE;EAChC;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,QAA8B,eACzB;EAAE;EAAW;EAAa;CAAO,IACxC;EAAC;EAAW;EAAa;CAAM,CACnC;CAEA,OAAO,oBAAC,iBAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACzF"}
+{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/webSocketContext/provider.tsx"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\nimport { getWebsocketsConfig } from \"@/api/websocketsConfig\";\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { WebSocketContext } from \".\";\nimport { WebSocketHandler } from \"./handler\";\nimport type {\n    WebSocketContextType,\n    WebSocketNotification,\n    WebSocketProviderProps,\n    WebSocketStatus,\n} from \"./types\";\n\n/**\n * Calls a status listener, logging and skipping one that throws, as notification listeners are,\n * so it cannot keep the others from hearing the change.\n */\nconst tellStatus = (listener: (status: WebSocketStatus) => void, status: WebSocketStatus) => {\n    try {\n        listener(status);\n    } catch (error) {\n        console.error(\"WebSocket status listener threw:\", error);\n    }\n};\n\n/**\n * WebSocketProvider\n *\n * React context provider that exposes a receive-only pub/sub API backed by Socket.IO.\n *\n * What this provider does:\n * - Fetches `/api/websockets_config` once on mount to get the connection URL, channel id,\n *   and session uid. Socket.IO handles reconnection internally — the config is not re-fetched,\n *   and the effect that does it runs once (`changeStatus`, its only dependency, is stable).\n * - Opens a `WebSocketHandler` instance that connects and joins the per-user channel.\n * - Exposes `subscribe`, `subscribeStatus`, `lastMessage`, and `status` via `WebSocketContext`.\n *\n * Why the pending buffer exists (`pendingRef`):\n * - The handler is created asynchronously (after the config fetch resolves).\n * - Consumers that call `subscribe` before the handler is ready have their callbacks buffered\n *   and registered once the handler initializes, ensuring no early subscriptions are lost.\n *\n * Subscribe buffering behavior:\n * - If `subscribe(fn)` is called before the handler exists, `fn` is stored with a `null` placeholder.\n * - Once the handler is ready, all pending callbacks are registered and their unsubscribe functions\n *   stored back into the map.\n * - The returned cleanup always works: it calls the real unsubscribe if available, or removes\n *   the entry from the pending map.\n *\n * Usage:\n * ```tsx\n * <WebSocketProvider>\n *   <YourPage />\n * </WebSocketProvider>\n * ```\n *\n * Context value (WebSocketContextType):\n * @returns {object}\n *  - `subscribe(fn)`: register a listener; returns an unsubscribe function.\n *  - `subscribeStatus(fn)`: hear the current status at once, then every status the socket\n *    reports, repeats included; returns an unsubscribe function.\n *  - `lastMessage`: the most recently received notification (or null).\n *  - `status`: current connection status (\"idle\" | \"connecting\" | \"connected\" | \"error\").\n */\nexport const WebSocketProvider = ({ children }: WebSocketProviderProps) => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    // Refs keep the latest values accessible inside the mount-only effect without\n    // making it re-run when api or showAlert change.\n    const apiRef = useRef(api);\n    const showAlertRef = useRef(showAlert);\n    useEffect(() => {\n        apiRef.current = api;\n    });\n    useEffect(() => {\n        showAlertRef.current = showAlert;\n    });\n\n    const handlerRef = useRef<WebSocketHandler | null>(null);\n    const unsubscribeProviderRef = useRef<(() => void) | null>(null);\n    const [lastMessage, setLastMessage] = useState<WebSocketNotification | null>(null);\n    const [status, setStatus] = useState<WebSocketStatus>(\"idle\");\n    const statusListenersRef = useRef(new Set<(status: WebSocketStatus) => void>());\n    const currentStatusRef = useRef<WebSocketStatus>(\"idle\");\n\n    /**\n     * Sets `status` and tells the status listeners, so both see the same sequence. The current\n     * status is also kept in a ref, so a new listener is told it at once rather than from React\n     * state, which lags a change until the next render.\n     */\n    const changeStatus = useCallback((next: WebSocketStatus) => {\n        currentStatusRef.current = next;\n        setStatus(next);\n        statusListenersRef.current.forEach((listener) => tellStatus(listener, next));\n    }, []);\n\n    const pendingRef = useRef(new Map<(m: WebSocketNotification) => void, (() => void) | null>());\n\n    useEffect(() => {\n        let cancelled = false;\n        const pending = pendingRef.current;\n\n        getWebsocketsConfig(apiRef.current)\n            .then((config) => {\n                if (cancelled) return;\n\n                changeStatus(\"connecting\");\n                const handler = new WebSocketHandler({\n                    ...config,\n                    onStatusChange: changeStatus,\n                });\n                handlerRef.current = handler;\n\n                unsubscribeProviderRef.current = handler.listen((message) =>\n                    setLastMessage(message),\n                );\n\n                for (const [fn, unsub] of pending.entries()) {\n                    if (!unsub) {\n                        const realUnsub = handler.listen(fn);\n                        pending.set(fn, realUnsub);\n                    }\n                }\n            })\n            .catch((error) => {\n                if (cancelled) return;\n                console.error(\"Failed to initialize WebSocket connection:\", error);\n                changeStatus(\"error\");\n                showAlertRef.current({\n                    message: \"Real-time notifications are unavailable. Please refresh the page.\",\n                    severity: \"error\",\n                });\n            });\n\n        return () => {\n            cancelled = true;\n            unsubscribeProviderRef.current?.();\n            unsubscribeProviderRef.current = null;\n            handlerRef.current?.close();\n            handlerRef.current = null;\n            pending.clear();\n        };\n    }, [changeStatus]);\n\n    const subscribe = useCallback((fn: (m: WebSocketNotification) => void) => {\n        if (handlerRef.current) {\n            return handlerRef.current.listen(fn);\n        }\n\n        pendingRef.current.set(fn, null);\n\n        return () => {\n            const maybeUnsub = pendingRef.current.get(fn);\n            if (maybeUnsub) maybeUnsub();\n            pendingRef.current.delete(fn);\n        };\n    }, []);\n\n    const subscribeStatus = useCallback((listener: (status: WebSocketStatus) => void) => {\n        statusListenersRef.current.add(listener);\n        tellStatus(listener, currentStatusRef.current);\n        return () => {\n            statusListenersRef.current.delete(listener);\n        };\n    }, []);\n\n    const value: WebSocketContextType = useMemo(\n        () => ({ subscribe, subscribeStatus, lastMessage, status }),\n        [subscribe, subscribeStatus, lastMessage, status],\n    );\n\n    return <WebSocketContext.Provider value={value}>{children}</WebSocketContext.Provider>;\n};\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAM,cAAc,UAA6C,WAA4B;CACzF,IAAI;EACA,SAAS,MAAM;CACnB,SAAS,OAAO;EACZ,QAAQ,MAAM,oCAAoC,KAAK;CAC3D;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,qBAAqB,EAAE,eAAuC;CACvE,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAIlC,MAAM,SAAS,OAAO,GAAG;CACzB,MAAM,eAAe,OAAO,SAAS;CACrC,gBAAgB;EACZ,OAAO,UAAU;CACrB,CAAC;CACD,gBAAgB;EACZ,aAAa,UAAU;CAC3B,CAAC;CAED,MAAM,aAAa,OAAgC,IAAI;CACvD,MAAM,yBAAyB,OAA4B,IAAI;CAC/D,MAAM,CAAC,aAAa,kBAAkB,SAAuC,IAAI;CACjF,MAAM,CAAC,QAAQ,aAAa,SAA0B,MAAM;CAC5D,MAAM,qBAAqB,uBAAO,IAAI,IAAuC,CAAC;CAC9E,MAAM,mBAAmB,OAAwB,MAAM;;;;;;CAOvD,MAAM,eAAe,aAAa,SAA0B;EACxD,iBAAiB,UAAU;EAC3B,UAAU,IAAI;EACd,mBAAmB,QAAQ,SAAS,aAAa,WAAW,UAAU,IAAI,CAAC;CAC/E,GAAG,CAAC,CAAC;CAEL,MAAM,aAAa,uBAAO,IAAI,IAA6D,CAAC;CAE5F,gBAAgB;EACZ,IAAI,YAAY;EAChB,MAAM,UAAU,WAAW;EAE3B,oBAAoB,OAAO,OAAO,CAAC,CAC9B,MAAM,WAAW;GACd,IAAI,WAAW;GAEf,aAAa,YAAY;GACzB,MAAM,UAAU,IAAI,iBAAiB;IACjC,GAAG;IACH,gBAAgB;GACpB,CAAC;GACD,WAAW,UAAU;GAErB,uBAAuB,UAAU,QAAQ,QAAQ,YAC7C,eAAe,OAAO,CAC1B;GAEA,KAAK,MAAM,CAAC,IAAI,UAAU,QAAQ,QAAQ,GACtC,IAAI,CAAC,OAAO;IACR,MAAM,YAAY,QAAQ,OAAO,EAAE;IACnC,QAAQ,IAAI,IAAI,SAAS;GAC7B;EAER,CAAC,CAAC,CACD,OAAO,UAAU;GACd,IAAI,WAAW;GACf,QAAQ,MAAM,8CAA8C,KAAK;GACjE,aAAa,OAAO;GACpB,aAAa,QAAQ;IACjB,SAAS;IACT,UAAU;GACd,CAAC;EACL,CAAC;EAEL,aAAa;GACT,YAAY;GACZ,uBAAuB,UAAU;GACjC,uBAAuB,UAAU;GACjC,WAAW,SAAS,MAAM;GAC1B,WAAW,UAAU;GACrB,QAAQ,MAAM;EAClB;CACJ,GAAG,CAAC,YAAY,CAAC;CAEjB,MAAM,YAAY,aAAa,OAA2C;EACtE,IAAI,WAAW,SACX,OAAO,WAAW,QAAQ,OAAO,EAAE;EAGvC,WAAW,QAAQ,IAAI,IAAI,IAAI;EAE/B,aAAa;GACT,MAAM,aAAa,WAAW,QAAQ,IAAI,EAAE;GAC5C,IAAI,YAAY,WAAW;GAC3B,WAAW,QAAQ,OAAO,EAAE;EAChC;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,kBAAkB,aAAa,aAAgD;EACjF,mBAAmB,QAAQ,IAAI,QAAQ;EACvC,WAAW,UAAU,iBAAiB,OAAO;EAC7C,aAAa;GACT,mBAAmB,QAAQ,OAAO,QAAQ;EAC9C;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,QAA8B,eACzB;EAAE;EAAW;EAAiB;EAAa;CAAO,IACzD;EAAC;EAAW;EAAiB;EAAa;CAAM,CACpD;CAEA,OAAO,oBAAC,iBAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACzF"}

package/dist/contexts/webSocketContext/types.d.ts

@@ -1,9 +1,4 @@
 import type { ReactNode } from "react";
-export type WebsocketsConfig = {
-    appConnectionURL: string;
-    appChannelID: string;
-    everyskUID: string;
-};
 export type WebSocketStatus = "idle" | "connecting" | "connected" | "error";
 export type AppNotificationPayload = {
     [key: string]: unknown;
@@ -32,6 +27,13 @@ export type AppNotification = WebSocketNotification & {
 };
 export type WebSocketContextType = {
     subscribe: (listener: (msg: WebSocketNotification) => void) => () => void;
+    /**
+     * Calls `listener` with the current status at once, then on every status the socket reports,
+     * repeats included; returns the unsubscribe. For code that waits on the socket outside React,
+     * where `status` cannot be watched: a reconnect is when it must catch up on what was
+     * published in between, which the server does not replay.
+     */
+    subscribeStatus: (listener: (status: WebSocketStatus) => void) => () => void;
     lastMessage: WebSocketNotification | null;
     status: WebSocketStatus;
 };

package/dist/contexts/webSocketContext/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC;AAE5E,MAAM,MAAM,sBAAsB,GAAG;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,qBAAqB,GAAG;IAClD,UAAU,EAAE,uBAAuB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,sBAAsB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAC/B,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC1E,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC1C,MAAM,EAAE,eAAe,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IAIjC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC;AAE5E,MAAM,MAAM,sBAAsB,GAAG;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,qBAAqB,GAAG;IAClD,UAAU,EAAE,uBAAuB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,sBAAsB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAC/B,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC1E;;;;;OAKG;IACH,eAAe,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC7E,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC1C,MAAM,EAAE,eAAe,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IAIjC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB,CAAC"}

package/dist/file/index.d.ts

@@ -3,4 +3,6 @@ export * from "../types/file.d.ts";
 export * from "../hooks/file/useFetchFile.js";
 export * from "../hooks/file/useFetchFiles.js";
 export * from "../hooks/file/useFileMutations.js";
+export * from "../lib/file.js";
+export type { FileDataProps } from "../hooks/file/fileData.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/file/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file/index.ts"],"names":[],"mappings":"AAQA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file/index.ts"],"names":[],"mappings":"AAQA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/hooks/datastore/useDatastoreMutations.d.ts

@@ -66,7 +66,7 @@ type UseDatastoreMutationsProps = {
  *  Returns an object with the three TanStack Query mutation results:
  *  - `create`: UseMutationResult<Datastore, Error, CreateDatastoreProps, unknown>
  *  - `update`: UseMutationResult<Datastore, Error, UpdateDatastoreProps, unknown>
- *  - `remove`: UseMutationResult<Datastore, Error, DeleteDatastoreProps, unknown>
+ *  - `remove`: UseMutationResult<DeletedEntity, Error, DeleteDatastoreProps, unknown>
  *
  * Each mutation includes standard TanStack Query helpers:
  * - `mutate(variables, options?)`
@@ -143,9 +143,9 @@ type UseDatastoreMutationsProps = {
  * ```
  */
 export declare const useDatastoreMutations: ({ queryKey }: UseDatastoreMutationsProps) => {
-    create: import("@tanstack/react-query").UseMutationResult<Datastore, unknown, CreateDatastoreProps, unknown>;
-    update: import("@tanstack/react-query").UseMutationResult<Datastore, unknown, UpdateDatastoreProps, unknown>;
-    remove: import("@tanstack/react-query").UseMutationResult<import("../..").DeleteEntityDefaultResponse[], unknown, DeleteDatastoreProps, unknown>;
+    create: import("@tanstack/react-query").UseMutationResult<Datastore, Error, CreateDatastoreProps, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<Datastore, Error, UpdateDatastoreProps, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<import("../..").DeletedEntity, Error, DeleteDatastoreProps, unknown>;
 };
 export {};
 //# sourceMappingURL=useDatastoreMutations.d.ts.map

package/dist/hooks/datastore/useDatastoreMutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDatastoreMutations.d.ts","sourceRoot":"","sources":["../../../src/hooks/datastore/useDatastoreMutations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,KAAK,oBAAoB,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAC9B,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgIG;AAEH,eAAO,MAAM,qBAAqB,GAAI,cAAc,0BAA0B;;;;CA8D7E,CAAC"}
+{"version":3,"file":"useDatastoreMutations.d.ts","sourceRoot":"","sources":["../../../src/hooks/datastore/useDatastoreMutations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,KAAK,oBAAoB,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAC9B,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgIG;AAEH,eAAO,MAAM,qBAAqB,GAAI,cAAc,0BAA0B;;;;CA0B7E,CAAC"}

package/dist/hooks/datastore/useDatastoreMutations.js

@@ -1,9 +1,7 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityMutation } from "../useEntityMutation.js";
 import { createDatastore, deleteDatastore, updateDatastore } from "../../api/datastore.js";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
 //#region src/hooks/datastore/useDatastoreMutations.ts
-var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? err.message : fallback;
 /**
 * useDatastoreMutations
 *
@@ -57,7 +55,7 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 *  Returns an object with the three TanStack Query mutation results:
 *  - `create`: UseMutationResult<Datastore, Error, CreateDatastoreProps, unknown>
 *  - `update`: UseMutationResult<Datastore, Error, UpdateDatastoreProps, unknown>
-*  - `remove`: UseMutationResult<Datastore, Error, DeleteDatastoreProps, unknown>
+*  - `remove`: UseMutationResult<DeletedEntity, Error, DeleteDatastoreProps, unknown>
 *
 * Each mutation includes standard TanStack Query helpers:
 * - `mutate(variables, options?)`
@@ -135,60 +133,24 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 */
 var useDatastoreMutations = ({ queryKey }) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
-	const queryClient = useQueryClient();
-	const invalidate = async () => {
-		if (!queryKey?.length) return;
-		await queryClient.invalidateQueries({ queryKey });
-	};
 	return {
-		create: useMutation({
-			mutationFn: async ({ data }) => createDatastore(api, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Datastore created successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to create the datastore. Please try again.")
-				});
-			}
+		create: useEntityMutation({
+			mutationFn: ({ data }) => createDatastore(api, data),
+			queryKey,
+			successMessage: "Datastore created successfully.",
+			errorMessage: "Unable to create the datastore. Please try again."
 		}),
-		update: useMutation({
-			mutationFn: async ({ id, data }) => updateDatastore(api, id, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Datastore updated successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to update the datastore. Please try again.")
-				});
-			}
+		update: useEntityMutation({
+			mutationFn: ({ id, data }) => updateDatastore(api, id, data),
+			queryKey,
+			successMessage: "Datastore updated successfully.",
+			errorMessage: "Unable to update the datastore. Please try again."
 		}),
-		remove: useMutation({
-			mutationFn: async ({ id, workspace }) => deleteDatastore(api, id, workspace),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Datastore deleted successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to delete the datastore. Please try again.")
-				});
-			}
+		remove: useEntityMutation({
+			mutationFn: ({ id, workspace }) => deleteDatastore(api, id, workspace),
+			queryKey,
+			successMessage: "Datastore deleted successfully.",
+			errorMessage: "Unable to delete the datastore. Please try again."
 		})
 	};
 };

package/dist/hooks/datastore/useDatastoreMutations.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDatastoreMutations.js","names":[],"sources":["../../../src/hooks/datastore/useDatastoreMutations.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"./../useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { Datastore } from \"@/types/datastore\";\nimport { deleteDatastore, createDatastore, updateDatastore } from \"@/api/datastore\";\n\ntype CreateDatastoreProps = {\n    data: Partial<Datastore>;\n};\n\ntype UpdateDatastoreProps = {\n    id: string;\n    data: Partial<Datastore>;\n};\n\ntype DeleteDatastoreProps = {\n    id: string;\n    workspace: string;\n};\n\ntype UseDatastoreMutationsProps = {\n    queryKey?: unknown[];\n};\n\nconst getErrorMessage = (err: unknown, fallback: string) =>\n    err instanceof Error && err.message ? err.message : fallback;\n\n/**\n * useDatastoreMutations\n *\n * Mutation hook built on TanStack Query to perform Datastore write operations:\n * - create a datastore (POST)\n * - update a datastore (PUT)\n * - delete a datastore (DELETE)\n *\n * It also:\n * - optionally invalidates a target query cache key after successful mutations\n * - displays success/error alerts via `useAppAlert`\n *\n * Important notes:\n * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchDatastore`.\n * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run\n *   mutations and show alerts, but it will NOT invalidate any cached queries.\n * - `remove` requires a `workspace` parameter because the underlying API helper `deleteDatastore(api, id, workspace)`\n *   expects it as a query param.\n *\n * Parameters (UseDatastoreMutationsProps):\n * @param {unknown[]} [queryKey]\n *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`\n *  (e.g., datastore list/detail) so UI data is refreshed automatically after a write.\n *\n *  Tip:\n *  - If you're using `useFetchDatastore`, you can pass its returned `queryKey` directly:\n *    `const fetch = useFetchDatastore(...);`\n *    `useDatastoreMutations({ queryKey: fetch.queryKey });`\n *\n * Mutations:\n * - `create`:\n *   - mutationFn: `createDatastore(api, data)`\n *   - variables: `{ data: Partial<Datastore> }`\n *   - success message: \"Datastore created successfully.\"\n *   - error message: \"Unable to create the datastore. Please try again.\" (fallback)\n *\n * - `update`:\n *   - mutationFn: `updateDatastore(api, id, data)`\n *   - variables: `{ id: string; data: Partial<Datastore> }`\n *   - success message: \"Datastore updated successfully.\"\n *   - error message: \"Unable to update the datastore. Please try again.\" (fallback)\n *\n * - `remove`:\n *   - mutationFn: `deleteDatastore(api, id, workspace)`\n *   - variables: `{ id: string; workspace: string }`\n *   - success message: \"Datastore deleted successfully.\"\n *   - error message: \"Unable to delete the datastore. Please try again.\" (fallback)\n *\n * Return value:\n * @returns {object}\n *  Returns an object with the three TanStack Query mutation results:\n *  - `create`: UseMutationResult<Datastore, Error, CreateDatastoreProps, unknown>\n *  - `update`: UseMutationResult<Datastore, Error, UpdateDatastoreProps, unknown>\n *  - `remove`: UseMutationResult<Datastore, Error, DeleteDatastoreProps, unknown>\n *\n * Each mutation includes standard TanStack Query helpers:\n * - `mutate(variables, options?)`\n * - `mutateAsync(variables, options?)`\n * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.\n *\n * Examples:\n *\n * 1) Invalidate a datastore list query after mutations:\n * ```ts\n * const { create, update, remove } = useDatastoreMutations({ queryKey: [\"datastore\"] });\n *\n * // Create\n * create.mutate({\n *   data: {\n *     name: \"My datastore\",\n *     workspace: \"ws-1\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n *\n * // Update\n * update.mutate({\n *   id: \"ds-123\",\n *   data: {\n *     name: \"Renamed datastore\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n *\n * // Delete\n * remove.mutate({\n *   id: \"ds-123\",\n *   workspace: \"ws-1\"\n * });\n * ```\n *\n * 2) Using async/await with `mutateAsync`:\n * ```ts\n * const { create } = useDatastoreMutations({ queryKey: [\"datastore\"] });\n *\n * await create.mutateAsync({\n *   data: {\n *     name: \"My datastore\",\n *     workspace: \"ws-1\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n * ```\n *\n * 3) Without cache invalidation (no queryKey):\n * ```ts\n * const { update } = useDatastoreMutations({});\n *\n * update.mutate({\n *   id: \"ds-123\",\n *   data: { name: \"Renamed datastore\" }\n * });\n * // Mutation still runs and alerts are shown, but cached queries are not invalidated.\n * ```\n *\n * 4) Using `useFetchDatastore` queryKey for automatic invalidation:\n * ```ts\n * const fetch = useFetchDatastore({\n *   id: null,\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n * });\n *\n * const { create } = useDatastoreMutations({ queryKey: fetch.queryKey });\n *\n * await create.mutateAsync({\n *   data: { name: \"My datastore\", workspace: \"ws-1\" }\n * });\n * ```\n */\n\nexport const useDatastoreMutations = ({ queryKey }: UseDatastoreMutationsProps) => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n    const queryClient = useQueryClient();\n\n    const invalidate = async () => {\n        if (!queryKey?.length) return;\n        await queryClient.invalidateQueries({ queryKey });\n    };\n\n    const create = useMutation({\n        mutationFn: async ({ data }: CreateDatastoreProps) => createDatastore(api, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Datastore created successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(err, \"Unable to create the datastore. Please try again.\"),\n            });\n        },\n    });\n\n    const update = useMutation({\n        mutationFn: async ({ id, data }: UpdateDatastoreProps) => updateDatastore(api, id, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Datastore updated successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(err, \"Unable to update the datastore. Please try again.\"),\n            });\n        },\n    });\n\n    const remove = useMutation({\n        mutationFn: async ({ id, workspace }: DeleteDatastoreProps) => deleteDatastore(api, id, workspace),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Datastore deleted successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(err, \"Unable to delete the datastore. Please try again.\"),\n            });\n        },\n    });\n\n    return { create, update, remove };\n};\n"],"mappings":";;;;;AAyBA,IAAM,mBAAmB,KAAc,aACnC,eAAe,SAAS,IAAI,UAAU,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoIxD,IAAa,yBAAyB,EAAE,eAA2C;CAC/E,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAClC,MAAM,cAAc,eAAe;CAEnC,MAAM,aAAa,YAAY;EAC3B,IAAI,CAAC,UAAU,QAAQ;EACvB,MAAM,YAAY,kBAAkB,EAAE,SAAS,CAAC;CACpD;CAqDA,OAAO;EAAE,QAnDM,YAAY;GACvB,YAAY,OAAO,EAAE,WAAiC,gBAAgB,KAAK,IAAI;GAC/E,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBAAgB,KAAK,mDAAmD;IACrF,CAAC;GACL;EACJ,CAoCS;EAAQ,QAlCF,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,WAAiC,gBAAgB,KAAK,IAAI,IAAI;GACvF,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBAAgB,KAAK,mDAAmD;IACrF,CAAC;GACL;EACJ,CAmBiB;EAAQ,QAjBV,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,gBAAsC,gBAAgB,KAAK,IAAI,SAAS;GACjG,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBAAgB,KAAK,mDAAmD;IACrF,CAAC;GACL;EACJ,CAEyB;CAAO;AACpC"}
+{"version":3,"file":"useDatastoreMutations.js","names":[],"sources":["../../../src/hooks/datastore/useDatastoreMutations.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityMutation } from \"@/hooks/useEntityMutation\";\nimport type { Datastore } from \"@/types/datastore\";\nimport { deleteDatastore, createDatastore, updateDatastore } from \"@/api/datastore\";\n\ntype CreateDatastoreProps = {\n    data: Partial<Datastore>;\n};\n\ntype UpdateDatastoreProps = {\n    id: string;\n    data: Partial<Datastore>;\n};\n\ntype DeleteDatastoreProps = {\n    id: string;\n    workspace: string;\n};\n\ntype UseDatastoreMutationsProps = {\n    queryKey?: unknown[];\n};\n\n/**\n * useDatastoreMutations\n *\n * Mutation hook built on TanStack Query to perform Datastore write operations:\n * - create a datastore (POST)\n * - update a datastore (PUT)\n * - delete a datastore (DELETE)\n *\n * It also:\n * - optionally invalidates a target query cache key after successful mutations\n * - displays success/error alerts via `useAppAlert`\n *\n * Important notes:\n * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchDatastore`.\n * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run\n *   mutations and show alerts, but it will NOT invalidate any cached queries.\n * - `remove` requires a `workspace` parameter because the underlying API helper `deleteDatastore(api, id, workspace)`\n *   expects it as a query param.\n *\n * Parameters (UseDatastoreMutationsProps):\n * @param {unknown[]} [queryKey]\n *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`\n *  (e.g., datastore list/detail) so UI data is refreshed automatically after a write.\n *\n *  Tip:\n *  - If you're using `useFetchDatastore`, you can pass its returned `queryKey` directly:\n *    `const fetch = useFetchDatastore(...);`\n *    `useDatastoreMutations({ queryKey: fetch.queryKey });`\n *\n * Mutations:\n * - `create`:\n *   - mutationFn: `createDatastore(api, data)`\n *   - variables: `{ data: Partial<Datastore> }`\n *   - success message: \"Datastore created successfully.\"\n *   - error message: \"Unable to create the datastore. Please try again.\" (fallback)\n *\n * - `update`:\n *   - mutationFn: `updateDatastore(api, id, data)`\n *   - variables: `{ id: string; data: Partial<Datastore> }`\n *   - success message: \"Datastore updated successfully.\"\n *   - error message: \"Unable to update the datastore. Please try again.\" (fallback)\n *\n * - `remove`:\n *   - mutationFn: `deleteDatastore(api, id, workspace)`\n *   - variables: `{ id: string; workspace: string }`\n *   - success message: \"Datastore deleted successfully.\"\n *   - error message: \"Unable to delete the datastore. Please try again.\" (fallback)\n *\n * Return value:\n * @returns {object}\n *  Returns an object with the three TanStack Query mutation results:\n *  - `create`: UseMutationResult<Datastore, Error, CreateDatastoreProps, unknown>\n *  - `update`: UseMutationResult<Datastore, Error, UpdateDatastoreProps, unknown>\n *  - `remove`: UseMutationResult<DeletedEntity, Error, DeleteDatastoreProps, unknown>\n *\n * Each mutation includes standard TanStack Query helpers:\n * - `mutate(variables, options?)`\n * - `mutateAsync(variables, options?)`\n * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.\n *\n * Examples:\n *\n * 1) Invalidate a datastore list query after mutations:\n * ```ts\n * const { create, update, remove } = useDatastoreMutations({ queryKey: [\"datastore\"] });\n *\n * // Create\n * create.mutate({\n *   data: {\n *     name: \"My datastore\",\n *     workspace: \"ws-1\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n *\n * // Update\n * update.mutate({\n *   id: \"ds-123\",\n *   data: {\n *     name: \"Renamed datastore\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n *\n * // Delete\n * remove.mutate({\n *   id: \"ds-123\",\n *   workspace: \"ws-1\"\n * });\n * ```\n *\n * 2) Using async/await with `mutateAsync`:\n * ```ts\n * const { create } = useDatastoreMutations({ queryKey: [\"datastore\"] });\n *\n * await create.mutateAsync({\n *   data: {\n *     name: \"My datastore\",\n *     workspace: \"ws-1\",\n *     data: [[\"id\", \"name\"], [\"ABEOX135\", \"Jorge\"]],\n *   }\n * });\n * ```\n *\n * 3) Without cache invalidation (no queryKey):\n * ```ts\n * const { update } = useDatastoreMutations({});\n *\n * update.mutate({\n *   id: \"ds-123\",\n *   data: { name: \"Renamed datastore\" }\n * });\n * // Mutation still runs and alerts are shown, but cached queries are not invalidated.\n * ```\n *\n * 4) Using `useFetchDatastore` queryKey for automatic invalidation:\n * ```ts\n * const fetch = useFetchDatastore({\n *   id: null,\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n * });\n *\n * const { create } = useDatastoreMutations({ queryKey: fetch.queryKey });\n *\n * await create.mutateAsync({\n *   data: { name: \"My datastore\", workspace: \"ws-1\" }\n * });\n * ```\n */\n\nexport const useDatastoreMutations = ({ queryKey }: UseDatastoreMutationsProps) => {\n    const { api } = useAxios();\n\n    const create = useEntityMutation({\n        mutationFn: ({ data }: CreateDatastoreProps) => createDatastore(api, data),\n        queryKey,\n        successMessage: \"Datastore created successfully.\",\n        errorMessage: \"Unable to create the datastore. Please try again.\",\n    });\n\n    const update = useEntityMutation({\n        mutationFn: ({ id, data }: UpdateDatastoreProps) => updateDatastore(api, id, data),\n        queryKey,\n        successMessage: \"Datastore updated successfully.\",\n        errorMessage: \"Unable to update the datastore. Please try again.\",\n    });\n\n    const remove = useEntityMutation({\n        mutationFn: ({ id, workspace }: DeleteDatastoreProps) =>\n            deleteDatastore(api, id, workspace),\n        queryKey,\n        successMessage: \"Datastore deleted successfully.\",\n        errorMessage: \"Unable to delete the datastore. Please try again.\",\n    });\n\n    return { create, update, remove };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyJA,IAAa,yBAAyB,EAAE,eAA2C;CAC/E,MAAM,EAAE,QAAQ,SAAS;CAwBzB,OAAO;EAAE,QAtBM,kBAAkB;GAC7B,aAAa,EAAE,WAAiC,gBAAgB,KAAK,IAAI;GACzE;GACA,gBAAgB;GAChB,cAAc;EAClB,CAiBS;EAAQ,QAfF,kBAAkB;GAC7B,aAAa,EAAE,IAAI,WAAiC,gBAAgB,KAAK,IAAI,IAAI;GACjF;GACA,gBAAgB;GAChB,cAAc;EAClB,CAUiB;EAAQ,QARV,kBAAkB;GAC7B,aAAa,EAAE,IAAI,gBACf,gBAAgB,KAAK,IAAI,SAAS;GACtC;GACA,gBAAgB;GAChB,cAAc;EAClB,CAEyB;CAAO;AACpC"}

package/dist/hooks/datastore/useFetchDatastore.d.ts

@@ -1,47 +1,36 @@
-import type { DatastoreWithRows } from "../../types/datastore.d.ts";
-import type { FetchEntityParams } from "../../types/entityQuery.d.ts";
-export type FetchDatastoreProps = FetchEntityParams<DatastoreWithRows>;
+import type { ParsedDatastore } from "../../types/datastore.d.ts";
+import type { DatastoreDataFormat } from "../../types/datastoreDataFormat.d.ts";
+import type { FetchEntityByIdProps } from "../../types/entityQuery.d.ts";
+export type FetchDatastoreProps<F extends DatastoreDataFormat = "object", TSelected = ParsedDatastore<F>> = FetchEntityByIdProps<ParsedDatastore<F>, TSelected> & {
+    /**
+     * Tabular datastores only: `"object"` (default) turns the matrix into one object per row;
+     * `"matrix"` leaves the matrix, header row included. A JSON datastore's `data` is unchanged either way.
+     */
+    dataFormat?: F;
+};
 /**
  * useFetchDatastore
  *
- * Data-fetching hook built on TanStack Query to retrieve a single datastore by ID.
- *
- * It also:
- * - triggers an error alert via `useAppAlert` whenever `query.error` is present
- *
- * Important notes:
- * - Returns a `DatastoreWithRows` object: the full `Datastore` shape with `data`
- *   replaced by `AnyRecord[]` (rows transformed via `tableToObjects`).
- *
- * Parameters (FetchDatastoreProps):
- * @param {string} id
- *   Datastore identifier (required).
- *
- * @param {string} workspace
- *   Workspace the datastore belongs to (required by `getDatastore`).
+ * Fetches one datastore. `data` is a `ParsedDatastore` — a table's matrix converted to row
+ * objects with `fields`, or a JSON datastore's content untouched, told apart by `format`, the
+ * same shape `useFetchDatastores` returns — or whatever `select` makes of it. With
+ * `dataFormat: "matrix"` a tabular datastore keeps its matrix unconverted, as in `useFetchDatastores`.
  *
- * @param {EntityQueryOptions<DatastoreWithRows>} [queryOptions=defaultQueryOptions]
- *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ * Idle while `id` is empty; fails loudly, without a request, while `workspace` is. A failure is
+ * shown as an error alert.
  *
- * Returns:
- * @returns {object}
- *   TanStack Query's `query` object extended with:
- *   - `queryKey`: the cache key used by React Query
+ * @param {FetchDatastoreProps} props - `id`, `workspace`, `dataFormat`, `select` and TanStack
+ *   `queryOptions`.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  *
  * Example:
  * ```ts
- * const { data, isLoading } = useFetchDatastore({
- *   id: "abc123",
- *   workspace: "my-workspace",
- * });
- * // data -> DatastoreWithRows (datastore metadata + rows as AnyRecord[])
- * // data.name -> "my-datastore"
- * // data.data -> [{ datastoreId: "abc123", col1: "value", ... }]
+ * const { data, isLoading, queryKey } = useFetchDatastore({ id: "abc123", workspace: "ws-1" });
  * ```
  */
-export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchDatastoreProps) => {
+export declare const useFetchDatastore: <F extends DatastoreDataFormat = "object", TSelected = ParsedDatastore<F>>({ id, workspace, dataFormat, select, queryOptions, }: FetchDatastoreProps<F, TSelected>) => {
     queryKey: string[];
-    data: DatastoreWithRows;
+    data: TSelected;
     error: Error;
     isError: true;
     isPending: false;
@@ -64,11 +53,11 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: DatastoreWithRows;
+    data: TSelected;
     error: null;
     isError: false;
     isPending: false;
@@ -91,7 +80,7 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -118,7 +107,7 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -145,7 +134,7 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -172,11 +161,11 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: DatastoreWithRows;
+    data: TSelected;
     isError: false;
     error: null;
     isPending: false;
@@ -199,7 +188,7 @@ export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchD
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
 //# sourceMappingURL=useFetchDatastore.d.ts.map

package/dist/hooks/datastore/useFetchDatastore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchDatastore.d.ts","sourceRoot":"","sources":["../../../src/hooks/datastore/useFetchDatastore.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;AAQvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAAI,iCAAuD,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC3G,CAAC"}
+{"version":3,"file":"useFetchDatastore.d.ts","sourceRoot":"","sources":["../../../src/hooks/datastore/useFetchDatastore.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,MAAM,MAAM,mBAAmB,CAC3B,CAAC,SAAS,mBAAmB,GAAG,QAAQ,EACxC,SAAS,GAAG,eAAe,CAAC,CAAC,CAAC,IAC9B,oBAAoB,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG;IACtD;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB,GAC1B,CAAC,SAAS,mBAAmB,GAAG,QAAQ,EACxC,SAAS,GAAG,eAAe,CAAC,CAAC,CAAC,EAChC,sDAMC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBnC,CAAC"}

package/dist/hooks/datastore/useFetchDatastore.js

@@ -1,81 +1,47 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } from "../../api/entityQuery.js";
 import { getDatastore } from "../../api/datastore.js";
-import { tableToObjects } from "../../lib/datastoreTable.js";
-import { useEffect } from "react";
-import { useQuery } from "@tanstack/react-query";
+import { parseDatastore } from "../../lib/datastoreTable.js";
 //#region src/hooks/datastore/useFetchDatastore.ts
-var defaultQueryOptions = {
-	refetchOnMount: "always",
-	staleTime: 0,
-	gcTime: 0
-};
 /**
 * useFetchDatastore
 *
-* Data-fetching hook built on TanStack Query to retrieve a single datastore by ID.
-*
-* It also:
-* - triggers an error alert via `useAppAlert` whenever `query.error` is present
-*
-* Important notes:
-* - Returns a `DatastoreWithRows` object: the full `Datastore` shape with `data`
-*   replaced by `AnyRecord[]` (rows transformed via `tableToObjects`).
-*
-* Parameters (FetchDatastoreProps):
-* @param {string} id
-*   Datastore identifier (required).
-*
-* @param {string} workspace
-*   Workspace the datastore belongs to (required by `getDatastore`).
+* Fetches one datastore. `data` is a `ParsedDatastore` — a table's matrix converted to row
+* objects with `fields`, or a JSON datastore's content untouched, told apart by `format`, the
+* same shape `useFetchDatastores` returns — or whatever `select` makes of it. With
+* `dataFormat: "matrix"` a tabular datastore keeps its matrix unconverted, as in `useFetchDatastores`.
 *
-* @param {EntityQueryOptions<DatastoreWithRows>} [queryOptions=defaultQueryOptions]
-*   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+* Idle while `id` is empty; fails loudly, without a request, while `workspace` is. A failure is
+* shown as an error alert.
 *
-* Returns:
-* @returns {object}
-*   TanStack Query's `query` object extended with:
-*   - `queryKey`: the cache key used by React Query
+* @param {FetchDatastoreProps} props - `id`, `workspace`, `dataFormat`, `select` and TanStack
+*   `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 *
 * Example:
 * ```ts
-* const { data, isLoading } = useFetchDatastore({
-*   id: "abc123",
-*   workspace: "my-workspace",
-* });
-* // data -> DatastoreWithRows (datastore metadata + rows as AnyRecord[])
-* // data.name -> "my-datastore"
-* // data.data -> [{ datastoreId: "abc123", col1: "value", ... }]
+* const { data, isLoading, queryKey } = useFetchDatastore({ id: "abc123", workspace: "ws-1" });
 * ```
 */
-var useFetchDatastore = ({ id, workspace, queryOptions = defaultQueryOptions }) => {
+var useFetchDatastore = ({ id, workspace, dataFormat, select, queryOptions }) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
+	const format = dataFormat ?? "object";
 	const queryKey = [
 		"datastore",
 		id,
-		workspace
+		workspace,
+		format
 	];
-	const query = useQuery({
-		queryKey,
-		queryFn: async () => {
-			const datastore = await getDatastore(api, id, workspace);
-			return {
-				...datastore,
-				data: tableToObjects(datastore.id, datastore.data?.[0], datastore.data)
-			};
-		},
-		...queryOptions ?? {}
-	});
-	useEffect(() => {
-		if (!query.error) return;
-		showAlert({
-			severity: "error",
-			message: query.error.message
-		});
-	}, [query.error, showAlert]);
 	return {
-		...query,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: async (signal) => parseDatastore(await getDatastore(api, id, workspace, signal), format),
+			select,
+			enabled: Boolean(id),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchDatastore"),
+			queryOptions
+		}),
 		queryKey
 	};
 };

package/dist/hooks/datastore/useFetchDatastore.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchDatastore.js","names":[],"sources":["../../../src/hooks/datastore/useFetchDatastore.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { getDatastore } from \"@/api/datastore\";\nimport { tableToObjects } from \"@/lib/datastoreTable\";\nimport type { DatastoreWithRows } from \"@/types/datastore\";\nimport type { EntityQueryOptions, FetchEntityParams } from \"@/types/entityQuery\";\n\nexport type FetchDatastoreProps = FetchEntityParams<DatastoreWithRows>;\n\nconst defaultQueryOptions: EntityQueryOptions<DatastoreWithRows> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchDatastore\n *\n * Data-fetching hook built on TanStack Query to retrieve a single datastore by ID.\n *\n * It also:\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * Important notes:\n * - Returns a `DatastoreWithRows` object: the full `Datastore` shape with `data`\n *   replaced by `AnyRecord[]` (rows transformed via `tableToObjects`).\n *\n * Parameters (FetchDatastoreProps):\n * @param {string} id\n *   Datastore identifier (required).\n *\n * @param {string} workspace\n *   Workspace the datastore belongs to (required by `getDatastore`).\n *\n * @param {EntityQueryOptions<DatastoreWithRows>} [queryOptions=defaultQueryOptions]\n *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * Returns:\n * @returns {object}\n *   TanStack Query's `query` object extended with:\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchDatastore({\n *   id: \"abc123\",\n *   workspace: \"my-workspace\",\n * });\n * // data -> DatastoreWithRows (datastore metadata + rows as AnyRecord[])\n * // data.name -> \"my-datastore\"\n * // data.data -> [{ datastoreId: \"abc123\", col1: \"value\", ... }]\n * ```\n */\nexport const useFetchDatastore = ({ id, workspace, queryOptions = defaultQueryOptions }: FetchDatastoreProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"datastore\", id, workspace];\n\n    const query = useQuery<DatastoreWithRows>({\n        queryKey,\n        queryFn: async () => {\n            const datastore = await getDatastore(api, id, workspace);\n\n            return {\n                ...datastore,\n                data: tableToObjects(\n                    datastore.id,\n                    datastore.data?.[0] as string[],\n                    datastore.data\n                ),\n            };\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;;AAaA,IAAM,sBAA6D;CAC/D,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,qBAAqB,EAAE,IAAI,WAAW,eAAe,0BAA+C;CAE7G,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAa;EAAI;CAAS;CAE5C,MAAM,QAAQ,SAA4B;EACtC;EACA,SAAS,YAAY;GACjB,MAAM,YAAY,MAAM,aAAa,KAAK,IAAI,SAAS;GAEvD,OAAO;IACH,GAAG;IACH,MAAM,eACF,UAAU,IACV,UAAU,OAAO,IACjB,UAAU,IACd;GACJ;EACJ;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}
+{"version":3,"file":"useFetchDatastore.js","names":[],"sources":["../../../src/hooks/datastore/useFetchDatastore.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport { getDatastore } from \"@/api/datastore\";\nimport { parseDatastore } from \"@/lib/datastoreTable\";\nimport type { ParsedDatastore } from \"@/types/datastore\";\nimport type { DatastoreDataFormat } from \"@/types/datastoreDataFormat\";\nimport type { FetchEntityByIdProps } from \"@/types/entityQuery\";\n\nexport type FetchDatastoreProps<\n    F extends DatastoreDataFormat = \"object\",\n    TSelected = ParsedDatastore<F>,\n> = FetchEntityByIdProps<ParsedDatastore<F>, TSelected> & {\n    /**\n     * Tabular datastores only: `\"object\"` (default) turns the matrix into one object per row;\n     * `\"matrix\"` leaves the matrix, header row included. A JSON datastore's `data` is unchanged either way.\n     */\n    dataFormat?: F;\n};\n\n/**\n * useFetchDatastore\n *\n * Fetches one datastore. `data` is a `ParsedDatastore` — a table's matrix converted to row\n * objects with `fields`, or a JSON datastore's content untouched, told apart by `format`, the\n * same shape `useFetchDatastores` returns — or whatever `select` makes of it. With\n * `dataFormat: \"matrix\"` a tabular datastore keeps its matrix unconverted, as in `useFetchDatastores`.\n *\n * Idle while `id` is empty; fails loudly, without a request, while `workspace` is. A failure is\n * shown as an error alert.\n *\n * @param {FetchDatastoreProps} props - `id`, `workspace`, `dataFormat`, `select` and TanStack\n *   `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n *\n * Example:\n * ```ts\n * const { data, isLoading, queryKey } = useFetchDatastore({ id: \"abc123\", workspace: \"ws-1\" });\n * ```\n */\nexport const useFetchDatastore = <\n    F extends DatastoreDataFormat = \"object\",\n    TSelected = ParsedDatastore<F>,\n>({\n    id,\n    workspace,\n    dataFormat,\n    select,\n    queryOptions,\n}: FetchDatastoreProps<F, TSelected>) => {\n    const { api } = useAxios();\n\n    const format = (dataFormat ?? \"object\") as F;\n    const queryKey = [\"datastore\", id, workspace, format];\n\n    const query = useEntityQuery<ParsedDatastore<F>, TSelected>({\n        queryKey,\n        fetchEntity: async (signal) =>\n            parseDatastore(await getDatastore(api, id, workspace, signal), format),\n        select,\n        enabled: Boolean(id),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchDatastore\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,qBAGX,EACE,IACA,WACA,YACA,QACA,mBACqC;CACrC,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,SAAU,cAAc;CAC9B,MAAM,WAAW;EAAC;EAAa;EAAI;EAAW;CAAM;CAYpD,OAAO;EAAE,GAVK,eAA8C;GACxD;GACA,aAAa,OAAO,WAChB,eAAe,MAAM,aAAa,KAAK,IAAI,WAAW,MAAM,GAAG,MAAM;GACzE;GACA,SAAS,QAAQ,EAAE;GACnB,aAAa,YAAY,KAAA,IAAY,sBAAsB,mBAAmB;GAC9E;EACJ,CAEY;EAAO;CAAS;AAChC"}