Refactor Repository to be 'F# first'; eliminate IRepository

Author: jt185133

samples/CrmDomain/Aggregate.Contact.fs

@@ -2,7 +2,6 @@ module CrmDomain.Aggregate.Contact
 
 open System
 open Fescq.Core
-open Fescq.Repository
 open CrmDomain
 
 type Contact = {
@@ -216,20 +215,16 @@ module private Storage =
          ex -> Error ex.Message
 
    let load (store:EventStore) (aggId:Guid) = 
-      Repository<Contact> store
-      :> IRepository<Contact>
-      |> fun x -> x.Load(aggId, factory)
+      Fescq.Repository.create<Contact> store
+      |> fun x -> x.Load aggId factory
 
    let loadExpectedVersion (store:EventStore) (aggId:Guid) (expectedVersion:int) = 
-      Repository<Contact> store
-      :> IRepository<Contact>
-      |> fun x -> x.LoadExpectedVersion(aggId, factory, expectedVersion)
+      Fescq.Repository.create<Contact> store
+      |> fun x -> x.LoadExpectedVersion aggId factory expectedVersion
 
    let save (store:EventStore) (update:Agg<Contact> * Event list) =
-
-      Repository<Contact> store
-      :> IRepository<Contact>
-      |> fun x -> x.Save(fst update, snd update)
+      Fescq.Repository.create<Contact> store
+      |> fun x -> x.Save (fst update) (snd update)
 
 
 module Workflow =

samples/CrmDomain/CSharp.fs

@@ -17,7 +17,7 @@ type ContactWorkflow private () =
    static member Update (getUtcNow:System.Func<DateTimeOffset>, store:EventStore, aggId:Guid, metaData:string, cmd:Fescq.Command.UpdateCommand) =
       Contact.Workflow.update (fun () -> getUtcNow.Invoke()) store aggId metaData cmd
       |> function
-         | Ok agg -> agg
+         | Ok x -> x
          | Error msg -> failwith msg
 
    static member Load (store:EventStore, aggId:Guid) =

samples/NetCoreWebApp/Controllers/api/ContactCommandController.cs

@@ -78,9 +78,13 @@ public async Task<ActionResult> AddPhone(Guid aggregateId, Guid phoneId, [FromBo
       private async Task<ActionResult> UpdateAsync(Guid aggregateId, Fescq.Command.UpdateCommand cmd) =>
          await Task.Run(() =>
 
-            Try(() => ContactWorkflow.Update(() => TimestampNow, _eventStore, aggregateId, "", cmd))
+            Try(() =>
+            {
+               ContactWorkflow.Update(() => TimestampNow, _eventStore, aggregateId, "", cmd);
+               return Unit.Default;
+            })
             .Match(
-               Succ: result => Ok(),
+               Succ: _ => Ok(),
                Fail: ex => ErrorResultAsBadRequest(ex))
          );
 

src/Fescq/Core.fs

@@ -68,3 +68,9 @@ type EventStore = {
    AddEvent: Event -> Result<unit, string>
    Save: unit -> Result<unit, string>
 }
+
+type AggRepository<'t> = {
+   Load : Guid-> (Event list -> Result<Agg<'t>, string>) -> Result<Agg<'t>, string>
+   LoadExpectedVersion : Guid -> (Event list -> Result<Agg<'t>, string>) -> int -> Result<Agg<'t>, string>
+   Save : Agg<'t> -> Event list -> Result<unit, string>
+}

src/Fescq/EventStore.fs

@@ -46,7 +46,7 @@ let create (registry:RegisteredEvents) (getEvents:DtoTypeProvider -> Guid -> seq
          ex -> Error ex.Message
 
 
-   { EventStore.Registry = registry
+   { Registry = registry
      GetEvents = getEvents
      AddEvent = addEvent
      Save = save }

src/Fescq/Repository.fs

@@ -2,28 +2,18 @@ module Fescq.Repository
 
 open System
 open Core
-open EventStore
 
-type IRepository<'t> =
-
-   abstract member Save : Agg<'t> * Event list -> Result<Agg<'t>, string>
+let create<'t> (eventStore:EventStore) =
 
    /// input: aggregate ID * factory
    /// output: aggregate
-   abstract member Load : Guid * (Event list -> Result<Agg<'t>, string>) -> Result<Agg<'t>, string>
-
-   /// input: aggregate ID * factory * expectedVersion
-   /// output: aggregate
-   abstract member LoadExpectedVersion : Guid * (Event list -> Result<Agg<'t>, string>) * int -> Result<Agg<'t>, string>
-
-
-type Repository<'t> (storage:EventStore) =
-
    let load (aggregateId:Guid) (factory:(Event list -> Result<Agg<'t>, string>)) =
       aggregateId
-         |> storage.GetEvents
+         |> eventStore.GetEvents
          |> Result.bind factory
 
+   /// input: aggregate ID * factory * expectedVersion
+   /// output: aggregate
    let loadExpectedVersion (aggregateId:Guid) (factory:(Event list -> Result<Agg<'t>, string>)) (expectedVersion:int) =
       load aggregateId factory
       |> Result.bind (fun x ->
@@ -42,24 +32,17 @@ type Repository<'t> (storage:EventStore) =
          |> List.unfold (fun events ->
                match events with
                | head :: tail ->
-                  match storage.AddEvent head with
+                  match eventStore.AddEvent head with
                   | Ok _ -> Some (Ok (), tail)
                   | Error msg -> Some (Error msg, [])
                | [] -> None)
 
          |> List.last
-         |> Result.bind storage.Save
-         |> Result.bind (fun _ -> aggregate |> Ok)
+         |> Result.bind eventStore.Save
+         |> Result.bind (fun x -> x |> Ok)
       else
          Error "unpersisted events must be part of aggregate history"
 
-   interface IRepository<'t> with
-
-      member x.Load (aggregateId:Guid, factory:(Event list -> Result<Agg<'t>, string>)) =
-         load aggregateId factory
-
-      member x.LoadExpectedVersion (aggregateId:Guid, factory:(Event list -> Result<Agg<'t>, string>), expectedVersion:int) =
-         loadExpectedVersion aggregateId factory expectedVersion
-
-      member x.Save (aggregate:Agg<'t>, unpersisted:Event list) =
-         save aggregate unpersisted
+   { Load = load
+     LoadExpectedVersion = loadExpectedVersion
+     Save = save }