let nodaTypes =

{|

Instant = synType "NodaTime.Instant"

LocalDate = synType "NodaTime.LocalDate"

LocalTime = synType "NodaTime.LocalTime"

LocalDateTime = synType "NodaTime.LocalDateTime"

OffsetDateTime = synType "NodaTime.OffsetDateTime"

ZonedDateTime = synType "NodaTime.ZonedDateTime"

Offset = synType "NodaTime.Offset"

Duration = synType "NodaTime.Duration"

Period = synType "NodaTime.Period"

DateTimeZone = synType "NodaTime.DateTimeZone"

|}

let giraffeAst (api: Api) =

let moduleName = Configuration.value.ModuleName |> Option.defaultValue api.Name

moduleName

type DateTimeGeneratedType =

| ZonedDateTime

| OffsetDateTime

| LocalDateTime

| Instant

type Configuration =

{

UseNodaTime: bool

MapDateTimeInto: DateTimeGeneratedType

ModuleName: string option

}

let mutable value =

{ UseNodaTime = false

MapDateTimeInto = OffsetDateTime

ModuleName = None }

<Compile Include="Configuration.fs" />

<PackageReference Include="NodaTime" Version="3.0.1" />

open NodaTime.Text

let inline oneWay kind (value: ^v) (toDefault: ^t -> ^o) =

let nodaMatch () =

let inline matchDateTime dt =

let inline oneWay f = oneWay (String DateTimeString) dt (f >> Some)

match Configuration.value.MapDateTimeInto with

| Configuration.DateTimeGeneratedType.ZonedDateTime -> oneWay (NodaTime.ZonedDateTime.FromDateTimeOffset >> ZonedDateTime)

| Configuration.DateTimeGeneratedType.OffsetDateTime -> oneWay (NodaTime.OffsetDateTime.FromDateTimeOffset >> OffsetDateTime)

| Configuration.DateTimeGeneratedType.LocalDateTime -> oneWay (fun dto -> NodaTime.LocalDateTime.FromDateTime dto.DateTime |> LocalDateTime)

| Configuration.DateTimeGeneratedType.Instant -> oneWay (fun dto -> NodaTime.OffsetDateTime.FromDateTimeOffset(dto).ToInstant() |> Instant)

match value with

| :? OpenApiDateTime as dt -> matchDateTime dt

| :? OpenApiDate as d -> oneWay (String DateString) d (NodaTime.LocalDate.FromDateTime >> LocalDate >> Some)

| :? OpenApiString as str ->

| String f ->

let inline extract (v: ParseResult<_>) = v.Value

let inline oneWay kind fn = oneWay (String f) str (fn >> kind >> Some)

let inline oneWayP kind (pattern: ^p) =

let inline parse v = (^p:(member Parse : string -> ParseResult<_>) pattern, v)

oneWay kind (parse >> extract)

// use the same format strings as NodaTime serialization libraries define

match f with

| Custom "local-date"

| DateString -> oneWayP LocalDate LocalDatePattern.Iso

| DateTimeString -> {| Value = DateTimeOffset.Parse str.Value |} |> matchDateTime

| Custom "instant" -> oneWayP Instant InstantPattern.ExtendedIso

| Custom "time"

| Custom "local-time" -> oneWayP LocalTime LocalTimePattern.GeneralIso

| Custom "local-date-time" -> oneWayP LocalDateTime LocalDateTimePattern.ExtendedIso

| Custom "offset-date-time" -> oneWayP OffsetDateTime OffsetDateTimePattern.Rfc3339

| Custom "offset"

| Custom "time-offset" -> oneWayP Offset OffsetPattern.GeneralInvariant

| Custom "duration" -> oneWayP Duration DurationPattern.JsonRoundtrip

| Custom "period" -> oneWayP Period PeriodPattern.Roundtrip

| Custom "time-zone"

| Custom "date-time-zone" ->

let provider = NodaTime.DateTimeZoneProviders.Tzdb

oneWay DateTimeZone (fun zone -> provider.[zone])

| _ -> None

| _ -> None

| _ -> None

let defaultMatch () =

match value with

| :? OpenApiInteger as int ->

match s with

| Int -> DefaultableKind.Integer int.Value

| Long -> DefaultableKind.Long (int64 int.Value)

| _ -> fw "integer"

| :? OpenApiLong as long ->

match s with

| Int -> DefaultableKind.Long (int64 long.Value)

| Long -> DefaultableKind.Long long.Value

| _ -> fw "int64"

| :? OpenApiDouble as double -> oneWay Double double DefaultableKind.Double

| :? OpenApiBoolean as bool -> oneWay Bool bool DefaultableKind.Boolean

| :? OpenApiDateTime as dateTime -> oneWay (String DateTimeString) dateTime DefaultableKind.DateTime

| :? OpenApiDate as date -> oneWay (String DateString) date DefaultableKind.Date

| :? OpenApiPassword as pwd -> oneWay (String PasswordString) pwd DefaultableKind.String

| :? OpenApiString as str ->

match s with

| String s ->

let inline oneWay x = oneWay (String s) x

match s with

| PasswordString

| StringFormat.String -> oneWay str DefaultableKind.String

| Custom "uri"

| Custom "uriref" -> oneWay {| Value = System.Uri str.Value |} DefaultableKind.Uri

| Custom "uuid"

| Custom "guid"

| Custom "uid" -> oneWay {| Value = Guid.Parse str.Value |} DefaultableKind.Guid

| _ -> oneWay str DefaultableKind.String

| _ -> fw "string"

| v -> failwith (sprintf "%A literals aren't supported for kind %A" v s)

Some Configuration.value

|> Option.filter (fun c -> c.UseNodaTime)

|> Option.bind (fun _ -> nodaMatch())

|> Option.map Noda

|> Option.defaultWith defaultMatch

and NodaTimeDefaultableKind =

| Instant of NodaTime.Instant

| LocalDate of NodaTime.LocalDate

| LocalTime of NodaTime.LocalTime

| LocalDateTime of NodaTime.LocalDateTime

| OffsetDateTime of NodaTime.OffsetDateTime

| ZonedDateTime of NodaTime.ZonedDateTime

| Offset of NodaTime.Offset

| Duration of NodaTime.Duration

| Period of NodaTime.Period

| DateTimeZone of NodaTime.DateTimeZone

| Noda of NodaTimeDefaultableKind

static member Parse (schema: OpenApiSchema): TypeKind * DefaultableKind option =

let def = schema.Default |> Option.ofObj |> Option.map (fun x -> x:?>IOpenApiPrimitive) |> Option.map (prim.GetDefaultLiteral)