Signal Dependencies and Injections

[LeeMatthewHiggins]

I have been experimenting with using signals in place of riverpod, I have a signal for my services and repositories, which is pretty cool as you can swap out different implementations in real time (though I mainly am trying this to limit my dependencies).

I have found it useful to be able to have a family of signals that are related.
Similar to families in riverpod.
Here's something I´ve been playing with:
I would be interested in thoughts.
If anyone thinks it's useful, I will be happy to do a pull request.

import 'package:signals/signals_flutter.dart';

SignalFamily<T, Arg> signalFamily<T, Arg>(Signal<T> Function(Arg) create,
    {bool cache = false}) {
  return SignalFamily<T, Arg>(create, cache: cache);
}

class SignalFamily<T, Arg> {
  final bool cache;
  final Map<Arg, Signal<T>> _cache = {};
  final Signal<T> Function(Arg) _create;
  SignalFamily(this._create, {this.cache = false});
  Signal<T> call(Arg arg) {
    if (cache) {
      return _cache[arg] ??= _create(arg);
    }
    return _create(arg);
  }

  void clear() {
    _cache.clear();
  }
}


/* example
final repositoryFamily = signalFamily<Repository<Booking>, String>(
  (path) {
    return signal(
      RepositoryFirestore<Booking>(
        path: path,
        toFirestore: (booking) => booking.toJson(),
        fromFirestore: (ref, data) {
          return Booking.fromJson(data);
        },
        queryBuilder: BookingsRepositoryQueryBuilder(
          path: path,
        ),
      ),
    );
  },
);



final roomBookingRepo = repositoryFamily('roomBookings');
final deskBookingRepo = repositoryFamily('deskBookings');
*/

[mafreud]

@LeeMatthewHiggins I was also thinking about the necessity of a family. I totally agree with your idea. upvote 👍

[Solido]

I get the concepts around the notion of Signal Group and Fork. It has started with Operators.
But I would stay away from Riverpod concept and vocabulary just to avoid confusion.

[Sserra90]

Maybe call it signalFactory instead of signalFamily

[Solido]

I found this an interesting field and would be happy if I can avoid to use any outside libs to handle injections.

If these got fully down the road then SignalInjector SignalDependencies or any suggestions in this domain would better capture the intention.

I would have a look at how Get_it does the stuff to have a rich template of ideas and concepts to port. It use a central repository that is exposed. Signals may use that too or use the internal Data in Node to handle the instances.

Using just a hashmap accessed by a String key will be limited too soon.

Let us know your progress and ideas, I'll be glad to challenge and see what can be done as a common solution.

[rodydavis]

Speaking of get_it I think it would be nice to also create immutable signals for use in DI but not modification

[Sserra90]

In the world of DI maybe SignalContainer can be an option like IOC containers

[rodydavis]

yeah I was just thinking about SignalContainer too.

[rodydavis]

Going to go with SignalContainer for v1. Happy to deprecate and rename in future if it makes sense

[rodydavis]

Added SignalContainer in 2.1.8:

import 'signals.dart';

/// Signal container used to create signals based on args
class SignalContainer<T, Arg> {
  /// If true then signals will be cached when created
  final bool cache;

  final Map<Arg, ReadonlySignal<T>> _cache = {};

  final ReadonlySignal<T> Function(Arg) _create;

  /// Signal container used to create multiple signals via args
  SignalContainer(
    this._create, {
    this.cache = false,
  });

  /// Create the signal with the given args
  ReadonlySignal<T> call(Arg arg) {
    if (cache) {
      return _cache.putIfAbsent(arg, () => _create(arg));
    } else {
      return _create(arg);
    }
  }

  /// Dispose of all created signals
  void dispose() {
    for (final signal in _cache.values) {
      signal.dispose();
    }
  }

  /// Clear the cache
  void clear() {
    _cache.clear();
  }
}

/// Create a signal container used to instance signals based on args
///
/// ```dart
/// final container = signalContainer<Cache, String>((e) {
///   return signal(Cache(e));
/// });
///
/// final cacheA = container('cache-a');
/// final cacheB = container('cache-b');
/// final cacheC = container('cache-c');
/// ```
SignalContainer<T, Arg> signalContainer<T, Arg>(
  ReadonlySignal<T> Function(Arg) create, {
  bool cache = false,
}) {
  return SignalContainer<T, Arg>(
    create,
    cache: cache,
  );
}

[mafreud]

@rodydavis Perfect! Thank you so much.