brick

Une façon intuitive de travailler avec des données persistantes dans DART.

Documentation complète

• Graphique
• REPOS
• Supabase

Pourquoi brique?

• Accès hors ligne à l'emploi aux données
• Manipuler et masquer la logique complexe de sérialisation / désérialisation
• Point d'accès unique et DSL d'opinion
• Migrations automatiques et intelligemment générées
• Interface de requête lisible

Qu'est-ce que la brique?

La brique est une interface de requête extensible pour les applications DART. Il s'agit d'une solution tout-en-un chargée de représenter les données commerciales dans l'application, peu importe d'où proviennent vos données. À l'aide de brique, les développeurs peuvent se concentrer sur la mise en œuvre de l'application, sans souci de savoir où vit les données. Brick a été inspiré par la nécessité que les applications travaillent d'abord hors ligne, même si une API représente votre source de vérité.

Démarrage rapide

1. Ajouter les packages:

    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 :

2. Configurez la structure de votre répertoire d'applications pour correspondre aux attentes de Brick:

   mkdir -p lib/brick/adapters lib/brick/db ;

3. Ajoutez des modèles qui contiennent la logique de votre application. Les modèles doivent être enregistrés avec le suffixe .model.dart (c'est-à-dire lib/brick/models/person.model.dart ).

4. Exécutez dart run build_runner build pour générer vos modèles et parfois des migrations. Rediger une rediffusion après chaque nouveau modèle de modèle ou dart run build_runner watch pour les générations automatiques. Vous devrez l'exécuter à nouveau après votre première migration.

5. Étendre un référentiel existant ou créer le vôtre (Supabase a quelques exceptions):

    // 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,
             ),
           );
   }

6. Profit.

Usage

Créez un modèle comme logique métier de l'application:

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

Et générer du code de sérialisation (DE) pour récupérer vers et depuis plusieurs fournisseurs:

$ (flutter) pub run build_runner build

Recherche de données

Un référentiel récupère et renvoie des données sur plusieurs fournisseurs. C'est le point d'accès unique pour les données de votre application:

 class MyRepository extends OfflineFirstWithRestRepository {
  MyRepository ();
}

final repository = MyRepository ();

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

Dans les coulisses, ce référentiel pourrait interroger un cache de mémoire, puis SQLite, puis une API REST. Le référentiel détermine intelligemment comment et quand utiliser chacun des fournisseurs pour renvoyer les données les plus rapides et les plus fiables.

 // 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);

Les requêtes peuvent également recevoir des mises à jour réactives . Le flux souscrit reçoit tous les modèles de sa requête chaque fois que la copie locale est mise à jour (par exemple lorsque les données sont hydratées dans une autre partie de l'application):

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

Mutation de données

Une fois qu'un modèle a été créé, il est envoyé au référentiel et recule à chaque fournisseur:

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

Association de données

Les référentiels peuvent soutenir les associations et la sérialisation automatique (DE) des modèles enfants.

 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);

La brique sérialise nativement les primitives, les associations et plus encore.

S'il est toujours trouble, consultez Apprenez pour les vidéos, les tutoriels et les exemples qui décomposent la brique.