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 Fabulous.AST.Build 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