csbiology/dynamicobj

F# library supporting Dynamic Objects including inheritance in functional style

dynamicobj's Issues

Combine IDOs

What API should be there?

Print does not work, while JsonConvert.SerializeObject works fine

I have a nested dynamic object type:

let response =
    [
        "StatusCode", string result.Value.Response.StatusCode
        "Time", (System.DateTime.Now.ToUniversalTime() - st).ToString()
    ]
    |> List.map (fun x -> fst x, snd x |> Some)
let request =
    let query =
        let queryLogger = Logger()
        ctx.Request.Query |> Seq.iter (fun x -> queryLogger.setProp(x.Key, Some x.Value) )
        queryLogger
    let headers =
        let queryLogger = Logger()
        ctx.Request.Headers |> Seq.iter (fun x -> queryLogger.setProp(x.Key, x.Value |> String.concat "," |> Some ) )
        queryLogger 
    let userAgent =
        ctx.Request.Headers
        |> Seq.tryFind (fun x -> x.Key ="User-Agent")
        |> Option.map (fun x -> x.Value |> String.concat ",")
        |> Option.defaultValue ""
    let contentType =
        ctx.Request.Headers
        |> Seq.tryFind (fun x -> x.Key ="Content-Type")
        |> Option.map (fun x -> x.Value |> String.concat ",")
        |> Option.defaultValue ""
    [
        "Path", box ctx.Request.Path
        "PathBase", box ctx.Request.PathBase
        "Method", box ctx.Request.Method
        "Host", box ctx.Request.Host.Host
        "Port",
            if ctx.Request.Host.Port.HasValue then string ctx.Request.Host.Port.Value else ""
            |> box
        "QueryString",
            if ctx.Request.QueryString.HasValue then string ctx.Request.Host.Port.Value else ""
            |> box
        "Query", if ctx.Request.Query.Count > 0 then box query else null
        "Headers", if ctx.Request.Headers.Count > 0 then box headers else null
        "UserAgent", box userAgent
        "ContentType", box contentType
    ]
    |> List.map (fun x -> fst x, snd x |> Some)
let logger =
    let props =
        [
            "Timestamp", st.ToString("yyyy.MM.dd hh:mm:ss.fffff") |> box
            "Request", Logger.init(request) |> box
            "Response", Logger.init(response) |> box
        ]
        |> List.map (fun x -> fst x, snd x |> Some)
    Logger.init(props)

The json export works:

logger |> JsonConvert.SerializeObject |> printfn "%A"

{
    "Timestamp": "2022.03.25 12:53:37.89496",
    "Request": {
      "Path": "/api/IHelpdeskAPI/getCaptcha",
      "PathBase": "",
      "Method": "GET",
      "Host": "localhost",
      "Port": "8085",
      "QueryString": "",
      "Query": null,
      "Headers": {
        "Connection": "close",
        "Content-Type": "application/json; charset=utf-8",
        "Accept": "*/*",
        "Accept-Encoding": "gzip, deflate, br",
        "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8",
        "Cookie": "ajs_anonymous_id=%22bf0866e7-3877-4d25-8805-c1b2a4b5bd71%22; isDarkmode=false",
        "Host": "localhost:8085",
        "Referer": "http://localhost:8080/?topic=Tools_Swate",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.109 Safari/537.36 OPR/84.0.4316.42",
        "sec-fetch-dest": "empty",
        "sec-fetch-mode": "cors",
        "sec-fetch-site": "same-origin",
        "sec-ch-ua-platform": "\"Windows\"",
        "sec-ch-ua-mobile": "?0",
        "x-remoting-proxy": "true",
        "sec-ch-ua": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"98\", \"Opera\";v=\"84\""
      },
      "UserAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.109 Safari/537.36 OPR/84.0.4316.42",
      "ContentType": "application/json; charset=utf-8"
    },
    "Response": {
      "StatusCode": "200",
      "Time": "00:00:24.8929431"
    }
  }

But DynObj.print logger returns an error:

System.MemberAccessException: Cannot access member.
  at DynamicObj.DynamicObj.op_Dynamic[b](b lookup, String name)
  at DynamicObj.DynObj.loop@93-3(DynamicObj d, DynamicObj object, Int32 identationLevel, FSharpList`1 membersLeft, FSharpList`1 acc)
  at DynamicObj.DynObj.loop@93-3(DynamicObj d, DynamicObj object, Int32 identationLevel, FSharpList`1 membersLeft, FSharpList`1 acc)
  at System.Runtime.CompilerServices.RuntimeHelpers.DispatchTailCalls(IntPtr callersRetAddrSlot, IntPtr callTarget, IntPtr retVal)
  at DynamicObj.DynObj.format(DynamicObj d)
  at DynamicObj.DynObj.print(DynamicObj d)

Casting issues with dynamic object

So this is more or less a collection of things i found missing and i am not sure if these are even possible/how to implement them.

1. Downcasting dynamic objects. Found this issue, when i played around with the DynamicObj.ofJson function i added. It will return a DynamicObj which cannot be downcaster to any type inheriten DynamicObj. The workaround is to use CopyDynamicPropertiesTo on the inerhiting type.

type Logger() =
    inherit DynamicObj()

let logger = Logger()
logger.SetValue ("key", "value")

let dynObj : DynamicObj = DynamicObj()
dynObj.SetValue ("key", "value")

// upcast
let d2 = logger :> DynamicObj // upcast works without issue
d2.TryGetValue "key" // Some "value"

// downcast
dynObj :?> Logger 
// Error: System.InvalidCastException: Unable to cast object of type 'DynamicObj.DynamicObj' to type 'Logger'.

//workaround
dynObj.CopyDynamicPropertiesTo logger 

2. Cast DynamicObj to (anonymous) record type. This could be especially nice for the TryGetTypedValue member.

type MyRecordType = {|
    key: string
|}

let dynObj : DynamicObj = DynamicObj()
dynObj.SetValue ("key", "value")

dynObj :?> MyRecordType
// Type constraint mismatch. The type 'MyRecordType'  is not compatible with type 'DynamicObj

Enable structural equality checks for dynamic members of type `IEnumerable`

https://stackoverflow.com/questions/17101329/f-sequence-comparison

We might want to do structural equality check in Equals, as dynamic members having type seq<'A> will fail on comparison even when they have the same items. This might be the last improvement to enable structural equality checks for charts in Plotly.NET.

Revisit transpilation to JS/Python via Fable

Current impression is:

• All code that needs reflection only needs to be there in .NET and can be completely ignored for transpilation (via compiler flags)
• Instead of the ? operator, implement the Item accession method, and conditionally transpile as JSON field access (JS) or dictionary item access (python)

ImmutableDynamicObj map not serialized correctly out of the box

There seems to be additional steps necessary to ensure that Newtonsoft.Json correctly serializes ImmutableDynamicObj. See this comparison:

DynamicObj (works)

let works =
    let foo = DynamicObj()
    foo?bar <- [1;2;3;4]
    foo

works |> JsonConvert.SerializeObject

val it : string = "{"bar":[1,2,3,4]}"

ImmutableDynamicObj (soes not work)

ImmutableDynamicObj()
|> ImmutableDynamicObj.add "foo" "bar" 
|> JsonConvert.SerializeObject

val it : string = "{}"

Combining DOs/IDOs should merge collections on the same member name

Problems that arise from this are for example plotly/Plotly.NET#45

Unify DO/IDO APIs

Ideally, both APIs should provide the exact same functionality. While the mutable operations on DO have no equivalents, here are some things we should do IMO:

• Add pipeable versions for add/remove etc, and the new set (e.g. ++, +?) of operators to DO
• Remove the DynObj namespace (it is confusing), make all functions contained there static members of DynamicObj

[Bug] DynObj.print does not work for nested dyn objects with multiple fields.

Hello, i found AND fixed a bug in the DynObj.print function! I will open a PR soon.

To replicate the issue you can use a dynamic object, replicating the following json:

{
  "serilog": {
    "Level": "Information",
    "MessageTemplate": "{Method} Request at {Path}"
  }
}

OR

let o = DynamicObj()
let o2 = DynamicObj()
o2.SetValue("Level", "Information")
o2.SetValue("MessageTemplate","{Method} Request at {Path}")
o.SetValue("serilog", o2)

Using the current print function will lead to the following error:

System.MemberAccessException: Cannot access member.
   at FSI_0009.loop@55-1(DynamicObj d, DynamicObj object, Int32 identationLevel, FSharpList`1 membersLeft, FSharpList`1 acc)
   at FSI_0009.loop@55-1(DynamicObj d, DynamicObj object, Int32 identationLevel, FSharpList`1 membersLeft, FSharpList`1 acc)
   at FSI_0009.format(DynamicObj d)
   at FSI_0009.print(DynamicObj d)
   at <StartupCode$FSI_0010>.$FSI_0010.main@()
Stopped due to error

This error is produced by line 105. In which the source dynamic object is given into the loop, instead of the current "parent"-dynamic object object.

Will open a PR for this.

Strongly namd signing DynamicObj

Hello!
In an effort to use Plotly.NET we'll likely need to strong-name sign this dependency as well.

See this issue for more details:
plotly/Plotly.NET#175