(
val properties: List
) : Create()
}
}
```
In the `Create` operations, we have `InsertOne` and `InsertMany`, which accept `Properties` or a list of `Properties` as input. Notice that we use `Nothing` for types we don't have yet, such as the `Key` for new entries.
### Defining `Read` Operations
Let's define a `DataSources` sealed class to represent the different sources of data we may want to query.
```kotlin theme={"system"}
data class DataSources(val memory: Boolean, val disk: Boolean, val remote: Boolean) {
companion object {
val all = DataSources(memory = true, disk = true, remote = true)
val localOnly = DataSources(memory = true, disk = true, remote = false)
val remoteOnly = DataSources(memory = false, disk = false, remote = true)
}
}
```
The `DataSources` class allows us to specify whether to fetch data from memory, disk, or remote sources.
Providing a companion object with common configurations improves readability
and reduces the likelihood of errors.
Next, we can define the `Query` operations within the `Operation` class. Each query
operation specifies the `DataSources` to use.
```kotlin {7-24} theme={"system"}
sealed class Query<
out K : Model.Key,
out P : Model.Properties,
out E : Model.Edges,
out N : Model.Node> : Operation() {
abstract val dataSources: DataSources
data class FindOne(val key: K, override val dataSources: DataSources) :
Query()
data class FindMany(val keys: List, override val dataSources: DataSources) :
Query()
data class FindAll(override val dataSources: DataSources) :
Query()
data class ObserveOne(val key: K, override val dataSources: DataSources) :
Query()
data class ObserveMany(
val keys: List,
override val dataSources: DataSources
) : Query()
}
```
The `Query` operations include:
* `FindOne` and `FindMany` for fetching specific items by key(s).
* `FindAll` for fetching all items.
* `ObserveOne` and `ObserveMany` for observing changes to specific items.
### Defining `Update` Operations
Under the `Mutation` class, we can define the `Update` operations for modifying existing data.
```kotlin {12-40} theme={"system"}
sealed class Mutation<
out K : Model.Key,
out P : Model.Properties,
out E : Model.Edges,
out N : Model.Node> : Operation() {
sealed class Create<
K : Model.Key,
P : Model.Properties,
E : Model.Edges> : Mutation() {...}
sealed class Update<
K : Model.Key,
P : Model.Properties,
E : Model.Edges> : Mutation() {
data class UpdateOne<
K : Model.Key,
P : Model.Properties,
E : Model.Edges,
N : Model.Node>(
val node: N
) : Update()
data class UpdateMany<
K : Model.Key,
P : Model.Properties,
E : Model.Edges,
N : Model.Node>(
val nodes: List
) : Update()
data class UpsertOne(
val properties: P
) : Update()
data class UpsertMany(
val properties: List
) : Update()
}
}
```
The `Update` operations include:
* `UpdateOne` and `UpdateMany` for updating existing items.
* `UpsertOne` and `UpsertMany` for inserting or updating an item.
### Defining `Delete` Operations
Finally, we can define `Delete` operations under the `Mutation` class.
```kotlin {16-28} theme={"system"}
sealed class Mutation<
out K : Model.Key,
out P : Model.Properties,
out E : Model.Edges,
out N : Model.Node> : Operation() {
sealed class Create<
K : Model.Key,
P : Model.Properties,
E : Model.Edges> : Mutation() {...}
sealed class Update<
K : Model.Key,
P : Model.Properties,
E : Model.Edges> : Mutation() {...}
sealed class Delete : Mutation() {
data class DeleteOne(
val key: K
) : Delete()
data class DeleteMany(
val keys: List
) : Delete()
data object DeleteAll : Delete()
}
}
```
The `Delete` operations include:
* `DeleteOne` and `DeleteMany` for deleting specific items by key(s).
* `DeleteAll` for deleting all items.
These operations require the `Key` of the items to be deleted.
## Defining Output Types
Because our operations can return either a single `Model` or a collection of `Model`s, we need to define an output type that can represent both cases.
We'll define an `Output` sealed class to represent the results of our operations.
```kotlin theme={"system"}
sealed class Output {
data class Single(val item: T) : Output()
data class Collection(val items: List) : Output()
}
```
The `Output` class has two subclasses:
* `Single`, which wraps a single `Model` item.
* `Collection`, which wraps a list of `Model` items.
This design allows our `Store` to handle both single-item and multiple-item results in a type-safe manner.
## Conclusion
With all the components in place, we can now redefine our `PostStore` to use the new `Operation` and `Output` types.
```kotlin theme={"system"}
typealias PostOperation = Operation
typealias Output = Output
typealias PostStore = MutableStore
```
Creating type aliases for `PostOperation`, `Output`, and `PostStore`
simplifies our code and improves readability.
By defining flexible data model and operation classes, we've established a foundation for handling complex query and mutation operations. In the [next part of this guide](/docs/use-cases/store5/implementing-crud-operations-in-store), we'll modify our implementations of `Fetcher`, `SourceOfTruth`, `Updater`, and `Bookkeeper` to support these operations.