マイクロサービスでイベントソーシングを利用したくなる理由とその動作原理を学ぼう / Why Event Sourcing

イベントソーシングがなぜ必要になるのかの解説と、その動作原理を解説する際に利用した資料です。
この資料を使ったトークが YouTube にアップロードされています。
トークURL: https://youtu.be/Jtcp9ry8ZcE

◆ URL
トークURL: https://youtu.be/Jtcp9ry8ZcE
チャンネル登録: https://www.youtube.com/c/narusemi?sub_confirmation=1
Twitter: https://twitter.com/nrslib
SampleCode: https://github.com/nrslib/microservice-with-event-sourcing-sample-kotlin

Transcript

1. View Slide

2. View Slide

3. View Slide

4. View Slide

5. View Slide

6. View Slide

7. View Slide

8. View Slide

9. View Slide

10. View Slide

11. View Slide

12. View Slide

13. View Slide

14. View Slide

15. View Slide

16. View Slide

17. View Slide

18. View Slide

19. View Slide

20. View Slide

21. View Slide

22. View Slide

23. View Slide

24. @Transactional
    public void order(String itemId) {
    var itemDao = new ItemDao();
    var item = itemDao.findById(itemId);
    ...
    var accountDao = new AccountDao();
    var account = accountDao.find(Session.Id);
    var paymentDao = new PaymentDao();
    var paymentInfo = paymentDao.find(account.id);
    paymentInfo.validate();
    creditService.approval(paymentInfo.cardInfo, order.total);
    ...
    orderDao.save(order);
    }
    

    View Slide

25. @Transactional
    public void order(String itemId) {
    var itemDao = new ItemDao();
    var item = itemDao.findById(itemId);
    ...
    var accountDao = new AccountDao();
    var account = accountDao.find(Session.Id);
    var paymentDao = new PaymentDao();
    var paymentInfo = paymentDao.find(account.id);
    paymentInfo.validate();
    creditService.approval(paymentInfo.cardInfo, order.total);
    ...
    orderDao.save(order);
    }
    

    View Slide

26. @Transactional
    public void order(String itemId) {
    var itemDao = new ItemDao();
    var item = itemDao.findById(itemId);
    ...
    var accountDao = new AccountDao();
    var account = accountDao.find(Session.Id);
    var paymentDao = new PaymentDao();
    var paymentInfo = paymentDao.find(account.id);
    paymentInfo.validate();
    creditService.approval(paymentInfo.cardInfo, order.total);
    ...
    orderDao.save(order);
    }
    

    View Slide

27. View Slide

28. View Slide

29. View Slide

30. View Slide

31. View Slide

32. View Slide

33. View Slide

34. View Slide

35. View Slide

36. View Slide

37. View Slide

38. View Slide

39. View Slide

40. View Slide

41. View Slide

42. View Slide

43. View Slide

44. View Slide

45. View Slide

46. View Slide

47. View Slide

48. View Slide

49. View Slide

50. View Slide

51. View Slide

52. View Slide

53. View Slide

54. View Slide

55. View Slide

56. View Slide

57. View Slide

58. View Slide

59. View Slide

60. View Slide

61. View Slide

62. View Slide

63. View Slide

64. View Slide

65. View Slide

66. View Slide

67. View Slide

68. View Slide

69. View Slide

70. View Slide

71. View Slide

72. View Slide

73. View Slide

74. View Slide

75. View Slide

76. View Slide

77. View Slide

78. View Slide

79. View Slide

80. View Slide

81. View Slide

82. View Slide

83. View Slide

84. View Slide

85. View Slide

86. View Slide

87. View Slide

88. View Slide

89. View Slide

90. View Slide

91. View Slide

92. View Slide

93. View Slide

94. View Slide

95. View Slide

96. View Slide

97. View Slide

98. View Slide

99. View Slide

100. View Slide

101. View Slide

102. View Slide

103. View Slide

104. View Slide

105. View Slide

106. View Slide

107. View Slide

108. View Slide

109. View Slide

110. View Slide

111. View Slide

112. View Slide

113. View Slide

114. View Slide

115. View Slide

116. View Slide

117. View Slide

118. View Slide

119. View Slide

120. View Slide

121. View Slide

122. View Slide

123. View Slide

124. View Slide

125. View Slide

126. View Slide

127. View Slide

128. View Slide

129. View Slide

130. View Slide

131. View Slide

132. View Slide

133. View Slide

134. View Slide

135. View Slide

136. View Slide

137. View Slide

138. View Slide

139. View Slide

140. View Slide

141. View Slide

142. View Slide

143. View Slide

144. View Slide

145. View Slide

146. View Slide

147. View Slide

148. View Slide

149. View Slide

150. View Slide

151. View Slide

152. View Slide

153. View Slide

154. View Slide

155. View Slide

156. View Slide

157. View Slide

158. View Slide

159. View Slide

160. View Slide

161. View Slide

162. View Slide

163. View Slide

164. View Slide

165. View Slide

166. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     ...
     }
     

     View Slide

167. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

168. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

169. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

170. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

171. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

172. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

173. class OrderApplicationService(
     private val itemRepository: ItemRepository,
     private val orderRepository: AggregateRepository
     ) {
     @Transactional
     fun createOrder(accountId: String, itemAndQuantities: List): String {
     val items = itemRepository.find(itemAndQuantities.map { ItemId(it.itemId) })
     val orderItems = makeOrderItems(itemAndQuantities, items)
     val command = CreateOrderCommand(UUID.randomUUID().toString(), accountId, orderItems)
     val result = orderRepository.save(command)
     return result.idAndVersion.id
     }
     ...
     private fun makeOrderItems(itemAndQuantities: List, items: List): OrderItems {
     val orderItems = itemAndQuantities.map {
     val item = items.first { item -> item.id.value == it.itemId }
     OrderItem(
     it.quantity,
     item.price
     )
     }
     return OrderItems(orderItems)
     }
     }
     

     View Slide

174. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

175. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

176. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

177. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

178. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

179. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     }
     

     View Slide

180. View Slide

181. View Slide

182. View Slide

183. View Slide

184. View Slide

185. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     fun process(command: CreateOrderCommand): List {
     val total = command.orderItems.total()
     val event = OrderCreatedEvent(command.id, command.accountId, total, command.orderItems)
     return listOf(event)
     }
     ...
     }
     

     View Slide

186. View Slide

187. View Slide

188. View Slide

189. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     ...
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     ...
     }
     

     View Slide

190. View Slide

191. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

192. View Slide

193. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

194. View Slide

195. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

196. View Slide

197. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

198. View Slide

199. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

200. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     fun save(command: CT): EntityWithIdAndVersion {
     val aggregate = clazz.getDeclaredConstructor().newInstance()
     val events = aggregate.processCommand(command)
     Aggregate.applyEvents(aggregate, events)
     val serializedEvents = events.map {
     EventTypeAndData(it.javaClass.name, Gson().toJson(it))
     }
     val entityIdVersionAndEventIds = aggregateStore.save(clazz, serializedEvents)
     return EntityWithIdAndVersion(
     entityIdVersionAndEventIds,
     aggregate
     )
     }
     ...
     }
     

     View Slide

201. View Slide

202. View Slide

203. View Slide

204. View Slide

205. View Slide

206. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     ...
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     fun apply(event: OrderApprovedEvent) {
     this.orderState = OrderState.APPROVED
     }
     fun apply(event: OrderRejectedEvent) {
     this.orderState = OrderState.APPROVAL_REJECTED
     }
     }
     

     View Slide

207. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     ...
     fun apply(event: OrderCreatedEvent) {
     accountId = event.accountId
     total = event.total
     items = event.orderItems
     orderState = OrderState.APPROVAL_PENDING
     }
     fun apply(event: OrderApprovedEvent) {
     this.orderState = OrderState.APPROVED
     }
     fun apply(event: OrderRejectedEvent) {
     this.orderState = OrderState.APPROVAL_REJECTED
     }
     }
     

     View Slide

208. View Slide

209. View Slide

210. class Order : CommandProcessingAggregate() {
     lateinit var accountId: String
     var total: Money = Money.zero()
     lateinit var items: OrderItems
     lateinit var orderState: OrderState
     ...
     fun process(command: ApproveOrderCommand): List {
     return listOf(OrderApprovedEvent())
     }
     }
     

     View Slide

211. View Slide

212. View Slide

213. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

214. View Slide

215. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

216. View Slide

217. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

218. View Slide

219. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

220. View Slide

221. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

222. View Slide

223. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

224. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

225. View Slide

226. enum class DocumentType {
     Entity,
     Event,
     Snapshot
     }
     class EventSourcingDocument {
     @Id
     lateinit var id: String
     lateinit var type: DocumentType
     lateinit var entityId: String
     lateinit var body: String
     var version: Long = -1
     @JsonProperty("_etag")
     var etag: String = ""
     }
     

     View Slide

227. enum class DocumentType {
     Entity,
     Event,
     Snapshot
     }
     class EventSourcingDocument {
     @Id
     lateinit var id: String
     lateinit var type: DocumentType
     lateinit var entityId: String
     lateinit var body: String
     var version: Long = -1
     @JsonProperty("_etag")
     var etag: String = ""
     }
     

     View Slide

228. enum class DocumentType {
     Entity,
     Event,
     Snapshot
     }
     class EventSourcingDocument {
     @Id
     lateinit var id: String
     lateinit var type: DocumentType
     lateinit var entityId: String
     lateinit var body: String
     var version: Long = -1
     @JsonProperty("_etag")
     var etag: String = ""
     }
     

     View Slide

229. class EventDataModel {
     lateinit var id: String
     lateinit var eventType: String
     lateinit var entityType: String
     lateinit var entityId: String
     lateinit var payload: String
     var version: Long = -1
     ...
     }
     

     View Slide

230. class EntityDataModel {
     lateinit var id: String
     lateinit var type: String
     var version: Long = -1
     ...
     }
     

     View Slide

231. class SnapshotDataModel {
     lateinit var id: String
     lateinit var entityType: String
     lateinit var entityId: String
     var entityVersion: Long = -1
     lateinit var snapshotType: String
     lateinit var snapshotData: String
     ...
     }
     

     View Slide

232. View Slide

233. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

234. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

235. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

236. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

237. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

238. @Beta(value = Beta.SinceVersion.V4_7_0, warningText = Beta.PREVIEW_SUBJECT_TO_CHANGE_WARNING)
     @Deprecated() //forRemoval = true, since = "4.19"
     public final class TransactionalBatch {
     

     View Slide

239. @Beta(value = Beta.SinceVersion.V4_7_0, warningText = Beta.PREVIEW_SUBJECT_TO_CHANGE_WARNING)
     @Deprecated() //forRemoval = true, since = "4.19"
     public final class TransactionalBatch {
     

     View Slide

240. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

241. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

242. class CosmosAggregateStore(...) : AggregateStore {
     override fun > save(clazz: Class, events: List, options: AggregateCrudSaveOptions?
     val container = getContainer()
     val entityId = UUID.randomUUID().toString()
     val version = events.count().toLong()
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val entityDataModel = EntityDataModel(entityId, clazz.name, version)
     val entityDocument = entityDataModel.toDocument()
     batch.createItemOperation(entityDocument)
     events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.eventType,
     clazz.name,
     entityId,
     index.toLong() + 1,
     it.eventData
     )
     }.map(EventDataModel::toDocument)
     .forEach { batch.createItemOperation(it) }
     val response = container.executeTransactionalBatch(batch)
     if (!response.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entityId, version)
     }
     

     View Slide

243. View Slide

244. }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels
     .map(EventDataModel::toDocument)
     .forEach {
     batch.createItemOperation(it)
     }
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     if (options?.snapshot != null) {
     val snapshot = options.snapshot
     val snapshotDataModel = SnapshotDataModel(
     UUID.randomUUID().toString(),
     clazz.name,
     entityIdAndVersion.id,
     latestVersion,
     snapshot!!.javaClass.name,
     

     View Slide

245. View Slide

246. override fun > update(clazz: Class, entityIdAndVersion: EntityIdAndVersion, events: List, option
     val entityId = entityIdAndVersion.id
     val currentVersion = entityIdAndVersion.version
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val container = getContainer()
     val entityDocumentReadResponse = container.readItem(entityId, PartitionKey(entityId), EventSourcingDocument::class.java
     val entityDocument = entityDocumentReadResponse.item
     if (currentVersion != entityDocument.version) {
     throw OptimisticConcurrencyException(entityId, currentVersion, entityDocument.version)
     }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels.map(EventDataModel::toDocument).forEach {batch.createItemOperation(it)}
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     

     View Slide

247. override fun > update(clazz: Class, entityIdAndVersion: EntityIdAndVersion, events: List, option
     val entityId = entityIdAndVersion.id
     val currentVersion = entityIdAndVersion.version
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val container = getContainer()
     val entityDocumentReadResponse = container.readItem(entityId, PartitionKey(entityId), EventSourcingDocument::class.java
     val entityDocument = entityDocumentReadResponse.item
     if (currentVersion != entityDocument.version) {
     throw OptimisticConcurrencyException(entityId, currentVersion, entityDocument.version)
     }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels.map(EventDataModel::toDocument).forEach {batch.createItemOperation(it)}
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     

     View Slide

248. override fun > update(clazz: Class, entityIdAndVersion: EntityIdAndVersion, events: List, option
     val entityId = entityIdAndVersion.id
     val currentVersion = entityIdAndVersion.version
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val container = getContainer()
     val entityDocumentReadResponse = container.readItem(entityId, PartitionKey(entityId), EventSourcingDocument::class.java
     val entityDocument = entityDocumentReadResponse.item
     if (currentVersion != entityDocument.version) {
     throw OptimisticConcurrencyException(entityId, currentVersion, entityDocument.version)
     }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels.map(EventDataModel::toDocument).forEach {batch.createItemOperation(it)}
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     

     View Slide

249. override fun > update(clazz: Class, entityIdAndVersion: EntityIdAndVersion, events: List, option
     val entityId = entityIdAndVersion.id
     val currentVersion = entityIdAndVersion.version
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val container = getContainer()
     val entityDocumentReadResponse = container.readItem(entityId, PartitionKey(entityId), EventSourcingDocument::class.java
     val entityDocument = entityDocumentReadResponse.item
     if (currentVersion != entityDocument.version) {
     throw OptimisticConcurrencyException(entityId, currentVersion, entityDocument.version)
     }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels.map(EventDataModel::toDocument).forEach {batch.createItemOperation(it)}
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     

     View Slide

250. override fun > update(clazz: Class, entityIdAndVersion: EntityIdAndVersion, events: List, option
     val entityId = entityIdAndVersion.id
     val currentVersion = entityIdAndVersion.version
     val batch = TransactionalBatch.createTransactionalBatch(PartitionKey(entityId))
     val container = getContainer()
     val entityDocumentReadResponse = container.readItem(entityId, PartitionKey(entityId), EventSourcingDocument::class.java
     val entityDocument = entityDocumentReadResponse.item
     if (currentVersion != entityDocument.version) {
     throw OptimisticConcurrencyException(entityId, currentVersion, entityDocument.version)
     }
     val eventDatamodels = events.mapIndexed { index, it ->
     EventDataModel(
     UUID.randomUUID().toString(),
     it.javaClass.name,
     clazz.name,
     entityId,
     currentVersion + index + 1,
     Gson().toJson(it)
     )
     }
     eventDatamodels.map(EventDataModel::toDocument).forEach {batch.createItemOperation(it)}
     val latestVersion = eventDatamodels.last().version
     val entity = EntityDataModel.from(entityDocument)
     entity.version = latestVersion
     val replaceEntityDocument = entity.toDocument()
     batch.replaceItemOperation(entityId, replaceEntityDocument, TransactionalBatchItemRequestOptions().setIfMatchETag(entit
     

     View Slide

251. if (options?.snapshot != null) {
     val snapshot = options.snapshot
     val snapshotDataModel = SnapshotDataModel(
     UUID.randomUUID().toString(),
     clazz.name,
     entityIdAndVersion.id,
     latestVersion,
     snapshot!!.javaClass.name,
     Gson().toJson(snapshot)
     )
     val snapshotDocument = snapshotDataModel.toDocument()
     batch.createItemOperation(snapshotDocument)
     }
     val result = container.executeTransactionalBatch(batch)
     if (!result.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entity.id, latestVersion)
     }
     

     View Slide

252. if (options?.snapshot != null) {
     val snapshot = options.snapshot
     val snapshotDataModel = SnapshotDataModel(
     UUID.randomUUID().toString(),
     clazz.name,
     entityIdAndVersion.id,
     latestVersion,
     snapshot!!.javaClass.name,
     Gson().toJson(snapshot)
     )
     val snapshotDocument = snapshotDataModel.toDocument()
     batch.createItemOperation(snapshotDocument)
     }
     val result = container.executeTransactionalBatch(batch)
     if (!result.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entity.id, latestVersion)
     }
     

     View Slide

253. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

254. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

255. class AggregateRepository(
     private val clazz: Class,
     private val aggregateStore: AggregateStore
     ) where T : CommandProcessingAggregate, CT : Command {
     ...
     fun update(id: String, cmd: CT, updateOption: UpdateOptions = UpdateOptions())
     : EntityWithIdAndVersion {
     val loadedData = aggregateStore.find(clazz, id)
     ?: throw IllegalArgumentException("$id is notfound")
     val aggregate = loadedData.entity
     val events = aggregate.processCommand(cmd)
     Aggregate.applyEvents(aggregate, events)
     val idAndVersion = aggregateStore.update(
     clazz,
     loadedData.idAndVersion,
     events,
     withPossibleSnapshot(
     updateOption, aggregate, loadedData.snapshotVersion, loadedData.events, events)
     )
     return EntityWithIdAndVersion(idAndVersion, aggregate)
     }
     }
     

     View Slide

256. class OrderSnapshotStrategy : SnapshotStrategy {
     override fun getAggregateClass(): Class<*> = Order::class.java
     override fun possiblySnapshot(
     aggregate: Aggregate<*>,
     oldEvents: List,
     newEvents: List,
     snapshotVersion: String?
     ): Snapshot? {
     val order = aggregate as Order
     val snapshot = OrderSnapshot()
     snapshot.accountId = order.accountId
     snapshot.orderState = order.orderState
     snapshot.total = order.total
     snapshot.items = order.items
     return snapshot
     }
     override fun recreateAggregate(clasz: Class, snapshot: Snapshot): T where T : Aggregate {
     val orderSnapshot = snapshot as OrderSnapshot
     val aggregate = Order()
     aggregate.accountId = orderSnapshot.accountId
     aggregate.orderState = orderSnapshot.orderState
     aggregate.total = orderSnapshot.total
     aggregate.items = orderSnapshot.items
     return aggregate as T
     }
     }
     

     View Slide

257. if (options?.snapshot != null) {
     val snapshot = options.snapshot
     val snapshotDataModel = SnapshotDataModel(
     UUID.randomUUID().toString(),
     clazz.name,
     entityIdAndVersion.id,
     latestVersion,
     snapshot!!.javaClass.name,
     Gson().toJson(snapshot)
     )
     val snapshotDocument = snapshotDataModel.toDocument()
     batch.createItemOperation(snapshotDocument)
     }
     val result = container.executeTransactionalBatch(batch)
     if (!result.isSuccessStatusCode) {
     throw UnsupportedOperationException()
     }
     return EntityIdAndVersion(entity.id, latestVersion)
     }
     

     View Slide

258. View Slide

259. val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     if (snapshotDataModel == null && events.isEmpty()) {
     return null
     }
     val version = if (events.isEmpty()) {
     entity.version
     } else {
     events.last().version
     }
     val idAndVersion = EntityIdAndVersion(id, version)
     val recreatedAggregate = if (snapshotDataModel != null) {
     

     View Slide

260. View Slide

261. override fun > find(clazz: Class, id: String): EntityWithMetadata? {
     val container = getContainer()
     val readSnapshotDocumentResponse = container.queryItems(
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Snapshot}¥" AND x.entityId = ¥"${id}¥" ORDER BY x.version DESC",
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(id)).setMaxBufferedItemCount(1),
     EventSourcingDocument::class.java
     )
     val snapshotDataModel = readSnapshotDocumentResponse.map(SnapshotDataModel.Companion::from).firstOrNull()
     val readEntityDocumentResponse = container.readItem(id, PartitionKey(id), EventSourcingDocument::class.java)
     val entityDocument = readEntityDocumentResponse.item
     val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     

     View Slide

262. override fun > find(clazz: Class, id: String): EntityWithMetadata? {
     val container = getContainer()
     val readSnapshotDocumentResponse = container.queryItems(
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Snapshot}¥" AND x.entityId = ¥"${id}¥" ORDER BY x.version DESC",
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(id)).setMaxBufferedItemCount(1),
     EventSourcingDocument::class.java
     )
     val snapshotDataModel = readSnapshotDocumentResponse.map(SnapshotDataModel.Companion::from).firstOrNull()
     val readEntityDocumentResponse = container.readItem(id, PartitionKey(id), EventSourcingDocument::class.java)
     val entityDocument = readEntityDocumentResponse.item
     val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     

     View Slide

263. override fun > find(clazz: Class, id: String): EntityWithMetadata? {
     val container = getContainer()
     val readSnapshotDocumentResponse = container.queryItems(
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Snapshot}¥" AND x.entityId = ¥"${id}¥" ORDER BY x.version DESC",
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(id)).setMaxBufferedItemCount(1),
     EventSourcingDocument::class.java
     )
     val snapshotDataModel = readSnapshotDocumentResponse.map(SnapshotDataModel.Companion::from).firstOrNull()
     val readEntityDocumentResponse = container.readItem(id, PartitionKey(id), EventSourcingDocument::class.java)
     val entityDocument = readEntityDocumentResponse.item
     val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     

     View Slide

264. override fun > find(clazz: Class, id: String): EntityWithMetadata? {
     val container = getContainer()
     val readSnapshotDocumentResponse = container.queryItems(
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Snapshot}¥" AND x.entityId = ¥"${id}¥" ORDER BY x.version DESC",
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(id)).setMaxBufferedItemCount(1),
     EventSourcingDocument::class.java
     )
     val snapshotDataModel = readSnapshotDocumentResponse.map(SnapshotDataModel.Companion::from).firstOrNull()
     val readEntityDocumentResponse = container.readItem(id, PartitionKey(id), EventSourcingDocument::class.java)
     val entityDocument = readEntityDocumentResponse.item
     val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     

     View Slide

265. override fun > find(clazz: Class, id: String): EntityWithMetadata? {
     val container = getContainer()
     val readSnapshotDocumentResponse = container.queryItems(
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Snapshot}¥" AND x.entityId = ¥"${id}¥" ORDER BY x.version DESC",
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(id)).setMaxBufferedItemCount(1),
     EventSourcingDocument::class.java
     )
     val snapshotDataModel = readSnapshotDocumentResponse.map(SnapshotDataModel.Companion::from).firstOrNull()
     val readEntityDocumentResponse = container.readItem(id, PartitionKey(id), EventSourcingDocument::class.java)
     val entityDocument = readEntityDocumentResponse.item
     val entity = EntityDataModel.from(entityDocument)
     val getEventsQuery = if (snapshotDataModel != null) {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.version > ${entity.version} AND x.entityId = ¥"${en
     } else {
     "SELECT * FROM x WHERE x.type = ¥"${DocumentType.Event}¥" AND x.entityId = ¥"${entity.id}¥" ORDER BY x.version"
     }
     val eventDocuments = container.queryItems(
     getEventsQuery,
     CosmosQueryRequestOptions().setPartitionKey(PartitionKey(entity.id)),
     EventSourcingDocument::class.java
     )
     val events = eventDocuments.map(EventDataModel.Companion::from).map {
     val eventClazz = Class.forName(it.eventType)
     val event = Gson().fromJson(it.payload, eventClazz) as Event
     EventWithMetaData(event, it.version)
     }
     

     View Slide

266. if (snapshotDataModel == null && events.isEmpty()) {
     return null
     }
     val version = if (events.isEmpty()) {
     entity.version
     } else {
     events.last().version
     }
     val idAndVersion = EntityIdAndVersion(id, version)
     val recreatedAggregate = if (snapshotDataModel != null) {
     val snapshotClazz = Class.forName(snapshotDataModel.snapshotType)
     val snapshot = Gson().fromJson(snapshotDataModel.snapshotData, snapshotClazz) as Snapshot
     val aggregate = snapshotManager.recreateFromSnapshot(clazz, snapshot)
     Aggregate.applyEvents(aggregate, events.map { it.event })
     } else {
     Aggregate.recreate(clazz, events.map { it.event })
     }
     return EntityWithMetadata(
     idAndVersion,
     events,
     recreatedAggregate,
     snapshotDataModel?.entityVersion.toString()
     )
     }
     

     View Slide

267. if (snapshotDataModel == null && events.isEmpty()) {
     return null
     }
     val version = if (events.isEmpty()) {
     entity.version
     } else {
     events.last().version
     }
     val idAndVersion = EntityIdAndVersion(id, version)
     val recreatedAggregate = if (snapshotDataModel != null) {
     val snapshotClazz = Class.forName(snapshotDataModel.snapshotType)
     val snapshot = Gson().fromJson(snapshotDataModel.snapshotData, snapshotClazz) as Snapshot
     val aggregate = snapshotManager.recreateFromSnapshot(clazz, snapshot)
     Aggregate.applyEvents(aggregate, events.map { it.event })
     } else {
     Aggregate.recreate(clazz, events.map { it.event })
     }
     return EntityWithMetadata(
     idAndVersion,
     events,
     recreatedAggregate,
     snapshotDataModel?.entityVersion.toString()
     )
     }
     

     View Slide

268. if (snapshotDataModel == null && events.isEmpty()) {
     return null
     }
     val version = if (events.isEmpty()) {
     entity.version
     } else {
     events.last().version
     }
     val idAndVersion = EntityIdAndVersion(id, version)
     val recreatedAggregate = if (snapshotDataModel != null) {
     val snapshotClazz = Class.forName(snapshotDataModel.snapshotType)
     val snapshot = Gson().fromJson(snapshotDataModel.snapshotData, snapshotClazz) as Snapshot
     val aggregate = snapshotManager.recreateFromSnapshot(clazz, snapshot)
     Aggregate.applyEvents(aggregate, events.map { it.event })
     } else {
     Aggregate.recreate(clazz, events.map { it.event })
     }
     return EntityWithMetadata(
     idAndVersion,
     events,
     recreatedAggregate,
     snapshotDataModel?.entityVersion.toString()
     )
     }
     

     View Slide

269. if (snapshotDataModel == null && events.isEmpty()) {
     return null
     }
     val version = if (events.isEmpty()) {
     entity.version
     } else {
     events.last().version
     }
     val idAndVersion = EntityIdAndVersion(id, version)
     val recreatedAggregate = if (snapshotDataModel != null) {
     val snapshotClazz = Class.forName(snapshotDataModel.snapshotType)
     val snapshot = Gson().fromJson(snapshotDataModel.snapshotData, snapshotClazz) as Snapshot
     val aggregate = snapshotManager.recreateFromSnapshot(clazz, snapshot)
     Aggregate.applyEvents(aggregate, events.map { it.event })
     } else {
     Aggregate.recreate(clazz, events.map { it.event })
     }
     return EntityWithMetadata(
     idAndVersion,
     events,
     recreatedAggregate,
     snapshotDataModel?.entityVersion.toString()
     )
     }
     

     View Slide

270. View Slide

271. View Slide

272. View Slide