brick

Uma maneira intuitiva de trabalhar com dados persistentes no DART.

Documentação completa

• GraphQL
• DESCANSAR
• Supabase

Por que tijolo?

• Acesso off-line fora da caixa
• Lidar e ocultar a lógica complexa de serialização/deserialização
• Ponto de acesso único e DSL opinativo
• Migrações automáticas e geradas inteligentemente
• Interface de consulta legível

O que é tijolo?

O tijolo é uma interface de consulta extensível para aplicativos DART. É uma solução tudo em um responsável por representar dados comerciais no aplicativo, independentemente de onde seus dados vêm. Usando tijolos, os desenvolvedores podem se concentrar na implementação do aplicativo, sem se preocupar com onde os dados vive. Brick foi inspirado pela necessidade de os aplicativos funcionarem primeiro offline, mesmo que uma API represente sua fonte de verdade.

Início rápido

1. Adicione os pacotes:

    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. Configure sua estrutura de diretório de aplicativos para combinar com as expectativas de Brick:

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

3. Adicione modelos que contêm a lógica do seu aplicativo. Os modelos devem ser salvos com o sufixo .model.dart (ou seja, lib/brick/models/person.model.dart ).

4. Run dart run build_runner build para gerar seus modelos e, às vezes, migrações. Remunos depois de cada novo modelo alterar ou dart run build_runner watch as gerações automáticas. Você precisará executar isso novamente após sua primeira migração.

5. Estender um repositório existente ou criar o seu próprio (supabase tem algumas exceções):

    // 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. Lucro.

Uso

Crie um modelo como a lógica de negócios do aplicativo:

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

E gerar (des) serializar o código para buscar e para vários fornecedores:

$ (flutter) pub run build_runner build

Buscar dados

Um repositório busca e retorna dados em vários fornecedores. É o ponto de acesso único para dados em seu aplicativo:

 class MyRepository extends OfflineFirstWithRestRepository {
  MyRepository ();
}

final repository = MyRepository ();

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

Nos bastidores, esse repositório poderia pesquisar um cache de memória, depois sqlite, depois uma API REST. O repositório determina de forma inteligente como e quando usar cada um dos provedores para retornar os dados mais rápidos e confiáveis.

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

As consultas também podem receber atualizações reativas . O fluxo inscrito recebe todos os modelos de sua consulta sempre que a cópia local é atualizada (por exemplo, quando os dados são hidratados em outra parte do aplicativo):

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

Dados de mutações

Depois que um modelo é criado, ele é enviado ao repositório e de volta a cada provedor:

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

Associando dados

Os repositórios podem apoiar associações e serialização automática (DE) de modelos infantis.

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

Brick serializa nativamente primitivas, associações e muito mais.

Se ainda estiver sombrio, confira vídeos, tutoriais e exemplos que quebram tijolos.