brick

Una forma intuitiva de trabajar con datos persistentes en DART.

Documentación completa

• Gráfico
• DESCANSAR
• Supabase

¿Por qué ladrillo?

• Acceso a datos fuera de línea listos para usar
• Manejar y ocultar la lógica compleja de serialización/deserialización
• Punto de acceso único y DSL en obstáculos
• Migraciones automáticas e generadas inteligentemente
• Interfaz de consulta legible

¿Qué es el ladrillo?

El ladrillo es una interfaz de consulta extensible para aplicaciones DART. Es una solución todo en uno responsable de representar los datos comerciales en la aplicación, independientemente de dónde provengan sus datos. Usando Brick, los desarrolladores pueden centrarse en implementar la aplicación, sin preocuparse por dónde viven los datos. Brick se inspiró en la necesidad de que las aplicaciones trabajen fuera de línea primero, incluso si una API representa su fuente de verdad.

Comienzo rápido

1. Agregue los paquetes:

    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 la estructura de su directorio de aplicaciones para que coincida con las expectativas de Brick:

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

3. Agregue modelos que contengan la lógica de su aplicación. Los modelos deben guardar con el sufijo .model.dart (es decir, lib/brick/models/person.model.dart ).

4. Ejecutar dart run build_runner build para generar sus modelos y, a veces, migraciones. Vuelva a ejecutar después de cada nuevo cambio de modelo o dart run build_runner watch para generaciones automáticas. Tendrá que ejecutar esto nuevamente después de su primera migración.

5. Extienda un repositorio existente o cree el suyo (Supabase tiene algunas excepciones):

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

Uso

Cree un modelo como la lógica comercial de la aplicación:

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

Y generar (DE) código de serialización para obtener a y desde múltiples proveedores:

$ (flutter) pub run build_runner build

Obtener datos

Un repositorio obtiene y devuelve datos en múltiples proveedores. Es el punto de acceso único para los datos en su aplicación:

 class MyRepository extends OfflineFirstWithRestRepository {
  MyRepository ();
}

final repository = MyRepository ();

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

Detrás de escena, este repositorio podría encuestar un caché de memoria, luego SQLite, luego una API REST. El repositorio determina de manera inteligente cómo y cuándo usar cada uno de los proveedores para devolver los datos más rápidos y confiables.

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

Las consultas también pueden recibir actualizaciones reactivas . El flujo suscrito recibe todos los modelos de su consulta cada vez que se actualiza la copia local (por ejemplo, cuando los datos se hidratan en otra parte de la aplicación):

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

Muting de datos

Una vez que se ha creado un modelo, se envía al repositorio y retrocede a cada proveedor:

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

Asociación de datos

Los repositorios pueden apoyar las asociaciones y la serialización automática (DE) de los modelos infantiles.

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

El ladrillo de forma nativa serializa primitivas, asociaciones y más.

Si todavía es turbio, consulte Learn para videos, tutoriales y ejemplos que descompongan el ladrillo.