@everysk/apps-sdk 0.1.0-beta.0

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

@@ -0,0 +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"}

package/dist/datastore/index.d.ts

@@ -0,0 +1,7 @@
+export * from "../api/datastore.js";
+export * from "../types/datastore.d.ts";
+export * from "../hooks/datastore/useDatastoreMutations.js";
+export * from "../hooks/datastore/useFetchDatastore.js";
+export * from "../hooks/datastore/useFetchDatastores.js";
+export * from "../lib/datastoreTable.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datastore/index.ts"],"names":[],"mappings":"AAQA,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,sBAAsB,CAAC"}

package/dist/file/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../api/file.js";
+export * from "../types/file.d.ts";
+export * from "../hooks/file/useFetchFile.js";
+export * from "../hooks/file/useFetchFiles.js";
+export * from "../hooks/file/useFileMutations.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,151 @@
+import type { Datastore } from "../../types/datastore.d.ts";
+type CreateDatastoreProps = {
+    data: Partial<Datastore>;
+};
+type UpdateDatastoreProps = {
+    id: string;
+    data: Partial<Datastore>;
+};
+type DeleteDatastoreProps = {
+    id: string;
+    workspace: string;
+};
+type UseDatastoreMutationsProps = {
+    queryKey?: unknown[];
+};
+/**
+ * useDatastoreMutations
+ *
+ * Mutation hook built on TanStack Query to perform Datastore write operations:
+ * - create a datastore (POST)
+ * - update a datastore (PUT)
+ * - delete a datastore (DELETE)
+ *
+ * It also:
+ * - optionally invalidates a target query cache key after successful mutations
+ * - displays success/error alerts via `useAppAlert`
+ *
+ * Important notes:
+ * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchDatastore`.
+ * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run
+ *   mutations and show alerts, but it will NOT invalidate any cached queries.
+ * - `remove` requires a `workspace` parameter because the underlying API helper `deleteDatastore(api, id, workspace)`
+ *   expects it as a query param.
+ *
+ * Parameters (UseDatastoreMutationsProps):
+ * @param {unknown[]} [queryKey]
+ *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`
+ *  (e.g., datastore list/detail) so UI data is refreshed automatically after a write.
+ *
+ *  Tip:
+ *  - If you're using `useFetchDatastore`, you can pass its returned `queryKey` directly:
+ *    `const fetch = useFetchDatastore(...);`
+ *    `useDatastoreMutations({ queryKey: fetch.queryKey });`
+ *
+ * Mutations:
+ * - `create`:
+ *   - mutationFn: `createDatastore(api, data)`
+ *   - variables: `{ data: Partial<Datastore> }`
+ *   - success message: "Datastore created successfully."
+ *   - error message: "Unable to create the datastore. Please try again." (fallback)
+ *
+ * - `update`:
+ *   - mutationFn: `updateDatastore(api, id, data)`
+ *   - variables: `{ id: string; data: Partial<Datastore> }`
+ *   - success message: "Datastore updated successfully."
+ *   - error message: "Unable to update the datastore. Please try again." (fallback)
+ *
+ * - `remove`:
+ *   - mutationFn: `deleteDatastore(api, id, workspace)`
+ *   - variables: `{ id: string; workspace: string }`
+ *   - success message: "Datastore deleted successfully."
+ *   - error message: "Unable to delete the datastore. Please try again." (fallback)
+ *
+ * Return value:
+ * @returns {object}
+ *  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>
+ *
+ * Each mutation includes standard TanStack Query helpers:
+ * - `mutate(variables, options?)`
+ * - `mutateAsync(variables, options?)`
+ * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.
+ *
+ * Examples:
+ *
+ * 1) Invalidate a datastore list query after mutations:
+ * ```ts
+ * const { create, update, remove } = useDatastoreMutations({ queryKey: ["datastore"] });
+ *
+ * // Create
+ * create.mutate({
+ *   data: {
+ *     name: "My datastore",
+ *     workspace: "ws-1",
+ *     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+ *   }
+ * });
+ *
+ * // Update
+ * update.mutate({
+ *   id: "ds-123",
+ *   data: {
+ *     name: "Renamed datastore",
+ *     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+ *   }
+ * });
+ *
+ * // Delete
+ * remove.mutate({
+ *   id: "ds-123",
+ *   workspace: "ws-1"
+ * });
+ * ```
+ *
+ * 2) Using async/await with `mutateAsync`:
+ * ```ts
+ * const { create } = useDatastoreMutations({ queryKey: ["datastore"] });
+ *
+ * await create.mutateAsync({
+ *   data: {
+ *     name: "My datastore",
+ *     workspace: "ws-1",
+ *     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+ *   }
+ * });
+ * ```
+ *
+ * 3) Without cache invalidation (no queryKey):
+ * ```ts
+ * const { update } = useDatastoreMutations({});
+ *
+ * update.mutate({
+ *   id: "ds-123",
+ *   data: { name: "Renamed datastore" }
+ * });
+ * // Mutation still runs and alerts are shown, but cached queries are not invalidated.
+ * ```
+ *
+ * 4) Using `useFetchDatastore` queryKey for automatic invalidation:
+ * ```ts
+ * const fetch = useFetchDatastore({
+ *   id: null,
+ *   filters: [{ field: "workspace", value: "ws-1" }],
+ * });
+ *
+ * const { create } = useDatastoreMutations({ queryKey: fetch.queryKey });
+ *
+ * await create.mutateAsync({
+ *   data: { name: "My datastore", workspace: "ws-1" }
+ * });
+ * ```
+ */
+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>;
+};
+export {};
+//# sourceMappingURL=useDatastoreMutations.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/datastore/useDatastoreMutations.js

@@ -0,0 +1,198 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.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
+*
+* Mutation hook built on TanStack Query to perform Datastore write operations:
+* - create a datastore (POST)
+* - update a datastore (PUT)
+* - delete a datastore (DELETE)
+*
+* It also:
+* - optionally invalidates a target query cache key after successful mutations
+* - displays success/error alerts via `useAppAlert`
+*
+* Important notes:
+* - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchDatastore`.
+* - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run
+*   mutations and show alerts, but it will NOT invalidate any cached queries.
+* - `remove` requires a `workspace` parameter because the underlying API helper `deleteDatastore(api, id, workspace)`
+*   expects it as a query param.
+*
+* Parameters (UseDatastoreMutationsProps):
+* @param {unknown[]} [queryKey]
+*  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`
+*  (e.g., datastore list/detail) so UI data is refreshed automatically after a write.
+*
+*  Tip:
+*  - If you're using `useFetchDatastore`, you can pass its returned `queryKey` directly:
+*    `const fetch = useFetchDatastore(...);`
+*    `useDatastoreMutations({ queryKey: fetch.queryKey });`
+*
+* Mutations:
+* - `create`:
+*   - mutationFn: `createDatastore(api, data)`
+*   - variables: `{ data: Partial<Datastore> }`
+*   - success message: "Datastore created successfully."
+*   - error message: "Unable to create the datastore. Please try again." (fallback)
+*
+* - `update`:
+*   - mutationFn: `updateDatastore(api, id, data)`
+*   - variables: `{ id: string; data: Partial<Datastore> }`
+*   - success message: "Datastore updated successfully."
+*   - error message: "Unable to update the datastore. Please try again." (fallback)
+*
+* - `remove`:
+*   - mutationFn: `deleteDatastore(api, id, workspace)`
+*   - variables: `{ id: string; workspace: string }`
+*   - success message: "Datastore deleted successfully."
+*   - error message: "Unable to delete the datastore. Please try again." (fallback)
+*
+* Return value:
+* @returns {object}
+*  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>
+*
+* Each mutation includes standard TanStack Query helpers:
+* - `mutate(variables, options?)`
+* - `mutateAsync(variables, options?)`
+* - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.
+*
+* Examples:
+*
+* 1) Invalidate a datastore list query after mutations:
+* ```ts
+* const { create, update, remove } = useDatastoreMutations({ queryKey: ["datastore"] });
+*
+* // Create
+* create.mutate({
+*   data: {
+*     name: "My datastore",
+*     workspace: "ws-1",
+*     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+*   }
+* });
+*
+* // Update
+* update.mutate({
+*   id: "ds-123",
+*   data: {
+*     name: "Renamed datastore",
+*     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+*   }
+* });
+*
+* // Delete
+* remove.mutate({
+*   id: "ds-123",
+*   workspace: "ws-1"
+* });
+* ```
+*
+* 2) Using async/await with `mutateAsync`:
+* ```ts
+* const { create } = useDatastoreMutations({ queryKey: ["datastore"] });
+*
+* await create.mutateAsync({
+*   data: {
+*     name: "My datastore",
+*     workspace: "ws-1",
+*     data: [["id", "name"], ["ABEOX135", "Jorge"]],
+*   }
+* });
+* ```
+*
+* 3) Without cache invalidation (no queryKey):
+* ```ts
+* const { update } = useDatastoreMutations({});
+*
+* update.mutate({
+*   id: "ds-123",
+*   data: { name: "Renamed datastore" }
+* });
+* // Mutation still runs and alerts are shown, but cached queries are not invalidated.
+* ```
+*
+* 4) Using `useFetchDatastore` queryKey for automatic invalidation:
+* ```ts
+* const fetch = useFetchDatastore({
+*   id: null,
+*   filters: [{ field: "workspace", value: "ws-1" }],
+* });
+*
+* const { create } = useDatastoreMutations({ queryKey: fetch.queryKey });
+*
+* await create.mutateAsync({
+*   data: { name: "My datastore", workspace: "ws-1" }
+* });
+* ```
+*/
+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.")
+				});
+			}
+		}),
+		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.")
+				});
+			}
+		}),
+		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.")
+				});
+			}
+		})
+	};
+};
+//#endregion
+export { useDatastoreMutations };
+
+//# sourceMappingURL=useDatastoreMutations.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,205 @@
+import type { DatastoreWithRows } from "../../types/datastore.d.ts";
+import type { FetchEntityParams } from "../../types/entityQuery.d.ts";
+export type FetchDatastoreProps = FetchEntityParams<DatastoreWithRows>;
+/**
+ * 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`).
+ *
+ * @param {EntityQueryOptions<DatastoreWithRows>} [queryOptions=defaultQueryOptions]
+ *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * Returns:
+ * @returns {object}
+ *   TanStack Query's `query` object extended with:
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * 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", ... }]
+ * ```
+ */
+export declare const useFetchDatastore: ({ id, workspace, queryOptions }: FetchDatastoreProps) => {
+    queryKey: string[];
+    data: DatastoreWithRows;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: DatastoreWithRows;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: DatastoreWithRows;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<DatastoreWithRows, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchDatastore.d.ts.map

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

@@ -0,0 +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"}