The PouchDB adapter to use for local storage. Set by the factory/resolver before calling init(). Default: "indexeddb" (the newer adapter). Use "idb" for the legacy adapter.

Optional accessor for usage analytics (see reportConflict).

Assigned by DatabaseFactoryService rather than injected: the database classes are constructed manually and have no access to Angular DI. It resolves lazily, and only once something is actually tracked, so that bootstrap never closes the cycle AnalyticsService -> ConfigService -> EntityMapperService -> DatabaseResolver -> DatabaseFactoryService.

An observable that emits a value whenever the PouchDB receives a new change. This change can come from the current user or remotely from the (live) synchronization

trigger to unsubscribe any internal subscriptions

A list of promises that resolve once all the (until now saved) indexes are created

The reference to the PouchDB instance

Query a page through PouchDB's local Mango engine (see PouchDatabase.find).

supportsFind stays false on purpose: the local engine has no bookmark cursor, so the opaque bookmark here is the positional offset of the next unseen document. That is enough for a caller which only passes it back unread, but it is not the cursor the remote contract promises, and production code choosing a data source should keep treating this database as one that cannot page.

Initialize the PouchDB with the in-memory adapter. See https://github.com/pouchdb/pouchdb/tree/master/packages/node_modules/pouchdb-adapter-memory

Load all documents (matching the given PouchDB options) from the database. (see Database)

Normally you should rather use "getAll()" or another well typed method of this class instead of passing PouchDB specific options here because that will make your code tightly coupled with PouchDB rather than any other database provider.

Listen to changes to documents in the database. Use rxjs operators to filter for specific prefixes etc. if needed.

observable which emits the filtered changes

Destroy the database and all saved data

Query a page of one entity type's documents with a Mango selector, optionally sorted (see Database.find).

Only available on databases that implement findPage, which differ only in how they fetch one page of results: RemotePouchDatabase uses CouchDB's real Mango bookmark cursor, MemoryPouchDatabase (for tests) the offset of the next document. A synced local database does not support this: PouchDB's local Mango query engine has no bookmark support at all - it always reports "nil" (see pouchdb-find/lib/index.js) - and paging by offset is currently not needed there.

When sorted, documents without a value for the sort property are included as well: last for "asc", first for "desc" (see sortedQueries).

Load a single document by id from the database. (see Database)

Get the actual instance of the PouchDB

Check if a database is new/empty. Returns true if there are no documents in the database

Check if this is a notifications database based on the database name. (may be used for special handling of notification DBs)

Permanently purge a document and all its revisions from the local database.

Unlike remove, which creates a deletion tombstone that is synced, purge completely removes local data without affecting the remote database. This also emits a synthetic deletion event via the changes feed so that in-memory caches (entity stores) drop the purged entity.

Adapter limitation: The underlying PouchDB purge() API is only available on the indexeddb adapter (PouchDB 8+). On unsupported adapters PouchDB will throw its own error, which callers should handle (e.g. via try/catch + logging).

     false if the document did not exist locally (benign — desired state already achieved)

true if the document was purged, false if the document did not exist locally (benign — desired state already achieved)

Save a document to the database. (see Database)

Save an array of documents to the database The save can partially fail and return a mix of success and error states in the array (e.g. [{ ok: true, ... }, { error: true, ... }])

array with the result for each object to be saved, if any item fails to be saved, this returns a rejected Promise. The save can partially fail and return a mix of success and error states in the array (e.g. [{ ok: true, ... }, { error: true, ... }])

Query data from the database based on a more complex, indexed request. (see Database)

This is directly calling the PouchDB implementation of this function. Also see the documentation there: https://pouchdb.com/api.html#query_database

Delete a document from the database (see Database)

Reset the database state so a new one can be opened.

Create a database index to query() certain data more efficiently in the future. (see Database)

Also see the PouchDB documentation regarding indices and queries: https://pouchdb.com/api.html#query_database

Whether to skip updating a design doc that differs from the local version. Overridden in RemotePouchDatabase to prevent older clients from overwriting indexes created by a newer app version on a shared server.

Hook wrapping an idempotent read (get/allDocs/query) so subclasses can transparently retry transient failures.

The base implementation runs the operation exactly once (no retry). RemotePouchDatabase overrides this to re-issue reads that fail with a transient network abort/timeout, which recovers e.g. a connection gone stale after the tab was suspended. Only reads use this hook — writes must run exactly once and are never routed through it, except for creating a query index, which changes nothing when repeated.

Load all documents (with the given prefix) from the database.

Delete all documents of the database matching the given filter.

Note that getAll() also returns the database's own "_design/..." index documents, so a filter that does not exclude them deletes the indices as well. They are only recreated when the app starts up again (see DatabaseIndexingService), so only delete them if the calling code reloads the app or restores the documents immediately afterwards.

   Pass a specialized document type if the filter reads fields other than `_id`.

the number of deleted documents

Whether find (bookmark-based pagination) is supported by this implementation. Callers should fall back to loading all docs otherwise.