PVCache constructor

PVCache({
  1. required String env,
  2. required List<PVCacheHook> hooks,
  3. required Map<String, dynamic> defaultMetadata,
  4. StorageType entryStorageType = StorageType.stdSembast,
  5. StorageType metadataStorageType = StorageType.stdSembast,
  6. bool noMetadataStoreIfEmpty = false,
  7. String metadataNameFunction(
    1. String
    )?,
  8. Map<Pattern, Future Function(String key)> macroGetHandlers = const {},
  9. Map<String, dynamic> macroGetDefaultMetadata = const {},
  10. bool heavy = false,
})

Create a new cache instance.

Hooks are sorted by EventFlow stage and priority automatically.

Example:

final cache = PVCache(
  env: 'prod',
  hooks: [createTTLHook(), createLRUHook(maxEntries: 100)],
  defaultMetadata: {},
);

Example with macro get:

final cache = PVCache(
  env: 'prod',
  hooks: [createTTLHook()],
  defaultMetadata: {},
  macroGetHandlers: {
    RegExp(r'^user:\d+$'): (key) async => await api.fetchUser(key),
  },
  macroGetDefaultMetadata: {'ttl': 3600},
);

Implementation

PVCache({
  required this.env,
  required List<PVCacheHook> hooks,
  required this.defaultMetadata,
  this.entryStorageType = StorageType.stdSembast,
  this.metadataStorageType = StorageType.stdSembast,
  this.noMetadataStoreIfEmpty = false,
  String Function(String)? metadataNameFunction,
  this.macroGetHandlers = const {},
  this.macroGetDefaultMetadata = const {},
  this.heavy = false,
}) : metadataNameFunction =
         metadataNameFunction ?? ((env) => '${env}_metadata') {
  PVCache.instances[env] = this;

  _hooks = hooks;
  _orderedPutHooks =
      _hooks
          .where((hook) => hook.actionTypes.contains(ActionType.put))
          .toList()
        ..sort((a, b) {
          final flowComparison = a.eventFlow.index.compareTo(
            b.eventFlow.index,
          );
          if (flowComparison != 0) return flowComparison;
          return a.priority.compareTo(b.priority);
        });

  _orderedGetHooks =
      _hooks
          .where((hook) => hook.actionTypes.contains(ActionType.get))
          .toList()
        ..sort((a, b) {
          final flowComparison = a.eventFlow.index.compareTo(
            b.eventFlow.index,
          );
          if (flowComparison != 0) return flowComparison;
          return a.priority.compareTo(b.priority);
        });

  _orderedDeleteHooks =
      _hooks
          .where((hook) => hook.actionTypes.contains(ActionType.delete))
          .toList()
        ..sort((a, b) {
          final flowComparison = a.eventFlow.index.compareTo(
            b.eventFlow.index,
          );
          if (flowComparison != 0) return flowComparison;
          return a.priority.compareTo(b.priority);
        });

  _orderedClearHooks =
      _hooks
          .where((hook) => hook.actionTypes.contains(ActionType.clear))
          .toList()
        ..sort((a, b) {
          final flowComparison = a.eventFlow.index.compareTo(
            b.eventFlow.index,
          );
          if (flowComparison != 0) return flowComparison;
          return a.priority.compareTo(b.priority);
        });

  _orderedExistsHooks =
      _hooks
          .where((hook) => hook.actionTypes.contains(ActionType.exists))
          .toList()
        ..sort((a, b) {
          final flowComparison = a.eventFlow.index.compareTo(
            b.eventFlow.index,
          );
          if (flowComparison != 0) return flowComparison;
          return a.priority.compareTo(b.priority);
        });
}