boot method

Future<void> boot()

Boots the application by initializing core services and providers.

Sets up:

• Default Router
• TemplateEngine with views and public paths
• StaticFilesServer
• Uuid generator
• SQLite Database in lib/src/storage/database.sqlite

Then boots all registered providers and triggers onBooted callbacks.

Sets status to AppStatus.ready on success, or AppStatus.error on failure.

Implementation

Future<void> boot() async {
  status = AppStatus.booting;

  // Default Router
  // container.singleton<Router>(factory: (_,[_]) => Router(), eager: true);
  final router = Router();
  container.bindInstance<Router>(router);

  // Default View Engine
  // final settings = {"viewsPath": 'lib/src/http/views', "publicPath": 'lib/src/http/public'};
  // container.singleton<TemplateEngine>(factory: (_,[_]) => TemplateEngine(viewsDirectory: settings['viewsPath']!, publicDirectory: settings['publicPath']!), eager: true);

  final settings = {
    "viewsPath": 'lib/src/http/views',
    "publicPath": 'lib/src/http/public',
  };

  final engine = TemplateEngine(
    viewsDirectory: settings['viewsPath']!,
    publicDirectory: settings['publicPath']!,
  );

  // Todo -move to config level
  // engine.shouldCache = true;

  container.bindInstance<TemplateEngine>(engine);

  // Default Static Files Server
  //container.singleton<StaticFilesServer>(factory: (_,[_]) => StaticFilesServer(root: Directory("")), eager: true);

  final staticFilesServer = StaticFilesServer();
  container.bindInstance<StaticFilesServer>(staticFilesServer);

  // Default UUID Generator
  final Uuid uuid = Uuid();

  container.bindInstance<Uuid>(uuid);
  // container.singleton<Uuid>(factory: (_,[_]) => Uuid(), eager: true);

  // Default SQLite DB
  final Directory dir = Directory("lib/src/storage");
  final file = File("${dir.absolute.path}/database.sqlite");
  final Database database = await databaseFactoryFfi.openDatabase(
    file.absolute.path,
    options: OpenDatabaseOptions(
      version: 1,
      onCreate: (db, version) async {
        // Placeholder for database migrations
      },
    ),
  );

  container.singleton<Database>(factory: (_, [_]) => database, eager: true);

  await container.initialize();

  try {
    // Boot all registered providers
    for (final provider in _providers) {
      try {
        await provider.boot(container);
      } catch (e, stack) {
        throw ProviderException.unbooted(
          type: provider.runtimeType,
          trace: stack,
        );
      }
    }

    // Execute post-boot callbacks
    for (final callback in _bootedCallbacks) {
      callback();
    }

    status = AppStatus.ready;
  } catch (e, stack) {
    status = AppStatus.error;
    print('[App Boot Error] $e\n$stack');
    rethrow; // Optional: allow external handling
  }
}