`createExpoSqlitePersister`

The createExpoSqlitePersister function creates a Persister object that can persist the Store to a local Expo-SQLite database (in an appropriate React Native environment).

createExpoSqlitePersister(
  store: Store,
  db: SQLiteDatabase,
  configOrStoreTableName?: string | DatabasePersisterConfig,
  onSqlCommand?: (sql: string, args?: any[]) => void,
  onIgnoredError?: (error: any) => void,
): ExpoSqlitePersister

	Type	Description
`store`	`Store`	The `Store` to persist.
`db`	`SQLiteDatabase`	The database instance that was returned from `SQLite.openDatabase(...)`.
`configOrStoreTableName?`	`string \| DatabasePersisterConfig`	A `DatabasePersisterConfig` to configure the persistence mode (or a string to set the `storeTableName` property of the JSON serialization).
`onSqlCommand?`	`(sql: string, args?: any[]) => void`	An optional handler called every time the `Persister` executes a SQL command or query. This is suitable for logging persistence behavior in a development environment, since v4.0.4.
`onIgnoredError?`	`(error: any) => void`	An optional handler for the errors that the `Persister` would otherwise ignore when trying to save or load data. This is suitable for debugging persistence issues in a development environment, since v4.0.4.
returns	`ExpoSqlitePersister`	A reference to the new `ExpoSqlitePersister` object.

Note that this Persister is currently experimental as Expo themselves iterate on the underlying database library API.

As well as providing a reference to the Store to persist, you must provide a db parameter which identifies the database instance.

A database Persister uses one of two modes: either a JSON serialization of the whole Store stored in a single row of a table (the default), or a tabular mapping of Table Ids to database table names and vice-versa).

The third argument is a DatabasePersisterConfig object that configures which of those modes to use, and settings for each. If the third argument is simply a string, it is used as the storeTableName property of the JSON serialization.

See the documentation for the DpcJson and DpcTabular types for more information on how both of those modes can be configured.

Examples

This example creates a ExpoSqlitePersister object and persists the Store to a local SQLite database as a JSON serialization into the my_tinybase table. It makes a change to the database directly and then reloads it back into the Store.

const db = SQLite.openDatabase('my.db');
const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
const persister = createExpoSqlitePersister(store, db, 'my_tinybase');

await persister.save();
// Store will be saved to the database.

console.log(
  await new Promise((resolve) =>
    db.all('SELECT * FROM my_tinybase;', (_, rows) => resolve(rows)),
  ),
);
// -> [{_id: '_', store: '[{"pets":{"fido":{"species":"dog"}}},{}]'}]

await new Promise((resolve) =>
  db.all(
    'UPDATE my_tinybase SET store = ' +
      `'[{"pets":{"felix":{"species":"cat"}}},{}]' WHERE _id = '_';`,
    resolve,
  ),
);
await persister.load();
console.log(store.getTables());
// -> {pets: {felix: {species: 'cat'}}}

persister.destroy();

This example creates a ExpoSqlitePersister object and persists the Store to a local SQLite database with tabular mapping.

const db = SQLite.openDatabase('my.db');
const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
const persister = createExpoSqlitePersister(store, db, {
  mode: 'tabular',
  tables: {load: {pets: 'pets'}, save: {pets: 'pets'}},
});

await persister.save();
console.log(
  await new Promise((resolve) =>
    db.all('SELECT * FROM pets;', (_, rows) => resolve(rows)),
  ),
);
// -> [{_id: 'fido', species: 'dog'}]

await new Promise((resolve) =>
  db.all(
    `INSERT INTO pets (_id, species) VALUES ('felix', 'cat')`,
    resolve,
  ),
);
await persister.load();
console.log(store.getTables());
// -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}

persister.destroy();

Since

v4.0.3