brick Download - brick Source Code Download

brick

Anderer Quellcode

1.0.0

Herunterladen

Eine intuitive Möglichkeit, mit anhaltenden Daten in Dart zu arbeiten.

Vollständige Dokumentation

Graphql
AUSRUHEN
Supabase

Warum Ziegel?

Off-the-Box-Offline-Zugriff auf Daten
Behandeln und ausblenden komplexe Serialisierungs-/Deserialisierungslogik
Einzelner Zugriffspunkt und machtender DSL
Automatische, intelligent generierte Migrationen
Lesbare Abfrageschnittstelle

Was ist Ziegel?

Brick ist eine erweiterbare Abfrageschnittstelle für DART -Anwendungen. Es handelt sich um eine All-in-One-Lösung, die für die Darstellung von Geschäftsdaten in der Anwendung verantwortlich ist, unabhängig davon, woher Ihre Daten stammen. Mit Brick können sich Entwickler auf die Implementierung der Anwendung konzentrieren, ohne dass die Daten leben. Brick wurde von der Notwendigkeit inspiriert, zuerst offline zu arbeiten, auch wenn eine API Ihre Quelle der Wahrheit darstellt.

Schneller Start

Fügen Sie die Pakete hinzu:

 dependencies :
  # Or brick_offline_first_with_graphql
  # Or brick_offline_first_with_supabase
  brick_offline_first_with_rest :
  sqflite : # optional
dev_dependencies :
  # Or brick_offline_first_with_graphql_build: any
  # Or brick_offline_first_with_supabase_build: any
  brick_offline_first_with_rest_build :
  build_runner :

Konfigurieren Sie Ihre App -Verzeichnisstruktur so, dass sie die Erwartungen von Brick entspricht:
```
mkdir -p lib/brick/adapters lib/brick/db ;
```
Fügen Sie Modelle hinzu, die Ihre App -Logik enthalten. Modelle müssen mit dem .model.dart -Suffix (dh lib/brick/models/person.model.dart ) gespeichert werden.
Führen Sie dart run build_runner build aus, um Ihre Modelle und manchmal Migrationen zu generieren. Nach jeder neuen Modelländerung oder dart run build_runner watch nach automatischen Generationen. Sie müssen dies nach Ihrer ersten Migration erneut ausführen.

Erweitern Sie ein vorhandenes Repository oder erstellen Sie Ihre eigenen (Supabase hat einige Ausnahmen):

 // lib/brick/repository.dart
import 'package:brick_offline_first_with_rest/brick_offline_first_with_rest.dart' ;
import 'package:brick_rest/brick_rest.dart' ;
import 'package:brick_sqlite/brick_sqlite.dart' ;
import 'package:my_app/brick/brick.g.dart' ;
import 'package:sqflite/sqflite.dart' show databaseFactory;
import 'package:my_app/brick/db/schema.g.dart' ;
export 'package:brick_core/query.dart' show And, Or, Query, QueryAction, Where, WherePhrase;

class Repository extends OfflineFirstWithRestRepository {
  Repository ()
      : super (
          migrations : migrations,
          restProvider : RestProvider (
            'http://0.0.0.0:3000' ,
            modelDictionary : restModelDictionary,
          ),
          sqliteProvider : SqliteProvider (
            _DB_NAME ,
            databaseFactory : databaseFactory,
            modelDictionary : sqliteModelDictionary,
          ),
          offlineQueueManager : RestRequestSqliteCacheManager (
            'brick_offline_queue.sqlite' ,
            databaseFactory : databaseFactory,
          ),
        );
}

Profitieren.

Verwendung

Erstellen Sie ein Modell als Geschäftslogik der App:

 // brick/models/user.dart
@ConnectOfflineFirstWithRest ()
class User extends OfflineFirstWithRestModel {}

Und generieren (DE) Serialisierungscode zum Abholen von und von mehreren Anbietern:

$ (flutter) pub run build_runner build

Daten abrufen

Ein Repository holt und gibt Daten über mehrere Anbieter zurück. Dies ist der einzelnen Zugriffspunkt für Daten in Ihrer App:

 class MyRepository extends OfflineFirstWithRestRepository {
  MyRepository ();
}

final repository = MyRepository ();

// Now the models can be queried:
final users = await repository. get < User >();

Hinter den Kulissen könnte dieses Repository einen Speichercache, dann einen SQLite, dann eine REST -API befragen. Das Repository bestimmt intelligent, wie und wann jeder der Anbieter verwendet werden soll, um die schnellsten und zuverlässigsten Daten zurückzugeben.

 // Queries can be general:
final query = Query (where : [ Where ( 'lastName' ). contains ( 'Muster' )]);
final users = await repository. get < User >(query : query);

// Or singular:
final query = Query . where ( 'email' , '[email protected]' , limit1 : true );
final user = await repository. get < User >(query : query);

Abfragen können auch reaktive Updates empfangen. Der abonnierte Stream empfängt alle Modelle aus seiner Abfrage, wenn die lokale Kopie aktualisiert wird (z. B. wenn die Daten in einem anderen Teil der App hydratisiert sind):

 final users = repository. subscribe < User >(). listen ((users) {})

Daten mutieren

Sobald ein Modell erstellt wurde, wird es an das Repository und wieder an jeden Anbieter gesendet:

 final user = User ();
await repository. upsert < User >(user);

Assoziieren von Daten

Repositorys können Assoziationen und automatische (DE) -Serialisierung von Kindermodellen unterstützen.

 class Hat extends OfflineFirstWithRestModel {
  final String color;
  Hat ({ this .color});
}
class User extends OfflineFirstWithRestModel {
  // user has many hats
  final List < Hat > hats;
}

final query = Query . where ( 'hats' , Where ( 'color' ). isExactly ( 'brown' ));
final usersWithBrownHats = repository. get < User >(query : query);