Retrieves an item from the specified collection, if available.
If the key is not known at all, the callback should be invoked with undefined. Otherwise, it should be invoked with a SerializedItemDescriptor as follows:
If the version number and deletion state can be determined without fully deserializing the item, then the store should set those properties in the SerializedItemDescriptor (and can set SerializedItemDescriptor#serializedItem to undefined for deleted items).
Otherwise, it should simply set SerializedItemDescriptor#serializedItem to the exact string that was persisted, and can leave the other properties as zero/false. See comments on PersistentDataStore for more about this.
specifies which collection to use
the unique key of the item within that collection
a callback which will be invoked on completion of the get
Retrieves all items from the specified collection.
If the store contains placeholders for deleted items, it should include them in the results, not filter them out. See #get for how to set the properties of the SerializedItemDescriptor for each item.
specifies which collection to use
method that will be invoked with the results of the operation.
Overwrites the store's contents with a set of items for each collection.
All previous data should be discarded, regardless of versioning.
The update should be done atomically. If it cannot be done atomically, then the store must first add or update each item in the same order that they are given in the input data, and then delete any previously stored items that were not in the input data.
a list of PersistentStoreDataKind instances and their corresponding data sets
Tests whether the store is initialized.
"Initialized" means that the store has been populated with data, either by the client having called #init within this process, or by another process (if this is a shared database).
Will be called back with the boolean result.
Updates or inserts an item in the specified collection.
If the given key already exists in that collection, the store must check the version number of the existing item (even if it is a deleted item placeholder); if that version is greater than or equal to the version of the new item, the update fails and the method returns false. If the store is not able to determine the version number of an existing item without fully deserializing the existing item, then it is allowed to call PersistentStoreDataKind#deserialize for that purpose.
If the item's SerializedItemDescriptor#deleted method returns true, this is a deleted item placeholder. The store must persist this, rather than simply removing the key from the store. The SDK will provide a string in SerializedItemDescriptor#serializedItem which the store can persist for this purpose; or, if the store is capable of persisting the version number and deleted state without storing anything else, it should do so.
specifies which collection to use
the unique key for the item within that collection
the item to insert or update
will be called with true if the item was inserted, or false if the version
was not newer than the existing item.
Optional err: ErrorOptional Optional updatedDescriptor: SerializedItemDescriptorOptional Generated using TypeDoc
This interface should be used for database integrations, or any other data store implementation that stores data in some external service. The SDK will take care of converting between its own internal data model and a serialized string form; the data store interacts only with the serialized form. The SDK will also provide its own caching layer on top of the persistent data store; the data store implementation should not provide caching, but simply do every query or update that the SDK tells it to do.
Conceptually, each item in the store is a SerializedItemDescriptor which always has a version number, and can represent either a serialized object or a placeholder (tombstone) for a deleted item. There are two approaches a persistent store implementation can use for persisting this data:
Preferably, it should store the version number and the SerializedItemDescriptor#deleted state separately so that the object does not need to be fully deserialized to read them. In this case, deleted item placeholders can ignore the value of SerializedItemDescriptor#item on writes and can set it to undefined on reads. The store should never call DataKind#deserialize.
If that isn't possible, then the store should simply persist the exact string from SerializedItemDescriptor#serializedItem on writes, and return the persisted string on reads (returning zero for the version and false for SerializedItemDescriptor#deleted). The string is guaranteed to provide the SDK with enough information to infer the version and the deleted state. On updates, the store must call PersistentStoreDataKind#deserialize in order to inspect the version number of the existing item if any.