красиво.fs

type ColumnSelector = { Name: string; ColumnName: string }
type RowSelector = { Name: string; RowName: string }
type SetValueArgs = { Name: string; RowName: string; ColumnName: string; Value: string  }
type SetDefaultValueArgs = { Name: string; RowName: string; Value: string  }



type Command =
    | Create          of string
    | AddColumn       of ColumnSelector
    | AddRow          of RowSelector
    | RemoveColumn    of ColumnSelector
    | RemoveRow       of RowSelector
    | SetValue        of SetValueArgs
    | SetDefaultValue of SetDefaultValueArgs
    

type QueryValue = { Name: string; RowName: string; ColumnName: string; }

    
    
type CommandHandler(store: IStore) =
    let logger = Log.Logger.ForContext<CommandHandler>()
    

    member this.Handle(cmd) = asyncResult {
        match cmd with
        | Create tableName ->
            match! store.Exist(tableName) with
            | true -> return! Error ^ AppError.create TableAlreadyExist
            | false ->
                let table = TableConfig.CreateNew().SetName(tableName)
                do! store.Save(table)
                logger.Information($"created new table '{tableName}'")
            
        | AddColumn args ->
            let! table = store.Find(args.Name) 
            let! table = table.AddColumn(args.ColumnName)
            do! store.Save(table)
            logger.Information($"added '{args.ColumnName}' column")
        
        | AddRow args ->
            let! table = store.Find(args.Name)
            let! table = table.AddRow(args.RowName)
            do! store.Save(table)
            logger.Information($"added '{args.RowName}' row")
            
        | RemoveColumn args ->
            let! table = store.Find(args.Name)
            let! table = table.RemoveColumn(args.ColumnName)
            do! store.Save(table)
            logger.Information($"removed '{args.ColumnName}' column")
        
        | RemoveRow args ->
            let! table = store.Find(args.Name)
            let! table = table.RemoveRow(args.RowName)
            do! store.Save(table)
            logger.Information($"removed '{args.RowName}' row")
        
        | SetValue args ->
            let! table = store.Find(args.Name)
            let! table = table.SetValue(args.RowName, args.ColumnName, args.Value)
            do! store.Save(table)
            logger.Information($"new value: {args.RowName}-{args.ColumnName} {args.Value}")
        
        | SetDefaultValue args ->
            let! table = store.Find(args.Name)
            let! table = table.SetDefaultValue(args.RowName, args.Value)
            do! store.Save(table)
            logger.Information($"new default value: {args.RowName} {args.Value}")
    }
    

type QueryHandler(store: IStore) =
    
    member this.GetState(name) = asyncResult {
        let! table = store.Find(name)
        return Store.dbTableConfigMap table
    }
    
    member this.QueryValue(qry) = asyncResult {
        let! table = store.Find(qry.Name)
        let! value = table.GetValue(qry.RowName, qry.ColumnName)
        
        return value.AsString
    }
    
    member this.TableList() = async {
        let! tables = store.GetAllTables()
        
        return tables |> Seq.map (fun x -> x.Name) |> Seq.toArray
    }

Красиво