isar_local_database.dart

Go to the documentation of this file.

import 'package:isar/isar.dart';
import 'package:path_provider/path_provider.dart';
 
class IsarLocalDatabase {
  static IsarLocalDatabase? _instance;
  static Isar? _isar;
  
  IsarLocalDatabase._();
  
  static IsarLocalDatabase get instance {
    _instance ??= IsarLocalDatabase._();
    return _instance!;
  }
  
  Future<void> initialize(List<CollectionSchema<dynamic>> schemas) async {
    if (_isar != null) return;
    
    final dir = await getApplicationDocumentsDirectory();
    _isar = await Isar.open(
      schemas,
      directory: dir.path,
    );
  }
  
  Isar get isar {
    if (_isar == null) {
      throw Exception('Isar not initialized. Call initialize() first.');
    }
    return _isar!;
  }
  
  IsarCollection<T> collection<T>() {
    return isar.collection<T>();
  }
  
  Future<Id> put<T>(T object) async {
    late Id id;
    await isar.writeTxn(() async {
      id = await collection<T>().put(object);
    });
    return id;
  }
  
  Future<List<Id>> putAll<T>(List<T> objects) async {
    late List<Id> ids;
    await isar.writeTxn(() async {
      ids = await collection<T>().putAll(objects);
    });
    return ids;
  }
  
  Future<T?> get<T>(Id id) async {
    return await collection<T>().get(id);
  }
 
  Future<List<T>> getAll<T>() async {
    return await collection<T>().where().findAll();
  }
  
  Future<bool> delete<T>(Id id) async {
    late bool success;
    await isar.writeTxn(() async {
      success = await collection<T>().delete(id);
    });
    return success;
  }
  
  Future<int> deleteAll<T>(List<Id> ids) async {
    late int count;
    await isar.writeTxn(() async {
      count = await collection<T>().deleteAll(ids);
    });
    return count;
  }
  
  Future<int> count<T>() async {
    return await collection<T>().count();
  }
  
  Future<void> clear<T>() async {
    await isar.writeTxn(() async {
      await collection<T>().clear();
    });
  }
  
  Stream<void> watch<T>({bool fireImmediately = false}) {
    return collection<T>().watchLazy(fireImmediately: fireImmediately);
  }
  
  Future<void> close() async {
    await _isar?.close();
    _isar = null;
    _instance = null;
  }
}