tinybase 9.5.0 → 9.6.0-beta.1

package/@types/persisters/persister-capacitor-sqlite/with-schemas/index.d.ts

@@ -0,0 +1,205 @@
+/**
+ * The persister-capacitor-sqlite module of the TinyBase project lets you save
+ * and load Store data to and from a SQLite database in a Capacitor app, via the
+ * `@capacitor-community/sqlite` plugin.
+ * @see Database Persistence guide
+ * @packageDocumentation
+ * @module persister-capacitor-sqlite
+ * @since 9.6.0
+ */
+import type {SQLiteDBConnection} from '@capacitor-community/sqlite';
+import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.ts';
+import type {
+  OptionalSchemas,
+  Store,
+} from '../../../store/with-schemas/index.d.ts';
+import type {
+  DatabasePersisterConfig,
+  DpcJson,
+  Persister,
+  Persists,
+} from '../../with-schemas/index.d.ts';
+
+/**
+ * The CapacitorSqlitePersister interface represents a Persister that lets you
+ * save and load Store data to and from a SQLite database in a Capacitor app.
+ *
+ * You should use the createCapacitorSqlitePersister function to create a
+ * CapacitorSqlitePersister object.
+ *
+ * It is a minor extension to the Persister interface and simply provides an
+ * extra getDb method for accessing a reference to the database connection the
+ * Store is being persisted to.
+ * @category Persister
+ * @since 9.6.0
+ */
+export interface CapacitorSqlitePersister<
+  Schemas extends OptionalSchemas,
+> extends Persister<Schemas, Persists.StoreOrMergeableStore> {
+  /**
+   * The getDb method returns a reference to the database connection the Store
+   * is being persisted to.
+   * @returns A reference to the database connection.
+   * @example
+   * This example creates a Persister object against a newly-created Store and
+   * then gets the database connection back out again.
+   *
+   * ```js ignore
+   * import {
+   *   CapacitorSQLite,
+   *   SQLiteConnection,
+   * } from '@capacitor-community/sqlite';
+   * import {createStore} from 'tinybase';
+   * import {createCapacitorSqlitePersister} from 'tinybase/persisters/persister-capacitor-sqlite';
+   *
+   * const sqlite = new SQLiteConnection(CapacitorSQLite);
+   * const db = await sqlite.createConnection(
+   *   'my.db',
+   *   false,
+   *   'no-encryption',
+   *   1,
+   *   false,
+   * );
+   * await db.open();
+   *
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const persister = createCapacitorSqlitePersister(store, db, 'my_tinybase');
+   *
+   * console.log(persister.getDb() == db);
+   * // -> true
+   *
+   * await persister.destroy();
+   * ```
+   * @category Getter
+   * @since 9.6.0
+   */
+  getDb(): SQLiteDBConnection;
+}
+
+/**
+ * The createCapacitorSqlitePersister function creates a
+ * CapacitorSqlitePersister object that can persist a Store to a SQLite database
+ * in a Capacitor app.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createCapacitorSqlitePersister<StoreType extends Store>(
+ *   store: StoreType,
+ *   db: SQLiteDBConnection,
+ *   configOrStoreTableName?:
+ *     | (NoInfer<StoreType> extends MergeableStore
+ *         ? DpcJson
+ *         : DatabasePersisterConfig)
+ *     | string,
+ *   onSqlCommand?: (sql: string, params?: any[]) => void,
+ *   onIgnoredError?: (error: any) => void,
+ * ): CapacitorSqlitePersister;
+ * ```
+ *
+ * A CapacitorSqlitePersister supports regular Store objects, and can also be
+ * used to persist the metadata of a MergeableStore when using the JSON
+ * serialization mode, as described below.
+ *
+ * As well as providing a reference to the Store to persist, you must provide a
+ * `db` parameter which is an open SQLiteDBConnection, as returned from the
+ * plugin's `createConnection` method.
+ *
+ * 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.
+ *
+ * The plugin does not signal when the database changes underneath the
+ * Persister, so if you enable automatic loading with the startAutoLoad method,
+ * it polls the database for changes in the same way that the LibSqlPersister
+ * does.
+ *
+ * Note: TinyBase's tests for this module run against a mocked plugin rather
+ * than a real device, since `@capacitor-community/sqlite` needs a native iOS or
+ * Android runtime (or its `jeep-sqlite` web component) that a Node test suite
+ * cannot provide. The SQL behavior itself is covered by the other SQLite
+ * Persisters, which share all of it, but the binding to the plugin is only
+ * verified against those mocks. Please report anything that behaves differently
+ * on a real device.
+ * @param store The Store or MergeableStore to persist.
+ * @param db The database connection that was returned from
+ * `createConnection(...)`.
+ * @param configOrStoreTableName A DatabasePersisterConfig to configure the
+ * persistence mode (or a string to set the `storeTableName` property of the
+ * JSON serialization).
+ * @param onSqlCommand 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.
+ * @param onIgnoredError 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.
+ * @returns A reference to the new CapacitorSqlitePersister object.
+ * @example
+ * This example creates a CapacitorSqlitePersister object and persists the Store
+ * to a 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.
+ *
+ * ```js ignore
+ * import {
+ *   CapacitorSQLite,
+ *   SQLiteConnection,
+ * } from '@capacitor-community/sqlite';
+ * import {createStore} from 'tinybase';
+ * import {createCapacitorSqlitePersister} from 'tinybase/persisters/persister-capacitor-sqlite';
+ *
+ * const sqlite = new SQLiteConnection(CapacitorSQLite);
+ * const db = await sqlite.createConnection(
+ *   'my.db',
+ *   false,
+ *   'no-encryption',
+ *   1,
+ *   false,
+ * );
+ * await db.open();
+ *
+ * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+ * const persister = createCapacitorSqlitePersister(store, db, 'my_tinybase');
+ *
+ * await persister.save();
+ * // Store will be saved to the database.
+ *
+ * console.log((await db.query('SELECT * FROM my_tinybase;')).values);
+ * // -> [{_id: '_', store: '[{"pets":{"fido":{"species":"dog"}}},{}]'}]
+ *
+ * await db.run(
+ *   'UPDATE my_tinybase SET store = ? WHERE _id = ?;',
+ *   ['[{"pets":{"felix":{"species":"cat"}}},{}]', '_'],
+ *   false,
+ * );
+ * await persister.load();
+ * console.log(store.getTables());
+ * // -> {pets: {felix: {species: 'cat'}}}
+ *
+ * await persister.destroy();
+ * ```
+ * @category Creation
+ * @since 9.6.0
+ */
+export function createCapacitorSqlitePersister<Schemas extends OptionalSchemas>(
+  store: MergeableStore<Schemas>,
+  db: SQLiteDBConnection,
+  configOrStoreTableName?: DpcJson | string,
+  onSqlCommand?: (sql: string, params?: any[]) => void,
+  onIgnoredError?: (error: any) => void,
+): CapacitorSqlitePersister<Schemas>;
+export function createCapacitorSqlitePersister<Schemas extends OptionalSchemas>(
+  store: Store<Schemas> & {getMergeableContent?: never},
+  db: SQLiteDBConnection,
+  configOrStoreTableName?: DatabasePersisterConfig<Schemas> | string,
+  onSqlCommand?: (sql: string, params?: any[]) => void,
+  onIgnoredError?: (error: any) => void,
+): CapacitorSqlitePersister<Schemas>;

package/@types/persisters/persister-indexed-db/index.d.ts

@@ -6,8 +6,9 @@
  * @module persister-indexed-db
  * @since v4.2.0
  */
+import type {MergeableStore} from '../../mergeable-store/index.d.ts';
 import type {Store} from '../../store/index.d.ts';
-import type {Persister} from '../index.d.ts';
+import type {Persister, Persists} from '../index.d.ts';
 
 /**
  * The IndexedDbPersister interface represents a Persister that lets you save
@@ -22,7 +23,7 @@ import type {Persister} from '../index.d.ts';
  * @category Persister
  * @since v4.3.14
  */
-export interface IndexedDbPersister extends Persister {
+export interface IndexedDbPersister extends Persister<Persists.StoreOrMergeableStore> {
   /**
    * The getDbName method returns the unique key of the IndexedDB the Store is
    * being persisted to.
@@ -53,17 +54,24 @@ export interface IndexedDbPersister extends Persister {
  * The createIndexedDbPersister function creates an IndexedDbPersister object
  * that can persist a Store to the browser's IndexedDB storage.
  *
- * An IndexedDbPersister only supports regular Store objects, and cannot be used
- * to persist the metadata of a MergeableStore.
+ * An IndexedDbPersister supports regular Store objects, and, since v9.6, can
+ * also be used to persist the metadata of a MergeableStore.
  *
  * As well as providing a reference to the Store to persist, you must provide a
  * `dbName` parameter which is unique to your application. This is the key used
  * to identify which IndexedDB to use.
  *
- * Within that database, this Persister will create two object stores: one
- * called 't', and one called 'v'. These will contain the Store's tabular and
- * key-value data respectively, using 'k' and 'v' to store the key and value of
- * each entry, as shown in the example.
+ * Within that database, this Persister will create three object stores. A
+ * regular Store uses one called 't' and one called 'v', which contain its
+ * tabular and key-value data respectively, using 'k' and 'v' to store the key
+ * and value of each entry, as shown in the example. A MergeableStore instead
+ * uses one called 'm', which holds its two halves of mergeable content under
+ * the keys 't' and 'v'.
+ *
+ * Since the two live alongside each other, a database written by a regular
+ * Store can be read by another regular Store, and the same for MergeableStore
+ * objects, but the two do not share data. Databases created before v9.6 are
+ * upgraded in place, and their existing content is preserved.
  *
  * Note that it is not possible to reactively detect changes to a browser's
  * IndexedDB. If you do choose to enable automatic loading for the Persister
@@ -113,7 +121,7 @@ export interface IndexedDbPersister extends Persister {
  * @since v4.2.0
  */
 export function createIndexedDbPersister(
-  store: Store,
+  store: Store | MergeableStore,
   dbName: string,
   autoLoadIntervalSeconds?: number,
   onIgnoredError?: (error: any) => void,

package/@types/persisters/persister-indexed-db/with-schemas/index.d.ts

@@ -6,11 +6,12 @@
  * @module persister-indexed-db
  * @since v4.2.0
  */
+import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.ts';
 import type {
   OptionalSchemas,
   Store,
 } from '../../../store/with-schemas/index.d.ts';
-import type {Persister} from '../../with-schemas/index.d.ts';
+import type {Persister, Persists} from '../../with-schemas/index.d.ts';
 
 /**
  * The IndexedDbPersister interface represents a Persister that lets you save
@@ -27,7 +28,7 @@ import type {Persister} from '../../with-schemas/index.d.ts';
  */
 export interface IndexedDbPersister<
   Schemas extends OptionalSchemas,
-> extends Persister<Schemas> {
+> extends Persister<Schemas, Persists.StoreOrMergeableStore> {
   /**
    * The getDbName method returns the unique key of the IndexedDB the Store is
    * being persisted to.
@@ -62,24 +63,31 @@ export interface IndexedDbPersister<
  *
  * ```ts override
  * createIndexedDbPersister(
- *   store: Store,
+ *   store: Store | MergeableStore,
  *   dbName: string,
  *   autoLoadIntervalSeconds?: number,
  *   onIgnoredError?: (error: any) => void,
  * ): IndexedDbPersister;
  * ```
  *
- * An IndexedDbPersister only supports regular Store objects, and cannot be used
- * to persist the metadata of a MergeableStore.
+ * An IndexedDbPersister supports regular Store objects, and, since v9.6, can
+ * also be used to persist the metadata of a MergeableStore.
  *
  * As well as providing a reference to the Store to persist, you must provide a
  * `dbName` parameter which is unique to your application. This is the key used
  * to identify which IndexedDB to use.
  *
- * Within that database, this Persister will create two object stores: one
- * called 't', and one called 'v'. These will contain the Store's tabular and
- * key-value data respectively, using 'k' and 'v' to store the key and value of
- * each entry, as shown in the example.
+ * Within that database, this Persister will create three object stores. A
+ * regular Store uses one called 't' and one called 'v', which contain its
+ * tabular and key-value data respectively, using 'k' and 'v' to store the key
+ * and value of each entry, as shown in the example. A MergeableStore instead
+ * uses one called 'm', which holds its two halves of mergeable content under
+ * the keys 't' and 'v'.
+ *
+ * Since the two live alongside each other, a database written by a regular
+ * Store can be read by another regular Store, and the same for MergeableStore
+ * objects, but the two do not share data. Databases created before v9.6 are
+ * upgraded in place, and their existing content is preserved.
  *
  * Note that it is not possible to reactively detect changes to a browser's
  * IndexedDB. If you do choose to enable automatic loading for the Persister
@@ -129,7 +137,7 @@ export interface IndexedDbPersister<
  * @since v4.2.0
  */
 export function createIndexedDbPersister<Schemas extends OptionalSchemas>(
-  store: Store<Schemas>,
+  store: Store<Schemas> | MergeableStore<Schemas>,
   dbName: string,
   autoLoadIntervalSeconds?: number,
   onIgnoredError?: (error: any) => void,

package/@types/persisters/persister-libsql/index.d.ts

@@ -2,6 +2,10 @@
  * The persister-libsql module of the TinyBase project lets you save and load
  * Store data to and from a local LibSQL database (in an appropriate
  * environment).
+ *
+ * This is also the module to use with hosted services built on LibSQL, such as
+ * Turso and Astro DB. See the createLibSqlPersister function for how to get at
+ * the underlying client in an Astro project.
  * @see Database Persistence guide
  * @packageDocumentation
  * @module persister-libsql
@@ -78,6 +82,29 @@ export interface LibSqlPersister extends Persister {
  * Note: When using tabular mode, SQL NULL values are loaded as TinyBase null
  * values, making tables dense (every Row has every Cell). See the Database
  * Persistence guide for details.
+ *
+ * In an Astro project, the `db` object exported from `astro:db` is a Drizzle
+ * wrapper around a LibSQL client, and its `$client` property is the client this
+ * Persister needs. That property is present at runtime but missing from the
+ * type that Astro exports, so TypeScript needs a cast to reach it:
+ *
+ * ```js ignore
+ * import type {Database} from '@astrojs/db/runtime';
+ * import type {Client} from '@libsql/client';
+ * import {db} from 'astro:db';
+ * import {createStore} from 'tinybase';
+ * import {createLibSqlPersister} from 'tinybase/persisters/persister-libsql';
+ *
+ * const client = (db as Database & {$client: Client}).$client;
+ * const persister = createLibSqlPersister(
+ *   createStore(),
+ *   client,
+ *   'my_tinybase',
+ * );
+ *
+ * await persister.load();
+ * await persister.destroy();
+ * ```
  * @param store The Store to persist.
  * @param client The database client that was returned from `createClient(...)`.
  * @param configOrStoreTableName A DatabasePersisterConfig to configure the

package/@types/persisters/persister-libsql/with-schemas/index.d.ts

@@ -2,6 +2,10 @@
  * The persister-libsql module of the TinyBase project lets you save and load
  * Store data to and from a local LibSQL database (in an appropriate
  * environment).
+ *
+ * This is also the module to use with hosted services built on LibSQL, such as
+ * Turso and Astro DB. See the createLibSqlPersister function for how to get at
+ * the underlying client in an Astro project.
  * @see Database Persistence guide
  * @packageDocumentation
  * @module persister-libsql
@@ -98,6 +102,29 @@ export interface LibSqlPersister<
  * Note: When using tabular mode, SQL NULL values are loaded as TinyBase null
  * values, making tables dense (every Row has every Cell). See the Database
  * Persistence guide for details.
+ *
+ * In an Astro project, the `db` object exported from `astro:db` is a Drizzle
+ * wrapper around a LibSQL client, and its `$client` property is the client this
+ * Persister needs. That property is present at runtime but missing from the
+ * type that Astro exports, so TypeScript needs a cast to reach it:
+ *
+ * ```js ignore
+ * import type {Database} from '@astrojs/db/runtime';
+ * import type {Client} from '@libsql/client';
+ * import {db} from 'astro:db';
+ * import {createStore} from 'tinybase';
+ * import {createLibSqlPersister} from 'tinybase/persisters/persister-libsql';
+ *
+ * const client = (db as Database & {$client: Client}).$client;
+ * const persister = createLibSqlPersister(
+ *   createStore(),
+ *   client,
+ *   'my_tinybase',
+ * );
+ *
+ * await persister.load();
+ * await persister.destroy();
+ * ```
  * @param store The Store to persist.
  * @param client The database client that was returned from `createClient(...)`.
  * @param configOrStoreTableName A DatabasePersisterConfig to configure the

package/@types/persisters/persister-pg/index.d.ts

@@ -0,0 +1,197 @@
+/**
+ * The persister-pg module of the TinyBase project lets you save and load Store
+ * data to and from a PostgreSQL database, via the `pg` module (in an
+ * appropriate environment).
+ *
+ * Since the `pg` module is the de facto standard PostgreSQL driver for Node.js,
+ * this module also works with the many hosted PostgreSQL services that provide
+ * a `pg`-compatible driver, such as Neon.
+ * @see Database Persistence guide
+ * @packageDocumentation
+ * @module persister-pg
+ * @since 9.6.0
+ */
+import type {Client, Pool} from 'pg';
+import type {MergeableStore} from '../../mergeable-store/index.d.ts';
+import type {Store} from '../../store/index.d.ts';
+import type {
+  DatabasePersisterConfig,
+  DpcJson,
+  Persister,
+  Persists,
+} from '../index.d.ts';
+
+/**
+ * The PgPersister interface represents a Persister that lets you save and load
+ * Store data to and from a PostgreSQL database, via the `pg` module.
+ *
+ * You should use the createPgPersister function to create a PgPersister object.
+ *
+ * It is a minor extension to the Persister interface and simply provides an
+ * extra getPg method for accessing a reference to the database connection the
+ * Store is being persisted to.
+ * @category Persister
+ * @since 9.6.0
+ */
+export interface PgPersister extends Persister<Persists.StoreOrMergeableStore> {
+  /**
+   * The getPg method returns a reference to the database connection the Store
+   * is being persisted to.
+   * @returns A reference to the `pg` Pool or Client.
+   * @example
+   * This example creates a Persister object against a newly-created Store and
+   * then gets the database connection back out again.
+   *
+   * ```js
+   * import {Pool} from 'pg';
+   * import {createStore} from 'tinybase';
+   * import {createPgPersister} from 'tinybase/persisters/persister-pg';
+   *
+   * const pool = new Pool({
+   *   connectionString: 'postgres://localhost:5432/tinybase',
+   * });
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const persister = await createPgPersister(store, pool, 'my_tinybase');
+   *
+   * console.log(persister.getPg() == pool);
+   * // -> true
+   *
+   * await persister.destroy();
+   * await pool.end();
+   * ```
+   * @category Getter
+   * @since 9.6.0
+   */
+  getPg(): Pool | Client;
+}
+
+/**
+ * The createPgPersister function creates a PgPersister object that can persist
+ * the Store to a PostgreSQL database via the `pg` module.
+ *
+ * A PgPersister supports regular Store objects, and can also be used to persist
+ * the metadata of a MergeableStore when using the JSON serialization mode, as
+ * described below.
+ *
+ * As well as providing a reference to the Store to persist, you must provide a
+ * `pg` parameter which is either a Pool or a Client. If you provide a Pool, one
+ * connection is checked out for the lifetime of the Persister (and a second
+ * while automatic loading is enabled), since the Persister needs to issue
+ * transactions on a stable connection. Make sure your pool is large enough to
+ * accommodate that.
+ *
+ * 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.
+ *
+ * Note: When using tabular mode, SQL NULL values are loaded as TinyBase null
+ * values, making tables dense (every Row has every Cell). See the Database
+ * Persistence guide for details.
+ *
+ * This method is asynchronous because it will await the creation of a dedicated
+ * new connection to the database. You will need to `await` a call to this
+ * function or handle the return type natively as a Promise.
+ * @param store The Store or MergeableStore to persist.
+ * @param pg The `pg` Pool or Client that identifies the database connection.
+ * @param configOrStoreTableName A DatabasePersisterConfig to configure the
+ * persistence mode (or a string to set the `storeTableName` property of the
+ * JSON serialization).
+ * @param onSqlCommand 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.
+ * @param onIgnoredError 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.
+ * @returns A reference to the new PgPersister object.
+ * @example
+ * This example creates a PgPersister object and persists the Store to a local
+ * PostgreSQL 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.
+ *
+ * ```js
+ * import {Pool} from 'pg';
+ * import {createStore} from 'tinybase';
+ * import {createPgPersister} from 'tinybase/persisters/persister-pg';
+ *
+ * const pool = new Pool({
+ *   connectionString: 'postgres://localhost:5432/tinybase',
+ * });
+ * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+ * const persister = await createPgPersister(store, pool, 'my_tinybase');
+ *
+ * await persister.save();
+ * // Store will be saved to the database.
+ *
+ * console.log((await pool.query('SELECT * FROM my_tinybase;')).rows);
+ * // -> [{_id: '_', store: '[{"pets":{"fido":{"species":"dog"}}},{}]'}]
+ *
+ * const json = '[{"pets":{"felix":{"species":"cat"}}},{}]';
+ * await pool.query('UPDATE my_tinybase SET store = $1 WHERE _id = $2;', [
+ *   json,
+ *   '_',
+ * ]);
+ *
+ * await persister.load();
+ * console.log(store.getTables());
+ * // -> {pets: {felix: {species: 'cat'}}}
+ *
+ * await persister.destroy();
+ * await pool.end();
+ * ```
+ * @example
+ * This example creates a PgPersister object and persists the Store to a local
+ * PostgreSQL database with tabular mapping.
+ *
+ * ```js
+ * import {Pool} from 'pg';
+ * import {createStore} from 'tinybase';
+ * import {createPgPersister} from 'tinybase/persisters/persister-pg';
+ *
+ * const pool = new Pool({
+ *   connectionString: 'postgres://localhost:5432/tinybase',
+ * });
+ * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+ * const persister = await createPgPersister(store, pool, {
+ *   mode: 'tabular',
+ *   tables: {load: {pets: 'pets'}, save: {pets: 'pets'}},
+ * });
+ *
+ * await persister.save();
+ * console.log((await pool.query('SELECT * FROM pets;')).rows);
+ * // -> [{_id: 'fido', species: '"dog"'}]
+ * // Note that Cells and Values are JSON-encoded in PostgreSQL databases.
+ *
+ * await pool.query(
+ *   `INSERT INTO pets (_id, species) VALUES ('felix', '"cat"')`,
+ * );
+ * await persister.load();
+ * console.log(store.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ *
+ * await persister.destroy();
+ * await pool.query('DROP TABLE IF EXISTS pets');
+ * await pool.end();
+ * ```
+ * @category Creation
+ * @since 9.6.0
+ */
+export function createPgPersister<StoreType extends Store>(
+  store: StoreType,
+  pg: Pool | Client,
+  configOrStoreTableName?:
+    | (NoInfer<StoreType> extends MergeableStore
+        ? DpcJson
+        : DatabasePersisterConfig)
+    | string,
+  onSqlCommand?: (sql: string, params?: any[]) => void,
+  onIgnoredError?: (error: any) => void,
+): Promise<PgPersister>;