refreshing or invalidating a provider ?

[kivocsa99]

Basically , i have this function in my repository layer :

  @override
  Future<Either<ApiFailures, String>> addNewLocation({
    required AddressModel address,
  }) async {
    try {
      final String createAddressMutation = r'''
        mutation CustomerAddressCreate($customerAccessToken: String!, $address: MailingAddressInput!) {
          customerAddressCreate(customerAccessToken: $customerAccessToken, address: $address) {
            customerAddress {
              id
              address1
              address2
              city
              company
              country
              countryCode
              countryCodeV2
              firstName
              formatted
              formattedArea
              lastName
              latitude
              longitude
              name
              phone
              province
              provinceCode
              zip
            }
            customerUserErrors {
              code
              field
              message
            }
          }
        }
      ''';
      var usersettings = ref.read(settingSharedPrefsNotifierProvider);

      final MutationOptions options = MutationOptions(
        document: gql(createAddressMutation),
        variables: {
          'customerAccessToken': usersettings.accessToken,
          'address': {
            "address1": address.address1,
            "firstName": address.firstName,
            "lastName": address.lastName,
            "phone": address.phone,
            "province": address.province,
            "country": address.country,
          },
        },
      );

      final QueryResult result = await client.mutate(options);

      if (result.hasException) {
        final error = result.exception?.graphqlErrors.firstOrNull;
        if (error?.message.contains('authentication') ?? false) {
          return left(const ApiFailures.cancel());
        }
        return left(ApiFailures.internalError(
            message: error?.message ??
                'An error occurred while adding the address'));
      }

      final data = result.data?['customerAddressCreate'];

      final customerUserErrors = data['customerUserErrors'] as List?;
      if (customerUserErrors != null && customerUserErrors.isNotEmpty) {
        final errorMessage = customerUserErrors.first['message'] as String;
        return left(ApiFailures.cancel(message: errorMessage));
      }

       ref.refresh(getUserDataProvider.future);
      appRouter.replaceAll([MainRoute()]);
      return right("Address added successfully");
    } on GraphQLError catch (e) {
      return left(ApiFailures.cancel(message: e.message));
    } catch (e) {
      return left(const ApiFailures.cancel());
    }
  }

and this is in my application layer :

// ignore_for_file: unused_field

import 'package:fpdart/fpdart.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:xmart/application/core/use_cases/i.use_case.dart';
import 'package:xmart/application/providers/cart.repository.provider.dart';
import 'package:xmart/application/providers/user.repository.provider.dart';
import 'package:xmart/domain/cart/interface/i.cart.repository.dart';
import 'package:xmart/domain/failures/api.failures.dart';
import 'package:xmart/domain/user/interface/i.user.repository.dart';

import 'add_location.input.dart';

final addLocationProvider = Provider((ref) =>
    AddLocationUseCase(
        userRepository: ref.watch(userRepositoryProvider)));

class AddLocationUseCase
    implements IUseCase<AddLocationUseCaseInput, String> {
  final IUserRepository? _userRepository;
  AddLocationUseCase({
    IUserRepository? userRepository,
  }) : _userRepository = userRepository;

  @override
  Future<Either<ApiFailures, String>> execute(input) async {
    return await _userRepository!.addNewLocation(
      address: input.addressModel,
    );
  }
}

my user get data function :

  @override
  Future<Either<ApiFailures, UserModel>> getUserData() async {
    const getCustomerDataQuery = '''
query Customer(\$customerAccessToken: String!) {
    customer(customerAccessToken: \$customerAccessToken) {
        acceptsMarketing
        createdAt
        displayName
        email
        firstName
        id
        lastName
        numberOfOrders
        phone
        tags
        updatedAt
        addresses(first: 100) {
            nodes {
                address1
                address2
                city
                company
                country
                countryCode
                countryCodeV2
                firstName
                formatted
                formattedArea
                id
                lastName
                latitude
                longitude
                name
                phone
                province
                provinceCode
                zip
            }
        }
                defaultAddress {
            address1
            address2
            city
            company
            country
            countryCode
            countryCodeV2
            firstName
            formatted
            formattedArea
            id
            lastName
            latitude
            longitude
            name
            phone
            province
            provinceCode
            zip
        }
    }
}
''';

    var usersettings = ref.read(settingSharedPrefsNotifierProvider);
    try {
      final result = await client.query(
        QueryOptions(
          document: gql(getCustomerDataQuery),
          variables: {
            'customerAccessToken': usersettings.accessToken,
          },
        ),
      );

      if (result.hasException) {
        return left(ApiFailures.noResponse(message: result.data.toString()));
      }

      final customerDataJson = result.data?['customer'];
      if (customerDataJson == null) {
        return left(const ApiFailures.notFound(message: "no user found"));
      }

      final user = UserModel.fromJson(customerDataJson as Map<String, dynamic>);

      usersettings = usersettings.copyWith(userId: user.id, isGuest: false);
      await ref
          .read(settingSharedPrefsNotifierProvider.notifier)
          .addItem(usersettings);

      return right(user);
    } on GraphQLError catch (e) {
      print(e);
      return left(ApiFailures.noResponse(message: e.message));
    }
  }

and it's provider :

import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:xmart/application/providers/graphql.provider.dart';
import 'package:xmart/application/providers/route.provider.dart';
import 'package:xmart/domain/user/interface/i.user.repository.dart';
import 'package:xmart/domain/user/model/user.model.dart';
import 'package:xmart/infrastructure/user/user.repository.dart';

part 'user.repository.provider.g.dart';

final userRepositoryProvider = Provider<IUserRepository>((ref) {
  return UserRepository(
    appRouter: ref.watch(appRouterProvider),
    ref: ref,
    client: ref.watch(graphQLClientProvider),
  );
});
@riverpod
Future<UserModel> getUserData(
  Ref ref,
) async {
  final result = await ref.watch(userRepositoryProvider).getUserData();
  return result.fold((left) => throw left, (data) => data);
}

Locations screen :

import 'package:auto_route/auto_route.dart';
import 'package:flutter/material.dart';
import 'package:flutter_hooks/flutter_hooks.dart';
import 'package:flutter_spinkit/flutter_spinkit.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:xmart/application/providers/route.provider.dart';
import 'package:xmart/application/providers/user.repository.provider.dart';
import 'package:xmart/application/routing/app_route.dart';
import 'package:xmart/application/user/remove_location/add_location.use_case.dart';
import 'package:xmart/application/user/remove_location/remove_location.input.dart';
import 'package:xmart/domain/user/model/user.model.dart';
import 'package:xmart/presentation/widgets/location_container.dart';
import 'package:xmart/presentation/widgets/responsive_widget.dart';

@RoutePage()
class LocationsScreen extends HookConsumerWidget {
  final AddressNodeModel addressNodeModel;
  const LocationsScreen({super.key, required this.addressNodeModel});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final isLoading = useState(false);
    final userData = ref.watch(getUserDataProvider);
    final router = ref.watch(appRouterProvider);
    return ResponsiveWidget(
      floatingActionButtonLocation: FloatingActionButtonLocation.centerFloat,
      floatingActionButton: SizedBox(
          width: MediaQuery.sizeOf(context).width - 32,
          child: FloatingActionButton.extended(
            backgroundColor: Color(0xFF0E3E5D),
            onPressed: () {
              router.push(const AddLocationRoute());
            },
            label: Row(
              spacing: 10,
              children: [
                Icon(
                  Icons.pin_drop,
                  color: Colors.white,
                ),
                Text(
                  "Add new location", // Replace with actual price
                  style: TextStyle(
                    fontSize: 20,
                    fontWeight: FontWeight.bold,
                    color: Colors.white,
                  ),
                ),
              ],
            ),
          )),
      appBar: AppBar(
        centerTitle: true,
        title: const Text('Locations'),
      ),
      child: userData.when(
        data: (data) => SizedBox(
          height: MediaQuery.sizeOf(context).height,
          width: double.infinity,
          child: RefreshIndicator(
            onRefresh: () =>
              ref.refresh(getUserDataProvider.future)
            , 
            child: ListView.separated(
                itemBuilder: (context, index) {
                  return LocationContainer(
                    onDelete: () async {
                      isLoading.value = true;
                      ref
                          .read(removeLocationProvider)
                          .execute(RemoveLocationUseCaseInput(
                              locationId: addressNodeModel.nodes![index].id!))
                          .then((value) {
                        isLoading.value = false;
                        value.fold((l) {
                          ScaffoldMessenger.of(context).showSnackBar(
                              SnackBar(content: Text(l.message.toString())));
                        }, (r) {
                          ScaffoldMessenger.of(context).showSnackBar(SnackBar(
                              content: Text("Location removed successfully")));
                        });
                      });
                    },
                    address: addressNodeModel.nodes![index],
                  );
                },
                separatorBuilder: (context, index) => const Divider(
                      color: Colors.grey,
                    ),
                itemCount: addressNodeModel.nodes!.length),
          ),
        ),
        error: (error, _) => Text(error.toString()),
        loading: () => const Center(
          child: SpinKitCubeGrid(
            color: Colors.blue,
          ),
        ),
      ),
    );
  }
}

my questions is why when i add a location the usedata doesn't get refreshed at all , and it stays cached ! , only when i reopen the app it refresh it .