Fabulous.AST.Json 2.0.0-pre08

Fabulous.AST.Json

Generate F# types from JSON samples using the Fabulous.AST DSL.

Overview

Fabulous.AST.Json is a programmatic F# type generator that:

• Takes a JSON sample as input
• Infers F# record types, nested types, and type aliases
• Outputs clean, Fantomas-formatted F# code

It is NOT:

• A runtime JSON deserializer (use System.Text.Json or Newtonsoft.Json for that)
• A Type Provider (types are generated as source code, not at compile-time)

Use cases:

• Generating F# types from API response samples
• Creating type-safe models from JSON schemas
• Test fixtures and documentation
• Custom code generation tooling

💡 Tip: For automatic build-time generation from JSON files, use instead.

Installation

dotnet add package Fabulous.AST.Json

Requirements: .NET 8.0 or later

Tutorial

Step 1: Basic Type Generation

The simplest use case is generating a record type from a JSON object:

open Fabulous.AST
open Fabulous.AST.Json
open type Ast

let json = """{ "name": "Alice", "age": 30, "active": true }"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json)
 }
 }
 |> Gen.mkOak
 |> Gen.run

printfn "%s" source

Output:

type Root = { name: string; age: int; active: bool }

Step 2: Custom Root Type Name

By default, the root type is named Root. Use .rootName() to customize it:

let json = """{ "id": 1, "email": "alice@example.com" }"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json).rootName("User")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

type User = { id: int; email: string }

Step 3: Nested Objects

Nested JSON objects become nested record types:

let json = """
{
 "user": {
 "name": "Alice",
 "address": {
 "city": "London",
 "country": "UK"
 }
 }
}
"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json).rootName("Response")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

type Address = { city: string; country: string }
type User = { name: string; address: Address }
type Response = { user: User }

Step 4: Arrays

Arrays generate an element type and a list alias:

let json = """
[
 { "id": 1, "name": "Item 1" },
 { "id": 2, "name": "Item 2" }
]
"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json).rootName("Products")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

type ProductsItem = { id: int; name: string }
type Products = ProductsItem list

Step 5: Optional Fields

When analyzing arrays of objects, fields that are missing or null in some objects become option types:

let json = """
[
 { "id": 1, "name": "Alice", "nickname": "Ali" },
 { "id": 2, "name": "Bob" }
]
"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json).rootName("Users")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

type UsersItem = { id: int; name: string; nickname: string option }
type Users = UsersItem list

Step 6: Relaxed JSON Parsing

Handle JSON with comments and trailing commas:

let json = """
{
 // This is a comment
 "id": 1,
 "name": "Test", // trailing comma
}
"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json)
 .documentAllowTrailingCommas(true)
 .documentCommentHandling(System.Text.Json.JsonCommentHandling.Skip)
 }
 }
 |> Gen.mkOak
 |> Gen.run

Step 7: Case-Insensitive Property Names

When JSON has inconsistent casing, use case-insensitive matching:

let json = """
[
 { "ID": 1, "Name": "First" },
 { "id": 2, "name": "Second" }
]
"""

let source =
 Oak() {
 AnonymousModule() {
 Json(json).nodePropertyNameCaseInsensitive(true)
 }
 }
 |> Gen.mkOak
 |> Gen.run

Step 8: Adding to a Namespace or Module

Wrap generated types in a namespace:

let json = """{ "id": 1, "name": "Alice" }"""

let source =
 Oak() {
 Namespace("MyApp.Models") {
 Json(json).rootName("User")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

namespace MyApp.Models

type User = { id: int; name: string }

Or in a module:

let source =
 Oak() {
 Module("MyApp.Models") {
 Json(json).rootName("User")
 }
 }
 |> Gen.mkOak
 |> Gen.run

Output:

module MyApp.Models

type User = { id: int; name: string }

Type Inference Rules

Special Field Name Handling

Leading Digits

JSON fields starting with digits are prefixed with _:

{ "2faEnabled": true, "3rdPartyId": "abc" }

Generates:

type Root = { _2faEnabled: bool; _3rdPartyId: string }

F# Reserved Keywords

JSON fields that are F# keywords are escaped with double backticks:

{ "type": "admin", "class": "premium" }

Generates:

type Root = { ``type``: string; ``class``: string }

API Reference

Available Modifiers

Related Packages

• Fabulous.AST - Core DSL for generating F# code
• Fabulous.AST.Build - MSBuild task for automatic build-time generation