What is the state of Falco?

[seangwright]

Hello!

I'm new-ish to F# and using Falco to build a web app.

I'm a bit confused about a handful of things. I'm not trying to place any blame or cast any shame, I'm just hoping there's some simple answers 😀

1. Should I use Falco 3.x or 4.x?
2. How do I do dependency injection at the HttpHandler level in 3.x? In 4.x I use Falco.Services.inject but in 3.x I cannot get withServices to compile the way it's used in the examples. It's like it's not even in the NuGet package.
3. I'm having trouble identifying which tags/branches of the repository match up with each version of the NuGet package.
4. Which version of Falco is the docs site representing?
5. Are the samples more up do date or are the docs?
6. When I 'go to defnition' in VS Code (using Ionide) on Services.inject in Falco 4.x, VS Code takes me to the definition of the FalcoExtensions type. I can see the inject class in JustDecompile, but not in VS Code. It seems like something is messed up in the NuGet package?
7. Which branch and file is the Services module located in for Falco 4.x?

If I was able to better orient myself in this project I might be able to help with the documentation or examples of some of the use-cases I've implemented (ex: using EFCore.FSharp w/ SQLite and Falco).

Thanks!

[pimbrouwers]

Hi Sean!

Thank you so much for reaching out, and for all of the effort your clearly put in here.

Let me being by saying how sorry I am. Amidst the final push a few weeks ago, I had something come up in my personal life that soaked up all of my spare time. I've done my best over the past few weeks to continue inching toward something I was happy with.

My intention was to hold off the official release until both the migration doc and new tutorial were complete. But with several people reaching out now, including yourself, I don't feel like things can remain in this fractured state for any longer. As such, I decided to push the package before being done those two things

To answer your questions:

1. Definitely use version 4.
2. Dependency injection is done using Service.inject. See this sample, or the tutorial (which is nearly complete) for usage examples. It supports up to five generic type parameters. Sorry for the confusion here.
3. I apologize, but I am not exactly sure what you mean here.
4. The website is referencing version 4
5. Samples are most up to date I would say, as they are part of the detailed build process and reference the local project.
6. This is happening because the package is reference code that wasn't yet posted to GitHub, which is no longer the case.

I would love to see a database-oriented project as a sample. I am biased toward Donald, but EFCore is great as well!

Thank you again for your patience and understanding. Most importantly for reaching out, instead of dismissing this project as "crap" just because the sole maintainer was torn away at an inopportune time.

All the best,
Pim

[seangwright]

1. Awesome I'll continue with 4.0.0-rc1
2. Ok, Services.inject works well. When I last looked at the samples in the master branch, the withServices function was being used but I couldn't find that in the NuGet package.
3. When I was trying to figure out what code the 3.x and 4.x NuGet packages were created from, I couldn't figure out which commits and branches in the repository I should be looking at. Are the develop or dotnet-7 branches in use, or is master where all the latest 4.x work is being performed?
4. 👍
5. Cool - I'll make sure to start with the samples then
6. That makes sense!

I totally understand the balance of being an OSS maintainer with everything else in life (I have quite a few C# packages I maintain), so no worries there. I hope things are are ok with you!

I had another question about task { } CEs w/ HttpHandler. Is this the pattern you generally recommend?

I made this utility function to help me render HTML via a Task<XmlNode>

module Response =
  /// <summary>
  /// Returns a <see cref="HttpHandler" /> that processes an async rendering of an Html response
  /// </summary>
  let ofHtmlTask (xmlTask: Task<XmlNode>) (httpContext: HttpContext) =
    ((task {
      let! xml = xmlTask
      return! Response.ofHtml xml httpContext
    })
    :> Task)

Which I used like this:

let handler: HttpHandler =
  Services.inject<ShopContext> (fun db -> db |> Template.page |> Response.ofHtmlTask)

But using the approach in the samples, I could instead write it like this:

  let handler: HttpHandler =
    Services.inject<ShopContext> (fun db ->
      fun ctx ->
        task {
          let! html = db |> Template.page
          return Response.ofHtml html ctx
        })

I assume that ctx: HttpContext is often used for various request based transformations, access to query params or form data, so in more complex scenarios it's important to have access to it, but in the example above it feels like it's dangling out there.

[seangwright]

I upgraded to Falco 4.0 but I'm still running into various issues that I'll list below.

1. I can't navigate to the definition of Services.inject in VS Code - it takes me to FalcoExtensions.UseFalcoExceptionHandler
2. Since Falco is centered around using Task, I'm (probably through simple ignorance) unable to figure out how to use it with code that returns Async<T>

For 2. the issue appears when trying to use Request.mapForm and Services.inject.

If I inject a service that returns Async<T> and then use it in the next function, the service is disposed before the code executes, unless I use Async.RunSynchronously:

This doesn't work (throws An exception of type 'System.ObjectDisposedException' occurred on my db) unless I replace Async.StartAsTask with Async.RunSynchronously (where BasketDomain.updateBasket returns Async<int>):

  let post: HttpHandler =
    Services.inject<ShopContext> (fun db ->

      let next productId : HttpHandler = fun ctx ->
        task {
          // int
          let! a = BasketDomain.updateBasket db productId |> Async.StartAsTask

          return Response.redirectPermanently $"/basket?added={a}" ctx
        }

      Request.mapForm (fun f -> f.TryGetGuid "id") next)

Restructuring to not use Request.mapForm and instead use Request.getForm appears to resolve the problem:

let post: HttpHandler =
  Services.inject<ShopContext> (fun db -> fun ctx ->
      task {
        let! form = Request.getForm ctx

        let productId = form.TryGetGuid "id"

        let! a = BasketDomain.updateBasket db productId |> Async.StartAsTask

        return Response.redirectPermanently $"/basket?added={a}" ctx
      })

[pimbrouwers]

Thanks for your patience again Sean.

I appreciate you asking, and everything is a-ok, just a level of busy-ness I've never experienced before. Normally I can carve out an hour here or there during the week, and usually some larger stretches during the evenings and weekends. But it has just been impossible lately.

I apologize on the injection patterns. I was toying with something and thought "I had it" a few times. But in practice hated it. Normally I apply a much tighter loop, but lately that's been more difficult.

Now on to the fun stuff!

With respect to the SourceLink stuff, I can't understand what's going on there. Everything was packed and shipped as it always is. I'll have to dig deeper into that. Maybe something to do with it being a type with only static members? Who knows. At this point, with the confusion it's caused and it tripping malware-checks. I have some regrets ::face palm::.

I am the first to admit that the CPS-style handlers can only take you so far. Especially when it comes to async work. For the first async example, "new me" would try:

let post: HttpHandler =    
    let next productId : HttpHandler = fun ctx -> task {
        use db = ctx.GetService<ShopContext>()
        let! a = BasketDomain.updateBasket db productId |> Async.StartAsTask
        return Response.redirectPermanently $"/basket?added={a}" ctx        
    }

    Request.mapForm (fun f -> f.TryGetGuid "id") next

I often find when the complexity/nesting gets dialed up. It's time to switch into "expose" the HttpContext and use the lower-level functions.

Can't tell you how much I appreciate the interest and time invested here. Please do let me know how all of that works.