@dynamic-labs-sdk/react-hooks 1.14.0 → 1.17.0

package/dist/index.esm.js

@@ -7,7 +7,7 @@ import { getCore } from "@dynamic-labs-sdk/client/core";
 
 //#region package.json
 var name = "@dynamic-labs-sdk/react-hooks";
-var version = "1.14.0";
+var version = "1.17.0";
 
 //#endregion
 //#region src/modules/DynamicContext/DynamicContext.ts
@@ -57,6 +57,7 @@ const useDynamicClient = () => {
 
 //#endregion
 //#region src/foundation/useBaseMutation/useBaseMutation.ts
+const EMPTY_MIDDLEWARES$1 = [];
 /**
 * Internal hook that wraps a react-query `useMutation` with the conventions
 * used by every async-write hook in this package:
@@ -67,12 +68,15 @@ const useDynamicClient = () => {
 * - Callers pass `mutateParams` to override any default
 *   `UseMutationOptions`, so consumers can wire `onSuccess` / `onError` /
 *   etc.
+* - Callers pass `middlewares` (named hooks like `invalidatesQueries`) and
+*   each contributed `onSuccess` runs, in order, ahead of the consumer's own.
 *
 * Returns the full `useMutation` result — `mutate`, `mutateAsync`, `data`,
 * `error`, `isPending`, `isSuccess`, `reset`, `status`, etc.
 */
-const useBaseMutation = ({ mutationFn, mutateParams }) => {
+const useBaseMutation = ({ middlewares = EMPTY_MIDDLEWARES$1, mutationFn, mutateParams }) => {
 	const client = useDynamicClient();
+	const contributions = middlewares.map((useMiddleware) => useMiddleware());
 	return useMutation({
 		mutationFn: async (variables) => {
 			await waitForClientInitialized(client);
@@ -81,7 +85,11 @@ const useBaseMutation = ({ mutationFn, mutateParams }) => {
 				variables
 			});
 		},
-		...mutateParams
+		...mutateParams,
+		onSuccess: async (...args) => {
+			for (const contribution of contributions) await contribution.onSuccess?.(...args);
+			return mutateParams?.onSuccess?.(...args);
+		}
 	});
 };
 
@@ -103,9 +111,32 @@ const useAcknowledgeRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client }) => acknowledgeRecoveryCodes(client)
 });
 
+//#endregion
+//#region src/foundation/hookKeyNamespace/hookKeyNamespace.ts
+/**
+* Root namespace shared by every react-query key this package creates.
+* Both `QUERY_KEY_PREFIX` (async-read hooks) and the state-hook key
+* prefix derive from this constant so the namespace is defined exactly
+* once.
+*/
+const HOOK_KEY_NAMESPACE = "@dynamic-labs-sdk/react-hooks";
+
+//#endregion
+//#region src/foundation/useBaseQuery/queryKeyPrefix.ts
+/**
+* Shared prefix for all query keys created by `useBaseQuery`. Mutation hooks
+* reference this when invalidating related queries on success.
+*/
+const QUERY_KEY_PREFIX = [HOOK_KEY_NAMESPACE, "query"];
+
 //#endregion
 //#region src/foundation/useBaseQuery/useBaseQuery.ts
 /**
+* Stable empty default for the `middlewares` param so the common (ungated)
+* case never allocates a fresh array per render.
+*/
+const EMPTY_MIDDLEWARES = [];
+/**
 * Internal hook that wraps a react-query `useQuery` with the conventions used
 * by every async-read hook in this package:
 *
@@ -116,24 +147,24 @@ const useAcknowledgeRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation({
 *   so consumers can opt into retries / custom staleTime / etc.
 * - Callers pass `enabled: false` (typically derived from whether their
 *   pseudo-required arguments are present) to short-circuit fetches.
+* - Callers pass `middlewares` (named hooks that gate the query and/or run
+*   reactive subscriptions) and the query only runs when every one returns
+*   `true`.
 *
 * Returns the full `useQuery` result — `data`, `error`, `isLoading`,
 * `isFetching`, `isSuccess`, `refetch`, `status`, etc.
 */
-const useBaseQuery = ({ queryFn, queryKey, queryParams, enabled = true }) => {
+const useBaseQuery = ({ enabled = true, middlewares = EMPTY_MIDDLEWARES, queryFn, queryKey, queryParams }) => {
 	const client = useDynamicClient();
+	const middlewaresAllow = middlewares.map((useMiddleware) => useMiddleware()).every(Boolean);
 	return useQuery({
 		queryFn: async () => {
 			await waitForClientInitialized(client);
 			return queryFn(client);
 		},
-		queryKey: useMemo(() => [
-			"@dynamic-labs-sdk/react-hooks",
-			"query",
-			...queryKey
-		], [queryKey]),
+		queryKey: useMemo(() => [...QUERY_KEY_PREFIX, ...queryKey], [queryKey]),
 		...queryParams,
-		enabled: enabled && queryParams?.enabled !== false
+		enabled: enabled && middlewaresAllow && queryParams?.enabled !== false
 	});
 };
 
@@ -272,6 +303,48 @@ const useAuthenticatePasskeyMFA = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => authenticatePasskeyMFA(variables, client)
 });
 
+//#endregion
+//#region src/middlewares/invalidatesQueries/invalidatesQueries.ts
+/**
+* Mutation middleware factory that invalidates one or more query hooks when
+* the mutation succeeds, so any mounted consumer of those queries refetches.
+*
+* Pass the query hooks' names (their `queryKey` leaf, e.g. `'useGetMfaDevices'`);
+* each is namespaced under `QUERY_KEY_PREFIX` to match the keys `useBaseQuery`
+* creates. The invalidation loop lives here, not in `useBaseMutation`.
+*
+* @example
+* ```ts
+* useBaseMutation({
+*   middlewares: [invalidatesQueries('useGetMfaDevices')],
+*   mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client),
+* });
+* ```
+*/
+const invalidatesQueries = (...queryKeys) => () => {
+	const queryClient = useQueryClient();
+	const client = useDynamicClient();
+	/**
+	* Swallows an `invalidateQueries` rejection so a failed refetch never
+	* surfaces as an unhandled rejection nor rejects the combined invalidation
+	* promise, while still logging it at debug level so internal devs can see
+	* which query failed to refetch. Curried over the query key and extracted
+	* to a named handler so the invalidation map stays within the
+	* function-nesting limit.
+	*/
+	const debugInvalidationFailure = (queryKey) => (error) => {
+		getCore(client).logger.debug("[invalidatesQueries] failed to invalidate query", {
+			error,
+			queryKey,
+			stack: error instanceof Error ? error.stack : void 0
+		});
+	};
+	return { onSuccess: () => Promise.all(queryKeys.map((key) => {
+		const queryKey = [...QUERY_KEY_PREFIX, key];
+		return queryClient.invalidateQueries({ queryKey }).catch(debugInvalidationFailure(queryKey));
+	})) };
+};
+
 //#endregion
 //#region src/hooks/wrappers/functions/useAuthenticateTotpMfaDevice/useAuthenticateTotpMfaDevice.ts
 /**
@@ -289,10 +362,13 @@ const useAuthenticatePasskeyMFA = ({ mutateParams } = {}) => useBaseMutation({
 * </button>
 * ```
 */
-const useAuthenticateTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => authenticateTotpMfaDevice(variables, client)
-});
+const useAuthenticateTotpMfaDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetMfaDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => authenticateTotpMfaDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/foundation/useBaseState/useBaseState.ts
@@ -363,7 +439,7 @@ const useBaseState = ({ event, queryKey, queryParams, selector, defaultValue, sk
 		return Object.keys(map).sort((a, b) => a.localeCompare(b));
 	}, [eventsMapJson]);
 	const fullQueryKey = useMemo(() => [
-		"@dynamic-labs-sdk/react-hooks",
+		HOOK_KEY_NAMESPACE,
 		"state",
 		...queryKey
 	], [JSON.stringify(queryKey)]);
@@ -554,6 +630,7 @@ const useAddCoinbaseOnrampOrderEventListener = ({ listener }) => {
 * ```
 */
 const useCompleteDeviceRegistration = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetRegisteredDevices")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => completeDeviceRegistration(variables, client)
 });
@@ -734,10 +811,13 @@ const useCreateNewMfaRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation(
 * </button>
 * ```
 */
-const useDeleteMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client)
-});
+const useDeleteMfaDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetMfaDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useDeletePasskey/useDeletePasskey.ts
@@ -1252,6 +1332,7 @@ const useRegisterPasskey = ({ mutateParams } = {}) => useBaseMutation({
 * ```
 */
 const useRegisterTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetMfaDevices")],
 	mutateParams,
 	mutationFn: ({ client }) => registerTotpMfaDevice(client)
 });
@@ -1312,10 +1393,13 @@ const useRequestExternalAuthElevatedToken = ({ mutateParams } = {}) => useBaseMu
 * </button>
 * ```
 */
-const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client }) => revokeAllRegisteredDevices(client)
-});
+const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetRegisteredDevices")],
+		mutateParams,
+		mutationFn: ({ client }) => revokeAllRegisteredDevices(client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useRevokeRegisteredDevice/useRevokeRegisteredDevice.ts
@@ -1338,10 +1422,13 @@ const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => useBaseMutation
 * </button>
 * ```
 */
-const useRevokeRegisteredDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => revokeRegisteredDevice(variables, client)
-});
+const useRevokeRegisteredDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetRegisteredDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => revokeRegisteredDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useSendEmailOTP/useSendEmailOTP.ts
@@ -1416,6 +1503,7 @@ const useSendSmsOTP = ({ mutateParams } = {}) => useBaseMutation({
 * ```
 */
 const useSetDefaultMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetMfaDevices")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => setDefaultMfaDevice(variables, client)
 });