asyncredux-nonreentrant-mixin - SKILL.md Agent Skill

name: asyncredux-nonreentrant-mixin description: Add the NonReentrant mixin to prevent an action from dispatching while already in progress. Covers preventing duplicate form submissions, avoiding race conditions, and protecting long-running operations.

NonReentrant Mixin

The NonReentrant mixin prevents concurrent execution of the same action type. When an action instance is already running, new dispatches of that same action are silently aborted.

Basic Usage

Add the NonReentrant mixin to any action that should not run concurrently:

class SaveAction extends AppAction with NonReentrant {
  Future<AppState?> reduce() async {
    await http.put('http://myapi.com/save', body: 'data');
    return null;
  }
}

With this mixin:

If the user clicks "Save" multiple times rapidly, only the first dispatch executes
Subsequent dispatches while the first is running are silently aborted
No duplicate API calls or race conditions occur

How It Works

The NonReentrant mixin overrides the abortDispatch method. When abortDispatch() returns true, the action's before(), reduce(), and after() methods will not run, and the state stays unchanged.

By default, checks are based on the action's runtime type - multiple instances of the same action class cannot run simultaneously.

Common Use Cases

Preventing duplicate form submissions - Stop users from accidentally submitting forms multiple times
Protecting API calls - Ensure save/update/delete operations don't fire concurrently
Resource-intensive tasks - Prevent expensive computations from running in parallel
Avoiding race conditions - Ensure sequential execution of operations that must not overlap

Customization

Allow Different Parameters to Run Concurrently

Override nonReentrantKeyParams() to allow actions with different parameters to run in parallel:

class SaveItemAction extends AppAction with NonReentrant {
  final String itemId;
  SaveItemAction(this.itemId);

  @override
  Object? nonReentrantKeyParams() => itemId;

  Future<AppState?> reduce() async {
    await saveItem(itemId);
    return null;
  }
}

With this customization:

SaveItemAction('A') and SaveItemAction('B') can run concurrently
Two SaveItemAction('A') dispatches will still block each other

Share Keys Across Different Action Types

Override computeNonReentrantKey() to make different action classes block each other:

class SaveUserAction extends AppAction with NonReentrant {
  final String orderId;
  SaveUserAction(this.orderId);

  @override
  Object? computeNonReentrantKey() => orderId;

  Future<AppState?> reduce() async { ... }
}

class DeleteUserAction extends AppAction with NonReentrant {
  final String orderId;
  DeleteUserAction(this.orderId);

  @override
  Object? computeNonReentrantKey() => orderId;

  Future<AppState?> reduce() async { ... }
}

This prevents SaveUserAction('123') and DeleteUserAction('123') from running simultaneously - useful when different operations on the same resource must not overlap.

Combining with Other Mixins

You can combine NonReentrant with other compatible mixins:

class LoadDataAction extends AppAction with CheckInternet, NonReentrant {
  Future<AppState?> reduce() async {
    final data = await fetchData();
    return state.copy(data: data);
  }
}

Incompatible mixins: NonReentrant cannot be combined with:

Throttle
UnlimitedRetryCheckInternet
Most optimistic update mixins (check the compatibility matrix)

References

URLs from the documentation: