initialize static method

Implementation

static Future<DatumEither<Object, Datum>> initialize({
  required DatumConfig config,
  required DatumConnectivityChecker connectivityChecker,
  DatumPersistence? persistence,
  DatumLogger? logger,
  List<DatumRegistration> registrations = const [],
  List<GlobalDatumObserver> observers = const [],
}) async {
  try {
    if (_instance != null) {
      return Success(_instance!);
    }

    // Default to in-memory persistence if none provided
    final DatumPersistence effectivePersistence = persistence ?? InMemoryDatumPersistence();

    if (!config.enableLogging) {
      final datum = await _initializeSilently(config, connectivityChecker, effectivePersistence, logger, registrations, observers);
      return Success(datum);
    }

    final initLogger = logger ?? DatumLogger(enabled: config.enableLogging);
    final logBuffer = StringBuffer();

    final datum = Datum._(
      config: config,
      connectivityChecker: connectivityChecker,
      persistence: effectivePersistence,
      logger: logger,
    );
    datum.globalObservers.addAll(observers);

    datum._logInitializationHeader(logBuffer, config: config, connectivityChecker: connectivityChecker);
    datum._logObservers(logBuffer);
    if (registrations.isNotEmpty) {
      logBuffer.writeln('├─ 📦 Registering Entities');
    }
    for (final reg in registrations) {
      reg.capture(
        <TT extends DatumEntityInterface>() => datum._register<TT>(reg as DatumRegistration<TT>, logBuffer),
      );
    }
    await datum._initializeManagers(logBuffer);
    await datum._logPendingOperationsSummary(logBuffer);

    logBuffer.write('└─ ✅ Datum Initialization Complete.');
    initLogger.info(logBuffer.toString());

    datum._listenToEventsForMetrics();
    _instance = datum;
    return Success(datum);
  } catch (e, s) {
    if (e is Exception) {
      return Failure(e, s);
    }
    return Failure(e, s);
  }
}