Buscar pacotes, repositórios e categorias de apps

Capa de brick_offline_first
Detalhes do pacotev4.0.2

brick_offline_first

Um domínio Brick que roteia a busca de dados por provedores locais antes dos provedores remotos.

AndroidiOSmacOSWindowsLinux
Downloads em 30 dias
2,5 mil
Curtidas
117
Pontos Pub
150

Instalar pacote

flutter pub add brick_offline_first

Visão geral do pacote

Orientação gerada a partir de informações públicas. Apenas para referência.

Brick Offline First é um pacote Flutter/Dart que prioriza fontes de dados locais para busca de dados, garantindo funcionalidade offline sem interrupções. Ele roteia as requisições por provedores locais antes de tentar as remotas, melhorando a responsividade e confiabilidade do aplicativo. Ideal para aplicações que exigem experiência consistente do usuário independentemente da disponibilidade da rede, integra-se a bancos de dados NoSQL persistentes para gerenciar sincronização de dados de forma eficiente. O pacote suporta múltiplas plataformas, incluindo Android, iOS, macOS, Windows e Linux, tornando-o versátil para desenvolvimento multiplataforma.

Casos de uso

  • Aplicativos móveis com foco em offline
  • Sincronização de dados entre dispositivos
  • acesso de dados de alta confiabilidade
  • Aplicações web progressivas
  • Ferramentas de colaboração em tempo real

Principais recursos

  • Roteamento de dados primeiro local
  • Falha automática para dados locais
  • Suporte multiplataforma
  • Sincronização eficiente com fontes remotas
  • Integração com persistência NoSQL

Indicado para

  • Aplicativos que precisam de capacidade offline
  • Desenvolvedores priorizando a resiliência de dados
  • Projetos usando armazenamento persistente
  • Equipes construindo recursos em tempo real
  • Aplicações com conectividade intermitente

Considerações

  • Requer configuração de provedores locais de dados
  • Pode ser necessário lógica personalizada de sincronização
  • Curva de aprendizado para novos usuários
  • Dependente da implementação subjacente do NoSQL
  • Complexidade potencial na resolução de conflitos

README original

Snapshot do README original do repositório-fonte vinculado. Consulte o repositório para o conteúdo mais recente.

An intuitive way to work with persistent data

An intuitive way to work with persistent data in Dart.

Full documentation

Why Brick?

What is Brick?

Brick is an extensible query interface for Dart applications. It's an all-in-one solution responsible for representing business data in the application, regardless of where your data comes from. Using Brick, developers can focus on implementing the application, without concern for where the data lives. Brick was inspired by the need for applications to work offline first, even if an API represents your source of truth.

Quick Start

  1. Add the 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. Configure your app directory structure to match Brick's expectations:

    mkdir -p lib/brick/adapters lib/brick/db;
    
  3. Add models that contain your app logic. Models must be saved with the .model.dart suffix (i.e. lib/brick/models/person.model.dart).

  4. Run dart run build_runner build to generate your models and sometimes migrations. Rerun after every new model change or dart run build_runner watch for automatic generations. You'll need to run this again after your first migration.

  5. Extend an existing repository or create your own (Supabase has some 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

Create a model as the app's business logic:

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

And generate (de)serializing code to fetch to and from multiple providers:

$ (flutter) pub run build_runner build
Fetching Data

A repository fetches and returns data across multiple providers. It's the single access point for data in your app:

class MyRepository extends OfflineFirstWithRestRepository {
  MyRepository();
}

final repository = MyRepository();

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

Behind the scenes, this repository could poll a memory cache, then SQLite, then a REST API. The repository intelligently determines how and when to use each of the providers to return the fastest, most reliable data.

// 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', 'user@example.com', limit1: true);
final user = await repository.get<User>(query: query);

Queries can also receive reactive updates. The subscribed stream receives all models from its query whenever the local copy is updated (e.g. when the data is hydrated in another part of the app):

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

Once a model has been created, it's sent to the repository and back out to each provider:

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

Repositories can support associations and automatic (de)serialization of child models.

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 natively serializes primitives, associations, and more.

If it's still murky, check out Learn for videos, tutorials, and examples that break down Brick.

Categorias

Dependências

Lista de dependências 9 itens

Repositório-fonte

Projetos que usam este pacote

Ainda não há dados.